从超类 C# 返回子类的“this”

Question

我需要从超类返回“this”或子类实例。

interface IA
{
    IA Format();
    void Print();
}
interface IB
{
    IA Format();
    void Print();
    void PrintB();
}
abstract class A : IA
{
    protected bool isFormated;
    public IA Format()
    {
        isFormated = true; 
        return this;
    }
    virtual public void Print()
    {
        Console.WriteLine("this is A");
    }
}

class B : A, IB
{
    override public void Print()
    {
        Console.WriteLine("this is B");
    }
    public void PrintB()
    {
        if (isFormated)
        {
            Console.WriteLine("this is formated B");
        }
        else
        {
            Console.WriteLine("this is B");
        }
    }
}
class Program
{
    static void Main(string[] args)
    {
        var x = new B();
        x.Format().PrintB();
    }
}

我有两个类，A 类是超类，B 类是从 A 继承的子类。 这两个类实现了接口 A 和 B。

我需要调用'x.Format().PrintB();'只是为了格式化字符串。

换句话说，我需要在 Format() 函数中返回相同的对象，并且基于 Format() 中的更改，我需要更改 PrintB 行为。

因此，如果我创建了新的 D 类并继承了 A，我也想基于 isFormated 实现具有不同行为的 PrintD。

Answer 1

我将 A 作为泛型类采用 T 类型并将其返回为 T

    interface IA<T> where T : class
{
    T Format { get; }
    void Print();
}
abstract class A<T> : IA<T> where T : class
{
    protected bool isFormated;
    public T Format
    {
        get
        {
            isFormated = true;
            return this as T;
        }
    }

    virtual public void Print()
    {
        Console.WriteLine("this is A");
    }
}

interface IB
{
    void Print();
    void PrintB();
}
class B : A<B>, IB
{
    override public void Print()
    {
        Console.WriteLine("this is B");
    }
    public void PrintB()
    {
        if (isFormated)
        {
            Console.WriteLine("this is formated B");
        }
        else
        {
            Console.WriteLine("this is B");
        }
    }
}
class Program
{
    static void Main(string[] args)
    {
        var x = new B();
        x.Format.PrintB();
    }
}

Answer 2

当您调用x.Next() 时，它会返回一个实现IA 的实例。那可能是A、B，或任何其他实现IA 的类，但因为它返回IA，其他类不知道具体类型是什么。这通常是故意的。如果其他类不知道IA 的实现是什么，那么您可以将一个替换为另一个。

但是，由于Next 返回一个IA，你可以调用PrintB 的唯一方法是IA 有一个PrintB 方法，像这样：

public interface IA
{
    void PrintB();
}

如果A 实现了IA，那么它必须有一个PrintB 方法。但是因为它是一个abstract 类，所以该方法可以是抽象的。这意味着A 并没有真正实现该方法。实现它需要一个继承自A 的非抽象类。

看起来像这样：

abstract class A : IA
{
    public IA Next()
    {
        return this;
    }
    virtual public void Print()
    {
        Console.WriteLine("this is A");
    }

    public abstract void PrintB();
}

PrintB 不必是抽象的。 A 可以实现它。它可以是虚拟的，其他类可以覆盖它。或者它既不是抽象的也不是虚拟的，其他类不能覆盖它。

现在，当您声明 B : A 时，编译器将要求 B 实现 PrintB。

然后你可以调用Next().PrintB()，因为Next()返回IA并且IA有一个PrintB方法。