C# Engine.CreateProxy方法代码示例

        public void CreateProxy()
        {
            Engine c = new Engine("CreateProxy");

            SomeClass proxy = (SomeClass) c.CreateProxy(typeof (SomeClass));

            Assert.IsTrue(proxy != null, "failed to create proxified instance");
        }

        public void CreateProxyWithCtorParams()
        {
            Engine c = new Engine("CreateProxyWithCtorParams");

            SomeClass proxy = (SomeClass) c.CreateProxy(typeof (SomeClass),555,"hello");

            Assert.IsTrue(proxy != null, "failed to create proxified instance");
        }

		public async Task TestCallAsync ()
		{
			var engine = new Engine();
			var proxy = engine.CreateProxy<ITarget>(new InternalThreadPoolTransport(engine.CreateRequestHandler(new Selector())));

			await proxy.FooAsync();
			Assert.Equal("x1", await proxy.BarAsync("x"));
		}

        public void AddException()
        {
            Engine c = new Engine("AddException");
            c.Configuration.Aspects.Add(new SignatureAspect("RemoveException", typeof (SomeClass), "*", new AddExceptionInterceptor()));

            SomeClass proxy = (SomeClass) c.CreateProxy(typeof (SomeClass));

            proxy.MyExceptionMethod();
        }

 public void CallServicedComponentClass()
 {
     Engine e = new Engine("CallServicedComponentClass");
     IAroundInterceptor myInterceptor = new MyInterceptor();
     SignatureAspect sa = new SignatureAspect("labb", "*", "*", myInterceptor);
     e.Configuration.Aspects.Add(sa);
     DummyServiced proxy = e.CreateProxy<DummyServiced>();
     proxy.Foo();
 }

        public void CreateProxyWithCtorParamsWithInterceptor()
        {
            Engine c = new Engine("CreateProxyWithCtorParamsWithInterceptor");
            c.Configuration.Aspects.Add(new SignatureAspect("ChangeReturnValue", typeof (SomeClass), "*", new ChangeReturnValueInterceptor()));

            SomeClass proxy = (SomeClass) c.CreateProxy(typeof (SomeClass),555,"hello");

            Assert.IsTrue(proxy != null, "failed to create proxified instance");
        }

        public void ChangeReturnValue()
        {
            Engine c = new Engine("ChangeReturnValue");
            c.Configuration.Aspects.Add(new SignatureAspect("ChangeReturnValue", typeof (SomeClass), "*", new ChangeReturnValueInterceptor()));

            SomeClass normal = new SomeClass();

            SomeClass proxy = (SomeClass) c.CreateProxy(typeof (SomeClass));

            Assert.IsTrue(normal.MyIntMethod() != proxy.MyIntMethod(), "return value has not been changed");
        }

        public void ChangeRefParam()
        {
            Engine c = new Engine("ChangeRefParam");
            c.Configuration.Aspects.Add(new SignatureAspect("ChangeRefParam", typeof (SomeClass), "*MyRefParamMethod*", new ChangeRefParamValueInterceptor()));

            SomeClass proxy = (SomeClass) c.CreateProxy(typeof (SomeClass));

            string refString = "some value";
            proxy.MyRefParamMethod(ref refString);

            Assert.IsTrue("some value" != refString, "ref param has not been changed");
            Assert.IsTrue("some changed value" == refString, "ref param has not been set correctly");
        }

        public void AddExceptionWithMultipleInterceptors()
        {
            Engine c = new Engine("AddExceptionWithMultipleInterceptors");
            c.Configuration.Aspects.Add(new SignatureAspect("Security", typeof (Foo), "*", new SecurityInterceptor()));
            c.Configuration.Aspects.Add(
                new SignatureAspect("Invariant", typeof (Foo), "*MyExceptionMethod*", new InvariantInterceptor()));
            c.Configuration.Aspects.Add(
                new SignatureAspect("RemoveException", typeof (Foo), "*MyExceptionMethod*",
                                    new AddExceptionInterceptor()));

            Foo proxy = c.CreateProxy<Foo>();

            proxy.MyExceptionMethod();
        }

        public void DirtyTrackingTest()
        {
            Engine c = new Engine("DirtyTrackingTest");
            c.Configuration.Aspects.Add(new DirtyTrackedAspect());

            DirtyTrackedClass d = c.CreateProxy<DirtyTrackedClass>();

            IDirtyTracked dt = d as IDirtyTracked;
            Assert.IsFalse(dt.IsDirty, "object was dirty");
            d.SomeProp = "Hello";
            Assert.IsTrue(dt.IsDirty, "object not was dirty");

            Assert.IsTrue(dt.GetPropertyDirtyStatus("SomeProp"),"SomeProp was not dirty");
            dt.ClearDirty();

            Assert.IsFalse(dt.GetPropertyDirtyStatus("SomeProp"), "SomeProp was dirty");
        }

        public void TypedAspectMixinTest()
        {
            Engine c = new Engine("TypedAspectMixinTest");
            c.Configuration.Aspects.Add(new MyTypedAspect());

            Foo proxy = (Foo)c.CreateProxy(typeof(Foo));

            ISayHello sayHello = (ISayHello)proxy;

            string helloString = sayHello.SayHello();

            Assert.IsTrue(helloString == "Hello", "SayHelloMixin did not work");
        }

        public void TypedAspectInterceptorTest()
        {
            Engine c = new Engine("TypedAspectInterceptorTest");
            c.Configuration.Aspects.Add(new ReturnValueChangerAspect());

            Foo proxy = (Foo)c.CreateProxy(typeof(Foo));

            int result = proxy.MyIntMethod();

            Assert.IsTrue(result == 1, "return value has not been changed");
        }

        public void RemoveException()
        {
            Engine c = new Engine("RemoveException");
            c.Configuration.Aspects.Add(
                new SignatureAspect("RemoveException", typeof (Foo), "*", new RemoveExceptionInterceptor()));

            Foo proxy = (Foo) c.CreateProxy(typeof (Foo));

            proxy.MyExceptionMethod();
        }

        public void ProxyGenericList()
        {
            Engine c = new Engine("ProxyGenericList");
            c.Configuration.Aspects.Add(
                new SignatureAspect("ProxyGenericList", typeof (List<string>), "*Add*", new PassiveInterceptor()));

            List<string> proxy = c.CreateProxy<List<string>>();
            Assert.IsTrue(proxy != null, "Failed to proxy generic list");
            Assert.IsTrue(proxy is IAopProxy, "Failed to proxy generic list");

            proxy.Add("a");
            proxy.Add("b");
            proxy.Add("c");
            proxy.RemoveAt(0);
            proxy.Remove("b");

            IList ilist = proxy;
            ilist.Add("hej");
        }

        public void ProxyExplicitIFace()
        {
            Engine c = new Engine("ProxyExplicitIFace");
            c.Configuration.Aspects.Add(
                new SignatureAspect("ProxyExplicitIFace", typeof (SomeClassWithExplicitIFace), "*Clone*"
                                    /*<-only Clone */, new ExplicitIFaceClonableInterceptor()));

            SomeClassWithExplicitIFace proxy =
                (SomeClassWithExplicitIFace) c.CreateProxy(typeof (SomeClassWithExplicitIFace));

            ICloneable cloneable = proxy;

            SomeClassWithExplicitIFace res = (SomeClassWithExplicitIFace) cloneable.Clone();

            Assert.IsTrue(res.SomeLongProp == 1234, "Clone interceptor did not work");
        }