Вызов base.Dispose () автоматически из производных классов

Лично я думаю, что вам может быть лучше справиться с этим с помощью чего-то вроде FxCop. Вы должны иметь возможность написать правило, которое проверяет, чтобы при создании объекта, реализующего IDisposable, вы использовали оператор using.

Мне кажется немного грязным автоматически избавляться от объекта.

Если вы хотите использовать [basetype] .Invoke ("Dispose" ...), вы можете реализовать вызов функции без жалоб отладчика. Позже, когда базовый тип фактически реализует интерфейс IDisposable, он выполнит правильный вызов.

Если вы хотите использовать [basetype] .Invoke ("Dispose" ...), вы можете реализовать вызов функции без жалоб отладчика. Позже, когда базовый тип фактически реализует интерфейс IDisposable, он выполнит правильный вызов.

Стандартный шаблон для вашего базового класса предназначен для реализации IDisposable и невиртуального метода Dispose (), а также для реализации виртуального метода Dispose (bool), который те классы, которые содержат одноразовые ресурсы, должны переопределить. Они всегда должны вызывать свой базовый метод Dispose (bool), который в конечном итоге будет связан с верхним классом в иерархии. Вызываются только те классы, которые его переопределяют, поэтому цепочка обычно довольно короткая.

Финализаторы, пишущиеся ~ Class на C#: не надо. Очень немногие классы будут нуждаться в одном, и очень легко случайно оставить большие графы объектов, потому что финализаторам требуется как минимум две коллекции, прежде чем память будет освобождена. В первой коллекции после того, как объект больше не упоминается, он помещается в очередь финализаторов для запуска. Они запускают в отдельном, выделенном потоке, который запускает только финализаторы (если он блокируется, финализаторы больше не запускаются, и ваше использование памяти резко возрастает). После запуска финализатора следующая коллекция, которая собирает соответствующее поколение, освободит объект и все остальное, на что он ссылался, что не упоминается иначе. К сожалению, поскольку он пережил первую коллекцию, он будет передан старшему поколению, которое собирается реже. По этой причине вы должны утилизировать как можно раньше и чаще.

Как правило, вы должны реализовать небольшой класс-оболочку ресурса, который Только управляет временем жизни ресурса и реализует финализатор для этого класса, а также IDisposable. Затем пользователь класса должен вызвать Dispose для этого, когда он будет удален. Обратной ссылки на пользователя быть не должно. Таким образом, только то, что действительно требует доработки, попадет в очередь доработки.

Если они вам понадобятся где-нибудь в иерархии, базовый класс, реализующий IDisposable, должен реализовать финализатор и вызвать Dispose (bool), передав false в качестве параметра.

ПРЕДУПРЕЖДЕНИЕ для разработчиков Windows Mobile (VS2005 и 2008, .NET Compact Framework 2.0 и 3.5): многие элементы, не относящиеся к элементам управления, которые вы перетаскиваете на поверхность конструктора, например строки меню, таймеры, HardwareButtons являются производными от System.ComponentModel.Component, который реализует финализатор. Для настольных проектов Visual Studio добавляет компоненты в System.ComponentModel.Container с именем components, который генерирует код для Dispose, когда форма Disposed - он, в свою очередь, удаляет все добавленные компоненты. Для мобильных проектов создается код Dispose components, но при падении компонента на поверхность код для добавления его в components не создается.. Вы должны сделать это самостоятельно в своем конструкторе после вызова InitializeComponent.

public class MyVeryBaseClass {
    protected void RealDispose(bool isDisposing) {
        IDisposable tryme = this as IDisposable;
        if (tryme != null) { // we implement IDisposable
            this.Dispose();
            base.RealDispose(isDisposing);
        }
    }
}
public class FirstChild : MyVeryBaseClasee {
    //non-disposable
}
public class SecondChild : FirstChild, IDisposable {
    ~SecondChild() {
        Dispose(false);
    }
    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
        base.RealDispose(true);
    }
    protected virtual void Dispose(bool bDisposing) {
        if (!m_bDisposed) {
            if (bDisposing) {
            }// Dispose managed resources
        } // Dispose unmanaged resources
    }
}

Таким образом, вы несете ответственность за правильную реализацию только первого класса, который является IDisposable.

Попробуй это. Это однострочное дополнение к методу Dispose (), которое вызывает метод удаления предка, если он существует. (Обратите внимание, что Dispose(bool) не является членом IDisposable)

// Disposal Helper Functions
public static class Disposing
{
    // Executes IDisposable.Dispose() if it exists.
    public static void DisposeSuperclass(object o)
    {
        Type baseType = o.GetType().BaseType;
        bool superclassIsDisposable = typeof(IDisposable).IsAssignableFrom(baseType);
        if (superclassIsDisposable)
        {
            System.Reflection.MethodInfo baseDispose = baseType.GetMethod("Dispose", new Type[] { });
            baseDispose.Invoke(o, null);
        }
    }
}

class classA: IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Disposing A");
    }
}

class classB : classA, IDisposable
{
}

class classC : classB, IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Disposing C");
        Disposing.DisposeSuperclass(this);
    }
}

Не существует «общепринятого» способа сделать это. Вы действительно хотите сделать свою логику очистки (независимо от того, работает ли она внутри Dispose или финализатора) как можно проще, чтобы она не потерпела неудачу. Использование отражения внутри утилиты (и особенно финализатора), как правило, плохая идея.

Что касается реализации финализаторов, в общем, в этом нет необходимости. Финализаторы увеличивают стоимость вашего объекта, и их трудно правильно написать, поскольку большинство предположений, которые вы обычно можете сделать о состоянии объекта и времени выполнения, недействительны.

См. Этот статья для получения дополнительной информации о шаблоне Dispose.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestDisposeInheritance
{
    class Program
    {
        static void Main(string[] args)
        {
            classC c = new classC();
            c.Dispose();
        }
    }

    class classA: IDisposable 
    { 
        private bool m_bDisposed;
        protected virtual void Dispose(bool bDisposing)
        {
            if (!m_bDisposed)
            {
                if (bDisposing)
                {
                    // Dispose managed resources
                    Console.WriteLine("Dispose A"); 
                }
                // Dispose unmanaged resources 
            }
        }
        public void Dispose() 
        {
            Dispose(true);
            GC.SuppressFinalize(this);
            Console.WriteLine("Disposing A"); 
        } 
    } 

    class classB : classA, IDisposable 
    {
        private bool m_bDisposed;
        public void Dispose()
        {
            Dispose(true);
            base.Dispose();
            GC.SuppressFinalize(this);
            Console.WriteLine("Disposing B");
        }

        protected override void Dispose(bool bDisposing)
        {
            if (!m_bDisposed)
            {
                if (bDisposing)
                {
                    // Dispose managed resources
                    Console.WriteLine("Dispose B");
                }
                // Dispose unmanaged resources 
            }
        }
    } 

    class classC : classB, IDisposable 
    {
        private bool m_bDisposed;
        public void Dispose() 
        {
            Dispose(true);
            base.Dispose();
            GC.SuppressFinalize(this);
            Console.WriteLine("Disposing C");             
        }
        protected override void Dispose(bool bDisposing)
        {
            if (!m_bDisposed)
            {
                if (bDisposing)
                {
                    // Dispose managed resources
                    Console.WriteLine("Dispose C");             
                }
                // Dispose unmanaged resources 
            }
        }
    } 

}