using System;

 using System.Collections.Generic;

 using System.Linq;

 using System.Text;

 using System.Threading.Tasks;

 using System.Linq;

 using System.Reflection;

 namespace SharpLib.Utils

 {

     public class Reflection

     {

         /// <summary>

         /// Get a list of all the concrete types derived from the given type in all loaded assembly.

         /// </summary>

         /// <typeparam name="T"></typeparam>

         /// <returns></returns>

         public static IEnumerable<Type> GetConcreteClassesDerivedFrom<T>() where T : class

         {

             List<Type> objects = new List<Type>();

             foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())

             {

                 foreach (Type type in asm.GetTypes()

                         .Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(T))))

                 {

                     objects.Add(type);

                 }

             }

             return objects;

         }

         /// <summary>

         /// Get a dictionary of all the concrete types derived from the given type in all loaded assembly.

         /// </summary>

         /// <typeparam name="T"></typeparam>

         /// <returns></returns>

         public static IDictionary<string, Type> GetConcreteClassesDerivedFromByName<T>() where T : class

         {

             Dictionary<string, Type> objects = new Dictionary<string, Type>();

             foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())

             {

                 foreach (Type type in asm.GetTypes()

                 .Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(T))))

                 {

                     objects.Add(type.Name, type);

                 }

             }

             return objects;

         }

         /// <summary>

         /// Get a list of an instance of all the types derived from the given type in all loaded assembly.

         /// </summary>

         /// <typeparam name="T"></typeparam>

         /// <returns></returns>

         public static IEnumerable<T> GetConcreteClassesInstanceDerivedFrom<T>() where T : class

         {

             List<T> objects = new List<T>();

             foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())

             {

                 foreach (Type type in asm.GetTypes()

                 .Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(T))))

                 {

                     objects.Add((T)Activator.CreateInstance(type));

                 }

             }

             if (objects.Count>0

                 && objects[0] is IComparable)

             {

                 objects.Sort();

             }

             return objects;

         }

         /// <summary>

         /// Get a dictionary of an instance of all the types derived from the given type in all loaded assembly.

         /// </summary>

         /// <typeparam name="T"></typeparam>

         /// <returns></returns>

         public static IDictionary<string, T> GetConcreteClassesInstanceDerivedFromByName<T>() where T : class

         {

             Dictionary<string, T> objects = new Dictionary<string, T>();

             foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())

             {

                 foreach (Type type in asm.GetTypes()

                 .Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(T))))

                 {

                     objects.Add(type.Name, (T)Activator.CreateInstance(type));

                 }

             }

             return objects;

         }

         /// <summary>

         /// Get the attribute instance matching the given attribute type from the specified type.

         /// </summary>

         /// <typeparam name="T"></typeparam>

         /// <param name="aType"></param>

         /// <returns></returns>

         public static T GetAttribute<T>(Type aType) where T : class

         {

             object[] attrs = aType.GetCustomAttributes(true);

             foreach (object attr in attrs)

             {

                 T attribute = attr as T;

                 if (attribute != null)

                 {

                     return attribute;

                 }

             }

             return null;

         }

         /// <summary>

         /// Get a list of all the types derived from the given type in all loaded assembly.

         /// </summary>

         /// <param name="baseType"></param>

         /// <param name="assembly"></param>

         /// <returns></returns>

         public static IEnumerable<Type> GetDerivedTypes<T>() where T: class

         {

             List<Type> types = new List<Type>();

             foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())

             {

                 foreach (Type type in asm.GetTypes()

                 .Where(myType => myType.IsClass && myType.IsSubclassOf(typeof(T))))

                 {

                     types.Add(type);

                 }

             }

             return types;

         }

     }

 }