C#: Property overriding by specifying the interface explicitly?

This has nothing to do with explicit interface implementation; it's simply a consequence of the general rules of inheritance and interface mapping: you would see exactly the same results if type A provided an implicit, rather than explicit, implementation of IMyInterface.

This has nothing to do with explicit interface implementation; it's simply a consequence of the general rules of inheritance and interface mapping: you would see exactly the same results if type A provided an implicit, rather than explicit, implementation of IMyInterface. Type B inherits from type A. Nothing is overridden.

B provides its own AlwaysFalse and IsTrue members but they don't implement IMyInterface; The implementation of IMyInterface is provided by the members inherited from A: when an instance of type B is cast to IMyInterface then it behaves in exactly the same way as an instance of type A because A is providing the members that implement the interface. Type C inherits from type A. Again, nothing is overridden.

C provides its own AlwaysFalse and IsTrue members but this time those members do implement IMyInterface: when an instance of type C is cast to IMyInterface then the members of C provide the interface implementation rather than those of A. Because type A implements IMyInterface explicitly the compiler doesn't warn that the members of B and C are hiding the members of A; In effect those members of A were already hidden due to the explicit interface implementation. If you changed type A to implement IMyInterface implicitly rather than explicitly then the compiler would warn that the members of B and C are hiding, not overriding, the members of A and that you should ideally use the new modifier when declaring those members in B and C.

Here are some relevant bits from the language specification. (Sections 20.4.2 and 20.4.4 in the ECMA-334 spec; sections 13.4.4 and 13.4.6 in the Microsoft C#4 spec. ) 20.4.2 Interface mapping The implementation of a particular interface member I.

M, where I is the interface in which the member M is declared, is determined by examining each class or struct S, starting with C and repeating for each successive base class of C, until a match is located. 20.4.4 Interface re-implementation A class that inherits an interface implementation is permitted to re-implement the interface by including it in the base class list. A re-implementation of an interface follows exactly the same interface mapping rules as an initial implementation of an interface.

Thus, the inherited interface mapping has no effect whatsoever on the interface mapping established for the re-implementation of the interface.

– Virtlink Sep 14 '10 at 9:06 It's precisely because you're not overriding that you're seeing this behaviour: For example, type B provides a new implementation of IsTrue that does not override the IsTrue method from type A. Type B only inherits its implementation of IMyInterface from A.It's the A. IsTrue method that implements IMyInterface so when you cast an instance of B to IMyInterface it's the A.

IsTrue method that's used.... – LukeH Sep 14 '10 at 9:15 Type C also provides a a new implementation of IsTrue that does not override the IsTrue method from type A. But type C implements IMyInterface directly. When you cast an instance of C to IMyInterface it's the C.

IsTrue method that's used, in accordance with the rules from the language specification. – LukeH Sep 14 '10 at 9:17 I agree that it's somewhat counter-intuitive, but it's just a consequence of the rules of the language! If the A.

Test method returned ((C)this). AlwaysFalse then you'd rightly expect it to start looking in C for a matching member, followed by its ancestors from newest to oldest (assuming that this is actually a C). Similarly when A.

Test returns ((IMyInterface)this). AlwaysFalse then it looks for the "newest" member that implements IMyInterface. AlwaysFalse (and that's the one provided by C, again assuming that this is actually a C).

– LukeH Sep 14 '10 at 10:39 Of course I see the logic of hiding, and casting to the interface calling the new member. But in this situation specifically, it is strange that there can be two (or more) implementations of the same interface in a class. I think it is a language error to allow implementing the same interface more than once on a class, which leads to this kind of situations.

– Virtlink Sep 14 '10 at 10:39.

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.