C# 为什么基构造函数处于静态上下文中？如何应对？

以这段代码为例：

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.
    }
}

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

实际上，我想做的是将

派生的
构造函数中的
新DisposeMe（）
替换为一个方法，该方法将创建并返回它，但也将它保存在过程中的一个字段中，这样我就可以在
派生的.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();
    }
}

但是我不能，因为出于某种原因（除了我之外），由
base
访问的构造函数是静态的。为什么？我怎样才能避开它

另外，我知道我可以将
Base
更改为
IDisposable
，并让它在每次处理对象时检查其是否为
IDisposable
。我对做那件事不感兴趣。它笨重、低效，最重要的是，分配对象的人应该是负责处理对象的人（否则，在处理其他地方使用的对象时，我会打自己的脚）。
我认为最简单的方法是为您的
派生类创建工厂：

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();
}

我认为最简单的方法是为
派生类创建工厂：

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();
}

您可以将受保护的只读属性添加到
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();
    }
}

您可以将受保护的只读属性添加到
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();
    }
}

public类派生：Base，IDisposable其中T:IDisposable，new（）
{
公共派生（）
：base（新的T（））
{
}
公共空间处置（）
{
var obj=基本对象。_对象作为IDisposable；
如果（obj！=null）
obj.Dispose（）；
}
}
公共类派生：Base，IDisposable，其中T:IDisposable，new（）
{
公共派生（）
：base（新的T（））
{
}
公共空间处置（）
{
var obj=基本对象。_对象作为IDisposable；
如果（obj！=null）
obj.Dispose（）；
}
}
您将工厂方法（应该创建
IDisposable的方法）放在哪里？你能提供一些示例代码来证明你的意图吗？请注意，您不能使用
派生的
实例方法，因为在调用
派生的
构造函数时，您的实例仍在构造中。@MattiasBuelens哦，我现在看到问题了。那么解决方案可能是什么呢？我必须有一个推荐人才能处理。我需要改变我的设计吗？如果是这样的话，会变成什么？分配对象的人应该是负责人。。。是的，没错。基地不应该负责储存。你根本不应该有这个问题。认为它是一个消息：你的基本设计是有缺陷的。您会将工厂方法（应该创建
IDisposable
）放在哪里？你能提供一些示例代码来证明你的意图吗？请注意，您不能使用
派生的
实例方法，因为在调用
派生的
构造函数时，您的实例仍在构造中。@MattiasBuelens哦，我现在看到问题了。那么解决方案可能是什么呢？我必须有一个推荐人才能处理。我需要改变我的设计吗？如果是这样的话，会变成什么？分配对象的人应该是负责人。。。是的，没错。基地不应该负责储存。你根本不应该有这个问题。认为它是一个消息：你的基本设计是有缺陷的。我不敢这么做（我对OOP非常保密），但另一种选择是将同一引用保存两次，一次用于使用，一次用于处置。你赢得了命运；谢谢你高兴@Ken我不认为在类中公开只读数据有什么错。当你能改变它们的时候，问题就开始了。哦，我的意思是吸引我回来的只是让它受到保护@Steve在实际案例中，它保证是
IDisposable
，尽管我在实际项目中检查了它是否为null。谢谢你们。这并不能真正解决“用方法调用替换
newdisposeme（）
”的问题，对吗？无论如何，您可以将
Base
设置为泛型，这样就不需要强制转换
Dispose
。此外，只需将
\u对象
改为受保护即可，但添加受保护的属性可能更灵活（如果需要覆盖它或其他内容）。@MattiasBuelens是的，但它解决了一般问题。而且，我尽量不使用泛型。是的，如果字段是只读的，你可以将其设置为字段保护。我害怕这样做（我对OOP非常保密），但另一个选择是将同一引用保存两次，一次用于使用，一次用于处置。你赢得了命运；谢谢你高兴@Ken我不认为在类中公开只读数据有什么错。当你能改变它们的时候，问题就开始了。哦，我的意思是吸引我回来的只是让它受到保护@Steve在实际案例中，它保证是
IDisposable
，尽管我在实际项目中检查了它是否为null。谢谢你们。这并不能真正解决“用方法调用替换
newdisposeme（）
”的问题，对吗？无论如何，您可以将
Base
设置为泛型，这样就不需要强制转换
Dispose
。此外，只需将
\u对象
改为受保护即可，但添加受保护的属性可能更灵活（如果需要覆盖它或其他内容）。@MattiasBuelens是的，但它解决了一般问题。而且，我尽量不使用泛型。是的，如果字段是只读的，您可以将其设置为受保护。
\u对象
对
派生的
不可见。这是私人的
。已解决的已接受答案确实使tho成为可能，但谢谢。
\u对象
对
派生的
不可见。这是私人的
。被接受的答案解决了，这是可能的，但谢谢你。如果