Utilizzare .DefaultIfEmpty() anziché .FirstOrDefault() ?? String.Empty;

Question

Come posso integrare il metodo di .DefaultIfEmpty() estensione in modo non ho non utilizzare

.FirstOrDefault() ?? String.Empty; 

Codice:

(from role in roleList 
let roleArray = role.RoleId.Split(new char[] { WorkflowConstants.WorkflowRoleDelimiter }) 
where roleArray.Length.Equals(_SplittedRoleIdArrayLength) && 
     HasAccessToCurrentUnit(roleArray[_UnitIndexInRoleId]) 
select roleArray[_LevelIndexInRoleId]).FirstOrDefault() ?? String.Empty; 

Answer 1

si potrebbe usare:

var query = ...; 

return query.DefaultIfEmpty(string.Empty).First(); 

Ma questo non lo fa ridurre la complessità IMO.

Answer 2

Se siete interessati a metodo di estensione, allora si potrebbe usare qualcosa di simile:

public static class Helpers 
{ 
    public static string FirstOrEmpty(this IEnumerable<string> source) 
    { 
     return source.FirstOrDefault() ?? string.Empty; 
    } 
} 

Modifica

Questo metodo non è generico perché poi avremmo dovuto usare default(T) e ci darà null anziché string.Empty.

Answer 3

Il codice:

var query=(
    from role in roleList 
    let delimiter=WorkflowConstants.WorkflowRoleDelimiter 
    let roleArray=role.RoleId.Split(new char[] { delimiter }) 
    where roleArray.Length.Equals(_SplittedRoleIdArrayLength) 
    where HasAccessToCurrentUnit(roleArray[_UnitIndexInRoleId]) 
    select roleArray[_LevelIndexInRoleId] 
    ).DefaultIfEmpty("").FirstOrDefault(); 

Per il sospetto circa il significato semantico di DefaultIfEmpty e FirstOrDefault, segue è il codice decompilato dalla libreria:

• Codice

  public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source) 
  { 
      return source.DefaultIfEmpty<TSource>(default(TSource)); 
  } 
  
  public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue) 
  { 
      if (source == null) 
      { 
       throw Error.ArgumentNull("source"); 
      } 
      return DefaultIfEmptyIterator<TSource>(source, defaultValue); 
  } 
  
  public static TSource First<TSource>(this IEnumerable<TSource> source) 
  { 
      if (source == null) 
      { 
       throw Error.ArgumentNull("source"); 
      } 
      IList<TSource> list = source as IList<TSource>; 
      if (list != null) 
      { 
       if (list.Count > 0) 
       { 
        return list[0]; 
       } 
      } 
      else 
      { 
       using (IEnumerator<TSource> enumerator = source.GetEnumerator()) 
       { 
        if (enumerator.MoveNext()) 
        { 
         return enumerator.Current; 
        } 
       } 
      } 
      throw Error.NoElements(); 
  } 
  
  public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source) 
  { 
      if (source == null) 
      { 
       throw Error.ArgumentNull("source"); 
      } 
      IList<TSource> list = source as IList<TSource>; 
      if (list != null) 
      { 
       if (list.Count > 0) 
       { 
        return list[0]; 
       } 
      } 
      else 
      { 
       using (IEnumerator<TSource> enumerator = source.GetEnumerator()) 
       { 
        if (enumerator.MoveNext()) 
        { 
         return enumerator.Current; 
        } 
       } 
      } 
      return default(TSource); 
  } 
  

E qui sono qualcosa di parlare:

1. DefaultIfEmpty ha un sovraccarico senza parametri, che invoca il sovraccarico parametrizzata con default(TSource) e restituisce il suo risultato.

2. L'unica differenza tra FirstOrDefault senza parametri e First, è il secondo che genera quando la raccolta è vuota.

   Per ulteriori informazioni, vedere Enumerable.FirstOrDefault<TSource> Method su MSDN.

3. FirstOrDefault semanticamente espresso first or default e così chiamato; non è denominato first or null. In C#, default(T) per un tipo di riferimento è null, ma per il tipo non di riferimento, non lo è. Ad esempio, default(int) è zero.

   La parola chiave default non è mai stata dichiarata null semantica. È DEFAULT.

   Inoltre, per ulteriori informazioni, default Keyword su MSDN.

Answer 4

ho trovato questo corso di Pluralsight interessante e mi ricordavo quando ho visto questa domanda.

È possibile visualizzare l'intero corso, ma le strategie Riduzione mappa e Option<T>, in particolare con DefaultIfEmpty, sembrano essere idonee per il proprio caso d'uso.

schemi tattici Design a .NET: Flow Control da Zoran Horvat https://app.pluralsight.com/library/courses/tactical-design-patterns-dot-net-control-flow/table-of-contents