C# - Le code qui N'A PAS FONCTIONNÉ EN COURS provoque une exception? Comment est-ce possible?

Question

Donc, je suis complètement perplexe sur celui-ci. Je reçois une erreur Object reference not set to an instance of an object. et je ne sais pas pourquoi.

J'ai une classe FILE

public class FILE 
    { 
     private string _fileName; 
     public string fileName 
     { 

      get 
      { 
       if (!Settings.Values.CaseSensitive) 
        return this._fileName.ToUpper(); 
       else 
        return this._fileName; 
      } 
      set 
      { 
       if (!Settings.Values.CaseSensitive) 
        this._fileName = value.ToUpper(); 
       else 
        this._fileName = value; 
      } 
     } 
     public string folderName { get; set; } 
     public byte[] fileHashDigest { get; set; } 
    } 

Je crée une instance comme:

FILE test1233;  
test1233 = new FILE(); // <---- Ex thrown here!? Why???  
test1233.fileName = ""; 
folderName = ""; 
fileHashDigest = new byte[1]; 

Dès que la variable est placée sur la pile, il lève une exception. MAIS ... si j'enlève toutes les réfrences à cette variable sur le code plus bas (QUI N'A PAS ENCORE ÉTÉ EXÉCUTÉ EN DEBUGMODE !!!) alors aucune exception n'est levée. Que diable se passe-t-il ici?

Pour refrence, voici la méthode dans son intégralité:

private bool IsFolderOverride(FileCollection zipFILEList, DataTable exceptionTableFileList, DataRow currentRow, ref DataTable detectedFolderRenames) 
    { 
     bool foundInExceptionTable = false; 
     foreach (DataRow exRow in exceptionTableFileList.Rows) 
     { 
      if (exRow["FILE_NAME"].ToString().ToUpper() == currentRow["FILE_NAME"].ToString().ToUpper() && 
       (decimal)exRow["WINDOW_GROUP_ID"] == (decimal)currentRow["WINDOW_GROUP_ID"]) 
      { 
       string name = exRow["FILE_NAME"].ToString().ToUpper(); 
       string folder = exRow["FOLDER_NAME"].ToString().ToUpper(); 
       byte[] digest = (byte[])exRow["FILE_HASH_DIGEST"]; 
       CopyCat exCopyCat = new CopyCat(); 
       exCopyCat.fileName = name; 
       exCopyCat.folderName = folder; 
       exCopyCat.fileHashDigest = digest; 

       //HAS AN EXCEPTION! 
       FILE test1233 = new FILE(); 
       test1233.fileName = ""; 
       test1233.folderName = ""; 
       test1233.fileHashDigest = new byte[1]; 

       //NO EXCEPTION THROWN 
       FILE test = new FILE(); 
       bool test9 = zipFileList.Contains(test1233); 


       test.fileName = name; 
       test.folderName = folder; 
       test.fileHashDigest = digest; 

       FILE test123 = new FILE(); 

       if (zipFileList.Contains(test1233)) // Exact match found in zip in old folder from exception table. 
       { 
        FILE exists = zipFileList.Where(f => f.fileName == test1233.fileName && 
              f.fileHashDigest.SequenceEqual(test1233.fileHashDigest)).First(); 
        object[] items = exRow.ItemArray; 
        Array.Resize(ref items, items.Length + 4); 
        items[items.Length - 1] = "Y"; 
        items[items.Length - 2] = exists.folderName; 
        items[items.Length - 3] = test1233.folderName; 
        items[items.Length - 4] = "Folder Override"; 
        if (detectedFolderRenames.Rows.Count == 0 || !detectedFolderRenames.Rows.Contains(items[0])) 
         detectedFolderRenames.Rows.Add(items); 

        foundInExceptionTable = true; 
        break; 
       } 
       else if (zipFileList.ContainsPartially(test1233)) // Match in zip with Different Hash found from ex table. 
       { 
        FILE exists = zipFileList.Where(f => f.fileName == test1233.fileName).First(); 
        object[] items = exRow.ItemArray; 
        Array.Resize(ref items, items.Length + 4); 
        items[items.Length - 1] = "N"; 
        items[items.Length - 2] = exists.folderName; 
        items[items.Length - 3] = test1233.folderName; 
        items[items.Length - 4] = "Folder Override"; 
        if (detectedFolderRenames.Rows.Count == 0 || !detectedFolderRenames.Rows.Contains(items[0])) 
         detectedFolderRenames.Rows.Add(items); 

        foundInExceptionTable = true; 
        break; 
       } 
      } 
      else 
       continue; 
     } 
     return foundInExceptionTable; 
    } 

MISE À JOUR: Je travaille toujours sur un exemple pour vous, mais en attendant voici des informations potentiellement utiles:

test1233' threw an exception of type 'System.NullReferenceException' 
Data: {System.Collections.ListDictionaryInternal} 
HResult: -2147467261 
HelpLink: null 
InnerException: null 
Message: "Object reference not set to an instance of an object." 
Source: null 
StackTrace: null 
TargetSite: null 

La partie Data: {System.Collections.ListDictionaryInternal} est un peu intéressante pour moi, ma classe n'utilise aucune liste de dictionnaire.

MISE À JOUR # 2: Ok, j'ai produit une séquence d'étapes reproductibles que les autres peuvent essayer. Sur vos machines, c'est peut-être bien, comme Jon Skeet l'a dit, il se peut que ce soit mes paramètres d'environnement de débogage mais s'il vous plaît essayez et faites le moi savoir. Voici les étapes à reproduire. Ouvrez le projet d'application de la console et copiez le code de pâte ci-dessous.

2. Définissez un point de rupture ici:
3. Code d'exécution passé, point de rupture, cela fonctionne! : D
4. Ensuite, exécutez le code à nouveau, mais cet arrêt du temps au point de rupture et faites glisser le curseur de l'instruction d'exécution dans la instruction if d'ici: ici:

Il est! Donc, l'erreur a été causée par ma méthode de test, mais est-ce que cela a un sens ou est-ce juste moi sur ma machine?

CODE:

using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

namespace testapp 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      FILECollection randomCollection = new FILECollection(); 
      // Fill with junk test data: 
      for(int i = 0; i<10; i++) 
      { 
       FILE junkfile = new FILE() { fileName = i.ToString(), folderName = i.ToString(), fileHashDigest = new byte[1] }; 
       randomCollection.Add(junkfile); 
      } 

      if (true) 
      { 
       Console.WriteLine("testing this weird exception issue..."); 
       FILE test; 
       test = new FILE(); 
       test.fileName = "3"; 
       test.folderName = "3"; 
       test.fileHashDigest = new byte[1]; 

       FILE exists = randomCollection.Where(f => f.fileName == test.fileName && 
               f.fileHashDigest.SequenceEqual(test.fileHashDigest)).First(); 
      } 
     } 
    } 


    public class FILE 
    { 
     public FILE() { _fileName = "";} 
     private string _fileName; 
     public string fileName 
     { 

      get 
      { 
        if (false) 
         return this._fileName.ToUpper(); 
        else 
         return this._fileName; 
      } 
      set 
      { 

        if (false) 
         this._fileName = value.ToUpper(); 
        else 
         this._fileName = value; 
      } 
     } 
     public string folderName { get; set; } 
     public byte[] fileHashDigest { get; set; } 
    } 

    public class FILECollection : IEnumerable<FILE>, ICollection<FILE> 
    { 
     private HashSet<FILE> svgHash; 
     private static List<FILE> PreallocationList; 
     public string FileName = "N/A"; 

     /// <summary> 
     /// Default Constructor, will not 
     /// preallocate memory. 
     /// </summary> 
     /// <param name="PreallocationSize"></param> 
     public FILECollection() 
     { 
      this.svgHash = new HashSet<FILE>(); 
      this.svgHash.Clear(); 
     } 

     /// <summary> 
     /// Overload Constructor Preallocates 
     /// memory to be used for the new 
     /// FILE Collection. 
     /// </summary> 
     public FILECollection(int PreallocationSize, string fileName = "N/A", int fileHashDigestSize = 32) 
     { 
      FileName = fileName; 
      PreallocationList = new List<FILE>(PreallocationSize); 
      for (int i = 0; i <= PreallocationSize; i++) 
      { 
       byte[] buffer = new byte[fileHashDigestSize]; 
       FILE preallocationSVG = new FILE() 
       { 
        fileName = "", 
        folderName = "", 
        fileHashDigest = buffer 
       }; 
       PreallocationList.Add(preallocationSVG); 
      } 
      this.svgHash = new HashSet<FILE>(PreallocationList); 
      this.svgHash.Clear(); // Capacity remains unchanged until a call to TrimExcess is made. 
     } 

     /// <summary> 
     /// Add an FILE file to 
     /// the FILE Collection. 
     /// </summary> 
     /// <param name="svg"></param> 
     public void Add(FILE svg) 
     { 
      this.svgHash.Add(svg); 
     } 

     /// <summary> 
     /// Removes all elements 
     /// from the FILE Collection 
     /// </summary> 
     public void Clear() 
     { 
      svgHash.Clear(); 
     } 


     /// <summary> 
     /// Determine if the FILE collection 
     /// contains the EXACT FILE file, folder, 
     /// and byte[] sequence. This guarantees 
     /// that the collection contains the EXACT 
     /// file you are looking for. 
     /// </summary> 
     /// <param name="item"></param> 
     /// <returns></returns> 
     public bool Contains(FILE item) 
     { 
      return svgHash.Any(f => f.fileHashDigest.SequenceEqual(item.fileHashDigest) && 
            f.fileName == item.fileName && 
            f.folderName == item.folderName); 
     } 

     /// <summary> 
     /// Determine if the FILE collection 
     /// contains the same file and folder name, 
     /// byte[] sequence is not compared. The file and folder 
     /// name may be the same but this does not guarantee the 
     /// file contents are exactly the same. Use Contains() instead. 
     /// </summary> 
     /// <param name="item"></param> 
     /// <returns></returns> 
     public bool ContainsPartially(FILE item) 
     { 
      return svgHash.Any(f => f.fileName == item.fileName && 
            f.folderName == item.folderName); 
     } 

     /// <summary> 
     /// Returns the total number 
     /// of FILE files in the Collection. 
     /// </summary> 
     public int Count 
     { get { return svgHash.Count(); } } 

     public bool IsReadOnly 
     { get { return true; } } 

     public void CopyTo(FILE[] array, int arrayIndex) 
     { 
      svgHash.CopyTo(array, arrayIndex); 
     } 

     public bool Remove(FILE item) 
     { 
      return svgHash.Remove(item); 
     } 

     public IEnumerator<FILE> GetEnumerator() 
     { 
      return svgHash.GetEnumerator(); 
     } 

     IEnumerator IEnumerable.GetEnumerator() 
     { 
      return svgHash.GetEnumerator(); 
     } 
    } 
} 

Je pense que ce soit, je suis le débogage d'une manière terriblement mal, ou Microsoft devrait jeter un oeil à ce sujet. C'est comme si le futur code rompt le code actuel ... ce qui est impossible!

Answer 1

J'ai essayé d'exécuter le code dans une application de console et fonctionne, pouvez-vous donner plus de détails? Les réponses à propos de l'initialisation de Settings n'ont pas de sens ici car vous devriez être capable de créer l'instance de FILE. Une fois que vous essayez d'assigner (set) ou de request (get), vous avez affaire à la propriété fileName. Je ne vois pas pourquoi vous obtenez l'exception lorsque vous créez l'instance.

static void Main(string[] args) 
     { 
      FILE test1233; 
      test1233 = new FILE(); // <---- Ex is not thrown here!?       test1233.fileName = ""; 
      test1233.folderName = ""; 
      test1233.fileHashDigest = new byte[1]; 
     } 

public class FILE 
    { 
     private string _fileName; 
     public string fileName 
     { 

      get 
      { 
       if (YOUR SETTING CONDITION HERE) 
        return this._fileName.ToUpper(); 
       else 
        return this._fileName; 
      } 
      set 
      { 
       if (YOUR SETTING CONDITION HERE) 
        this._fileName = value.ToUpper(); 
       else 
        this._fileName = value; 
      } 
     } 
     public string folderName { get; set; } 
     public byte[] fileHashDigest { get; set; } 
    } 

voir le curseur sur l'écran d'impression

Voici ma configuration de débogage