Dynamically loading a DLL - MC++

Introduction

Today someone was asking how he can load a DLL dynamically with .NET. For some design related reasons he didn't want to add a reference to the DLL at compile time. For all I know this might be something everyone knew about except this particular individual and me. But I didn't know anything about this and I had never thought that anyone would want to do anything like that. Anyway as I found out it was really easy. This example is completely in MC++. Just in case someone starts flaming me saying this is an oft-discussed topic, I can always claim this is the first MC++ example. And my google searches kept directing me to pages that talked about normal dynamic loading of DLLs [means the non-.NET stuff]

The DLL

Create a simple class library called Abc.dll. This will be the DLL which we will load dynamically.

#include "stdafx.h"


#using <mscorlib.dll>

using namespace System;

namespace Abc
{
    public __gc class Class1
    {
    public:
        //This simply prefixes a Hello

        //to whatever string is passed

        String* Hello(String* str)
        {
            return String::Concat(S"Hello ",str);
        }
    };
}

The Program

Okay, this is the little program that will load the above DLL, and call the Hello function, passing a string to it and also getting back the string that the function returns. Remember that Abc.dll must be in the same directory as our program's executable. I believe there are ways to put the DLL in some special directories that all .NET programs look into, but I am totally ignorant of such things.

#include "stdafx.h"


#using <mscorlib.dll>

using namespace System;
using namespace System::Reflection;

int wmain(void)
{
    //First we load our assembly

    //using the display name

    Assembly *a = Assembly::Load("Abc");

    //Now we get the type of the object

    //we want to instantiate. Since our class is

    //part of the assembly we have to use the full

    //name of the class with assembly name

    Type *t = a->GetType("Abc.Class1");

    //The MethodInfo class is used to

    //describe a method. It holds metadata about

    //a particular method. We get the MethodInfo for

    //our Hello method    

    MethodInfo *mi = t->GetMethod("Hello");    
    //Just showing off some public properties

    Console::WriteLine("Return type of *{0}* method is *{1}*",
        mi->Name,mi->ReturnType);

    //We create an instance of our object.

    //Here the default constructor is called.

    Object *o = Activator::CreateInstance(t);

    //Prepare our argument list

    String *args[] = new String*[1]; 
    args[0]= S"Nish";  
  
    //We use Invoke to call the Hello method

    //on the object we got from CreateInstance above

    //We pass to it our arguments as an Object array

    String *s1=static_cast<String*>(mi->Invoke(o,args));
    Console::WriteLine(s1);
    return 0;
}