c# - C# 中的类模板实现 shim

Question

我发现自己需要这样的东西:

// This could just as well be a concrete class.
//
// It is an interface for the sake of this example.
public interface Quark
{
    void Do();
}

public class Strange : Quark
{
    public virtual void Do()
    {
        // Something is done
    }

    public void DoSpecificThing()
    {
        MessageBox.Show("Specific Thing!");
    }
}

public class Charm : Quark
{
    public virtual void Do()
    {
        // Something else is done
    }

    public void DoAnotherSpecificThing()
    {
        MessageBox.Show("Another Specific Thing!");
    }
}

在另一个文件中:

internal class ReUsableCode<BaseType> : BaseType // <- not allowed
{
    public override void Do()
    {
        // Let's pretend this is around 2000 lines of
        // 90's-style Win32 message spaghetti.

        MessageBox.Show(base.GetType().ToString() + " did!");

        base.Do();
    }
}

public class LibraryStrange : ReUsableCode<Strange>
{
}

public class LibraryCharm : ReUsableCode<Charm>
{
}

在某个函数中:

LibraryStrange imStrange = new LibraryStrange();
LibraryCharm imCharmed = new LibraryCharm();

imStrange.Do();
imStrange.DoSpecificThing();

imCharmed.Do();
imCharmed.DoAnotherSpecificThing();

在 C++ 中，我只需要制作一个完全符合上述要求的模板。

由于上述原因，这在 C# 中是不可能的，而且多重继承也是不允许的。那么，如何在不复制和粘贴或强制一切都从单个基类继承的情况下重用词法相同的实现？

这是为了减少用户控件库所需的维护工作，这些控件全部继承自 System.Windows.Forms 中的内容，并且还以完全相同的方式覆盖 WndProc方式(代码都是复制粘贴的，我正在努力消除或集中它)。

注意:我没有做大量的 C# 工作，所以如果这个问题看起来很初级或滥用了这个领域的术语，请原谅我。

Answer 1

我想出的最简单的解决方案是放弃继承以支持组合。不幸的是，它需要概括“SpecificThing”的概念。

问题恰恰在于 SRP和 ISP在你的设计中被违反了，你想出的一切都只是为了避免问题而不是解决问题的技巧!

您在评论中写下“问题中的“基本类型”[...]”——最好将其放在引号中——这些不应该是基本类型。然而，该表述过于笼统，很难明确指出哪里出了问题 - 这里似乎一切都是错误的。

public interface Quark
{
    void Do();
}

public interface SpecificQuark : Quark
{
    void DoSpecificThing();
}

public class Strange : SpecificQuark
{
    public virtual void Do()
    {
        // Something is done
    }

    public void DoSpecificThing()
    {
        Console.WriteLine("Specific Thing!");
    }
}

public class Charm : SpecificQuark
{
    public virtual void Do()
    {
        // Something else is done
    }

    public void DoSpecificThing()
    {
        Console.WriteLine("Another Specific Thing!");
    }
}

class ReUsableCode<T>
    where T: SpecificQuark, new()
{
    public T InnerQuark { get; private set; }

    public ReUsableCode()
    {
        this.InnerQuark = new T();
    }

    public void Do()
    {
        // Let's pretend this is around 2000 lines of
        // 90's-style Win32 message spaghetti.

        Console.WriteLine(InnerQuark.GetType().ToString() + " did!");
        this.InnerQuark.Do();
    }
}

class LibraryStrange : ReUsableCode<Strange>
{
}

class LibraryCharm : ReUsableCode<Charm>
{
}

然后:

LibraryStrange ls = new LibraryStrange();
LibraryCharm lc = new LibraryCharm();

ls.Do();
ls.InnerQuark.DoSpecificThing();
lc.Do();
lc.InnerQuark.DoSpecificThing();