Home
MICROSOFT VISUAL STUDIO: Entity Framework

Vediamo in questo articolo qualche cenno a Entity Framework ed al suo uso in ambito C# e Microsoft Visual Studio.

Vedremo come si fa una Join, una left join, come si può fare l'Update di un Record o la sua cancellazione.

 

 

 

Entity Framwork

Entity Framework (EF) è un set di tecnologie che supportano lo sviluppo di applicazioni software orientate ai dati (quindi per intenderci la parte di collegamento verso il database). 
Con EF si ha vita più semplice nella modellizzazione delle entità e delle relazioni tra le entità e nel recupero dei dati.

Entity Framework consente di utilizzare i dati sotto forma di proprietà e oggetti operando così a un livello superiore di astrazione quando si gestiscono i dati e permette di creare e gestire applicazioni orientate ai dati con meno codice rispetto alle applicazioni tradizionali. Poiché Entity Framework è un componente del .NET Framework è necessario avere installata almeno la versione 3.5 SP1.

 

Detto questo passiamo ad un primo esempio.

 

Fare una Join

                
                using (MyEntities context = new MyEntities ())
                {
                    //query construction
                    IQueryable<MyEntity> dbObj = context.MyEntity;
                                        
                        dbObj = from pkg in context.MyEntity
                                     join pkg2 in context.MyEntity2 on pkg.ID equals pkg2.ID
                                     where pkg2.Desc.Contains("my text")
                                     select pkg;
                 }

 

In questo caso stiamo facendo la join tra la tabella MyEntity e la tabella MyEntity2 basata sul campo ID e cercando i record che nella descrizione hanno la parola "my text".

 

Fare una Left Join

Vediamo un semplice esempio su come realizzare una left join usando Entity Framework (testato con la versione 6.2.0):

 

var myRecords = from wu in context.MyTable
      join wui in context.MyTable2 on wu.ID equals wui.ID into www
      from x in www.DefaultIfEmpty()
      where x.Date == null
      select wu;

 

La Left Join viene fatta tra la tabella MyTable e la tabella MyTable2 ed è basata sul campo ID.

La differenza tra una Join normale ed una Left Join la fa l'istruzione from x in www.DefaultIfEmpty() che rende nulli i campi della MyTable2 nel caso non ci sia la corrispondenza.

 

Fare una Delete

Per fare la delete di un dato record si può usare il seguente codice:

 

            try
            {
                using (MyEntities context = new MyEntities())
                {
                    var dbMyTable = from w in context.MyTable
                                         where w.ID == 213
                                         select w;

                    if (dbMyTable.Count() > 0)
                    {
                        MyTable myRecord = dbMyTable.ToList<MyTable>()[0];
                        context.MyTable.Remove(myRecord);
                        context.SaveChanges();
                    }
                }
            }
            catch (Exception ex)
            {                
                throw new ApplicationException(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + MethodBase.GetCurrentMethod().Name +
                    " - Error", ex);
            }

 

Fare un Update

Per fare la delete di un dato record si può usare il seguente codice:

 

            try
            {
                using (MyEntities context = new MyEntities())
                {
                    var dbMyTable = from w in context.MyTable
                                         where w.ID == 213
                                         select w;

                    if (dbMyTable.Count() > 0)
                    {
                        MyTable myRecord = dbMyTable.ToList<MyTable>()[0];

                        myRecord.MyField = myUpdate;                        
                        context.SaveChanges();
                    }
                }
            }
            catch (Exception ex)
            {                
                throw new ApplicationException(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + MethodBase.GetCurrentMethod().Name +
                    " - Error", ex);
            }

 

Fare una Ricerca

                
               

logger.EnterMethod(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + MethodBase.GetCurrentMethod().Name);
try
{
    configurations = new List<ConfigurationDTO>();
    using (MyEntities context = new MyEntities())
    {
        //query construction: get all records from MyTable
        IQueryable<MyTable> dbRecords = context.MyTable;

        //Filter records
        dbRecords = dbRecords.Where(en => en.MyField.equals(myFilter));

        if (!string.IsNullOrEmpty(myFilter2))
        {
            dbRecords = dbRecords.Where(en => en.MyField2.equals(myFilter2));
        }        
    }
    return;
}
catch (Exception ex)
{
    logger.LogException(ex);
    throw new Exception(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + MethodBase.GetCurrentMethod().Name +
        " - Error", ex);
}

 

In questa query i record vengono filtrati per il campo MyFilter e poi filtrati per l'eventuale myFilter2 se presente.

Il vantaggio di questo approccio è che è possibile gestire campi opzionali.

Ovvero se il campo myFilter2 è nullo non si deve filtrare affatto per esso.

Lo svantaggio invece è che la query viene raffinata a step successivi.

Quindi la prima istruzione estrae tutti i record e le successive filtrano sulla base di questi.

Quindi non andrebbe usata se la tabella ha tantissimi record.

 

Buon Lavoro!

Il nostro sito utilizza i cookie

Usando il sito accetti implicitamente il loro uso. Per saperne di piu'

Approvo

Per ulteriori informazioni leggi il seguente articolo Privacy e Cookies