首页 / 知识

关于.net：C＃接口的非公开成员

2023-04-12 14:31:00

Non Public Members for C# Interfaces

在C＃中，实现接口时，所有成员都是隐式公共的。如果可以指定可访问性修饰符(当然是protected，internal，当然除了private除外)会更好，还是应该只使用抽象类呢？

如果接口是内部接口，则其所有成员都将在部件内部。如果嵌套接口受保护，则只有外部类的子类才能访问该接口。

在其声明程序集外部的接口的内部成员将毫无意义，在其声明外部类外部的接口的受保护成员也将毫无意义。

接口的重点是描述接口的实现类型和用户之间的协定。外部呼叫者将不必在乎，也不必在乎实现，这是内部成员和受保护成员的目的。

对于由基类调用的受保护成员，抽象类是在基类和从其继承的类之间指定契约的方法。但是在这种情况下，实现细节通常非常相关，除非它是一个退化的纯抽象类(所有成员都是抽象类)，在这种情况下，受保护的成员是无用的。在这种情况下，请使用一个接口并保存单个基类以实现选择的类型。

您可以通过在方法名称之前显式说明接口名称来隐藏接口的实现：

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

public interface IInterface {
public void Method();
}

public class A : IInterface {
public void IInterface.Method() {
// Do something
}
}

public class Program {
public static void Main() {
A o = new A();
o.Method(); // Will not compile
((IInterface)o).Method(); // Will compile
}
}

没道理。接口是您与公众签订的支持这些方法和属性的合同。坚持抽象类。

这里的所有答案或多或少都表明接口的含义是，它们是通用的公共规范。

这是讨论最多的话题，当我浮出水面时，让我发表两个在SO上找到的出色答案。

这个答案给出了一个示例，说明派生类中的接口成员具有非统一的访问说明符可能是荒谬的。代码总是比技术说明更好。

对我而言，强制公共接口成员最令人讨厌的事情是，接口本身可以在程序集内部，但其公开的成员必须是公共的。乔恩·斯基特(Jon Skeet)可悲的是，这是设计使然。

这就提出了一个问题，为什么接口的设计没有为成员提供非公开的定义。这样可以使合同更加灵活。在编写不希望将类的特定成员暴露给程序集外部的程序集时，这非常有用。我不知道为什么。

您可以隐藏几乎所有由外部程序集的接口实现的代码。

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

interface IVehicle
{
void Drive();
void Steer();
void UseHook();
}
abstract class Vehicle // :IVehicle // Try it and see!
{
/// <summary>
/// Consuming classes are not required to implement this method.
/// </summary>
protected virtual void Hook()
{
return;
}
}
class Car : Vehicle, IVehicle
{
protected override void Hook() // you must use keyword"override"
{
Console.WriteLine(" Car.Hook(): Uses abstracted method.");
}
#region IVehicle Members

public void Drive()
{
Console.WriteLine(" Car.Drive(): Uses a tires and a motor.");
}

public void Steer()
{
Console.WriteLine(" Car.Steer(): Uses a steering wheel.");
}
/// <summary>
/// This code is duplicated in implementing classes. Hmm.
/// </summary>
void IVehicle.UseHook()
{
this.Hook();
}

#endregion
}
class Airplane : Vehicle, IVehicle
{
protected override void Hook() // you must use keyword"override"
{
Console.WriteLine(" Airplane.Hook(): Uses abstracted method.");
}
#region IVehicle Members

public void Drive()
{
Console.WriteLine(" Airplane.Drive(): Uses wings and a motor.");
}

public void Steer()
{
Console.WriteLine(" Airplane.Steer(): Uses a control stick.");
}
/// <summary>
/// This code is duplicated in implementing classes. Hmm.
/// </summary>
void IVehicle.UseHook()
{
this.Hook();
}

#endregion
}

这将测试代码。

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

class Program
{
static void Main(string[] args)
{
Car car = new Car();
IVehicle contract = (IVehicle)car;
UseContract(contract); // This line is identical...
Airplane airplane = new Airplane();
contract = (IVehicle)airplane;
UseContract(contract); // ...to the line above!
}

private static void UseContract(IVehicle contract)
{
// Try typing these 3 lines yourself, watch IDE behavior.
contract.Drive();
contract.Steer();
contract.UseHook();
Console.WriteLine("Press any key to continue...");
Console.ReadLine();
}
}

接口是所有实现类都遵守的契约。这意味着他们必须遵守所有规则或不遵守任何规则。

如果接口是公共的，那么该联系人的每个部分都必须是公共的，否则对朋友/内部类来说意味着一个，而对其他所有东西则意味着不同。

在接口上使用抽象基类或(如果可能且可行)内部扩展方法。

接口的方法中没有访问修饰符，因此可以使用任何合适的访问修饰符。这有一个目的：它允许其他类型推断出接口后对象可用的方法和属性。为它们提供受保护的/内部的访问器会破坏接口的目的。

如果您坚决需要为方法提供访问修饰符，则可以将其保留在接口之外，或者如您所说，使用抽象类。

在我看来，这违反了封装。我必须公开实现一个方法，然后再实现一个接口。我认为没有理由在实现接口的类中强制公开。 (C＃)

我熟悉Java而不是C＃，但是为什么您会希望在接口中加入私有成员呢？它没有任何实现，并且对实现类是不可见的，因此将毫无用处。存在用于指定行为的接口。如果您需要默认行为，则可以使用抽象类。

接口修饰符子类抽象类