c# - 如何将 C# 对象设置为 null 本身

Question

在 C++ 中，可以删除this并将其自己的引用设置为 null。

我想将一个对象实例设置为 null 本身。

public class Foo
{

    public void M( )
    {
       // this = null; // How do I do this kind of thing?
    }
}

Answer 1

this实际上只是arg0实例方法中参数的一个特殊名称。不允许将其设置null为：

1. this例如，您永远无法更改class
2. 例如，您可以更改a 上的方法，但不能分配thisstructnull

1. 的原因是它没有用：

• 该参数arg0在实例方法上是 by-val（不是 by-ref）class，因此方法的调用者不会注意到更改（为了完整性：在实例方法arg0上是 by-ref ）struct
• 它不会以任何方式真正改变内存管理：
  • 将某些内容设置为null不会删除它；GC 处理
  • 如果有外部根持有对对象的引用，它们仍将持有对对象的引用
  • 如果您担心参数的边缘情况是对象的最后一个根，那么只需退出该方法

所以基本上，这种语法是不允许的，因为它不符合你的要求。对于您想要的东西，没有C# 隐喻。

Answer 2

这在 .NET 中是不可能的。您不能从对象本身将当前实例设置为 null。在 .NET 中，当前实例 ( this) 是只读的，您不能为其赋值。顺便说一句，这在 .NET 中甚至都不需要。

Answer 3

在 C++delete this中，释放对象的内存。没有与 C#（或任何其他 .NET 语言）中的等效项。虽然它在 C++ 中是允许的，但我认为这不是一个好习惯。至少你必须非常小心。

.NET 使用垃圾回收来释放内存。一旦一个对象不再被引用并且不能从代码中的任何地方访问，垃圾收集器最终可以释放内存（并且垃圾收集器很小心）。所以只需向后靠，让垃圾收集器完成它的工作。

Answer 4

根本没有。因为这是不可能从空对象访问方法的。在你的情况下，你想说

F f = new F() // where f = null
f.SomeMethod(); // ?????? not possible

在这种情况下，您会得到一个空引用异常。你也可以看到达林的评论和解释。你怎么能从 null 访问任何东西，这意味着什么。我对遗产一无所知，但 .Net 并没有为您提供这些东西。相反，您可以在不再需要它时将其设置为 null。

来自 MSDN

public class Node<T>
{
        // Private member-variables
        private T data;
        private NodeList<T> neighbors = null;

        public Node() {}
        public Node(T data) : this(data, null) {}
        public Node(T data, NodeList<T> neighbors)
        {
            this.data = data;
            this.neighbors = neighbors;
        }

        public T Value
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }

        protected NodeList<T> Neighbors
        {
            get
            {
                return neighbors;
            }
            set
            {
                neighbors = value;
            }
        }
    }
}


public class NodeList<T> : Collection<Node<T>>
{
    public NodeList() : base() { }

    public NodeList(int initialSize)
    {
        // Add the specified number of items
        for (int i = 0; i < initialSize; i++)
            base.Items.Add(default(Node<T>));
    }

    public Node<T> FindByValue(T value)
    {
        // search the list for the value
        foreach (Node<T> node in Items)
            if (node.Value.Equals(value))
                return node;

        // if we reached here, we didn't find a matching node
        return null;
    }
}

 and Right—that operate on the base class's Neighbors property.
public class BinaryTreeNode<T> : Node<T>
{
    public BinaryTreeNode() : base() {}
    public BinaryTreeNode(T data) : base(data, null) {}
    public BinaryTreeNode(T data, BinaryTreeNode<T> left, BinaryTreeNode<T> right)
    {
        base.Value = data;
        NodeList<T> children = new NodeList<T>(2);
        children[0] = left;
        children[1] = right;

        base.Neighbors = children;
    }

    public BinaryTreeNode<T> Left
    {
        get
        {
            if (base.Neighbors == null)
                return null;
            else
                return (BinaryTreeNode<T>) base.Neighbors[0];
        }
        set
        {
            if (base.Neighbors == null)
                base.Neighbors = new NodeList<T>(2);

            base.Neighbors[0] = value;
        }
    }

    public BinaryTreeNode<T> Right
    {
        get
        {
            if (base.Neighbors == null)
                return null;
            else
                return (BinaryTreeNode<T>) base.Neighbors[1];
        }
        set
        {
            if (base.Neighbors == null)
                base.Neighbors = new NodeList<T>(2);

            base.Neighbors[1] = value;
        }
    }
}


public class BinaryTree<T>
{
   private BinaryTreeNode<T> root;

   public BinaryTree()
   {
      root = null;
   }

   public virtual void Clear()
   {
      root = null;
   }

   public BinaryTreeNode<T> Root
   {
      get
      {
         return root;
      }
      set
      {
         root = value;
      }
   }
}