Creare una tupla in una selezione Linq

Sto lavorando con C # e .NET Framework 4.5.1 recuperando dati da un database SQL Server con Entity Framework 6.1.3.

Ho questo:

codes = codesRepo.SearchFor(predicate)
      .Select(c => new Tuple<string, byte>(c.Id, c.Flag))
      .ToList();

E quando lo eseguo, ricevo questo messaggio:

Solo i costruttori e gli inizializzatori senza parametri sono supportati in LINQ to Entities.

Non so come devo creare la tupla perché tutti gli esempi che ho trovato sono per lo più come questo.

Ho provato questo:

codes = codesRepo.SearchFor(predicate)
      .Select(c => Tuple.Create(c.Id, c.Flag))
      .ToList();

E ottieni questo errore:

LINQ to Entities non riconosce il metodo 'System.Tuple`2 [System.String, System.Byte] Create [String, Byte] (System.String, Byte)' e questo metodo non può essere tradotto in un'espressione di archivio.

Dov'è il problema?

Sebbene la risposta di octavioccl funzioni , è meglio proiettare prima il risultato della query in tipo anonimo, quindi passare a enumerabile e convertirlo in tupla. In questo modo la tua query recupererà dal database solo i campi necessari.

codes = codesRepo.SearchFor(predicate)
    .Select(c => new { c.Id, c.Flag })
    .AsEnumerable()
    .Select(c => new Tuple<string, byte>(c.Id, c.Flag))
    .ToList();

Nota: la regola precedente si applica a EF6. EF Core supporta naturalmente le tuple (in proiezione o come chiavi di join / gruppo) tramite il costruttore di tuple, ad esempio la query originale funziona semplicemente

codes = codesRepo.SearchFor(predicate)
  .Select(c => new Tuple<string, byte>(c.Id, c.Flag))
  .ToList();

ma non il Tuple.Createmetodo (EF Core 2.x).

Solo una risposta aggiornata per C # 7, ora puoi usare una sintassi più semplice per creare ValueTuples.

codes = codesRepo.SearchFor(predicate)
.Select(c => new { c.Id, c.Flag })
.AsEnumerable()
.Select(c => (c.Id, c.Flag))
.ToList();

Puoi anche nominare le proprietà della tupla ora:

codes = codesRepo.SearchFor(predicate)
.Select(c => new { c.Id, c.Flag }) // anonymous type
.AsEnumerable()
.Select(c => (Id: c.Id, Flag: c.Flag)) // ValueTuple
.ToList();

Quindi, invece di usarlo come Item1 o Item2, puoi accedervi come Id o Flag.

Altri documenti sulla scelta tra anonimo e tupla

Prova questo:

codes = codesRepo.SearchFor(predicate)
  .Select(c => Tuple.Create(c.Id, c.Flag))
  .ToList();

È stato informato che questo non è accettato in LINQ to entity.

Un'altra opzione sarebbe quella di inserire il risultato in memoria prima di selezionarlo. Se hai intenzione di farlo, ti consiglio di fare tutto il filtraggio prima di .AsEnumerable () in quanto significa che stai solo ritirando i risultati desiderati invece di tirare indietro l'intera tabella e quindi filtrare.

codes = codesRepo.SearchFor(predicate).AsEnumerable()
  .Select(c => Tuple.Create(c.Id, c.Flag))
  .ToList();

anche Tuple.Create (c.Id, c.Flag) potrebbe essere cambiato in new Tuple (c.Id, c.Flag) se vuoi rendere il codice un po 'più esplicito nei tipi di tuple

In linq to entity puoi proiettare su un tipo anonimo o su un DTO.Per evitare questo problema puoi usare il AsEnumerablemetodo di estensione:

codes = codesRepo.SearchFor(predicate).AsEnumerable().
      .Select(c => new Tuple<string, byte>(c.Id, c.Flag))
      .ToList();

Questo metodo ti consente di lavorare con Linq to Object invece di Linq to Entities , quindi dopo averlo chiamato, puoi proiettare il risultato della tua query in qualsiasi cosa tu abbia bisogno.Il vantaggio di usare AsEnumerableinvece ToListè che AsEnumerablenon esegue la query, preserva l'esecuzione differita. È una buona idea filtrare sempre i dati prima di chiamare uno di questi metodi.

Ho trovato la risposta:

codes = codesRepo.SearchFor(predicate)
      .ToList()
      .Select(c => Tuple.Create(c.Id, c.Flag))
      .ToList();

Usa questo metodo per farlo e usa il metodo async.

var codes = await codesRepo.SearchFor(predicate)
                    .Select(s => new
                    {
                        Id = s.Id,
                        Flag = s.Flag
                    }).FirstOrDefaultAsync();

                var return_Value = new Tuple<string, byte>(codes.Id, codes.Flag);

Solo i miei due centesimi: questo mi ha colto un paio di volte con i nomi dei tipi:

Alcuni esempi assurdi:

    private Tuple<string, byte> v1()
    {
        return new Tuple<string, byte>("", 1);
    }

    private (string, int) v2()
    {
        return ("", 1);
    }

    private (string Id, byte Flag) v3()
    {
        return ("", 1);
    }

Saluti.