【C#属性的运行时行为】：动态设置和获取属性值的8个技巧

# 1. C#属性基础与运行时行为概述

## 1.1 属性的基本概念
属性是C#编程语言中用于封装数据的一种机制。它们类似于公共字段，但提供了更高级的控制，如数据验证和隐藏数据存储的实现细节。属性允许开发者定义读取和写入数据的方法，称为访问器，包含`get`和`set`方法。

public class MyClass
{
    private int _myProperty;
    public int MyProperty
    {
        get { return _myProperty; }
        set { _myProperty = value; }
    }
}

在上述示例中，`MyClass` 类有一个名为 `MyProperty` 的属性，该属性封装了私有字段 `_myProperty`。

## 1.2 属性的运行时行为
运行时，属性被当作对象的状态进行处理。通过属性访问器可以添加逻辑来控制数据如何被设置或检索。在某些情况下，属性的读取和写入可以触发额外的逻辑，如更改通知或日志记录。

public class MyClass
{
    private int _myProperty;
    public int MyProperty
    {
        get { return _myProperty; }
        set 
        {
            if (value != _myProperty)
            {
                _myProperty = value;
                NotifyPropertyChanged();
            }
        }
    }
    private void NotifyPropertyChanged() { /* 实现通知逻辑 */ }
}

在此代码中，每当 `MyProperty` 的值被修改时，会检查新旧值是否不同。如果不同，调用 `NotifyPropertyChanged` 方法通知任何侦听此属性更改的对象。

## 1.3 属性与字段的区别
属性不同于字段，字段是类中变量的直接表示，而属性则是通过访问器方法提供对字段的封装访问。这种封装提供了对数据访问的控制，允许开发者在数据被读取或写入时实现自定义逻辑。

public class MyClass
{
    // 字段
    private int _age;

    // 属性
    public int Age
    {
        get { return _age; }
        set { _age = value; }
    }
}

在上面的示例中，`Age` 属性提供了一种方式来访问私有字段 `_age`。通过属性，可以在获取或设置值时添加验证逻辑，例如检查年龄是否为有效的正数。

# 2. 动态访问和修改属性值的技巧

在软件开发中，属性是对象的状态和行为的关键组成部分。在运行时动态地访问和修改属性值为开发者提供了一种灵活的方法来处理对象，特别是在需要反射、元编程或在运行时构建动态行为的场景中。在本章节中，我们将探讨一些实用的技术和方法，这些技术可以帮助我们实现属性值的动态访问和修改。

### 2.1 属性动态访问的方法论

#### 2.1.1 反射机制在属性动态访问中的应用

反射是.NET中一种强大的特性，允许程序在运行时获取对象的类型信息，并操作类型的成员（字段、属性、方法等）。当需要在运行时获取或设置属性值时，反射提供了一种有效的方式。

public class ReflectionExample
{
    public string Name { get; set; }
}

// 示例代码：通过反射访问属性值
using System;
using System.Reflection;

public class Program
{
    public static void Main()
    {
        var instance = new ReflectionExample();
        instance.Name = "Dynamic";

        PropertyInfo propInfo = typeof(ReflectionExample).GetProperty("Name");
        // 获取属性值
        object value = propInfo.GetValue(instance);
        Console.WriteLine(value); // 输出: Dynamic

        // 设置属性值
        propInfo.SetValue(instance, "Reflected");
        Console.WriteLine(instance.Name); // 输出: Reflected
    }
}

在上述代码中，我们首先创建了一个`ReflectionExample`类的实例，并设置了`Name`属性的值。然后，使用`GetProperty`方法通过反射获取了`Name`属性的信息。最后，我们使用`GetValue`和`SetValue`方法分别读取和设置属性的值。

#### 2.1.2 使用表达式树实现属性访问

表达式树是表示代码的树状结构，允许在运行时分析代码表达式。通过表达式树，可以构建表示属性访问的代码结构，并在运行时执行。

using System;
using System.Linq.Expressions;

public class ExpressionTreeExample
{
    public string Description { get; set; }
}

// 示例代码：通过表达式树访问属性值
using System.Linq.Expressions;

public class Program
{
    public static void Main()
    {
        Expression<Func<ExpressionTreeExample, string>> expr = e => e.Description;
        var param = Expression.Parameter(typeof(ExpressionTreeExample), "e");
        var member = Expression.Property(param, "Description");
        var lambda = Expression.Lambda<Func<ExpressionTreeExample, string>>(member, param);
        var getterFunc = ***pile();

        var instance = new ExpressionTreeExample { Description = "Example Description" };
        // 执行表达式树获取属性值
        string description = getterFunc(instance);
        Console.WriteLine(description); // 输出: Example Description
    }
}

在这个示例中，我们构建了一个表达式树来访问`ExpressionTreeExample`类的`Description`属性。之后，我们编译并执行该表达式树，从而动态获取了属性值。

### 2.2 动态修改属性值的策略

#### 2.2.1 利用动态类型和dynamic关键字

在C#中，`dynamic`关键字提供了一种方法来跳过编译时类型检查。当属性访问与修改涉及动态类型时，编译器不会进行类型检查，这提供了更多的灵活性，尤其是在处理不同类型对象时。

public class DynamicExample
{
    public dynamic Value { get; set; }
}

// 示例代码：使用dynamic类型动态修改属性值
public class Program
{
    public static void Main()
    {
        var instance = new DynamicExample();
        instance.Value = "Initial";

        // 动态修改属性值
        instance.Value = 100; // 不需要类型转换
        Console.WriteLine(instance.Value); // 输出: 100

        instance.Value = new { Id = 1, Name = "Dynamic Type" };
        Console.WriteLine(instance.Value.Name); // 输出: Dynamic Type
    }
}

在这个示例中，`DynamicExample`类的`Value`属性被声明为`dynamic`类型。这意味着我们可以将`Value`设置为任何类型，且无需在编译时进行类型转换。

#### 2.2.2 使用IL代码直接操作属性

在某些情况下，使用反射和表达式树可能不满足性能要求。这时，可以通过直接生成中间语言（IL）代码来操作属性。这通常需要使用`System.Reflection.Emit`命名空间。

using System.Reflection;
using System.Reflection.Emit;

public class DynamicMethodExample
{
    public string Content { get; set; }
}

// 示例代码：使用IL直接设置属性值
using System;
using System.Reflection;
using System.Reflection.Emit;

public class Program
{
    public static void Main()
    {
        var dynamicMethod = new DynamicMethod(
            "SetContent", 
            null, 
            new Type[] { typeof(DynamicMethodExample), typeof(string) }
        );
        ILGenerator il = dynamicMethod.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0); // 加载第一个参数(实例)
        il.Emit(OpCodes.Ldarg_1); // 加载第二个参数(内容)
        il.Emit(OpCodes.Call, typeof(DynamicMethodExample).GetProperty("Content").GetSetMethod());
        il.Emit(OpCodes.Ret);

        var setter = (Action<DynamicMethodExample, string>)dynamicMethod.CreateDelegate(typeof(Action<DynamicMethodExample, string>));
        var instance = new DynamicMethodExample();
        // 使用IL生成的方法设置属性值
        setter(instance, "Dynamically Set");
        Console.WriteLine(instance.Content); // 输出: Dynamically Set
    }
}

在此代码示例中，我们创建了一个`DynamicMethod`对象来生成一个动态方法。我们使用`ILGenerator`来发出IL指令，这些指令加载属性的实例和值，并调用`Content`属性的设置器方法。然后，我们创建了一个委托来调用这个动态生成的方法，用于设置属性值。

### 2.3 属性的延迟计算和缓存机制

#### 2.3.1 延迟加载(Lazy Loading)的实现

延迟加载，或称为惰性加载，是一种设计模式，它允许对象在首次需要时才进行初始化，而不是在对象创建时就立即加载。这种技术特别适用于那些初始化成本高或者数据访问昂贵的场景。

using System;

public class LazyLoadingExample
{
    private Lazy<string> _description = new Lazy<string>(() => LoadDescription());

    public string Description => _description.Value;

    private string LoadDescription()
    {
        // 模拟延迟加载数据的过程
        Console.WriteLine("Loading description data...");
        return "This is a dynamically loaded description.";
    }
}

// 示例代码：使用Lazy<T>实现延迟加载
public class Program
{
    public static void Main()
    {
        LazyLoadingExample example = new LazyLoadingExample();
        // 初始时不会加载数据
        Console.WriteLine("Before accessing Description.");
        // 访问属性，触发延迟加载
        Console.WriteLine(example.Description);
        // 第二次访问将使用缓存的值
        Console.WriteLine(example.Description);
    }
}

在这个例子中，`LazyLoadingExample`类使用`Lazy<T>`类型来实现`Description`属性的延迟加载。数据只有在首次访问`Description`