C# 泛型方法声明

我有等级制度：

class A{}
class B: A {}
class C:B {}

是否可以在类A中实现方法，并且它将被派生类B和C等继承，并且该方法应该返回类类型的值

A val = A.method(); (val is A)
B val = B.method(); (val is B)
C val = C.method(); (val is C)

我不希望在调用此方法时使用泛型，即：

C val = C.method<C>();

C val=C.method（）；

伙计们，对不起，一个精化，这个方法应该是静态的

我不想在方法istelf中使用泛型，因为它强制指向该方法应返回的类型，而该方法应返回其类的类型

class A
    {
      Method<T>()
      {
         T result;
         return result;
      }
    }

A类
{
方法（）
{
T结果；
返回结果；
}
}

如果我有这样的方法，我可以更改返回类型：

D result = A.Method<D>();

D结果=A.Method（）；

---

但我希望它返回类型A的值

> P>使用C++的一些设计模式使之更容易：

class A
{
    protected virtual A method_impl() { return new A(); }
    public A method() { return method_impl(); }
}

class B : A
{
    protected override A method_impl() { return new B(); }
    public new B method() { return (B)method_impl(); }
}

class C : B
{
    protected override A method_impl() { return new C(); }
    public new C method() { return (C)method_impl(); }
}

当然，这个问题从来没有出现在C++中，它允许重写的共用返回类型。

---

另一种方式，使用IoC模式：

class A
{
    protected virtual void method_impl(A a) { a.initialize(); }
    public A method() { A result = new A(); method_impl(result); return result; }
}

class B : A
{
    public new B method() { B result = new B(); method_impl(result); return result; }
}

class C : B
{
    public new C method() { C result = new C(); method_impl(result); return result; }
}

---

使用C++的一些设计模式使之更容易：

class A
{
    protected virtual A method_impl() { return new A(); }
    public A method() { return method_impl(); }
}

class B : A
{
    protected override A method_impl() { return new B(); }
    public new B method() { return (B)method_impl(); }
}

class C : B
{
    protected override A method_impl() { return new C(); }
    public new C method() { return (C)method_impl(); }
}

当然，这个问题从来没有出现在C++中，它允许重写的共用返回类型。

---

另一种方式，使用IoC模式：

class A
{
    protected virtual void method_impl(A a) { a.initialize(); }
    public A method() { A result = new A(); method_impl(result); return result; }
}

class B : A
{
    public new B method() { B result = new B(); method_impl(result); return result; }
}

class C : B
{
    public new C method() { C result = new C(); method_impl(result); return result; }
}

---

使用扩展方法：

class Program
    {
        static void Main(string[] args)
        {
            B x = new B();
            x.Method();
        }
    }

    public static class Ext
    {
        public static T Method<T>(this T obj)
            where T : A,new()
        {
            return new T();
        }
    }

    public class A
    {

    }

    public class B : A
    {

    }

类程序
{
静态void Main（字符串[]参数）
{
B x=新的B（）；
x、 方法（）；
}
}
公共静态类Ext
{
公共静态T方法（此T对象）
其中T:A，new（）
{
返回新的T（）；
}
}
公共A类
{
}
B级：A级
{
}

---

或其变体。请注意，您必须有一些能够创建指定类型实例的公共成员。具体来说，编译器“猜测”类型参数的值。该方法仍然是泛型的，但调用该方法时（通常）找不到泛型语法。

使用扩展方法：

class Program
    {
        static void Main(string[] args)
        {
            B x = new B();
            x.Method();
        }
    }

    public static class Ext
    {
        public static T Method<T>(this T obj)
            where T : A,new()
        {
            return new T();
        }
    }

    public class A
    {

    }

    public class B : A
    {

    }

类程序
{
静态void Main（字符串[]参数）
{
B x=新的B（）；
x、 方法（）；
}
}
公共静态类Ext
{
公共静态T方法（此T对象）
其中T:A，new（）
{
返回新的T（）；
}
}
公共A类
{
}
B级：A级
{
}

---

或其变体。请注意，您必须有一些能够创建指定类型实例的公共成员。具体来说，编译器“猜测”类型参数的值。该方法仍然是泛型的，但调用该方法时（通常）找不到泛型语法。

不，这是不可能的

要像这样调用该方法，它必须是静态的，并且静态方法不会被继承

---

使用

B.method（）

在

a

中调用静态方法与使用

a.method（）

相同。编译器只是使用类型来确定方法的位置，但是方法不可能知道它是使用

A

还是

B

类型调用的。

不，这是不可能的

要像这样调用该方法，它必须是静态的，并且静态方法不会被继承

---

使用

B.method（）

在

a

中调用静态方法与使用

a.method（）

相同。编译器只是使用类型来确定方法的位置，但是方法不可能知道它是使用

A

还是

B

类型调用的。

done。语言是c#让我问一个问题，如果您编写：var val=（c as a.method（），会发生什么；关键是，这种构造在正常情况下是不必要的。所以你想在B中使用

public B method（）{}

，在C中使用

public method（）{}

，你想在A中定义这个方法，对吗？奇怪的是，你为什么不想在方法中使用泛型呢？看起来你想要一个静态方法？是这样吗？好了。语言是c#让我问一个问题，如果您编写：var val=（c as a.method（），会发生什么；关键是，这种构造在正常情况下是不必要的。所以你想在B中使用

public B method（）{}

，在C中使用

public method（）{}

，你想在A中定义这个方法，对吗？奇怪的是，你为什么不想在方法中使用泛型呢？看起来你想要一个静态方法？是这样吗？虽然

B.method（）

返回一个

B

实例，但返回类型是

a

，因此它仍然需要强制转换：

B val=（B）（B.method（））

@Guffa:再看看——受保护的

方法\u impl

是这样的，而不是公共方法（除非通过基类句柄以多态方式调用）。@BenVoigt:我明白了，B中有一个方法隐藏了a中的方法，这是OP特别要求避免的。所以，-1因为答案不能回答问题。@Guffa:他问什么来避免这个问题？他要求继承行为，受保护的虚拟方法中的行为被继承。@BenVoigt:请阅读问题。对于其他类，该方法没有在A中实现，因为实现是隐藏的。虽然

B.method（）

返回一个

B

实例，但返回类型是

A

，因此它仍然需要强制转换：

B val=（B）（B.method（））

@Guffa:再看看——受保护的

方法\u impl

是这样的，而不是公共方法（除非通过基类句柄以多态方式调用）。@BenVoigt:我明白了，B中有一个方法隐藏了a中的方法，这是OP特别要求避免的。所以，-1因为答案不能回答问题。@Guffa:他问什么来避免这个问题？他要求继承行为，受保护的虚拟方法中的行为被继承。@BenVoigt:请阅读问题。对于其他类，该方法没有在中实现，因为实现是隐藏的。