Playing with Remoting

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@176 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Client.config

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+	<system.runtime.remoting>
+		<application>
+			<client>			 
+				<wellknown  
+					url="http://localhost:8686/Debugger" 
+					type="DebuggerLibrary.NDebugger, Debugger.Core"
+				/>
+			</client>
+			<channels>
+				<channel ref="http" port="0">
+					<clientProviders>
+						<provider type="CustomSinks.PrivateEventHandlersClientChannelSinkProvider, Debugger.Core"
+						          customSinkType="CustomSinks.PrivateEventHandlersClientChannelSink, Debugger.Core" />
+						<provider type="CustomSinks.InvokeOnSTAClientChannelSinkProvider, Debugger.Core"
+						          customSinkType="CustomSinks.InvokeOnSTAClientChannelSink, Debugger.Core" />
+						<formatter ref="soap" typeFilterLevel="Full"/>
+					</clientProviders>
+					<serverProviders>
+						<formatter ref="soap" typeFilterLevel="Full"/>
+						<!--
+						<provider type="CustomSinks.InvokeOnSTAServerChannelSinkProvider, Debugger.Core"
+						          customSinkType="CustomSinks.InvokeOnSTAServerChannelSink, Debugger.Core" />
+						-->
+					</serverProviders>
+				</channel>
+			</channels>
+		</application>
+	</system.runtime.remoting>
+</configuration>

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Debugger.AddIn.csproj

@@ -31,9 +31,15 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <None Include="Client.config">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
     <None Include="Debugger.AddIn.addin">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Include="Server.config">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
     <Compile Include="Configuration\AssemblyInfo.cs" />
     <Compile Include="Src\Pads\BreakPointsPad.cs" />
     <Compile Include="Src\Pads\CallStackPad.cs" />

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Server.config

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+	<system.runtime.remoting>
+		<application>
+			<service>
+				<wellknown 
+				   mode="Singleton" 
+				   type="DebuggerLibrary.NDebugger, Debugger.Core"
+				   objectUri="Debugger"
+				/>
+			</service>
+			<channels>
+				<channel ref="http" port="8686">
+					<clientProviders>
+						<provider type="CustomSinks.PrivateEventHandlersClientChannelSinkProvider, Debugger.Core"
+						          customSinkType="CustomSinks.PrivateEventHandlersClientChannelSink, Debugger.Core" />
+						<formatter ref="soap" typeFilterLevel="Full"/>
+					</clientProviders>
+					<serverProviders>
+						<formatter ref="soap" typeFilterLevel="Full"/>
+					</serverProviders>
+				</channel>
+			</channels>
+		</application>
+	</system.runtime.remoting>
+</configuration>

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/BreakPointsPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class BreakPointsPad : AbstractPadContent
 	{
 		WindowsDebugger debugger;
+		NDebugger debuggerCore;
 
 		ListView  breakpointsList;
 		
@@ -43,6 +44,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
 			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debuggerCore = debugger.DebuggerCore;
 
 			breakpointsList = new ListView();
 			breakpointsList.FullRowSelect = true;
@@ -59,11 +61,11 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			name.Width = 300;
 			path.Width = 400;
 			
-			debugger.DebuggingResumed += new DebuggerEventHandler(debuggerService_OnDebuggingResumed);
-			debugger.BreakpointAdded += new DebuggerLibrary.BreakpointEventHandler(AddBreakpoint);
-			debugger.BreakpointStateChanged += new DebuggerLibrary.BreakpointEventHandler(RefreshBreakpoint);
-			debugger.BreakpointRemoved += new DebuggerLibrary.BreakpointEventHandler(RemoveBreakpoint);
-			debugger.BreakpointHit += new DebuggerLibrary.BreakpointEventHandler(Breakpoints_OnBreakpointHit);
+			debuggerCore.DebuggingResumed += new DebuggerEventHandler(debuggerService_OnDebuggingResumed);
+			debuggerCore.BreakpointAdded += new DebuggerLibrary.BreakpointEventHandler(AddBreakpoint);
+			debuggerCore.BreakpointStateChanged += new DebuggerLibrary.BreakpointEventHandler(RefreshBreakpoint);
+			debuggerCore.BreakpointRemoved += new DebuggerLibrary.BreakpointEventHandler(RemoveBreakpoint);
+			debuggerCore.BreakpointHit += new DebuggerLibrary.BreakpointEventHandler(Breakpoints_OnBreakpointHit);
 			
 			RedrawContent();
 		}
@@ -92,7 +94,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			breakpointsList.ItemCheck -= new ItemCheckEventHandler(BreakpointsListItemCheck);
 			breakpointsList.BeginUpdate();
 			breakpointsList.Items.Clear();
-			foreach(DebuggerLibrary.Breakpoint b in debugger.Breakpoints) {
+			foreach(DebuggerLibrary.Breakpoint b in debuggerCore.Breakpoints) {
 				AddBreakpoint(new BreakpointEventArgs(b));
 			}
 			breakpointsList.EndUpdate();
@@ -157,7 +159,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void debuggerService_OnDebuggingResumed(object sender, DebuggerEventArgs e)
 		{
 			breakpointsList.BeginUpdate();
-			foreach(DebuggerLibrary.Breakpoint b in debugger.Breakpoints)
+			foreach(DebuggerLibrary.Breakpoint b in debuggerCore.Breakpoints)
 				RefreshBreakpoint(this, new BreakpointEventArgs(b));
 			breakpointsList.EndUpdate();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/CallStackPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class CallStackPad : AbstractPadContent
 	{
 		WindowsDebugger debugger;
+		NDebugger debuggerCore;
 
 		ListView  callStackList;
 		
@@ -43,6 +44,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
 			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debuggerCore = debugger.DebuggerCore;
 
 			callStackList = new ListView();
 			callStackList.FullRowSelect = true;
@@ -57,8 +59,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			name.Width = 300;
 			language.Width = 400;
 			
-			debugger.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
-			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debuggerCore.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debuggerCore.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
 
 			RedrawContent();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/ExceptionHistoryPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class ExceptionHistoryPad : AbstractPadContent
 	{
 		WindowsDebugger debugger;
+		NDebugger debuggerCore;
 
 		ListView  exceptionHistoryList;
 		
@@ -44,6 +45,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
 			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debuggerCore = debugger.DebuggerCore;
 
 			exceptionHistoryList = new ListView();
 			exceptionHistoryList.FullRowSelect = true;
@@ -59,8 +61,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			location.Width = 400;
 			time.Width = 80;
 			
-			debugger.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
-			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debuggerCore.IsDebuggingChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debuggerCore.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
 
 			RedrawContent();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/LoadedModulesPad.cs

@@ -22,6 +22,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class LoadedModulesPad : AbstractPadContent
 	{
 		WindowsDebugger debugger;
+		NDebugger debuggerCore;
 
 		ListView  loadedModulesList;
 		
@@ -49,6 +50,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
 			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debuggerCore = debugger.DebuggerCore;
 
 			loadedModulesList = new ListView();
 			loadedModulesList.FullRowSelect = true;
@@ -68,8 +70,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			timestamp.Width = 0;//80;
 			information.Width = 130;
 
-			debugger.ModuleLoaded += new DebuggerLibrary.ModuleEventHandler(AddModule);
-			debugger.ModuleUnloaded += new DebuggerLibrary.ModuleEventHandler(RemoveModule);
+			debuggerCore.ModuleLoaded += new DebuggerLibrary.ModuleEventHandler(AddModule);
+			debuggerCore.ModuleUnloaded += new DebuggerLibrary.ModuleEventHandler(RemoveModule);
 
 			RedrawContent();
 		}
@@ -87,7 +89,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			information.Text  = StringParser.Parse("${res:MainWindow.Windows.Debug.InformationColumn}");
 
             loadedModulesList.Items.Clear();
-            foreach(Module m in debugger.Modules) {
+            foreach(Module m in debuggerCore.Modules) {
                 AddModule(this, new ModuleEventArgs(m));
             }
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/LocalVarPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class LocalVarPad : AbstractPadContent
 	{
 		WindowsDebugger debugger;
+		NDebugger debuggerCore;
 
 		TreeListView localVarList;
 		
@@ -44,6 +45,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
 			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debuggerCore = debugger.DebuggerCore;
 
 			ImageList imageList = new ImageList();
 			imageList.Images.Add(IconService.GetBitmap("Icons.16x16.Class"));
@@ -65,7 +67,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 
 			localVarList.BeforeExpand += new TreeListViewCancelEventHandler(localVarList_BeforeExpand);
 			
-			debugger.DebuggingPaused += new DebuggingPausedEventHandler(debuggerService_OnDebuggingPaused);
+			debuggerCore.DebuggingPaused += new DebuggingPausedEventHandler(debuggerService_OnDebuggingPaused);
 
 			RedrawContent();
 		}
@@ -86,7 +88,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			localVarList.BeginUpdate();
 			localVarList.Items.Clear();
 
-			AddVariables(localVarList.Items, debugger.LocalVariables);
+			AddVariables(localVarList.Items, debuggerCore.LocalVariables);
 
 			localVarList.EndUpdate();
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/RunningThreadsPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class RunningThreadsPad : AbstractPadContent
 	{
 		WindowsDebugger debugger;
+		NDebugger debuggerCore;
 
 		ListView  runningThreadsList;
 		
@@ -46,6 +47,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		void InitializeComponents()
 		{
 			debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
+			debuggerCore = debugger.DebuggerCore;
 
 			runningThreadsList = new ListView();
 			runningThreadsList.FullRowSelect = true;
@@ -64,10 +66,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			breaked.Width = 80;
 		
 			
-			debugger.ThreadStarted += new ThreadEventHandler(AddThread);
-			debugger.ThreadStateChanged += new ThreadEventHandler(RefreshThread);
-			debugger.ThreadExited += new ThreadEventHandler(RemoveThread);
-			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debuggerCore.ThreadStarted += new ThreadEventHandler(AddThread);
+			debuggerCore.ThreadStateChanged += new ThreadEventHandler(RefreshThread);
+			debuggerCore.ThreadExited += new ThreadEventHandler(RemoveThread);
+			debuggerCore.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
 	
 			RedrawContent();
 		}
@@ -134,7 +136,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 
 		private void RefreshAllItems()
 		{
-			foreach (Thread t in debugger.Threads) {
+			foreach (Thread t in debuggerCore.Threads) {
 				RefreshThread(this, new ThreadEventArgs(t));
 			}
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/WindowsDebugger.cs

@@ -29,13 +29,64 @@ using ICSharpCode.SharpDevelop.Project;
 //using ICSharpCode.SharpDevelop.Internal.Project;
 //using ICSharpCode.SharpDevelop.Gui.Dialogs;
 using ICSharpCode.SharpDevelop.Services;
+using System.Runtime.Remoting;
+using System.Reflection;
+using System.Security.Policy;
 
 //using Reflector.UserInterface;
 
 namespace ICSharpCode.SharpDevelop.Services
 {	
-	public class WindowsDebugger:NDebugger, IDebugger //, IService
+	public class WindowsDebugger:IDebugger //, IService
 	{
+		[Serializable]
+		public class RemotingConfigurationHelpper
+		{
+			public string path;
+
+			public RemotingConfigurationHelpper(string path)
+			{
+				this.path = path;
+			}
+
+			public void Configure()
+			{
+				AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
+				
+				RemotingConfiguration.Configure(Path.Combine(path, "Client.config"));
+
+				string baseDir = Directory.GetDirectoryRoot(AppDomain.CurrentDomain.BaseDirectory);
+				string relDirs = AppDomain.CurrentDomain.BaseDirectory + ";" + path;
+				AppDomain serverAppDomain = AppDomain.CreateDomain("Debugging server",
+				                                                   new Evidence(AppDomain.CurrentDomain.Evidence),
+																   baseDir,
+																   relDirs,
+																   AppDomain.CurrentDomain.ShadowCopyFiles);
+				serverAppDomain.DoCallBack(new CrossAppDomainDelegate(ConfigureServer));
+			}
+
+			private void ConfigureServer()
+			{
+				AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
+				RemotingConfiguration.Configure(Path.Combine(path, "Server.config"));
+			}
+
+			Assembly AssemblyResolve(object sender, ResolveEventArgs args)
+			{
+				foreach (System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) {
+					string fullFilename = assembly.Location;
+					if (Path.GetFileNameWithoutExtension(fullFilename).ToLower() == args.Name.ToLower()) {
+						return assembly;
+					}
+				}
+				return null;
+			}
+		}
+
+		bool useRemotingForThreadInterop = false;
+
+		NDebugger debugger;
+
 		public event EventHandler DebugStopped; // FIX: unused
 
 		List<DebuggerLibrary.Exception> exceptionHistory = new List<DebuggerLibrary.Exception>();
@@ -52,7 +103,11 @@ namespace ICSharpCode.SharpDevelop.Services
 			
 		}
 		
-
+		public NDebugger DebuggerCore {
+			get {
+				return debugger;
+			}
+		}
 		
 		MessageViewCategory messageViewCategoryDebug;
 		MessageViewCategory messageViewCategoryDebuggerLog;
@@ -78,6 +133,25 @@ namespace ICSharpCode.SharpDevelop.Services
 		
 		public WindowsDebugger()
 		{
+			if (useRemotingForThreadInterop) {
+				// This needs to be called before instance of NDebugger is created
+				string path = null;
+				foreach (System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) {
+					string fullFilename = assembly.Location;
+					if (Path.GetFileName(fullFilename).ToLower() == "debugger.core.dll") {
+						path = Path.GetDirectoryName(fullFilename);
+						break;
+					}
+				}
+
+				if (path == null) {
+					throw new System.Exception("Debugger.Core.dll is not loaded");
+				}
+				new RemotingConfigurationHelpper(path).Configure();
+			}
+
+			debugger = new NDebugger();
+
 			InitializeService();
 		}
 		
@@ -88,6 +162,15 @@ namespace ICSharpCode.SharpDevelop.Services
 		
 		public void InitializeService()
 		{
+			debugger.DebuggerTraceMessage    += new MessageEventHandler(DebuggerTraceMessage);
+			debugger.LogMessage              += new MessageEventHandler(LogMessage);
+			debugger.DebuggingStarted        += new DebuggerEventHandler(DebuggingStarted);
+			debugger.DebuggingPaused         += new DebuggingPausedEventHandler(DebuggingPaused);
+			debugger.DebuggingResumed        += new DebuggerEventHandler(DebuggingResumed);
+			debugger.DebuggingStopped        += new DebuggerEventHandler(DebuggingStopped);
+			debugger.IsProcessRunningChanged += new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.BreakpointStateChanged += new DebuggerLibrary.BreakpointEventHandler(RestoreSharpdevelopBreakpoint);
+
 			DebuggerService.BreakPointAdded   += new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointRemoved += new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointChanged += new EventHandler(RestoreNDebuggerBreakpoints);
@@ -99,6 +182,13 @@ namespace ICSharpCode.SharpDevelop.Services
 
 		public void UnloadService()
 		{
+			debugger.DebuggerTraceMessage   -= new MessageEventHandler(DebuggerTraceMessage);
+			debugger.LogMessage             -= new MessageEventHandler(LogMessage);
+			debugger.DebuggingStarted       -= new DebuggerEventHandler(DebuggingStarted);
+			debugger.DebuggingPaused        -= new DebuggingPausedEventHandler(DebuggingPaused);
+			debugger.IsProcessRunningChanged -= new DebuggerEventHandler(DebuggerStateChanged);
+			debugger.BreakpointStateChanged -= new DebuggerLibrary.BreakpointEventHandler(RestoreSharpdevelopBreakpoint);
+
 			DebuggerService.BreakPointAdded   -= new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointRemoved -= new EventHandler(RestoreNDebuggerBreakpoints);
 			DebuggerService.BreakPointChanged -= new EventHandler(RestoreNDebuggerBreakpoints);
@@ -110,6 +200,17 @@ namespace ICSharpCode.SharpDevelop.Services
 		#endregion		
 		
 		#region ICSharpCode.SharpDevelop.Services.IDebugger interface implementation
+		public bool IsDebugging { 
+			get { 
+				return debugger.IsDebugging; 
+			} 
+		}
+		
+		public bool IsProcessRunning { 
+			get { 
+				return debugger.IsProcessRunning; 
+			} 
+		}
 		
 		public bool SupportsStartStop { 
 			get { 
@@ -123,64 +224,90 @@ namespace ICSharpCode.SharpDevelop.Services
 			} 
 		}
 		
+		public void StartWithoutDebugging(System.Diagnostics.ProcessStartInfo psi)
+		{
+			debugger.StartWithoutDebugging(psi);
+		}
+		
+		public void Start(string fileName, string workingDirectory, string arguments)
+		{
+			debugger.Start(fileName, workingDirectory, arguments);
+		}
+		
 		public void Stop()
 		{
-			this.Terminate();
+			debugger.Terminate();
 		}
 		
+		public void Break()
+		{
+			debugger.Break();
+		}
+		
+		public void StepInto()
+		{
+			debugger.StepInto();
+		}
+		
+		public void StepOver()
+		{
+			debugger.StepOver();
+		}
+		
+		public void StepOut()
+		{
+			debugger.StepOut();
+		}
+		
+		public void Continue()
+		{
+			debugger.Continue();
+		}
 		#endregion
 		
 
 		
 		public void RestoreNDebuggerBreakpoints(object sender, EventArgs e)
 		{
-			ClearBreakpoints();
+			debugger.ClearBreakpoints();
 			foreach (ICSharpCode.Core.Breakpoint b in DebuggerService.Breakpoints) {
-				DebuggerLibrary.Breakpoint newBreakpoint = new DebuggerLibrary.Breakpoint(this, b.FileName, b.LineNumber, 0, b.IsEnabled); 
+				DebuggerLibrary.Breakpoint newBreakpoint = new DebuggerLibrary.Breakpoint(debugger, b.FileName, b.LineNumber, 0, b.IsEnabled); 
 				newBreakpoint.Tag = b;
 				b.Tag = newBreakpoint;
-				AddBreakpoint(newBreakpoint); 
-			}
+				debugger.AddBreakpoint(newBreakpoint); 
 			}
-
-		protected override void OnBreakpointStateChanged(object sender, BreakpointEventArgs e)
-		{
-			RestoreSharpdevelopBreakpoint(e.Breakpoint);
 		}
 
-		public void RestoreSharpdevelopBreakpoint(DebuggerLibrary.Breakpoint breakpoint)
+		public void RestoreSharpdevelopBreakpoint(object sender, BreakpointEventArgs e)
 		{
-			ICSharpCode.Core.Breakpoint sdBreakpoint = breakpoint.Tag as ICSharpCode.Core.Breakpoint;
+			ICSharpCode.Core.Breakpoint sdBreakpoint = e.Breakpoint.Tag as ICSharpCode.Core.Breakpoint;
 			if (sdBreakpoint != null) {
-				sdBreakpoint.IsEnabled  = breakpoint.Enabled;
-				sdBreakpoint.FileName   = breakpoint.SourcecodeSegment.SourceFullFilename;
-				sdBreakpoint.LineNumber = breakpoint.SourcecodeSegment.StartLine;
+				sdBreakpoint.IsEnabled  = e.Breakpoint.Enabled;
+				sdBreakpoint.FileName   = e.Breakpoint.SourcecodeSegment.SourceFullFilename;
+				sdBreakpoint.LineNumber = e.Breakpoint.SourcecodeSegment.StartLine;
 			}
 		}
 		
 		// Output messages that report status of debugger
-		protected override void OnDebuggerTraceMessage(string message)
+		void DebuggerTraceMessage(object sender, MessageEventArgs e)
 		{
-			base.OnDebuggerTraceMessage(message);
 			if (messageViewCategoryDebuggerLog != null) {
-				messageViewCategoryDebuggerLog.AppendText(message + "\n");
-				System.Console.WriteLine(message);
+				messageViewCategoryDebuggerLog.AppendText(e.Message + "\n");
+				System.Console.WriteLine(e.Message);
 			}
 		}
 		
 		// Output messages form debuged program that are caused by System.Diagnostics.Trace.WriteLine(), etc...
-		protected override void OnLogMessage(string message)
+		void LogMessage(object sender, MessageEventArgs e)
 		{
-			base.OnLogMessage(message);
-			OnDebuggerTraceMessage(message);
+			DebuggerTraceMessage(this, e);
 			if (messageViewCategoryDebug != null) {
-				messageViewCategoryDebug.AppendText(message + "\n");
+				messageViewCategoryDebug.AppendText(e.Message + "\n");
 			}
 		}
 		
-		protected override void OnDebuggingStarted()
+		void DebuggingStarted(object sender, DebuggerEventArgs e)
 		{
-			base.OnDebuggingStarted();
 			// Initialize 
 			/*PadDescriptor cmv = (CompilerMessageView)WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView));
 			if (messageViewCategoryDebug == null) {	
@@ -194,25 +321,24 @@ namespace ICSharpCode.SharpDevelop.Services
 			messageViewCategoryDebuggerLog.ClearText();*/
 		}
 
-		protected override void OnDebuggingPaused(PausedReason reason)
+		void DebuggingPaused(object sender, DebuggingPausedEventArgs e)
 		{
-			base.OnDebuggingPaused(reason);
-			if (reason == PausedReason.Exception) {
-				exceptionHistory.Add(CurrentThread.CurrentException);
-				if (CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED && (CatchHandledExceptions == false)) {
+			if (e.Reason == PausedReason.Exception) {
+				exceptionHistory.Add(debugger.CurrentThread.CurrentException);
+				if (debugger.CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED && (debugger.CatchHandledExceptions == false)) {
 					// Ignore the exception
 					Continue();
 					return;
 				}
 				
 				
-				//MessageBox.Show("Exception was thrown in debugee:\n" + NDebugger.CurrentThread.CurrentException.ToString());
+				//MessageBox.Show("Exception was thrown in debugee:\n" + debugger.CurrentThread.CurrentException.ToString());
 				ExceptionForm form = new ExceptionForm();
 				form.label.Text = "Exception " + 
-				                  CurrentThread.CurrentException.Type +
+				                  debugger.CurrentThread.CurrentException.Type +
                                   " was thrown in debugee:\n" +
-				                  CurrentThread.CurrentException.Message;
-				form.pictureBox.Image = ResourceService.GetBitmap((CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED)?"Icons.32x32.Warning":"Icons.32x32.Error");
+				                  debugger.CurrentThread.CurrentException.Message;
+				form.pictureBox.Image = ResourceService.GetBitmap((debugger.CurrentThread.CurrentException.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED)?"Icons.32x32.Warning":"Icons.32x32.Error");
 				form.ShowDialog(ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.MainForm);
 				switch (form.result) {
 					case ExceptionForm.Result.Break: 
@@ -228,22 +354,20 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 			
 			try {
-				SelectThread(CurrentThread);
+				SelectThread(debugger.CurrentThread);
 			} catch (CurrentThreadNotAviableException) {}
 			JumpToCurrentLine();
 		}
 		
-		protected override void OnDebuggingResumed()
+		void DebuggingResumed(object sender, DebuggerEventArgs e)
 		{
-			base.OnDebuggingResumed();
 			selectedThread = null;
 			selectedFunction = null;
 			DebuggerService.RemoveCurrentLineMarker();
 		}
 		
-		protected override void OnDebuggingStopped()
+		void DebuggingStopped(object sender, DebuggerEventArgs e)
 		{
-			base.OnDebuggingStopped();
 			exceptionHistory.Clear();
 			//DebuggerService.Stop();//TODO: delete
 		}
@@ -287,9 +411,8 @@ namespace ICSharpCode.SharpDevelop.Services
 			}
 		}
 		
-		protected override void OnIsProcessRunningChanged()
+		public void DebuggerStateChanged(object sender, DebuggerEventArgs e)
 		{
-			base.OnIsProcessRunningChanged();
 			UpdateToolbars();
 		}
 		
@@ -306,8 +429,8 @@ namespace ICSharpCode.SharpDevelop.Services
 		/// </summary>
 		public string GetValueAsString(string variableName)
 		{
-			if (!IsDebugging || IsProcessRunning) return null;
-			VariableCollection collection = LocalVariables;
+			if (!debugger.IsDebugging || debugger.IsProcessRunning) return null;
+			VariableCollection collection = debugger.LocalVariables;
 			if (collection == null)
 				return null;
 			foreach (Variable v in collection) {

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/NDebugger.cs

@@ -13,7 +13,7 @@ using DebuggerInterop.MetaData;
 
 namespace DebuggerLibrary
 {
-	public partial class NDebugger
+	public partial class NDebugger: MarshalByRefObject
 	{
 		ICorDebug                  corDebug;
 		ManagedCallback            managedCallback;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/RemotingSinks/InvokeOnSTASink/InvokeOnSTAClientChannelSink.cs

@@ -63,13 +63,17 @@ namespace CustomSinks
 		IMessage IMessageSink.SyncProcessMessage(IMessage msg)
 		{
 			IMessage response = null;
-			Thread thread = new Thread(new ThreadStart(delegate {
+			//Thread thread = new Thread(new ThreadStart(delegate {
 				response = nextSink.SyncProcessMessage(msg);
-			}));
+			//}));
 
-			thread.Start();
+			//thread.Start();
+			//thread.Join();
 
-			while (thread.IsAlive) Application.DoEvents();
+			ThreadPriority oldPriority = Thread.CurrentThread.Priority;
+			Thread.CurrentThread.Priority = ThreadPriority.BelowNormal;
+			//while (thread.IsAlive) Application.DoEvents();
+			Thread.CurrentThread.Priority = oldPriority;
 
 			return response;
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/RemotingSinks/PrivateEventHandlersSink/EventForwarder.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Windows.Forms;
 
 namespace CustomSinks
 {
@@ -13,59 +14,73 @@ namespace CustomSinks
 			this.realEvent = realEvent;
 		}
 
+		void DynamicInvoke(params object[] par)
+		{
+			// TODO: Walkaround - custom sinks do not work properly in same Process - they are ignored
+			if (Application.OpenForms.Count > 0) {
+				Application.OpenForms[0].Invoke(new EventHandler(delegate
+				{
+					realEvent.DynamicInvoke(par);
+				}));
+			} else {
+				realEvent.DynamicInvoke(par);
+			}
+			//realEvent.DynamicInvoke(par);
+		}
+
 		public void ForwardEvent0()
 		{
-			realEvent.DynamicInvoke(new object[] {});
+			DynamicInvoke(new object[] {});
 		}
 
 		public void ForwardEvent1(object p1)
 		{
-			realEvent.DynamicInvoke(new object[] { p1});
+			DynamicInvoke(new object[] { p1});
 		}
 
 		public void ForwardEvent2(object p1, object p2)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2});
+			DynamicInvoke(new object[] { p1, p2});
 		}
 
 		public void ForwardEvent3(object p1, object p2, object p3)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3});
+			DynamicInvoke(new object[] { p1, p2, p3});
 		}
 
 		public void ForwardEvent4(object p1, object p2, object p3, object p4)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4});
+			DynamicInvoke(new object[] { p1, p2, p3, p4});
 		}
 
 		public void ForwardEvent5(object p1, object p2, object p3, object p4, object p5)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4, p5});
+			DynamicInvoke(new object[] { p1, p2, p3, p4, p5});
 		}
 
 		public void ForwardEvent6(object p1, object p2, object p3, object p4, object p5, object p6)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6});
+			DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6});
 		}
 
 		public void ForwardEvent7(object p1, object p2, object p3, object p4, object p5, object p6, object p7)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7});
+			DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7});
 		}
 
 		public void ForwardEvent8(object p1, object p2, object p3, object p4, object p5, object p6, object p7, object p8)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7, p8});
+			DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7, p8});
 		}
 
 		public void ForwardEvent9(object p1, object p2, object p3, object p4, object p5, object p6, object p7, object p8, object p9)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7, p8, p9});
+			DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7, p8, p9});
 		}
 
 		public void ForwardEvent10(object p1, object p2, object p3, object p4, object p5, object p6, object p7, object p8, object p9, object p10)
 		{
-			realEvent.DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10});
+			DynamicInvoke(new object[] { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10});
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/RemotingSinks/PrivateEventHandlersSink/PrivateEventHandlersClientChannelSink.cs

@@ -63,6 +63,7 @@ namespace CustomSinks
 
 		IMessage IMessageSink.SyncProcessMessage(IMessage msg)
 		{
+			Console.WriteLine("Remoting message:" + msg.Properties["__MethodName"].ToString());
 			MethodCall methodCall = new MethodCall(msg);
 			if (methodCall.ArgCount > 0 && methodCall.Args[0] is Delegate) {
 				Delegate realDelegate = methodCall.Args[0] as Delegate;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/RemotingSinks/PrivateEventHandlersSink/PrivateEventHandlersSink.csproj

@@ -19,6 +19,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml" />
     <Reference Include="System.Runtime.Remoting, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
   </ItemGroup>