public
class
AOPExportProvider : ExportProvider, IDisposable

{

private
CatalogExportProvider _exportProvider;

public AOPExportProvider(Func<ComposablePartCatalog> catalogResolver)

{

_exportProvider = new
CatalogExportProvider(catalogResolver(),true);

//support recomposition

_exportProvider.ExportsChanged += (s, e) => OnExportsChanged(e);

_exportProvider.ExportsChanging += (s, e) => OnExportsChanging(e);

}

public
ExportProvider SourceProvider

{

get

{

return _exportProvider.SourceProvider;

}

set

{

_exportProvider.SourceProvider = value;

}

}

protected
override
IEnumerable<Export> GetExportsCore(

ImportDefinition definition, AtomicComposition atomicComposition)

{

IEnumerable<Export> exports = _exportProvider.GetExports(definition, atomicComposition);

return exports.Select(export => new
Export(export.Definition, () => GetValue(export)));

}

private
object GetValue(Export innerExport)

{

var value = innerExport.Value;

IInterceptor[] attribs = value.GetType().GetCustomAttributes(typeof(IInterceptor), true).Cast<IInterceptor>().ToArray();

if (attribs.Length == 0)

return value;

ProxyGenerator generator = new
ProxyGenerator();

object proxy = generator.CreateClassProxy(value.GetType(), attribs);

PropertyInfo[] propertyInfo= value.GetType().GetProperties();

Type proxyType = proxy.GetType().BaseType;

foreach (var item in propertyInfo)

{

PropertyInfo property = proxyType.GetProperty(item.Name);

if (property == null) continue;

property.SetValue(proxy, item.GetValue(value,null),null);

}

return proxy;

}

public
void Dispose()

{

_exportProvider.Dispose();

}

}

public
static
class
MefConfig

{

public
static
void RegisterMef()

{

var container = ConfigureContainer();

ControllerBuilder.Current.SetControllerFactory(new
MefControllerFactory(container));

var dependencyResolver = System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver;

}

private
static
CompositionContainer ConfigureContainer()

{

Func<ComposablePartCatalog> catalogResolver = () =>

{

AggregateCatalog catalog = new
AggregateCatalog();

catalog.Catalogs.Add(new
DirectoryCatalog(AppDomain.CurrentDomain.SetupInformation.PrivateBinPath, "Mw*.dll"));

return catalog;

};

AOPExportProvider provider = new
AOPExportProvider(catalogResolver);

CompositionContainer container = new
CompositionContainer(provider);

provider.SourceProvider = container;

AppDomain.CurrentDomain.SetData("Container", container);

return container;

}

}

[Export(typeof(IInterceptor))]

public
class
CacheInterceptor : Attribute, IInterceptor

{

private
ICache _cacheProvider;

public CacheInterceptor(){

_cacheProvider = ((CompositionContainer)AppDomain.CurrentDomain.GetData("Container")).GetExportedValue<ICache>();

}

private
char _linkChar = ':';

public
void Intercept(IInvocation invocation)

{

var qCachingAttribute = this.GetQCachingAttributeInfo(invocation.MethodInvocationTarget ?? invocation.Method);

if (qCachingAttribute != null)

{

ProceedCaching(invocation, qCachingAttribute);

}

else

{

invocation.Proceed();

}

}

private
QCachingAttribute GetQCachingAttributeInfo(MethodInfo method)

{

return method.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(QCachingAttribute)) as
QCachingAttribute;

}

private
void ProceedCaching(IInvocation invocation, QCachingAttribute attribute)

{

var cacheKey = attribute.Key;

if(string.IsNullOrEmpty(cacheKey))

cacheKey= GenerateCacheKey(invocation);

var cacheValue = _cacheProvider.Get(cacheKey, x => { return
null; });

if (cacheValue != null)

{

invocation.ReturnValue = cacheValue;

return;

}

invocation.Proceed();

if (!string.IsNullOrWhiteSpace(cacheKey))

{

_cacheProvider.Set(cacheKey, invocation.ReturnValue, TimeSpan.FromSeconds(attribute.AbsoluteExpiration));

}

}

private
string GenerateCacheKey(IInvocation invocation)

{

var typeName = invocation.TargetType.Name;

var methodName = invocation.Method.Name;

var methodArguments = this.FormatArgumentsToPartOfCacheKey(invocation.Arguments);

return
this.GenerateCacheKey(typeName, methodName, methodArguments);

}

//拼接缓存的键

private
string GenerateCacheKey(string typeName, string methodName, IList<string> parameters)

{

var builder = new
StringBuilder();

builder.Append(typeName);

builder.Append(_linkChar);

builder.Append(methodName);

builder.Append(_linkChar);

foreach (var param in parameters)

{

builder.Append(param);

builder.Append(_linkChar);

}

return builder.ToString().TrimEnd(_linkChar);

}

private
IList<string> FormatArgumentsToPartOfCacheKey(IList<object> methodArguments, int maxCount = 5)

{

return methodArguments.Select(this.GetArgumentValue).Take(maxCount).ToList();

}

//处理方法的参数，可根据情况自行调整

private
string GetArgumentValue(object arg)

{

if (arg is
int || arg is
long || arg is
string)

return arg.ToString();

if (arg is
DateTime)

return ((DateTime)arg).ToString("yyyyMMddHHmmss");

if (arg is
IQCachable)

return ((IQCachable)arg).CacheKey;

return
null;

}

}

[AttributeUsage(AttributeTargets.Method, Inherited = true)]

public
class
QCachingAttribute: Attribute

{

public
int AbsoluteExpiration { get; set; } = 30;

public
string Key { get; set; }

}

}

[Export(typeof(ICompanyDaily))]

[CacheInterceptor]

public
class
CompanyDaily : ICompanyDaily

{

[Import]

public
ItbshopRepository _shopRepository { get; set; }

[QCaching(AbsoluteExpiration =60*60*8)]

public
virtual
DataTable GetSalesDetailStatistics(DateTime sellDateBegin, DateTime sellDateEnd, string sShopGUID, string mAreaId, int classify, string types)

{

string beginDate = sellDateBegin.ToString("yyyy-MM-dd");

string endDate = sellDateEnd.ToString("yyyy-MM-dd");

try

{

//dosomething

return dtChart;

}

catch (Exception exp)

{

throw exp;

}

}