C# ProxyFactory.AddAdvice方法代码示例

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        public static void Main(string[] args)
        {
            try
            {
                // Create AOP proxy programmatically.
                ProxyFactory factory = new ProxyFactory(new ServiceCommand());
                factory.AddAdvice(new ConsoleLoggingBeforeAdvice());
                factory.AddAdvice(new ConsoleLoggingAfterAdvice());
                factory.AddAdvice(new ConsoleLoggingThrowsAdvice());
                ICommand command = (ICommand)factory.GetProxy();

                command.Execute();
                if (command.IsUndoCapable)
                {
                    command.UnExecute();
                }
            }
            catch (Exception ex)
            {
				Console.Out.WriteLine();
                Console.Out.WriteLine(ex);
            }
            finally
            {
				Console.Out.WriteLine();
                Console.Out.WriteLine("--- hit <return> to quit ---");
                Console.ReadLine();
            }
        }

 private static void Main(string[] args)
 {
     ProxyFactory factory = new ProxyFactory(new ServiceCommand());
     factory.AddAdvice(new ConsoleLoggingAroundAdvice());
     ICommand command = (ICommand)factory.GetProxy();
     command.Execute("This is the argument");
 }

 public static IXMLMailUtil GetEntity()
 {
     if (entity == null)
     {
         ProxyFactory factory = new ProxyFactory(new XMLMailUtil());
         factory.AddAdvice(new AroundAdvice());
         entity = (IXMLMailUtil)factory.GetProxy();
     }
     return entity;
 }

        protected override void AddPersistenceExceptionTranslation(ProxyFactory pf, IPersistenceExceptionTranslator pet)
        {
            if (AttributeUtils.FindAttribute(pf.TargetType, typeof(RepositoryAttribute)) != null)
            {
                DefaultListableObjectFactory of = new DefaultListableObjectFactory();
                of.RegisterObjectDefinition("peti", new RootObjectDefinition(typeof(PersistenceExceptionTranslationInterceptor)));
                of.RegisterSingleton("pet", pet);
                pf.AddAdvice((PersistenceExceptionTranslationInterceptor) of.GetObject("peti"));

            }
        }

 protected override object Advised(object target, IPlatformTransactionManager ptm,
                                   ITransactionAttributeSource tas)
 {
     TransactionInterceptor ti = new TransactionInterceptor();
     ti.TransactionManager = ptm;
     Assert.AreEqual(ptm, ti.TransactionManager);
     ti.TransactionAttributeSource = tas;
     Assert.AreEqual(tas, ti.TransactionAttributeSource);
     ProxyFactory pf = new ProxyFactory(target);
     pf.AddAdvice(0, ti);
     return pf.GetProxy();
 }

 static void Main(string[] args)
 {
     ProxyFactory factory = new ProxyFactory(new ServiceCommand());
     factory.AddAdvice(new ExceptionAdvice());
     ICommand cc = (ICommand)factory.GetProxy();
     cc.Execute();
     //cc.DoExecute();
     //var ctx = ContextRegistry.GetContext();
     //ICommand command = (ICommand)ctx.GetObject("myAfterAdvice");
     //command.Execute();
     //command.DoExecute();
     Console.ReadLine();
 }

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

        public object GetServiceProxy(Assembly webServiceAssembly, string serviceName)
        {
            object proxy = webServiceAssembly.CreateInstance(serviceName);
            if (proxy == null)
                throw new Exception("Cannot create proxy instance");

            if (_modifier == null)
                return proxy;

            var factory = new ProxyFactory(proxy) { ProxyTargetType = true };
            factory.AddAdvice(new WebRequestModifyInterceptor(_modifier));
            var result = factory.GetProxy();

            SetUpMissingValues(proxy, result);
            return result;
        }

        public void IntegrationTest()
        {
            ProxyFactory pf = new ProxyFactory(new TestTarget());

            ILog log = (ILog)mocks.CreateMock(typeof(ILog));
            SimpleLoggingAdvice loggingAdvice = new SimpleLoggingAdvice(log);
            pf.AddAdvice(loggingAdvice);

            Expect.Call(log.IsTraceEnabled).Return(true).Repeat.Any();
            log.Trace("Entering DoSomething");
            log.Trace("Exiting DoSomething");

            mocks.ReplayAll();

            object proxy = pf.GetProxy();
            ITestTarget ptt = (ITestTarget)proxy;
            ptt.DoSomething();

            mocks.VerifyAll();
        }

 public void AddAndRemoveEventHandlerThroughInterceptor()
 {
     TestObject target = new TestObject();
     NopInterceptor nopInterceptor = new NopInterceptor();
     CountingBeforeAdvice countingBeforeAdvice = new CountingBeforeAdvice();
     target.Name = "SOME-NAME";
     ProxyFactory pf = new ProxyFactory(target);
     pf.AddAdvice(nopInterceptor);
     pf.AddAdvisor(new DefaultPointcutAdvisor(countingBeforeAdvice));
     object proxy = pf.GetProxy();
     ITestObject to = proxy as ITestObject;
     // add event handler through proxy
     to.Click += new EventHandler(OnClick);
     OnClickWasCalled = false;
     to.OnClick();
     Assert.IsTrue(OnClickWasCalled);
     Assert.AreEqual(2, countingBeforeAdvice.GetCalls());
     // remove event handler through proxy
     to.Click -= new EventHandler(OnClick);
     OnClickWasCalled = false;
     to.OnClick();
     Assert.IsFalse(OnClickWasCalled);
     Assert.AreEqual(4, countingBeforeAdvice.GetCalls());
 }

        public void AdvisedSupportListenerMethodsAreCalledAppropriately()
        {
            IAdvisedSupportListener listener = MockRepository.GenerateMock<IAdvisedSupportListener>();

            ProxyFactory factory = new ProxyFactory(new TestObject());
            factory.AddListener(listener);

            // must fire the Activated callback...
            factory.GetProxy();
            // must fire the AdviceChanged callback...
            factory.AddAdvice(new NopInterceptor());
            // must fire the InterfacesChanged callback...
            factory.AddInterface(typeof(ISerializable));

            listener.AssertWasCalled(x => x.Activated(Arg<AdvisedSupport>.Is.NotNull));
            listener.AssertWasCalled(x => x.AdviceChanged(Arg<AdvisedSupport>.Is.NotNull));
            listener.AssertWasCalled(x => x.InterfacesChanged(Arg<AdvisedSupport>.Is.NotNull));
        }

 private ITestObject CreateProxy()
 {
     exceptionHandlerAdvice.AfterPropertiesSet();
     ProxyFactory pf = new ProxyFactory(new TestObject());
     pf.AddAdvice(exceptionHandlerAdvice);
     return (ITestObject)pf.GetProxy();
 }

        private ITestObject CreateProxy(object target, IAdvice interceptor, bool exposeProxy)
        {
            ProxyFactory pf = new ProxyFactory(target);
            pf.ExposeProxy = exposeProxy;
//            pf.Target = target;
            pf.AddAdvice(interceptor);

            return pf.GetProxy() as ITestObject;
        }

 public void ReplaceAdvisor()
 {
     TestObject target = new TestObject();
     ProxyFactory pf = new ProxyFactory(target);
     NopInterceptor nop = new NopInterceptor();
     CountingBeforeAdvice cba1 = new CountingBeforeAdvice();
     CountingBeforeAdvice cba2 = new CountingBeforeAdvice();
     IAdvisor advisor1 = new DefaultPointcutAdvisor(cba1);
     IAdvisor advisor2 = new DefaultPointcutAdvisor(cba2);
     pf.AddAdvisor(advisor1);
     pf.AddAdvice(nop);
     ITestObject proxied = (ITestObject)pf.GetProxy();
     // Use the type cast feature
     // Replace etc methods on advised should be same as on ProxyFactory
     IAdvised advised = (IAdvised)proxied;
     proxied.Age = 5;
     Assert.AreEqual(1, cba1.GetCalls());
     Assert.AreEqual(0, cba2.GetCalls());
     Assert.AreEqual(1, nop.Count);
     Assert.IsFalse(advised.ReplaceAdvisor(null, null));
     Assert.IsFalse(advised.ReplaceAdvisor(null, advisor2));
     Assert.IsFalse(advised.ReplaceAdvisor(advisor1, null));
     Assert.IsTrue(advised.ReplaceAdvisor(advisor1, advisor2));
     Assert.AreEqual(advisor2, pf.Advisors[0]);
     Assert.AreEqual(5, proxied.Age);
     Assert.AreEqual(1, cba1.GetCalls());
     Assert.AreEqual(2, nop.Count);
     Assert.AreEqual(1, cba2.GetCalls());
     Assert.IsFalse(pf.ReplaceAdvisor(new DefaultPointcutAdvisor(null), advisor1));
 }

        public void LoggingTest()
        {
            LogExceptionHandler logHandler = new LogExceptionHandler();
            logHandler.LogName = "adviceHandler";
            string testText =
                @"'Hello World, exception message = ' + #e.Message + ', target method = ' + #method.Name";
            logHandler.SourceExceptionNames.Add("ArithmeticException");
            logHandler.ActionExpressionText = testText;

            exceptionHandlerAdvice.ExceptionHandlers.Add(logHandler);

            exceptionHandlerAdvice.AfterPropertiesSet();

            ProxyFactory pf = new ProxyFactory(new TestObject());
            pf.AddAdvice(exceptionHandlerAdvice);
            ITestObject to = (ITestObject)pf.GetProxy();

            try
            {
                to.Exceptional(new ArithmeticException());
                Assert.Fail("Should have thrown exception when only logging");
            }
            catch (ArithmeticException)
            {
                bool found = false;
                foreach (string message in loggerFactoryAdapter.LogMessages)
                {
                    if (message.IndexOf("Hello World") >= 0)
                    {
                        found = true;
                    }
                }
                Assert.IsTrue(found, "did not find logging output");
            }
        }