Dynamically Creating Generic List and Generic Dictionary at Runtime Using C#

Generic List<T>

Used Namespaces

using System;
using System.Collections.Generic;

Used Concept

Generic Collection C#

Steps to create a generic List<T> at runtime:

Step 1: Creating the generic List<T>

    //Creating the Generic List.
    Type d1 = typeof(List<>);

Step 2: Determining the type of the generic List<T> :

    //Creating the Type for Generic List.
    Type[] typeArgs = { typeof(string) };

Step 3: Combining its Type to form the List<T>:

    //Now combing the List and its type.

    Type makeme = d1.MakeGenericType(typeArgs);

Output:

    List<String> -- This created in the above step.

Step 4: Creating the Instance for List<T>:

    //Creating the Instance for List.
    object o = Activator.CreateInstance(makeme);

Output:

    List<String> obj=new List<string>; -- This is created from the above step.

Step 5: Converting the Object to the List<T> object and add the item to it:

    //Now typecasting the object to List.
    List<string> itsMe = o as List<string>;
    itsMe.Add("Arun");

Step 6: Displaying the result:

    //Displaying the Result
    Response.Write((itsMe == null) ? "Failed" : "Succeeded");

Step 7: Code snippet with Output:



Generic Dictionary<k,T>

Used Concept

Generic Collection C#

Used Namespaces

using System;
using System.Collections.Generic;

Steps to create a Generic Dictionary<k,T> at runtime:

Step 1: Creating the Dictionary Type:

    //Creating the Dictionary Type.
    Type d1 = typeof(Dictionary<,>);

Step 2: Creating Types for the KeyValue:

    //Creating KeyValue Type for Dictionary.
    Type[] typeArgs = { typeof(string), typeof(List<string>) };

Step 3: Passing the KeyValue Type and make it a generic type:

    //Passing the Type and create Dictionary Type.
    Type makeme = d1.MakeGenericType(typeArgs);

Step 4: Creating an instance for Dictionary<K,T>:

    //Creating Instance for Dictionary<K,T>.
    object o = Activator.CreateInstance(makeme);

Step 5: Converting the Object to a Dictionary Object:

    //Typecasting the Object to Dictionary Obj.
    Dictionary<string, List<string>> itsMe =
        o as Dictionary<string, List<string>>;

Step 6: Getting the Type casted Object:

    //Getting the Type of Casted object.
    Type dicType = itsMe.GetType();

Step 7: Helps to get the Generic Arguments alone as collection:

    // This is used to check any generic arguments passed.
    Type[] dicTypes = dicType.GetGenericArguments();

Step 8: Helps to determine if the typecasted object type is generic:

    //To check whether it is generic type.
    Response.Write("   Is this a generic type? {0}" + dicType.IsGenericType);

Step 9: Helps to check whether it is Generic Type definition:

    Response.Write("   Is this a generic type definition? {0}" + dicType.IsGenericTypeDefinition);

Step 10: Iterating the passed Generic Type arguments:

    //Iterate the passed generic type arguments.
    foreach (Type type in dicTypes)
    {
         Response.Write("" + type.IsGenericType);
    }

Step 11: Creating the List<T> item and added to the value and set the key for it:

    //Creating the list item and adding to dictionary.
    List<string> add = new List<string>();
    itsMe.Add("Arun", add);

Step 12: Displaying the results:

    //Results
    Response.Write((itsMe == null) ? "Failed" : "Succeeded");

Output for Runtime Dictionary:



Code Snippet:

using System;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
 
namespace DictionaryRuntime
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            CreateDicGenericInstance();
        }
 
        /// <summary>
        /// This is used to create instance generic list obj dynamically.
        /// </summary>
        public void CreateDicGenericInstance()
        {
            //Creating the Dictionary.
            Type d1 = typeof(Dictionary<,>);
 
            //Creating KeyValue Type for Dictionary.
            Type[] typeArgs = { typeof(string), typeof(List<string>) };
 
            //Passing the Type and create Dictionary Type.
            Type makeme = d1.MakeGenericType(typeArgs);
 
            //Creating Instance for Dictionary<K,T>.
            object o = Activator.CreateInstance(makeme);
 
            //Typecasting the Object to Dictionary Obj.
            Dictionary<string, List<string>> itsMe =
                o as Dictionary<string, List<string>>;
 
            //Getting the Type of Casted object.
            Type dicType = itsMe.GetType();
 
            // This is used to check any generic arguments passed.
            Type[] dicTypes = dicType.GetGenericArguments();
 
            //To check whether it is generic type.
            Response.Write("   Is this a generic type? {0}" + dicType.IsGenericType);
            Response.Write("   Is this a generic type definition? {0}" + dicType.IsGenericTypeDefinition);
 
            //Iterate the passed generic type arguments.
            foreach (Type type in dicTypes)
            {
                Response.Write("" + type.IsGenericType);
            }
 
            //Creating the list item and adding to dictionary.
            List<string> add = new List<string>();
            itsMe.Add("Arun", add); 

            //Results
            Response.Write((itsMe == null) ? "Failed" : "Succeeded");
        }
    }
}

Thanks for reading this article. Have a nice day.