Question

所以我完全被这个问题困住了。我收到错误Object reference not set to an instance of an object.，我不确定原因。

我有一个班级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; }
    }

我正在创建一个像

这样的实例

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

只要将变量放在堆栈上，它就会抛出异常。但是......如果我在代码中删除了对该变量的所有引用（在DEBUGMODE中没有执行过!!!）那么就不会抛出任何异常。到底是怎么回事？

对于参考，以下是其中的方法：

    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;
    }

更新：我仍然在为你做一个例子，但同时在这里可能是有用的信息：

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

Data: {System.Collections.ListDictionaryInternal}部分对我来说有点兴趣，我的班级不使用任何字典列表。

更新＃2：好的，我已经为其他人尝试制作了可重复的步骤序列。在你的机器上，它可能很好，就像Jon Skeet说的那样，它可能是我的调试环境设置但请尽量让我知道。以下是重现的步骤。

打开控制台应用程序项目并复制下面的粘贴代码。
在此设置一个断点：
首先运行代码过去的断点，它的工作原理！：d
然后再次运行代码，但这次在断点处停止，并将执行语句游标从这里拖到if语句中：到这里：

它就是！所以错误是由我的测试方法引起的，但这是否有意义，或者这只是我在我的机器上？

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();
        }
    }
}

我认为要么以非常错误的方式进行调试，要么微软应该看看这个。它就像未来的代码正在破坏当前的代码......这是不可能的！

Answer 1

我尝试在控制台应用中执行代码并且正在运行，您能提供更多详细信息吗？关于设置初始化的答案此处没有意义，因为您应该能够创建FILE实例。一旦你尝试分配（设置）或请求（获取），那么你正在处理fileName属性。我不明白为什么在创建实例时会出现异常。

 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; }
    }

在打印屏幕上看光标

这是我的调试配置

c＃ - 没有运行的代码导致异常？这怎么可能呢？

1 个答案: