C#•2y ago

Plugin system not casting properly

I'm trying to make a plugin system for my app, which does this:

public void LoadAndRunPlugins()
{
    foreach (string dllFile in Directory.GetFiles(pluginDirectory, "*.dll"))
    {
        try
        {
            Assembly assembly = pluginLoadContext.LoadFromAssemblyPath(Path.GetFullPath(dllFile));

            foreach (Type type in assembly.GetTypes().Where(asm => !asm.FullName.Contains("GyroShell.Library")))
            {
                if (type.GetInterface("IPlugin") != null)
                {
                    IPlugin plugin = Activator.CreateInstance(type) as IPlugin;
                    plugin.Initialize();
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"[-] PluginManager: Error loading and running plugin from {dllFile}: {ex.Message}");
        }
    }
}

public void LoadAndRunPlugins()
{
    foreach (string dllFile in Directory.GetFiles(pluginDirectory, "*.dll"))
    {
        try
        {
            Assembly assembly = pluginLoadContext.LoadFromAssemblyPath(Path.GetFullPath(dllFile));

            foreach (Type type in assembly.GetTypes().Where(asm => !asm.FullName.Contains("GyroShell.Library")))
            {
                if (type.GetInterface("IPlugin") != null)
                {
                    IPlugin plugin = Activator.CreateInstance(type) as IPlugin;
                    plugin.Initialize();
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"[-] PluginManager: Error loading and running plugin from {dllFile}: {ex.Message}");
        }
    }
}

public void LoadAndRunPlugins()
{
    foreach (string dllFile in Directory.GetFiles(pluginDirectory, "*.dll"))
    {
        try
        {
            Assembly assembly = pluginLoadContext.LoadFromAssemblyPath(Path.GetFullPath(dllFile));

            foreach (Type type in assembly.GetTypes().Where(asm => !asm.FullName.Contains("GyroShell.Library")))
            {
                if (type.GetInterface("IPlugin") != null)
                {
                    IPlugin plugin = Activator.CreateInstance(type) as IPlugin;
                    plugin.Initialize();
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"[-] PluginManager: Error loading and running plugin from {dllFile}: {ex.Message}");
        }
    }
}

public void LoadAndRunPlugins()
{
    foreach (string dllFile in Directory.GetFiles(pluginDirectory, "*.dll"))
    {
        try
        {
            Assembly assembly = pluginLoadContext.LoadFromAssemblyPath(Path.GetFullPath(dllFile));

            foreach (Type type in assembly.GetTypes().Where(asm => !asm.FullName.Contains("GyroShell.Library")))
            {
                if (type.GetInterface("IPlugin") != null)
                {
                    IPlugin plugin = Activator.CreateInstance(type) as IPlugin;
                    plugin.Initialize();
                }
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"[-] PluginManager: Error loading and running plugin from {dllFile}: {ex.Message}");
        }
    }
}

The

IPlugin

IPlugin

instance is null, so calling

plugin.Initialize()

plugin.Initialize()

throws an NRE. The thing is, it should work just fine, given my plugin code:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using GyroShell.Library.Interfaces;

namespace TestGyroShellModule
{
    public class PluginRoot : IPlugin
    {
        //public IPluginInfo PluginInformation => new PluginInfo();

        public void Initialize()
        {
            Debug.WriteLine("We're alive from test plugin!");
        }

        public void Shutdown()
        {
            // Shutdown logic
        }

        /*private class PluginInfo : IPluginInfo
        {
            public string Name => "Test GyroShell Plugin";
        }*/
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using GyroShell.Library.Interfaces;

namespace TestGyroShellModule
{
    public class PluginRoot : IPlugin
    {
        //public IPluginInfo PluginInformation => new PluginInfo();

        public void Initialize()
        {
            Debug.WriteLine("We're alive from test plugin!");
        }

        public void Shutdown()
        {
            // Shutdown logic
        }

        /*private class PluginInfo : IPluginInfo
        {
            public string Name => "Test GyroShell Plugin";
        }*/
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using GyroShell.Library.Interfaces;

namespace TestGyroShellModule
{
    public class PluginRoot : IPlugin
    {
        //public IPluginInfo PluginInformation => new PluginInfo();

        public void Initialize()
        {
            Debug.WriteLine("We're alive from test plugin!");
        }

        public void Shutdown()
        {
            // Shutdown logic
        }

        /*private class PluginInfo : IPluginInfo
        {
            public string Name => "Test GyroShell Plugin";
        }*/
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using GyroShell.Library.Interfaces;

namespace TestGyroShellModule
{
    public class PluginRoot : IPlugin
    {
        //public IPluginInfo PluginInformation => new PluginInfo();

        public void Initialize()
        {
            Debug.WriteLine("We're alive from test plugin!");
        }

        public void Shutdown()
        {
            // Shutdown logic
        }

        /*private class PluginInfo : IPluginInfo
        {
            public string Name => "Test GyroShell Plugin";
        }*/
    }
}

And yes, they both reference the same exact interface, defined in

GyroShell.Library.Interfaces

GyroShell.Library.Interfaces

.

Lastly, I've tried debugging this and nothing should go wrong. It tries to cast the

PluginRoot

PluginRoot

class to an

IPlugin

IPlugin

, which should work since it properly implements the interface, but it just fails. No exceptions are thrown.

hugeman•2/13/24, 10:02 PM

I'd do

if (typeof(IPlugin).IsAssignableFrom(type))

if (typeof(IPlugin).IsAssignableFrom(type))

Hhugeman I'd do `if (typeof(IPlugin).IsAssignableFrom(type))`

PdawgOP•2/13/24, 10:02 PM

Okay, I'll try this

PdawgOP•2/13/24, 10:03 PM

There's not an NRE anymore, but now it just fails to cast. Once again, no exceptions are thrown, and it should work just fine

PdawgOP•2/13/24, 10:03 PM

The test plugin references GyroShell.Library, so it's definitely implementing the correct interface

Jimmacle•2/13/24, 10:04 PM

if you expect the cast to succeed, use a C style cast instead of

as

as

so you get an invalid cast exception if something unexpected happens

PdawgOP•2/13/24, 10:04 PM

Okay

PdawgOP•2/13/24, 10:04 PM

Well

Jimmacle•2/13/24, 10:04 PM

that will give you more info than it just returning null

PdawgOP•2/13/24, 10:04 PM

if (typeof(IPlugin).IsAssignableFrom(type))

if (typeof(IPlugin).IsAssignableFrom(type))

it never gets past here though

PdawgOP•2/13/24, 10:04 PM

This is before the cast can be done

Jimmacle•2/13/24, 10:05 PM

then the cast isn't failing

PdawgOP•2/13/24, 10:05 PM

It thinks that you can't cast

PluginRoot

PluginRoot

even though it implements the interface properly

hugeman•2/13/24, 10:05 PM

Are you sure it's even processing your plugin's dll?

Hhugeman Are you sure it's even processing your plugin's dll?

PdawgOP•2/13/24, 10:06 PM

I believe so, when I tried debugging, the module showed up along with its respective Types

hugeman•2/13/24, 10:06 PM

Set a breakpoint on the LoadFromAssemblyPath line, and set a breakpoint on the

typeof(IPlugin).IsAssignable...

typeof(IPlugin).IsAssignable...

line with a condition of

type.Name == "PluginRoot"

type.Name == "PluginRoot"

hugeman•2/13/24, 10:07 PM

And then check the debugger local variables for the type and see if it's correct

PdawgOP•2/13/24, 10:07 PM

Okay. Also, I tried the C Style cast and got a generic exception out of it:

hugeman•2/13/24, 10:08 PM

Maybe there's a version difference since you compiled the PluginRoot and the CLR doesn't like it

Jimmacle•2/13/24, 10:08 PM

do you have multiple types called

IPlugin

IPlugin

JJimmacle do you have multiple types called `IPlugin`?

PdawgOP•2/13/24, 10:08 PM

nope, just one

Hhugeman Set a breakpoint on the LoadFromAssemblyPath line, and set a breakpoint on the `...

PdawgOP•2/13/24, 10:09 PM

trying this rn

PdawgOP•2/13/24, 10:10 PM

@br4kejet

PdawgOP•2/13/24, 10:10 PM

This next breakpoint is never hit

hugeman•2/13/24, 10:10 PM

If you move next then it should try to run CreateInstance

hugeman•2/13/24, 10:11 PM

or you could do that

Hhugeman If you move next then it should try to run CreateInstance

PdawgOP•2/13/24, 10:11 PM

It just fails at the if statement, it thinks that the PluginRoot isn't assignable to IPlugin

PdawgOP•2/13/24, 10:11 PM

It won't run the CreateInstance

hugeman•2/13/24, 10:12 PM

Click the little arrow thing on type

Jimmacle•2/13/24, 10:12 PM

are you absolutely 100% sure there aren't multiple types in your project called

IPlugin

IPlugin

hugeman•2/13/24, 10:12 PM

Explore the interfaces

Jimmacle•2/13/24, 10:12 PM

because what this is indicating is the IPlugin you're testing against and the IPlugin the type implements are different types

Hhugeman Explore the interfaces

PdawgOP•2/13/24, 10:13 PM

JJimmacle because what this is indicating is the IPlugin you're testing against and the IP...

PdawgOP•2/13/24, 10:13 PM

I'm certain that they're implementing the same interface

PdawgOP•2/13/24, 10:14 PM

PdawgOP•2/13/24, 10:14 PM

PluginRoot implements GyroShell.Library.Interfaces.IPlugin

hugeman•2/13/24, 10:15 PM

I dunno then, the code I gave worked for me

hugeman•2/13/24, 10:15 PM

Though I use an abstract class instead of an interface

Hhugeman Though I use an abstract class instead of an interface

PdawgOP•2/13/24, 10:16 PM

should I do that instead?

hugeman•2/13/24, 10:17 PM

Could try it

PdawgOP•2/13/24, 10:17 PM

It doesn’t really matter which method I use, as long as it’s not some crude manual reflection thing

hugeman•2/13/24, 10:17 PM

Then if that works try using an interface again

PdawgOP•2/13/24, 10:17 PM

I’ll try an abstract later, I gotta go eat dinner

PdawgOP•2/13/24, 10:17 PM

Thanks for the help though

Jimmacle•2/13/24, 10:20 PM

dunno if it'll help but here's relevant code from the last plugin loader i was involved with https://github.com/TorchAPI/Torch/blob/master/Torch/Plugins/PluginManager.cs#L506-L573

PdawgOP•2/13/24, 10:26 PM

Cool, I’ll look into it later. Thanks!

PdawgOP•2/14/24, 2:11 AM

@br4kejet Hey, I'm back, and I tried an abstract class

PdawgOP•2/14/24, 2:11 AM

same problem as before

PdawgOP•2/14/24, 2:12 AM

I'll check the version of .NET and WASDK

PdawgOP•2/14/24, 2:17 AM

Nope, they're on the same version of WASDK and .NET

Plugin system not casting properly

Similar Threads

Similar Threads

Similar Threads