In this article, I would like to explain how to load an assembly dynamically and call one of its methods. Consider a situation where you want to call a method at runtime from a unknown assembly based on the user's input, this task can be acheived using reflection.

In the below example an assembly called "BusinessLogic" will be loaded at runtime, which can be determined programatically also.

UI
**
           //Input parameters to be passed to the method
            object[] Parameter =  new object[1];
            Parameter[0]= textBox1.Text;

//Calling the method

           // Parameters Assembly Name, Class Name, Method Name, Parmateres as
 Array
           object obj = Process("BusinessLogic", "BankAccount", "GetBalance", Parameter);
            // Assign the result
            label2.Text = "Balance in your account is:" + Convert.ToString(obj);

Load Assembly
**** ********

/// <summary>
/// Call the asssembly dynamically and execute a method
///
/// </summary>
/// <param name="AssemblyName">Name of the Assembly to be loaded</param>
/// <param name="className">Name of the class to be intantiated </param>
/// <param name="methodName">Name of the method to be called</param>
/// <param name="parameterForTheMethod">Parameters should be passed as object array</param>
/// <returns>Returns as Generic object..</returns>

public static object Process(string AssemblyName, string className, string methodName, object[] parameterForTheMethod)
       
{
            object returnObject = null;
            MethodInfo mi = null;
            ConstructorInfo ci = null;
            object responder = null;
            Type type = null;
            System.Type[] objectTypes;
            int count = 0;
            try
            {
                //Load the assembly and get it's information
                type = System.Reflection.Assembly.LoadFrom(AssemblyName  +   .dll").GetType(AssemblyName +"." +
className);                                      
                //Get the Passed parameter types to find the method type
                objectTypes = new System.Type[parameterForTheMethod.GetUpperBound(0) + 1];
                foreach (object objectParameter in parameterForTheMethod)

                {
                    if (objectParameter != null)
                        objectTypes[count] = objectParameter.GetType();
                    count++;
                }

                //Get the reference of the method
                mi = type.GetMethod(methodName, objectTypes);
                ci = type.GetConstructor(Type.EmptyTypes);
                responder = ci.Invoke(null);
                //Invoke the method
                returnObject = mi.Invoke(responder, parameterForTheMethod);
            }
                catch (Exception ex)
            {
                throw ex;
            }
                finally
            {
                mi = null;
                ci = null;
                responder = null;
                type = null;
                objectTypes = null;
            }

//Return the value as a generic object
            return returnObject;

        }
    }

Business Logic
****** *****

//The below class resides in a assembly called BusinessLogic and
//this will be invoked through our dynamic assembly loader

namespace BusinessLogic
{
    public class BankAccount
    {
        public int GetBalance(string AccountNumber)
        {
            //Fetching Account Balance
            Random r = new Random();
            int Balance = r.Next(100000);
            return Balance;
        }
    }
}

Please download the code for full working example.