C# se-null-poi-null espressione

Question

Solo per curiosità/convenienza: C# fornisce due funzioni espressione condizionale interessanti che conosco:

string trimmed = (input == null) ? null : input.Trim(); 

e

string trimmed = (input ?? "").Trim(); 

mi manca un altro tale espressione per una situazione che affronto molto spesso:

Se il riferimento di input è nullo, l'output deve essere nullo. In caso contrario, l'output dovrebbe essere il risultato dell'accesso a un metodo o una proprietà dell'oggetto di input.

Ho fatto esattamente questo nel mio primo esempio, ma (input == null) ? null : input.Trim() è piuttosto prolisso e illeggibile.

Esiste un'altra espressione condizionale per questo caso oppure è possibile utilizzare l'operatore ?? in modo elegante?

Answer 1

Qualcosa come l'operatore di dereferenziazione Null-Safe di Groovy?

string zipCode = customer?.Address?.ZipCode; 

ho capito che la squadra # C ha guardato a questo e ha scoperto che non è così semplice per la progettazione elegante come ci si potrebbe aspettare ... anche se non ho sentito parlare i dettagli dei problemi.

Non credo che al momento ci sia qualcosa di simile nella lingua, temo ... e non ho sentito nessun piano per questo, anche se questo non vuol dire che non succederà a qualche punto.

EDIT: Ora farà parte del C# 6, come "operatore condizionale nullo".

Answer 2

Attualmente possiamo scrivere solo un metodo di estensione se non vuoi ripetere te stesso, temo.

public static string NullableTrim(this string s) 
{ 
    return s == null ? null : s.Trim(); 
} 

Answer 3

Non c'è niente di built-in, ma si potrebbe avvolgere il tutto in un metodo di estensione, se si voleva (anche se probabilmente non mi preoccuperei).

Per questo esempio specifico:

string trimmed = input.NullSafeTrim(); 

// ... 

public static class StringExtensions 
{ 
    public static string NullSafeTrim(this string source) 
    { 
     if (source == null) 
      return source; // or return an empty string if you prefer 

     return source.Trim(); 
    } 
} 

o una versione più general-purpose:

string trimmed = input.IfNotNull(s => s.Trim()); 

// ... 

public static class YourExtensions 
{ 
    public static TResult IfNotNull<TSource, TResult>(
     this TSource source, Func<TSource, TResult> func) 
    { 
     if (func == null) 
      throw new ArgumentNullException("func"); 

     if (source == null) 
      return source; 

     return func(source); 
    } 
} 

Answer 4

Ho avuto lo stesso problema che ho scritto qualche piccolo metodi di estensione:

public static TResult WhenNotNull<T, TResult>(
    this T subject, 
    Func<T, TResult> expression) 
    where T : class 
{ 
    if (subject == null) return default(TResult); 
    return expression(subject); 
} 

public static TResult WhenNotNull<T, TResult>(
    this T subject, Func<T, TResult> expression, 
    TResult defaultValue) 
    where T : class 
{ 
    if (subject == null) return defaultValue; 
    return expression(subject); 
} 

public static void WhenNotNull<T>(this T subject, Action<T> expression) 
    where T : class 
{ 
    if (subject != null) 
    { 
     expression(subject); 
    } 
} 

Lo usi così;

string str = null; 
return str.WhenNotNull(x => x.Length); 

o

IEnumerable<object> list; 
return list.FirstOrDefault().WhenNotNull(x => x.id, -1); 

o

object obj; 
IOptionalStuff optional = obj as IOptionalStuff; 
optional.WhenNotNull(x => x.Do()); 

ci sono sovraccarichi anche per i tipi nullable.

Answer 5

Come soluzione temporanea è possibile utilizzare ciò che è basato su Maybe monad.

public static Tout IfNotNull<Tin, Tout>(this Tin instance, Func<Tin, Tout> Output) 
{ 
    if (instance == null) 
     return default(Tout); 
    else 
     return Output(instance); 
} 

usarlo in questo modo:

int result = objectInstance.IfNotNull(r => 5); 
var result = objectInstance.IfNotNull(r => r.DoSomething()); 

Answer 6

è possibile scegliere tra una classe personalizzata Nullify o di un metodo NullSafe estensione come descritto qui: http://qualityofdata.com/2011/01/27/nullsafe-dereference-operator-in-c/

L'utilizzo sarà il seguente:

//Groovy: 
bossName = Employee?.Supervisor?.Manager?.Boss?.Name 

//C# Option 1: 
bossName = Nullify.Get(Employee, e => e.Supervisor, s => s.Manager, 
         m => m.Boss, b => b.Name); 
//C# Option 2: 
bossName = Employee.NullSafe(e => e.Supervisor).NullSafe(s => s.Boss) 
         .NullSafe(b => b.Name);