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)); }