This is an interesting read!! Please find the below article to learn more about sending events across AppDomains.
blog.vcillusion.co.in/sending-events-through-application-domain-boundary/
An application domain is an isolated environment where applications execute. In other words, it's a partition in an operating system process where one or more applications reside.
1. AppDomain allows us to load DLL at runtime.
2. For communication between 'AppDomain' boundary, the types should be Serializable.
3. Derive from class MarshalByRefObject which enables access to objects across application domain boundaries in applications that support remoting.
4. Full name of DLL assembly is used to load it into AppDomain. For now, we place it in the same folder as the main program.
In this section, we detailed how to achieve sending and receiving events through Application Domain boundary. Here we are using the shared universal library with interfaces already known to us, and two separate publisher and subscriber DLLs loaded on runtime and fire events across domains.
For understanding, we use four separate projects.
1. **EventsCommon (Class Library Project)**
It defines standard interfaces for Publisher and Subscriber classes, and the Main Class uses it to create interface objects.
namespace EventCommons
{
using System;
/// <summary>
/// Common Interface for Publisher
/// </summary>
public interface IEventCommonGenerator
{
/// <summary>
/// Name Generator with <see cref="Action{T}"/> accepts string and return void
/// </summary>
event Action<string> NameGenerator;
/// <summary>
/// Fire Events
/// </summary>
/// <param name="input"></param>
void FireEvent(string input);
}
/// <summary>
/// Common Interface for Subscriber
/// </summary>
public interface IEventCommonCatcher
{
/// <summary>
/// Print Events executed
/// </summary>
/// <returns></returns>
string PrintEvents();
/// <summary>
/// Subscribe to Publisher's <see cref="IEventCommonGenerator.NameGenerator"/> event
/// </summary>
/// <param name="commonGenerator"></param>
void Subscribe(IEventCommonGenerator commonGenerator);
}
}
2. **EventsPublisher (Class Library Project)**
It references EventCommon project and implements Publisher related Interface IEventCommonGenerator from EventCommon.
namespace EventsPublisher
{
using EventCommons;
using System;
/// <summary>
/// Implements <see cref="IEventCommonGenerator"/> from <see cref="EventCommons"/>
/// </summary>
[Serializable]
public class EventsGenerators : IEventCommonGenerator
{
/// <summary>
/// Fires Event
/// </summary>
/// <param name="input"></param>
public void FireEvent(string input)
{
this.NameGenerator?.Invoke(input);
}
/// <summary>
/// Event for Publisher
/// </summary>
public event Action<string> NameGenerator;
}
}
3. **EventsSubscriber (Class Library Project)**
It references EventCommon project and implements Subscriber-related Interface IEventCommonCatcher from EventCommon.
namespace EventsSubscriber
{
using System;
using System.Collections.Generic;
using EventCommons;
/// <summary>
/// Implements <see cref="IEventCommonCatcher"/> from <see cref="EventCommons"/>
/// </summary>
[Serializable]
public class EventsCatcher : IEventCommonCatcher
{
/// <summary>
/// Initializes object of <see cref="ReceivedValueList"/> and <see cref="EventsCatcher"/>
/// </summary>
public EventsCatcher()
{
this.ReceivedValueList = new List<string>();
}
/// <summary>
/// Subscribes to the Publisher
/// </summary>
/// <param name="commonGenerator"></param>
public void Subscribe(IEventCommonGenerator commonGenerator)
{
if (commonGenerator != null)
{
commonGenerator.NameGenerator += this.CommonNameGenerator;
}
}
/// <summary>
/// Called when event fired from <see cref="IEventCommonGenerator"/> using <see cref="IEventCommonGenerator.FireEvent"/>
/// </summary>
/// <param name="input"></param>
private void CommonNameGenerator(string input)
{
this.ReceivedValueList.Add(input);
}
/// <summary>
/// Holds Events Values
/// </summary>
public List<string> ReceivedValueList { get; set; }
/// <summary>
/// Returns Comma Separated Events Value
/// </summary>
/// <returns></returns>
public string PrintEvents()
{
return string.Join(",", this.ReceivedValueList);
}
}
}
4. **CrossDomainEvents (Main Console Application)**
It loads EventsPublisher into Publisher AppDomain and EventsSubscriber into Subscriber AppDomain, Subscribes Events of Publisher AppDomain into Subscriber AppDomain and Fires the event.
using System;
namespace CrossDomainEvents
{
using EventCommons;
class Program
{
static void Main()
{
// Load Publisher DLL
PublisherAppDomain.SetupDomain();
PublisherAppDomain.CustomDomain.Load("EventsPublisher, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
var newPublisherGenerator = PublisherAppDomain.Instance as IEventCommonGenerator;
// Load Subscriber DLL
SubscriberAppDomain.SetupDomain(newPublisherGenerator);
SubscriberAppDomain.CustomDomain.Load("EventsSubscriber, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
var newSubscriberCatcher = SubscriberAppDomain.Instance as IEventCommonCatcher;
// Fire Event from Publisher and validate event on Subscriber
if (newSubscriberCatcher != null && newPublisherGenerator != null)
{
// Subscribe Across Domains
newSubscriberCatcher.Subscribe(newPublisherGenerator);
// Fire Event
newPublisherGenerator.FireEvent("First");
// Validate Events
Console.WriteLine(newSubscriberCatcher.PrintEvents());
}
Console.ReadLine();
}
}
/// <summary>
/// Creates Publisher AppDomain
/// </summary>
public class PublisherAppDomain : MarshalByRefObject
{
public static AppDomain CustomDomain;
public static object Instance;
public static void SetupDomain()
{
// Domain Name EventsGenerator
CustomDomain = AppDomain.CreateDomain("EventsGenerator");
// Loads EventsPublisher Assembly and create EventsPublisher.EventsGenerators
Instance = Activator.CreateInstance(CustomDomain, "EventsPublisher, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "EventsPublisher.EventsGenerators").Unwrap();
}
}
/// <summary>
/// Creates Subscriber AppDomain
/// </summary>
public class SubscriberAppDomain : MarshalByRefObject
{
public static AppDomain CustomDomain;
public static object Instance;
public static void SetupDomain(IEventCommonGenerator eventCommonGenerator)
{
// Domain Name EventsCatcher
CustomDomain = AppDomain.CreateDomain("EventsCatcher");
// Loads EventsSubscriber Assembly and create EventsSubscriber.EventsCatcher
Instance = Activator.CreateInstance(
CustomDomain,
"EventsSubscriber, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null",
"EventsSubscriber.EventsCatcher").Unwrap();
}
}
}
**Note:**
We need to ensure that the EventsSubscriber.dll and EventsPublisher.dll are present in the same folder as CrossDomainEvents.exe. It can be done using XCOPY command in Publisher and Subscriber projects to paste DLL in CrossDomainEvents Project Output Directory.
