How does using interfaces overcome the problem of multiple inheritance in C#?

One class may implement any number of interfaces, even if those interfaces extend other interfaces as well. Multiple inheritance is not possible only with classes This is not allowed class A { void A() {} } class B { void B() {} } class C : A, B {} // This is allowed interface IA { void A(); } interface IB { void B(); } class A : IA, IB { void A() {} void B() {} } The diamond problem exists with classes because there is a possibility of clashing implementations (if A and B have the same method and C extends both, which method does it take? ).

Interfaces, on the other hand, simply require an implementing type to have the methods that they declare If the exact same method is defined in two interfaces, and a class implements both interfaces, that doesn't matter. All the class needs to do is provide an implementation for the method so that code can be written to call that method. Meaning, this works: interface IA { void Method(int x); } interface IB { void Method(int x); } class A : IA, IB { void Method(int x) { Console.

WriteLine(x); } } Note that a class may still inherit from one other class plus any number of interfaces: class A : B, IA, IB {}.

One class may implement any number of interfaces, even if those interfaces extend other interfaces as well. Multiple inheritance is not possible only with classes. // This is not allowed class A { void A() {} } class B { void B() {} } class C : A, B {} // This is allowed interface IA { void A(); } interface IB { void B(); } class A : IA, IB { void A() {} void B() {} } The diamond problem exists with classes because there is a possibility of clashing implementations (if A and B have the same method and C extends both, which method does it take?).

Interfaces, on the other hand, simply require an implementing type to have the methods that they declare. If the exact same method is defined in two interfaces, and a class implements both interfaces, that doesn't matter. All the class needs to do is provide an implementation for the method so that code can be written to call that method.

Meaning, this works: interface IA { void Method(int x); } interface IB { void Method(int x); } class A : IA, IB { void Method(int x) { Console. WriteLine(x); } } Note that a class may still inherit from one other class, plus any number of interfaces: class A : B, IA, IB {}.

– tbridge Mar 2 at 7:31 @tbridge: It was just a wild guess. – BoltClock? Mar 2 at 7:32 bahaha!

+1 for probably being right – tbridge Mar 2 at 7:36 A downvote! How adorable. I'll keep it!

– BoltClock? Mar 2 at 9:18 The downvote wasn't from me, but I can understand it. Your answer doesn't really touch on the diamond problem, which has nothing to do with methods whose names coincidentally match.

It would be better to show two interfaces which implement a common IBase, and a class which implements both interfaces. The reason the diamond problem doesn't exist with interfaces is that if e.g. A class MyThing implements IList and ICollection, both of which inherit IEnumerable, the class only implements IEnumerable once. Whether it's cast directly to IEnumerable... – supercat Mar 27 at 16:00.

The "diamond problem" is not present when just using interfaces because there is no ambiguous implementation possible. Read the Wikipedia article, which contains a full explanation.

You can inherite only one class and unlimited number of interfaces at one time.

I think it is not fair to think about this in scope of C# only. CLR itself does not support multiple inheritance. May be because they wanted to support other languages that do not support it currently or cannot support it in future.

Though that may be the case and something worth keeping in mind, I don't think it answers the question. I would have posted this as a comment, instead. – Cody Gray Mar 2 at 7:42 @Cody Gray: He wants to know why C# does not support it.

And this is my answer for that. – decyclone Mar 2 at 7:44.

Multiple interfaces will not create the diamond problem because each class must provide their own unique implementation, which means there is no sharing of resources. C# does not allow multiple inheritance because they care about you, and made the language as shoot-yourself-in-the-foot-proof as possible.

Because they care about you' implies that other languages 'do not care' which is non sense :) – anthares Mar 2 at 7:51 @anthares: I think the nonsensical part is implying that languages care... – Cody Gray Mar 2 at 7:53.

If you ask about inheritance: class can inherit only one class, but can implement any number of interfaces. See this article about inheritance and polymorphism in C#.

This is a possible way to try to achieve something that you usually can achieve with multiple inheritance. Interface IA { void DoAnything(string name); } class A : IA { public void DoSomething() { // some code } public void DoAnything(string name) { // Some code } } class B : IA { public void DoNothing() { // Some code } public void DoAnything(string name) { // Some code } } class StorageCache : IA { private A ObjA; private B ObjB; public void DoAnything(string name) { ObjA. DoAnything(name); ObjB.

DoAnything(name); } public void DoNothing() { ObjB.DoNothing(); } public void DoSomething() { ObjA.DoSomething(); } }.

I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.