C# inheritance interface liskov-substitution-principle

C# 接口实现关系只是“Can-Do”关系关系？

发布于 2024-07-08 22:15:59 字数 341 浏览 8 评论 0原文

今天有人告诉我，C# 中的接口实现只是“Can-Do”关系，而不是“Is-A”关系。这与我长期以来所相信的LSP（里氏替换原理）相冲突。我一直认为所有的继承都应该意味着“Is-A”关系。

所以，如果接口实现只是一种“Can-Do”关系。如果有一个接口“IHuman”和“IEngineer”，并且一个类“Programmer”继承自“IHuman”和“IEngineer”怎么办？ “我工程师”？当然，“程序员”是“IHuman”和“IEngineer”。

如果这只是“Can-Do”关系，是否意味着我们不能期望“程序员”实例行为在被视为 IHuman 和被视为 IEngineer 时可能有所不同？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

浪荡不羁 2024-07-15 22:16:00

很晚才发现这个问题，但我想插话。C

# 中的接口有 is-a 关系，但不是 is-an-object 关系。相反，是一种实现。

换句话说，对于实现 IBar 的类 Foo，以下测试：

Foo myFoo = new Foo(); 
return myFoo is IBar;

字面上返回 true。你也可以说，

IBar bar = myArrayList[3] as IBar;
Foo foo = bar as Foo;

或者，如果一个方法需要 IBar，你可以传递 Foo。

void DoSomething(IBar bar) {
}

static void Main() {
    Foo myFoo = new Foo();
    DoSomething(myFoo);
}

显然，IBar 本身没有实现，因此 can-do 关系也适用。

interface IBar { void happy(); }
class Foo : IBar
{
    void happy()
    {
        Console.Write("OH MAN I AM SO HAPPY!");
    }
}
class Program
{
    static void Main()
    {
        IBar myBar = new Foo();
        myBar.happy();
    }
}

但是，就此而言，对象继承也是如此。继承类 Bar 的类 Foo 的对象具有 can-do 关系以及 is-a 关系，与接口的方式相同。只是它的实现是为其预先构建的。

真正的问题是，is-a-what，can-do-what？继承的类对象是-[父实例]并且可以-[父的行为]，而接口的实现是-[接口实现]，因此可以-[接口行为]。

在大多数使用编程 is-a 关系（例如上面列出的关系）的情况下，仅评估接口，因此继承的类和实现的接口都共享相同的 is-a 和 can-do 品质。

哈特哈，
乔恩

Found this question rather late but I wanted to chime in.

Interfaces in C# have an is-a relationship, but not is-an-object. Rather, is-an-implementation.

In other words, for class Foo that implements IBar, the following test:

Foo myFoo = new Foo(); 
return myFoo is IBar;

literally returns true. You can also say,

IBar bar = myArrayList[3] as IBar;
Foo foo = bar as Foo;

Or, if a method requires an IBar, you can pass a Foo.

void DoSomething(IBar bar) {
}

static void Main() {
    Foo myFoo = new Foo();
    DoSomething(myFoo);
}

Obviously, an IBar has no implementation in itself, so the can-do relationship also applies.

interface IBar { void happy(); }
class Foo : IBar
{
    void happy()
    {
        Console.Write("OH MAN I AM SO HAPPY!");
    }
}
class Program
{
    static void Main()
    {
        IBar myBar = new Foo();
        myBar.happy();
    }
}

But, for that matter, the same is true of object inheritance; an object of class Foo that inherits class Bar has a can-do relationship as well as an is-a relationship, in the same way as the interface does. It's just that its implementation was pre-built for it.

The real question is, is-a-what, can-do-what? An inherited class object is-a-[parent instance] and can-do-[parent's behavior], whereas an implementation of an interface is-an-[interface implementation] and therefore can-do-[the interface behavior].

In most cases where programmatic is-a relationships are used such as those listed above, only the interface is evaluated, so both an inherited class and an implemented interface share the same is-a and can-do qualities.

HTH,
Jon

回复收藏 0 原文