Example #1
0
	static void CrossDomainTest (string name, CrossAppDomainDelegate dele) {
		Console.WriteLine ("----Testing {0}----", name);
		for (int i = 0; i < 20; ++i) {
			var ad = AppDomain.CreateDomain (string.Format ("domain-{0}-{1}", name, i));
			ad.DoCallBack (dele);
			AppDomain.Unload (ad);
		}
	}
Example #2
0
        public ServiceWaitForm(string title, CrossAppDomainDelegate action)
        {
            InitializeComponent();
            this.Font = SystemFonts.MessageBoxFont;
            this.ControlBox = false;

            this.Text = title;
            bw.RunWorkerAsync(action);
        }
Example #3
0
        /// <summary>
        /// Run installers (infrastructure and per endpoint) and handles profiles.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="configFile"></param>
        public static void Install(string[] args, string configFile)
        {
            // Create the new appdomain with the new config.
            var installDomain = AppDomain.CreateDomain("installDomain", AppDomain.CurrentDomain.Evidence, new AppDomainSetup
                                                                                                              {
                                                                                                                  ConfigurationFile = configFile,
                                                                                                                  AppDomainInitializer = DomainInitializer,
                                                                                                                  AppDomainInitializerArguments = args
                                                                                                              });

            // Call the right config method in that appdomain.
            var del = new CrossAppDomainDelegate(RunInstall);
            installDomain.DoCallBack(del);
        }
        public static void Install(IEnumerable<string> args, Type endpointConfig, string endpointName, string configFile)
        {
            // Create the new appdomain with the new config.
            var installDomain = AppDomain.CreateDomain("installDomain", AppDomain.CurrentDomain.Evidence, new AppDomainSetup
                                                                                                              {
                                                                                                                  ConfigurationFile = configFile,
                                                                                                                  AppDomainInitializer = DomainInitializer,
                                                                                                                  AppDomainInitializerArguments = new[]{string.Join(";",args),endpointConfig.AssemblyQualifiedName,endpointName}
                                                                                                              });

            // Call the write config method in that appdomain.
            var del = new CrossAppDomainDelegate(RunInstall);
            installDomain.DoCallBack(del);
        }
Example #5
0
 /// <summary>
 /// 跨Appdomain运行代码
 /// </summary>
 private void CrossAppDomain()
 {
     Console.WriteLine("CurrentAppDomain start!");
     //建立新的应用程序域对象
     AppDomain newAppDomain = AppDomain.CreateDomain("newAppDomain");
     //绑定CrossAppDomainDelegate的委托方法
     CrossAppDomainDelegate crossAppDomainDelegate = new CrossAppDomainDelegate(MyCallBack);
     //绑定DomainUnload的事件处理方法
     newAppDomain.DomainUnload += (obj, e) =>
     {
         Console.WriteLine("NewAppDomain unload!");
     };
     //调用委托
     newAppDomain.DoCallBack(crossAppDomainDelegate);
     AppDomain.Unload(newAppDomain);
 }
Example #6
0
        /// <summary>
        /// Invokes the specified delegate in a new <see cref="AppDomain"/>.
        /// </summary>
        /// <param name="callBackDelegate">The delegate to invoke in the new <see cref="AppDomain"/>.</param>
        /// <param name="appDomainData">The optional data to set for the <see cref="AppDomain"/>.</param>
        /// <param name="configurationFile">The optional name of the configuration file to use.</param>
        /// <param name="callerMemberName">The optional name of the caller of this method.</param>
        public static void InvokeInNewAppDomain(
            CrossAppDomainDelegate callBackDelegate,
            IDictionary<string, object> appDomainData = null,
            string configurationFile = null,
            [CallerMemberName] string callerMemberName = null)
        {
            AppDomainSetup info = AppDomain.CurrentDomain.SetupInformation;

            if (!string.IsNullOrEmpty(configurationFile))
            {
                info.ConfigurationFile = configurationFile;
            }

            AppDomain domain = AppDomain.CreateDomain(
                callerMemberName,
                null,
                info);

            try
            {
                if (appDomainData != null)
                {
                    foreach (var pair in appDomainData)
                    {
                        domain.SetData(pair.Key, pair.Value);
                    }
                }

                if (Logger.DefaultLogger.GetType().IsMarshalByRef)
                {
                    // Create an instance of the type that configures logging in the new AppDomain
                    Type helperType = typeof(LoggingHelper);
                    var handle = domain.CreateInstanceFrom(helperType.Assembly.Location, helperType.FullName);

                    var helper = (LoggingHelper)handle.Unwrap();
                    helper.SetLogger(Logger.DefaultLogger);
                }

                domain.DoCallBack(callBackDelegate);
            }
            finally
            {
                AppDomain.Unload(domain);
            }
        }
Example #7
0
        public static int Main(string[] args)
        {
            AppDomainSetup setup = new AppDomainSetup();
            setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            _serverAppDomain = AppDomain.CreateDomain("Server", null, setup);
            _serverAppDomain.Load(typeof(ZyanConnection).Assembly.GetName());

            CrossAppDomainDelegate serverWork = new CrossAppDomainDelegate(() =>
            {
                var server = EventServer.Instance;
                if (server != null)
                {
                    Console.WriteLine("Event server started.");
                }
            });
            _serverAppDomain.DoCallBack(serverWork);

            // Test IPC Binary
            int ipcBinaryTestResult = IpcBinaryTest.RunTest();
            Console.WriteLine("Passed: {0}", ipcBinaryTestResult == 0);

            // Test TCP Binary
            int tcpBinaryTestResult = TcpBinaryTest.RunTest();
            Console.WriteLine("Passed: {0}", tcpBinaryTestResult == 0);

            // Test TCP Custom
            int tcpCustomTestResult = TcpCustomTest.RunTest();
            Console.WriteLine("Passed: {0}", tcpCustomTestResult == 0);

            // Test TCP Duplex
            int tcpDuplexTestResult = TcpDuplexTest.RunTest();
            Console.WriteLine("Passed: {0}", tcpDuplexTestResult == 0);

            // Test HTTP Custom
            int httpCustomTestResult = HttpCustomTest.RunTest();
            Console.WriteLine("Passed: {0}", httpCustomTestResult == 0);

            // Test NULL Channel
            const string nullChannelResultSlot = "NullChannelResult";
            _serverAppDomain.DoCallBack(new CrossAppDomainDelegate(() =>
            {
                int result = NullChannelTest.RunTest();
                AppDomain.CurrentDomain.SetData(nullChannelResultSlot, result);
            }));
            var nullChannelTestResult = Convert.ToInt32(_serverAppDomain.GetData(nullChannelResultSlot));
            Console.WriteLine("Passed: {0}", nullChannelTestResult == 0);

            // Stop the event server
            EventServerLocator locator = _serverAppDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "IntegrationTest_DistributedEvents.EventServerLocator") as EventServerLocator;
            locator.GetEventServer().Dispose();
            Console.WriteLine("Event server stopped.");

            if (!MonoCheck.IsRunningOnMono || MonoCheck.IsUnixOS)
            {
                // Mono/Windows bug:
                // AppDomain.Unload freezes in Mono under Windows if tests for
                // System.Runtime.Remoting.Channels.Tcp.TcpChannel were executed.
                AppDomain.Unload(_serverAppDomain);
                Console.WriteLine("Server AppDomain unloaded.");
            }

            if (ipcBinaryTestResult + tcpBinaryTestResult + tcpCustomTestResult + tcpDuplexTestResult + httpCustomTestResult + nullChannelTestResult == 0)
            {
                Console.WriteLine("All tests passed.");
                return 0;
            }

            return 1;
        }
 public void DoCallBack (CrossAppDomainDelegate callBackDelegate) {
     Contract.Requires(callBackDelegate != null);
 }
 // This method allows you to execute code in the
 // special HostingEnvironment-enabled AppDomain.
 private void Execute(CrossAppDomainDelegate testMethod)
 {
     this._hostingEnvironmentDomain.DoCallBack(testMethod);
 }
Example #10
0
        /// <summary>
        /// Unregisters an event on all servers.
        /// </summary>
        /// <param name="eventName">The event name to unregister.</param>
        /// <param name="function">The function to register to the event.</param>
        /// <returns>Unregistration success?</returns>
        public bool UnregisterEvent(string eventName, CrossAppDomainDelegate function)
        {
            for ( int i = 0; i < IModule.MaxServers; i++ ) {

                IRCEvents serversIrcEvents = (IRCEvents)RequestVariable( Request.IRCEvents, i );
                if ( serversIrcEvents == null ) break;

                int loc = Algorithms.BinarySearch.EventInfoBinarySearch( eventList, eventName );
                if ( loc < 0 )
                    return false;

                //Get the method we need to create a delegate to.
                MethodInfo mi = typeof( ModuleEvents ).GetMethod( "On" + eventName );
                //Get the event we need to attach the delegate to.
                EventInfo ei = typeof( IRCEvents ).GetEvent( eventName );

                // Servers IRCEvents Object --- CALLS --> OnPing in ModuleEvents
                ei.AddEventHandler( serversIrcEvents, Delegate.CreateDelegate( ei.EventHandlerType, moduleEvents, mi ) );

                // ModuleLoader's ModuleEvents Object ---- CALLS --> 'function' inside the Module.
                ( typeof( ModuleEvents ).GetEvent( eventName, BindingFlags.Public | BindingFlags.Instance ) )
                .RemoveEventHandler( this.moduleEvents, function );

            }

            return true;
        }
Example #11
0
        /// <summary>
        /// Enables a module to register a parse that will be activated on
        /// the events specified by the parsetype on all servers.
        /// </summary>
        /// <param name="parse">The parse to register.</param>
        /// <param name="d">The function to call.</param>
        /// <param name="parseType">The events to add the parse to.</param>
        public void RegisterWildcardParse(string parse, CrossAppDomainDelegate d, IRCEvents.ParseTypes parseType)
        {
            IRCEvents.Parse p = new IRCEvents.Parse( parse, d, parseType,
                instanceOfModule.GetType().GetField( "parseReturns", BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.SetField ),
                instanceOfModule
                );

            for ( int i = 0; i < IModule.MaxServers; i++ ) {
                IRCEvents serversIrcEvents = (IRCEvents)RequestVariable( Request.IRCEvents, i );
                if ( serversIrcEvents == null ) break;

                serversIrcEvents.WildcardParses.Add( p );
            }
        }
Example #12
0
 public Parse(string parse, CrossAppDomainDelegate function, ParseTypes ptypes, FieldInfo fi, Object instanceOf)
 {
     this.parse = parse;
     this.ptypes = ptypes;
     this.function = function;
     this.fi = fi;
     this.instanceOf = instanceOf;
 }
        void RunSample(Control parent, ExampleInfo e)
        {
            if (e == null)
                return;

            MethodInfo main =
                e.Example.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ??
                e.Example.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] {
                typeof(object),
                typeof(object)
            }, null);
            if (main != null)
            {
                try
                {
                    if (parent != null)
                    {
                        parent.Visible = false;
                        Application.DoEvents();
                    }
                    Trace.WriteLine(String.Format("Launching sample: \"{0}\"", e.Attribute.Title));
                    Trace.WriteLine(String.Empty);

                    AppDomain sandbox = AppDomain.CreateDomain("Sandbox");
                    sandbox.DomainUnload += HandleSandboxDomainUnload;

                    SampleRunner runner = new SampleRunner(main);
                    CrossAppDomainDelegate cross = new CrossAppDomainDelegate(runner.Invoke);
                    sandbox.DoCallBack(cross);
                    AppDomain.Unload(sandbox);
                }
                finally
                {
                    if (parent != null)
                    {
                        textBoxOutput.Text = File.ReadAllText("debug.log");
                        parent.Visible = true;
                        Application.DoEvents();
                    }
                }
            }
            else
            {
                MessageBox.Show("The selected example does not define a Main method", "Entry point not found", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        private static void RunInPartialTrust(CrossAppDomainDelegate testMethod)
        {
            Assert.IsTrue(Assembly.GetExecutingAssembly().IsFullyTrusted);

            AppDomainSetup setup = new AppDomainSetup();
            setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            PermissionSet perms = PermissionsHelper.InternetZone;
            AppDomain domain = AppDomain.CreateDomain("PartialTrustSandBox", null, setup, perms);

            domain.DoCallBack(testMethod);
        }
Example #15
0
        public static int Main(string[] args)
        {
            AppDomainSetup setup = new AppDomainSetup();
            setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            _serverAppDomain = AppDomain.CreateDomain("Server", null, setup);
            _serverAppDomain.Load("Zyan.Communication");

            CrossAppDomainDelegate serverWork = new CrossAppDomainDelegate(() =>
            {
                EventServer server = EventServer.Instance;
            });
            _serverAppDomain.DoCallBack(serverWork);

            //TcpCustomClientProtocolSetup protocol = new TcpCustomClientProtocolSetup(true);
            MsmqClientProtocolSetup protocol = new MsmqClientProtocolSetup();
            //_connection = new ZyanConnection("tcp://localhost:8083/EventTest",protocol);
            _connection = new ZyanConnection(@"msmq://private$/reqchannel/EventTest", protocol);
            _proxySingleton = _connection.CreateProxy<IEventComponentSingleton>();
            _proxySingleCall = _connection.CreateProxy<IEventComponentSingleCall>();
            _proxyCallbackSingleton = _connection.CreateProxy<ICallbackComponentSingleton>();
            _proxyCallbackSingleCall = _connection.CreateProxy<ICallbackComponentSingleCall>();
            _proxyRequestResponseSingleCall = _connection.CreateProxy<IRequestResponseCallbackSingleCall>();

            int successCount = 0;

            _proxyCallbackSingleton.Out_Callback = CallBackSingleton;
            _proxyCallbackSingleCall.Out_Callback = CallBackSingleCall;

            _proxyCallbackSingleton.DoSomething();
            if (_callbackCountSingleton == 1)
            {
                successCount++;
                Console.WriteLine("Singleton Callback Test passed.");
            }
            _proxyCallbackSingleCall.DoSomething();
            if (_callbackCountSingleCall == 1)
            {
                successCount++;
                Console.WriteLine("SingleCall Callback Test passed.");
            }

            RegisterEvents();
            if (_registrationsSingleton == _proxySingleton.Registrations)
                successCount++;
            if (_registrationsSingleCall == _proxySingleCall.Registrations)
                successCount++;

            _proxySingleton.TriggerEvent();
            if (_firedCountSingleton == 1)
            {
                successCount++;
                Console.WriteLine("Singleton Event Test passed.");
            }

            _proxySingleCall.TriggerEvent();
            if (_firedCountSingleCall == 1)
            {
                successCount++;
                Console.WriteLine("SingleCall Event Test passed.");
            }

            UnregisterEvents();
            if (_registrationsSingleton == _proxySingleton.Registrations)
                successCount++;
            if (_registrationsSingleCall == _proxySingleCall.Registrations)
                successCount++;

            RequestResponseResult requestResponseResult = new RequestResponseResult();

            _proxyRequestResponseSingleCall.DoRequestResponse("Success", requestResponseResult.ReceiveResponseSingleCall);

            Thread.Sleep(1000);

            if (requestResponseResult.Count == 1)
                successCount++;

            _connection.Dispose();
            EventServerLocator locator = _serverAppDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "IntegrationTest_DistributedEvents.EventServerLocator") as EventServerLocator;
            locator.GetEventServer().Dispose();
            AppDomain.Unload(_serverAppDomain);

            if (successCount == 9)
                return 0;
            else
                return 1;
        }
Example #16
0
 public void DoCallBack(CrossAppDomainDelegate action)
 {
     this.domain.DoCallBack(action);
 }
 public void DoCallBack(CrossAppDomainDelegate callBackDelegate)
 {
 }
        public static void StopServer()
        {
            #region TCP Duplex

            try
            {
                CrossAppDomainDelegate serverWork = new CrossAppDomainDelegate(() =>
                {
                    TcpDuplexServerHostEnvironment.Instance.Dispose();
                });
                _tcpDuplexServerAppDomain.DoCallBack(serverWork);
            }
            finally
            {
                AppDomain.Unload(_tcpDuplexServerAppDomain);
            }

            #endregion

            #region TCP Simplex

            try
            {
                CrossAppDomainDelegate serverWork = new CrossAppDomainDelegate(() =>
                {
                    TcpSimplexServerHostEnvironment.Instance.Dispose();
                });
                _tcpSimplexServerAppDomain.DoCallBack(serverWork);
            }
            finally
            {
                AppDomain.Unload(_tcpSimplexServerAppDomain);
            }

            #endregion
        }
Example #19
0
 public void DoCallBack(CrossAppDomainDelegate callBackDelegate)
 {
     if (callBackDelegate == null)
     {
         throw new ArgumentNullException("callBackDelegate");
     }
     callBackDelegate();
 }
        public static void StartServers(TestContext ctx)
        {
            #region TCP Duplex

            // Setup TCP Duplex Server AppDomain
            AppDomainSetup tcpDuplexAppDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) };
            _tcpDuplexServerAppDomain = AppDomain.CreateDomain("RecreateClientConnectionTests_Server", null, tcpDuplexAppDomainSetup);
            _tcpDuplexServerAppDomain.Load(typeof(ZyanConnection).Assembly.GetName());

            // Start Zyan host inside the TCP Duplex Server AppDomain
            var tcpDuplexServerWork = new CrossAppDomainDelegate(() =>
            {
                var server = TcpDuplexServerHostEnvironment.Instance;

                if (server != null)
                {
                    Console.WriteLine("TCP Duplex Server running.");
                }
            });
            _tcpDuplexServerAppDomain.DoCallBack(tcpDuplexServerWork);

            #endregion

            #region TCP Simplex

            // Setup TCP Simplex Server AppDomain
            AppDomainSetup tcpSimplexAppDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) };
            _tcpSimplexServerAppDomain = AppDomain.CreateDomain("RecreateClientConnectionTests_Server", null, tcpSimplexAppDomainSetup);
            _tcpSimplexServerAppDomain.Load(typeof(ZyanConnection).Assembly.GetName());

            // Start Zyan host inside the TCP Simplex Server AppDomain
            var tcpSimplexServerWork = new CrossAppDomainDelegate(() =>
            {
                var server = TcpSimplexServerHostEnvironment.Instance;

                if (server != null)
                {
                    Console.WriteLine("TCP Simplex Server running.");
                }
            });
            _tcpSimplexServerAppDomain.DoCallBack(tcpSimplexServerWork);

            #endregion
        }
Example #21
0
		private void DoTestWithPartialTrust( CrossAppDomainDelegate test )
		{
			var appDomainSetUp = new AppDomainSetup() { ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase };
			var evidence = new Evidence();
			evidence.AddHostEvidence( new Zone( SecurityZone.Internet ) );
			var permisions = SecurityManager.GetStandardSandbox( evidence );
			AppDomain workerDomain = AppDomain.CreateDomain( "PartialTrust", evidence, appDomainSetUp, permisions, GetStrongName( this.GetType() ) );
			try
			{
				workerDomain.DoCallBack( test );
			}
			finally
			{
				AppDomain.Unload( workerDomain );
			}
		}
Example #22
0
        /// <summary>
        /// Registers an event to all servers.
        /// </summary>
        /// <param name="eventName">The event name to register.</param>
        /// <param name="function">The function to register to the event.</param>
        /// <returns>Registration success?</returns>
        public bool RegisterEvent(string eventName, CrossAppDomainDelegate function)
        {
            int loc = Algorithms.BinarySearch.EventInfoBinarySearch( eventList, eventName );
            if ( loc < 0 )
                return false;

            //Get the method we need to create a delegate to.
            MethodInfo mi = typeof( ModuleEvents ).GetMethod( "On" + eventName );
            //Get the event we need to attach the delegate to.
            EventInfo ei = typeof( IRCEvents ).GetEvent( eventName );

            for ( int i = 0; i < IModule.MaxServers; i++ ) {

                IRCEvents serversIrcEvents = (IRCEvents)RequestVariable( Request.IRCEvents, i );

                if ( serversIrcEvents == null ) break;

                //When we add an event from IRCEvents --- CALLS --> OnEvent in ModuleEvents.
                //We can't let it add twice. ModuleEvents keeps it's own list of methods to call in the module it's on.
                //So if the method we would add to IRCEvents' handler is found in the IRCEvents.EventName delegate
                //we should not add it PROVIDING that the moduleEvents target on that handler is the same object as the one
                //we hold in our current ModuleProxy object.
                FieldInfo fi = typeof( IRCEvents ).GetField( eventName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetField );
                object o = fi.GetValue( serversIrcEvents );
                Delegate d = (Delegate)o;
                bool addToIRCEvents = true;
                if ( d != null ) {
                    Delegate[] invocList = d.GetInvocationList();
                    foreach ( Delegate invoc in invocList ) {
                        if ( invoc.Method.Equals( mi ) && this.moduleEvents.GetHashCode() == invoc.Target.GetHashCode() )
                            addToIRCEvents = false;
                    }
                }

                if ( addToIRCEvents )
                    // Servers IRCEvents Object --- CALLS --> OnPing in ModuleEvents
                    ei.AddEventHandler( serversIrcEvents, Delegate.CreateDelegate( ei.EventHandlerType, moduleEvents, mi ) );

                // ModuleLoader's ModuleEvents Object ---- CALLS --> 'function' inside the Module.
                ( typeof( ModuleEvents ).GetEvent( eventName, BindingFlags.Public | BindingFlags.Instance ) )
                .AddEventHandler( this.moduleEvents, function );

            }

            return true;
        }
Example #23
0
        /// <summary>
        /// Enables a module to register a parse that will be activated on
        /// the events specified by the parsetype on all servers.
        /// </summary>
        /// <param name="parse">The parse to register.</param>
        /// <param name="d">The function to call.</param>
        /// <param name="parseType">The events to add the parse to.</param>
        public void RegisterParse(string parse, CrossAppDomainDelegate d, IRCEvents.ParseTypes parseType)
        {
            IRCEvents.Parse p = new IRCEvents.Parse( parse, d, parseType,
                instanceOfModule.GetType().GetField( "parseReturns", BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.SetField ),
                instanceOfModule
                );

            for ( int k = 0; k < IModule.MaxServers; k++ ) {

                IRCEvents serversIrcEvents = (IRCEvents)RequestVariable( Request.IRCEvents, k );
                if ( serversIrcEvents == null ) break;

                if ( serversIrcEvents.Parses.Count == 0 )
                    serversIrcEvents.Parses.Add( p );
                else {
                    for ( int i = 0; i < serversIrcEvents.Parses.Count; i++ )
                        if ( serversIrcEvents.Parses[i].ParseString.CompareTo( parse ) >= 0 ) {
                            serversIrcEvents.Parses.Insert( i, p ); //I hope to god this shoves to the right and not the left.
                            return;
                        }
                    serversIrcEvents.Parses.Insert( serversIrcEvents.Parses.Count - 1, p );
                }

            }
        }
Example #24
0
		//
		// AppDomain.DoCallBack works because AppDomain is a MarshalByRefObject
		// so, when you call AppDomain.DoCallBack, that's a remote call
		//
		public void DoCallBack (CrossAppDomainDelegate callBackDelegate)
		{
			if (callBackDelegate != null)
				callBackDelegate ();
		}
Example #25
0
        /// <summary>
        /// Enables a module to register a parse that will be activated on
        /// the events specified by the parsetype.
        /// </summary>
        /// <param name="parse">The parse to register.</param>
        /// <param name="serverid">The server to register the parse to.</param>
        /// <param name="d">The function to call.</param>
        /// <param name="parseType">The events to add the parse to.</param>
        public void RegisterWildcardParse(string parse, int serverid, CrossAppDomainDelegate d, IRCEvents.ParseTypes parseType)
        {
            IRCEvents.Parse p = new IRCEvents.Parse( parse, d, parseType,
                instanceOfModule.GetType().GetField("parseReturns", BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.SetField ),
                instanceOfModule
                );

            IRCEvents serversIrcEvents = (IRCEvents)RequestVariable( Request.IRCEvents, serverid );

            serversIrcEvents.WildcardParses.Add( p );
        }
        // This is useful for requesting execution of some code
        // in another appDomain ... the delegate may be defined 
        // on a marshal-by-value object or a marshal-by-ref or 
        // contextBound object.
        public void DoCallBack(CrossAppDomainDelegate callBackDelegate)
        {
            if (callBackDelegate == null)
                throw new ArgumentNullException("callBackDelegate");
            Contract.EndContractBlock();

            callBackDelegate();        
        }
	public void DoCallBack(CrossAppDomainDelegate theDelegate)
			{
				// TODO
				// for now just call it directly
				theDelegate();
			}