How to create a loosely coupled architecture with hot-swap capability?

I'm interested in creating a desktop application composed of modules such that the source code to those modules is embedded in the application itself, allowing the user to edit the application as they are running it and have the updated modules开发者_如何转开发 put into use without restarting the application. Can anyone suggest a good architecture for this?

I'm looking to use Microsoft.Net and C# for this. DLR is not an option.

Thanks!

It's not easy to suggest a good architecture for this in a short posting.

At first, i'd define a contract (an Interface) every module the user writes/modifies must implement. It should contain at least an Execute method.

Then I'd create a Wrapper-Class for these modules which:

1. loads the source code from a file
2. The wrapper compiles the file and also makes sure it implements the contract
3. Contains an indicator of whether the file could be compiled sucessfully
4. It should also implement the contract, for easy calling and handling

Then I'd have some kind of shell which contains a collection of all the module-wrappers. Any wrapper that sucessfully compiled would then let the Shell call the Execute method of the module interface.

When it comes to compiling and executing code on the fly, this link should provide all the information you need: http://www.west-wind.com/presentations/dynamicCode/DynamicCode.htm

Well, a dynamic language certainly would have been the best fit...

You can use the types in the System.Reflection.Emit namespace to dynamically create assemblies.

However, it's going to be really painful because you'd need to load those dynamic assemblies into custom AppDomains because otherwise you'll not be able to unload them again.

This again means that you must address marshalling and assembly resolution issues related to cross-AppDomain communication.

What you are probably looking for is the concept of Dependency Injection.

Dependency Injection means that instead of having module X use module Y directly, module X only relies on an interface, and the application tells module X which implementation should use for it, e.g. using module Y.

There are several ways of implementing Dependency Injection. One is to have references to the interfaces in each of your modules, and explicitly let the application configure each of its modules with the right implementation of the interface.

The second wahy of implementing it (and probably the most useful in your case) is by using a central registry. Define all the interfaces that you want to have in your application. These are the interface for which you want to dynamically change the implementation. Then define identifications for these interfaces. These could be strings or integers or GUID's. Then make a map in your application that maps the identifications to the interfaces, and fill the map with the correct implementations of the interfaces. In a C++ application (I'm not very skilled in C# yet) this could work like this:

std::map<std::string,IInterface> appInterfaces;
appInterfaces["database"] = new OracleDatabaseModule();
appInterfaces["userinterface"] = new VistaStyleUserInterface();

Make all modules go to this central registry whenever they want to use one of the modules. Make sure they don't access the modules directly, but they only pass via the registry. E.g.

MyModule::someMethod()
{
IDatabaseInterface *dbInterface = dynamic_cast<IDatabaseInterface *>(appInterfaces["database"]);
dbInterface->executeQuery(...);
}

If you now want to change the implementation for an interface in the application, you can simply change the entry in the registry, like this:

IInterface *iface = appInterfaces["database"];
if (iface) delete iface;
appInterface["database"] = new SqlServerDatabaseInterface();