public void CacheHitInterfaceProxy() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateInterfaceProxyWithoutTarget<IEmptyInterface>(); generator.CreateInterfaceProxyWithoutTarget<IEmptyInterface>(); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.IEmptyInterfaceProxy " + "for target type Castle.DynamicProxy.Tests.LoggingTestCase+IEmptyInterface.")); }
public T Create <T>() where T : class { var generator = new ProxyGenerator(); var proxy = generator.CreateInterfaceProxyWithoutTarget <T>(new CallInterceptor(_baseUrl)); return(proxy); }
public override object BuildProxy(ProxyGenerator generator, Type objType, CommonData data, object baseObj) { if (!objType.IsInterface) { throw new Exception("Set can only be created from ISet Interface"); } object proxy; if (baseObj == null) { proxy = generator.CreateInterfaceProxyWithoutTarget(objType, new ProxyGenerationOptions(new GeneralProxyGenerationHook()) { Selector = _setSelector }, new GeneralGetInterceptor(data), new SetAddInterceptor(data), new SetRemoveInterceptor(data)); } else { proxy = generator.CreateInterfaceProxyWithTarget(objType, baseObj, new ProxyGenerationOptions(new GeneralProxyGenerationHook()) { Selector = _setSelector }, new GeneralGetInterceptor(data), new SetAddInterceptor(data), new SetRemoveInterceptor(data)); } return(proxy); }
public void Initialise(IoHandler ioHandler, string prefix) { ProxyInstance = ProxyGenerator.CreateInterfaceProxyWithoutTarget(ResultBaseType, new ConfigurationInterceptor(ResultBaseType, ioHandler, prefix)); IsInitialised = true; }
private static object ConvertReturnValue(object value, Type type) { if (value == null || value.GetType() == type) { return(value); } if (type.IsInterface) { ProxyGenerator generator = new ProxyGenerator(); return(generator.CreateInterfaceProxyWithoutTarget(type, new Wrapper(value))); } else { var result = type.GetConstructor(new Type[0]).Invoke(new object[0]); foreach (var property in value.GetType().GetProperties()) { var propertyValue = property.GetValue(value); type.GetProperties() .Where(p => CaptionsEquality(property.Name, p.Name)) .Single() .SetValue(result, propertyValue); } return(result); } }
public static void Test() { ProxyGenerator generator = new ProxyGenerator(); //采用默认的基类(Object) IPerson person = generator.CreateInterfaceProxyWithoutTarget <IPerson> (new ReadMethodInterceptor()); DisplayMessage(person); ProxyGenerator proxyGenerator = new ProxyGenerator(); ProxyGenerationOptions options = new ProxyGenerationOptions(); //改变接口对象的基类为MarshalByRefObject options.BaseTypeForInterfaceProxy = typeof(MarshalByRefObject); Console.WriteLine(); Console.WriteLine("====================================="); IPerson person1 = (IPerson)proxyGenerator.CreateInterfaceProxyWithoutTarget( typeof(IPerson), null, options, new ReadMethodInterceptor()); DisplayMessage(person1); Console.ReadLine(); }
/// <summary> /// 获取服务代理类 /// </summary> /// <param name="serviceType">服务接口类型</param> /// <returns>服务代理类</returns> public object GetService(Type serviceType) { ServiceProxyInterceptor interceptor = new ServiceProxyInterceptor(); interceptor.ServiceAgent = serviceAgent; RemoteCaller caller; if (remoteCallers.ContainsKey(serviceType)) { caller = remoteCallers[serviceType]; } else { caller = new RemoteCaller(); remoteCallers.Add(serviceType, caller); } ProxyGenerationOptions option = new ProxyGenerationOptions(); option.AddMixinInstance(caller); object proxy = generator.CreateInterfaceProxyWithoutTarget(serviceType, null, option, interceptor); return(proxy); }
public T CreateClient <T>(string serviceName) where T : class { HttpRequestInterceptor httpRequestInterceptor = new HttpRequestInterceptor(_httpClientFactory.CreateClient(serviceName)); return(_services.GetOrAdd(typeof(T).FullName, _proxyGenerator.CreateInterfaceProxyWithoutTarget <T>(httpRequestInterceptor)) as T); }
public void CacheHitInterfaceProxy() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateInterfaceProxyWithoutTarget <IEmptyInterface>(); generator.CreateInterfaceProxyWithoutTarget <IEmptyInterface>(); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.IEmptyInterfaceProxy " + "for target type Castle.DynamicProxy.Tests.LoggingTestCase+IEmptyInterface.")); }
private void ComponentContainer_NoComponentRegisted(object sender, NoComponentRegistedEventArgs e) { if (!e.ServiceType.IsInterface) { return; } IEnumerable <AttachedRuntimeInfo> matchedInfos = this.attachedImplementorInfo .Where(info => info.Attachment.CanAttach(e.ServiceType)); int count = matchedInfos.Count(); if (count == 0) { return; } if (count > 1) { throw new ApplicationException(); } var implementorType = matchedInfos.First().AttachedType; e.ComponentProvider = cm => { var implementor = (IImplementor)cm.CreateComponent(implementorType); ImplementorAttributeExecuteInterceptor interceptor = new ImplementorAttributeExecuteInterceptor(e.ServiceType, implementor); var rlt = proxyGenerator.CreateInterfaceProxyWithoutTarget( e.ServiceType, interceptor ); return(rlt); }; }
protected override void OnAfterStart() { try { _address = Constants.BaseAddress + Pid; var binding = WcfUtils.GetNetNamedPipeBinding(); var ep = new EndpointAddress(_address); var type = typeof(IRemoteVstService); var proxyCreatorType = MakeGenericType(type); var proxyCreator = GetProxyCreator(proxyCreatorType, binding, ep); var x = _generator.CreateInterfaceProxyWithoutTarget(type, new[] { typeof(IContextChannel) }, CreateInterceptor(proxyCreator, type)); _vstService = x as IRemoteVstService; _vstService.Ping(); _vstServiceAvailable = true; IsBusy = false; _pingTimer.Start(); } catch (Exception ex) { ForceStop($"Failure when attempting to open the service channel: {ex}"); } }
/// <summary> /// 创建接口代理类 /// </summary> /// <param name="type"></param> /// <returns></returns> public object CreateMicroClientProxy(Type type) { ProxyGenerator proxyGenerator = new ProxyGenerator(); object t = proxyGenerator.CreateInterfaceProxyWithoutTarget(type, new MicroClientProxy(middleService)); return(t); }
public object CreateProxyInterface(Type type) { var args = OnAgentPreparation(type); return(_proxyGenerator.CreateInterfaceProxyWithoutTarget(type, args.AdditionalInterfacesToProxy.ToArray(), args.GenerationOptions, args.Interceptors.ToArray())); }
public object Target(Type type, string url) { var clientDescriptor = new ClientDescriptor { MethodDescriptorTable = new MethodDescriptorTable(), Name = _clientName, Type = type }; foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance)) { clientDescriptor.MethodDescriptorTable.Set(type, method); var methodDescriptor = clientDescriptor.MethodDescriptorTable.Get(type, method); if (methodDescriptor.Decoder == null) { methodDescriptor.Decoder = _decoder; } if (methodDescriptor.Encoder == null) { methodDescriptor.Encoder = _encoder; } } var httpClientFactory = _services.GetRequiredService <IHttpClientFactory>(); var parameterExpanderLocator = _services.GetRequiredService <IParameterExpanderLocator>(); var goInterceptor = new FeignInterceptor(clientDescriptor, httpClientFactory, parameterExpanderLocator); var feignProxy = ProxyGenerator.CreateInterfaceProxyWithoutTarget(type, Enumerable.Empty <Type>().ToArray(), goInterceptor); return(ProxyGenerator.CreateInterfaceProxyWithTarget(type, feignProxy, new HystrixInterceptor(_clientName, type, feignProxy, _fallbackType, _services))); }
/// <summary> /// 使用WebApi动态代理客户端 /// </summary> /// <param name="service"></param> /// <param name="optionAction"></param> public static IServiceCollection AddWebApiProxy(this IServiceCollection service, Action <WebApiProxyOptions> optionAction) { AppDomain.CurrentDomain.UpdateExcutingAssemblies(); var option = new WebApiProxyOptions(); optionAction(option); foreach (var o in option.WebApiProxies) { var types = o.GetType().Assembly.GetTypes().Where(x => x.IsInterface && x.GetMethods().SelectMany(m => m.GetCustomAttributes(typeof(ApiActionAttribute), true)).Any()); foreach (var type in types) { var proxy = ProxyGenerator.CreateInterfaceProxyWithoutTarget(type, new HttpApiClient(o.BaseUrl ?? option.ProxyHost)); service.AddSingleton(type, x => proxy); } } foreach (var type in option.RegisteredServices) { if (type.Value.IsInterface) { var proxy = ProxyGenerator.CreateInterfaceProxyWithoutTarget(type.Value, new HttpApiClient(type.Key ?? option.ProxyHost)); service.AddSingleton(type.Value, x => proxy); } } return(service); }
public void InitialiseAt(int index, IoHandler ioHandler, string prefix) { object instance = ProxyGenerator.CreateInterfaceProxyWithoutTarget(ResultBaseType, new InterfaceInterceptor(ResultBaseType, ioHandler, prefix)); _indexToProxyInstance[index] = instance; }
public IWampClientProxy <TMessage> Create(IMessagePlayer <TMessage> player, IMessageRecorder <TMessage> recorder, WampMessage <TMessage> welcomeMessage) { ProxyGenerationOptions options = new ProxyGenerationOptions(); options.Selector = new MockClientInterceptorSelector(); IWampFormatter <TMessage> formatter = mBinding.Formatter; long sessionId = formatter.Deserialize <long>(welcomeMessage.Arguments[0]); WelcomeDetails welcomeDetails = formatter.Deserialize <WelcomeDetails>(welcomeMessage.Arguments[1]); IWampClientProxy <TMessage> result = mGenerator.CreateInterfaceProxyWithoutTarget (typeof(IWampClientProxy), new[] { typeof(IWampClientProxy <TMessage>), typeof(IWampConnectionMonitor) }, options, new RecordAndPlayRawInterceptor <TMessage>(player, recorder, mBinding), new RecordAndPlayInterceptor <TMessage> (mOutgoingSerializer, player, recorder, mBinding), new SessionPropertyInterceptor(sessionId), new WelcomeDetailsInterceptor(welcomeDetails)) as IWampClientProxy <TMessage>; return(result); }
public void Test1() { var proxyGen = new ProxyGenerator(); var client = new WebApiClient(); client.BaseUrl = "http://localhost:28180/api/ilogger/"; var i = new TestInterfaceInterceptor(client); var p = proxyGen.CreateInterfaceProxyWithoutTarget <ILogger>(i); var result = p.Log("Hello"); var t = p.LogAsync("AsyncErrorMessage"); t.Wait(); var asyncResult = t.Result; Task.Run(() => p.LogAsync("Async Error Message").GetAwaiter().GetResult()).GetAwaiter().GetResult(); p.LogError("Error Message"); p.LogException(new Exception("Test Exception")); p.LogException("Test Exception Message"); p.LogException(new Exception("Test Exception"), "Test Exception Message"); p.LogWarning("Test Warning"); }
/// <summary> /// 注入自定义消息总线 /// 注:可以通过此方法注入多个总线 /// </summary> /// <typeparam name="TMessageBus">自定义总线类型</typeparam> /// <param name="services">服务容器</param> /// <param name="options">配置</param> /// <returns></returns> public static IServiceCollection AddMessageBus <TMessageBus>(this IServiceCollection services, MessageBusOptions options) where TMessageBus : class, IMessageBus { if (!typeof(TMessageBus).IsPublic) { throw new Exception($"{typeof(TMessageBus).FullName}必须公开"); } services.AddHostedService <MessageBusBootstraper>(); MessageBusBootstraper.Bootstrap += serviceProvider => serviceProvider.GetService <TMessageBus>(); return(services.AddSingleton(serviceProvider => { var busInstance = MessageBusFactory.GetBusInstance(serviceProvider, options); if (typeof(TMessageBus) == typeof(IMessageBus)) { return (TMessageBus)busInstance; } else { return Generator.CreateInterfaceProxyWithoutTarget <TMessageBus>(new ActLikeInterceptor(busInstance)); } })); }
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs) { if (typesToMock == null) { throw new ArgumentNullException("typesToMock"); } Type primaryType = typesToMock.PrimaryType; Type[] additionalInterfaces = BuildAdditionalTypeArrayForProxyType(typesToMock); IInterceptor mockInterceptor = new MockObjectInterceptor(mockFactory, typesToMock, name, mockStyle); object result; if (primaryType.IsInterface) { result = generator.CreateInterfaceProxyWithoutTarget(primaryType, additionalInterfaces, new ProxyGenerationOptions { BaseTypeForInterfaceProxy = typeof(InterfaceMockBase) }, mockInterceptor); ((InterfaceMockBase)result).Name = name; } else { result = generator.CreateClassProxy(primaryType, additionalInterfaces, ProxyGenerationOptions.Default, constructorArgs, mockInterceptor); //return generator.CreateClassProxy(primaryType, new []{typeof(IMockObject)}, mockInterceptor); } return(result); }
public static object Generate <TInterface>(object obj34) where TInterface : class { // var obj = _proxyGenerator.CreateInterfaceProxyWithoutTarget<TInterface>(new Interceptor()); var obj = _proxyGenerator.CreateInterfaceProxyWithoutTarget(typeof(TInterface), new Interceptor()); return(obj); }
private object CreateState(ProxyGenerator proxyGenerator) { return(proxyGenerator.CreateInterfaceProxyWithoutTarget( _composite.Mapping.State, _composite.Extensions.Select(e => e.State).ToArray(), new StateInterceptor())); }
/// <summary> /// Executes the specified args. /// </summary> /// <param name="args">The args.</param> public void Execute(ObjectConstructionArgs args) { if (args.Result == null && args.Configuration.Type.IsInterface) { args.Result = _generator.CreateInterfaceProxyWithoutTarget(args.Configuration.Type, new InterfacePropertyInterceptor(args)); } }
private void CreateProxy(IInvocation invocation, PathAttribute pathAttribute) { var routePath = GetRoutePath(invocation, Path, pathAttribute.Path); var proxy = _proxyGenerator.CreateInterfaceProxyWithoutTarget(invocation.Method.ReturnType, new Interceptor(_httpClient, _proxyGenerator, routePath)); invocation.ReturnValue = proxy; }
private static TFactory CreateFactory <TFactory>(IServiceProvider serviceProvider) where TFactory : class { var generator = new ProxyGenerator(); return(generator.CreateInterfaceProxyWithoutTarget <TFactory>( new FactoryInterceptor(serviceProvider))); }
public object CreateMock(Type mockType) { var interceptor = new MockInterceptor(invocationDescriptorFactory, invocationTransformer, invocationStage, invocationOperationManagerFinder); var mock = proxyGenerator.CreateInterfaceProxyWithoutTarget(mockType, interceptor); interceptor.SetMock(mockType, mock); return(mock); }
public TPluginType Create() { var container = _context.GetInstance <IContainer>(); var interceptor = new FactoryInterceptor(container, _conventionProvider); return(_proxyGenerator.CreateInterfaceProxyWithoutTarget <TPluginType>(interceptor)); }
public TSettings Build <TSettings>() where TSettings : class { var interceptors = _interceptors.ToArray(); var proxy = _generator.CreateInterfaceProxyWithoutTarget <TSettings>(interceptors); return(proxy); }
protected T CreateProxy <T>([NotNull] Func <HttpWebRequest> requestFactory) where T : class { var interceptor = new HttpRpcClientInterceptor(requestFactory); var proxy = _proxyGenerator.CreateInterfaceProxyWithoutTarget <T>(interceptor); return(proxy); }
public static T WrapAs <T>(Delegate impl) where T : class { var generator = new ProxyGenerator(); var interceptor = new MethodInterceptor(impl); var proxy = generator.CreateInterfaceProxyWithoutTarget <T>(interceptor); return(proxy); }
/// <summary> /// Creates an instance of the configuration interface /// </summary> /// <returns></returns> public T Build() { var handler = new IoHandler(_stores, _cacheInterval); T instance = _generator.CreateInterfaceProxyWithoutTarget <T>(new ConfigurationInterceptor <T>(handler)); return(instance); }
public void CanCreateInterfaceProxy() { var proxyGenerator = new ProxyGenerator(); proxyGenerator.CreateInterfaceProxyWithoutTarget<InterfaceWithMethodsWithAllKindsOfOptionalParameters>(); }
private object BuildFor(Type gatewayInterfaceType, IInterceptor interceptor) { var generator = new ProxyGenerator(); var proxy = generator.CreateInterfaceProxyWithoutTarget(gatewayInterfaceType, interceptor); return proxy; }