pushbomb

namespace SuperGraph
{

public class Loader
{
AppDomain appDomain;
RemoteLoader remoteLoader;

Utilities oUtil = null;

public T LoadClassInAppDomain(String AssemblyName, String TypeName)
{
return (T)appDomain.CreateInstanceAndUnwrap(AssemblyName, TypeName);
}
public void ShowAssemblies()
{
if (oUtil == null)
oUtil = LoadClassInAppDomain("SuperGraph",
"SuperGraph.Utilities");
//oUtil = (Utilities) appDomain.CreateInstanceAndUnwrap("SuperGraph",
// "SuperGraph.Utilities");
oUtil.ShowAssemblies(appDomain);
}
public Loader(string functionDirectory, String AppDomainName)
{
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
//setup.PrivateBinPath =
// AppDomain.CurrentDomain.BaseDirectory;
//setup.CachePath
setup.ApplicationName = "Graph";
setup.ShadowCopyFiles = "true";
setup.ShadowCopyDirectories = functionDirectory;
appDomain = AppDomain.CreateDomain(AppDomainName, null, setup);
SetAppDomainPolicy(appDomain);
remoteLoader = (RemoteLoader) appDomain.CreateInstanceAndUnwrap(
"SuperGraph",
"SuperGraphInterface.RemoteLoader");
}

// NOTE: I have not optimized this for security. This makes the AppDomain 'Wide Open' to do just about anything

void SetAppDomainPolicy(AppDomain appDomain)
{
// Create an AppDomain policy level.
PolicyLevel pLevel = PolicyLevel.CreateAppDomainLevel();
// The root code group of the policy level combines all
// permissions of its children.
UnionCodeGroup rootCodeGroup;
PermissionSet ps = new PermissionSet(PermissionState.Unrestricted);
ps.AddPermission(new SecurityPermission(SecurityPermissionFlag.AllFlags));
rootCodeGroup = new UnionCodeGroup(new AllMembershipCondition(),
new PolicyStatement(ps, PolicyStatementAttribute.All));
NamedPermissionSet localIntranet = FindNamedPermissionSet("LocalIntranet");
// The following code limits all code on this machine to local intranet permissions
// when running in this application domain.
UnionCodeGroup virtualIntranet = new UnionCodeGroup(
new ZoneMembershipCondition(SecurityZone.MyComputer),
new PolicyStatement(localIntranet,
PolicyStatementAttribute.Nothing));
virtualIntranet.Name = "Virtual Intranet";
// Add the code groups to the policy level.
rootCodeGroup.AddChild(virtualIntranet);
pLevel.RootCodeGroup = rootCodeGroup;
appDomain.SetAppDomainPolicy(pLevel);
}
private NamedPermissionSet FindNamedPermissionSet(string name)
{
IEnumerator policyEnumerator = SecurityManager.PolicyHierarchy();
while (policyEnumerator.MoveNext())
{
PolicyLevel currentLevel = (PolicyLevel)policyEnumerator.Current;
if (currentLevel.Label == "Machine")
{
IList namedPermissions = currentLevel.NamedPermissionSets;
IEnumerator namedPermission = namedPermissions.GetEnumerator();
while (namedPermission.MoveNext())
{
if (((NamedPermissionSet)namedPermission.Current).Name == name)
{
return ((NamedPermissionSet)namedPermission.Current);
}
}
}
}
return null;
}
public FunctionList LoadAssembly(string filename)
{
return remoteLoader.LoadAssembly(filename);
}
public void Unload()
{
AppDomain.Unload(appDomain);
appDomain = null;
}
}
}

The RemoteLoader to be loaded in the remote AppDomain:

using System;
using System.IO;
using System.Reflection;
using System.Security;
using System.Security.Policy;
using SuperGraph;
using System.Security.Permissions;

namespace SuperGraphInterface
{
///
/// Summary description for RemoteLoader.
///
public class RemoteLoader: MarshalByRefObject
{
public RemoteLoader()
{
//Console.WriteLine(AppDomain.CurrentDomain);
}

[FileIOPermission(SecurityAction.Assert)]
public FunctionList LoadAssembly(string fullname)
{
//string path = Path.GetDirectoryName(fullname);
//string filename = Path.GetFileNameWithoutExtension(fullname);
FunctionList functionList = new FunctionList();
Assembly assembly = Assembly.LoadFile(fullname);
foreach (Type t in assembly.GetTypes())
{
functionList.AddAllFromType(t);
}
return functionList;
}
}
}

The Interface in a SEPERATE ASSEMBLY:

using System;
namespace SuperGraph
{
public interface IQuantFunction
{
double Invoke(params double[] parameters);
string Name { get; }
}
}

An example of Implementation which would be loaded in a seperate assembly:

using System;
using System.Collections.Generic;
using System.Text;
namespace ExtraFunctions
{
class SqrFunction : IFunction
{
#region IFunction Members
public SqrFunction() {}
public double AlgorithmTransform(double T)
{
return T * T;
}
#endregion
}
}

Code called in the constructor of the loading form in the main AppDomain:

public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
const String ADDINDIRECTORY = @"D:\Documents and Settings\Damon Carr.AGILEFAST\My Documents\Visual Studio 2005\AppDomainWork\ExtraFunctions\bin\Debug";
LoadGraph();
try
{
graph.FunctionAssemblyDirectory = ADDINDIRECTORY;
graph.HookupFunctions();
graph.Min = Convert.ToDouble(this.min.Text);
graph.Max = Convert.ToDouble(this.max.Text);
graph.SetScale(graphPanel.Size);
graph.UpdateListbox(this.graphLineListbox);
graph.ReloadCountChanged += new Graph.ReloadCountHandler(ReloadChanged);
}
catch (PolicyException e)
{
MessageBox.Show(e.Message);
}
}