Question

以此代码为例：

public class DisposeMe : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("I'm disposed!");
    }
}

public class Base
{
    private readonly Object _object;

    public Base(Object obj)
    {
        _object = obj;
    }
}

public class Derived : Base, IDisposable
{
    public Derived()
        : base(new DisposeMe())
    {
    }

    public void Dispose()
    {
        // Should dispose the object allocated in the constructor.
    }
}

我在实际程序中有这种代码。

我真正想做的是将new DisposeMe()构造函数中的Derived替换为一个可以创建＆amp;的方法。返回它，但也将它保存在进程中的一个字段中，这样我就可以在Derived.Dispose处理它。

但是我不能，因为出于某种原因（除了我），base访问的构造函数是静态的。为什么？我怎么能绕过它？

P.S。我知道我可以将Base更改为IDisposable并让它在每次处理时检查馈送的对象是否为IDisposable。我不对此感兴趣。这是繁琐，低效的，最重要的是分配对象的人应该是负责处理它的人（否则我会在脚下射击自己处理在其他地方使用的对象）。

Answer 1

您可以将受保护的只读属性添加到Base，以便您可以从Derived.Dispose访问它。

public class DisposeMe : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("I'm disposed!");
    }
}

public class Base
{
    private readonly Object _object;
    protected Object _Object { get { return _object; } }

    public Base(Object obj)
    {
        _object = obj;
    }
}

public class Derived : Base, IDisposable
{
    public Derived()
        : base(new DisposeMe())
    {
    }

    public void Dispose()
    {
        (_Object as IDisposable).Dispose();
    }
}

Answer 2

我认为最简单的方法是为Derived班级建立一个工厂：

public static Derived CreateDerived()
{
   DisposeMe d = new DisposeMe();
   return new Derived(d);
}

private DisposeMe _d;
private Derived(DisposeMe d) : base (d) 
{
    _d = d;
}

然后你的处置方法：

public void Dispose()
{
   _d.Dispose();
}

Answer 3

public class Derived<T> : Base, IDisposable where T : IDisposable, new()
{
    public Derived()
        : base(new T())
    {
    }

    public void Dispose()
    {
        var obj = base._object as IDisposable;
        if (obj != null)
            obj.Dispose();
    }
}

为什么基础构造函数在静态上下文中？如何应对？

3 个答案: