关于c＃：静态方法继承的正确替代方法是什么？

What's the correct alternative to static method inheritance?

我知道C中不支持静态方法继承。我还阅读了许多讨论(包括这里)，其中开发人员声称需要此功能，对此，典型的回答是"如果需要静态成员继承，那么您的设计中就存在缺陷"。

好吧，考虑到OOP甚至不想让我考虑静态继承，我必须得出结论，我对它的明显需求指出了我的设计中的一个错误。但是，我被卡住了。我真的很感谢你帮我解决这个问题。这是挑战…

我想创建一个抽象的基类(我们称之为水果)，它封装了一些复杂的初始化代码。此代码不能放置在构造函数中，因为其中一些代码将依赖于虚拟方法调用。

水果将由其他具体类(Apple、Orange)继承，每个类必须公开标准的工厂方法createInstance()以创建和初始化实例。

如果静态成员继承是可行的，我会将工厂方法放在基类中，并使用对派生类的虚拟方法调用来获取必须从中初始化具体实例的类型。客户端代码将简单地调用apple.createInstance()以获取完全初始化的apple实例。

但显然这是不可能的，所以有人能解释一下我的设计需要如何改变以适应相同的功能吗？

相关讨论

一个想法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public abstract class Fruit<T>
where T : Fruit<T>, new()
{
public static T CreateInstance()
{
T newFruit = new T();
newFruit.Initialize(); // Calls Apple.Initialize
return newFruit;
}

protected abstract void Initialize();
}

public class Apple : Fruit<Apple>
{
protected override void Initialize() { ... }
}

像这样叫：

1	Apple myAppleVar = Fruit<Apple>.CreateInstance();

不需要额外的工厂课程。

相关讨论

imho，最好将泛型类型移动到CreateInstance方法，而不是将其放在类级别。(就像我回答的那样)。
注意您的偏好。对您的偏好作一个简短的解释会更受欢迎。
这样做，就不会"污染"类的其余部分；类型参数只在create方法中是必需的(至少在本例中)。接下来，我认为：fruit.create()；比：fruit.create()更可读；
我可以看到，尽管"污染"问题高度依赖于其他类别的要求(即，类型信息可能在其他地方需要)。对于本例的目的和局限性，这两种解决方案似乎都非常充分。
您不应该将构造函数设置为私有吗？
@约翰-是的，接球很好。在Apple中应该有一个定义为非公共的构造函数，这样外部类就必须使用工厂方法来创建对象。可能需要对其进行保护，以便水果类可以访问它。Fruit在技术上不需要构造函数，因为它是一个抽象类。我将相应地进行编辑。
不能使Apple构造函数小于public，因为where T : Fruit, new()规定T必须有public构造函数。@Matt Hamsmith-在删除protected Apple() { }之前，代码不会编译。我已经在vs.
@托希德-你是对的。我已经编辑过了。然而，这确实暴露了在不使用水果createInstance静态工厂方法的情况下构建苹果，但这似乎是不可避免的。
如果我需要将参数传递给CreateInstance，但是所需参数在继承的类中可能有所不同，该怎么办？
@shadow_map the op states"水果将由其他具体类(apple、orange)继承，每个类必须公开标准工厂方法createInstance()以创建和初始化实例。"听起来您的问题与非标准createInstance()方法有关，以初始化实例。你的情况可能需要一个完全不同的问题和解决方案。
我还想指出，这可以用简单的Apple.CreateInstance()而不是Fruit.CreateInstance()来调用。
这种设计的唯一真正优势是您可以调用Apple.CreateInstance()。否则，为什么不直接用public static T CreateInstance() where T : Fruit来称呼它，就像用Fruit.CreateInstance()来称呼它？我以前使用过您建议的设计，但最终停止使用，因为它会导致代码混乱。这不仅仅是我的观点：blogs.msdn.microsoft.com/ericlippert/2011/02/03/&hellip；

将工厂方法移出类型，并将其放入自己的工厂类中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public abstract class Fruit
{
protected Fruit() {}

public abstract string Define();

}

public class Apple : Fruit
{
public Apple() {}

public override string Define()
{
return"Apple";
}
}

public class Orange : Fruit
{
public Orange() {}

public override string Define()
{
return"Orange";
}
}

public static class FruitFactory<T>
{
public static T CreateFruit<T>() where T : Fruit, new()
{
return new T();
}
}

但是，正如我所看到的，不需要将create方法移动到它自己的工厂类(尽管我认为它更可取——分离关注点)，您可以将它放在fruit类中：

1
2
3
4
5
6
7
8
9
10
11

public abstract class Fruit
{

public abstract string Define();

public static T CreateFruit<T>() where T : Fruit, new()
{
return new T();
}

}

而且，为了看看它是否有效：

1
2
3
4
5
6
7
8
9
10

class Program
{
static void Main( string[] args )
{
Console.WriteLine (Fruit.CreateFruit<Apple> ().Define ());
Console.WriteLine (Fruit.CreateFruit<Orange> ().Define ());

Console.ReadLine ();
}
}

相关讨论

我想做这样的事

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public abstract class Fruit() {
public abstract void Initialize();
}

public class Apple() : Fruit {
public override void Initialize() {

}
}

public class FruitFactory<T> where T : Fruit, new {
public static <T> CreateInstance<T>() {
T fruit = new T();
fruit.Initialize();
return fruit;
}
}

var fruit = FruitFactory<Apple>.CreateInstance()

为什么不使用创建方法创建工厂类(模板化)？

1	FruitFactory<Banana>.Create();

相关讨论

首先，没有可以是虚拟的静态初始值设定项并不意味着您不能有可以重载的"标准"成员方法。其次，您可以从构造函数调用虚拟方法，它们将按预期工作，所以这里没有问题。第三，您可以使用泛型来拥有类型安全工厂。下面是一些代码，它使用了由构造函数调用的factory+member initialize()方法(它是受保护的，因此您不必担心，在创建对象后会有人再次调用它)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

abstract class Fruit
{
public Fruit()
{
Initialize();
}

protected virtual void Initialize()
{
Console.WriteLine("Fruit.Initialize");
}
}

class Apple : Fruit
{
public Apple()
: base()
{ }

protected override void Initialize()
{
base.Initialize();
Console.WriteLine("Apple.Initialize");
}

public override string ToString()
{
return"Apple";
}
}

class Orange : Fruit
{
public Orange()
: base()
{ }

protected override void Initialize()
{
base.Initialize();
Console.WriteLine("Orange.Initialize");
}

public override string ToString()
{
return"Orange";
}
}

class FruitFactory
{
public static T CreateFruit<T>() where T : Fruit, new()
{
return new T();
}
}

public class Program
{

static void Main()
{
Apple apple = FruitFactory.CreateFruit<Apple>();
Console.WriteLine(apple.ToString());

Orange orange = new Orange();
Console.WriteLine(orange.ToString());

Fruit appleFruit = FruitFactory.CreateFruit<Apple>();
Console.WriteLine(appleFruit.ToString());
}
}

相关讨论

.NET BCL中的WebRequest类及其派生类型是一个很好的例子，说明了这种设计是如何相对良好地实现的。

WebRequest类有几个子类，包括HttpWebRequest和FtpWebReuest。现在，这个WebRequest基类也是工厂类型，并且公开了一个静态Create方法(实例构造函数是隐藏的，根据工厂模式的要求)。

1 2	public static WebRequest Create(string requestUriString) public static WebRequest Create(Uri requestUri)

此Create方法返回WebRequest类的特定实现，并使用uri(或uri字符串)确定要创建和返回的对象类型。

这是以下使用模式的最终结果：

1
2
3
4
5
6
7

var httpRequest = (HttpWebRequest)WebRequest.Create("http://stackoverflow.com/");
// or equivalently
var httpRequest = (HttpWebRequest)HttpWebWebRequest.Create("http://stackoverflow.com/");

var ftpRequest = (FtpWebRequest)WebRequest.Create("ftp://stackoverflow.com/");
// or equivalently
var ftpRequest = (FtpWebRequest)FtpWebWebRequest.Create("ftp://stackoverflow.com/");

我个人认为这是解决这个问题的一个好方法，而且它似乎确实是.NET框架创建者首选的方法。

我想说，最好的做法是在必须调用的Fruit类上创建一个虚拟/抽象初始化方法，然后创建一个外部的"Fruit Factory"类来创建实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Fruit
{
//other members...
public abstract void Initialise();
}

public class FruitFactory()
{
public Fruit CreateInstance()
{
Fruit f = //decide which fruit to create
f.Initialise();

return f;
}
}