Ciao mi sono imbattuto in una cosa + grande di me :D
sarò veloce: ho le mie classi mappate (a mano), devo creare un record, bene un bel metodo statico:
public static UserProfile CreateUserProfile(UserProfile _userProfile)
{
try
{
DataContext context = new DataContext(stringa di connessione recuperata da un file di configurazione);
context.GetTable<UserProfile>().InsertOnSubmit(_userProfile);
context.SubmitChanges(ConflictMode.FailOnFirstConflict);
return _userProfile;
}
catch (Exception ex)
{
throw ex;
}
}
niente di + semplice (lo dico ora che stò incominciando a capire come funzione linq to sql)
Poi mi sono detto: "che palle però istanziare sempre la stessa classe DataContext scrivendo ogni volta il codice necessario per recuperare la stringa di connessione.." quindi mi sono creato una classe helper:
public class DataContextHelper
{
private static DataContext context = null;
public static DataContext Context
{
get
{
try
{
if (context == null)
{
context = new DataContext(GetConnectionString);
return context;
}
return context;
}
catch
{
throw new NullReferenceException("Cannot retrieve the DataContext");
}
}
}
}
ed il metodo di prima diventa:
public static UserProfile CreateUserProfile(UserProfile _userProfile)
{
try
{
DataContextHelper.Context.GetTable<UserProfile>().InsertOnSubmit(_userProfile);
DataContextHelper.Context.SubmitChanges(ConflictMode.FailOnFirstConflict);
return _userProfile;
}
catch (Exception ex)
{
throw ex;
}
}
L'intenzione era semplicemente quella di non scrivere sempre la stessa cosa.. ma scrivendo questa proprietà Context, non sò come mi è venuto, ho implementato anche il pattern lazy load, non l'avessi mai fatto!!
Cioè, mi sono detto: vabbè mettiamo che recupero un record, subito dopo devo modificarlo per poi aggiornarlo quindi:
UserProfile profile = UserProfileData.RetrieveUserProfileByUserKey(2);
profile.LastName = "AOOOOOOOOOOOOOOOOOOOOOOOOOOOO";
UserProfileData.UpdateUserProfile(profile);
incominciano i guai: con il metodo: "UserProfileData.RetrieveUserProfileByUserKey(2);" recupero il record (o istanza chiamatela come volete) che mi serve, ma allo stesso tempo stò mettendo questa istanza nel DataContext in modo del tutto trasparente, quindi modifico il record e chiamo un metodo per aggiornare: "UserProfileData.UpdateUserProfile(profile);"
ecco che mi si presenta il problema per cui stò scrivendo questo post, ho infatti implementato il lazy load su DataContexHelper.Context e quando cerco di fare l'aggiornamento dell'istanza, questa è già presente nel DataContext e in nessun modo riesco ad aggiornarla o sostituirla.. o meglio.. ci sono anche riuscito annullando il DataContext che la contiene (DataContextHelper.Context = null) ed attaccando (Attach) o inserendo (InsertOnSubmit) in una nuova istanza di DataContextHelper.Context, ma .. ecco il framework che mi sgrida.. dice infatti che questa istanza che stò per aggiornare contiene una associazione con un altra classe, e tale associazione non verrà mantenuta..
Insomma.. senza scendere troppo nel dettaglio, sembra che stia prendendo il sopravvento quel concetto che ho letto in vari articoli, cioè un datacontex per ogni operazione :(
conferme, correzioni, smentite.. accetto tutto :D