Mega Code Archive

 

Categories / C# / Reflection

 

Reflector

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Reflection; using System.Linq.Expressions; using System.IO; using System.Web; namespace PK.Utilities.Reflection {     public class Reflector     {         private delegate T ObjectActivator<T>(params object[] args);         /// <summary>         /// Create an instance from an object using reflection and linq expressions. Works for every constructor         /// </summary>         /// <typeparam name="T">The type of the object to instance</typeparam>         /// <param name="assemblyName">The name of the assembly who stores the type</param>         /// <param name="typeFullName">The fullname of the type to instanciate</param>         /// <param name="args">The arguments of the constructor</param>         /// <returns>An instance of the given type</returns>         public static T GetInstance<T>(string assemblyName, string typeFullName, params object[] args)         {             T res = default(T);             //var completeAssemblyName =Path.Combine(GetRunningPath(),  assemblyName + (assemblyName.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) ? "" : ".dll"));             Assembly assembly = Assembly.Load(GetAssemblyName(assemblyName));             Type type = assembly.GetType(typeFullName);             ConstructorInfo ctor = GetConstructor(args, type);             ObjectActivator<T> createdActivator = GetActivator<T>(ctor);             res = createdActivator(args);             return res;         }         private static AssemblyName GetAssemblyName(string assemblyName)         {             var name = new AssemblyName(assemblyName);             return name;         }         private static ConstructorInfo GetConstructor(object[] args, Type type)         {             if (args == null)                 args = new object[0];             ConstructorInfo ctor = type.GetConstructor(args.Select(o => o.GetType()).ToArray());             return ctor;         }         /// <summary>         ///  Create an instance from an object using reflection and linq expressions. Works for every constructor         /// </summary>         /// <typeparam name="T">The type of the object to instance</typeparam>         /// <param name="type">A Type object containing the object type to instantiate</param>         /// <param name="args">The arguments of the constructor</param>         /// <returns>An instance of the given type</returns>         public static T GetInstance<T>(Type type, params object[] args)         {             T res = default(T);             ConstructorInfo ctor = GetConstructor(args, type);             ObjectActivator<T> createdActivator = GetActivator<T>(ctor);             res = createdActivator(args);             return res;         }         /// <summary>         /// Create an instance from an object using reflection and linq expressions. Uses the default constructor.         /// </summary>         /// <typeparam name="T">The type of the object to instance</typeparam>         /// <param name="assemblyName">The name of the assembly who stores the type</param>         /// <param name="typeFullName">The fullname of the type to instanciate</param>         /// <returns>An instance of the given type</returns>         public static T GetInstance<T>(string assemblyName, string typeFullName)         {             return GetInstance<T>(assemblyName, typeFullName, new object[] { });         }         /// <summary>         /// Create an instance from an object using reflection and linq expressions. Uses the default constructor.         /// </summary>         /// <typeparam name="T">The type of the object to instance</typeparam>         /// <param name="fullTypeName">The string with full type name and asembly, in format "fullName, Assembly"</param>         /// <returns>An instance of the given type</returns>         public static T GetInstance<T>(string fullTypeName)         {             var values = fullTypeName.Split(new char[]{','}, 2 );             return GetInstance<T>(values[1].Trim(), values[0].Trim(), new object[] { });         }         /// <summary>         /// Creates an ObjectActivator specifyc for an object type and a constructor type         /// </summary>         /// <typeparam name="T">Type of the object to get an instance for</typeparam>         /// <param name="ctor">ContructorInfo containing detail information for an specicyc contrustor</param>         /// <returns>An delegate of the compiled ObjectActivator method</returns>         private static ObjectActivator<T> GetActivator<T>(ConstructorInfo ctor)         {             ParameterInfo[] paramsInfo = ctor.GetParameters();             //create a single param of type object[]             ParameterExpression param = Expression.Parameter(typeof(object[]), "args");             Expression[] argsExp = new Expression[paramsInfo.Length];             //pick each arg from the params array              //and create a typed expression of them             for (int i = 0; i < paramsInfo.Length; i++)             {                 Expression index = Expression.Constant(i);                 Type paramType = paramsInfo[i].ParameterType;                 Expression paramAccessorExp = Expression.ArrayIndex(param, index);                 Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType);                 argsExp[i] = paramCastExp;             }             //make a NewExpression that calls the             //ctor with the args we just created             NewExpression newExp = Expression.New(ctor, argsExp);             //create a lambda with the New             //Expression as body and our param object[] as arg             LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator<T>), newExp, param);             //compile it             ObjectActivator<T> compiled = (ObjectActivator<T>)lambda.Compile();             return compiled;         }     } }