public object CreateProxy(IMappedStatement selectStatement, object param, object target, ISetAccessor setAccessor) { Type memberType = setAccessor.MemberType; if (_logger.IsDebugEnabled) { _logger.Debug(string.Format("Statement '{0}', create proxy for member {1}.", selectStatement.Id, setAccessor.MemberType)); } IInterceptor interceptor = new LazyLoadInterceptor(selectStatement, param, target, setAccessor); return(ProxyGeneratorFactory.GetProxyGenerator().CreateClassProxy(memberType, interceptor, Type.EmptyTypes)); }
/// <summary> /// Builds the specified lazy load proxy for a concrete class with virtual method. /// </summary> /// <param name="selectStatement">The mapped statement used to build the lazy loaded object.</param> /// <param name="param">The parameter object used to build lazy loaded object.</param> /// <param name="target">The target object which contains the property proxydied..</param> /// <param name="setAccessor">The proxified member accessor.</param> /// <returns>Return a proxy object</returns> public object CreateProxy(IMappedStatement selectStatement, object param, object target, ISetAccessor setAccessor) { Type typeProxified = setAccessor.MemberType; if (_logger.IsDebugEnabled) { _logger.Debug(string.Format("Statement '{0}', create proxy for member {1}.", selectStatement.Id, setAccessor.MemberType)); } // Build the proxy IInterceptor handler = new LazyLoadInterceptor(selectStatement, param, target, setAccessor); // if you want to proxy concrete classes, there are also 2 main requirements : // the class can not be sealed and only virtual methods can be intercepted. // The reason is that DynamicProxy will create a subclass of your class overriding all methods // so it can dispatch the invocations to the interceptor. // The proxified type must also have an empty constructor object proxy = ProxyGeneratorFactory.GetProxyGenerator().CreateClassProxy(typeProxified, handler, Type.EmptyTypes); return proxy; }
/// <summary> /// Builds the specified lazy load proxy for a concrete class with virtual method. /// </summary> /// <param name="selectStatement">The mapped statement used to build the lazy loaded object.</param> /// <param name="param">The parameter object used to build lazy loaded object.</param> /// <param name="target">The target object which contains the property proxydied..</param> /// <param name="setAccessor">The proxified member accessor.</param> /// <returns>Return a proxy object</returns> public object CreateProxy(IMappedStatement selectStatement, object param, object target, ISetAccessor setAccessor) { Type typeProxified = setAccessor.MemberType; if (_logger.IsDebugEnabled) { _logger.Debug(string.Format("Statement '{0}', create proxy for member {1}.", selectStatement.Id, setAccessor.MemberType)); } // Build the proxy IInterceptor handler = new LazyLoadInterceptor(selectStatement, param, target, setAccessor); // if you want to proxy concrete classes, there are also 2 main requirements : // the class can not be sealed and only virtual methods can be intercepted. // The reason is that DynamicProxy will create a subclass of your class overriding all methods // so it can dispatch the invocations to the interceptor. // The proxified type must also have an empty constructor object proxy = ProxyGeneratorFactory.GetProxyGenerator().CreateClassProxy(typeProxified, handler, Type.EmptyTypes); return(proxy); }