471,338 Members | 1,036 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,338 software developers and data experts.

Automatic Properties Backing Field Naming Conventions?

Hello there,

does anyone know the precise naming conventions used for internal
backing fields for automatic properties? Something official besides
looking at the compiled assemblies that might let you 'assume' a
certain schema...

Cheers and thanks,
-jB
Aug 11 '08 #1
4 3673
Joerg Battermann <jb@joergbattermann.comwrote:
does anyone know the precise naming conventions used for internal
backing fields for automatic properties? Something official besides
looking at the compiled assemblies that might let you 'assume' a
certain schema...
I wouldn't make any assumptions. If you need direct access to the
fields, don't use automatic properties. The naming scheme is compiler-
dependent and unspecified; it could change between compiler versions.

--
Jon Skeet - <sk***@pobox.com>
Web site: http://www.pobox.com/~skeet
Blog: http://www.msmvps.com/jon.skeet
C# in Depth: http://csharpindepth.com
Aug 11 '08 #2
On Mon, 11 Aug 2008 10:58:07 -0700, Joerg Battermann
<jb@joergbattermann.comwrote:
does anyone know the precise naming conventions used for internal
backing fields for automatic properties? Something official besides
looking at the compiled assemblies that might let you 'assume' a
certain schema...
Surely this is undocumented for a reason.

I think the best you can do is inspect what the compiler generates, and
you absolutely definitely no way should ever actually rely on that
information. The compiler could change it's behavior any time.

For what it's worth, if you have control over the code implementing the
property, you can just not use the automatically implemented property and
name the field whatever you want. Automatically implemented properties
don't add _that_ much. And if you don't have control over the code
implementing the property, I don't think you even have a reliable way to
distinguish automatically implemented properties from regular ones.

Pete
Aug 11 '08 #3
Argh - ok that's bad (for me). Basically I have an oodbms attached to
some of my classes.. and adding indexes relies in knowing the field
names. Bad... but oh well.

Thanks Jon & Peter!

On Aug 11, 8:13*pm, Jon Skeet [C# MVP] <sk...@pobox.comwrote:
Joerg Battermann <j...@joergbattermann.comwrote:
does anyone know the precise naming conventions used for internal
backing fields for automatic properties? Something official besides
looking at the compiled assemblies that might let you 'assume' a
certain schema...

I wouldn't make any assumptions. If you need direct access to the
fields, don't use automatic properties. The naming scheme is compiler-
dependent and unspecified; it could change between compiler versions.

--
Jon Skeet - <sk...@pobox.com>
Web site:http://www.pobox.com/~skeet*
Blog:http://www.msmvps.com/jon.skeet
C# in Depth:http://csharpindepth.com
Aug 11 '08 #4
Joerg Battermann wrote:
Argh - ok that's bad (for me). Basically I have an oodbms attached to
some of my classes.. and adding indexes relies in knowing the field
names. Bad... but oh well.
Hmm... well... the following code will give you the field for
automatically generated properties on all but the most crazy compilers,
where it could potentially do odd things (for example, if the automatic
property's getter strangly called a method before accessing the field
and that method happened to contain 0x7B in its token).

Cecil would be useful here and could parse the IL instead of guessing
that the first instance of 0x7B is the ldfld instruction so the token
will come next.

Having said that, it does work for any reasonable compiler and I wanted
to keep the code simple:

private static FieldInfo GetBackingField(PropertyInfo property)
{
if (!(property.CanRead && property.CanWrite))
{
throw new NotSupportedException("Not an automatic property");
}

byte[] getter =
property.GetGetMethod().GetMethodBody().GetILAsByt eArray();
byte ldfld = (byte)(property.GetGetMethod().IsStatic ?
OpCodes.Ldsfld : OpCodes.Ldfld).Value;
byte[] fieldToken = getter.SkipWhile(b =b !=
ldfld).Skip(1).Take(4).ToArray();
if (fieldToken.Length != 4)
{
throw new NotSupportedException("Not an automatic property");
}
FieldInfo field =
property.DeclaringType.Module.ResolveField(BitConv erter.ToInt32(fieldToken,
0));
if (field == null)
{
throw new NotSupportedException("Not an automatic property");
}

//Not sure about this: compilers don't strictly have to add this
attribute.
if (!field.IsDefined(typeof(CompilerGeneratedAttribut e), false))
{
throw new NotSupportedException("Not an automatic property");
}
return field;
}

Alun Harford
Aug 12 '08 #5

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

7 posts views Thread by cmiddlebrook | last post: by
1 post views Thread by clintonG | last post: by
15 posts views Thread by Gary Morris | last post: by
5 posts views Thread by Abhishek Srivastava | last post: by
4 posts views Thread by Mark Broadbent | last post: by
3 posts views Thread by clintonG | last post: by
5 posts views Thread by rastaman | last post: by
reply views Thread by =?ISO-8859-1?Q?J=F6rg_Battermann?= | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.