Scroll to top

C# Language : Reflection

Curious Bot - December 1, 2018 - 0 comments

Reflection is a C# language mechanism for accessing dynamic object properties on runtime. Typically, reflection is used to fetch the information about dynamic object type and object attribute values. In REST application, for example, reflection could be used to iterate through serialized response object.

According to MS guidelines performance critical code should avoid reflection. See

Get a System.Type

For an instance of a type:

var theString = "hello";
var theType = theString.GetType();

From the type itself:

var theType = typeof(string);

Get the members of a type

using System;
using System.Reflection;
using System.Linq;

public class Program
public static void Main()
var members = typeof(object)
.GetMembers(BindingFlags.Public |
BindingFlags.Static |

foreach (var member in members)
bool inherited = member.DeclaringType.Equals( typeof(object).Name );
Console.WriteLine($"{member.Name} is a {member.MemberType}, " +
$"it has {(inherited ? "":"not")} been inherited.");

Output (see note about output order further down):

GetType is a Method, it has not been inherited.
GetHashCode is a Method, it has not been inherited.
ToString is a Method, it has not been inherited.
Equals is a Method, it has not been inherited.
Equals is a Method, it has not been inherited.
ReferenceEquals is a Method, it has not been inherited.
.ctor is a Constructor, it has not been inherited.

We can also use the GetMembers() without passing any BindingFlags. This will return all public members of that specific type.

One thing to note that GetMembers does not return the members in any particular order, so never rely on the order that GetMembers returns you.

View Demo

Get a method and invoke it

Get Instance method and invoke it

using System;

public class Program
public static void Main()
var theString = "hello";
var method = theString
new[] {typeof(int), typeof(int)}); //The types of the method arguments
var result = method.Invoke(theString, new object[] {0, 4});



View Demo

Get Static method and invoke it

On the other hand, if the method is static, you do not need an instance to call it.

var method = typeof(Math).GetMethod("Exp");
var result = method.Invoke(null, new object[] {2});//Pass null as the first argument (no need for an instance)
Console.WriteLine(result); //You'll get e^2



View Demo

Getting and setting properties

Basic usage:

PropertyInfo prop = myInstance.GetType().GetProperty("myProperty");
// get the value myInstance.myProperty
object value = prop.GetValue(myInstance);

int newValue = 1;
// set the value myInstance.myProperty to newValue
prop.setValue(myInstance, newValue);

Setting read-only automatically-implemented properties can be done through it’s backing field (in .NET Framework name of backing field is "k__BackingField"):

// get backing field info
FieldInfo fieldInfo = myInstance.GetType()
.GetField("<myProperty>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

int newValue = 1;
// set the value of myInstance.myProperty backing field to newValue
fieldInfo.SetValue(myInstance, newValue);

Custom Attributes

Find properties with a custom attributeMyAttribute

var props = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Public |
prop => Attribute.IsDefined(prop, typeof(MyAttribute)));

Find all custom attributes on a given property

var attributes = typeof(t).GetProperty("Name").GetCustomAttributes(false);

Enumerate all classes with custom attributeMyAttribute

static IEnumerable<Type> GetTypesWithAttribute(Assembly assembly) {
foreach(Type type in assembly.GetTypes()) {
if (type.GetCustomAttributes(typeof(MyAttribute), true).Length > 0) {
yield return type;

Read value of a custom attribute at runtime

public static class AttributeExtensions

/// <summary>
/// Returns the value of a member attribute for any member in a class.
///     (a member is a Field, Property, Method, etc...)
/// <remarks>
/// If there is more than one member of the same name in the class, it will return the first one (this applies to overloaded methods)
/// </remarks>
/// <example>
/// Read System.ComponentModel Description Attribute from method 'MyMethodName' in class 'MyClass':
///     var Attribute = typeof(MyClass).GetAttribute("MyMethodName", (DescriptionAttribute d) => d.Description);
/// </example>
/// <param name="type">The class that contains the member as a type</param>
/// <param name="MemberName">Name of the member in the class</param>
/// <param name="valueSelector">Attribute type and property to get (will return first instance if there are multiple attributes of the same type)</param>
/// <param name="inherit">true to search this member's inheritance chain to find the attributes; otherwise, false. This parameter is ignored for properties and events</param>
/// </summary>
public static TValue GetAttribute<TAttribute, TValue>(this Type type, string MemberName, Func<TAttribute, TValue> valueSelector, bool inherit = false) where TAttribute : Attribute
var att = type.GetMember(MemberName).FirstOrDefault().GetCustomAttributes(typeof(TAttribute), inherit).FirstOrDefault() as TAttribute;
if (att != null)
return valueSelector(att);
return default(TValue);


//Read System.ComponentModel Description Attribute from method 'MyMethodName' in class 'MyClass'
var Attribute = typeof(MyClass).GetAttribute("MyMethodName", (DescriptionAttribute d) => d.Description);

Looping through all the properties of a class

Type type = obj.GetType();
//To restrict return properties. If all properties are required don't provide flag.
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
PropertyInfo[] properties = type.GetProperties(flags);

foreach (PropertyInfo property in properties)
Console.WriteLine("Name: " + property.Name + ", Value: " + property.GetValue(obj, null));

Determining generic arguments of instances of generic types

If you have an instance of a generic type but for some reason don’t know the specific type, you might want to determine the generic arguments that were used to create this instance.

Let’s say someone created an instance of List<T> like that and passes it to a method:

var myList = new List<int>();

where ShowGenericArguments has this signature:

public void ShowGenericArguments(object o)

so at compile time you don’t have any idea what generic arguments have been used to create o. Reflection provides a lot of methods to inspect generic types. At first, we can determine if the type of o is a generic type at all:

public void ShowGenericArguments(object o)
if (o == null) return;

Type t = o.GetType();
if (!t.IsGenericType) return;

Type.IsGenericType returns true if the type is a generic type and false if not.

But this is not all we want to know. List<> itself is a generic type, too. But we only want to examine instances of specific constructed generic types. A constructed generic type is for example a List<int> that has a specific type argument for all its generic parameters.

The Type class provides two more properties, IsConstructedGenericType and IsGenericTypeDefinition, to distinguish these constructed generic types from generic type definitions:

typeof(List<>).IsGenericType // true
typeof(List<>).IsGenericTypeDefinition // true
typeof(List<>).IsConstructedGenericType// false

typeof(List<int>).IsGenericType // true
typeof(List<int>).IsGenericTypeDefinition // false
typeof(List<int>).IsConstructedGenericType// true

To enumerate the generic arguments of an instance, we can use the GetGenericArguments() method that returns an Type array containing the generic type arguments:

public void ShowGenericArguments(object o)
if (o == null) return;
Type t = o.GetType();
if (!t.IsConstructedGenericType) return;

foreach(Type genericTypeArgument in t.GetGenericArguments())

So the call from above (ShowGenericArguments(myList)) results in this output:


Get a generic method and invoke it

Let’s say you have class with generic methods. And you need to call its functions with reflection.

public class Sample
public void GenericMethod<T>()
// ...

public static void StaticMethod<T>()

Let’s say we want to call the GenericMethod with type string.

Sample sample = new Sample();//or you can get an instance via reflection

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(typeof(string));
generic.Invoke(sample, null);//Since there are no arguments, we are passing null

For the static method you do not need an instance. Therefore the first argument will also be null.

MethodInfo method = typeof(Sample).GetMethod("StaticMethod");
MethodInfo generic = method.MakeGenericMethod(typeof(string));
generic.Invoke(null, null);

Create an instance of a Generic Type and invoke it’s method

var baseType = typeof(List<>);
var genericType = baseType.MakeGenericType(typeof(String));
var instance = Activator.CreateInstance(genericType);
var method = genericType.GetMethod("GetHashCode");
var result = method.Invoke(instance, new object[] { });

Instantiating classes that implement an interface (e.g. plugin activation)

If you want your application to support a plug-in system, for example to load plug-ins from assemblies located in plugins folder:

interface IPlugin
string PluginDescription { get; }
void DoWork();

This class would be located in a separate dll

class HelloPlugin : IPlugin
public string PluginDescription => "A plugin that says Hello";
public void DoWork()

Your application’s plugin loader would find the dll files, get all types in those assemblies that implement IPlugin, and create instances of those.

    public IEnumerable<IPlugin> InstantiatePlugins(string directory)
var pluginAssemblyNames = Directory.GetFiles(directory, "*.addin.dll").Select(name => new FileInfo(name).FullName).ToArray();
//load the assemblies into the current AppDomain, so we can instantiate the types later
foreach (var fileName in pluginAssemblyNames)
var assemblies = pluginAssemblyNames.Select(System.Reflection.Assembly.LoadFile);
var typesInAssembly = assemblies.SelectMany(asm => asm.GetTypes());
var pluginTypes = typesInAssembly.Where(type => typeof (IPlugin).IsAssignableFrom(type));
return pluginTypes.Select(Activator.CreateInstance).Cast<IPlugin>();

Creating an instance of a Type

The simplest way is to use the Activator class.

However, even though Activator performance have been improved since .NET 3.5, using Activator.CreateInstance() is bad option sometimes, due to (relatively) low performance: Test 1, Test 2, Test 3

With Activator class

Type type = typeof(BigInteger);
object result = Activator.CreateInstance(type); //Requires parameterless constructor.
Console.WriteLine(result); //Output: 0
result = Activator.CreateInstance(type, 123); //Requires a constructor which can receive an 'int' compatible argument.
Console.WriteLine(result); //Output: 123

You can pass an object array to Activator.CreateInstance if you have more than one parameter.

// With a constructor such as MyClass(int, int, string)
Activator.CreateInstance(typeof(MyClass), new object[] { 1, 2, "Hello World" });

Type type = typeof(someObject);
var instance = Activator.CreateInstance(type);

For a generic type

The MakeGenericType method turns an open generic type (like List<>) into a concrete type (like List<string>) by applying type arguments to it.

// generic List with no parameters
Type openType = typeof(List<>);

// To create a List<string>
Type[] tArgs = { typeof(string) };
Type target = openType.MakeGenericType(tArgs);

// Create an instance - Activator.CreateInstance will call the default constructor.
// This is equivalent to calling new List<string>().
List<string> result = (List<string>)Activator.CreateInstance(target);

The List<> syntax is not permitted outside of a typeof expression.

Without Activator class

Using new keyword (will do for parameterless constructors)

T GetInstance<T>() where T : new()
T instance = new T();
return instance;

Using Invoke method

// Get the instance of the desired constructor (here it takes a string as a parameter).
ConstructorInfo c = typeof(T).GetConstructor(new[] { typeof(string) });
// Don't forget to check if such constructor exists
if (c == null)
throw new InvalidOperationException(string.Format("A constructor for type '{0}' was not found.", typeof(T)));
T instance = (T)c.Invoke(new object[] { "test" });

Using Expression trees

Expression trees represent code in a tree-like data structure, where each node is an expression.
As MSDN explains:

Expression is a sequence of one or more operands and zero or more
operators that can be evaluated to a single value, object, method, or
namespace. Expressions can consist of a literal value, a method
invocation, an operator and its operands, or a simple name. Simple
names can be the name of a variable, type member, method parameter,
namespace or type.

public class GenericFactory<TKey, TType>
private readonly Dictionary<TKey, Func<object[], TType>> _registeredTypes; // dictionary, that holds constructor functions.
private object _locker = new object(); // object for locking dictionary, to guarantee thread safety

public GenericFactory()
_registeredTypes = new Dictionary<TKey, Func<object[], TType>>();

/// <summary>
/// Find and register suitable constructor for type
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="key">Key for this constructor</param>
/// <param name="parameters">Parameters</param>
public void Register(TKey key, params Type[] parameters)
ConstructorInfo ci = typeof(TType).GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, CallingConventions.HasThis, parameters, new ParameterModifier[] { }); // Get the instance of ctor.
if (ci == null)
throw new InvalidOperationException(string.Format("Constructor for type '{0}' was not found.", typeof(TType)));

Func<object[], TType> ctor;

lock (_locker)
if (!_registeredTypes.TryGetValue(key, out ctor)) // check if such ctor already been registered
var pExp = Expression.Parameter(typeof(object[]), "arguments"); // create parameter Expression
var ctorParams = ci.GetParameters(); // get parameter info from constructor

var argExpressions = new Expression[ctorParams.Length]; // array that will contains parameter expessions
for (var i = 0; i < parameters.Length; i++)

var indexedAcccess = Expression.ArrayIndex(pExp, Expression.Constant(i));

if (!parameters[i].IsClass && !parameters[i].IsInterface) // check if parameter is a value type
var localVariable = Expression.Variable(parameters[i], "localVariable"); // if so - we should create local variable that will store paraameter value

var block = Expression.Block(new[] { localVariable },
Expression.IfThenElse(Expression.Equal(indexedAcccess, Expression.Constant(null)),
Expression.Assign(localVariable, Expression.Default(parameters[i])),
Expression.Assign(localVariable, Expression.Convert(indexedAcccess, parameters[i]))

argExpressions[i] = block;

argExpressions[i] = Expression.Convert(indexedAcccess, parameters[i]);
var newExpr = Expression.New(ci, argExpressions); // create expression that represents call to specified ctor with the specified arguments.

_registeredTypes.Add(key, Expression.Lambda(newExpr, new[] { pExp }).Compile() as Func<object[], TType>); // compile expression to create delegate, and add fucntion to dictionary

/// <summary>
/// Returns instance of registered type by key.
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="key"></param>
/// <param name="args"></param>
/// <returns></returns>
public TType Create(TKey key, params object[] args)
Func<object[], TType> foo;
if (_registeredTypes.TryGetValue(key, out foo))
return (TType)foo(args);

throw new ArgumentException("No type registered for this key.");

Could be used like this:

 public class TestClass
public TestClass(string parameter)

public void TestMethod()
var factory = new GenericFactory<string, TestClass>();
factory.Register("key", typeof(string));
TestClass newInstance = factory.Create("key", "testParameter");

Using FormatterServices.GetUninitializedObject

T instance = (T)FormatterServices.GetUninitializedObject(typeof(T));

In case of using FormatterServices.GetUninitializedObject
constructors and field initializers will not be called. It is meant to be used in serializers and remoting engines

Get a Type by name with namespace

To do this you need a reference to the assembly which contains the type. If you have another type available which you know is in the same assembly as the one you want you can do this:

  • where typeName is the name of the type you are looking for (including the namespace)
    , and KnownType is the type you know is in the same assembly.

Less efficient but more general is as follows:

Type t = null;
foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
if (ass.FullName.StartsWith("System."))
t = ass.GetType(typeName);
if (t != null)

Notice the check to exclude scanning System namespace assemblies to speed up the search. If your type may actually be a CLR type, you will have to delete these two lines.

If you happen to have the fully assembly-qualified type name including the assembly you can simply get it with


Get a Strongly-Typed Delegate to a Method or Property via Reflection

When performance is a concern, invoking a method via reflection (i.e. via the MethodInfo.Invoke method) is not ideal. However, it is relatively straightforward to obtain a more performant strongly-typed delegate using the Delegate.CreateDelegate function. The performance penalty for using reflection is incurred only during the delegate-creation process. Once the delegate is created, there is little-to-no performance penalty for invoking it:

// Get a MethodInfo for the Math.Max(int, int) method...
var maxMethod = typeof(Math).GetMethod("Max", new Type[] { typeof(int), typeof(int) });
// Now get a strongly-typed delegate for Math.Max(int, int)...
var stronglyTypedDelegate = (Func<int, int, int>)Delegate.CreateDelegate(typeof(Func<int, int, int>), null, maxMethod);
// Invoke the Math.Max(int, int) method using the strongly-typed delegate...
Console.WriteLine("Max of 3 and 5 is: {0}", stronglyTypedDelegate(3, 5));

This technique can be extended to properties as well. If we have a class named MyClass with an int property named MyIntProperty, the code to get a strongly-typed getter would be (the following example assumes ‘target’ is a valid instance of MyClass):

// Get a MethodInfo for the MyClass.MyIntProperty getter...
var theProperty = typeof(MyClass).GetProperty("MyIntProperty");
var theGetter = theProperty.GetGetMethod();
// Now get a strongly-typed delegate for MyIntProperty that can be executed against any MyClass instance...
var stronglyTypedGetter = (Func<MyClass, int>)Delegate.CreateDelegate(typeof(Func<MyClass, int>), theGetter);
// Invoke the MyIntProperty getter against MyClass instance 'target'...
Console.WriteLine("target.MyIntProperty is: {0}", stronglyTypedGetter(target));

…and the same can be done for the setter:

// Get a MethodInfo for the MyClass.MyIntProperty setter...
var theProperty = typeof(MyClass).GetProperty("MyIntProperty");
var theSetter = theProperty.GetSetMethod();
// Now get a strongly-typed delegate for MyIntProperty that can be executed against any MyClass instance...
var stronglyTypedSetter = (Action<MyClass, int>)Delegate.CreateDelegate(typeof(Action<MyClass, int>), theSetter);
// Set MyIntProperty to 5...
stronglyTypedSetter(target, 5);


Reflection allows code to access information about the assemblies, modules and types at run-time (program execution). This can then be further used to dynamically create, modify or access types. Types include properties, methods, fields and attributes.

Further Reading :


Reflection in .Net Framework

Related posts