views:

179

answers:

2

How can I use an object initializer with an explicit interface implementation in C#?

public interface IType
{
  string Property1 { get; set; }
}

public class Type1 : IType
{
  string IType.Property1 { get; set; }
}

...

//doesn't work
var v = new Type1 { IType.Property1 = "myString" };
+4  A: 

Explicit interface methods/properties are private (this is why they cannot have an access modifier: it would always be private and so would be redundant*). So you can't assign to them from outside. You might as well ask: how can I assign to private properties/fields from external code?

(* Though why they didn't make the same choice with public static implicit operator is another mystery!)

Daniel Earwicker
Please expand upon description as "private". Explicit methods can be invoked by other objects, which seems at odds with your description?!
Ben Aston
I think I understand that explicitly implemented members are private to the implementing type. AFAICT it is merely a language syntax limitation preventing the convenient setting of explicit members, which is a shame, seeing as I prefer explicit over implicit.
Ben Aston
@Ben Aston - "private" isn't the right word in all respects, e.g. a mere private field can by accessed inside the class whereas an explicit interface member cannot even allow that(directly). It would be more correct to say that explicit interface members are not accessible *at all* via the type they are implemented in (so even more private than `private`!) You can only access them via the interface type itself. Object initializer syntax is effectively just a way of assigning to members, and it would be weird if that could achieve things that ordinary assignments could not.
Daniel Earwicker
+2  A: 

You can't. The only way to access an explicit implementation is through a cast to the interface. ((IType)v).Property1 = "blah";

You could theoretically wrap a proxy around the property, and then use the proxy property in initialization. (The proxy uses the cast to the interface.)

class Program
{
    static void Main()
    {
        Foo foo = new Foo() { ProxyBar = "Blah" };
    }
}

class Foo : IFoo
{
    string IFoo.Bar { get; set; }

    public string ProxyBar
    {
        set { (this as IFoo).Bar = value; }
    }
}

interface IFoo
{
    string Bar { get; set; }
}
Anthony Pegram