montrant ArgumentOutOfRange de l'appelant

Question

Je voudrais savoir s'il y a un moyen d'obtenir le « ArgumentOutOfRangeException » de l'appelant d'une méthode/fonction:

recherché pour cette pendant des jours, et pas de chance ... soit rare ou mauvais choix des paramètres de recherche ...

Exemple:

class Main 
{ 
    struct XYZ 
    { 
     public int X, Y, Z; 
     public XYZ(int x, int y, int z) 
     { 
      X = x; 
      Y = y; 
      Z = z; 
     } 
    } 
    class ArrayE<T> 
    { 
     public T[, ,] data; 

     public ArrayE(XYZ xyz) 
     { 
      data = new T[xyz.X, xyz.Y, xyz.Z]; 
     } 
     public T this[XYZ xyz] 
     { 
      get 
      { 
       if (OutOfBounds(xyz)) 
       { 
        throw new ArgumentOutOfRangeException(); // Error shows here in debug 
       } 
       else 
       { 
        return data[xyz.X, xyz.Y, xyz.Z]; 
       } 
      } 
      set 
      { 
       if (OutOfBounds(xyz)) 
       { 
        throw new ArgumentOutOfRangeException(); // Error shows here in debug 
       } 
       else 
       { 
        data[xyz.X, xyz.Y, xyz.Z] = value; 
       } 
      } 
     } 

     bool OutOfBounds(XYZ xyz) 
     { 
      return xyz.X < 0 | xyz.Y < 0 | xyz.Z < 0 | 
         xyz.X >= data.GetLength(0) | 
         xyz.Y >= data.GetLength(1) | 
         xyz.Z >= data.GetLength(2); 
     } 
    } 

    ArrayE<int> Data; 
    public void Test() 
    { 
     XYZ xyz = new XYZ(10, 10, 10); 
     Data = new ArrayE<int>(xyz); 

     xyz = new XYZ(1,0,2); 
     Data[xyz] = 2; 


     xyz = new XYZ(1, -1, 2); 
     Data[xyz] = 4; // I would like the debugger to stop here 
     //As if I did this: 
     Data[xyz.X,xyz.Y,xyz.Z] = 4 // The debugger would then stop at this line 

     //Example of what I want 
     int[] array = new int[10]; 
     array[2] = 1; 
     array[-1] = 3; // This is the behavior I would like to happen when out of bounds, The error shows here. 
    } 
} 

Edit: Plus spécifique:
Quand je commence debuggin, je voulez que le débogueur s'arrête sur la ligne "Data [xyz] = 4;" où xyz est un index invalide, donc je peux voir d'où il a été appelé, et non de l'intérieur de la fonction get [xyz] Data. Si un int normal [] obtiendrait un index invalide, par exemple -1, alors le débogueur arrêterait sur cette ligne, et vous pouvez regarder les lignes avant l'accès au tableau, donc il serait possible de découvrez pourquoi l'indice est ce qu'il est. Avec la configuration actuelle, lorsqu'un index invalide de xyz est utilisé sur ArrayE [xyz], le débogueur s'arrête à l'intérieur du get set, me rendant incapable de suivre et comprendre pourquoi le xyz est en dehors des limites du tableau ...

J'espère que c'est plus clair, quant à ce que je vous demande.
Je pourrais utiliser try catch, mais n'y a-t-il pas d'autre moyen? faire le try try rendrait rapidement le code illisible et ingérable, puisque le programme est très grand ...

Alors, comment cela peut-il être fait, si possible?

J'utilise Visual C# 2010 Express

Answer 1

Just Running ce code affiché, il semble faire ce que vous voulez. Un exemple d'appelant attrapant et manipulant ci-dessous. Si vous vouliez gérer ces fonctions dans votre fonction de test, vous ne déplaceriez que l'essayer.

public class Program 
{ 
    public static void Main(string[] args) 
    { 
     try 
     { 
      Main m = new Main(); 
      m.Test(); 
     } 
     catch (Exception e) 
     { 
      Console.Write("Uh oh :O " + e.StackTrace); 
     } 
    } 
} 

EDIT: Ok, après avoir regardé ce que je suis venu avec une façon de faire ce que vous demandez. Vous devez définir un attribut DebugerHidden. Exemple:

 public T this[XYZ xyz] 
     { 
      //add attribute here to say this function is 'ignored' 
      [DebuggerHidden] 
      get 
      { 
       if (OutOfBounds(xyz)) 
       { 
        throw new ArgumentOutOfRangeException(); // Error shows here in debug 
       } 
       else 
       { 
        return data[xyz.X, xyz.Y, xyz.Z]; 
       } 
      } 
      //add attribute here to say this function is 'ignored' 
      [DebuggerHidden] 
      set 
      { 
       if (OutOfBounds(xyz)) 
       { 
        throw new ArgumentOutOfRangeException(); // Error shows here in debug 
       } 
       else 
       { 
        data[xyz.X, xyz.Y, xyz.Z] = value; 
       } 
      } 
     }