✨ Conditional Breakpoints

src/SharpDbg.Application/DebugAdapter.cs

@@ -183,7 +183,8 @@ protected override InitializeResponse HandleInitializeRequest(InitializeArgument
 		{
 			SupportsConfigurationDoneRequest = true,
 			SupportsFunctionBreakpoints = true,
-			SupportsConditionalBreakpoints = false,
+			SupportsConditionalBreakpoints = true,
+			SupportsHitConditionalBreakpoints = true,
 			SupportsEvaluateForHovers = true,
 			SupportsStepBack = false,
 			SupportsSetVariable = false,
@@ -261,8 +262,14 @@ protected override SetBreakpointsResponse HandleSetBreakpointsRequest(SetBreakpo
 				throw new ProtocolException("Missing source path");
 			}
 
-			var lines = arguments.Breakpoints?.Select(bp => ConvertClientLineToDebugger(bp.Line)).ToArray() ?? Array.Empty<int>();
-			var breakpoints = _debugger.SetBreakpoints(arguments.Source.Path, lines);
+			var breakpointRequests = arguments.Breakpoints?
+				.Select(bp => new SharpDbgBreakpointRequest(
+					ConvertClientLineToDebugger(bp.Line),
+					bp.Condition,
+					bp.HitCondition))
+				.ToArray() ?? [];
+
+			var breakpoints = _debugger.SetBreakpoints(arguments.Source.Path, breakpointRequests);
 
 			var responseBreakpoints = breakpoints.Select(bp => new MSBreakpoint
 			{

src/SharpDbg.Infrastructure/Debugger/BreakpointManager.cs

@@ -25,22 +25,36 @@ public class BreakpointInfo
 		public int? MethodToken { get; set; }
 		public int? ILOffset { get; set; }
 		public CORDB_ADDRESS? ModuleBaseAddress { get; set; }
+
+		/// <summary>Conditional expression to evaluate when breakpoint is hit</summary>
+		public string? Condition { get; set; }
+
+		/// <summary>Hit count condition (e.g., ">=10", "==5", "%3")</summary>
+		public string? HitCondition { get; set; }
+
+		/// <summary>Current hit count for this breakpoint</summary>
+		public int HitCount { get; set; }
 	}
 
 	/// <summary>
 	/// Create a new breakpoint
 	/// </summary>
-	public BreakpointInfo CreateBreakpoint(string filePath, int line)
+	public BreakpointInfo CreateBreakpoint(string filePath, int line, string? condition = null, string? hitCondition = null)
 	{
 		lock (_lock)
 		{
 			var id = _nextBreakpointId++;
+			if (string.IsNullOrWhiteSpace(condition)) condition = null;
+			if (string.IsNullOrWhiteSpace(hitCondition)) hitCondition = null;
 			var bp = new BreakpointInfo
 			{
 				Id = id,
 				FilePath = filePath,
 				Line = line,
-				Verified = false
+				Verified = false,
+				Condition = condition,
+				HitCondition = hitCondition,
+				HitCount = 0
 			};
 
 			_breakpoints[id] = bp;

src/SharpDbg.Infrastructure/Debugger/ManagedDebugger.cs

@@ -24,7 +24,7 @@ public partial class ManagedDebugger : IDisposable
 	private int? _pendingAttachProcessId;
 	private bool _justMyCode;
 	private AsyncStepper? _asyncStepper;
-	private CompiledExpressionInterpreter? _expressionInterpreter;
+	private CompiledExpressionInterpreter _expressionInterpreter = null!;
 
 	public event Action<int, string>? OnStopped;
 	// ThreadId, FilePath, Line, Reason

src/SharpDbg.Infrastructure/Debugger/ManagedDebugger_ConditionalBreakpoints.cs

@@ -0,0 +1,102 @@
+using System.Runtime.InteropServices;
+using ClrDebug;
+using SharpDbg.Infrastructure.Debugger.ExpressionEvaluator;
+using SharpDbg.Infrastructure.Debugger.ExpressionEvaluator.Compiler;
+
+namespace SharpDbg.Infrastructure.Debugger;
+
+public partial class ManagedDebugger
+{
+	private async Task<bool> EvaluateBreakpointCondition(CorDebugThread corThread, string condition)
+	{
+		try
+		{
+			var threadId = new ThreadId(corThread.Id);
+			var frameStackDepth = new FrameStackDepth(0); // Top frame
+
+			var compiledExpression = ExpressionCompiler.Compile(condition, false);
+			var evalContext = new CompiledExpressionEvaluationContext(corThread, threadId, frameStackDepth);
+			var result = await _expressionInterpreter.Interpret(compiledExpression, evalContext);
+
+			if (result.Error is not null)
+			{
+				_logger?.Invoke($"Condition evaluation error for '{condition}': {result.Error}");
+				return false; // Don't stop on error - condition couldn't be evaluated, so skip the breakpoint
+			}
+
+			return IsTruthyValue(result.Value);
+		}
+		catch (Exception ex)
+		{
+			_logger?.Invoke($"Exception evaluating condition '{condition}': {ex.Message}");
+			return false; // Don't stop on exception - condition couldn't be evaluated, so skip the breakpoint
+		}
+	}
+
+	private static bool EvaluateHitCondition(int hitCount, string hitCondition)
+	{
+		// Support common hit count formats:
+		// "10" or "==10" - break when hit count equals 10
+		// ">=10" - break when hit count is >= 10
+		// ">10" - break when hit count is > 10
+		// "%10" - break every 10th hit (modulo)
+
+		hitCondition = hitCondition.Trim();
+		var hitConditionSpan = hitCondition.AsSpan();
+		return hitConditionSpan switch
+		{
+			['>', '=', ..] => int.TryParse(hitConditionSpan[2..], out var threshold) && hitCount >= threshold,
+			['>', ..] => int.TryParse(hitConditionSpan[1..], out var threshold) && hitCount > threshold,
+			['<', '=', ..] => int.TryParse(hitConditionSpan[2..], out var threshold) && hitCount <= threshold,
+			['<', ..] => int.TryParse(hitConditionSpan[1..], out var threshold) && hitCount < threshold,
+			['%', ..] => int.TryParse(hitConditionSpan[1..], out var modulo) && modulo > 0 && hitCount % modulo == 0,
+			['=', '=', ..] => int.TryParse(hitConditionSpan[2..], out var target) && hitCount == target,
+			_ => int.TryParse(hitConditionSpan, out var target) && hitCount == target // Plain number means break when hit count = number
+		};
+	}
+
+	/// <summary>
+	/// Check if a debug value is truthy (true, non-zero, non-null)
+	/// </summary>
+	private static bool IsTruthyValue(CorDebugValue? value)
+	{
+		if (value is null) return false;
+
+		var unwrapped = value.UnwrapDebugValue();
+
+		if (unwrapped is CorDebugGenericValue genericValue)
+		{
+			var buffer = Marshal.AllocHGlobal(genericValue.Size);
+			try
+			{
+				genericValue.GetValue(buffer);
+				return genericValue.Type switch
+				{
+					CorElementType.Boolean => Marshal.ReadByte(buffer) != 0,
+					CorElementType.I1 or CorElementType.U1 => Marshal.ReadByte(buffer) != 0,
+					CorElementType.I2 or CorElementType.U2 => Marshal.ReadInt16(buffer) != 0,
+					CorElementType.I4 or CorElementType.U4 => Marshal.ReadInt32(buffer) != 0,
+					CorElementType.I8 or CorElementType.U8 => Marshal.ReadInt64(buffer) != 0,
+					CorElementType.R4 => BitConverter.ToSingle(BitConverter.GetBytes(Marshal.ReadInt32(buffer)), 0) != 0,
+					CorElementType.R8 => BitConverter.ToDouble(BitConverter.GetBytes(Marshal.ReadInt64(buffer)), 0) != 0,
+					_ => true // Unknown types - default to true
+				};
+			}
+			catch
+			{
+				return false;
+			}
+			finally
+			{
+				Marshal.FreeHGlobal(buffer);
+			}
+		}
+
+		if (unwrapped is CorDebugReferenceValue refValue)
+		{
+			return !refValue.IsNull;
+		}
+
+		return true;
+	}
+}

src/SharpDbg.Infrastructure/Debugger/ManagedDebugger_EventHandlers.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using System.Diagnostics;
 using ClrDebug;
 using SharpDbg.Infrastructure.Debugger.ExpressionEvaluator;
 using SharpDbg.Infrastructure.Debugger.ExpressionEvaluator.Interpreter;
@@ -148,6 +148,23 @@ private async void HandleBreakpoint(object? sender, BreakpointCorDebugManagedCal
 
 			var managedBreakpoint = _breakpointManager.FindByCorBreakpoint(functionBreakpoint.Raw);
 			ArgumentNullException.ThrowIfNull(managedBreakpoint);
+
+			managedBreakpoint.HitCount++;
+
+			if (managedBreakpoint.HitCondition is not null && EvaluateHitCondition(managedBreakpoint.HitCount, managedBreakpoint.HitCondition) is false)
+			{
+				_logger?.Invoke($"Hit count condition not met: count={managedBreakpoint.HitCount}, condition={managedBreakpoint.HitCondition}");
+				Continue();
+				return;
+			}
+
+			if (managedBreakpoint.Condition is not null && await EvaluateBreakpointCondition(corThread, managedBreakpoint.Condition) is false)
+			{
+				_logger?.Invoke($"Conditional breakpoint condition not met: {managedBreakpoint.Condition}");
+				Continue();
+				return;
+			}
+
 			IsRunning = false;
 			OnStopped2?.Invoke(corThread.Id, managedBreakpoint.FilePath, managedBreakpoint.Line, "breakpoint", null);
 		}

src/SharpDbg.Infrastructure/Debugger/ManagedDebugger_RequestHandlers.cs

@@ -10,6 +10,8 @@
 
 namespace SharpDbg.Infrastructure.Debugger;
 
+public record SharpDbgBreakpointRequest(int Line, string? Condition = null, string? HitCondition = null);
+
 public partial class ManagedDebugger
 {
 	// Store launch info for deferred attach in ConfigurationDone
@@ -315,12 +317,12 @@ public async void StepOut(int threadId)
 	}
 
 	/// <summary>
-	/// Set breakpoints for a source file
+	/// Set breakpoints for a source file with optional conditions
 	/// </summary>
-	public List<BreakpointManager.BreakpointInfo> SetBreakpoints(string filePath, int[] lines)
+	public List<BreakpointManager.BreakpointInfo> SetBreakpoints(string filePath, SharpDbgBreakpointRequest[] breakpoints)
 	{
 		//System.Diagnostics.Debugger.Launch();
-		_logger?.Invoke($"SetBreakpoints: {filePath}, lines: {string.Join(",", lines)}");
+		_logger?.Invoke($"SetBreakpoints: {filePath}, breakpoints: {string.Join(",", breakpoints.Select(b => $"L{b.Line}" + (b.Condition != null ? $"[{b.Condition}]" : "")))}");
 
 		// Deactivate and clear existing breakpoints for this file
 		var existingBreakpoints = _breakpointManager.GetBreakpointsForFile(filePath);
@@ -342,9 +344,9 @@ public async void StepOut(int threadId)
 
 		// Create new breakpoints
 		var result = new List<BreakpointManager.BreakpointInfo>();
-		foreach (var line in lines)
+		foreach (var request in breakpoints)
 		{
-			var bp = _breakpointManager.CreateBreakpoint(filePath, line);
+			var bp = _breakpointManager.CreateBreakpoint(filePath, request.Line, request.Condition, request.HitCondition);
 
 			// Try to bind the breakpoint if we have a process
 			if (_process != null)

tests/DebuggableConsoleApp/HitConditionClass.cs

@@ -0,0 +1,12 @@
+namespace DebuggableConsoleApp;
+
+public class HitConditionClass
+{
+	private static int _count = 0;
+
+	public void Test()
+	{
+		_count++;
+		; // breakpoint here
+	}
+}

tests/DebuggableConsoleApp/Program.cs

@@ -13,12 +13,14 @@ public static void Main(string[] args)
 		var myClass = new MyClass();
 		var myAsyncClass = new MyAsyncClass();
 		var myClassNoMembers = new MyClassNoMembers();
+		var hitConditionClass = new HitConditionClass();
 		while (true)
 		{
 			// Keep the application running to allow debugging
 			myLambdaClass.Test();
 			myClass.MyMethod(13, 6);
 			myClassNoMembers.MyMethod(42);
+			hitConditionClass.Test();
 			var asyncResult = myAsyncClass.MyMethodAsync(4).GetAwaiter().GetResult();
 			Thread.Sleep(100);
 			//await Task.Delay(500);