public TInterface WrapWith(IProxyHandler <TInterface> handler)
{
var proxyDelegatorType = IlGeneratorProxyGenerator.CreateProxyFor <TInterface>();
var proxyInstance = (TInterface)Activator.CreateInstance(proxyDelegatorType, _implementation, handler);
return(proxyInstance);
}
public SleipnerCache(T implementation, ICacheProvider <T> cache)
{
_implementation = implementation;
_cache = cache;
CachePolicyProvider = new BasicConfigurationProvider <T>();
_proxyHandler = new SleipnerCacheProxyHandler <T>(_implementation, CachePolicyProvider, _cache);
}
public TypeProxyKey(Type type, IProxyHandler handler, IMethodFilter filter)
{
Type = type;
Handler = handler;
Filter = filter;
//ConcurrentDictionary<TypeProxy,Type> di=new ConcurrentDictionary<TypeProxy, Type>(IEqualityComparer)
}
public static T Invoke <T>(IProxyHandler handler)
{
if (typeof(T).IsInterface)
{
return((T)Invoke(typeof(T), handler));
}
else
{
throw new Exception(string.Format("Type：{0} is not Interface ", typeof(T).Name));
}
}
/// <summary>
/// Creates a "transparent" proxy of the specified type, returning it as a ProxyObject
/// </summary>
/// <param name="t">The type to make a transparent proxy of</param>
/// <param name="id">The id to pass the proxy</param>
/// <param name="handler">The handler that will manage the proxy</param>
/// <returns>A proxy object implementing the specified interface</returns>
public static ProxyObject CreateProxy(Type t, long id, IProxyHandler handler)
{
if (!_builders.TryGetValue(t, out var builder))
{
_builders[t] = builder = (Func <long, IProxyHandler, ProxyObject>)
_create_object.MakeGenericMethod(t)
.CreateDelegate(typeof(Func <long, IProxyHandler, ProxyObject>));
}
return(builder.Invoke(id, handler));
}
internal static object Invoke(System.Type type, IProxyHandler handler)
{
if (!typeof(IProxyHandler).GetMethods().ToList().Exists(a => a.Name == "Invoke"))
{
throw new Exception(string.Format("Type：{0}, not exists Invoke Method", type.Name));
}
var methods = type.GetMethods();
var typeBuilder = CreateDynamicTypeBuilder(type);
Proxy(type, typeBuilder, methods);
return(Activator.CreateInstance(typeBuilder.CreateTypeInfo(), handler, methods));
}
/// <summary>
/// Construct a proxy object, if called directly, it does not implement the contract.
/// It is recommended you extend this class, or use ProxyGenerator to generate the proxy object
/// if you want that behavior
/// </summary>
/// <param name="contract">The contract this proxy is using.</param>
/// <param name="id">The id of the proxy object.</param>
/// <param name="handler">The handler for this object, it is responsible for relaying execution request to the real object</param>
public ProxyObject(Type contract, long id, IProxyHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
if (!handler.CheckProxy(id, contract))
{
throw new InvalidOperationException("This proxy configuration is invalid!");
}
ContractType = contract;
_handler = handler;
Id = id;
}
public ProxyBuilder(Type type, IProxyHandler handler, IMethodFilter methodFilter)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (methodFilter == null)
{
throw new ArgumentNullException("methodFilter");
}
if (type.IsAbstract)
{
throw new TypeProxyException("ProxyBuilder不支持对抽象类与接口的代理");
}
if (type.IsSealed)
{
throw new TypeProxyException("ProxyBuilder不支持有sealed修饰的类");
}
if (type.IsGenericType)
{
throw new TypeProxyException("ProxyBuilder不支持泛型类");
}
this.type = type;
this.handler = handler;
this.methodFilter = methodFilter;
TypeProxyKey key = new TypeProxyKey(type, handler, methodFilter);
Type t;
if (PROXY_TYPES.TryGetValue(key, out t))
{
className = t.FullName;
}
else
{
int id = Interlocked.Increment(ref classid);
className = GetTypeName(type).Replace('.', '_') + "_Proxy" + "_" + id.ToString().Replace('-', '_');
}
}
/// <summary>
/// 处理当前消息。
/// </summary>
protected void ProcessHandler(Type messageType, IMessage message, IProxyHandler messageHandler)
{
var @event = message as EventStream;
if (@event != null) {
messageHandler.Handle(message);
return;
}
if (_logger.IsDebugEnabled)
_logger.DebugFormat("executing a message. data:{0}",
DefaultTextSerializer.Instance.Serialize(message));
var messageHandlerType = messageHandler.GetInnerHandler().GetType();
try {
if (_handlerStore.IsHandlerInfoExist(message.Id, messageType, messageHandlerType)) {
if (_logger.IsInfoEnabled)
_logger.InfoFormat("The message has been handled. messageHandlerType:{0}, messageType:{1}, messageId:{2}",
messageHandlerType.FullName, messageType.FullName, message.Id);
return;
}
messageHandler.Handle(message);
if (_logger.IsInfoEnabled)
_logger.InfoFormat("Handle message success. messageHandlerType:{0}, messageType:{1}, messageId:{2}",
messageHandlerType.FullName, messageType.FullName, message.Id);
}
catch (Exception ex) {
if (_logger.IsErrorEnabled) {
string errorMessage = string.Format("Exception raised when {0} handling {1}. message info:{2}.",
messageHandlerType.FullName, messageType.FullName, message);
_logger.Error(errorMessage, ex);
}
throw ex;
}
finally {
_handlerStore.AddHandlerInfo(message.Id, messageType, messageHandlerType);
using (messageHandler as IDisposable) {
}
if (_logger.IsDebugEnabled)
_logger.DebugFormat("message executed. messageId:{0}", message.Id);
}
}
/// <summary>
/// 处理当前消息。
/// </summary>
protected void ProcessHandler(Type messageType, IMessage message, IProxyHandler messageHandler)
{
var messageHandlerType = messageHandler.GetInnerHandler().GetType();
try {
if (message is EventStream)
{
messageHandler.Handle(message);
}
else
{
var messageHandlerTypeCode = _typeCodeProvider.GetTypeCode(messageHandlerType);
var messageTypeCode = _typeCodeProvider.GetTypeCode(messageType);
var messageHandlerInfo = new HandlerRecordData(message.Id, messageHandlerTypeCode, messageTypeCode);
if (!_handlerStore.IsHandlerInfoExist(messageHandlerInfo))
{
messageHandler.Handle(message);
_handlerStore.AddHandlerInfo(messageHandlerInfo);
}
_logger.Debug("Handle message success. messageHandlerType:{0}, messageType:{1}, messageId:{2}",
messageHandlerType.FullName, messageType.FullName, message.Id);
}
}
catch (Exception ex) {
if (!(message is EventStream))
{
string errorMessage = string.Format("Exception raised when {0} handling {1}. message info:{2}.",
messageHandlerType.FullName, messageType.FullName, message.ToString());
_logger.Error(ex, errorMessage);
}
throw ex;
}
finally {
if (messageHandler is IDisposable)
{
((IDisposable)messageHandler).Dispose();
}
}
}
public static object GetProxyObject(Type type, IProxyHandler handler)
{
return(new ProxyBuilder(type, handler).GetProxy());
}
private static ProxyObject CreateObject <T>(long id, IProxyHandler handler) where T : class => (ProxyObject)(object)ProxyGenerator <T> .CreateProxy(id, handler);
/// <summary> /// Creates a transparent proxy of the specified type, returning it as a ProxyObject /// </summary> /// <typeparam name="T">The type to make a transparent proxy of</param> /// <param name="id">The id to pass the proxy</param> /// <param name="handler">The handler that will manage the proxy</param> /// <returns>A proxy object implementing the specified interface</returns> public static T CreateProxy <T>(long id, IProxyHandler handler) where T : class => ProxyGenerator <T> .CreateProxy(id, handler);
/// <summary>
/// Returns a proxy for the provided interface
/// </summary>
/// <typeparam name="TProxy">Type to be proxied</typeparam>
/// <param name="handler">The actual handler object that handles all the calls to the proxy.</param>
/// <param name="useProxyCache">If true, cached proxies can be reused</param>
/// <returns>
/// Proxy object
/// </returns>
/// <exception cref="System.ArgumentException">T needs to be an interface</exception>
public static TProxy GetProxy <TProxy>(IProxyHandler handler, bool useProxyCache = true)
{
var t = typeof(TProxy);
if (!t.IsInterface)
{
throw new ArgumentException("T needs to be an interface");
}
if (useProxyCache && ProxyCache.ContainsKey(t))
{
return((TProxy)ProxyCache[t]);
}
lock (LockDummy)
{
if (_assemblyBuilder == null)
{
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("CODE.Framework.Proxies"), AssemblyBuilderAccess.Run);
var assemblyName = _assemblyBuilder.GetName().Name;
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(assemblyName);
}
var typeBuilder = _moduleBuilder.DefineType(t.Name + "_CODE_Framework_Proxy_" + Guid.NewGuid().ToString().Replace("-", "_"), TypeAttributes.Class | TypeAttributes.Public, typeof(Object), new[] { t });
var proxyFieldBuilder = typeBuilder.DefineField("handler", typeof(IProxyHandler), FieldAttributes.Private);
var callRetMethod = typeof(IProxyHandler).GetMethod("OnMethod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(MethodInfo), typeof(object[]) }, null);
var constructorType = Type.GetType("System.Object");
if (constructorType != null)
{
var constructor = constructorType.GetConstructor(new Type[] { });
var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new[] { typeof(IProxyHandler) });
var cIl = constructorBuilder.GetILGenerator();
cIl.Emit(OpCodes.Ldarg_0); // Load this to stack
if (constructor != null)
{
cIl.Emit(OpCodes.Call, constructor); // Call base (object) constructor
}
cIl.Emit(OpCodes.Ldarg_0); // Load this to stack
cIl.Emit(OpCodes.Ldarg_1); // Load the IProxyHandler to stack
cIl.Emit(OpCodes.Stfld, proxyFieldBuilder); // Set proxy to the actual proxy
cIl.Emit(OpCodes.Ret);
}
// Creating all the methods on the interface
foreach (var method in t.GetMethods())
{
var mb = typeBuilder.DefineMethod(method.Name, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual, method.ReturnType, method.GetParameters().Select(pi => pi.ParameterType).ToArray());
var privateParameterCount = method.GetParameters().Length;
var il = mb.GetILGenerator();
var argArray = il.DeclareLocal(typeof(object[]));
il.Emit(OpCodes.Ldc_I4, privateParameterCount);
il.Emit(OpCodes.Newarr, typeof(object));
il.Emit(OpCodes.Stloc, argArray);
var methodInfo = il.DeclareLocal(typeof(MethodInfo));
il.Emit(OpCodes.Ldtoken, method);
il.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetMethodFromHandle", new[] { typeof(RuntimeMethodHandle) }));
il.Emit(OpCodes.Stloc, methodInfo);
for (var counter = 0; counter < privateParameterCount; counter++)
{
var info = method.GetParameters()[counter];
il.Emit(OpCodes.Ldloc, argArray);
il.Emit(OpCodes.Ldc_I4, counter);
il.Emit(OpCodes.Ldarg_S, counter + 1);
if (info.ParameterType.IsPrimitive || info.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, info.ParameterType);
}
il.Emit(OpCodes.Stelem_Ref);
}
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, proxyFieldBuilder);
il.Emit(OpCodes.Ldloc, methodInfo);
il.Emit(OpCodes.Ldloc, argArray);
il.Emit(OpCodes.Call, callRetMethod);
if (method.ReturnType.IsValueType && method.ReturnType != typeof(void))
{
il.Emit(OpCodes.Unbox_Any, method.ReturnType);
}
if (method.ReturnType == typeof(void))
{
il.Emit(OpCodes.Pop);
}
il.Emit(OpCodes.Ret);
}
var proxyType = typeBuilder.CreateType();
var proxy = Activator.CreateInstance(proxyType, new object[] { handler }, null);
if (useProxyCache)
{
ProxyCache.Add(t, proxy);
}
return((TProxy)proxy);
}
}
public object CreateBase(IProxyHandler handler)
{
return _constructor.Invoke(new object[] { _methodList, handler });
}
public ProxyBuilder(Type type, IProxyHandler handler)
: this(type, handler, new DefaultMethodFilter())
{
}
public ProxyController(IProxyHandler proxyHandler)
{
_proxyHandler = proxyHandler;
}
public BaseProxyHandler(IProxyHandler proxy)
{
_proxy = proxy;
}
public static T CreateProxy <T>(IProxyHandler handler)
{
Type instanceType = CreateType <T>();
return((T)Activator.CreateInstance(instanceType, handler));
}
