Changement de l'Attribut de paramètre lors de l'exécution

Au cas où quelqu'un d'autre marche le long de cette avenue, la réponse est que vous pouvez le faire, avec la réflexion, à l'exception que vous ne pouvez pas car il y a un bug dans le cadre. Voici comment faire:

Dim prop As PropertyDescriptor = TypeDescriptor.GetProperties(GetType(UserInfo))("Age")
Dim att As CategoryAttribute = DirectCast(prop.Attributes(GetType(CategoryAttribute)), CategoryAttribute)
Dim cat As FieldInfo = att.GetType.GetField("categoryValue", BindingFlags.NonPublic Or BindingFlags.Instance)
cat.SetValue(att, "A better description")

Tout va bien, sauf que la catégorie d'attribut est modifié pour toutes les propriétés, et pas seulement "Âge".

Malheureusement, les attributs ne sont pas destinées à changer lors de l'exécution. En gros, vous avez deux options:

1. Recréer un type similaire à la volée à l'aide de System.Reflection.Emit comme indiqué ci-dessous.

2. Demandez à votre fournisseur pour ajouter cette fonctionnalité. Si vous utilisez Xceed.WpfToolkit.Étendue vous pouvez télécharger le code source de ici et facilement mettre en œuvre une interface comme IResolveCategoryName qui permettrait de résoudre l'attribut au moment de l'exécution. J'ai fait un peu plus que cela, il était assez facile d'ajouter plus de fonctionnalités, comme des limites lors de la modification d'une valeur numérique dans une DoubleUpDown à l'intérieur de la PropertyGrid, etc.

   namespace Xceed.Wpf.Toolkit.PropertyGrid
   {
       public interface IPropertyDescription
       {
           double MinimumFor(string propertyName);
           double MaximumFor(string propertyName);
           double IncrementFor(string propertyName);
           int DisplayOrderFor(string propertyName);
           string DisplayNameFor(string propertyName);
           string DescriptionFor(string propertyName);
           bool IsReadOnlyFor(string propertyName);
       }
   }

Pour la première option: néanmoins le manque de bonne propriété de liaison afin de refléter le résultat de retour de l'objet réel en cours d'édition.

    private static void CreatePropertyAttribute(PropertyBuilder propertyBuilder, Type attributeType, Array parameterValues)
{
var parameterTypes = (from object t in parameterValues select t.GetType()).ToArray();
ConstructorInfo propertyAttributeInfo = typeof(RangeAttribute).GetConstructor(parameterTypes);
if (propertyAttributeInfo != null)
{
var customAttributeBuilder = new CustomAttributeBuilder(propertyAttributeInfo,
parameterValues.Cast<object>().ToArray());
propertyBuilder.SetCustomAttribute(customAttributeBuilder);
}
}
private static PropertyBuilder CreateAutomaticProperty(TypeBuilder typeBuilder, PropertyInfo propertyInfo)
{
string propertyName = propertyInfo.Name;
Type propertyType = propertyInfo.PropertyType;
//Generate a private field
FieldBuilder field = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
//Generate a public property
PropertyBuilder property = typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyType,
null);
//The property set and property get methods require a special set of attributes:
const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig;
//Define the "get" accessor method for current private field.
MethodBuilder currGetPropMthdBldr = typeBuilder.DefineMethod("get_" + propertyName, getSetAttr, propertyType, Type.EmptyTypes);
//Intermediate Language stuff...
ILGenerator currGetIl = currGetPropMthdBldr.GetILGenerator();
currGetIl.Emit(OpCodes.Ldarg_0);
currGetIl.Emit(OpCodes.Ldfld, field);
currGetIl.Emit(OpCodes.Ret);
//Define the "set" accessor method for current private field.
MethodBuilder currSetPropMthdBldr = typeBuilder.DefineMethod("set_" + propertyName, getSetAttr, null, new[] { propertyType });
//Again some Intermediate Language stuff...
ILGenerator currSetIl = currSetPropMthdBldr.GetILGenerator();
currSetIl.Emit(OpCodes.Ldarg_0);
currSetIl.Emit(OpCodes.Ldarg_1);
currSetIl.Emit(OpCodes.Stfld, field);
currSetIl.Emit(OpCodes.Ret);
//Last, we must map the two methods created above to our PropertyBuilder to 
//their corresponding behaviors, "get" and "set" respectively. 
property.SetGetMethod(currGetPropMthdBldr);
property.SetSetMethod(currSetPropMthdBldr);
return property;
}
public static object EditingObject(object obj)
{
//Create the typeBuilder
AssemblyName assembly = new AssemblyName("EditingWrapper");
AppDomain appDomain = System.Threading.Thread.GetDomain();
AssemblyBuilder assemblyBuilder = appDomain.DefineDynamicAssembly(assembly, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assembly.Name);
//Create the class
TypeBuilder typeBuilder = moduleBuilder.DefineType("EditingWrapper",
TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit, typeof(System.Object));
Type objType = obj.GetType();
foreach (var propertyInfo in objType.GetProperties())
{
string propertyName = propertyInfo.Name;
Type propertyType = propertyInfo.PropertyType;
//Create an automatic property
PropertyBuilder propertyBuilder = CreateAutomaticProperty(typeBuilder, propertyInfo);
//Set Range attribute
CreatePropertyAttribute(propertyBuilder, typeof(Category), new[]{"My new category value"});
}
//Generate our type
Type generetedType = typeBuilder.CreateType();
//Now we have our type. Let's create an instance from it:
object generetedObject = Activator.CreateInstance(generetedType);
return generetedObject;
}
}

Étant donné que la grille des propriétés de l'élément sélectionné est "l'Âge":

SetCategoryLabelViaReflection(MyPropertyGrid.SelectedGridItem.Parent,
MyPropertyGrid.SelectedGridItem.Parent.Label, "New Category Label");

Où SetCategoryLabelViaReflection() est définie comme suit:

private void SetCategoryLabelViaReflection(GridItem category,
string oldCategoryName,
string newCategoryName)
{
try
{
Type t = category.GetType();
FieldInfo f = t.GetField("name",
BindingFlags.NonPublic | BindingFlags.Instance);
if (f.GetValue(category).Equals(oldCategoryName))
{
f.SetValue(category, newCategoryName);
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.Write("Failed Renaming Category: " + ex.ToString());
}
}

Autant que par programmation réglage de l'élément sélectionné, le parent de la catégorie dont vous souhaitez changer; il y a un certain nombre de solutions simples. Google "Définir le Focus à une grille de propriété à la propriété".

Dans le temps de le dire, je suis venu pour une solution partielle, dérivée à partir des articles suivants:

1. ICustomTypeDescriptor, Partie 1
2. ICustomTypeDescriptor, Partie 2
3. Ajouter (ou Retirer) des Éléments de (de) grille de propriété au moment de l'Exécution

Fondamentalement, vous devez créer une classe générique CustomTypeDescriptorWithResources<T>, qui permettrait d'obtenir les propriétés de la réflexion et de la charge Description et Category à partir d'un fichier (je suppose que vous avez besoin pour afficher le texte localisé afin que vous pouvez utiliser un fichier de ressources (.resx))

Vous pouvez modifier les valeurs d'Attribut au moment de l'exécution au niveau de la Classe (pas d'objet):

var attr = TypeDescriptor.GetProperties(typeof(UserContact))["UserName"].Attributes[typeof(ReadOnlyAttribute)] as ReadOnlyAttribute;
attr.GetType().GetField("isReadOnly", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(attr, username_readonly);