public IQuery SetEntity(int position, object val)
{
SetParameter(position, val, NHibernateUtil.Entity(NHibernateProxyHelper.GuessClass(val)));
return(this);
}
public IQuery SetEntity(string name, object val)
{
SetParameter(name, val, NHibernateUtil.Entity(NHibernateProxyHelper.GuessClass(val)));
return(this);
}
public IFuturo <T> GetFuturo <T>(Guid id) where T : EntityBase
{
var tarea = Task.Run(() =>
{
T entidad = null;
using (var sessionStateless = _session.SessionFactory.OpenStatelessSession())
{
entidad = sessionStateless.Get <T>(id);
}
IEntityPersister persister = _session.GetSessionImplementation().GetEntityPersister(NHibernateProxyHelper.GuessClass(entidad).FullName, entidad);
object[] fields = persister.GetPropertyValues(entidad, _session.ActiveEntityMode);
object oid = persister.GetIdentifier(entidad, _session.ActiveEntityMode);
EntityEntry entry = _session.GetSessionImplementation().PersistenceContext.AddEntry(entidad, Status.Loaded, fields, null, id, null, LockMode.None, true, persister, true, false);
return(entidad);
});
_tareas.Add(tarea);
return(new Futuro <T>(tarea));
}
private Type GetRealType()
{
return(NHibernateProxyHelper.GetClassWithoutInitializingProxy(this));
}
/// <summary>
/// Создаёт диалог для конкретного объекта доменной модели приложения.
/// </summary>
/// <returns>Виджет с интерфейсом ITdiDialog</returns>
/// <param name="entity">Объект для которого нужно создать диалог.</param>
public static ITdiDialog CreateObjectDialog(object entity)
{
return(CreateObjectDialog(NHibernateProxyHelper.GuessClass(entity), entity));
}
public override string ToLoggableString(object value, ISessionFactoryImplementor factory)
{
return(value == null ? "null" :
NHibernateUtil.Entity(NHibernateProxyHelper.GetClassWithoutInitializingProxy(value)).ToLoggableString(value, factory));
}
internal AptifyEntityMetadata GetEntityMetadata(Object entity)
{
Type type = NHibernateProxyHelper.GetClassWithoutInitializingProxy(entity);
return(this.tables[type].Entity);
}
/// <summary>
/// Returns the concrete type of the object, not the proxy one.
/// </summary>
/// <returns></returns>
public virtual System.Type GetConcreteType()
{
return(NHibernateProxyHelper.GuessClass(this));
}
public static T Attach <T>(this ISession session, T entity, LockMode mode = null)
{
mode = mode ?? LockMode.None;
IEntityPersister persister = session.GetSessionImplementation().GetEntityPersister(NHibernateProxyHelper.GuessClass(entity).FullName, entity);
Object[] fields = persister.GetPropertyValues(entity, session.ActiveEntityMode);
Object id = persister.GetIdentifier(entity, session.ActiveEntityMode);
Object version = persister.GetVersion(entity, session.ActiveEntityMode);
EntityEntry entry = session.GetSessionImplementation().PersistenceContext.AddEntry(entity, Status.Loaded, fields, null, id, version, LockMode.None, true, persister, true, false);
return(entity);
}
/// <remarks>
/// Small violation of Separation of Concerns here...
/// </remarks>
private Type GetUnproxiedType()
{
return(GetType().Name.Contains("ProxyForFieldInterceptor")
? GetType().BaseType
: NHibernateProxyHelper.GetClassWithoutInitializingProxy(this));
}
public static bool IsProxy(this object sourceEntity)
{
return(NHibernateProxyHelper.IsProxy(sourceEntity));
}
private static T Unproxy <T>(T entity, ISession session, HashSet <object> resolvedEntities)
{
if (entity == null)
{
return(default(T));
}
T resolvedEntity;
if (entity is INHibernateProxy)
{
if (!NHibernateUtil.IsInitialized(entity))
{
var id = session.GetIdentifier(entity);
var et = NHibernateProxyHelper.GetClassWithoutInitializingProxy(entity);
entity = (T)Activator.CreateInstance(et);
session.SessionFactory.GetClassMetadata(et).SetIdentifier(entity, id);
return(entity);
}
resolvedEntity = (T)session.GetSessionImplementation().PersistenceContext.Unproxy(entity);
}
else
{
resolvedEntity = entity;
}
if (resolvedEntities.Contains(resolvedEntity))
{
return(resolvedEntity);
}
resolvedEntities.Add(resolvedEntity);
Type entityType = resolvedEntity.GetType();
var entityMetadata = session.SessionFactory.GetClassMetadata(entityType);
if (entityMetadata == null)
{
if (IsAnonymousType(entityType))
{
foreach (PropertyInfo prop in entityType.GetProperties())
{
var propValue = prop.GetValue(entity, null);
Unproxy(propValue, session, resolvedEntities);
}
return(entity);
}
else if (IsList(entityType))
{
var entityCollection = (IList)resolvedEntity;
for (int i = 0; i < entityCollection.Count; i++)
{
entityCollection[i] = Unproxy(entityCollection[i], session, resolvedEntities);
}
return(resolvedEntity);
}
else
{
return(default(T));
}
}
PropertyInfo[] propertyInfos = entityType.GetProperties();
foreach (PropertyInfo propertyInfo in propertyInfos)
{
var propertyName = propertyInfo.Name;
var entityPropertyType = entityMetadata.GetPropertyType(propertyName);
var propertyValue = propertyInfo.GetValue(entity, null);
if (entityPropertyType.IsCollectionType)
{
var propertyListPublicType = propertyInfo.PropertyType.GetGenericArguments()[0];
var propertyListType = typeof(List <>).MakeGenericType(propertyListPublicType);
IList propertyList = (IList)Activator.CreateInstance(propertyListType);
propertyInfo.SetValue(resolvedEntity, propertyList, null);
if (NHibernateUtil.IsInitialized(propertyValue))
{
foreach (var propValue in (IEnumerable)propertyValue)
{
propertyList.Add(Unproxy(propValue, session, resolvedEntities));
}
}
}
else if (entityPropertyType.IsEntityType)
{
propertyInfo.SetValue(resolvedEntity, Unproxy(propertyValue, session, resolvedEntities), null);
}
}
return(resolvedEntity);
}
public static bool NeedTrace(IDomainObject entity)
{
var type = NHibernateProxyHelper.GuessClass(entity);
return(NeedTrace(type));
}
