blocks|key|2034073|text|基本上就是用接口而不是具体的类(或者更糟的是静态方法)来表达你的依赖关系。因此，如果您的某个类需要执行身份验证，那么应该为它提供一个IAuthenticator+(或其他任何东西)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2034074|这意味着：|2034075|2034076|您可以在实现真正的依赖项之前编写代码|unordered-list-item|2034077|您可以非常容易地通过模拟进行测试(不必模拟类，这会变得很丑陋)|2034078|很清楚您依赖的是什么，而不是实现(即，您有更松散的耦合)|2034079|2034080|entityMap^0|1U|E|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|X|8|@]|D|@]|E|$]]|$1|L|3|M|5|K|7|Y|8|@]|D|@]|E|$]]|$1|N|3|O|5|K|7|Z|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

It's basically a matter of expressing your dependencies in terms of interfaces instead of concrete classes (or worse, static methods). So if one of your classes needs to perform authentication, it should be provided an <code>IAuthenticator</code> (or whatever).

This means that:

<ul>
<li>You can write your code before implementing the real dependency</li>
<li>You can test via mocking really easily (without having to mock classes, which gets ugly)</li>
<li>It's clear what you depend on in terms of the API instead of implementation (i.e. you have looser coupling)</li>
</ul>

blocks|key|579362|text|"Practical+API+Design"+by+Jaroslav+Tulach的第6章的标题是“针对接口的代码，而不是实现”。它解释说，通过针对接口而不是特定的实现进行编码，您可以解耦系统中的模块(或组件)，从而提高系统质量。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|579363|Bertrand+Meyer在OOSC2中清楚地解释了为什么“关闭”系统并使其更加模块化可以提高其质量。|579364|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/1430209739|1|https://rads.stackoverflow.com/amzn/click/com/0136291554^0|0|15|0|0|F|5|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

Chapter 6 of <a href="https://rads.stackoverflow.com/amzn/click/com/1430209739" rel="noreferrer" rel="nofollow noreferrer">"Practical API Design" by Jaroslav Tulach</a> is titled "Code Against Interfaces, Not Implementations". It explains that, by coding against an interface rather than a specific implementation, you can decouple modules (or components) in a system and therefore raise the system quality.

Bertrand Meyer in <a href="https://rads.stackoverflow.com/amzn/click/com/0136291554" rel="noreferrer" rel="nofollow noreferrer">OOSC2</a> explains clearly why "closing" a system and making it more modular raises its quality.

blocks|key|1882157|text|看看这些非常受欢迎的讨论是否有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1882158|What+is+the+best+analogy+to+help+non-oop+developers+grok+interface+based+programming?|offset|length|1882159|Why+would+I+want+to+use+Interfaces?|1882160|When+are+interfaces+needed?|1882161|When+should+one+use+interfaces?|1882162|What+is+the+purpose+of+interfaces?|1882163|Good+Case+For+Interfaces|1882164|What+does+it+mean+to+“program+to+an+interface”?|1882165|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/429068/what-is-the-best-analogy-to-help-non-oop-developers-grok-interface-based-programm|1|https://stackoverflow.com/questions/240152/why-would-i-want-to-use-interfaces|2|https://stackoverflow.com/questions/570302/when-are-interfaces-needed|3|https://stackoverflow.com/questions/1686174/when-should-one-use-interfaces|4|https://stackoverflow.com/questions/667139/what-is-the-purpose-of-interfaces-closed|5|https://stackoverflow.com/questions/1335586/good-case-for-interfaces|6|https://stackoverflow.com/questions/383947/what-does-it-mean-to-program-to-an-interface^0|0|0|2D|0|0|0|Z|1|0|0|R|2|0|0|V|3|0|0|Y|4|0|0|O|5|0|0|1B|6|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|F|3|G|5|6|7|1G|8|@]|9|@$D|1H|E|1I|1|1J]]|A|$]]|$1|H|3|I|5|6|7|1K|8|@]|9|@$D|1L|E|1M|1|1N]]|A|$]]|$1|J|3|K|5|6|7|1O|8|@]|9|@$D|1P|E|1Q|1|1R]]|A|$]]|$1|L|3|M|5|6|7|1S|8|@]|9|@$D|1T|E|1U|1|1V]]|A|$]]|$1|N|3|O|5|6|7|1W|8|@]|9|@$D|1X|E|1Y|1|1Z]]|A|$]]|$1|P|3|Q|5|6|7|20|8|@]|9|@$D|21|E|22|1|23]]|A|$]]|$1|R|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]|Z|$5|U|V|W|A|$X|10]]|11|$5|U|V|W|A|$X|12]]|13|$5|U|V|W|A|$X|14]]|15|$5|U|V|W|A|$X|16]]|17|$5|U|V|W|A|$X|18]]|19|$5|U|V|W|A|$X|1A]]]]

See if these very popular discussions help:

<a href="https://stackoverflow.com/questions/429068/what-is-the-best-analogy-to-help-non-oop-developers-grok-interface-based-programm">What is the best analogy to help non-oop developers grok interface based programming?</a>

<a href="https://stackoverflow.com/questions/240152/why-would-i-want-to-use-interfaces">Why would I want to use Interfaces?</a>

<a href="https://stackoverflow.com/questions/570302/when-are-interfaces-needed">When are interfaces needed?</a>

<a href="https://stackoverflow.com/questions/1686174/when-should-one-use-interfaces">When should one use interfaces?</a>

<a href="https://stackoverflow.com/questions/667139/what-is-the-purpose-of-interfaces-closed">What is the purpose of interfaces?</a>

<a href="https://stackoverflow.com/questions/1335586/good-case-for-interfaces">Good Case For Interfaces</a>

<a href="https://stackoverflow.com/questions/383947/what-does-it-mean-to-program-to-an-interface">What does it mean to “program to an interface”?</a>

blocks|key|625999|text|您所说的“基于接口的编程”通常指的是对接口的编程。下面是一个例子。好处是隐藏了接口的实际实现，并允许您的代码在未来更加灵活和易于维护。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|626000|YourInterface+foo+=+CreateYourInterface();
foo.DoWork();
foo.DoMoreWork();|code-block|syntax|javascript|626001|CreateYourInterface()将返回YourInterface的具体实现。这允许您通过更改一行来更改应用程序的功能：|626002|YourInterface+foo+=+CreateYourInterface();|626003|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

What you refer to as "interface based programming" is more commonly referred to as programming to an interface. Here is an example below. The benefit is hiding the actual implementation of the interface and allowing your code to be more flexible and easily maintained in the future.

<pre><code>YourInterface foo = CreateYourInterface();
foo.DoWork();
foo.DoMoreWork();
</code></pre>

CreateYourInterface() would return a concrete implementation of YourInterface. This allows you to change the functionality of the application by changing one line:

<pre><code>YourInterface foo = CreateYourInterface();
</code></pre>

blocks|key|1879766|text|如果你在谷歌上搜索界面，你会发现大量关于界面有多有用的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1879767|其概念是定义清晰的接口，这些接口将被各种组件/部件/类/模块用来通信和交互。一旦您定义了这些接口的输入/输出应该是什么，您就可以让不同的团队开发满足接口要求所需的任何东西，包括输入/输出测试，...等|1879768|如果您遵循此模式，各个团队可以开始开发自己的部分，而无需等待其他部分准备就绪。除此之外，您还可以使用单元测试(使用伪对象来模拟您未开发的其他部分，并测试您的部分)。|1879769|这种方法是任何新的编程项目的标准，每个人都会认为这是理所当然的。|1879770|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If you google for interfaces, you will find plenty of information about how useful interfaces may be.

The concept is to define clear interfaces, which will be used by the various components/parts/classes/modules to communicate and interact. Once you have defined what should be the input/output of these interfaces, you can let the various teams to develop whatever is needed to fulfill the interface requirements, including the input/output testing, ... etc

If you follow this pattern, various teams can start developing their part without waiting for the other parts to be ready. In addition to that you can use Unit testing (using fake objects to simulate the other parts which you are not developing, and test your part).

This method is quite the standard for any new programming project and everybody will take this for granted.

blocks|key|579411|text|这是我不推荐在C#开发中大量使用的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|579412|Interface-based+programming基本上是对接口进行编程。您开发了要使用契约的接口，而这些接口的实际实现隐藏在这些契约的后面。|offset|length|579413|在.NET出现之前，这是非常普遍的，因为在Windows中获得可重用组件的最好方法是通过COM，它通过接口在任何地方工作。然而，由于.NET能够通过一个运行库(+CLR)支持多种语言，而且与本机代码相比，它对版本控制的支持更强，因此在使用C#编程时，基于接口的编程的有用性就会大大降低(除非您正在尝试制作COM组件，在这种情况下，您仍然需要从C#类间接创建COM接口)。|579414|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Interface_based_programming^0|0|0|R|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

This is something that I don't recommend using heavily in C# development.

<a href="http://en.wikipedia.org/wiki/Interface_based_programming" rel="nofollow noreferrer">Interface-based programming</a> is basically programming to interfaces. You develop the interfaces you're going to use an Contracts, and the actual implementation of the interfaces is hidden behind these contracts.

It was very common prior to .NET, as the best way to get reusable components in Windows was via COM, which worked via interfaces everywhere. However, given .NET's ability to support multiple languages with a single runtime (the CLR), as well as it's superior support for versioning when compared with native code, the usefulness of interface based programming is lessened dramatically when you're programming in C# (unless you're trying to make COM components, in which case, you'll still be creating the COM interfaces indirectly from your C# classes).

blocks|key|579135|text|基于接口的编程可以被认为是将功能的实现与访问功能的方式解耦。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|579136|定义一个接口|579137|interface+ICallSomeone+{+++++public+bool+DialNumber(string+number);+}|offset|length|style|CODE|579138|然后你编写你的实现|579139|public+class+callsomeone:+ICallSomeone+{|579140|public+bool+DialNumber(string+number)+{|579141|//dial+number,+return+results+}}|579142|您使用接口而不关心实现。如果你改变了实现，那就没什么关系了，因为它只使用接口。|579143|entityMap^0|0|0|0|1X|0|0|0|14|0|0|13|0|0|T|U|2|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@$F|Y|G|Z|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@$F|12|G|13|H|I]]|9|@]|A|$]]|$1|N|3|O|5|6|7|14|8|@$F|15|G|16|H|I]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|17|8|@$F|18|G|19|H|I]|$F|1A|G|1B|H|I]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|U|$]]

Interface based programming can be thought of as decoupling the implementation of functionality and how you access the functionality.

You define an interface 
<code>interface ICallSomeone { 
 public bool DialNumber(string number);
}</code>

and you write your implementation 

<code>public class callsomeone: ICallSomeone {</code> 
<code>public bool DialNumber(string number) {</code> 
<code>//dial number, return results</code>
<code>}}</code>

You use the interface without caring about the implementation. If you change the implementation, nothing cares because it just uses the interface.

blocks|key|2034337|text|从非常抽象的角度来看，基于接口的编程类似于管道工使用的组件(管道接头和管道)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2034338|只要管道和接头是根据指定的界面(螺纹数量和间距等)制造的，各种制造商就可以为可能由其他供应商制造的管道提供接头(但要遵守前述接头/管道界面)。|2034339|因此，组件的互操作性更强，水管工可以从不同的供应商、价格范围等中自由选择，以创建功能齐全的管道系统。|2034340|用软件组件替换管道和接头，这些相似之处令人惊讶地简单。|2034341|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

From a very abstract view, interface based programming is akin to the components used by a plumber (pipe joints and pipes).

As long as the pipes and the joints are manufactured according to the interface specified (the number of threads and the spacing, etc) various manufactures can provide joints to pipes that were potentially manufactured by some other vendor (but adhering to the aforementioned joint/pipe interface). 

Thus, there is more interoperability of components and freedom for the plumber to choose from various vendors, price ranges etc in order to create a functional plumbing system.

Replace the pipes and joints with software components and the parallels are astonishingly simple.

I often hear/read about interfaced based programming but I am not exactly clear on what that really means. Is interfaced based programming an actual stand alone topic that actually has books written about it? If so, can anyone recommend any good ones?

I came across interface based programming as I was reading about how good APIs are designed and would like to learn more about it. Right now I am not clear how to properly go about designing an API around interfaces.

Any info is greatly appreciated.

What exactly is "interface based programming"?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我经常听到/读到关于基于接口的编程，但我不是很清楚那到底是什么意思。基于接口的编程是一个实际的独立主题吗，实际上已经有关于它的书籍了？如果是这样的话，有谁能推荐一些好的吗？当我读到如何设计好的API时，我偶然发现了基于接口的编程，我想了解更多关于它的知识。现在，我不清楚如何正确地围绕接口来设计API。任何信息都是非常感谢的。

问什么是“基于接口的编程”？
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是“基于接口的编程”？EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是“基于接口的编程”？
EN