Esempio n. 1
0
 void M <SomeTypeParameter>(
     SomeClass a,
     SomeStruct b,
     SomeRecord c,
     SomeEnum d,
     SomeInterface e,
     SomeDelegate f,
     SomeTypeParameter g)
 {
 }
Esempio n. 2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            ProxyGenerator proxyGenerator = new ProxyGenerator();

            object[] param = { "Hello DoSome2" };
            //SomeInterface proxyClass = proxyGenerator.CreateClassProxy<ImpClass1>(new SomeInterceptor());
            SomeInterface proxyClass = (SomeInterface)proxyGenerator.CreateClassProxy(typeof(ImpClass2), param, new SomeInterceptor());

            proxyClass.DoSome();
        }
Esempio n. 3
0
        public void InvokesGenericInterfaceMethod()
        {
            var test         = new SomeInterface();
            var method       = typeof(ITest).Method("GetDefault").MakeGeneric(typeof(int));
            var exactInvoker = method.InvokerAs <Func <ITest, int> >();

            Assert.Equal(test.GetDefault <int>(), exactInvoker(test));
            var returnInvoker = method.InvokerAs <Func <ITest, object> >();

            Assert.Equal(test.GetDefault <int>(), returnInvoker(test));
            var convertInvoker = method.InvokerAs <Func <object, object> >();

            Assert.Equal(test.GetDefault <int>(), convertInvoker(test));
        }
Esempio n. 4
0
        static void Main(string[] args)
        {
            SomeInterface <A> a = new ClassImplementingInterface <A>();
            SomeInterface <B> b = new ClassImplementingInterface <B>();

            SomeInterface <A>[] arr = new SomeInterface <A>[]
            {
                new ClassImplementingInterface <B>(),
                new ClassImplementingInterface <A>()
            };

            foreach (var obj in arr)
            {
                obj.ShowTypeT();
            }

            Console.ReadKey();
        }
Esempio n. 5
0
        public static void Maini(string[] args)
        {
            SomeInterface @someClass = null;
            SomeInterface someClass2 = null;
            SomeInterface someClass3 = null;

            var resolver = new IocResolver(new IocContainer());

            //resolver.Register<SomeInterface>(new SomeClass());
            //Lazy initialization
            resolver.Register <SomeInterface>(() => new SomeAnotherClass());

            Console.WriteLine("resolver.Register<SomeInterface>(() => new SomeAnotherClass());");

            @someClass = resolver.Resolve <SomeInterface>();
            someClass2 = resolver.Resolve <SomeInterface>();
            someClass3 = resolver.Resolve <SomeInterface>();

            Console.WriteLine("asas");
            Console.WriteLine(@someClass?.Description);
            Console.WriteLine(someClass2?.Description);
            Console.WriteLine(someClass3?.Description);
        }
Esempio n. 6
0
 public SomeOtherImplementation(SomeInterface inner)
 {
 }
 public void CallDoSomething(SomeInterface s, int value)
 {
   s.DoSomething(value);
 }
Esempio n. 8
0
 public SomeInterface YetAnotherMethod(SomeInterface s)
 {
     return s;
 }
 public void CallDoSomething(SomeInterface s, int value)
 {
     s.DoSomething(value);
 }
Esempio n. 10
0
 public SomeInterface YetAnotherMethod(SomeInterface s)
 {
     return(s);
 }