CODEWITHSUNDEEP
c#.net.net-core
Gamania
Gamania

Reputation: 33

How to call a method from an external Assembly

I have sample c# project:

namespace SampleExe
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

And I have sample c# dll:

namespace SampleDll
{
    public class Program
    {
        public static void TestMethod(string samplestr)
        {
            Console.WriteLine("TestMethod Void Runned! Your string is: "+samplestr);
        }
    }
}

How can i call TestMethod() from compilled SampleDll.DLL (i want to load external dll)

Upvotes: 2

Views: 2315

Answers (3)

Sean Skelly
Sean Skelly

Reputation: 1324

Here's a working example of using Reflection to load a library at runtime and execute a static method. Note that it assumes quite a lot: you must know the library name, the class name, the method name, and all of its arguments ahead of time. It's often much easier to just reference a library directly.

A great way to use Reflection successfully is together with inheritance/interfaces. Library A contains the base class or interface, and Library B contains a derived class. Library A can use reflection to load Library B , then find all class types in Library B that are derived from the base class or interface (using Type.IsAssignableFrom). In this way, Library A will have strongly typed properties and methods to work with coming from the base, instead of having to know string names of classes, methods, and properties in Library B a priori.

Code for main EXE doing the reflection:

using System;
using System.IO;
using System.Linq;
using System.Reflection;

namespace SomeNamespace
{
    public class Program
    {
        static void Main()
        {
            string pathToSampleDLL = "<if you know the path ahead of time, use it>";

            // if SampleDLL.dll is in same directory as this EXE (a common occurrence):
            string workingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            pathToSampleDLL = Path.Combine(workingDirectory, "SampleDLL.dll");

            // load the DLL at runtime
            Assembly sampleDLL = Assembly.LoadFrom(pathToSampleDLL);

            // since you know the type name, you can use LINQ to return your type:
            Type sampleType = sampleDLL.GetTypes().FirstOrDefault(t => t.Name == "Program");

            // you are looking for a static method on this type, and you know its name, so use GetMethods:
            MethodInfo staticMethod = sampleType.GetMethod("TestMethod", BindingFlags.Public | BindingFlags.Static);

            // invoke the method.  Since you know its arguments and return value ahead of time, just hard code it:
            // you can use null for the object since this is a static method.  It takes only one argument, a sample string
            staticMethod.Invoke(null, new object[] { "sampleStr" });
        }
    }
}

Code for sample library (compiled to "SampleDLL.dll"):

using System;

namespace SampleDll
{
    public class Program
    {
        public static void TestMethod(string sampleStr)
        {
            Console.WriteLine("TestMethod Void Runned! Your string is: " + sampleStr);
        }
    }
}

Upvotes: 3

anti
anti

Reputation: 34

To do this, you need to use reflection.

            var assembly = Assembly.Load(File.ReadAllBytes("SampleDLL.dll"));

            foreach(Type type in assembly.GetExportedTypes())
            {
                var c = Activator.CreateInstance(type);
                type.InvokeMember("TestMethod", BindingFlags.InvokeMethod, null, c, new object[] { @"Hi!" });
            }

Upvotes: 0

Vivek Nuna
Vivek Nuna

Reputation: 1

You have multiple options for this. You can create a dll and add the dll as a reference to the project. You can add the project as a reference also. You can create a NuGet package of dll also and use that.

Then simply call SampleDll.Program.TestMethod

Upvotes: 0

Related Questions