Finding objects that implement interface from load

I have class that will load all assemblies in a directory and then get all the types an see if they implement an interface. I cannot get the type comparison to work. In the debugger I see my type loaded (the one I am interested in) if always fails the comparison. If I use the same comparison code locally there is no problem I get the expected result. I could just do sting compares on the type interfaces, but I'd prefer to know what I am doing wrong.

Tests:

    // Fails
    [Fact]
    public void FindISerialPortTest()
    {
        var path = Directory.GetCurrentDirectory();
        var results = FindImplementers.GetInterfaceImplementor<ISerialPort>(path);
        results.Length.Should().Be(1);
        results[0].Should().BeAssignableTo<SerialPortWrapper>();
    }

    //Passes
    [Fact]
    public void DoesTypeImplementInterfaceTest()
    {
        var myType = typeof(SerialPortWrapper);
        var myInterface = typeof(ISerialPort);
        FindImplementers.DoesTypeImplementInterface(myType, myInterface).Should().Be(true);

    }

The class:

    public class FindImplementers
{

    public static T[] GetInterfaceImplementor<T>(string directory)
    {
        if (String.IsNullOrEmpty(directory)) { return null; } //sanity check

        DirectoryInfo info = new DirectoryInfo(directory);
        if (!info.Exists) { return null; } //make sure directory exists

        var implementors = new List<T>();

        foreach (FileInfo file in info.GetFiles("*.dll")) //loop through all dll files in directory
        {
            Assembly currentAssembly = null;
            Type[] types = null;
            try
            {
                //using Reflection, load Assembly into memory from disk
                currentAssembly = Assembly.LoadFile(file.FullName);
                types = currentAssembly.GetTypes();
            }
            catch (Exception ex)
            {
                //ignore errors
                continue;
            }

            foreach (Type type in types)
            {
                if (!DoesTypeImplementInterface(type, typeof(T)))
                {
                    continue;
                }
                //Create instance of class that implements T and cast it to type
                var plugin = (T)Activator.CreateInstance(type);
                implementors.Add(plugin);
            }
        }
        return implementors.ToArray();
    }

    public static bool DoesTypeImplementInterface(Type type, Type interfaceType)
    {
        return (type != interfaceType && interfaceType.IsAssignableFrom(type));
    }

}

OK - this gave me the answer: invalidcastexception-when-using-assembly-loadfile

Here is the updated class:

public class PluginLoader
{
    public static T[] GetInterfaceImplementor<T>(string directory)
    {
        if (String.IsNullOrEmpty(directory)) { return null; } //sanity check

        DirectoryInfo info = new DirectoryInfo(directory);
        if (!info.Exists) { return null; } //make sure directory exists

        var implementors = new List<T>();

        foreach (FileInfo file in info.GetFiles("*.dll")) //loop through all dll files in directory
        {
            Assembly currentAssembly = null;
            try
            {
                var name = AssemblyName.GetAssemblyName(file.FullName);
                currentAssembly = Assembly.Load(name);
            }
            catch (Exception ex)
            {
                continue;
            }

            currentAssembly.GetTypes()
                .Where(t => t != typeof(T) && typeof(T).IsAssignableFrom(t))
                .ToList()
                .ForEach(x => implementors.Add((T)Activator.CreateInstance(x)));
        }
        return implementors.ToArray();
    }
}