C# 将引用类型的字典值设置为null的正确方法是什么？

假设我们有一个类，如下所示：-

        class DoubleLinkedListNode
        {
            public int Value { get; set; }

            public DoubleLinkedListNode(int value)
            {
                Value = value;
            }

            public DoubleLinkedListNode next = null;

            public DoubleLinkedListNode prev = null;
        }

然后我们创建一个字典，如下所示：-

IDictionary<int, DoubleLinkedListNode> dict = new Dictionary<int, DoubleLinkedListNode>();

private void RemoveNode(DoubleLinkedListNode nodeToBeRemoved)
{
     if(nodeToBeRemoved != null)
     {
         //Do Something

         nodeToBeRemoved = null;
     }

}

    private void RemoveNodeAnother(DoubleLinkedListNode nodeToBeRemoved)
    {
         if(nodeToBeRemoved != null)
         {
             //Do Something
             dict[nodeToBeRemoved.Value] = null;
         }

    }

我们还要创建一个函数，该函数将字典值的类型作为输入，并将该值设置为

null

，如下所示：-

IDictionary<int, DoubleLinkedListNode> dict = new Dictionary<int, DoubleLinkedListNode>();

private void RemoveNode(DoubleLinkedListNode nodeToBeRemoved)
{
     if(nodeToBeRemoved != null)
     {
         //Do Something

         nodeToBeRemoved = null;
     }

}

    private void RemoveNodeAnother(DoubleLinkedListNode nodeToBeRemoved)
    {
         if(nodeToBeRemoved != null)
         {
             //Do Something
             dict[nodeToBeRemoved.Value] = null;
         }

    }

我们这样调用函数：-

DoubleLinkedListNode newNode = new DoubleLinkedListNode(value);
dict.Add(newNode.Value, newNode );

RemoveNode(dict[someValue]);

RemoveNodeAnother(dict[someValue]);

让我们创建另一个函数，在其中显式地将值

null

，如下所示：-

IDictionary<int, DoubleLinkedListNode> dict = new Dictionary<int, DoubleLinkedListNode>();

private void RemoveNode(DoubleLinkedListNode nodeToBeRemoved)
{
     if(nodeToBeRemoved != null)
     {
         //Do Something

         nodeToBeRemoved = null;
     }

}

    private void RemoveNodeAnother(DoubleLinkedListNode nodeToBeRemoved)
    {
         if(nodeToBeRemoved != null)
         {
             //Do Something
             dict[nodeToBeRemoved.Value] = null;
         }

    }

然后我们调用如下函数：-

DoubleLinkedListNode newNode = new DoubleLinkedListNode(value);
dict.Add(newNode.Value, newNode );

RemoveNode(dict[someValue]);

RemoveNodeAnother(dict[someValue]);

以上两种功能的区别是什么

为什么我要问这个是我在Leetcode上做的。我写的解决方案如下：-

public class FirstUnique 
{
    private class DoubleLinkedListNode
    {
        public int Value { get; set; }

        public DoubleLinkedListNode(int value)
        {
            Value = value;
        }

        public DoubleLinkedListNode next = null;

        public DoubleLinkedListNode prev = null;
    }

    DoubleLinkedListNode dummyHeadNode = new DoubleLinkedListNode(-1);

    DoubleLinkedListNode dummyTailNode = new DoubleLinkedListNode(-1);

    IDictionary<int, DoubleLinkedListNode> dict = new Dictionary<int, DoubleLinkedListNode>();

    public FirstUnique(int[] nums) 
    {
        InitialiseDummyHeadAndTailNodes();

        foreach(int i in nums)
        {
            Add(i);
        }
    }

    public int ShowFirstUnique() 
    {
        return dummyHeadNode.next.Value;
    }

    public void Add(int value)
    {
        if (dict.ContainsKey(value))
        {
            RemoveNode(dict[value]);
        }
        else
        {
            DoubleLinkedListNode newNode = new DoubleLinkedListNode(value);

            AddNode(newNode);

        }
    }

    private void InitialiseDummyHeadAndTailNodes()
    {
        dummyHeadNode.next = dummyTailNode;
        dummyTailNode.prev = dummyHeadNode;
    }

    private void RemoveNode(DoubleLinkedListNode nodeToBeRemoved)
    {
        if(nodeToBeRemoved != null)
        {
            nodeToBeRemoved.prev.next = nodeToBeRemoved.next;
            nodeToBeRemoved.next.prev = nodeToBeRemoved.prev;

            // If I write nodeToBeRemoved = null, the solution won't pass.
            // But if I write dict[nodeToBeRemoved.Value] = null, the solution is accepted.

            dict[nodeToBeRemoved.Value] = null;
        }

    }

    private void AddNode(DoubleLinkedListNode nodeToBeAdded)
    {
        //Update the pointers.
        nodeToBeAdded.prev = dummyTailNode.prev;
        nodeToBeAdded.prev.next = nodeToBeAdded;
        nodeToBeAdded.next = dummyTailNode;
        dummyTailNode.prev = nodeToBeAdded;

        //Add the node to the dictionary.
        dict.Add(nodeToBeAdded.Value, nodeToBeAdded);
    }
}

public类FirstUnique
{
私有类DoubleLinkedListNode
{
公共int值{get；set；}
公共DoubleLinkedListNode（int值）
{
价值=价值；
}
public DoubleLinkedListNode next=null；
public DoubleLinkedListNode prev=null；
}
DoubleLinkedListNode dummyHeadNode=新的DoubleLinkedListNode（-1）；
DoubleLinkedListNode dummyTailNode=新的DoubleLinkedListNode（-1）；
IDictionary dict=新字典（）；
public FirstUnique（int[]nums）
{
初始化DummyHeadAndTailNodes（）；
foreach（整数i，单位为nums）
{
加（i）；
}
}
public int ShowFirstUnique（）
{
返回dummyHeadNode.next.Value；
}
公共void Add（int值）
{
if（dict.ContainsKey（值））
{
RemoveNode（dict[value]）；
}
其他的
{
DoubleLinkedListNode newNode=新的DoubleLinkedListNode（值）；
AddNode（newNode）；
}
}
私有void InitialiseDummyHeadAndTailNodes（）
{
dummyHeadNode.next=dummyTailNode；
dummyTailNode.prev=dummyHeadNode；
}
私有void RemoveNode（DoubleLinkedListNode节点已移动）
{
if（nodeToBeRemoved！=null）
{
nodeToBeRemoved.prev.next=nodeToBeRemoved.next；
nodeToBeRemoved.next.prev=nodeToBeRemoved.prev；
//如果我写入nodeToBeRemoved=null，解决方案将不会通过。
//但如果我将dict[nodeToBeRemoved.Value]=null写入，则该解决方案被接受。
dict[nodeToBeRemoved.Value]=null；
}
}
私有void AddNode（DoubleLinkedListNode节点添加）
{
//更新指针。
nodeTobeaded.prev=dummyTailNode.prev；
nodeTobeaded.prev.next=nodeTobeaded；
nodeToBeAdded.next=dummyTailNode；
dummyTailNode.prev=nodetobeaded；
//将节点添加到字典中。
dict.Add（nodetobeaded.Value，nodetobeaded）；
}
}

我已经在反常之处发表了评论。这种行为的原因可能是什么？

只有一种方法可以“将字典值设置为null”——

事实上，如果密钥不存在，您需要先添加它。。。这导致了将值设置为null的方法-

 dictionary[key] = null;

请注意，将值设置为

null

对先前存储的内容没有影响。

只有一种方法可以“将字典值设置为null”——

事实上，如果密钥不存在，您需要先添加它。。。这导致了将值设置为null的方法-

 dictionary[key] = null;

---

请注意，将值设置为

null

对先前存储的内容没有任何影响。

nodeToBeRemoved的范围是

RemoveNode

方法，如果

null

该指针（

nodeToBeRemoved=null

），则该指针指向实际的

DoubleLinkedListNode

）你所要做的就是把本地指针指向零。您的

词典

仍保留另一个指向该对象的指针，因此不会发生任何更改，条目将保持存在。至于正确性，我不能说太多，因为leetcode链接要求您登录。正如@Knoop所说的。这就是为什么对

nodeToBeRemoved

（如

node.next

）属性的修改将反映在dictionary节点中，因为它们都引用相同的对象。但赋值是另一回事——在

nodeToBeRemoved=null之后

，字典值和本地节点不再引用同一事物。如果不再需要键值，您可能需要查看该方法（它是

Add

方法的对应项，其中键和值都被删除）。我不清楚字典的用途，除了查找节点可能比遍历列表更快（在这种情况下，我认为对于

null

值，您不需要

键），如果我多次遇到该键，我需要该键，但不需要它的值。
nodeToBeRemoved
的作用域是
RemoveNode
方法，如果您
null
该指针（
nodeToBeRemoved=null
），这是指向实际的
DoubleLinkedListNode
的指针你所要做的就是把本地指针指向零。您的
词典
仍保留另一个指向该对象的指针，因此不会发生任何更改，条目将保持存在。至于正确性，我不能说太多，因为leetcode链接要求您登录。正如@Knoop所说的。这就是为什么对
nodeToBeRemoved
（如
node.next
）属性的修改将反映在dictionary节点中，因为它们都引用相同的对象。但赋值是另一回事——在
nodeToBeRemoved=null之后
，字典值和本地节点不再引用同一事物。如果不再需要键值，您可能需要查看该方法（它是
Add
方法的对应项，其中键和值都被删除）。我不清楚字典的作用是什么，除了可能有一种比遍历列表更快的查找节点的方法（在wh中）