Reflection in .NET

class AeroPlane
    {
        public AeroPlane()
        {
            Console.WriteLine("AeroPlane Constructor invoked");
        }
        private void Model()
        {
            Console.WriteLine("Airbus A380");
        }
        private void Company()
        {
            Console.WriteLine("Airbus");
        }
        private void CompanyLoacation()
        {
            Console.WriteLine("United States");
        }
        public void PublicMethod()
        {
            Console.WriteLine("This is public Method");
        }
        private void DoSum(int a, int b)
        {
            Console.WriteLine("Addition of {0} and {1} is {2}", a, b, a + b);
        }
        private void Age(string name, int age)
        {
            Console.WriteLine("Hi {0} your age is : {1}", name, age);
        }
    }

namespace NamespaceReflectionInner
    {
        class TestReflection
        {
            Type _type = null;
            public TestReflection()
            {
                _type = Type.GetType("AeroPlane");
            }
            public void Proceed()
            {
                _type = typeof(AeroPlane);
                if (_type.IsClass)
                {
                    ConstructorInfo[] _cInfo = _type.GetConstructors();
                    foreach (ConstructorInfo _ci in _cInfo)
                    {
                        Console.WriteLine(_ci.Name);
                    }
                    object obj = Activator.CreateInstance(_type);
                    MethodInfo _minfo = _type.GetMethod("Model", BindingFlags.Instance | BindingFlags.NonPublic);
                    if (_minfo != null)
                    {
                        _minfo.Invoke(obj, null);
                    }
                    MethodInfo[] _mInfoCollection = _type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);
                    foreach (MethodInfo _mm in _mInfoCollection)
                    {
                        ParameterInfo[] _pInfo = _mm.GetParameters();
                        if (_pInfo.Length != 0)
                        {
                            object[] _param;
                            if (_mm.Name.Equals("DoSum"))
                            {
                                _param = new object[] { 2, 4 };
                            }
                            else
                            {
                                _param = new object[] { "Ashutosh", 23 };
                            }
                            _mm.Invoke(obj, _param);
                        }
                        else
                        {
                            _mm.Invoke(obj, null);
                        }
                    }
                }
            }
        }
    }

Now let’s move to the next line where I’m using something called “MethodInfo”. This MethodInfo used to retrieve the method from that Type so that we can use them further in our code, in my code you can see I’m retrieving MethodInfo with the help of _type.GetMethod(“Model”) with some bindingflag parameter. There are two ways to get the method details, one to get all in an array using _type.GetMethods() and the second one I’ve used above _type.GetMethod(“MethodName”).  With _type.GetMethod(“”) you can get a specific method in MethodInfo object. The bindingflag is a enumeration that help you to extract information of Type, bindingflag.instance will bring you instance, bindingflag.NonPublic will brings NonPublic method like private so that you can use them ahead in your code.so the code below will bring the Model, that is private as in nature and with MethodInfo.Invoke method I’m going to invoke them, so that I can see the output of that method.as you can see invoke method takes object obj as first parameter, this is the reason we’ve created this object in our code earlier to invoke methods. For better understanding please refer to the image below.

 

In the above image you can see, I’ve retrieved the Model method inside my MethodInfo object, now I can do lotsa things with this object.

Now let’s move ahead when you don’t wanna be specific while calling methods, in simple language when you want to retrieve all the method details and wants to invoke them one by one. As I said earlier there are two methods to retrieve method details; first one we saw already to get the details of a specific method, now we are going to use the next method that will bring out all the method inside MethodInfo array object, that is _type.GetMethods().  For better understanding please see the image below.

 

In above code you can see I’ve retrieved all the NonPublic method details inside _mInfoCollection object. Now we will invoke them one by one; as you can see most of the methods are void and taking no parameters; apart DoSum() that is taking two Int32 parameters and Age() that is taking String and Int32 as parameters, so with MethodInfo.Invoke() method we will invoke our parameterless methods, and those methods that are taking parameters we will invoke them with the help of ParameterInfo.

Before we start understanding the code first go through the image below

 

As you can see in the above code I’m iterating through the _mInfoCollection that is the collection of my methods as of now. Now with the help of ParameterInfo[] I’m trying to access their parameters and checking whether they take any parameter with the help of checking their length property. If they contain any parameter based on the method name, I’m creating the object array and passing my parameters and while invoking taking the second parameter as obj, remember earlier we were passing it NULL. So it will call parameterized methods with parameter as we passed, and for those methods that doesn’t contain any parameter you can pass it as NULL.

So at the end if you execute the code you will found the output below

 

 I hope it gave you some idea about Reflection in .NET