/// <summary> /// Intercepts an exported value. /// </summary> /// <param name="value">The value to be intercepted.</param> /// <returns>Intercepted value.</returns> public object Intercept(object value) { var interfaces = value.GetType().GetInterfaces(); ProxyFactory factory = new ProxyFactory(value); foreach (var intf in interfaces) { factory.AddInterface(intf); } if (this.advices != null) { foreach (var advice in this.advices) { factory.AddAdvice(advice); } } else { foreach (var advisor in this.advisors) { factory.AddAdvisor(advisor); } } return factory.GetProxy(); }
public void Should_create_a_non_target_proxy_using_a_delegate() { Func<IMethodInvocation, object> del = delegate(IMethodInvocation mi) { return "ack"; }; var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<Goo>(del); Assert.Equal("ack", proxy.Go()); }
protected ProxyObjectReference(SerializationInfo info, StreamingContext context) { // Deserialize the base type using its assembly qualified name string qualifiedName = info.GetString("__baseType"); _baseType = Type.GetType(qualifiedName, true, false); // Rebuild the list of interfaces List<Type> interfaceList = new List<Type>(); int interfaceCount = info.GetInt32("__baseInterfaceCount"); for(int i = 0; i < interfaceCount; i++) { string keyName = string.Format("__baseInterface{0}", i); string currentQualifiedName = info.GetString(keyName); Type interfaceType = Type.GetType(currentQualifiedName, true, false); interfaceList.Add(interfaceType); } // Reconstruct the proxy ProxyFactory factory = new ProxyFactory(); Type proxyType = factory.CreateProxyType(_baseType, interfaceList.ToArray()); // Initialize the proxy with the deserialized data object[] args = new object[] { info, context }; _proxy = (IProxy)Activator.CreateInstance(proxyType, args); }
public void Should_create_a_non_target_proxy_using_an_anonymous_method() { Func<IMethodInvocation, object> del = mi => "ack"; var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<IFoo>( del ); Assert.Equal("ack", proxy.Go()); }
public void Should_create_a_proxy_using_a_target_object_and_a_lambda() { var target = new Goo(); var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create(target, mi => mi.Method.Invoke(mi.Target, mi.Arguments)); Assert.Equal("ack", proxy.Go()); }
public void ProxyFactoryConstructorTest() { ITest test = ProxyFactory.CreateProxy<ITest>(typeof(RTest)); object aaa = test.Test(); ProxyFactory target = new ProxyFactory(); Assert.Inconclusive("TODO: 实现用来验证目标的代码"); }
/*----------------------------------------------------------------------------------------*/ #region Disposal /// <summary> /// Releases all resources held by the object. /// </summary> /// <param name="disposing"><see langword="True"/> if managed objects should be disposed, otherwise <see langword="false"/>.</param> protected override void Dispose(bool disposing) { if (disposing && !IsDisposed) _factory = null; base.Dispose(disposing); }
public void Should_create_a_non_target_proxy_using_a_generic_type_and_an_interceptor() { var interceptor = new ReturnValueInterceptor("ack"); var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<Goo>(interceptor); Assert.Equal("ack", proxy.Go()); }
public void Should_create_a_proxy_using_a_lambda() { var target = new Foo(); var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<IFoo>(mi => target.Go()); //-> non-reflective call Assert.Equal("ack", proxy.Go()); }
public void Test() { var proxyFactory = new ProxyFactory(); var advisedFoo = proxyFactory.Create<IFoo>(new Foo(), new BarAdvice()); advisedFoo.Bar(); }
public void Should_create_a_non_target_proxy_using_a_lambda_and_a_list_of_types_to_implement() { var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<IFoo>(mi => "ack", new[] { typeof(IDisposable), typeof(ICloneable) }); Assert.Equal("ack", proxy.Go()); Assert.True(typeof(IDisposable).IsAssignableFrom(proxy.GetType())); Assert.True(typeof(ICloneable).IsAssignableFrom(proxy.GetType())); }
public void Should_create_a_proxy_using_a_target_object_and_an_interceptor() { var interceptor = new ForwardExecutionInterceptor(); var target = new Goo(); var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create(target, interceptor); Assert.Equal("ack", proxy.Go()); }
public void TargetImplementsAnInterface() { ProxyFactory advisedSupport = new ProxyFactory(new TestObject()); IAopProxy aopProxy = CreateAopProxy(advisedSupport); Assert.IsNotNull(aopProxy); Assert.IsTrue(AopUtils.IsCompositionAopProxy(aopProxy)); }
public void LazyFieldInterceptorIsBinarySerializable() { var pf = new ProxyFactory(); var propertyInfo = typeof(MyClass).GetProperty("Id"); pf.PostInstantiate("MyClass", typeof(MyClass), new HashedSet<System.Type>(), propertyInfo.GetGetMethod(), propertyInfo.GetSetMethod(), null); var fieldInterceptionProxy = (IFieldInterceptorAccessor)pf.GetFieldInterceptionProxy(new MyClass()); fieldInterceptionProxy.FieldInterceptor = new DefaultFieldInterceptor(null, null, null, "MyClass", typeof(MyClass)); fieldInterceptionProxy.Should().Be.BinarySerializable(); }
public void Should_catch_an_exception_and_run_a_callback_before_and_after_the_exception_is_rethrown() { int ack = 0; var target = new Foo(); var interceptor = new OnCatchAndOnFinallyInterceptor{ Action = ()=> { Assert.True(target.Executed); ++ack; } }; var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<IFoo>(target, interceptor); Assert.Throws<InvalidOperationException>(() => proxy.Fail()); Assert.Equal(2, ack); }
public void Should_replace_target_execution_result() { var target = new Foo(); var interceptor = new OnReturnInterceptor("ack"); var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<IFoo>(target, interceptor); proxy.Go(); Assert.Equal("ack", proxy.Go()); Assert.True(target.Executed); }
public void Should_run_a_callback_after_target_execution() { bool ack = false; var target = new Foo(); var interceptor = new OnAfterInterceptor{ Action = ()=> { Assert.True(target.Executed); ack = true; } }; var factory = new ProxyFactory(AppConfig.ProxyBehavior); var proxy = factory.Create<IFoo>(target, interceptor); proxy.Go(); Assert.True(ack); }
public void IsDecoratorProxy() { var pf = new ProxyFactory(new DebugAdvice()); pf.Target = _target; pf.ProxyTargetType = true; var proxy = (TestObject)pf.GetProxy(); Assert.True(AopUtils.IsDecoratorAopProxy(proxy)); Assert.True(AopUtils.IsAopProxy(proxy)); }
public void TargetImplementsAnInterfaceWithProxyTargetTypeSetToTrue() { ProxyFactory advisedSupport = new ProxyFactory(); advisedSupport.ProxyTargetType = true; advisedSupport.Target = new TestObject(); IAopProxy aopProxy = CreateAopProxy(advisedSupport); Assert.IsNotNull(aopProxy); Assert.IsTrue(AopUtils.IsDecoratorAopProxy(aopProxy)); }
public void DoesNotCacheWithDifferentTargetType() { ProxyFactory advisedSupport = new ProxyFactory(new BadCommand()); CreateAopProxy(advisedSupport); advisedSupport = new ProxyFactory(new GoodCommand()); CreateAopProxy(advisedSupport); AssertAopProxyTypeCacheCount(2); }
public void when_proxy_factory_invoked_then_gets_implementation_of_interface() { var factory = new ProxyFactory(); var mock = new TestMock(); var proxy = factory.CreateProxy(mock, typeof(ICalculator)); Assert.NotNull(proxy); Assert.True(proxy is ICalculator); }
public void Spring_behavior_does_not_support_non_target_proxies_on_types_without_a_default_constructor() { var expected = "ack"; var spring = new ProxyFactory(ProxyBehavior.Spring); Assert.Throws<InvalidOperationException>(()=> spring.Create<Hoo>(mi => expected).Name); // linfu does... var linfu = new ProxyFactory(ProxyBehavior.LinFu); Assert.Same(expected, linfu.Create<Hoo>(mi => expected).Name); }
public void Example_of_how_to_create_an_interface_proxy_implementign_IInterceptor() { var target = new Foo(); var interceptor = new IInterceptorImpl(); var factory = new ProxyFactory(ProxyBehavior.Castle); var foo = factory.Create<IFoo>(target, interceptor); foo.Go("SLC"); foo.Go("SLC", "MEX"); Assert.Throws<ArgumentNullException>(() => foo.Go("SLC", null)); }
private object InitExternalContext() { string providerDirectory = GetProviderDirectory(); _request.Verbose("Loading Zero Install OneGet provider from {0}", providerDirectory); var assembly = Assembly.LoadFrom(Path.Combine(providerDirectory, "ZeroInstall.OneGet.dll")); var requestType = assembly.GetType("PackageManagement.Sdk.Request", throwOnError: true); object requestProxy = new ProxyFactory().CreateProxy(requestType, new RequestInterceptor(_request)); var contextType = assembly.GetType("ZeroInstall.OneGet.OneGetContext", throwOnError: true); return Activator.CreateInstance(contextType, requestProxy); }
public void when_proxy_instance_called_then_can_retrieve_mock_from_invocation() { var factory = new ProxyFactory(); var mock = new TestMock(defaultValue: 15); var proxy = (ICalculator)factory.CreateProxy(mock, typeof(ICalculator)); proxy.Add(5, 10); Assert.Same(mock, mock.LastCall.Mock); }
public void when_proxy_instance_called_then_can_retrieve_invocation_method() { var factory = new ProxyFactory(); var mock = new TestMock(defaultValue: 10); var proxy = (ICalculator)factory.CreateProxy(mock, typeof(ICalculator)); proxy.Add(5, 5); Assert.Equal(typeof(ICalculator).GetMethod("Add"), mock.LastCall.Method); }
public void when_proxy_instance_called_then_calls_back_into_mock_behavior() { var factory = new ProxyFactory(); var mock = new TestMock(defaultValue: 10); var proxy = (ICalculator)factory.CreateProxy(mock, typeof(ICalculator)); proxy.Add(5, 5); Assert.NotNull(mock.LastCall); }
public void TargetDoesNotImplementAnyInterfaces() { ProxyFactory advisedSupport = new ProxyFactory(); advisedSupport.AopProxyFactory = new DefaultAopProxyFactory(); advisedSupport.ProxyTargetType = false; advisedSupport.Target = new DoesNotImplementAnyInterfacesTestObject(); IAopProxy aopProxy = CreateAopProxy(advisedSupport); Assert.IsNotNull(aopProxy); Assert.IsTrue(AopUtils.IsDecoratorAopProxy(aopProxy)); }
public void DoesNotCacheWithDifferentProxyTargetAttributes() { ProxyFactory advisedSupport = new ProxyFactory(new GoodCommand()); advisedSupport.ProxyTargetAttributes = true; CreateAopProxy(advisedSupport); advisedSupport = new ProxyFactory(new GoodCommand()); advisedSupport.ProxyTargetAttributes = false; CreateAopProxy(advisedSupport); AssertAopProxyTypeCacheCount(2); }
public void when_proxy_instance_called_then_can_retrieve_invocation_arguments() { var factory = new ProxyFactory(); var mock = new TestMock(defaultValue: 15); var proxy = (ICalculator)factory.CreateProxy(mock, typeof(ICalculator)); proxy.Add(5, 10); Assert.Equal(5, (int)mock.LastCall.Arguments[0]); Assert.Equal(10, (int)mock.LastCall.Arguments[1]); }
public void AdviceShouldBeCalledWhenPointcutSaysSo() { //Arrange var config = new TestBaseConfiguration(); var mockedAdvice = new Mock <IAdvice>(); config.Add(mockedAdvice.Object, new AlwaysApplyAdvice()); var proxied = ProxyFactory.Create <ITestInterface>(new TestClass(), config); //Act proxied.Foo(); //Assert mockedAdvice.Verify(x => x.ApplyAdvice(It.IsAny <IInvocation>()), Times.Once()); }
public void DontCreateProxyWhenNoAdvicesCanBeApplied() { //Arrange var instance = new TestClass(); var config = new TestBaseConfiguration(); var advice = new TestAdvice(); config.Add(advice, new NeverApplyAdvice()); //Act var proxied = ProxyFactory.Create(instance, config); //Assert Assert.AreEqual(instance, proxied); }
public void DoesNotCacheWithDifferentBaseType() { // Decorated-based proxy (BaseType == TargetType) ProxyFactory advisedSupport = new ProxyFactory(new TestObject()); advisedSupport.ProxyTargetType = true; CreateAopProxy(advisedSupport); // Composition-based proxy (BaseType = BaseCompositionAopProxy) advisedSupport = new ProxyFactory(new TestObject()); advisedSupport.ProxyTargetType = false; CreateAopProxy(advisedSupport); AssertAopProxyTypeCacheCount(2); }
private static void Around() { ProxyFactory factory = new ProxyFactory(new OrderService() { UserName = "******" }); factory.AddAdvice(new AroundAdvise()); IOrderService service = (IOrderService)factory.GetProxy(); object result = service.Save(1); Console.WriteLine(result); Console.ReadLine(); }
/// <summary> /// Gets the proxy by applying throw advices. /// /// </summary> /// <param name="target"></param> /// <returns></returns> public static object GetProxy(object target) { try { ProxyFactory proxyFactory = new ProxyFactory(target); DefaultPointcutAdvisor exceptionHandlingAdvisor = new DefaultPointcutAdvisor(aASAExceptionAdvice); proxyFactory.AddAdvisor(exceptionHandlingAdvisor); return(proxyFactory.GetProxy()); } catch (Exception ex) { return(new ASAException("ASAExceptionAdvice failed " + ex.Message)); } }
/// <summary>Creates a clone of this proxy, with a new identity and optionally other options. The clone /// is identical to this proxy except for its identity and other options set through parameters.</summary> /// <param name="prx">The source proxy.</param> /// <param name="identity">The identity of the clone.</param> /// <param name="factory">The proxy factory used to manufacture the clone.</param> /// <param name="adapterId">The adapter ID of the clone (optional).</param> /// <param name="cacheConnection">Determines whether or not the clone caches its connection (optional).</param> /// <param name="clearLocator">When set to true, the clone does not have an associated locator proxy (optional). /// </param> /// <param name="clearRouter">When set to true, the clone does not have an associated router proxy (optional). /// </param> /// <param name="compress">Determines whether or not the clone compresses requests (optional).</param> /// <param name="connectionId">The connection ID of the clone (optional).</param> /// <param name="connectionTimeout">The connection timeout of the clone (optional).</param> /// <param name="context">The context of the clone (optional).</param> /// <param name="encoding">The encoding of the clone (optional).</param> /// <param name="endpointSelection">The encoding selection policy of the clone (optional).</param> /// <param name="endpoints">The endpoints of the clone (optional).</param> /// <param name="facet">The facet of the clone (optional).</param> /// <param name="fixedConnection">The connection of the clone (optional). When specified, the clone is a fixed /// proxy. You can clone a non-fixed proxy into a fixed proxy but not vice-versa.</param> /// <param name="invocationMode">The invocation mode of the clone (optional).</param> /// <param name="invocationTimeout">The invocation timeout of the clone (optional).</param> /// <param name="locator">The locator proxy of the clone (optional).</param> /// <param name="locatorCacheTimeout">The locator cache timeout of the clone (optional).</param> /// <param name="oneway">Determines whether the clone is oneway or twoway (optional). This is a simplified /// version of the invocationMode parameter.</param> /// <param name="preferNonSecure">Determines whether the clone prefers non-secure connections over secure /// connections (optional).</param> /// <param name="protocol">The Ice protocol of the clone (optional).</param> /// <param name="router">The router proxy of the clone (optional).</param> /// <returns>A new proxy manufactured by the proxy factory (see factory parameter).</returns> public static T Clone <T>(this IObjectPrx prx, Identity identity, ProxyFactory <T> factory, string?adapterId = null, bool?cacheConnection = null, bool clearLocator = false, bool clearRouter = false, bool?compress = null, string?connectionId = null, int?connectionTimeout = null, IReadOnlyDictionary <string, string>?context = null, Encoding?encoding = null, EndpointSelectionType?endpointSelection = null, IEnumerable <Endpoint>?endpoints = null, string?facet = null, Connection?fixedConnection = null, InvocationMode?invocationMode = null, int?invocationTimeout = null, ILocatorPrx?locator = null, TimeSpan?locatorCacheTimeout = null, bool?oneway = null, bool?preferNonSecure = null, Protocol?protocol = null, IRouterPrx?router = null) where T : class, IObjectPrx { return(factory(prx.IceReference.Clone(adapterId, cacheConnection, clearLocator, clearRouter, compress, connectionId, connectionTimeout, context, encoding, endpointSelection, endpoints, facet, fixedConnection, identity, invocationMode, invocationTimeout, locator, locatorCacheTimeout, oneway, preferNonSecure, protocol, router))); }
public bool Open(string registrationServerNameOrAddress, int registrationServerPort, int listenerPort) { if (_host == null) { try { //Open a connection to the registration server var addressList = Dns.GetHostEntry(registrationServerNameOrAddress).AddressList; IPAddress address = null; foreach (var a in addressList) { if (a.AddressFamily == AddressFamily.InterNetwork) { address = a; break; } } var registrationServerEndPoint = new IPEndPoint(address, registrationServerPort); _registrationServerProxy = ProxyFactory.CreateProxy <IRegistrationServer>(registrationServerEndPoint); //get node hosts that are already registered _remoteHosts.Clear(); var remoteHostEndPoints = _registrationServerProxy.GetAllHostEndPoints(); foreach (var remoteHostEndPoint in remoteHostEndPoints) { INodeHost remoteHost = ProxyFactory.CreateProxy <INodeHost>(remoteHostEndPoint); _remoteHosts.Add(remoteHost.GetId(), remoteHost); } //open the host that contains this node _host = new ServiceHost(this, listenerPort); _host.Open(); //Register the host with the registration server. This causes all other registered nodes to connect to this one _registrationServerProxy.RegisterHost(_host.EndPoint); return(true); } catch (Exception ex) { string msg = ex.InnerException != null ? ex.InnerException.Message : ex.Message; Log.Error("Could not connect to registration server. Message reads : {0}", msg); } } return(false); }
public void ShouldCacheProxyTypes() { var factory = new ProxyFactory(); Type baseType = typeof(ISampleService); Type proxyType = factory.CreateProxyType(baseType, new Type[0]); int runCount = 10; // All subsequent results must return the same proxy type for (int i = 0; i < runCount; i++) { Type currentType = factory.CreateProxyType(baseType, new Type[0]); Assert.AreEqual(proxyType, currentType); Assert.AreSame(proxyType, currentType); } }
public UnitTestRunReportingListener(string testReportHost, int port = 80, ILogger logger = null) { Logger = logger ?? Log.Default; ProxyFactory proxyFactory = new ProxyFactory(); HashSet <Assembly> reference = new HashSet <Assembly>() { typeof(TestMethod).Assembly, typeof(ConsoleMethod).Assembly }; TestReportService = proxyFactory.GetProxy <TestReportService>(testReportHost, port, reference); TestReportHost = testReportHost; _testSuiteExecutionLookupByTitle = new ConcurrentDictionary <string, TestSuiteExecutionSummary>(); _testSuiteDefinitionLookupByTitle = new ConcurrentDictionary <string, TestSuiteDefinition>(); _testDefinitionLookupByTitle = new ConcurrentDictionary <string, TestDefinition>(); _testExecutionLookupByMethodInfo = new ConcurrentDictionary <MethodInfo, TestExecution>(); }
protected override IInventorRepository CreateInventorStore() { Region region = CreateRegion(); cache = new GemFireCache(region); context.ObjectFactory.RegisterSingleton("inventors", cache); ProxyFactory pf = new ProxyFactory(new InventorRepository()); pf.AddAdvisors(cacheAspect); Repository = (IInventorRepository)pf.GetProxy(); return(Repository); }
public void UriOverride_Basic() { string uri = "http://localhost/urioverride"; using (var host = new ServiceHost(typeof(UriOverride), new Uri(uri))) { host.AddServiceEndpoint(typeof(IUriOverride), new WS2007HttpBinding(SecurityMode.None), uri); host.Open(); var factory = new ProxyFactory(); factory.AddEndpointAddressOverride <IUriOverride>(new Uri(uri)); var proxy = factory.Proxy <IUriOverride>(); Assert.AreEqual("test", proxy.TestMe("test")); } }
public void TimeoutTest() { string uri = "http://localhost:9595/timeouttest"; using (var host = new ServiceHost(typeof(TimeoutTest), new Uri(uri))) { host.AddServiceEndpoint(typeof(ITimeoutTest), new WS2007HttpBinding(SecurityMode.None), uri); host.Open(); var factory = new ProxyFactory(); var proxy = factory.Proxy <ITimeoutTest>(); Assert.AreEqual("hi", proxy.TestMe()); } }
private void Dispatch <RECORD, REPORT>(RecordType type, ProxyFactory <REPORT> factory, RECORD record, RecordCheck <RECORD, REPORT> checker) where RECORD : Org.Neo4j.Kernel.impl.store.record.AbstractBaseRecord where REPORT : ConsistencyReport { ReportInvocationHandler <RECORD, REPORT> handler = new ReportHandler <RECORD, REPORT>(_report, factory, type, _records, record, _monitor); try { checker.Check(record, handler, _records); } catch (Exception e) { // This is a rare event and exposing the stack trace is a good idea, otherwise we // can only see that something went wrong, not at all what. handler.ReportConflict.error(type, record, "Failed to check record: " + stringify(e), new object[0]); } handler.UpdateSummary(); }
public static object GetProxy(object target) { ProxyFactory factory = GetFactory(target); object proxy = factory.GetProxy(); if (target is ProxyTypeObject) { // step 2: // hack: hook handlers ... var targetAsProxyTypeObject = (ProxyTypeObject)target; var proxyAsProxyTypeObject = (ProxyTypeObject)proxy; HookHandlers(targetAsProxyTypeObject, proxyAsProxyTypeObject); } return(proxy); }
public void Test() { ICommand target = new BusinessCommand(); ProxyFactory factory = new ProxyFactory(target); factory.AddAdvice(new ConsoleLoggingAroundAdvice()); object obj = factory.GetProxy(); ICommand business = (ICommand)obj; Console.WriteLine(obj.GetType().ToString()); //ICommand command = (ICommand)factory.GetProxy(); business.Execute("tyb"); target.Execute("This is the argument"); }
public void Hosted_HTTP() { string uri = "http://localhost/servicehelpers"; using (var host = new ServiceHost(typeof(ExternalService), new Uri(uri))) { host.AddServiceEndpoint(typeof(IExternalService), new WS2007HttpBinding(), uri); host.Open(); var factory = new ProxyFactory(); factory.Call <IExternalService>(call => { Assert.AreEqual("hi", call.TestMe("hi")); }); } }
public void Hosted_TCP() { string uri = "net.tcp://localhost:10095/servicehelpersTCP"; using (var host = new ServiceHost(typeof(ExternalServiceTcp), new Uri(uri))) { host.AddServiceEndpoint(typeof(IExternalServiceTcp), new NetTcpBinding(), uri); host.Open(); var factory = new ProxyFactory(); factory.Call <IExternalServiceTcp>(call => { Assert.AreEqual("hi", call.TestMe("hi")); }); } }
async void OnCancelReservation() { var proxy = ProxyFactory.GetProxyInstace(); var response = await proxy.ExecuteAsync(API.Endpoints.ReservationsEndpoints.CancelReservation(reservation.Id)); if (response.Successful) { OnCancelled?.Invoke(this, reservation); Toast.MakeText(this, "Reservation cancelled successfully!", ToastLength.Short).Show(); Finish(); } else { Toast.MakeText(this, "Failed cancelling reservation", ToastLength.Short).Show(); } }
static void Main(string[] args) { //Person p=new Person(); // p.Pen=new Pen(); // p.Write(); ProxyFactory proxy = new ProxyFactory(new Pen()); //proxy.AddAdvice(new BeforeAdvice()); proxy.AddAdvice(new AroundAdvice()); IWrite p = proxy.GetProxy() as IWrite; p.Write(); Console.ReadKey(); }
static void Main() { TestInterceptor interceptor = new TestInterceptor(new TestClass()); ProxyFactory factory = new ProxyFactory(); TestClass test = factory.CreateProxy <TestClass>(interceptor); // Turn it back on and replace // the method call with the one // in the interceptor Console.Write("Interception On: "); test.DoSomething(); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); }
private void SubscribeOnEmailService() { ProxyFactory proxyFactory = new ProxyFactory(); this.subscriberProxy = proxyFactory.CreateProxy <SubscriberProxy, ISubscriber>(callTracker, EndpointNames.SubscriberEndpoint); if (subscriberProxy == null) { string message = "SubscribeOnEmailService() => SubscriberProxy is null."; Logger.LogError(message); throw new NullReferenceException(message); } subscriberProxy.Subscribe(Topic.OUTAGE_EMAIL); Logger.LogDebug("Successfully subscribed to Email Service messages."); }
private static void Test(ProxyFactory <ITestInterface> factory) { var proxyOfTestClass = factory.GenerateProxy(new TestClass()); Console.WriteLine(proxyOfTestClass.GetCalls()); // 0 proxyOfTestClass.Sleep1s(); proxyOfTestClass.Sleep2s(); Console.WriteLine(proxyOfTestClass.GetCalls()); // 2 proxyOfTestClass.Sleep1s(); proxyOfTestClass.Sleep2s(); Console.WriteLine(proxyOfTestClass.GetCalls()); // Still 2 Thread.Sleep(5000); proxyOfTestClass.Sleep1s(); proxyOfTestClass.Sleep2s(); Console.WriteLine(proxyOfTestClass.GetCalls()); // 4 }
public void InterceptInterfaceVirtualMethod() { ProxyFactory factory = new ProxyFactory(); NopInterceptor interceptor = new NopInterceptor(new ProxyTestClass("test", 0)); object proxy = factory.CreateProxy(typeof(ProxyTestClass), interceptor); Assert.IsTrue(proxy is IProxy); Assert.IsTrue(proxy is IProxyTest); Assert.IsTrue(proxy is ProxyTestClass); IProxyTest proxyTest = proxy as IProxyTest; Assert.AreEqual("test", proxyTest.GetName()); Assert.AreEqual(1, interceptor.Count); }
public void TestAutomaticInterfaceRecognitionInDelegate() { IIntroductionAdvisor ia = new DefaultIntroductionAdvisor(new Test(EXPECTED_TIMESTAMP)); TestObject target = new TestObject(); ProxyFactory pf = new ProxyFactory(target); pf.AddIntroduction(0, ia); ITimeStamped ts = (ITimeStamped)pf.GetProxy(); Assert.IsTrue(ts.TimeStamp == EXPECTED_TIMESTAMP); ((ITest)ts).Foo(); int age = ((ITestObject)ts).Age; }
/// <summary> /// Wraps an interface. The target argument must be an /// object capable of responding to the interface messages, or /// your interceptors must be capable of respoding to them. /// </summary> /// <param name="classType">Concrete class with a available constructor (public or protected) to be wrapped</param> /// <returns>A proxy</returns> public virtual object WrapClass(Type classType, params object[] constructorArgs) { AssertUtil.ArgumentNotNull(classType, "classType"); AssertUtil.ArgumentNotInterface(classType, "classType"); AspectDefinition[] aspects = AspectMatcher.Match(classType, Configuration.Aspects); if (aspects.Length == 0) { return(Activator.CreateInstance(classType, constructorArgs)); } AspectDefinition aspectdef = Union(aspects); return(ProxyFactory.CreateClassProxy(classType, aspectdef, constructorArgs)); }
public void Should_support_methods_that_return_null() { var interceptorSource = new TestInterceptorSource(new[] { _concatenateInterceptor.Object }); var proxiedObj = new Mock <ITest>(); proxiedObj.Setup(i => i.Intercepted(1)).Returns(() => null); var proxyFactory = new ProxyFactory <ITest>(interceptorSource, _interceptorManager); var proxy = proxyFactory.GenerateProxy(proxiedObj.Object); string returnedValue = proxy.Intercepted(1); proxiedObj.Verify(i => i.Intercepted(1)); _concatenateInterceptor.Verify(); Assert.True(interceptorSource.CalledFindMatchingInterceptors); Assert.Null(returnedValue); }
public IExecution GetExecution(int key) { try { var item = _executions[key]; ProxyFactory factory = new ProxyFactory(item); factory.AddAdvice(new InterceptorAdvice()); IExecution command = (IExecution)factory.GetProxy(); //return command; return(item); } catch (KeyNotFoundException e) { return(new EmptyExecution()); } }
public FunctionExecutor(SCADAModel scadaModel) { this.modelUpdateQueue = new ConcurrentQueue <IWriteModbusFunction>(); this.writeCommandQueue = new ConcurrentQueue <IWriteModbusFunction>(); this.readCommandQueue = new ConcurrentQueue <IReadModbusFunction>(); this.commandEvent = new AutoResetEvent(true); this.modelUpdateQueueEmptyEvent = new AutoResetEvent(false); this.writeCommandQueueEmptyEvent = new AutoResetEvent(false); this.proxyFactory = new ProxyFactory(); SCADAModel = scadaModel; SCADAModel.SignalIncomingModelConfirmation += EnqueueModelUpdateCommands; ConfigData = SCADAConfigData.Instance; ModbusClient = new ModbusClient(ConfigData.IpAddress.ToString(), ConfigData.TcpPort); }
public void GenericInProc_Raw() { string uri = "net.tcp://localhost:10095/genericContractTCP"; using (var host = new ServiceHost(typeof(GenericService), new Uri(uri))) { host.AddServiceEndpoint(typeof(IGenericContract), new NetTcpBinding(), uri); host.Open(); var factory = new ProxyFactory(); factory.Call <IGenericContract>(call => { Assert.AreEqual(10, call.Find(10)); }); } }
static void Main(string[] args) { ProxySetting setting = new ProxySetting(); setting.TransferSetting = TransferSettingGetter.Get; ProxyFactory factory = new ProxyFactory(setting, typeof(JsonTransferSerializer), typeof(HttpTransmitter)); var proxy = factory.CreateProxy <IExampleService>(); ConsoleHelper.ShowTextInfo("Any key to continue:"); Console.ReadLine(); var info = proxy.GetPlayerInfo("John Wang"); ConsoleHelper.ShowPlayerInfo(info); }