Consider the following three interfaces:
interface IBaseInterface
{
event EventHandler SomeEvent;
}
interface IInterface1 : IBaseInterface
{
...
}
interface IInterface2 : IBaseInterface
{
...
}
Now consider the following class that implements both IInterface1 and IInterface 2:
class Foo : IInterface1, IInterface2
{
event EventHandler IInterface1.SomeEvent
{
add { ... }
remove { ... }
}
event EventHandler IInterface2.SomeEvent
{
add { ... }
remove { ... }
}
}
This results in an error because SomeEvent is not part of IInterface1 or IInterface2, it is part of IBaseInterface.
How can the class Foo implement both IInterface1 and IInterface2?
You can use generics:
interface IBaseInterface<T> where T : IBaseInterface<T>
{
event EventHandler SomeEvent;
}
interface IInterface1 : IBaseInterface<IInterface1>
{
...
}
interface IInterface2 : IBaseInterface<IInterface2>
{
...
}
class Foo : IInterface1, IInterface2
{
event EventHandler IBaseInterface<IInterface1>.SomeEvent
{
add { ... }
remove { ... }
}
event EventHandler IBaseInterface<IInterface2>.SomeEvent
{
add { ... }
remove { ... }
}
}
SomeEvent isn't part of IInterface1 or IInterface2, its a part of IBaseInterface.
class Foo : IInterface1, IInterface2
{
event EventHandler IBaseInterface.SomeEvent {
add { ... }
remove { ... }
}
}
interface IBaseInterface
{
event EventHandler SomeEvent;
}
interface IInterface1 : IBaseInterface
{
event EventHandler SomeEvent;
}
interface IInterface2 : IBaseInterface
{
event EventHandler SomeEvent;
}
class Foo : IInterface1, IInterface2
{
public event EventHandler SomeEvent
{
add { }
remove { }
}
event EventHandler IInterface1.SomeEvent
{
add { }
remove { }
}
event EventHandler IInterface2.SomeEvent
{
add { }
remove { }
}
}