//----------------------------------------------------------
private CResultAErreur MiseAjour(CMemoryDb sourceDB, bool bUpdateOnly)
{
foreach (DataTable table in sourceDB.Tables)
{
if (!bUpdateOnly || Tables[table.TableName] != null)
{
Type tp = sourceDB.GetTypeForTable(table.TableName);
if (tp != null)
{
GetTable(tp);
}
}
}
EnforceConstraints = false;
foreach (DataTable table in sourceDB.Tables)
{
if (Tables.Contains(table.TableName))
{
table.BeginLoadData();
Type tp = sourceDB.GetTypeForTable(table.TableName);
foreach (DataRow row in table.Rows)
{
if (!bUpdateOnly || Tables[table.TableName].Rows.Find(row[table.PrimaryKey[0]]) != null)
{
CEntiteDeMemoryDb entite = Activator.CreateInstance(tp, new object[] { row }) as CEntiteDeMemoryDb;
ImporteObjet(entite, false, false);
}
}
table.EndLoadData();
}
}
EnforceConstraints = true;
return(CResultAErreur.True);
}
//----------------------------------------------------------------
public CListeEntitesDeMemoryDbBase(CMemoryDb db, Type typeElements)
{
m_database = db;
m_typeElements = typeElements;
CEntiteDeMemoryDb entite = Activator.CreateInstance(typeElements, new object[] { db }) as CEntiteDeMemoryDb;
m_strSortOrder = entite.GetChampTriParDefaut();
}
//----------------------------------------------------
public CEntiteDeMemoryDb ImporteObjet(
CEntiteDeMemoryDb valeur,
bool bAvecFils,
bool bMiseAJourElementsExistants)
{
HashSet <string> elementsDejaImportés = new HashSet <string>();
return(ImporteObjet(valeur, bAvecFils, bMiseAJourElementsExistants, elementsDejaImportés));
}
//----------------------------------------------------------
public CResultAErreur RemoveEntite(Type tp, string strId)
{
CResultAErreur result = CResultAErreur.True;
CEntiteDeMemoryDb entite = Activator.CreateInstance(tp, new object[] { this }) as CEntiteDeMemoryDb;
if (entite != null && entite.ReadIfExist(strId))
{
result = entite.Delete();
}
return(result);
}
//----------------------------------------------------------
public CEntiteDeMemoryDb GetElementFromFournisseurSupplementaire(Type tp, string strId)
{
List <IFournisseurElementsManquantsPourMemoryDb> lst = null;
if (m_fournisseursSupplementairesElements.TryGetValue(tp, out lst))
{
foreach (IFournisseurElementsManquantsPourMemoryDb fournisseur in lst)
{
CEntiteDeMemoryDb entite = fournisseur.GetEntite(tp, strId, this);
if (entite != null)
{
return(entite);
}
}
}
return(null);
}
//----------------------------------------------------------
public CResultAErreur UpdateEntite(CEntiteDeMemoryDb entite)
{
CResultAErreur result = CResultAErreur.True;
if (entite.Database != this)
{
try
{
ImporteObjet(entite, true, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
return(result);
}
//----------------------------------------------------------------
public CEntiteDeMemoryDb GetEntity(CMemoryDb contexteMemoire)
{
CEntiteDeMemoryDb entite = (CEntiteDeMemoryDb)Activator.CreateInstance(m_typeObjet, new object[] { contexteMemoire });
foreach (object cle in m_cles)
{
try
{
string strId = (string)cle;
if (entite.ReadIfExist(strId))
{
return(entite);
}
}
catch
{
continue;
}
}
return(null);
}
//--------------------------------------------
public CValiseEntiteDeMemoryDb(CEntiteDeMemoryDb entite)
{
m_entite = entite;
}
public CReferenceEntiteMemoryDb(CEntiteDeMemoryDb entite)
{
m_typeObjet = entite.GetType();
m_cles = new object[] { entite.Id };
}
//----------------------------------------------------
public CEntiteDeMemoryDb ImporteObjet(
CEntiteDeMemoryDb valeur,
bool bAvecFils,
bool bMiseAJourElementsExistants,
HashSet <string> elementsDejaImportés)
{
bool bOldEnforceConstrainte = EnforceConstraints;
try
{
EnforceConstraints = false;
DataTable table = GetTable(valeur.GetType());
if (elementsDejaImportés.Contains(valeur.ObjectKey))
{
DataRow row = table.Rows.Find(valeur.Id);
if (row == null)
{
return(null);
}
return(Activator.CreateInstance(valeur.GetType(), new object[] { row }) as CEntiteDeMemoryDb);
}
DataRow rowExistante = table.Rows.Find(valeur.Id);
if (rowExistante != null && !(bool)rowExistante[c_champIsToRead] && !bMiseAJourElementsExistants)
{
return(Activator.CreateInstance(valeur.GetType(), new object[] { rowExistante }) as CEntiteDeMemoryDb);
}
elementsDejaImportés.Add(valeur.ObjectKey);
foreach (PropertyInfo info in valeur.GetType().GetProperties())
{
object[] attrs = info.GetCustomAttributes(typeof(MemoryParentAttribute), true);
if (attrs != null && attrs.Length > 0)
{
MemoryParentAttribute parentAtt = attrs[0] as MemoryParentAttribute;
string strChampFils = parentAtt.NomChampFils;
if (strChampFils == "")
{
CEntiteDeMemoryDb entite = Activator.CreateInstance(info.PropertyType, new object[] { this }) as CEntiteDeMemoryDb;
strChampFils = entite.GetChampId();
}
CEntiteDeMemoryDb parent = valeur.GetParent(info.PropertyType, strChampFils);
if (parent != null)
{
ImporteObjet(parent, true, bMiseAJourElementsExistants, elementsDejaImportés);
}
}
}
if (rowExistante == null)
{
table.ImportRow(valeur.Row.Row);
}
else
{
if ((bool)valeur.Row.Row[c_champIsToRead] || bMiseAJourElementsExistants)
{
foreach (DataColumn col in valeur.Row.Row.Table.Columns)
{
if (table.Columns.Contains(col.ColumnName))
{
rowExistante[col.ColumnName] = valeur.Row.Row[col.ColumnName];
}
}
}
}
if (bAvecFils)
{
foreach (DataRelation dr in valeur.Database.Relations)
{
if (dr.ParentTable.TableName == table.TableName)
{
Type tpFils = valeur.Database.GetTypeForTable(dr.ChildTable.TableName);
if (tpFils != null)
{
PropertyInfo prop = tpFils.GetProperty(dr.ExtendedProperties[c_ExtPropRelationNomProprieteFils].ToString());
if (prop != null)
{
object[] attrs = prop.GetCustomAttributes(typeof(MemoryParentAttribute), true);
if (attrs != null && attrs.Length > 0)
{
MemoryParentAttribute parentAtt = attrs[0] as MemoryParentAttribute;
if (parentAtt.IsComposition)
{
Type tpListe = typeof(CListeEntitesDeMemoryDb <>);
Type tpListeType = tpListe.MakeGenericType(tpFils);
IEnumerable lst = Activator.CreateInstance(tpListeType, new object[] { valeur.Database, new CFiltreMemoryDb(dr.ChildColumns[0].ColumnName + "=@1", valeur.Id) }) as IEnumerable;
foreach (CEntiteDeMemoryDb entite in lst)
{
ImporteObjet(entite, bAvecFils, bMiseAJourElementsExistants, elementsDejaImportés);
}
}
}
}
}
}
}
}
return(Activator.CreateInstance(valeur.GetType(), new object[] { table.Rows.Find(valeur.Id) }) as CEntiteDeMemoryDb);
}
finally
{
EnforceConstraints = bOldEnforceConstrainte;
}
}
//---------------------------------------
private string GetNomTable(Type tp)
{
CEntiteDeMemoryDb entite = Activator.CreateInstance(tp, new object[] { this }) as CEntiteDeMemoryDb;
return(entite.GetNomTable());
}
