在C＃中直接引用时，如何让类使用默认的getter / setter？

Question

Let's say I have a class like

class SecretInt
{
    private int secret = 1;
}

How can I make it so that.

SecretInt a = new SecretInt();
SecretInt b = new SecretInt();
Console.Write(a + b);

Would output 2?

Is there something like

Class SecretInt()
{
    int secret = 1;
    get { return secret; }
    set { secret = value; }
}

So that direct references to the class would use the getters and setters rather than the class itself?

Answer 1

You can do this in two step.

1. Overload the + operator for your class

    public static SecretInt operator +(SecretInt s1, SecretInt s2) { var s = new SecretInt(); s.secret = s1.secret + s2.secret; return s; } 

2. Then override ToString method:

    public override string ToString() { return this.secret.ToString(); } 

Take a look at Operator Overloading Tutorial for more details.

Answer 2

Overload the + operator so sums extract the real value

http://msdn.microsoft.com/en-us/library/aa288467(v=vs.71).aspx

Answer 3

Unfortunately C# does not implement the concept of Default Properties that we see in VB.NET or similar. The solutions generally given for this are to use conversion operators to create new instances of the class... but you lose the rest of the properties and state.

For instance, this VB.NET class:

public class MyClass
    Public myNumber As Integer
    Private myString As String
    Default Property myProperty As String
        Get
            return myString
        End Get
        Set(ByVal Value As String)
            myString = Value
        End Set
    End Property
End Class

In VB you can then do:

Dim i As New MyClass
i.myInteger = 10
i = "Hello"

The VB.NET compiler locates the default property and uses that as the target of the assignment.

Now consider the same code in C#, operating on the same class:

var i = new MyClass();
i.myInteger = 10;
i = "Hello";

Since C# doesn't know about the default property, this fails to compile. Using the standard conversion technique we can define a conversion operator that looks like this:

public static implicit operator MyClass(string value)
{
    return new MyClass { myProperty = value };
}

Now we can do i = "Hello"; and the myProperty value will of course be set... but the myInteger field will now be reinitialised to default.

The sad thing is that We can decorate a C# class with DefaultPropertyAttribute to tell VB.NET which property it should use as the default when working with our class, but we can't use that information in C# without some reflection techniques.

The other answers here give workarounds to solve the specific case you listed, but there is no solution to give the same Default Property functionality that the VB.NET language has. Unless you want to start hacking on Roslyn and create your own version of C# :P