Changing property attributes at runtime

[Kimmo Laine]

Hi is there a way to change propertys attribute from the code?

Let´s say that i have the following property in my class:

[DisplayName("Nu mber of cars")]
public int Count[
get { . . . }
set { . . . ]
}

Is there a way to change the displayname, from my code, at runtime to
"Number of bikes".

thx!

Kimmo Laine

[Marc Gravell]

Yes; kind of... but not trivial... I guess it comes down to "why?" as to
whether it is worth the effort... are you using this on a property grid or
something? Because if this is just for a column heading on a grid, I suspect
you can override that text on the grid control...

You could try just obtaining the reflective attribute via GetType and
GetProperty, but IIRC this doesn't "stick".

However, for the /component/ model (which Forms binding uses) you can
actually do pretty much anything... invent properties on the fly, rename
them, change the attributes, etc:
You can implement the ICustomTypeDesc riptor interface; forward most of the
methods to the TypeDescriptor equivalents (using GetType(), not "this" as
the parameter); for GetProperties, call the TypeDescriptor version, but then
change the results for the property you care about... instead of returning
the (reflective) PropertyDescrip tor you get, you should be able to return a
bespoke one that changes the Attributes.

Too much there for a short example, but I have useed the above (as part of a
complex system) with great success (for dynamic properties similar to
DataSet columnns).

Marc

[MMA]

Try this may require a little tweaking but should be close:

using System;
using System.Reflecti on;

// A custom attribute to allow a target to have a display value.
public class DisplayName: Attribute {
// The constructor is called when the attribute is set.
public AnimalTypeAttri bute(String Value) {
_value = Value;
}

// Keep a variable internally ...
protected string _value;

// .. and show a copy to the outside world.
public string Value {
get { return _value; }
set { _value = value; }
}
}

// A test class where property has its own display value.
class DisplayNameTest Class {
[DisplayName("Nu mber of cars")]
public int Count
{
get { . . . }
set { . . . }
}

}

class DemoClass {
static void Main(string[] args) {
DisplayNameTest Class testClass = new DisplayNameTest Class
Type type = testClass.GetTy pe();
FieldInfo myFieldInfo = type.GetField(" Count")
DisplayName att =
(DisplayName)At tribute.GetCust omAttribute(myF ieldInfo,Type.G etType("Display Name"));
att.Value = "Number of bikes";
}
}

"Kimmo Laine" wrote:

Hi is there a way to change propertys attribute from the code?

Let´s say that i have the following property in my class:

[DisplayName("Nu mber of cars")]
public int Count[
get { . . . }
set { . . . ]
}

Is there a way to change the displayname, from my code, at runtime to
"Number of bikes".

thx!

Kimmo Laine

[Marc Gravell]

Well, to my mind, the main use of the [DisplayName] is for the component
model - otherwise the OP could just use a static property of
"CountDisplayNa me" or similar and read it at runtime.

For this to be useful, it would have to return the correct value to the
following (which is what 99% of callers will be using):

string displayName = // wrap
TypeDescriptor. GetProperties(t estClass)["Count"].DisplayName;

The code posted won't satisfy this, since the component model will simply
ignore the new "DisplayNam e" attribute, using the pucka DisplayNameAttr ibute
from the System.Componen tModel namespace instead.

Additionally, the DisplayNameAttr ibute.DisplayNa me property is readonly, so
you can't tweak it with reflection. In short, I don't think this will behave
as expected.

Marc

[Marc Gravell]

OK, here's the full version; obviously you can change other discreet
values via the PropertyDescrip tor implementation, or any attribute via
GetAttributes. I have implemented it as a static instance here, but you
could merrily recreate for each instance, or even on each call.
Personally I use an extenstion of this in a dynamic property bag
approach.

Most of the code is boiler-plate; ForwardingPrope rtyDescriptor just
allows a daisy-chain. I've chucked in a demo to illustrate it working
with a property-grid and data-grid-view.

using System;
using System.Componen tModel;
using System.Collecti ons.Generic;
using System.Windows. Forms;

class Program {
static void Main() {
SomeClass test = new SomeClass();
ShowObject(test , "Before");
SomeClass.Count DisplayName = "Toadstool count";
ShowObject(test , "After");
}
private static void ShowObject(Some Class item, string title) {
using (Form form = new Form())
using (PropertyGrid propGrid = new PropertyGrid())
using (DataGridView gridView = new DataGridView()) {
form.Height = 500;
form.Text = title;
propGrid.Dock = DockStyle.Fill;
gridView.Dock = DockStyle.Botto m;
form.Controls.A dd(propGrid);
form.Controls.A dd(gridView);
propGrid.Select edObject = item;
List<SomeClassi tems = new List<SomeClass> ();
items.Add(item) ;
gridView.DataSo urce = items;
form.ShowDialog ();
}
}
}
class SomeClass : ICustomTypeDesc riptor {
private int count = 5;
[DisplayName("Co unt of something"), DefaultValue(5)]
public int Count {
get {return count;}
set {count = value;}
}
private string somethingElse = "Empty";
[DisplayName("An other Property"), DefaultValue("E mpty")]
public string SomethingElse {
get { return somethingElse; }
set { somethingElse = value; }
}
AttributeCollec tion ICustomTypeDesc riptor.GetAttri butes() {
return TypeDescriptor. GetAttributes(G etType());
}

string ICustomTypeDesc riptor.GetClass Name() {
return TypeDescriptor. GetClassName(Ge tType());
}

string ICustomTypeDesc riptor.GetCompo nentName() {
return TypeDescriptor. GetComponentNam e(GetType());
}

TypeConverter ICustomTypeDesc riptor.GetConve rter() {
return TypeDescriptor. GetConverter(Ge tType());
}

EventDescriptor ICustomTypeDesc riptor.GetDefau ltEvent() {
return TypeDescriptor. GetDefaultEvent (GetType());
}

PropertyDescrip tor ICustomTypeDesc riptor.GetDefau ltProperty() {
return TypeDescriptor. GetDefaultPrope rty(GetType());
}

object ICustomTypeDesc riptor.GetEdito r(Type editorBaseType) {
return TypeDescriptor. GetEditor(GetTy pe(), editorBaseType) ;
}

EventDescriptor Collection
ICustomTypeDesc riptor.GetEvent s(Attribute[] attributes) {
return TypeDescriptor. GetEvents(GetTy pe(), attributes);
}

EventDescriptor Collection ICustomTypeDesc riptor.GetEvent s() {
return TypeDescriptor. GetEvents(GetTy pe());
}

PropertyDescrip torCollection
ICustomTypeDesc riptor.GetPrope rties(Attribute[] attributes) {
return HackProperties( TypeDescriptor. GetProperties(G etType(),
attributes));
}

PropertyDescrip torCollection ICustomTypeDesc riptor.GetPrope rties()
{
return HackProperties( TypeDescriptor. GetProperties(G etType()));
}

object ICustomTypeDesc riptor.GetPrope rtyOwner(Proper tyDescriptor
pd) {
return this;
}

private PropertyDescrip torCollection
HackProperties( PropertyDescrip torCollection properties) {
List<PropertyDe scriptorpropLis t = new
List<PropertyDe scriptor>();
foreach (PropertyDescri ptor prop in properties) {
if (prop.Name == "Count")
propList.Add(Co untPropertyDesc riptor);
else
propList.Add(pr op);
}
return new PropertyDescrip torCollection(p ropList.ToArray (),
true);
}
private static readonly DisplayNameProp ertyDescriptor
CountPropertyDe scriptor;
public SomeClass() { }
public static string CountDisplayNam e {
get { return CountPropertyDe scriptor.Displa yName; }
set { CountPropertyDe scriptor.SetDis playName(value) ; }
}
static SomeClass() {
CountPropertyDe scriptor = new
DisplayNameProp ertyDescriptor( TypeDescriptor. GetProperties(t ypeof(SomeClass ))["Count"]);
}
}
public class DisplayNameProp ertyDescriptor :
ForwardingPrope rtyDescriptor {
private string displayName;
public void SetDisplayName( string displayName) {
this.displayNam e = displayName;
}
public DisplayNameProp ertyDescriptor( PropertyDescrip tor root)
: base(root) {
SetDisplayName( root.DisplayNam e);
}
public override string DisplayName {
get { return displayName; }
}

}

public abstract class ForwardingPrope rtyDescriptor : PropertyDescrip tor
{
private readonly PropertyDescrip tor _root;
protected PropertyDescrip tor Root { get { return _root; } }
protected ForwardingPrope rtyDescriptor(P ropertyDescript or root)
: base(root) {
_root = root;
}
public override void AddValueChanged (object component, EventHandler
handler) {
Root.AddValueCh anged(component , handler);
}
public override AttributeCollec tion Attributes {
get {
return Root.Attributes ;
}
}
public override bool CanResetValue(o bject component) {
return Root.CanResetVa lue(component);
}
public override string Category {
get {
return Root.Category;
}
}
public override Type ComponentType {
get { return Root.ComponentT ype; }
}
public override TypeConverter Converter {
get {
return Root.Converter;
}
}
public override string Description {
get {
return Root.Descriptio n;
}
}
public override bool DesignTimeOnly {
get {
return Root.DesignTime Only;
}
}
public override string DisplayName {
get {
return Root.DisplayNam e;
}
}
public override bool Equals(object obj) {
return Root.Equals(obj );
}
public override PropertyDescrip torCollection
GetChildPropert ies(object instance, Attribute[] filter) {
return Root.GetChildPr operties(instan ce, filter);
}
public override object GetEditor(Type editorBaseType) {
return Root.GetEditor( editorBaseType) ;
}
public override int GetHashCode() {
return Root.GetHashCod e();
}
public override object GetValue(object component) {
return Root.GetValue(c omponent);
}
public override bool IsBrowsable {
get {
return Root.IsBrowsabl e;
}
}
public override bool IsLocalizable {
get {
return Root.IsLocaliza ble;
}
}
public override bool IsReadOnly {
get { return Root.IsReadOnly ; }
}
public override string Name {
get {
return Root.Name;
}
}
public override Type PropertyType {
get { return Root.PropertyTy pe; }
}
public override void RemoveValueChan ged(object component,
EventHandler handler) {
Root.RemoveValu eChanged(compon ent, handler);
}
public override void ResetValue(obje ct component) {
Root.ResetValue (component);
}
public override void SetValue(object component, object value) {
Root.SetValue(c omponent, value);
}
public override bool ShouldSerialize Value(object component) {
return Root.ShouldSeri alizeValue(comp onent);
}
public override bool SupportsChangeE vents {
get {
return Root.SupportsCh angeEvents;
}
}
public override string ToString() {
return Root.ToString() ;
}
}

[Kimmo Laine]

Thx for your replys! I used the Marc´s method and did the following:

// Data which is shown in the propertygrid. It inherits from my custom
descriptor
class MyData : MyCustomDescrip tor {
// Property which i need to localize. Custom attribute holds the string
ID which is loaded from the resource file
[MyAttribute(123 )]
public int Count{ . . . }
}

// Custom descriptor. Used when propertygrid is inspecting my class - MyData
class MyCustomDescrip tor : ICustomTypeDesc riptor {
public PropertyDescrip torCollection GetProperties() {
PropertyDescrip torCollection orgPdc =
TypeDescriptor. GetProperties(t his, true);
PropertyDescrip torCollection newPdc = new
PropertyDescrip torCollection(n ull);

foreach(Propert yDescriptor t in orgPdc) {
// See if the property name needs to be changed
MyAttribute ma = (MyAttribute)t. Attributes[typeof(MyAttrib ute)];
if (ma != null) {
// Create custom description object - explained later
newPdc.Add(new MyDescription(t , ma.MsgID));
} else {
// Use normal
newPdc.Add(t);
}
}

return newPdc;
}
}

// Custom description object - the actual work is done here
class MyDescription : PropertyDescrip tor {
private PropertyDescrip tor m_PD = null;
private int m_MsgID = 0;

public MyDescription(P ropertyDescript or pd, int msgID) : base(pd)
{
m_PD = pd;
m_MsgID = msgID;
}

public override string DisplayName {
get {
return // Load the resource (m_MsgID) from somewhere
}
}
}
-K