What hack can I use to define a C# property with same name as class?

Question

I'm using C# to make a .Net class library (a DLL) that will be distributed widely. I have an abstract class called Value, and I want it to have an abstract double property that is also called Value i.e.

public abstract class Value {

    // Only accessible by subclasses within the project.
    internal Value() {}

    public abstract double Value {
        get;
    }

}

But the C# compiler won't allow this - I get the message "member names cannot be the same as their enclosing type", as discussed here.

I understand that the easiest thing to do would be to change the name of the property or the name of the class... But really I want the names to be like that, and I'm quite happy to implement an ugly hack to get it that way. So long as it works properly from external code that uses this DLL.

Unlike C#, VB.Net will allow me to define a property with the same name as the class, so I'm currently investigating merging my C# project with a VB project that defines the Value class (and its Value property) to make one DLL. This doesn't seem to be quite as straightforward as I was hoping.

Another option would be to re-write the whole project in VB... Not very appealing, but I'll consider it if necessary. I prefer C# over VB.Net but my priority is to get the built DLL the way I want it.

I'm wondering what other alternatives there might be. Any ideas for a good way to hack this?

EDIT: From the comments below it's clear that quite a number of people don't think much of the name "Value" for a class... Could anyone explain why it's so bad? I know it's not very descriptive, but I think it fits well in the context of my project. Is it because it's a keyword in C# that's used in property setters?

Answer 1

You cannot do that directly. You could, however, consider:

• impelenting an interface with a Value member, and using explicit interface implementation (callers would have the use the interface, though)
• renaming it in the class, and using an extension method to expose a Value() method, so obj.Value() works
• rename it in the class, but expose it as Value in the subclasses

Ugly hack:

public abstract class ValueBase {
    public abstract double Value { get; }
    internal ValueBase() {}
}
public abstract class Value : ValueBase {
    internal Value() {}
}
public sealed class ValueReal : Value {
    public override double Value { get { return 123; } }
}

Answer 2

If your class is representative of a double (except for some additional metadata), you could opt for a conversion operator:

public abstract class Value
{
    protected abstract double GetValue();

    public static explicit operator double (Value value)
    {
        return value.GetValue();
    }
}

Then your client code could access the metadata or cast an instance of type Value to a double. Depending on the metadata and usage, you might make the conversion implicit so you don't have to do an explicit cast, and you might define a conversion from double to Value.

There is a similar approach used by the System.Xml.Linq assembly where, for example, XElement can be cast to any primitive type as a means of accessing its "value".