Invoke a matlab method in C# code with parameters

Question

I am trying to invoke a matlab method in my C# code with parameters. I used reflection to load a dll with the matlab funcion at runtime into my application, which works fine:

Assembly matlabAssembly = Assembly.LoadFrom(info.FullName);

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

types = matlabAssembly.GetTypes().ToList();

List<MethodInfo> methods = new List<MethodInfo>();
methods.AddRange(types[0].GetMethods());

dynamic dynamicObject = Activator.CreateInstance(types[0]);

The dll contains one type with one function:

MWArray MyMatlabFunction(MWArray, MWArray, MWArray, MWArray);

I create a few arrays and want to pass them as parameters to this function. To make the type MWArray available to C# at compile time, i added the Assembly "MWArray.dll" from the Matlab runtime statically to my project.

MWArray array1 = new MWNumericArray(120);
MWArray array2 = new MWNumericArray(100);
MWArray array3 = new MWNumericArray(15);
MWArray array4 = new MWLogicalArray(true);
object[] params = new object[] {array1, array2, array3, array4};

MethodInfo matlabFuncion = methods[5]; //MyMatlabFunction

matlabFunction.Invoke(dynamicObject, params);

When i call the invoke method, I get an exception that an MWNummericArray cannot be converted into an MWArray although MWNummericArray directly derives from MWArray. Am I missing something or am I doing it completely the wrong way?

Answer 1

In case anyone stumbles upon the same problem here is the solution I found:

When you want to run Matlab code in your C# application, you need a reference to the "MWArray.dll" from the Matlab runtime. If you add the reference to this dll statically to your project however, it won´t work because the reference can somehow not be loaded.

The solution is to load load the reference to "MWArray" also with reflection and create instances to "MWArray" dynamically.

public void Foo()
{
    AppDomain currentDomain = AppDomain.CurrentDomain;
    currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

    // Load dll which was exported from Matlab into application
    string path = @"..\..\..\..\MatlabDlls\Matlab-Integration";
    string dllName = "MyExportedMatlabDLL.dll";
    List<string> dllPaths = Directory.GetFiles(path).Where(file => file.EndsWith(dllName)).ToList();

    FileInfo info = new FileInfo(dllPaths[0]);
    Assembly matlabAssembly = Assembly.LoadFrom(info.FullName);

    // Get types from exported dll
    List<Type> exportedMatlabTypes = new List<Type>();
    exportedMatlabTypes = matlabAssembly.GetTypes().ToList();

    List<MethodInfo> methods = new List<MethodInfo>();
    methods.AddRange(exportedMatlabTypes[0].GetMethods());

    // Create instance of exported Matlabtype 
    dynamic dynamicObject = Activator.CreateInstance(exportedMatlabTypes[0]);

    // Select MWArray from loaded Assemblies
    // Important: MWArray could only be loaded into the application with
    // the ResolveEventHandler further below
    Assembly mwArrayAssembly = AppDomain.CurrentDomain.GetAssemblies().Where(name => name.FullName.Contains("MWArray")).ToList()[0];

    // Get all available types of MWArray
    List<Type> MWArrayTypes = mwArrayAssembly.GetTypes().ToList();                          

    // Create some MWArrays
    // MWNummericArray
    dynamic array1 = Activator.CreateInstance(MWArrayTypes[9], new object[] { new byte[640 * 480]});
    //MWNummericArray
    dynamic array2 = Activator.CreateInstance(MWArrayTypes[9], new object[] { 100 });
    //MWLogicalArray
    dynamic array3 = Activator.CreateInstance(MWArrayTypes[5], new object[] { true });

    // Parameters for Matlab function 
    object[] params= new object[] { array1, array2, array3};

    MethodInfo matlabFuncion = methods[5];      
    var result = matlabFuncion.Invoke(dynamicObject, params);
}

// The ResolveEventHandler ensures the proper loading of dependent assemblies
// I wrote a crawler that would search inside the Matlab runtime for dependent 
// assemblies. It is enough to just load "MWArray" from a static path... 
private Assembly MyResolveEventHandler(object sender, ResolveEventArgs args)
{
    Assembly dependentAssembly = null;
    string assemblyName = args.Name.Split(',')[0];
    string assemblypath = _crawler.getFullName(_runtimepath, assemblyName);
    if (assemblypath != string.Empty)
        dependentAssembly = Assembly.LoadFile(assemblypath);
    return dependentAssembly;
}