bool IsCacheValid(ClassDefineMetadata metadata, IQueryTimestamp cacheData)
{
ICache dependCache = RepositoryFramework.GetCacher(metadata, "cache:region");
var values = dependCache.GetBatch <long>(regions.Select(o => o.CacheKey));
return(values.Count() == 0 || values.All(o => o < cacheData.Timestamp));
}
static object CreateProxy(Type entityType, ClassDefineMetadata metadata)
{
Func <IInterceptor[], object> func;
if (!(factoryCache.TryGetValue(entityType, out func)))
{
lock (factoryCache)
{
if (!(factoryCache.TryGetValue(entityType, out func)))
{
ProxyGenerationOptions options = new ProxyGenerationOptions(new InnerHook(metadata));
var proxyType = generator.ProxyBuilder.CreateClassProxyType(entityType, new Type[0], options);
var construncor = proxyType.GetConstructor(new Type[] { typeof(IInterceptor[]) });
var interceptors = Expression.Parameter(typeof(IInterceptor[]), "interceptors");
var main = Expression.Convert(Expression.New(construncor, interceptors), typeof(object));
func = Expression.Lambda <Func <IInterceptor[], object> >(main, interceptors).Compile();
factoryCache[entityType] = func;
}
}
}
var ei = new EntityInterceptor(metadata);
var proxy = func(new IInterceptor[] { ei });
ei.Inited = true;
return(proxy);
}
public DataWrapper(ClassDefineMetadata metadata, IEnumerable ids)
{
Metadata = metadata;
Datas = ids.Cast <object>().Select(o => new DataItem()
{
Id = o, Key = metadata.GetCacheKeyById(o)
}).ToList();
}
public static IPersister CreatePersister(IInvocation invocation, ClassDefineMetadata metadata)
{
DataSourcePersister dataSource = new DataSourcePersister(invocation, null);
SecondLevelPersister secondLevel = new SecondLevelPersister(metadata, RepositoryFramework.GetCacher(metadata), dataSource);
SessionPersister session = new SessionPersister(SessionCache.Current, secondLevel);
return(session);
}
/// <summary>
/// 获取用于查询缓存的缓存
/// </summary>
/// <param name="metadata"></param>
/// <returns></returns>
internal static ICache GetCacherForQuery(ClassDefineMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
return(GetCacher(metadata, "@@" + metadata.EntityType.FullName));
}
public UniqueRaise(RaiseType raiseType, ClassDefineMetadata metadata, object entity, bool autoDisposed)
{
key = String.Format("{0}:{1}:{2}", metadata.EntityType.FullName, EntityUtil.GetId(entity), raiseType);
NotRaised = !WorkbenchUtil <string, bool> .GetValue(UniqueRaiseKey, key);
if (NotRaised)
{
WorkbenchUtil <string, bool> .SetValue(UniqueRaiseKey, key, true);
}
AutoDisposed = autoDisposed;
}
internal ClassJoinDefine(ClassDefineMetadata metadata, ClassJoinType joinType, MemberInfo member, Action <TEntity, HasManyByForeignKeyDefine> foreignKeyDefine)
: this(metadata, joinType, member)
{
switch (joinType)
{
case ClassJoinType.HasManyByForeignKey:
joinMetadata.DataProcesser = new HasManyByForeignKeyClassJoinProcessor <TEntity, TJoin>(foreignKeyDefine, joinMetadata);
break;
default:
throw new NotSupportedException();
}
}
public static object CreateEntityProxy(Type entityType)
{
ClassDefineMetadata metadata = RepositoryFramework.GetDefineMetadataAndCheck(entityType);
return(CreateProxy(entityType, metadata));
//var ei = new EntityInterceptor(metadata);
//ProxyGenerationOptions options = new ProxyGenerationOptions(new InnerHook(metadata));
////var t = generator.ProxyBuilder.CreateClassProxyType(entityType,new Type[0], options);
////
//var proxy = generator.CreateClassProxy(entityType, options, ei);
//ei.Inited = true;
//return proxy;
}
internal static ICache GetCacher(ClassDefineMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
var cache = CacheManager.GetCacher(metadata.EntityType);
if (!metadata.IsContextCacheable || cache is HttpContextCache)
{
return(cache);
}
return(new SecondaryCacheEx(cache));
}
public void Process(IInvocation invocation, ClassDefineMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (metadata.IsCacheable)
{
var cacheKey = metadata.GetCacheKeyById(invocation.Arguments[1]);
ICache cache = RepositoryFramework.GetCacher(metadata);
//CacheData value = cache.Get(cacheKey);
var value = cache.Get(metadata.EntityType, cacheKey);
if (value == null)
{
// 调用源接口，并将结果写入缓存
using (MonitorContext.Repository(invocation.Method))
invocation.Proceed();
var entity = invocation.ReturnValue;
if (entity != null)
{
cache.Set(cacheKey, metadata.CloneEntity(entity));
}
if (ProfilerContext.Current.Enabled)
{
ProfilerContext.Current.Trace("platform", String.Format("missing get{1}\r\n{0}", cacheKey, entity == null ? " for null" : ""));
}
}
else
{
//if (ProfilerContext.Current.Enabled)
// ProfilerContext.Current.Trace("platform", String.Format("hit get\r\n{0}", cacheKey));
//invocation.ReturnValue = value.Convert(metadata.EntityType);
using (MonitorContext.Repository(invocation.Method, true))
{
}
invocation.ReturnValue = value;
}
}
else
{
using (MonitorContext.Repository(invocation.Method))
invocation.Proceed();
}
}
public void Process(IInvocation invocation, ClassDefineMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
var entity = invocation.Arguments[0];
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var interceptors = RepositoryFramework.GetInterceptors(metadata.EntityType);
//invoke pre event
var preUr = new UniqueRaise(GetRaiseType(invocation, true), metadata, entity, false);
var postUr = new UniqueRaise(GetRaiseType(invocation, false), metadata, entity, false);
//invoke cascade delete or update
var preRaiseType = GetRaiseType(invocation, true);
if (preRaiseType == RaiseType.PreDelete || preRaiseType == RaiseType.PreUpdate)
{
Cascade(invocation, entity);
}
RepositoryFramework.Raise(entity, preRaiseType, preUr);
using (MonitorContext.Repository(invocation.Method))
invocation.Proceed();
//invoke post event
var postRaiseType = GetRaiseType(invocation, false);
RepositoryFramework.Raise(entity, postRaiseType, postUr);
//invoke cascade create
if (postRaiseType == RaiseType.PostCreate)
{
Cascade(invocation, entity);
}
preUr.Dispose();
postUr.Dispose();
}
internal ClassJoinDefine(ClassDefineMetadata metadata, ClassJoinType joinType, MemberInfo member, Func <TEntity, ISpecification <TJoin>, ISpecification <TJoin> > joinExpr)
: this(metadata, joinType, member)
{
switch (joinType)
{
case ClassJoinType.HasOne:
joinMetadata.DataProcesser = new HasOneClassJoinProcessor <TEntity, TJoin>(joinExpr, joinMetadata);
break;
case ClassJoinType.HasMany:
joinMetadata.DataProcesser = new HasManyClassJoinProcessor <TEntity, TJoin>(joinExpr, joinMetadata);
break;
default:
throw new NotSupportedException();
}
}
private ClassJoinDefine(ClassDefineMetadata metadata, ClassJoinType joinType, MemberInfo member)
{
this.metadata = metadata;
this.joinType = joinType;
this.member = member;
joinMetadata = new ClassJoinDefineMetadata();
joinMetadata.JoinName = member.Name;
var property = member as PropertyInfo;
if (property != null)
{
var getMethod = property.GetGetMethod(true);
if (getMethod == null)
{
throw new PlatformException("类型 {0} 的级联属性 {1} 必须可读。", member.DeclaringType, member.Name);
}
joinMetadata.Method = getMethod;
joinMetadata.JoinType = MethodJoinType.PropertyGet;
// set
var setMethod = property.GetSetMethod(true);
if (setMethod == null)
{
throw new PlatformException("类型 {0} 的级联属性 {1} 必须可写。", member.DeclaringType, member.Name);
}
var setDefine = new ClassJoinDefineMetadata();
setDefine.Method = setMethod;
setDefine.JoinType = MethodJoinType.PropertySet;
setDefine.JoinName = member.Name;
metadata.ClassJoinDefines.Add(setDefine.Method, setDefine);
}
else
{
joinMetadata.JoinType = MethodJoinType.Method;
joinMetadata.Method = (MethodInfo)member;
}
metadata.ClassJoinDefines.Add(joinMetadata.Method, joinMetadata);
}
internal static ICache GetCacher(ClassDefineMetadata metadata, string name)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
var cache = CacheManager.GetCacher(name);
if (!metadata.IsContextCacheable || cache is HttpContextCache)
{
return(cache);
}
return(new SecondaryCacheEx(cache));
}
internal static void ProxyJoins(object entity)
{
ClassDefineMetadata metadata = RepositoryFramework.GetDefineMetadataAndCheck(entity.GetType());
var joins = metadata.ClassJoinDefines.Values.Cast <ClassJoinDefineMetadata>().Where(o => o.JoinType == MethodJoinType.PropertyGet);
var ta = TypeAccessor.GetAccessor(metadata.EntityType);
foreach (var join in joins)
{
var value = ta.GetProperty(join.JoinName, entity);
//已经为代理对象，直接忽略
if (IsProxy(value))
{
((IProxy)value).Reset();
continue;
}
var type = join.Method.ReturnType;
if (EntityUtil.IsGenericList(type))
{
var itemType = type.GetGenericArguments()[0];
var proxyType = typeof(ProxyCollection <>).MakeGenericType(itemType);
IProxyCollection proxy = (IProxyCollection)FastActivator.Create(proxyType);
proxy.Init(entity, join);
ta.SetProperty(join.JoinName, entity, proxy);
}
else
{
var ei = new EntityProxyInterceptor(entity, join);
var proxy = ProxyProvider.GetCreateFunc(type)(new IInterceptor[] { ei });
ei.IsConstructed = true;
ta.SetProperty(join.JoinName, entity, proxy);
}
}
}
public SecondLevelPersister(ClassDefineMetadata metadata, ICache cache, IPersister innerPersister)
: base(innerPersister)
{
this.metadata = metadata;
this.cache = cache;
}
protected internal ClassJoinManyDefine(ClassDefineMetadata metadata, MemberInfo member, Func <TEntity, ISpecification <TJoin>, ISpecification <TJoin> > joinonExpr) :
base(metadata, ClassJoinType.HasMany, member, joinonExpr)
{
cascadeDefine = new ClassJoinManyCascadeDefine <TEntity, TJoin>(JoinMetadata);
cacheDefine = new ClassJoinCacheDefine <TEntity, TJoin>(JoinMetadata.JoinCache);
}
public InnerHook(ClassDefineMetadata metadata)
{
this.metadata = metadata;
}
public void Process(IInvocation invocation, ClassDefineMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (metadata.IsCacheable)
{
IEnumerable ids = (IEnumerable)invocation.Arguments[1];
var cache = RepositoryFramework.GetCacher(metadata);
var idKeys = ids.Cast <object>().Distinct().Select(o => new IdKey(o, metadata.GetCacheKeyById(o)));
//访问缓存并获取不在缓存中的 CacheKey
IEnumerable <string> missing;
//var cacheItems = cache.GetBatch<CacheData>(idKeys.Select(o => o.Key), out missing).Select(o => o.Convert(metadata.EntityType)).ToList();
var cacheItems = cache.GetBatch(metadata.EntityType, idKeys.Select(o => o.Key), out missing).Cast <object>().ToList();
if (missing.Count() > 0)
{
var missIds = missing.Select(o => idKeys.First(ik => ik.Key == o).Id);
invocation.SetArgumentValue(1, missIds);
using (MonitorContext.Repository(invocation.Method))
invocation.Proceed();
var sourceItems = ((IEnumerable)invocation.ReturnValue).Cast <object>();
cacheItems.AddRange(sourceItems);
if (sourceItems.Count() > 0)
{
//加入缓存
cache.SetBatch(sourceItems.Select(o => new CacheItem <object>(metadata.GetCacheKey(o), metadata.CloneEntity(o))), 1200);
}
else
{
if (ProfilerContext.Current.Enabled)
{
ProfilerContext.Current.Trace("platform", String.Format("missing get list for null\r\n{0}", String.Join(",", missing)));
}
}
}
else
{
using (MonitorContext.Repository(invocation.Method, true))
{
}
}
var ta = TypeAccessor.GetAccessor(metadata.EntityType);
var idGetter = ta.GetPropertyGetter(metadata.IdMember.Name);
//按ID排序并进行类型转化
invocation.ReturnValue = cacheItems
.OrderBy(entity => idGetter(entity), ids.Cast <object>())
.Cast(metadata.EntityType);
//按ID排序并进行类型转化
invocation.ReturnValue = cacheItems
.OrderBy(entity => idGetter(entity), ids.Cast <object>())
.Cast(metadata.EntityType);
}
else
{
using (MonitorContext.Repository(invocation.Method))
invocation.Proceed();
}
}
public EntityInterceptor(ClassDefineMetadata metadata)
{
this.metadata = metadata;
}
protected internal ClassJoinManyDefine(ClassDefineMetadata metadata, MemberInfo member, Action <TEntity, HasManyByForeignKeyDefine> foreignKeyDefine)
: base(metadata, ClassJoinType.HasManyByForeignKey, member, foreignKeyDefine)
{
cascadeDefine = new ClassJoinManyCascadeDefine <TEntity, TJoin>(JoinMetadata);
cacheDefine = new ClassJoinCacheDefine <TEntity, TJoin>(JoinMetadata.JoinCache);
}
