C# - 如何在不使用反射的情况下获取/设置对象的属性值

本文关键字：设置 获取 对象 属性 情况下 反射的 | 更新日期: 2023-09-27 18:31:16

我需要能够存储对对象属性的引用，以便以后读取/写入它，理想情况下不使用反射。 我也对一种有效的设计模式持开放态度，但性能至关重要，因为我的应用程序将进行数百万次调用以在各种"父"类上"运行"。 下面的代码模板应该解释我正在尝试做什么。

例如，我想保持它，即我"需要"的变量是 Child 类的对象属性，而不是存储在某个列表中的数据结构。

最后，我想我正在寻找超越重置对象值或检查不为空的东西。 例如，在调用_run后，Parent 可能会将属性的值用于其他内容。

谢谢。

class requiredAttribute : Attribute
{
}
abstract class Parent
{
    abstract protected void _run();
    public Parent() {
        // This can do whatever set-up is necessary in order to make the below run() call
        // not need reflection.
        /* What code goes here? */
    }
    public void run() {
        // This code should reset all 'required' properties to null.
        /* What goes here? */
        _run();
        // This code needs to ensure any required property is now not null.
        // If it finds a null one, it should throw.
        /* What goes here? */
    }
}
class Child : Parent
{
    [required]
    protected object value1;
    [required]
    protected object value2;
    // not required..
    protected object value3;
    protected void _run() {
        // This must set all 'required' properties' values, otherwise the Parent should throw.
        value1 = "some value";
        value2 = "some other value";
    }
}

C# - 如何在不使用反射的情况下获取/设置对象的属性值

与其使用

an 属性，不如使用接口。

创建一个接口IValidatable并将其放置在父接口上。
为父级提供它的抽象实现。并在孩子身上实施它。

abstract class Parent : IValidatable
{
    public abstract bool IsValid();
    abstract protected void _run();
    public Parent()
    {
    }
    public void run()
    {
        _run();
        if (!IsValid())
            //throw
    }
}
class Child : Parent
{
    protected object value1;
    protected object value2;
    // not required..
    protected object value3;
    protected override void _run()
    {
        // This must set all 'required' properties' values, otherwise the Parent should throw.
        value1 = "some value";
        value2 = "some other value";
    }
    public override bool IsValid()
    {
        return value1 != null && value2 != null;
    }
}
public interface IValidatable
{
    bool IsValid();
}

我找到了一个运行良好的高性能反射库：FastMember。

using FastMember;
class RequiredAttribute : Attribute
{
}
abstract class Parent
{
    abstract protected void _run();
    private List<string> required_prop_names = new List<string>();
    private ObjectAccessor accessor;
    public Parent()
    {
        // create list of properties that are 'required'
        required_prop_names = this.GetType().GetFields()
            .Where(prop => Attribute.IsDefined(prop, typeof(RequiredAttribute)))
            .Select(prop => prop.Name)
            .ToList<string>();
        // create FastMember accessor
        accessor = ObjectAccessor.Create(this);
    }
    public void run()
    {
        // set all to null
        required_prop_names.ForEach(x => accessor[x] = null);
        // call child
        _run();
        // validate
        foreach (string prop_name in required_prop_names){
            Console.WriteLine("Value of {0} is {1}", prop_name, accessor[prop_name]);
            if (accessor[prop_name] == null){
                Console.WriteLine("Null value found on {}!", prop_name);
            }
        }
    }
}
class Child : Parent
{
    [Required]
    public object value1 = "something";
    [Required]
    public object value2 = "something";
    // not required..
    public object value3;
    override protected void _run()
    {
        // This must set all 'required' properties' values, otherwise the Parent should throw.
        value1 = "something else";
        //value2 = "something else";
    }
}

另一种解决方案使用 Wrapper 对象——这样我们就可以存储对这些对象的引用，并在以后获取/设置它们。 为方便起见，可以使用反射由基对象自动创建包装器实例。 唯一的问题是在 _run（） 中，您必须执行 value1.value = "某个值"而不是 value1 = "某个值"。 公平贸易，国际海事组织。

此解决方案只需要在实例化时进行反射，并且仍然保持类型（为了智能感知的好处）

代码看起来像这样......还没有测试过它，但这是一般的想法。

class Wrapper {
   public object value;
}
class Wrapper<T> : Wrapper {
   new public T value;
}
class requiredAttribute : Attribute
{
}
abstract class Parent
{
    abstract protected void _run();
    private List<Wrapper> wrappers = new List<Wrapper>();
    public Parent() {
        // Use reflection to find all fields that have a 'required' attribute.
        // For each one, instantiate an instance of Wrapper<T>
        // Store the reference to each object so that in run() we can reset and validate.
        /* code that does above statement goes here. */
    }
    public void run() {
        foreach (Wrapper wrapper in wrappers){
           wrapper.value = null;
        }
        _run();
        foreach (Wrapper wrapper in wrappers){
           if (wrapper.value == null) throw new Exception("null value found");
        } 
    }
}
class Child : Parent
{
    [required]
    protected Wrapper<string> value1;
    [required]
    protected Wrapper<int> value2;
    // not required..
    protected object value3;
    protected void _run() {
        // This must set all 'required' properties' values, otherwise the Parent should throw.
        value1.value = "some value";
        value2.value = 123;
    }
}
相关文章：