Method implementation of interfaces

Let's say, both interfaces prescribe the same method signature. Overloading won't help you, since there is no difference in name and parameters. Than you can use the fully qualified interface member names. Here are some good samples: http://stackoverflow.com/questions/7080861/c-sharp-interface-method-ambiguity[^]
It is up to you if you want to implement all in different ways, or one of them - and that will satisfy all interfacs. But in the first case, you will need to qualify the method on call.

This is absolutely possible. You need to use explicit interface implementation:

interface IFirst { void SomeMethod(); }
interface ISecond { void SomeMethod(); }

class Implementation : IFirst, ISecond {
    void IFirst.SomeMethod() { /* one implementation */ }
    void ISecond.SomeMethod() { /* another implementation */ }
} //class Implementation

Generally, in many cases I recommend to prefer explicit implementation over implicit one (based on a public method of the same name). The case of method name clash to be resolved demonstrates just one of those benefits.

Practically, this case is not so important. But there is another case where you could have clearly unambiguous syntax which is impossible to express without interfaces — two different indexed property. How to achieve the syntax below?

MyClass myInstance = //...
myInstance[3] = "first case";
myInstance["key"] = "second case";

How? Here is the solution:

interface IAuxIndexer { string this[int index] { get; set; } }
class MyClass {
    string IAuxIndexer.this[int index] { get { /*...*/ } set { /*...*/ } }
    public string this[string index] { get { /*...*/ } set { /*...*/ } }
}

This way, to have three different indexed property in one class, you need two interfaces, etc.

—SA

Your implementing class will have one method and this will satisfy the requirements of both interfaces. It doesn't matter what type of reference variable it calls, the same method will always be executed.

Check this.
http://stackoverflow.com/questions/4638218/class-implementing-two-interfaces-which-define-the-same-method[^]

.NET does not support multiple inheritances directly because in .NET, a class cannot inherit from more than one class. .NET supports multiple inheritances through interfaces
for more...

Spam removed.