Ciao a tutti,

sono un programmatore (vecchia scuola) e mi sto addentrando nella programmazione ad oggetti. Sto leggendo molti testi e forum compreso il vostro che ritengo tra i più validi. Non so se è cosa comune ma quando si leggono gli esempi dei libri sembra tutto chiaro, mentre andando a realizzare delle applicazioni reali la poca chiarezza iniziale diventa "poche idee ben sparse e confuse". Mi piacerebbe avere i vostri suggerimenti su come implementare correttamente l'esempio riportato:

public class Company
{
public Company()
{
Name = null;
Email = null;
}

public long Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
}

public class Unit
{
public long Id { get; set; }
public long CompanyId { get; set; }
public string Address { get; set; }
}

In un altro file:

public class db
{

public static List<Unit> GetUnitByCompanyID(long id)
{
SqlCommand myCommand = new SqlCommand("SELECT * FROM Unit WHERE companyid = @CID");
SqlParameter myParam = new SqlParameter("@CID", SqlDbType.BigInt);
myParam.Value = id;
myCommand.Parameters.Add(myParam);
List<Unit> myListUnit = new List<Unit>();

using (DataTable dt = SQLProvider.GetDataTable(myCommand))
{
foreach(DataRow dr in dt.Rows)
{
Unit myUnit=new Unit();
myUnit.Id = (Int64)dr["id"];
myUnit.CompanyId = (Int64)dr["companyid"];
myUnit.Address = dr["address"].ToString();

myListUnit.Add(myUnit);
}
}
return myListUnit;
}
return null;
}

public static Unit GetUnitByID(long id)
{
..... indentica a GetUnitByCompanyID cambia solo la query
}



Quale sarebbe il modo corretto di implementare questo comune problema?
Ringrazio chi avrà la bontà di non ridere e la pazienza di rispondermi.
Ciao, Luca.

Ciao, tra le tue classi Company e Unit esiste una relazione di uno a molti. L'approccio che hai segnalto nel primo post non è sbagliato, ma volendo ottenere le Unit di 30 Company dovresti invocare per 30 volte la funzione GetUnitByCompanyID. Questo è un problema noto come select n+1, ovvero sei costretto ad inviare 30+1 comandi al database quando invece te la potresti cavare con una sola query JOIN tra le due tabelle.

Ragionando a "vecchio modo" farei una funzione parametrica

Potresti farlo, ma ti renderesti presto conto che le funzioni da scrivere diventano tantissime nel momento in cui aggiungi nuove classi al sistema. E' qui che un ORM ti viene in aiuto. Ad esempio Entity Framework può risolverti il problema select n+1 grazie all'eager loading.

http://blogs.microsoft.co.il/blogs/gilf/archive/2010/08/18/select-n-1-problem-how-to-decrease-your-orm-performance.aspx

Con Entity Framework, quando stabilisci una relazione di uno a molti tra due entità usando il designer di Visual Studio, puoi creare in ciascuna delle due classi quella che si chiama una "Navigation Property", ovvero una collezione di oggetti (o un solo oggetto) dell'altro tipo. Esse ti permettono, appunto, di "navigare" tra le istanze delle tue classi.

Il mio problema non è quello di trovare la tecnologia più adatta allo scopo, bensì capire la metodologia di approcio al problema con gli oggetti.

Certo, ma puoi comunque prendere spunto da Entity Framework, osservando come il designer genera le classi. L'esempio delle Navigation Properties puoi attuarlo tu stesso, preparando le tue classi così:



...e poi stabilendo una relazione tra loro, in questo modo.
http://www.linqitalia.com/script/268/Mappare-Relazione-Entity-Framework-Code-First.aspx

Entity Framework ti lascia libero di scrivere in autonomia le tue classi (si chiama approccio code-first) e poi ti mette a disposizione i metodi per estrarre i dati dal database in maniera ottimizzata (=caricamento di ciò che ti serve con il minor numero di query possibili). Ti consente di ottenere buone prestazioni senza per questo dover scrivere una montagna di codice :)

---

Modificato da BrightSoul il 27 luglio 2011 23.34 -