반사 - 당신이 알아야 할 것.

In computer science, reflection is the ability of a computer program to examine, introspect, and modify its own structure and behavior at runtime.[1]

// Using GetType to obtain type information:  
int i = 42;  
System.Type type = i.GetType();  
System.Console.WriteLine(type);

System.Int32

So this static method GetType uses reflection to obtain the type of the variable! Obviously when writing the code we know that "i" is an Integer but the runtime doesn't have this knowledge to hand, so it must search within itself to figure it out! Most people will have used GetType in the past, but some may have not known how it obtains the type!

Let's look at the main uses of Reflection and answer some of the questions raised above, I'll try and keep it easy to follow.

리플렉션을 사용하는 시기와 이유!

• Traditionally used to load modules/classes from assembly and create an instance of them, at runtime.
• For getting an Object's Public Attributes.
• During testing, creating mock objects during runtime initialisation.
• To create Generic libraries to handle different formats without redeployments, sometimes referred to, or using Implicit Late Binding.
• When building new types at runtime.
• For examining and instantiating types in an assembly.
• The ability to change the value of a field marked private in a 3rd party library.

The ability to inspect the code in the system and see object types is not reflection, but rather Type Introspection. Reflection is then the ability to make modifications at runtime by making use of introspection. The distinction is necessary here as some languages support introspection, but do not support reflection. One such example is C++

So as you can see it's mainly about classes, looking at them, changing them, instantiating them, but all at runtime rather than compile time!

The best way I can explain the difference between the two is by looking at your running shoes!

Compile time is like doing up your shoe laces and checking them before you go out for a run. Whatever you do to your shoes will be saved and kept. This will give you an insight whether anything is wrong with them, and what they contain and can do.

Runtime is when you're already out on the road! Your shoes have already been prepared for you, you can't usually change those shoes or retie those laces unless you stop, but you can see what the shoes are capable of, and use any existing features that these shoes have available! You could switch shoes by jumping into a new set, but this requires the new set of shoes to be already created too and available to you on the run.

In object-oriented programming languages, reflection allows inspection of classes, interfaces, fields and methods at runtime without knowing the names of the interfaces, fields, methods at compile time. It also allows instantiation of new objects and invocation of methods.

So above we had an example of using reflection on an object and getting the object attributes, now lets looks at using reflection to get info from a Type, and how we'd find and load new assemblies during runtime.

        // Using Reflection to get information from an Assembly:  
        System.Reflection.Assembly integerTypeAssembly = typeof(System.Int32).Assembly;  
        System.Type integerType = typeof(System.Int32);

        System.Console.WriteLine(integerTypeAssembly); // mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
        System.Console.WriteLine(integerType.ToString()); // System.Int32

        //Use this typeString to refind the type
        Type calcType = integerTypeAssembly.GetType(integerType.ToString());
        System.Console.WriteLine(calcType); // System.Int32

        // We can then Create a new Instance of whatever this type may be, and call it's methods.
        object integerInstance = Activator.CreateInstance(calcType); 
        // In this case it's just a boring Integer, and we can see it's been initialised to it's default of 0..
        System.Console.WriteLine(integerInstance.ToString());

//This will load the dll from a static resource such as a DB or File
Assembly searchAssembly = LoadSearchServiceAssemblyFromResource();
// Now we need to find the class in the assembly, this in this instance is simply called "Search"
Type searchType = searchAssembly.GetType(searchAssembly.GetName().Name + "Search");

// If we have found the class
if (searchType != null)
{
    object searchResult = null;
    dynamic classInstance = Activator.CreateInstance(searchType);
    // DoSearch is a method that is declared on both SearchService Classes!
    var searchResult = instance.DoSearch();
}