C# Linq To Entity Framework left join

In questo frammento di codice di Linq To Entity Framework, con il linguaggio di programmazione C#, illustra una tecnica per effettuare una select per estrapolare i dati da due tabelle.

Supponiamo di avere due tabelle e rilevare i dati da entrambi le tabelle, anche nel caso che il campo di relazione non è presente in una tabella, ma si vuole rilevare ugualmente il dato della prima tabella .

Tramite il metodo DefaultIfEmpty prende il dato anche se nella seconda tabella non sono presenti dati.

Di seguito il frammento di codice che estrapola i dati della tabella Portieri, in relazione alla tabella Condomini, anche se in quest'ultima non sono presenti dati di relazione.

C#

  var elencoPortieri = (from portiere in entita.Portieri

                                      join condominio in entita.Condomini

                                          on portiere.IdCondominio equals condominio.Id into gruppoCondomini

                                      from condominio in gruppoCondomini.DefaultIfEmpty()

                                      select new

                                      {

                                          idPortiere = portiere.IdPortieri,

                                          portiere.Nome,

                                          portiere.Cognome,

                                          portiere.DataNascita,

                                          portiere.Email,

                                          portiere.Indirizzo,

                                          portiere.Telefono,

                                          portiere.LuogoNascita,

                                          NomeFile = portiere.File!= null ? "Scarica" : "",

                                          portiere.Note,

                                          portiere.DataAssunzione,

                                          portiere.DataDimissioni,

                                          portiere.Stipendio,

                                          Condominio = condominio != null ? condominio.Nome : "Nessuno",

                                      }).OrderBy(p => p.idPortiere).ToList();

 

 

 

                DtgListaPortieri.AutoGenerateColumns = false;

                DtgListaPortieri.DataSource = elencoPortieri;

C# Linq to Entity Framework inserire una riga (record) nella prima posizione in una select

Quando si utilizza Linq con Entity Framework nel linguaggio di programmazione C#, può capitare di voler aggiungere un nuovo record, riga, in una select.

Supponiamo che abbiamo una select di dati per riempire una combobox, e desideriamo inserire nella prima posizione, il valore "Nessuno", tramite il frammento di codice qui di seguito, viene illustrata una delle varie tecniche per aggiungere in prima posizione un valore in una select.

C#

  try

            {

              

                var elencoCondomini = (new[] { new { idCondominio = 0L, Descrizione = "Nessuno" } })

                                            .Concat(from dati in entita.Condomini.ToList()

                                       select new

                                       {

                                           idCondominio = dati.Id,

                                           Descrizione = dati.Nome

 

                                       }).ToList();

                CmbCondominio.DisplayMember = "Descrizione";

                CmbCondominio.ValueMember = "idCondominio";

                CmbCondominio.DataSource = elencoCondomini;

 

            }

            catch (Exception ex)

            {

                Utility.MessaggioErrore(ex.Message);

            }

 

Il valore 0L è un valore che indica 0 per il campo chiave ID

linq metodo ToLookup per creare un oggetto con chiave

 

Tramite il metodo "ToLookup" di una lista, possiamo ottenere un oggetto composto da chiave ed oggetto. Nel metodo ToLookup, possiamo indicare per quale colonna utilizzare come colonna, come rappresentata nella figura precedente.

Di seguito il frammento di codice di esempio.

C#

 List<Persona> persone = new List<Persona>();

 Persona persona = new Persona();

 persona.Cognome = "Mattei";

 persona.Nome = "Emanuele";

 persona.Eta = 1;

 persone.Add(persona);

 persona = new Persona();

 persona.Cognome = "Cristaldi";

 persona.Nome = "Luigi";

 persona.Eta = 2;

 persone.Add(persona);

 persona = new Persona();

 persona.Cognome = "Bianchi";

 persona.Nome = "Luca";

 persona.Eta = 3;

 persone.Add(persona);

var NuovoOggetto = persone.ToLookup(p => p.Nome);

Linq ordinamento con il secondo tipo di ordinamento con ThenBy

Nel caso che dobbiamo ordinare una lista per un secondo elemento, possiamo utilizzare il metodo ThenBy, di Ling, utilizzando il metodo OrderByDescending.

Di seguito un frammento di codice, con il quale effettua un ordinamento per nome e come secondo elemento di ordinamento il cognome a parità di iniziali uguali tra loro del primo elemento di ordinamento.

C#

  List<Persona> persone = new List<Persona>();

  Persona persona = new Persona();

  persona.Cognome = "Mattei";

  persona.Nome = "Emanuele";

  persona.Eta = 1;

  persone.Add(persona);

  persona = new Persona();

  persona.Cognome = "Cristaldi";

  persona.Nome = "Luigi";

  persona.Eta = 2;

  persone.Add(persona);

  persona = new Persona();

  persona.Cognome = "Bianchi";

  persona.Nome = "Luca";

  persona.Eta = 3;

  persone.Add(persona);

  var personeOrdinate = persone.OrderByDescending(x => x.Nome).ThenBy(c => c.Cognome);

C# linq OrderByDescending per ordinare in maniera discendente

Nel caso che dobbiamo ordinare in maniera discendente (dal più grande al più piccolo) una lista o un array, tramite il metodo OrderByDescending, possiamo ottenere tale ordinamento.

Di seguito un frammento di codice di utilizzo.

//Lista

  List<Persona> persone = new List<Persona>();

  Persona persona = new Persona();

  persona.Cognome = "Mattei";

  persona.Nome = "Emanuele";

  persona.Eta = 1;

  persone.Add(persona);

  persona = new Persona();

  persona.Cognome = "Cristaldi";

  persona.Nome = "Luigi";

  persona.Eta = 2;

  persone.Add(persona);

  persona = new Persona();

  persona.Cognome = "Bianchi";

  persona.Nome = "Luca";

  persona.Eta = 3;

  persone.Add(persona);

//Ordinamento

 var personeOrdinate = persone.OrderByDescending(x => x.Eta);

C# Windows Forms rilevare tutti i controlli che iniziano con un determinato nome

Supponiamo di avere in una forms di un progetto Windows Forms una serie di caselle di testo, tutte quante iniziano con "textbox" e vogliamo impostare del testo per ogni casella presente nella form.

Il frammento di codice nel linguaggio C#, tramite Linq, rileva tutte le caselle di testo "TextBox", che iniziano per un determinato nome ed imposta la proprietà "Text" con un valore.

C#

var controlli = this.Controls.Cast<Control>().Where(controllo => controllo.Name.StartsWith("textBox"));

            foreach (TextBox textBox in controlli)

            {

                textBox.Text = "Mio testo";

            }

C# linq metodo IntersectBy per ritornare gli oggetti di due insieme

Il metodo Intersect, estrapola quei dati che presi due liste, hanno i valori uguali, qui https://emanuelemattei.blogspot.com/2021/04/linq-utilizzo-del-metodo-intersect-per.html un esempio di utilizzo.

Con la versione .Net 6 e versione successive, è possibile utilizzare il metodo "IntersectBy" per estrapolare un oggetto presente in entrambi le liste.

Di seguito il frammento di codice di una lista per la classe persona, con il quale si estrapolano gli oggetti che sono uguali in entrambi le liste, utilizzando come condizione la proprietà "Eta".

List<Persona> persone = new List<Persona>();

Persona persona = new Persona();

persona.Cognome = "Mattei";

persona.Nome = "Emanuele";

persona.Eta = 1;

persone.Add(persona);

persona = new Persona();

persona.Cognome = "Cristaldi";

persona.Nome = "Luigi";

persona.Eta = 2;

persone.Add(persona);

persona = new Persona();

persona.Cognome = "Bianchi";

persona.Nome = "Luca";

persona.Eta = 3;

persone.Add(persona);

List<Persona> persone2 = new List<Persona>();

Persona persona2 = new Persona();

persona2.Cognome = "Mattei";

persona2.Nome = "Emanuele";

persona2.Eta = 1;

persone2.Add(persona2);

persona2 = new Persona();

persona2.Cognome = "Cristaldi";

persona2.Nome = "Luigi";

persona2.Eta = 4;

persone2.Add(persona2);

           

var risultato = persone.IntersectBy(persone2.Select(p=>p.Eta), p=>p.Eta); //Restituisce Emanuele Mattei

C# utilizzo del metodo ExceptBy

Altra novità interessante della versione .Net 6 e versioni successive, è quella del metodo ExceptBy, con il quale esaminando due liste, restituisce gli oggetti che non sono presenti nella seconda lista in riferimento ad una condizione.

Nell'esempio seguente, si esaminano due liste di oggetti di tipo persone, utilizzando la proprietà "Eta" come condizione.

  List<Persona> persone = new List<Persona>();

  Persona persona = new Persona();

  persona.Cognome = "Mattei";

  persona.Nome = "Emanuele";

  persona.Eta = 1;

  persone.Add(persona);

  persona = new Persona();

  persona.Cognome = "Cristaldi";

  persona.Nome = "Luigi";

  persona.Eta = 2;

  persone.Add(persona);

  persona = new Persona();

  persona.Cognome = "Bianchi";

  persona.Nome = "Luca";

  persona.Eta = 3;

  persone.Add(persona);

  List<Persona> persone2 = new List<Persona>();

  Persona persona2 = new Persona();

  persona2.Cognome = "Mattei";

  persona2.Nome = "Emanuele";

  persona2.Eta = 1;

  persone2.Add(persona2);

  persona2 = new Persona();

  persona2.Cognome = "Cristaldi";

  persona2.Nome = "Luigi";

  persona2.Eta = 4;

  persone2.Add(persona2);

 

  var risultato = persone.ExceptBy(persone2.Select(p=>p.Eta), p=>p.Eta); //Restituisce l'oggetto Cristaldi e Bianchi Luca

            

Mentre nel caso di utilizzo di liste semplice (esempio array di string) è consigliabile usare il metodo Except .

C# utilizzo del metodo DistinctBy .Net 6

Altra novità della versione .Net 6 è quella della funzione DistinctBy che restituisce il primo elemento di un insieme in base alla condizione impostata.

Supponiamo di avere una classe persona e di questa tramite il metodo DistinctBy restituisce il primo che corrisponde alla condizione tramite età.

Di seguito il frammento di codice del relativo utilizzo DistinctBy e Distinct.

            List<Persona> persone = new List<Persona>();

            Persona persona = new Persona();

            persona.Cognome = "Mattei";

            persona.Nome = "Emanuele";

            persona.Eta = 1;

            persone.Add(persona);

            persona = new Persona();

            persona.Cognome = "Cristaldi";

            persona.Nome = "Luigi";

            persona.Eta = 1;

            persone.Add(persona);

            persona = new Persona();

            persona.Cognome = "Bianchi";

            persona.Nome = "Luca";

            persona.Eta = 3;

            persone.Add(persona);

            var risultato = persone.DistinctBy(x => x.Eta); //Restituisce l'oggetto Mattei Emanuele e Bianchi Luca

            var risultato2 = persone.Distinct(); //Restituisce tutti gli oggetti 

C# lambda numero elevato al quadrato

Il frammento di codice di seguito, illustra una tecnica di utilizzo lambda con il linguaggio C# per elevare una serie di numeri al quadrato, ossia moltiplicare il numero per se stesso.

 private void BtnLambdaMoltiplicazione_Click(object sender, EventArgs e)

 {

     int[] numeri = { 4, 5, 7, 9 };

     var numeriAlQuadrato = numeri.Select(x => x * x);

     foreach (var elemento in numeriAlQuadrato)

     {

         MessageBox.Show(elemento.ToString()); //16, 25, 49, 81

     }      

 }

C# valore di default in linq

Con l'ultima versione di C# e Framework .Net, è possibile eseguire un valore di default in operazioni di lambda di Linq.

Di seguito un esempio di somma, con un parametro che ha un valore di default.

 var EsempioValoreDefault = (int primoValore, int SecondoValore = 2) => primoValore + SecondoValore;

 var risultatoSomma = EsempioValoreDefault(4, 4); //restituisce 8

 var risultatoSommaSoloUnParametro = EsempioValoreDefault(3); //restituisce 5

Processing of the LINQ expression 'DbSet by 'NavigationExpandingExpressionVisitor' failed. This may indicate either a bug or a limitation in EF Core. See https://go.microsoft.com/fwlink/?linkid=2101433 for more detailed information.

Durante l'esecuzione del codice, può capire che una query linq to Entity Framework Core, generi un eccezione del tipo 

"Processing of the LINQ expression 'DbSet< ..... ' by 'NavigationExpandingExpressionVisitor' failed. This may indicate either a bug or a limitation in EF Core. See https://go.microsoft.com/fwlink/?linkid=2101433 for more detailed information." dove viene riporta la query con l'errore.

Questo può verificarsi per una serie di sotto query.

Una delle possibili soluzioni è quello di utilizzare come risultato un generico e non un Iqueryable e precedere prima della condizione Where, il Tolist.

Di seguito si riporta un esempio di prima, con l'errore e dopo senza errore.

Per esempio da così

IQueryable<NomeClasse> listaRecord= from u in DbContenx.TabellaOrVista.Where......(con subquery e condizioni)

Diventa così

 var risultato = from u in DbContenx.TabellaOrVista.ToList().Where(con subquery e condizioni)

could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to either AsEnumerable(), AsAsyncEnumerable(), ToList(), or ToListAsync(). See https://go.microsoft.com/fwlink/?linkid=2101038 for more information

 

Durante le esecuzioni di query tramite Linq, può capitare che venga sollevata l'eccezione, del tipo "could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to either AsEnumerable(), AsAsyncEnumerable(), ToList(), or ToListAsync(). See https://go.microsoft.com/fwlink/?linkid=2101038 for more information"

Per evitare che si verifica questa eccezione, occorre utilizzare il metodo "ToList" o "AsEnumerable" prima di un raggruppamento oppure dopo se è presente ulteriore select, nel caso che ci troviamo in select e groupBy annidate.

L'utilizzo di "ToList" eviterà questa eccezione.

C# linq distinct

Di seguito si riporta un frammento di codice, che raggruppa i dati in base ad un campo e tramite il metodo "FirstOfDefault" estrapola il dato univoco, che nel linguaggio SQL può considerarsi la "Distinct".

Di seguito il frammento di codice per ottenere dati univoci.

 var allegati = FonteDati

                .Where(g => !string.IsNullOrEmpty(g.NomeCampo))

                .GroupBy(g => g.Campo)

                .Select(g => g.FirstOrDefault())

                .Select(g=> new Classe

                { 

                    CampoDellaClasse = g.Campo

                })

                .ToList();

C# linq group by

Nel caso che si ha la necessità di raggruppare dati, in maniera univoca evitando i doppioni, dopo il metodo Group, nella condizione utilizzare la funzione FirstOfDefault, in modo da permettere di ottenere il dato univoco.

Di seguito il frammento di codice di un possibile utilizzo di Group che non fa altro che raggruppare i dati e poi ottenere la distinct per il dato.

 var allegati = FonteDati

                .Where(g => !string.IsNullOrEmpty(g.NomeCampo))

                .GroupBy(g => g.Campo)

                .Select(g => g.FirstOrDefault())

                .Select(g=> new Classe

                { 

                    CampoDellaClasse = g.Campo

                })

                .ToList();

C# invertire il testo di una frase in Linq

Il frammento di codice qui di seguito, illustra una tecnica in Linq e linguaggio di programmazione C#, per invertire il testo di una frase tramite il metodo reverse.

Di seguito il frammento di codice.

 string testo = "Buongiorno a tutti";

 string risultato = string.Join(" ", testo.Reverse().ToArray());  

C# LINQ to get items in one List<>, that are not in another List<>

Supponiamo di avere due liste di oggetti che hanno una serie di proprietà, questi oggetti contengono n dati e vogliamo verificare che i dati presenti in uno non ci sono nell'altro. Per esempio gli oggetti mappano due tabelle con le stesse colonne ma che si vuole vedere la differenza tra il primo ed il secondo.

La classe che utilizzeremo come oggetto e lista è la seguente:

  public class Anagrafica

    {

        public string Nome { get; set; }

        public string Cognome { get; set; }

    }

Di seguito l'inizializzazione della classe con una ipotetica fonte dati:

 List<Anagrafica> AnagraficaOrigine = CaricaDati();

 List<Anagrafica> AnagraficaDestinazione = CaricaDati();

Ora che i due oggetti contengono i dati per le due proprietà (nome e cognome) dobbiamo effettuare una select per vedere quali dati mancano nel secondo oggetto utilizzando le proprietà come condizione di scrematura dati.

 var risultato = AnagraficaOrigine .Where(a => !AnagraficaDestinazione .Any(b => a.Nome  == b.Nome && a.Cognome== b.Cognome));

L'oggetto "risultato" avrà i valori che non sono presenti nell'oggetto "AnagraficaDestinazione.

               

C# Linq Aggiungere un nuovo elemento ad una lista di tipi anonimi

Il frammento di codice qui di seguito, illustra una tecnica di come aggiungere un nuovo elemento ad una lista di tipi generici.

Var Risultato = (from Dati in Elementi where Dati.Campo == Valore 

                            select new 

                            {

                                   EtichettaA = Dati.Campo1,

                                   EtichettaB = Dati.Campo2,

                            }).ToList();

var Elemento = new {EtichettaA="Valore", EtichettaB="Valore2",};

Risultato.Insert(0, Elemento);

Linq metodo LongCount

Il metodo LongCount restituire un valore int64, che visualizza il totale degli elementi su cui si sta eseguendo la selezione.

Ne frammento di codice qui di seguito, si è creata una classe con due proprietà, una di tipo string, che sta per rappresentare la descrizione, ed uno di tipo int che indica il codice dell'ordine.

Nella query Linq, si prendono tutti gli elementi che hanno ID ordine maggiore di 2 e si vuole sapere quanti elementi sono.

//Classe:

  public class Ordini

    {

      public  int IdOrdine { get; set; }

       public string Descrizione { get; set; }

    }

Query:

 Ordini[] ordiniLista = { new Ordini { Descrizione  ="Pasta", IdOrdine=8 },

                   new Ordini { Descrizione="Boots", IdOrdine=4 },

                   new Ordini { Descrizione="Whiskers", IdOrdine=1 } };

            long Totale = ordiniLista.LongCount(ordini => ordini.IdOrdine  > 2);

            Console.WriteLine("Elementi trovati con id superiore a 2;" + Totale);

Linq utilizzo di Union per rilevare in due array string valori univoci

 Il frammento di codice qui di seguito, illustra una tecnica con il quale prendendo due array di string, visualizza tutti quei elementi rendendo univoci i valori .

 string[] TutteCitta = { "Berlino", "Parigi", "Roma", "Palermo", "Mantova", "Madrid" };

            string[] CittaItaliane = { "Roma", "Mantova", "Palermo" };

            var UnioneCitta = TutteCitta.Union(CittaItaliane); //se sono uguali non li visualizza due volte

            foreach (string citta in UnioneCitta)

                MessageBox.Show(citta);

In questo caso, nonostante sono presenti in tutte e due gli array il valore "Roma" "Mantova" e "Palermo" verrà visualizzato una sola volta.