explicit-interface

I stumbled on a feature of C# method resolution that I didn't notice before. Namely, when I explicitly implement an interface that supports a setter, and the implicit interface only offers a protected set, the compiler sensibly defers to the protected set when I call it. So I get most of the convenience of auto-implemented properties, but I can prevent accidental modification of fields by clients who shouldn't be changing them. As an example, virtual public DateTime CreatedOn { get; protected set; } virtual public DateTime? ModifiedOn { get; protected set; } #region IHaveUpdateDateFields

interface IBar { void Hidden(); } class Foo : IBar { public void Visible() { /*...*/ } void IBar.Hidden() { /*...*/ } } class Program { static T CallHidden1<T>(T foo) where T : Foo { foo.Visible(); ((IBar)foo).Hidden(); //Cast required return foo; } static T CallHidden2<T>(T foo) where T : Foo, IBar { foo.Visible(); foo.Hidden(); //OK return foo; } } Is there any difference (CallHidden1 vs. CallHidden2) is actual compiled code? Is there other differences between where T : Foo and where T : Foo, IBar (if Foo implements IBar) that in accessing explicitly implemented interface members ? The IL

Although there are quite a lot of Q&As regarding IDisposable to be found on SO, I haven't found an answer to this yet: I usually follow the practice that when one of my classes owns an IDisposable object then it also implements IDisposable and calls Dispose on the owned object. However recently I came across a class which implemented IDisposable explicitly thus preventing me from directly calling Dispose forcing me to cast it which I found annoying and unnecessary. So the question: Why and when would one want to use an explicit interface implementation of IDisposable ? I know that there are

For the record, I've already seen this connect item but I can't really understand what would be the problem in supporting this. Say I have the following code: public interface IInterface { void Method(); } public class Base : IInterface { virtual void IInterface.Method() { throw new NotImplementedException(); } } what is the problem with the virtual identifier? Having a virtual modifier would make it possible to override indicating there's a different implementation in the base class. I can make it work now by removing the virtual method and creating the derived class like this: public class

More specifically, if I have: public class TempClass : TempInterface { int TempInterface.TempProperty { get; set; } int TempInterface.TempProperty2 { get; set; } public int TempProperty { get; set; } } public interface TempInterface { int TempProperty { get; set; } int TempProperty2 { get; set; } } How do I use reflection to get all the propertyInfos for properties explicitly implementing TempInterface? Thanks. I think the class you are looking for is System.Reflection.InterfaceMapping. Type ifaceType = typeof(TempInterface); Type tempType = typeof(TempClass); InterfaceMapping map = tempType