blocks|key|245249|text|虽然您可以将接口本身设置为内部接口，但这些方法仍然是公共API的一部分。您可以选择显式的接口实现，以便接口定义的API只能通过接口可见，而不能通过类可见。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|245250|interface+IFoo
{
+++++void+M();
}

interface+IBar
{
+++++void+X();+
}

public+class+Bar+:+IBar,+IFoo
{
++++public+void+X()+//+part+of+the+public+API+of+Bar
++++{
++++}

++++void+IFoo.M()+//+explicit+implementation,+only+visible+via+IFoo
++++{
++++}
}

Bar+bar+=+new+Bar();
bar.X();+//+visible
bar.M();+//+NOT+visible,+cannot+be+invoked
IFoo+foo+=+bar;
foo.M();+//+visible,+can+be+invoked|code-block|syntax|javascript|245251|除此之外，如果您需要让世界永远不知道类支持接口，那么您只需要不让类实现接口即可。接口用于广播给定对象支持给定行为的意图，显式或非显式。如果这不是你想要的，你需要换个方向。它可以简单地将行为实现为私有的实现细节，sans接口。另一种方法是将这些实现放入私有嵌套类中。|245252|public+class+Bar+:+IBar
{
++++Foo+foo+=+new+Foo();

++++public+void+X()+{+}+++

++++public+void+DoSomething()
++++{
++++++++this.foo.M();+//+invokes+method+of+instance+of+nested+class
++++}

++++class+Foo+:+IFoo
++++{
++++++++public+void+M()+{+}+
++++}
}|245253|在这种方法下，世界永远不会知道一个类是否履行了接口契约，因为从技术上讲它不会。契约是由Foo来履行的，并且世界看不到Foo。但是，好处是，如果类需要调用需要接口的外部定义的方法，它仍然可以将嵌套的类实例传递给这些方法。|offset|length|style|CODE|245254|entityMap^0|0|0|0|0|17|3|1M|3|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

While you can make the interface itself internal, the methods would still be part of the public API. What you can elect to do is explicit interface implementation, so that the API defined by the interface is only visible via the interface, and not via the class.

<pre><code>interface IFoo
{
 void M();
}

interface IBar
{
 void X(); 
}

public class Bar : IBar, IFoo
{
 public void X() // part of the public API of Bar
 {
 }

 void IFoo.M() // explicit implementation, only visible via IFoo
 {
 }
}

Bar bar = new Bar();
bar.X(); // visible
bar.M(); // NOT visible, cannot be invoked
IFoo foo = bar;
foo.M(); // visible, can be invoked
</code></pre>

Beyond this, if you need the world to never have any idea that the class supports the interface, then you would simply need to not have the class implement the interface. Interfaces are for the intent of broadcasting that a given object supports given behaviors, explicitly or otherwise. If that's not what you want, you need to go a different direction. It could simply be that the class implements the behaviors as private implementation details, sans interface. Another approach is to shovel those implementations into a private nested class. 

<pre><code>public class Bar : IBar
{
 Foo foo = new Foo();

 public void X() { } 

 public void DoSomething()
 {
 this.foo.M(); // invokes method of instance of nested class
 }

 class Foo : IFoo
 {
 public void M() { } 
 }
}
</code></pre>

Under this approach, the world never knows that a class fulfills the interface contract, because it technically doesn't. The contract is fulfilled by <code>Foo</code>, and the world cannot see <code>Foo</code>. However, the benefit is that if the class needs to invoke externally defined methods that require the interface, it can still pass the nested class instance to those methods.

blocks|key|2924033|text|无法将强制转换操作限制在接口上。但是，您可以提供一个实现接口的包装类，但该类通常是不可用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2924034|例如：|2924035|public+class+Foo
{
++++private+IFoo+wrap+=+new+WrapFoo(this);

++++internal+IFoo+GetIFoo()
++++{
++++++++return+wrap;
++++}

++++private+class+WrapFoo+:+IFoo
++++{
++++++++public+WrapFoo(Foo+parent)
++++++++{
++++++++++++//Save+parent
++++++++}

++++++++public+void+DoSomething()
++++++++{
++++++++++++//Implement+interface
++++++++}
++++}
}|code-block|syntax|javascript|2924036|另一种更复杂的方法是使用代码签名来验证调用者是否是库，否则抛出异常。|2924037|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

There is no way to restrict casting operations to an interface. However you could provide a wrapper class that implements the interface but isn't normally available.

For instance:

<pre><code>public class Foo
{
 private IFoo wrap = new WrapFoo(this);

 internal IFoo GetIFoo()
 {
 return wrap;
 }

 private class WrapFoo : IFoo
 {
 public WrapFoo(Foo parent)
 {
 //Save parent
 }

 public void DoSomething()
 {
 //Implement interface
 }
 }
}
</code></pre>

Another more complicated way would be to use code signing to verify that the caller is the library and throwing an exception otherwise.

Straight to the problem: I have a class that implements two interfaces:

<pre><code>public class A : Interface1, Interface2{
 // Interface 1 implementation...
 // Interface 2 implementation...
}
</code></pre>

Is there a way (without creating another new class) to make Interface1 implementation internal and hide it from other components (only Interface2 will stay public)? 

EDIT: Some more useful infos: <code>Interface1</code> and <code>Interface2</code> are defined as public in another core component and cannot be changed.

Thanks in advance,

Internal Interface implementation

直奔问题:我有一个实现两个接口的类：public class A : Interface1, Interface2{   // Interface 1 implementation...   // Interface 2 implementation...}有没有一种方法(不需要创建另一个新类)使Interface1实...

问内部接口实现
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问内部接口实现EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问内部接口实现
EN