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

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

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

        private static Contact GetProxy()
        {
            Contact target = new Contact();
            target.FirstName = "Aleksandar";
            target.LastName = "Seovic";

            ProxyFactory pf = new ProxyFactory(target);
            pf.AddAdvisor(new ModificationAdvisor(target.GetType()));
            pf.AddIntroduction(new IsModifiedAdvisor());
            pf.ProxyTargetType = true;

            return (Contact)pf.GetProxy();
        }

        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 void TestIntroductionInterceptorWithDelegation()
		{
			TestObject raw = new TestObject();
			Assert.IsTrue(! (raw is ITimeStamped));
			ProxyFactory factory = new ProxyFactory(raw);
	
			ITimeStampedIntroduction ts = MockRepository.GenerateMock<ITimeStampedIntroduction>();
			ts.Stub(x => x.TimeStamp).Return(EXPECTED_TIMESTAMP);

			DefaultIntroductionAdvisor advisor = new DefaultIntroductionAdvisor(ts);
			factory.AddIntroduction(advisor);

			ITimeStamped tsp = (ITimeStamped) factory.GetProxy();
			Assert.IsTrue(tsp.TimeStamp == EXPECTED_TIMESTAMP);
		}

        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 TestIntroductionInterceptorWithInterfaceHierarchy() 
		{
			TestObject raw = new TestObject();
			Assert.IsTrue(! (raw is ISubTimeStamped));
			ProxyFactory factory = new ProxyFactory(raw);

            ISubTimeStampedIntroduction ts = MockRepository.GenerateMock<ISubTimeStampedIntroduction>();
			ts.Stub(x => x.TimeStamp).Return(EXPECTED_TIMESTAMP);

			DefaultIntroductionAdvisor advisor = new DefaultIntroductionAdvisor(ts);
			// we must add introduction, not an advisor
			factory.AddIntroduction(advisor);

			object proxy = factory.GetProxy();
			ISubTimeStamped tsp = (ISubTimeStamped) proxy;
			Assert.IsTrue(tsp.TimeStamp == EXPECTED_TIMESTAMP);
		}

		public void testIntroductionInterceptorWithDelegation()
		{
			TestObject raw = new TestObject();
			Assert.IsTrue(! (raw is ITimeStamped));
			ProxyFactory factory = new ProxyFactory(raw);
	
			IDynamicMock tsControl = new DynamicMock(typeof(ITimeStampedIntroduction));
			ITimeStampedIntroduction ts = (ITimeStampedIntroduction) tsControl.Object;
			tsControl.ExpectAndReturn("TimeStamp", EXPECTED_TIMESTAMP);

			DefaultIntroductionAdvisor advisor = new DefaultIntroductionAdvisor(ts);
			factory.AddIntroduction(advisor);

			ITimeStamped tsp = (ITimeStamped) factory.GetProxy();
			Assert.IsTrue(tsp.TimeStamp == EXPECTED_TIMESTAMP);
	
			tsControl.Verify();
		}

        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 Matches()
		{
			SerializablePerson target = new SerializablePerson();
			target.SetAge(27);
			ControlFlowPointcut cflow = new ControlFlowPointcut(typeof(One), "GetAge");
			ProxyFactory factory = new ProxyFactory(target);
			NopInterceptor nop = new NopInterceptor();
			IPerson proxied = (IPerson) factory.GetProxy();
			factory.AddAdvisor(new DefaultPointcutAdvisor(cflow, nop));

			// not advised, not under One...
			Assert.AreEqual(target.GetAge(), proxied.GetAge());
			Assert.AreEqual(0, nop.Count, "Whoops, appear to be advising when not under One's cflow.");

			// will be advised...
			One one = new One();
			Assert.AreEqual(27, one.GetAge(proxied));
			Assert.AreEqual(1, nop.Count, "Not advising when under One's cflow (must be).");

			// won't be advised...
			Assert.AreEqual(target.GetAge(), new One().NoMatch(proxied));
			Assert.AreEqual(1, nop.Count, "Whoops, appear to be advising when under One's cflow scope, BUT NOT under a target method's cflow scope.");
			Assert.AreEqual(3, cflow.EvaluationCount, "Pointcut not invoked the correct number of times.");
		}

        public void GetsAllInterfaces()
        {
            // Extend to get new interface
            TestObjectSubclass raw = new TestObjectSubclass();
            ProxyFactory factory = new ProxyFactory(raw);
            Assert.AreEqual(8, factory.Interfaces.Length, "Found correct number of interfaces");
            //System.out.println("Proxied interfaces are " + StringUtils.arrayToDelimitedString(factory.getProxiedInterfaces(), ","));
            ITestObject tb = (ITestObject)factory.GetProxy();
            Assert.IsTrue(tb is IOther, "Picked up secondary interface");

            raw.Age = 25;
            Assert.IsTrue(tb.Age == raw.Age);

            DateTime t = new DateTime(2004, 8, 1);
            TimestampIntroductionInterceptor ti = new TimestampIntroductionInterceptor(t);

            Console.WriteLine(StringUtils.ArrayToDelimitedString(factory.Interfaces, "/"));

            //factory.addAdvisor(0, new DefaultIntroductionAdvisor(ti, typeof(ITimeStamped)));
            factory.AddIntroduction(
                new DefaultIntroductionAdvisor(ti, typeof(ITimeStamped))
                );

            Console.WriteLine(StringUtils.ArrayToDelimitedString(factory.Interfaces, "/"));

            ITimeStamped ts = (ITimeStamped)factory.GetProxy();
            Assert.IsTrue(ts.TimeStamp == t);
            // Shouldn't fail;
            ((IOther)ts).Absquatulate();
        }

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

 public void TryRemoveNonProxiedInterface()
 {
     ProxyFactory factory = new ProxyFactory(new TestObject());
     Assert.IsFalse(factory.RemoveInterface(typeof(IServiceProvider)));
 }

 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 RemoveProxiedInterface()
 {
     ProxyFactory factory = new ProxyFactory(new TestObject());
     Assert.IsTrue(factory.RemoveInterface(typeof(ITestObject)));
 }