Dispose释放资源管理器

最新推荐文章于 2024-02-26 09:17:50 发布

dedinglv8588

最新推荐文章于 2024-02-26 09:17:50 发布

阅读量101

点赞数

原文链接：http://www.cnblogs.com/nogic/archive/2013/01/29/2881173.html

版权

这里有两种释放资源的写法，实现原理基本相同，但是第二种方法更利于扩展，如下所示：

第一种方法的基类：

using System;
using System.IO;

namespace Dispose模式
{
    public abstract class BaseClass : IDisposable
    {
        protected BaseClass(string name)
        {
            _count++;
            Index = _count;
            Name = name;
        }

        private static int _count;

        protected int Index;

        protected readonly string Name;

        protected bool IsDisposed;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool isDisposing)
        {
            if (!IsDisposed)
            {
                if (isDisposing)
                {
                    // 清理托管资源
                    File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "BaseClass"));
                }

                // 清理非托管资源
                File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "BaseClass"));
                IsDisposed = true;
            }
        }

        ~BaseClass()
        {
            Dispose(false);
        }
    }
}

子类：

using System.IO;

namespace Dispose模式
{
    public class SubClass : BaseClass
    {
        public SubClass(string name)
            : base(name)
        {
        }

        protected override void Dispose(bool isDisposing)
        {
            if (!IsDisposed)
            {
                if (isDisposing)
                {
                    // 清理托管资源
                    File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "SubClass"));
                }

                // 清理非托管资源
                File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "SubClass"));
                base.Dispose(isDisposing);
            }
        }

        ~SubClass()
        {
            Dispose(false);
        }
    }
}

从属子类：

using System.IO;

namespace Dispose模式
{
    public class SuperSubClass : SubClass
    {
        public SuperSubClass(string name)
            : base(name)
        {

        }

        protected override void Dispose(bool isDisposing)
        {
            if (!IsDisposed)
            {
                if (isDisposing)
                {
                    // 清理托管资源
                    File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "SuperSubClass"));
                }

                // 清理非托管资源
                File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "SuperSubClass"));
                base.Dispose(isDisposing);
            }
        }

        ~SuperSubClass()
        {
            Dispose(false);
        }
    }
}

测试类：

using System;
using System.IO;

namespace Dispose模式
{
    public class TestClass : IDisposable
    {
        public TestClass(string name)
        {
            _count++;
            Index = _count;
            _name = name;
            _baseClass = new SuperSubClass(_name);
        }

        private static int _count;

        protected int Index;

        private readonly string _name;

        private readonly BaseClass _baseClass;

        private bool _isDisposed;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool isDisposing)
        {
            if (!_isDisposed)
            {
                if (isDisposing)
                {
                    // 清理托管资源
                    File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, _name, "TestClass"));
                    _baseClass.Dispose();
                }

                // 清理非托管资源
                File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, _name, "TestClass"));
                _isDisposed = true;
            }
        }

        ~TestClass()
        {
            Dispose(false);
        }
    }
}

第二种方法基类：

using System;
using System.IO;

namespace Dispose模式
{
    public class InheritedBaseClass : IDisposable
    {
        protected InheritedBaseClass(string name)
        {
            _count++;
            Index = _count;
            Name = name;
        }

        private static int _count;

        protected int Index;

        protected readonly string Name;

        private bool _isDisposed;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected void Dispose(bool isDisposing)
        {
            if (!_isDisposed)
            {
                if (isDisposing)
                {
                    DisposeManagedResources();
                }

                DisposeUnmanagedResources();
                _isDisposed = true;
            }
        }

        protected virtual void DisposeManagedResources()
        {
            // 清理托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "InheritedBaseClass"));
        }

        protected virtual void DisposeUnmanagedResources()
        {
            // 清理非托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "InheritedBaseClass"));
        }

        ~InheritedBaseClass()
        {
            Dispose(false);
        }
    }
}

子类：

using System.IO;

namespace Dispose模式
{
    public class InheritedSubClass : InheritedBaseClass
    {
        protected InheritedSubClass(string name)
            : base(name)
        {
        }

        protected override void DisposeManagedResources()
        {
            // 清理托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "InheritedSubClass"));
            base.DisposeManagedResources();
        }

        protected override void DisposeUnmanagedResources()
        {
            // 清理非托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "InheritedSubClass"));
            base.DisposeUnmanagedResources();
        }

        ~InheritedSubClass()
        {
            Dispose(false);
        }
    }
}

从属子类：

using System.IO;

namespace Dispose模式
{
    public class InheritedSuperSubClass : InheritedSubClass
    {
        public InheritedSuperSubClass(string name)
            : base(name)
        {
        }

        protected override void DisposeManagedResources()
        {
            // 清理托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "InheritedSuperSubClass"));
            base.DisposeManagedResources();
        }

        protected override void DisposeUnmanagedResources()
        {
            // 清理非托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "InheritedSuperSubClass"));
            base.DisposeUnmanagedResources();
        }

        ~InheritedSuperSubClass()
        {
            Dispose(false);
        }
    }
}

测试类：

using System.IO;

namespace Dispose模式
{
    public class TestInheritedClass : InheritedBaseClass
    {
        public TestInheritedClass(string name)
            : base(name)
        {
            _inheritedBaseClass = new InheritedSuperSubClass(Name);
        }

        private readonly InheritedBaseClass _inheritedBaseClass;

        protected override void DisposeManagedResources()
        {
            // 清理托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.ManagedFormat, Index, Name, "TestInheritedClass"));
            _inheritedBaseClass.Dispose();
            base.DisposeManagedResources();
        }

        protected override void DisposeUnmanagedResources()
        {
            // 清理非托管资源
            File.AppendAllText("Test.txt", string.Format(Resources.UnmanagedFormat, Index, Name, "TestInheritedClass"));
            base.DisposeUnmanagedResources();
        }

        ~TestInheritedClass()
        {
            Dispose(false);
        }
    }
}

释放资源类：

using System;

namespace Dispose模式
{
    public static class Resources
    {
        public static readonly string ManagedFormat = "第{0}个对象{1}，清理{2}托管资源" + Environment.NewLine;

        public static readonly string UnmanagedFormat = "第{0}个对象{1}，清理{2}非托管资源" + Environment.NewLine;
    }
}

主类：

using System;
using System.IO;

namespace Dispose模式
{
    class Program
    {
        static void Main()
        {
            File.Delete("Test.txt");

            using (var a1 = new TestClass("a1"))
            {
                Console.WriteLine(a1.ToString());
            }

            var a2 = new TestClass("a2");
            Console.WriteLine(a2.ToString());

            var b1 = new TestInheritedClass("b1");
            Console.WriteLine(b1.ToString());
            b1.Dispose();

            var b2 = new TestInheritedClass("b2");
            Console.WriteLine(b2.ToString());
        }
    }
}

运行结果：

第1个对象a1，清理TestClass托管资源
第1个对象a1，清理SuperSubClass托管资源
第1个对象a1，清理SuperSubClass非托管资源
第1个对象a1，清理SubClass托管资源
第1个对象a1，清理SubClass非托管资源
第1个对象a1，清理BaseClass托管资源
第1个对象a1，清理BaseClass非托管资源
第1个对象a1，清理TestClass非托管资源
第1个对象b1，清理TestInheritedClass托管资源
第2个对象b1，清理InheritedSuperSubClass托管资源
第2个对象b1，清理InheritedSubClass托管资源
第2个对象b1，清理InheritedBaseClass托管资源
第2个对象b1，清理InheritedSuperSubClass非托管资源
第2个对象b1，清理InheritedSubClass非托管资源
第2个对象b1，清理InheritedBaseClass非托管资源
第1个对象b1，清理InheritedBaseClass托管资源
第1个对象b1，清理TestInheritedClass非托管资源
第1个对象b1，清理InheritedBaseClass非托管资源
第4个对象b2，清理InheritedSuperSubClass非托管资源
第4个对象b2，清理InheritedSubClass非托管资源
第4个对象b2，清理InheritedBaseClass非托管资源
第3个对象b2，清理TestInheritedClass非托管资源
第3个对象b2，清理InheritedBaseClass非托管资源
第2个对象a2，清理SuperSubClass非托管资源
第2个对象a2，清理SubClass非托管资源
第2个对象a2，清理BaseClass非托管资源
第2个对象a2，清理TestClass非托管资源

转载于:https://www.cnblogs.com/nogic/archive/2013/01/29/2881173.html