C# Client.Breakpoint类代码示例

		internal void Bind (PinnedWatch watch, Breakpoint be)
		{
			lock (watches) {
				if (be == null) {
					if (watch.BoundTracer != null)
						liveWatches.Remove (watch.BoundTracer);
					watch.LiveUpdate = false;
				} else {
					watch.BoundTracer = be;
					liveWatches [be] = watch;
					watch.LiveUpdate = true;
				}
			}
		}

		public BreakpointPropertiesDialog (Breakpoint bp, bool isNew)
		{
			this.Build();
			this.bp = bp;
			
			entryFile.Text = bp.FileName;
			entryLine.Text = bp.Line.ToString ();
			
			if (!isNew) {
				entryFile.IsEditable = false;
				entryLine.IsEditable = false;
				entryFile.ModifyBase (Gtk.StateType.Normal, Style.Backgrounds [(int)Gtk.StateType.Insensitive]);
				entryFile.ModifyBase (Gtk.StateType.Active, Style.Backgrounds [(int)Gtk.StateType.Insensitive]);
				entryLine.ModifyBase (Gtk.StateType.Normal, Style.Backgrounds [(int)Gtk.StateType.Insensitive]);
				entryLine.ModifyBase (Gtk.StateType.Active, Style.Backgrounds [(int)Gtk.StateType.Insensitive]);
			}
			
			if (string.IsNullOrEmpty (bp.ConditionExpression)) {
				radioBreakAlways.Active = true;
			} else {
				entryCondition.Text = bp.ConditionExpression;
				if (bp.BreakIfConditionChanges)
					radioBreakChange.Active = true;
				else
					radioBreakTrue.Active = true;
			}
			
			spinHitCount.Value = bp.HitCount;
			
			if (bp.HitAction == HitAction.Break)
				radioActionBreak.Active = true;
			else {
				radioActionTrace.Active = true;
				entryTraceExpr.Text = bp.TraceExpression;
			}
			
			Project project = IdeApp.Workspace.GetProjectContainingFile (bp.FileName);
			if (project != null) {
				// Check the startup project of the solution too, since the current project may be a library
				SolutionEntityItem startup = project.ParentSolution.StartupItem;
				boxConditionOptions.Sensitive = DebuggingService.IsFeatureSupported (project, DebuggerFeatures.ConditionalBreakpoints) ||
					DebuggingService.IsFeatureSupported (startup, DebuggerFeatures.ConditionalBreakpoints);
				boxAction.Sensitive = DebuggingService.IsFeatureSupported (project, DebuggerFeatures.Tracepoints) ||
					DebuggingService.IsFeatureSupported (startup, DebuggerFeatures.Tracepoints);
			}
			
			UpdateControls ();
		}

			public void Update (Breakpoint bp)
			{
				Update (bp.FileName, bp.Line, bp.Column);
			}

		void SetInitialBreakpointData (Breakpoint bp)
		{
			stopOnFunction.Visible = false;
			hboxFunction.Visible = false;
			stopOnException.Visible = false;
			vboxException.Visible = false;

			stopOnLocation.Active = true;
			breakpointLocation.Update (bp);

			entryLocationFile.Text = breakpointLocation.ToString ();
			Project project = null;
			if (!string.IsNullOrEmpty (bp.FileName))
				project = IdeApp.Workspace.GetProjectsContainingFile (bp.FileName).FirstOrDefault ();

			if (project != null) {
				// Check the startup project of the solution too, since the current project may be a library
				SolutionEntityItem startup = project.ParentSolution.StartupItem;
				entryConditionalExpression.Sensitive = DebuggingService.IsFeatureSupported (project, DebuggerFeatures.ConditionalBreakpoints) ||
				DebuggingService.IsFeatureSupported (startup, DebuggerFeatures.ConditionalBreakpoints);

				bool canTrace = DebuggingService.IsFeatureSupported (project, DebuggerFeatures.Tracepoints) ||
				                DebuggingService.IsFeatureSupported (startup, DebuggerFeatures.Tracepoints);

				breakpointActionPause.Sensitive = canTrace;
				entryPrintExpression.Sensitive = canTrace;
			}
		}

		void InsertBreakpoint (Breakpoint bp, BreakInfo bi)
		{
			bi.Req = vm.SetBreakpoint (bi.Location.Method, bi.Location.ILOffset);
			bi.Req.Enabled = bi.Enabled;
			breakpoints [bi.Req] = bi;
		}

		public static bool ShowBreakpointProperties (Breakpoint bp, bool editNew)
		{
			var dlg = new BreakpointPropertiesDialog (bp, editNew);
			if (MessageService.ShowCustomDialog (dlg) == (int) Gtk.ResponseType.Ok)
				return true;
			return false;
		}

		void AddBreakpoint (Breakpoint bp)
		{
			if (DebuggingService.PinnedWatches.IsWatcherBreakpoint (bp))
				return;
			FilePath fp = Name;
			if (fp.FullPath == bp.FileName) {
				DocumentLine line = widget.TextEditor.Document.GetLine (bp.Line);
				var status = bp.GetStatus (DebuggingService.DebuggerSession);
				
				if (line == null)
					return;
				if (!bp.Enabled) {
					if (bp.HitAction == HitAction.Break)
						widget.TextEditor.Document.AddMarker (line, new DisabledBreakpointTextMarker (widget.TextEditor, false));
					else
						widget.TextEditor.Document.AddMarker (line, new DisabledBreakpointTextMarker (widget.TextEditor, true));
				} else if (status == BreakEventStatus.Bound || status == BreakEventStatus.Disconnected) {
					if (bp.HitAction == HitAction.Break)
						widget.TextEditor.Document.AddMarker (line, new BreakpointTextMarker (widget.TextEditor, false));
					else
						widget.TextEditor.Document.AddMarker (line, new BreakpointTextMarker (widget.TextEditor, true));
				} else
					widget.TextEditor.Document.AddMarker (line, new InvalidBreakpointTextMarker (widget.TextEditor));
				widget.TextEditor.QueueDraw ();
				breakpointSegments.Add (line);
			}
		}

		void InsertBreakpoint (Breakpoint bp, BreakInfo bi)
		{
			bi.Req = vm.SetBreakpoint (bi.Location.Method, bi.Location.ILOffset);
			bi.Req.Enabled = bi.Enabled;
			breakpoints [bi.Req] = bi;
			OnBreakpointBound (bp, (BreakpointEventRequest) bi.Req);
		}

		void AddBreakpoint (Breakpoint bp)
		{
			if (DebuggingService.PinnedWatches.IsWatcherBreakpoint (bp))
				return;
			var textEditor = widget.TextEditor;
			if (textEditor == null)
				return;
			var document = textEditor.Document;
			if (document == null)
				return;

			FilePath fp = Name;
			if (fp.FullPath == bp.FileName) {
				if (bp.Line <= 0 || bp.Line > textEditor.Document.LineCount) {
					LoggingService.LogWarning ("Invalid breakpoint :" + bp + " in line " + bp.Line);
					return;
				}
				DocumentLine line = document.GetLine (bp.Line);
				var status = bp.GetStatus (DebuggingService.DebuggerSession);
				bool tracepoint = (bp.HitAction & HitAction.Break) == HitAction.None;

				if (line == null)
					return;

				//TODO: 1. When not in debug mode use Microsoft.CodeAnalysis.CSharp.EditAndContinue.BreakpointSpans.TryGetBreakpointSpan
				//TODO: 2. When in debug mode extend Breakpoint class to have endLine and endColumn set if .mdb/.pdb has endLine/endColumn
				var offset = line.Offset;
				var lenght = line.Length;
				DebugMarkerPair marker;
				if (!bp.Enabled) {
					marker = new DisabledBreakpointTextMarker (textEditor, offset, lenght, tracepoint);
				} else if (status == BreakEventStatus.Bound || status == BreakEventStatus.Disconnected) {
					marker = new BreakpointTextMarker (textEditor, offset, lenght, tracepoint);
				} else {
					marker = new InvalidBreakpointTextMarker (textEditor, offset, lenght, tracepoint);
				}

				textEditor.QueueDraw ();
				breakpointSegments.Add (marker);
				marker.AddTo (document, line);
			}
		}

		void InsertBreakpoint (Breakpoint bp, BreakInfo bi)
		{
			bi.Req = vm.SetBreakpoint (bi.Location.Method, bi.Location.ILOffset);
			bi.Req.Enabled = bi.BreakEvent.Enabled;
			breakpoints [bi.Req] = bi;
			
			if (bi.Location.LineNumber != bp.Line)
				bi.AdjustBreakpointLocation (bi.Location.LineNumber);
		}

		void AddBreakpoint (Breakpoint bp)
		{
			if (DebuggingService.PinnedWatches.IsWatcherBreakpoint (bp))
				return;
			var textEditor = widget.TextEditor;
			if (textEditor == null)
				return;
			var document = textEditor.Document;
			if (document == null)
				return;

			FilePath fp = Name;
			if (fp.FullPath == bp.FileName) {
				if (bp.Line <= 0 || bp.Line > textEditor.Document.LineCount) {
					LoggingService.LogWarning ("Invalid breakpoint :" + bp +" in line " + bp.Line); 
					return;
				}
				DocumentLine line = document.GetLine (bp.Line);
				var status = bp.GetStatus (DebuggingService.DebuggerSession);
				bool tracepoint = (bp.HitAction & HitAction.Break) == HitAction.None;

				if (line == null)
					return;

				if (!bp.Enabled) {
					document.AddMarker (line, new DisabledBreakpointTextMarker (textEditor, tracepoint));
				} else if (status == BreakEventStatus.Bound || status == BreakEventStatus.Disconnected) {
					document.AddMarker (line, new BreakpointTextMarker (textEditor, tracepoint));
				} else {
					document.AddMarker (line, new InvalidBreakpointTextMarker (textEditor, tracepoint));
				}

				textEditor.QueueDraw ();
				breakpointSegments.Add (line);
			}
		}

		public bool IsWatcherBreakpoint (Breakpoint bp)
		{
			lock (watches) {
				return liveWatches.ContainsKey (bp);
			}
		}

		internal bool UpdateLiveWatch (Breakpoint bp, string trace)
		{
			lock (watches) {
				PinnedWatch w;
				if (!liveWatches.TryGetValue (bp, out w))
					return false;
				w.UpdateFromTrace (trace);
				return true;
			}
		}

		public BreakpointEventArgs (Breakpoint bp)
		{
			this.bp = bp;
		}

		void SaveBreakpoint (Breakpoint bp)
		{
			bp.SetColumn (breakpointLocation.Column);
			bp.SetLine (breakpointLocation.Line);
		}