未处理的异常，无法调试

Question

我试图调试我的c＃应用程序，检查MIPS语法。但它不允许进行调试。无论我在哪里输入断点，它都会被忽略，包括Main（）函数的第一行。它也扔我这个错误。 '添加ABC' 工作正常，如果我不叫HasValidParams（） '添加AB' 抛出了同样的情况 例外既不工作调用HasValidParams时（）

的Program.cs

private static void Main(string[] args) 
     { 
      var validator = new MipsValidator(); 
      Console.Write("Please enter a MIPS statement: "); 
      string input = Console.ReadLine(); 
      List<string> arguments = input.Split(new char[0]).ToList(); 
      Response status = validator.IsSyntaxValid(arguments); 
      //Check syntax 
      if (status.Success.Equals(true)) 
      { 
       Response stat = validator.HasValidParams(arguments); 
       //Check parameters 
       if (stat.Success.Equals(true)) 
       { 
       Console.WriteLine(string.Format("'{0}' is a valid mips instruction ", input)); 
       } 
       else 
       { 
        foreach (var reason in stat.Reasons) 
        { 
         Console.WriteLine(reason); 
        } 
       } 
      } 
      else 
      { 
       foreach (string reason in status.Reasons) 
       { 
        Console.WriteLine(reason); 
       } 
      } 
     } 

MIPS

-validator.cs

using System; 
using System.Collections.Generic; 
using System.Text.RegularExpressions; 

namespace mips_validator.utils 
{ 
    public class MipsValidator : IMipsValidator 
    { 
     #region Implementation of IMipsValidator 

     public Response IsSyntaxValid(List<string> args) 
     { 
      var response = new Response {Success = true}; 
      var op = (Operator) Enum.Parse(typeof (Operator), args[0]); 
      switch (op) 
      { 
       case Operator.addi: 
       case Operator.add: 
       case Operator.beq: 
        if (args.Count != 4) 
        { 
         response.Reasons.Add(string.Format("4 operands required for {0}, {1} parameters provided.", 
                  op, args.Count)); 
         response.Success = false; 
        } 
        break; 
       case Operator.j: 
        if (args.Count != 2) 
        { 
         response.Reasons.Add(string.Format("1 operands required for {1}, {0} parameters provided.", 
                  args.Count, op)); 
         response.Success = false; 
        } 
        break; 
       default: 
        response.Reasons.Add(string.Format("{0} is an unknown mips operation", op)); 
        response.Success = false; 
        break; 
      } 
      return response; 
     } 

     public Response HasValidParams(List<string> parameters) 
     { 
      string op1, op2, op3; 
      var temporary = new Regex(@"/\$t\d+/"); 
      var store = new Regex(@"/\$s\d+/"); 
      var zero = new Regex(@"/\$zero/"); 
      var osReserved = new Regex(@"/\$k0|1/"); 
      var memory = new Regex(@""); 
      var constant = new Regex(@"/-?\d*/"); 
      var label = new Regex(@"/.*\:/"); 
      Operator operation; 
      var response = new Response {Success = true}; 
      string opString = parameters[0]; 
      Enum.TryParse(opString.Replace("$", string.Empty), true, out operation); 
      switch (operation) 
      { 
       case Operator.add: 
        { 
         op1 = parameters[1]; 
         op2 = parameters[2]; 
         if (!temporary.IsMatch(op1) && !store.IsMatch(op1) && !zero.IsMatch(op1)) 
         { 
          response.Reasons.Add(string.Format("{0}: error register expected", op1)); 
          response.Success = false; 
         } 
         if (!temporary.IsMatch(op2) && !store.IsMatch(op2) && !zero.IsMatch(op2)) 
         { 
          response.Reasons.Add(string.Format("{0}: error register expected", op2)); 
          response.Success = false; 
         } 
        } 
        break; 
       case Operator.addi: 
        { 
         op1 = parameters[1]; 
         op2 = parameters[2]; 
         if (!temporary.IsMatch(op1) && !store.IsMatch(op1) && !zero.IsMatch(op1)) 
         { 
          response.Reasons.Add(string.Format("{0}: error register expected", op1)); 
          response.Success = false; 
         } 
         if (!constant.IsMatch(op2) && !zero.IsMatch(op2)) 
         { 
          response.Reasons.Add(string.Format("{0}: error constant expected", op2)); 
          response.Success = false; 
         } 
        } 
        break; 
       case Operator.beq: 
        { 
         op1 = parameters[1]; 
         op2 = parameters[2]; 
         op3 = parameters[3]; 
         if (!temporary.IsMatch(op1) && !store.IsMatch(op1) && !zero.IsMatch(op1)) 
         { 
          response.Reasons.Add(string.Format("{0}: error register expected", op1)); 
          response.Success = false; 
         } 
         if (!temporary.IsMatch(op2) && !store.IsMatch(op2) && !zero.IsMatch(op2)) 
         { 
          response.Reasons.Add(string.Format("{0}: error register expected", op2)); 
          response.Success = false; 
         } 
         if (!label.IsMatch(op3) && !constant.IsMatch(op3)) 
         { 
          response.Reasons.Add(string.Format("{0}: error label or constant expected", op3)); 
          response.Success = false; 
         } 
        } 
        break; 
      } 

      return response; 
     } 

     #endregion 
    } 
} 

SOLUTION ------- 个Response.cs（旧）

public class Response 
{ 
    public List<string> Reasons; 
    public bool Success = true; 

} 

Response.cs（电流）

public class Response 
    { 
     public Response() 
     { 
      Reasons = new List<string>(); 
      Success = true; 
     } 
     public List<string> Reasons; 
     public bool Success = true; 

    } 

Answer 1

我不能告诉如果您正在寻找一种能够调试您的项目的方式，或者如果您希望在代码中告诉您潜在的问题。

对于后者：

确保Response.Reasons是由Response构造（或字段初始值）初始化。

Answer 2

检查您的断点看起来是这样的：

如果是这样，你的源代码与程序集实际编译的代码不同。请确保您的项目正常建设（右键单击该解决方案，并选择“重建”），并检查您的当前配置：

希望这有助于...

Answer 3

您没有显示Response类，因此请确保Reasons实际上已设置为可添加到的集合，而不是默认设置为null。

编辑：@nodakai指出，下面可能的原因是@nodakai不是一个;结果是一个空字符数组是一个特殊的情况下分割空白。

*你在做计算参数 List arguments = input.Split（new char [0]）。ToList（）; ......据我所知，绝对没有除了把原来的字符串放在一个List中。您可能想要拆分new char[] {' '}而不是拆分空格。*