在运行时更改属性参数

Question

我不确定是否可以在运行时更改属性参数？例如，在程序集中，我有以下类：

public class UserInfo
{
    [Category("change me!")]
    public int Age
    {
        get;
        set;
    }
    [Category("change me!")]
    public string Name
    {
        get;
        set;
    }
}

这是由第三方供应商提供的类，我无法更改代码。但是现在我发现上述描述不准确，当我将上述类的实例绑定到属性网格时，我想将“change me”类别名称更改为其他内容。

请问如何操作？

- Ngu Soon Hui

Answer 1

每天都会学到新东西，显然我撒了谎：

What isn’t generally realised is that you can change attribute instance values fairly easily at runtime. The reason is, of course, that the instances of the attribute classes that are created are perfectly normal objects and can be used without restriction. For example, we can get the object:

ASCII[] attrs1=(ASCII[])
    typeof(MyClass).GetCustomAttributes(typeof(ASCII), false);

…change the value of its public variable and show that it has changed:

attrs1[0].MyData="A New String";
MessageBox.Show(attrs1[0].MyData);

…and finally create another instance and show that its value is unchanged:

ASCII[] attrs3=(ASCII[])
    typeof(MyClass).GetCustomAttributes(typeof(ASCII), false);
 MessageBox.Show(attrs3[0].MyData);

http://www.vsj.co.uk/articles/display.asp?id=713

- Glenn Slaven

---

不完全是这样。您可以创建属性对象的实例并对其进行修改，但这不会影响使用标记在该属性上的属性（因为它们将获得自己不变的实例）。 - denver

Answer 2

如果有其他人需要这方面的帮助，答案是你可以使用反射来实现，但由于框架存在一个bug，所以实际上不能这样做。以下是如何实现它的方法：

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")

所有的都很好，但是类别属性被更改了，不仅仅是“年龄”属性。

- Jules

---

如果你在“BindingFlags.NonPublic”字段中乱动，我几乎不会称其为一个bug。 - Marty Neal

我相信这确实是一个错误，因为即使您不使用“BindingFlags.NonPublic”字段，它也会发生在公共属性中。有人知道是否已经提出了这个问题吗？提供错误页面的链接将非常有用。使用TypeDescriptor而不是Reflection完美地解决了问题！ - kkara

Answer 3

您可以很容易地对大多数常见属性进行子类化，以提供此扩展性：

using System;
using System.ComponentModel;
using System.Windows.Forms;
class MyCategoryAttribute : CategoryAttribute {
    public MyCategoryAttribute(string categoryKey) : base(categoryKey) { }

    protected override string GetLocalizedString(string value) {
        return "Whad'ya know? " + value;
    }
}

class Person {
    [MyCategory("Personal"), DisplayName("Date of Birth")]
    public DateTime DateOfBirth { get; set; }
}

static class Program {
    [STAThread]
    static void Main() {
        Application.EnableVisualStyles();
        Application.Run(new Form { Controls = {
           new PropertyGrid { Dock = DockStyle.Fill,
               SelectedObject = new Person { DateOfBirth = DateTime.Today}
           }}});
    }
}

更复杂的选项涉及编写自定义PropertyDescriptor，通过TypeConverter，ICustomTypeDescriptor或TypeDescriptionProvider公开 - 但通常这是不必要的。

- Marc Gravell

---

但是马克说他没有代码访问权限。 - toddmo

Answer 4

你解决问题了吗？

以下是实现可接受解决方案的可能步骤：

1. 尝试创建子类，重新定义你需要更改 [Category] 属性的所有属性（使用 new 标记）。例如：

public class UserInfo
{
 [Category("Must change")]
 public string Name { get; set; }
}

public class NewUserInfo : UserInfo
{
 public NewUserInfo(UserInfo user)
 {
 // transfer all the properties from user to current object
 }

 [Category("Changed")]
 public new string Name {
get {return base.Name; }
set { base.Name = value; }
 }

public static NewUserInfo GetNewUser(UserInfo user)
{
return NewUserInfo(user);
}
}

void YourProgram()
{
UserInfo user = new UserInfo();
...

// Bind propertygrid to object

grid.DataObject = NewUserInfo.GetNewUser(user);

...

}

稍后编辑：如果您需要重写大量属性，则此解决方案的这部分是不可行的。这就是第二部分发挥作用的地方：

2. 当然，如果类不可继承或者您有很多对象（和属性），这并不能帮助您。您需要创建一个完全自动代理类，获取您的类并创建一个动态类，应用属性，并且当然在两个类之间建立连接。这有点复杂，但也是可以实现的。只需使用反射，您就可以走上正确的道路。

- Bogdan Maxim

---

Bogdan，我担心子类化该类并进行所有重新定义是不切实际的，至少可以这么说。 - Graviton

如果你正在进行子类化，那么你必须自动重新创建所有属性，并替换旧属性。如果可以进行子类化，这是最简单的解决方案。主要思路是自动创建代理（使用动态类型），并在运行时替换属性。 - Bogdan Maxim

Answer 5

很不幸，属性在运行时不能更改。你基本上有两个选项：

1. Recreate a similar type on the fly using System.Reflection.Emit as shown below.

2. Ask your vendor to add this functionality. If you are using Xceed.WpfToolkit.Extended you can download the source code from here and easily implement an interface like IResolveCategoryName that would resolve the attribute at runtime. I did a bit more than that, it was pretty easy to add more functionality like limits when editing a numeric value in a DoubleUpDown inside the 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);
       }
   }
   

对于第一种选项：然而，它缺乏适当的属性绑定来反映结果回到实际被编辑的对象。

    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;
    }
}

- Darien Pardinas

Answer 6

假设 PropertyGrid 的选定项是 "Age"：

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

SetCategoryLabelViaReflection() 的定义如下：

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());
    }
}

如果您想要以编程的方式设置所选项目，更改其父类别，则有许多简单的解决方案。请搜索“将焦点设置为特定的PropertyGrid属性”。

- David MacDermot

Answer 7

这里有一个“作弊”的方法：

如果属性参数有固定数量的常量潜在值，您可以为每个参数潜在值定义一个单独的属性（并为每个属性赋予稍微不同的属性），然后动态切换引用哪个属性。

在VB.NET中，它可能看起来像这样：

Property Time As Date

<Display(Name:="Month")>
ReadOnly Property TimeMonthly As Date
    Get
        Return Time
    End Get
End Property

<Display(Name:="Quarter")>
ReadOnly Property TimeQuarterly As Date
    Get
        Return Time
    End Get
End Property

<Display(Name:="Year")>
ReadOnly Property TimeYearly As Date
    Get
        Return Time
    End Get
End Property

- mbomb007

Answer 8

与此同时，我已经想出了一个部分解决方案，源自以下文章：

1. ICustomTypeDescriptor,第1部分
2. ICustomTypeDescriptor,第2部分
3. 在运行时向PropertyGrid添加（删除）项目

基本上，您需要创建一个泛型类 CustomTypeDescriptorWithResources<T>，通过反射获取属性，并从文件中加载 Description 和 Category (我想您需要显示本地化文本，因此可以使用资源文件 (.resx))

- Bogdan Maxim

Answer 9

我真的不这么认为，除非有一些奇怪的反射可以完成它。属性修饰符在编译时设置，并且据我所知是固定的。

- Glenn Slaven

Answer 10

您可以在类级别（而不是对象）运行时更改属性值：

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

- mmm