Assembly Event Question

[Andrew Neillans]

Hi all,

First off, I apologise if this is mentioned in a MSDN document
somewhere, but I've searched both MSDN and Google and can't find
anything - so thought I'd post.

Ok, now the problem.

I have an application which is dynamically loading a series of
Assemblies (as plugins to extend the main application). This works
wonderfully. However, I now need to provide a way for logging data back
from the assembly to the main application - like a CallBack in C.
However, I can not find anyway to do this -- lots of information on how
to do the reverse - get the application to trigger a delegate in the
Assembly...

Any one have any suggestions as to where I should look for ?

Regards,

Andy

[Jon Skeet [C# MVP]]

Andrew Neillans wrote:

First off, I apologise if this is mentioned in a MSDN document
somewhere, but I've searched both MSDN and Google and can't find
anything - so thought I'd post.

Ok, now the problem.

I have an application which is dynamically loading a series of
Assemblies (as plugins to extend the main application). This works
wonderfully. However, I now need to provide a way for logging data back
from the assembly to the main application - like a CallBack in C.
However, I can not find anyway to do this -- lots of information on how
to do the reverse - get the application to trigger a delegate in the
Assembly...

Any one have any suggestions as to where I should look for ?

I'm not entirely sure I follow you, unfortunately. Could you provide a
short but complete example program with both assemblies (just tiny ones
- the sample at http://www.pobox.com/~skeet/csharp/plugin.html is the
kind of thing I'm after) and then highlight what you want to happen?

Jon

[Andrew Neillans]

Hi Jon,

Ok, hopefully this might help :)

Lets say we have this is the main program.

static void Main()
{
DoLogging("Im Alive");
// Main program thread here
// At some point we dynamically load the Assemblies we find, create
instances etc.
}

public void DoLogging(string LogString)
{
// Do something with LogString
}

The DoLogging function does something with the string passed to it - in
my case, it sends it to an internal log server.

Now, the problem is I need to allow the dynamically loaded assemblies
to call the DoLogging function; I could add the DoLogging function and
associated logic to the assemblies however this would increase
dependacies dramatically - which I do not want to do.

So the question is: How can a dynamically loaded assembly access a
function in the parent application?

Clear as mud I know :)

Andy

[Michael Nemtsev]

Use delegates to call your function

CrossAppDomainDelegate delegateA = new CrossAppDomainDelegate(DoLogging);
<YouDomain>.DoCallBack(delegateA);

"Andrew Neillans" wrote:

Hi Jon,

Ok, hopefully this might help :)

Lets say we have this is the main program.

static void Main()
{
DoLogging("Im Alive");
// Main program thread here
// At some point we dynamically load the Assemblies we find, create
instances etc.
}

public void DoLogging(string LogString)
{
// Do something with LogString
}

The DoLogging function does something with the string passed to it - in
my case, it sends it to an internal log server.

Now, the problem is I need to allow the dynamically loaded assemblies
to call the DoLogging function; I could add the DoLogging function and
associated logic to the assemblies however this would increase
dependacies dramatically - which I do not want to do.

So the question is: How can a dynamically loaded assembly access a
function in the parent application?

Clear as mud I know :)

--
WBR,
Michael Nemtsev :: blog: http://spaces.msn.com/laflour

"At times one remains faithful to a cause only because its opponents do not
cease to be insipid." (c) Friedrich Nietzsche

[Stoitcho Goutsev \(100\)]

Andrew,

Decalre a interface that your all plug-ins will implement. In this interface
decalare a event that is going to be fired whenever something needs to be
logged. Attach the DoLogging method to this event.

This is one possible solution for your problem.
--
HTH
Stoitcho Goutsev (100)

"Andrew Neillans" <ne******@gmail.com> wrote in message
news:11**********************@i40g2000cwc.googlegr oups.com...

Hi Jon,

Ok, hopefully this might help :)

Lets say we have this is the main program.

static void Main()
{
DoLogging("Im Alive");
// Main program thread here
// At some point we dynamically load the Assemblies we find, create
instances etc.
}

public void DoLogging(string LogString)
{
// Do something with LogString
}

The DoLogging function does something with the string passed to it - in
my case, it sends it to an internal log server.

Now, the problem is I need to allow the dynamically loaded assemblies
to call the DoLogging function; I could add the DoLogging function and
associated logic to the assemblies however this would increase
dependacies dramatically - which I do not want to do.

So the question is: How can a dynamically loaded assembly access a
function in the parent application?

Clear as mud I know :)

Andy

[Michael Nemtsev]

And to set your string to domain where DoLogging is located, use
<youDomain>.SetData method and Domain.GetData to get it

--
WBR,
Michael Nemtsev :: blog: http://spaces.msn.com/laflour

"At times one remains faithful to a cause only because its opponents do not
cease to be insipid." (c) Friedrich Nietzsche


"Michael Nemtsev" wrote:

Use delegates to call your function

CrossAppDomainDelegate delegateA = new CrossAppDomainDelegate(DoLogging);
<YouDomain>.DoCallBack(delegateA);

"Andrew Neillans" wrote:

Hi Jon,

Ok, hopefully this might help :)

Lets say we have this is the main program.

static void Main()
{
DoLogging("Im Alive");
// Main program thread here
// At some point we dynamically load the Assemblies we find, create
instances etc.
}

public void DoLogging(string LogString)
{
// Do something with LogString
}

The DoLogging function does something with the string passed to it - in
my case, it sends it to an internal log server.

Now, the problem is I need to allow the dynamically loaded assemblies
to call the DoLogging function; I could add the DoLogging function and
associated logic to the assemblies however this would increase
dependacies dramatically - which I do not want to do.

So the question is: How can a dynamically loaded assembly access a
function in the parent application?

Clear as mud I know :)

--
WBR,
Michael Nemtsev :: blog: http://spaces.msn.com/laflour

"At times one remains faithful to a cause only because its opponents do not
cease to be insipid." (c) Friedrich Nietzsche

[Jon Skeet [C# MVP]]

Andrew Neillans <ne******@gmail.com> wrote:

Ok, hopefully this might help :)

Well, it doesn't particularly show where the problem is, unfortunately.

Usually plug-ins implement an interface defined by your main
application, and you use that to communicate. Is that a problem for you
in some way? If so, it would be helpful to know how, exactly. Note that
you could specify some kind of method in the interface which takes a
parameter which is another interface implemented this time by your main
application - for instance, an interface with DoLogging. You would then
be able to tell your plug-ins who they were registeredwith, and they
could use that to do logging.

Here's a short but complete example demonstrating that:

Interfaces.cs:
using System;

public interface ILogger
{
void Log (string x);
}

public interface IPlugin
{
ILogger Logger { set; }
void SayHello();
}

Test.cs:
using System;
using System.Reflection;

class Test
{
static void Main(string[] args)
{
Assembly a = Assembly.Load (args[0]);

ILogger log = new Logger();

foreach (Type t in a.GetTypes())
{
if (typeof(IPlugin).IsAssignableFrom(t))
{
IPlugin plugin = (IPlugin)
Activator.CreateInstance(t);
plugin.Logger = log;
plugin.SayHello();
}
}
}
}

class Logger : ILogger
{
public void Log (string x)
{
Console.WriteLine (x);
}
}

Plugin.cs:
using System;

public class Plugin : IPlugin
{
ILogger logger;

public ILogger Logger
{
set { logger = value; }
}

public void SayHello()
{
logger.Log ("Hello");
}
}

Compile:
csc /target:library Interfaces.dll
csc /r:Interfaces.dll Test.cs
csc /target:library /r:Interfaces.dll Plugin.cs

Run:
test plugin

Output:
Hello

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too