I would like to dynamically load assemblies that implement a single
interface. I would like to reference a single definition of an interface
without creating and deploying a seperate assembly. How is this done in C#?
What constructs in C# provide the same functionality as #include C++?

For example:
Declared interface
interface MyAbstractInterface

A. Assembly 1
class DerivedClassOne : MyAbstractInterface

B. Assembly 2
class DerivedClassTwo : MyAbstractInterface

C. Application Executable, dynamically loading assemblies from above
MyAbstractInterface someVariable = null;
Assembly assemblyOne = System.AppDomain.CurrentDomain.Load(...);
MyAbstractInterface classOne =
(MyAbstractInterface)assembly.CreateInstance("DerivedClassOne");
// Use classOne
classOne.SomeMethod();

I've discovered that .NET is so strongly typed that defining the same
interface in each assembly causes an exception when I cast the object from
CreateInstance.

TIA,
SteveB, MCSD
Welch Allyn

You would have to put it into a shared library (or have the plugins
reference the original library) ...

LibraryA.ISomething != LibraryB.ISomething

Cheers,

Greg Young
MVP - C#
http://codebetter.com/blogs/gregyoung

"Steve_B" <(E-Mail Removed)> wrote in message
news:7FC82CA1-C429-420F-B527-(E-Mail Removed)...
>I would like to dynamically load assemblies that implement a single
> interface. I would like to reference a single definition of an interface
> without creating and deploying a seperate assembly. How is this done in
> C#?
> What constructs in C# provide the same functionality as #include C++?
>
> For example:
> Declared interface
> interface MyAbstractInterface
>
> A. Assembly 1
> class DerivedClassOne : MyAbstractInterface
>
> B. Assembly 2
> class DerivedClassTwo : MyAbstractInterface
>
> C. Application Executable, dynamically loading assemblies from above
> MyAbstractInterface someVariable = null;
> Assembly assemblyOne = System.AppDomain.CurrentDomain.Load(...);
> MyAbstractInterface classOne =
> (MyAbstractInterface)assembly.CreateInstance("DerivedClassOne");
> // Use classOne
> classOne.SomeMethod();
>
> I've discovered that .NET is so strongly typed that defining the same
> interface in each assembly causes an exception when I cast the object from
> CreateInstance.
>
> TIA,
> SteveB, MCSD
> Welch Allyn
>
>

Steve_B wrote:

> I would like to dynamically load assemblies that implement a single
> interface. I would like to reference a single definition of an interface
> without creating and deploying a seperate assembly. How is this done in C#?

You can put the interface in your .exe file, and have your .dlls
reference the executable.

> What constructs in C# provide the same functionality as #include C++?

C#, as you've found, is strongly typed, so there isn't an equivalent
with the same semantics.

-- Barry

--
http://barrkel.blogspot.com/

Barry Kelly wrote:
> Steve_B wrote:
>
> > I would like to dynamically load assemblies that implement a single
> > interface. I would like to reference a single definition of an interface
> > without creating and deploying a seperate assembly. How is this done in C#?
>
> You can put the interface in your .exe file, and have your .dlls
> reference the executable.

Yuck.. that's a horrible idea. A dll shouldn't ever reference an exe..
another dll is the best option.

Steve_B wrote:
> I've discovered that .NET is so strongly typed that defining the same
> interface in each assembly causes an exception when I cast the object from
> CreateInstance.

Of course it is. How could it be any other way? If it weren't this way,
the runtime could well confuse the ISomethingOrOther interface that you
wrote with the ISomethingOrOther interface buried somewhere inside some
Framework DLL. Or, more importantly, the runtime could well confuse the
ISomethingOrOther interface written by some hacker with the one that
you wrote.

> I would like to dynamically load assemblies that implement a single
> interface. I would like to reference a single definition of an interface
> without creating and deploying a seperate assembly. How is this done in C#?
> What constructs in C# provide the same functionality as #include C++?
>
> For example:
> Declared interface
> interface MyAbstractInterface
>
> A. Assembly 1
> class DerivedClassOne : MyAbstractInterface
>
> B. Assembly 2
> class DerivedClassTwo : MyAbstractInterface
>
> C. Application Executable, dynamically loading assemblies from above
> MyAbstractInterface someVariable = null;
> Assembly assemblyOne = System.AppDomain.CurrentDomain.Load(...);
> MyAbstractInterface classOne =
> (MyAbstractInterface)assembly.CreateInstance("DerivedClassOne");
> // Use classOne
> classOne.SomeMethod();

The solution is to put the interface definition itself into a separate
DLL. See Jon Skeet's article here:

http://www.yoda.arachsys.com/csharp/plugin.html

Yes, I agree that is not a very elegant solution (DLLs referencing the EXE)
but the only one I can think of besides creating a separate (shared) library.
Maybe Anders will pipe in with some insight...

"Andy" wrote:

> Barry Kelly wrote:
> > Steve_B wrote:
> >
> > > I would like to dynamically load assemblies that implement a single
> > > interface. I would like to reference a single definition of an interface
> > > without creating and deploying a seperate assembly. How is this done in C#?
> >
> > You can put the interface in your .exe file, and have your .dlls
> > reference the executable.
>
> Yuck.. that's a horrible idea. A dll shouldn't ever reference an exe..
> another dll is the best option.
>
>

Steve there are benefits to keeping it seperate as opposed to the way an
include file works .. namely versioning.

Cheers,

Greg
"Steve_B" <(E-Mail Removed)> wrote in message
news:ED510C72-EB10-4E7A-9124-(E-Mail Removed)...
> Yes, I agree that is not a very elegant solution (DLLs referencing the
> EXE)
> but the only one I can think of besides creating a separate (shared)
> library.
> Maybe Anders will pipe in with some insight...
>
> "Andy" wrote:
>
>> Barry Kelly wrote:
>> > Steve_B wrote:
>> >
>> > > I would like to dynamically load assemblies that implement a single
>> > > interface. I would like to reference a single definition of an
>> > > interface
>> > > without creating and deploying a seperate assembly. How is this done
>> > > in C#?
>> >
>> > You can put the interface in your .exe file, and have your .dlls
>> > reference the executable.
>>
>> Yuck.. that's a horrible idea. A dll shouldn't ever reference an exe..
>> another dll is the best option.
>>
>>

Having a background in C++ and COM, reusing an interface is not that
uncommon. But, in the current world of more secure applications I can see
where that's no longer acceptable...

"Bruce Wood" wrote:

>
> Steve_B wrote:
> > I've discovered that .NET is so strongly typed that defining the same
> > interface in each assembly causes an exception when I cast the object from
> > CreateInstance.
>
> Of course it is. How could it be any other way? If it weren't this way,
> the runtime could well confuse the ISomethingOrOther interface that you
> wrote with the ISomethingOrOther interface buried somewhere inside some
> Framework DLL. Or, more importantly, the runtime could well confuse the
> ISomethingOrOther interface written by some hacker with the one that
> you wrote.
>
> > I would like to dynamically load assemblies that implement a single
> > interface. I would like to reference a single definition of an interface
> > without creating and deploying a seperate assembly. How is this done in C#?
> > What constructs in C# provide the same functionality as #include C++?
> >
> > For example:
> > Declared interface
> > interface MyAbstractInterface
> >
> > A. Assembly 1
> > class DerivedClassOne : MyAbstractInterface
> >
> > B. Assembly 2
> > class DerivedClassTwo : MyAbstractInterface
> >
> > C. Application Executable, dynamically loading assemblies from above
> > MyAbstractInterface someVariable = null;
> > Assembly assemblyOne = System.AppDomain.CurrentDomain.Load(...);
> > MyAbstractInterface classOne =
> > (MyAbstractInterface)assembly.CreateInstance("DerivedClassOne");
> > // Use classOne
> > classOne.SomeMethod();
>
> The solution is to put the interface definition itself into a separate
> DLL. See Jon Skeet's article here:
>
> http://www.yoda.arachsys.com/csharp/plugin.html
>
>