www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Properties in C# and prop_Foo

reply Bill Baxter <wbaxter gmail.com> writes:
Interesting thing I found out about C# properties.
The syntax

int Thing {
   get { return _thing; }
   set { _thing = value; }
}

is rewritten by the C# compiler into

int prop_Thing() { return _thing; }
void prop_Thing(int value) { _thing = value; }

Just thought it was interesting given all our discussions,
particularly that the syntax C# translates into is exactly what Andrei
was proposing we use for D's syntax.  And I think I even said that was
fine, but let's have a different syntax for declaring that the D
compiler translates into those prop_Thing methods.  Well, it turns out
that's exactly what C# does.

--bb
Aug 08 2009
parent reply grauzone <none example.net> writes:
Bill Baxter wrote:
 Interesting thing I found out about C# properties.
 The syntax
 
 int Thing {
    get { return _thing; }
    set { _thing = value; }
 }
 
 is rewritten by the C# compiler into
 
 int prop_Thing() { return _thing; }
 void prop_Thing(int value) { _thing = value; }
 
 Just thought it was interesting given all our discussions,
 particularly that the syntax C# translates into is exactly what Andrei
 was proposing we use for D's syntax.  And I think I even said that was
 fine, but let's have a different syntax for declaring that the D
 compiler translates into those prop_Thing methods.  Well, it turns out
 that's exactly what C# does.
C# doesn't allow you to directly call the accessors (which are named set_Thing and get_Thing, btw.). It also creates and associates metadata with the property (so that you know that "Thing" is supposed to be a property with these setters and getters). In C# (as in the language) properties still work as cast into concrete; it's just that on the lowest level, it is mapped to normal methods + extra metadata. That's probably not quite what was proposed.
 --bb
Aug 09 2009
parent reply Bill Baxter <wbaxter gmail.com> writes:
On Sun, Aug 9, 2009 at 11:25 AM, grauzone<none example.net> wrote:
 Bill Baxter wrote:
 Interesting thing I found out about C# properties.
 The syntax

 int Thing {
 =A0 get { return _thing; }
 =A0 set { _thing =3D value; }
 }

 is rewritten by the C# compiler into

 int prop_Thing() { return _thing; }
 void prop_Thing(int value) { _thing =3D value; }

 Just thought it was interesting given all our discussions,
 particularly that the syntax C# translates into is exactly what Andrei
 was proposing we use for D's syntax. =A0And I think I even said that was
 fine, but let's have a different syntax for declaring that the D
 compiler translates into those prop_Thing methods. =A0Well, it turns out
 that's exactly what C# does.
C# doesn't allow you to directly call the accessors (which are named set_Thing and get_Thing, btw.). It also creates and associates metadata w=
ith
 the property (so that you know that "Thing" is supposed to be a property
 with these setters and getters).

 In C# (as in the language) properties still work as cast into concrete; i=
t's
 just that on the lowest level, it is mapped to normal methods + extra
 metadata.
I see. I thought you could call get_Thing, set_Thing directly. --bb
Aug 09 2009
parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Sun, 09 Aug 2009 15:53:23 -0400, Bill Baxter <wbaxter gmail.com> wrote:

 On Sun, Aug 9, 2009 at 11:25 AM, grauzone<none example.net> wrote:
 Bill Baxter wrote:
 Interesting thing I found out about C# properties.
 The syntax

 int Thing {
   get { return _thing; }
   set { _thing = value; }
 }

 is rewritten by the C# compiler into

 int prop_Thing() { return _thing; }
 void prop_Thing(int value) { _thing = value; }

 Just thought it was interesting given all our discussions,
 particularly that the syntax C# translates into is exactly what Andrei
 was proposing we use for D's syntax.  And I think I even said that was
 fine, but let's have a different syntax for declaring that the D
 compiler translates into those prop_Thing methods.  Well, it turns out
 that's exactly what C# does.
C# doesn't allow you to directly call the accessors (which are named set_Thing and get_Thing, btw.). It also creates and associates metadata with the property (so that you know that "Thing" is supposed to be a property with these setters and getters). In C# (as in the language) properties still work as cast into concrete; it's just that on the lowest level, it is mapped to normal methods + extra metadata.
I see. I thought you could call get_Thing, set_Thing directly.
It used to be in C++.NET (at least the .NET 1.0 version) you HAD to call/define properties that way ;) I think they've since added syntax to C++.Net to have more friendly property access. I'm not sure if you can still call the get_/set_ versions, but knowing Microsoft's propensity for backwards compatibility, you probably can... I too thought you could call the get_Thing and set_Thing directly from C#, though I've never found a need to. One possible reason is to pass it as a delegate. -Steve
Aug 10 2009