在C#单例模式下内存不会释放

Question

我对C#中的单例模式在C++中释放对象内存有一个困惑；这里是C++代码：

#include<iostream>
using namespace std;
class Rocket
{
private:
    Rocket() { speed = 100; }
    ~Rocket() {}
    static Rocket* ms_rocket;
public:
    int speed;
    static Rocket*ShareRocket()
    {
        if (ms_rocket == NULL)
            ms_rocket = new Rocket();
        return ms_rocket;
    }
    static void Close()
    {
        if (ms_rocket != NULL)
            delete ms_rocket;
    }
};
Rocket *Rocket::ms_rocket = NULL;
int main()
{
    Rocket* p =  Rocket::ShareRocket();
    p->speed = 100;
    cout << p->speed << endl;
    Rocket::Close();
    cout << p->speed << endl;
    getchar();
}

当我使用rocket::close（）时，ms_rocket指向的内存空间将被释放，ms_rocket变成一个野指针，第二个“cout

    class A : IDisposable
    {
        public int age;
        public A() {  }
        public void Run()
        {
            Console.WriteLine("Run");
        }
        #region IDisposable Support
        private bool disposedValue = false; 

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    Console.WriteLine("A is release");
                }
                disposedValue = true;

            }
        }
        public void Dispose()
        {
            Dispose(true);
        }
        #endregion
    }

    class B
    {
        static A a;
        private B() { }
        public static A Intance
        {
            get
            {
                if (a == null)
                    a = new A();
                return a;
            }
        }

    }
    class Class1
    {

        public static void Main(string[] args)
        {
            A a = B.Intance;
            a.age =100;
            Console.WriteLine(a.age);
            a.Dispose();
            A a1 = B.Intance;
            Console.WriteLine(a1.age);
            Console.Read();
        }
    }

在C#中，我认为当我使用Dispose（）时，内存(B单例中的'a'对象）会被释放，但在第二次访问中，age值不应该是100，静态变量'a'会变得像野指针一样。谁能告诉我为什么？

Answer 1

Dispose主要用于在不需要的时候释放非托管资源，而不是释放对象本身占用的内存--它由垃圾收集器处理，垃圾收集器只会在它从所谓的GC根（而静态变量是GC根之一，因此B.intance将在堆中保留对A实例的引用）变得不可访问时才释放（当GC决定它需要运行时）。