Come ottenere un elenco distinto senza distinzione tra maiuscole e minuscole utilizzando Linq ed Entity Framework

Question

È necessario ottenere un elenco senza distinzione tra maiuscole e minuscole dai risultati di una query di framework di entità. Ho il seguente:

var myList = myEF.GroupBy(e => new { e.Code, e.Description }) 
      .Select(e => e.First()) 
      .ToList(); 

Questo mi dà un elenco distinto, ma è case-sensitive. Ho bisogno di insensibilità al maiuscolo/minuscolo.

ho pensato che dovrei essere in grado di fare qualcosa del genere:

var myList = myEF.GroupBy(e => new { e.Code, e.Description }, StringComparer.InvariantCultureIgnoreCase) 
      .Select(e => e.First()) 
      .ToList(); 

Ma questo non sembra voler lavorare con l'oggetto anonimo.

L'aggiunta di .ToLower o .ToLowerInvariant non sembra funzionare. Né utilizza Distinct(StringComparer.InvariantCultureIgnoreCase) anziché GroupBy.

Sembra che ci dovrebbe essere un modo semplice per farlo, ma non lo trovo.

Answer 1

Ho provato vari metodi che hai detto e tutti hanno fallito. Tuttavia, ho funzionato:

var distinct = list.Distinct(new CaseInsensitiveComparer()); 

public class CaseInsensitiveComparer : IEqualityComparer<A> 
{ 
    public bool Equals(A x, A y) 
    { 
     return x.Code.Equals(y.Code, StringComparison.OrdinalIgnoreCase) && 
       x.Description.Equals(y.Description, StringComparison.OrdinalIgnoreCase); 
    } 

    public int GetHashCode(A obj) 
    { 
     return obj.Code.ToLowerInvariant().GetHashCode(); 
    } 
} 

Sentiti libero di modificare le tue esigenze.

Fiddle

Answer 2

Probabilmente occorreranno 2 passaggi per questa query.

Prima richiesta per la conversione in lettere minuscole, la seconda per il raggruppamento.

Solo gli escape potrebbero essere estratti in maiuscolo immediatamente da Entity Framework.

o con l'aggiunta di funzioni/EF LINQ che sono ancora in fase di sviluppo :(

Answer 3

sudicia, ma funziona:

private class StructuralTupleComparer<T>: IEqualityComparer<Tuple<T, T>>{ 

    private IEqualityComparer<T> _cmp; 

    public StructuralTupleComparer(IEqualityComparer<T> cmp){ 
     this._cmp = cmp 
    } 

    public bool Equals(Tuple<T, T> t1, Tuple<T, T> t2) 
    { 
     return _cmp(t1.Item1, t2.Item1) && _cmp(t1.Item2, t2.Item2); 
    } 


    public int GetHashCode(Tuple<T, T> t) 
    { 
     return _cmp.GetHashCode(t.Item1)^_cmp.GetHashCode(t.Item2) 
    } 
} 

e poi

var myList = myEF.GroupBy(e => new Tuple<String, String>(e.Code, e.Description), 
           new StructuralTupleComparer(StringComparer.InvariantCultureIgnoreCase)) 
      .Select(e => e.First()) 
      .ToList(); 

e sperare che a un certo punto nel glorioso futuro ci sarà un metodo di estensione static IGrouping GroupBy<T, U>(this IEnumerable<T> src, Func<T, U> groupingprojection, Func<U, bool> equalitytester) (per Great Justice)