public ClassProxy GetProxy(Guid id)
{
ClassProxy _classProxy = null;
__proxies.TryGetValue(id, out _classProxy);
return(_classProxy);
}
/// <summary>
/// Trouve et retourne le <see cref="ClassProxy"/> de entity s'il existe, ou le crée et l'attache, ainsi
/// que les <see cref="ClassProxy"/> de ces membres objets de<see cref="Base"/>,
/// puis le retourne.
/// Provoque une exception si entity est null ou non représenté
/// par un <see cref="Set"/> dans ce <see cref="ShContext"/>.
/// </summary>
public ClassProxy GetOrAttach(Base entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
Set _set = GetSet(entity.GetType());
if (_set == null)
{
throw new Exception
("Le type d'entity " + entity.GetType().Name + " n'a pas été représenté dans le Context");
}
ClassProxy _proxy = _set.GetProxy(entity);
if (_proxy == null)
{
_proxy = new ClassProxy(this, entity);
_set.AddProxy(_proxy);
}
Set _attacheds = new Set <Base>();
_attacheds.AddProxy(_proxy);
AttachProxyChildren(_proxy, _attacheds);
return(_proxy);
}
public ClassProxy(ShContext context, Type classType, Guid id)
: base(context)
{
ClassProxy _proxy = this;
ProxyFactory.ClassProxyFactory(Context, ref _proxy, classType, id);
IsBuilt = true;
}
public ClassProxy Factory()
{
Base _entity = (Activator.CreateInstance(Type)) as Base;
ClassProxy _proxy = new ClassProxy(Context, _entity)
{
Context = Context
};
return(_proxy);
}
public ClassProxy(ShContext context, Base entity)
: base(context)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
ClassProxy _proxy = this;
ProxyFactory.ClassProxyFactory(Context, ref _proxy, entity.GetType(), entity.ID);
__entity = entity;
UpdateProxyValues();
IsBuilt = true;
}
/// <summary>
/// Trouve ou ajoute au <see cref="Set"/> le <see cref="ClassProxy"/> construit
/// sur entity.
/// </summary>
public ClassProxy GetOrAttachProxy(Base entity)
{
ClassProxy _proxy = GetProxy(entity);
if (_proxy == null)
{
_proxy = new ClassProxy(Context, entity)
{
Context = Context
};
AddProxy(_proxy);
}
return(_proxy);
}
private void AttachProxyChildren(ClassProxy proxy, Set attacheds)
{
foreach (PropertyObjectProxy _prProxy in proxy.PropertiesObjects())
{
Base _entity = _prProxy.Entity;
Attach(_entity, attacheds);
}
foreach (PropertyListProxy _prListProxy in proxy.PropertiesList())
{
foreach (Base _entity in _prListProxy.Entities())
{
Attach(_entity, attacheds);
}
}
}
private void Attach(Base entity, Set attacheds)
{
if (entity != null && !attacheds.IsAttached(entity))
{
Set _set = GetSet(entity.GetType());
if (_set != null)
{
ClassProxy _childProxy = _set.GetProxy(entity);
if (_childProxy == null)
{
_childProxy = new ClassProxy(this, entity);
_set.AddProxy(_childProxy);
}
attacheds.AddProxy(_childProxy);
AttachProxyChildren(_childProxy, attacheds);
}
}
}
/// <summary>
/// Trouve et retourne le proxy de type typename et ID id s'il existe,
/// ou le crée, lui donnant son id, l'attache et le retourne.
///
/// Cette fonction est utile lors d'un chargement de données, par exemple
/// lors de la lecture des données retournées par une DB.
/// Les proxys sont alors crées à partir de ces données, leur id leur est donné,
/// ainsi que leurs valeurs.
/// Les id et données de leur propriétés object de <see cref="Base"/>,
/// ou des objets contenus dans des propriétés collection, ne sont
/// pas connus à ce moment, cette fonction n'attache donc pas en cascade
/// ces propriétés. C'est code qui lit les données qui est chargé
/// de générér chaque proxy et entité, ouis l'appelle à la fonction
/// <see cref="UpdateEntitiesValues"/> recrée les liens.
///
/// Provoque une exception si typename n'est pas le nom d'un type représenté
/// par un <see cref="Set"/> dans ce context, ou si id est un <see cref="Guid.Empty"/>.
/// </summary>
public ClassProxy GetOrAttach(string typename, Guid id)
{
if (string.IsNullOrWhiteSpace(typename))
{
throw new Exception("typename ne peut pas être null ou vide.");
}
Set _set = GetSet(typename);
if (_set == null)
{
throw new Exception("Le type " + typename + " n'est pas représenté dans ce context.");
}
ClassProxy _proxy = _set.GetProxy(id);
if (_proxy == null)
{
_proxy = new ClassProxy(this, _set.Type, id);
_set.AddProxy(_proxy);
}
return(_proxy);
}
public static ClassProxy ClassProxyFactory(ShContext context, ref ClassProxy proxy, Type t, Guid id)
{
if (proxy == null)
{
return(new ClassProxy(context, t, id));// appellera cette fonction à nouveau.
}
proxy.Context = context;
proxy.Type = t;
if (proxy.ID == Guid.Empty)
{
proxy.ID = id;
}
foreach (PropertyInfo _pr in t.GetProperties())
{
if (PropertyHelper.IsMappableProperty(_pr))
{
proxy.SetProperty(_pr.Name, PropertyProxyFactory(context, _pr, proxy));
}
}
return(proxy);
}
public PropertyProxy(ShContext context, PropertyInfo prInfo, ClassProxy parent)
: base(context)
{
PropertyInfo = prInfo;
Parent = parent;
}
/// <summary>
/// Ajoute un <see cref="ClassProxy"/> à ce <see cref="Set"/>.
/// Ne vérifie pas qu'il n'y soit déja.
/// </summary>
public void AddProxy(ClassProxy proxy)
{
__proxies[proxy.ID] = proxy;
}
public static PropertyProxy PropertyProxyFactory(ShContext context, PropertyInfo prInfo, ClassProxy parent)
{
if (TypeHelper.IsPrimitiveOrAlike(prInfo.PropertyType))
{
return(new PropertyPrimitiveProxy(context, prInfo, parent));
}
if (prInfo.PropertyType.IsSubclassOf(typeof(Base)))
{
return(new PropertyObjectProxy(context, prInfo, parent));
}
if (TypeHelper.IsGenericList(prInfo.PropertyType))
{
return(new PropertyListProxy(context, prInfo, parent));
}
if (TypeHelper.IsDictionary(prInfo.PropertyType))
{
return(new PropertyDictionaryProxy(context, prInfo, parent));
}
if (prInfo.PropertyType.IsEnum)
{
return(new PropertyEnumProxy(context, prInfo, parent));
}
throw new Exception("Le type " + prInfo.PropertyType.Name + " n'est pas pris en compte.");
}
