10步精通C#反射：动态配置系统全解析

🔥关注墨瑾轩，带你探索编程的奥秘！🚀
🔥超萌技术攻略，轻松晋级编程高手🚀
🔥技术宝库已备好，就等你来挖掘🚀
🔥订阅墨瑾轩，智趣学习不孤单🚀
🔥即刻启航，编程之旅更有趣🚀

第1章：反射机制简介

嘿，亲爱的小伙伴们，欢迎来到C#的魔法世界——反射机制！🎩✨ 反射，听起来是不是有点像照镜子？没错，它就像是程序代码的一面镜子，让我们能够在运行时“照”到自己的样子，也就是动态地查看和操作对象的属性和方法。

反射是什么？

在C#中，反射是一种强大的特性，它允许程序在运行时（也就是程序运行的过程中）获取对象的类型信息。这就像是拥有了X光视觉，能够透视对象的内部结构。

反射能做什么？

• 动态创建对象：在不知道对象类型的情况下，根据类型名称动态创建对象实例。
• 访问属性和方法：即使这些属性和方法是私有的，反射也能访问它们。
• 调用方法：可以调用任何方法，无论它们是公共的还是私有的。
• 加载程序集：动态加载和使用程序集中的类型。

为什么使用反射？

使用反射可以带来很多好处，比如：

• 提高代码的灵活性：可以在不修改源代码的情况下，根据配置文件动态地加载和使用类。
• 实现通用功能：比如一个通用的属性复制函数，可以复制任何对象的属性，而不需要知道对象的具体类型。

反射的工作原理

反射的工作原理其实很简单。首先，你需要获取一个Type对象，这个对象代表了你想要操作的类型。然后，你可以使用这个Type对象来创建实例、访问属性和方法等。

反射的局限性

虽然反射很强大，但它也有局限性：

• 性能问题：反射操作通常比直接代码调用要慢，因为它需要在运行时解析类型信息。
• 破坏封装性：反射可以访问私有成员，这可能会破坏类的封装性。

总结

反射是C#中一个非常有用的工具，它可以让你的代码更加灵活和强大。但是，使用反射时也要注意它的性能影响和对封装性的破坏。好了，反射的魔法之旅就从这里开始，下一章我们将深入了解如何获取类型信息。🚀

---

第2章：获取类型信息

嘿，小伙伴们，我们继续在C#的反射世界中探险！🚀 上一章我们了解了反射的基本概念，现在，让我们更深入地挖掘如何获取类型信息，这是使用反射的第一步哦！

2.1 获取Type对象

在C#中，每个类型都有一个与之对应的Type对象。要使用反射，首先得获取这个Type对象。就像拿到一把钥匙，才能打开宝箱一样。获取Type对象的方法有两种：

1. 直接使用typeof关键字：
   这是最简单直接的方式，适用于你知道类型名称的情况。

   Type type = typeof(YourClassName);
   

2. 通过字符串形式的类型名称获取：
   如果你只有类型名称的字符串，可以使用Type.GetType方法。

   string typeName = "YourNamespace.YourClassName";
   Type type = Type.GetType(typeName);
   

2.2 查看类型成员

拿到了Type对象，就像拿到了一张宝藏图，接下来我们要探索这张图上的宝藏——类型的成员，包括属性、方法、构造函数等。

• 获取所有公共属性：
  使用GetProperties方法可以获取类型的所有公共属性。

  PropertyInfo[] properties = type.GetProperties();
  foreach (PropertyInfo property in properties)
  {
      Console.WriteLine("Property Name: " + property.Name);
  }
  

• 获取所有公共方法：
  使用GetMethods方法可以获取类型的所有公共方法。

  MethodInfo[] methods = type.GetMethods();
  foreach (MethodInfo method in methods)
  {
      Console.WriteLine("Method Name: " + method.Name);
  }
  

• 获取构造函数：
  使用GetConstructors方法可以获取类型的所有公共构造函数。

  ConstructorInfo[] constructors = type.GetConstructors();
  foreach (ConstructorInfo constructor in constructors)
  {
      Console.WriteLine("Constructor: " + constructor);
  }
  

2.3 过滤成员

如果你只想获取特定类型的成员，比如只获取公共的实例属性，可以使用重载的GetProperties方法，并传入BindingFlags参数。

PropertyInfo[] instanceProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);

2.4 成员的详细信息

获取到成员后，你可以进一步探索它们的详细信息：

• 属性类型：
  使用PropertyInfo.PropertyType获取属性的类型。

  Type propertyType = property.PropertyType;
  

• 方法的返回类型和参数：
  使用MethodInfo.ReturnType获取方法的返回类型，使用MethodInfo.GetParameters获取方法的参数信息。

  Type returnType = method.ReturnType;
  ParameterInfo[] parameters = method.GetParameters();
  

2.5 总结

获取类型信息是使用反射的基础，通过Type对象，我们可以访问类型的所有成员，包括属性、方法和构造函数。了解如何过滤和获取成员的详细信息，将帮助你更有效地使用反射。

---

第3章：动态创建对象

嘿，亲爱的小伙伴们，我们继续在C#的反射世界中探险！🚀 上一章我们学会了如何获取类型信息，现在，让我们看看如何利用这些信息来动态创建对象，就像魔法师从帽子里变出兔子一样神奇！

3.1 使用Activator类

Activator类是C#中一个非常强大的类，它提供了多种方法来创建对象实例。想象一下，你有一个空的篮子，Activator就像是一个神奇的篮子，你只需要告诉它你想变出什么，它就能帮你实现。

创建无参构造函数的对象

Type type = typeof(YourClass);
object obj = Activator.CreateInstance(type);

这段代码就像是对篮子说：“我想要一个YourClass类型的对象。”然后Activator就会帮你从篮子里变出一个对象来。

创建有参构造函数的对象

如果你的对象需要通过有参数的构造函数来创建，你可以这样做：

ConstructorInfo constructor = type.GetConstructor(new[] { typeof(int), typeof(string) });
object obj = constructor.Invoke(new object[] { 123, "Hello World" });

这里我们首先通过GetConstructor方法找到了需要的构造函数，然后使用Invoke方法调用它，并传入了相应的参数。

3.2 使用构造函数

除了Activator类，我们还可以直接使用ConstructorInfo来创建对象。这就像是直接打开魔法书，找到正确的咒语来变出对象。

获取构造函数

首先，我们需要获取到构造函数的信息：

ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);

这里我们使用Type.EmptyTypes来表示我们想要获取的是无参构造函数。

调用构造函数

然后，我们调用这个构造函数来创建对象：

object obj = constructor.Invoke(null);

null在这里表示我们没有传递任何参数给构造函数。

3.3 动态创建对象的注意事项

• 异常处理：在动态创建对象时，可能会遇到各种异常，比如TargetException、MethodAccessException等。确保你的代码能够妥善处理这些异常。

  try
  {
      object obj = Activator.CreateInstance(type);
  }
  catch (Exception ex)
  {
      Console.WriteLine("Failed to create an instance: " + ex.Message);
  }
  

• 性能考虑：反射创建对象通常比直接使用new关键字慢，因为它涉及到类型解析和动态调用。

3.4 总结

动态创建对象是反射中一个非常实用的功能，它允许我们在运行时根据类型信息来创建对象实例。通过Activator类和ConstructorInfo，我们可以灵活地创建对象，无论是通过无参构造函数还是有参构造函数。

---

第4章：访问和修改属性

嘿嘿，小伙伴们，我们继续在C#的反射世界中探险，这次我们要学习如何访问和修改对象的属性，就像给玩具娃娃换衣服一样简单有趣！🧸👗

4.1 获取属性信息

在我们开始给娃娃换衣服之前，我们得先知道娃娃有哪些衣服可以换，也就是获取对象的属性信息。属性信息可以通过Type对象的GetProperty方法来获取。

Type type = typeof(YourClass);
PropertyInfo propertyInfo = type.GetProperty("YourPropertyName");

这里"YourPropertyName"是你想要获取的属性的名称。如果类中有多个同名属性，这个方法会返回公共的那个属性。

4.2 读取属性值

现在我们知道了娃娃有哪些衣服，下一步就是看看娃娃现在穿的是哪一件。通过GetValue方法，我们可以读取属性的值。

object obj = new YourClass();
object value = propertyInfo.GetValue(obj);

这里的obj是我们想要读取属性的对象实例。GetValue方法将返回属性的值。

4.3 设置属性值

给娃娃换衣服的时间到了！如果娃娃的衣服旧了或者我们想给娃娃换一件新衣服，我们可以通过SetValue方法来设置属性的新值。

propertyInfo.SetValue(obj, newValue);

这里的newValue是我们想要设置的新值。这段代码就像是告诉娃娃：“嘿，换上这件新衣服吧！”

4.4 访问索引器属性

如果属性是一个索引器，我们可以通过GetIndexParameters方法来获取索引器的参数，然后使用GetValue和SetValue方法来读取和设置值。

// 假设属性是一个字符串数组索引器
PropertyInfo indexerProperty = type.GetProperty("Item");
ParameterInfo[] indexes = indexerProperty.GetIndexParameters();
object valueAtIndex = indexerProperty.GetValue(obj, new object[] { index });
indexerProperty.SetValue(obj, newValue, new object[] { index });

4.5 访问静态属性

如果你要访问的是静态属性，那么在调用GetValue和SetValue方法时不需要传递对象实例，而是传递null。

object staticValue = propertyInfo.GetValue(null);
propertyInfo.SetValue(null, newStaticValue);

4.6 动态属性访问的注意事项

• 访问权限：反射可以访问私有属性，但这样做可能会破坏封装性，所以要谨慎使用。

• 异常处理：在访问属性时可能会抛出异常，如TargetException或ArgumentException，确保你的代码能够妥善处理这些异常。

  try
  {
      object value = propertyInfo.GetValue(obj);
  }
  catch (Exception ex)
  {
      Console.WriteLine("Error accessing property: " + ex.Message);
  }
  

4.7 总结

通过反射，我们可以动态地访问和修改对象的属性，无论是公共的还是私有的，静态的还是实例的。这为我们的程序带来了极大的灵活性，但同时也要注意不要滥用这种能力。

---

第5章：调用方法

嘿嘿，亲爱的小伙伴们，我们继续在C#的反射世界中探险，这次我们要学习如何调用对象的方法，就像给机器人编程让它执行任务一样酷炫！🤖🛠️

5.1 获取方法信息

在我们开始给机器人编程之前，我们得先知道机器人能执行哪些任务，也就是获取对象的方法信息。方法信息可以通过Type对象的GetMethod方法来获取。

Type type = typeof(YourClass);
MethodInfo methodInfo = type.GetMethod("YourMethodName");

这里"YourMethodName"是你想要获取的方法的名称。如果类中有多个同名方法，这个方法会返回公共的那个方法。

5.2 调用无参方法

现在我们知道了机器人能执行哪些任务，下一步就是让机器人执行这些任务。通过Invoke方法，我们可以调用方法。

object obj = new YourClass();
object result = methodInfo.Invoke(obj, null);

这里的obj是我们想要调用方法的对象实例。Invoke方法将执行方法并返回结果。

5.3 调用带参方法

如果机器人的任务需要一些指令，我们可以通过传递参数来实现。

object[] parameters = new object[] { arg1, arg2 }; // 参数数组
object result = methodInfo.Invoke(obj, parameters);

这里的parameters是包含方法所需参数的数组。

5.4 调用静态方法

如果你要调用的是静态方法，那么在调用Invoke方法时不需要传递对象实例，而是传递null。

object result = methodInfo.Invoke(null, new object[] { arg1, arg2 });

5.5 调用方法的注意事项

• 访问权限：反射可以调用私有方法，但这样做可能会破坏封装性，所以要谨慎使用。

• 异常处理：在调用方法时可能会抛出异常，如TargetException或ArgumentException，确保你的代码能够妥善处理这些异常。

  try
  {
      object result = methodInfo.Invoke(obj, parameters);
  }
  catch (Exception ex)
  {
      Console.WriteLine("Error invoking method: " + ex.Message);
  }
  

• 方法重载：如果存在方法重载，GetMethod可能不会返回你期望的方法。在这种情况下，你可能需要使用GetMethods获取所有方法，并通过筛选找到正确的方法。

5.6 绑定参数

在调用带参数的方法时，你可能需要考虑参数的匹配和绑定。BindingFlags枚举可以帮助你指定搜索方法时应使用的绑定属性。

MethodInfo methodInfo = type.GetMethod("YourMethodName", BindingFlags.Public | BindingFlags.Instance);

5.7 总结

通过反射，我们可以动态地调用对象的方法，无论是公共的还是私有的，静态的还是实例的。这为我们的程序带来了极大的灵活性，但同时也要注意不要滥用这种能力。

---

第6章：处理异常

嘿嘿，亲爱的小伙伴们，我们继续在C#的反射世界中探险，这次我们要学习如何处理异常，就像给小船装上救生圈，确保在遇到问题时不会翻船！🚤💺

6.1 异常的类型

在使用反射时，可能会遇到几种类型的异常，它们像海上的暗礁，需要我们小心应对：

• TargetException：尝试访问的对象不是目标方法或属性的实例。
• MethodAccessException：尝试访问的方法是私有的，而当前上下文不允许访问它。
• ArgumentException：传递给方法的参数无效或数量不正确。

6.2 异常处理策略

处理异常就像是航海中的导航，我们需要制定策略来避开暗礁：

1. 使用try-catch块：这是最基本的异常处理方式，可以捕获并处理特定类型的异常。

   try
   {
       // 反射操作
   }
   catch (TargetException ex)
   {
       Console.WriteLine("目标错误：" + ex.Message);
   }
   catch (MethodAccessException ex)
   {
       Console.WriteLine("方法访问被拒绝：" + ex.Message);
   }
   catch (ArgumentException ex)
   {
       Console.WriteLine("参数错误：" + ex.Message);
   }
   

2. 预检查：在调用反射之前，检查方法或属性是否存在，以及参数是否正确。

   if (methodInfo != null && methodInfo.IsPublic)
   {
       object result = methodInfo.Invoke(obj, parameters);
   }
   else
   {
       Console.WriteLine("方法不存在或不可访问。");
   }
   

3. 使用BindingFlags：在获取方法或属性时，使用BindingFlags来指定访问级别，避免访问被拒绝。

   MethodInfo methodInfo = type.GetMethod("MethodName", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
   

6.3 异常链

在捕获异常并进行处理时，保留原始异常信息是很重要的，这可以通过Exception.InnerException属性实现。

catch (Exception ex)
{
    while (ex != null)
    {
        Console.WriteLine("异常信息：" + ex.Message);
        ex = ex.InnerException;
    }
}

6.4 用户友好的错误信息

提供用户友好的错误信息可以提高程序的可用性，尤其是在反射操作失败时。

catch (Exception ex)
{
    Console.WriteLine("发生错误：");
    Console.WriteLine(ex.Message);
}

6.5 总结

异常处理是编程中非常重要的一部分，特别是在使用反射时。通过妥善处理异常，我们可以确保程序的健壮性和稳定性，即使在遇到问题时也能优雅地处理。

---

第7章：反射的局限性和性能考虑

嘿嘿，亲爱的小伙伴们，我们继续在C#的反射世界中探险，这次我们要学习反射的局限性和性能考虑，就像在建造高楼之前，我们需要考虑地基的稳固和材料的选择一样重要！🏗️🔨

7.1 反射的局限性

虽然反射是一个非常强大的特性，但它也有一些局限性，我们需要了解并注意：

1. 破坏封装性：反射可以访问私有成员，这可能会破坏类的封装性，导致代码的安全性和维护性降低。

2. 类型安全问题：使用反射时，类型检查是在运行时进行的，而不是编译时，这可能导致类型安全问题。

3. 版本控制问题：如果使用反射来访问程序集中的类型，那么程序集的版本变化可能会影响程序的正确性。

7.2 性能考虑

反射虽然强大，但它的性能开销比直接代码调用要大，我们需要考虑：

1. 启动开销：反射操作在第一次调用时会有较大的启动开销，因为它需要查找类型信息。

2. 运行时开销：反射操作在运行时需要动态解析和调用，这比直接调用方法要慢。

3. 缓存反射调用：为了提高性能，可以缓存反射调用的结果，避免重复的类型查找和方法解析。

7.3 优化反射使用

为了优化反射的使用，我们可以采取以下措施：

1. 减少反射调用：尽可能减少反射的使用，只在必要时使用。

2. 预解析类型信息：在程序启动时预先解析需要的类型信息，并缓存起来。

3. 使用表达式树：在某些情况下，使用表达式树可能比反射有更好的性能。

7.4 代码示例：缓存反射调用

下面是一个使用字典来缓存PropertyInfo的示例，以减少反射调用的次数：

public class ReflectionCache<T>
{
    private static readonly Dictionary<string, PropertyInfo> propertyInfoCache = new Dictionary<string, PropertyInfo>();

    public static PropertyInfo GetPropertyInfo(string propertyName)
    {
        if (propertyInfoCache.TryGetValue(propertyName, out PropertyInfo propertyInfo))
        {
            return propertyInfo;
        }

        propertyInfo = typeof(T).GetProperty(propertyName);
        if (propertyInfo != null)
        {
            propertyInfoCache[propertyName] = propertyInfo;
        }

        return propertyInfo;
    }
}

7.5 总结

反射是一个强大的工具，但使用时需要考虑其局限性和性能影响。通过合理地使用反射，并采取一些优化措施，我们可以在提高程序灵活性的同时，保持程序的性能和稳定性。

---

第8章：实际案例分析

嘿嘿，亲爱的小伙伴们，我们来到了这次C#反射之旅的高潮部分——实际案例分析！🌟 我们将通过一个具体的案例来展示反射的强大功能，就像用乐高积木搭建一个酷炫的城堡一样有趣！

8.1 案例背景

假设我们有一个应用程序，需要根据不同的配置动态加载和使用不同的算法类。这些算法类都实现了同一个接口，但是具体的实现可能各不相同。

8.2 定义算法接口

首先，我们定义一个算法接口IAlgorithm：

public interface IAlgorithm
{
    void Execute();
}

8.3 创建具体的算法实现

然后，我们创建几个实现了IAlgorithm接口的类：

public class AlgorithmA : IAlgorithm
{
    public void Execute()
    {
        Console.WriteLine("执行算法A");
    }
}

public class AlgorithmB : IAlgorithm
{
    public void Execute()
    {
        Console.WriteLine("执行算法B");
    }
}

8.4 动态加载算法

接下来，我们使用反射来动态加载和执行这些算法：

public void LoadAndExecuteAlgorithm(string assemblyPath, string typeName)
{
    // 加载程序集
    Assembly assembly = Assembly.LoadFrom(assemblyPath);

    // 获取类型
    Type type = assembly.GetType(typeName);
    if (type == null)
    {
        Console.WriteLine("类型未找到");
        return;
    }

    // 检查类型是否实现了IAlgorithm接口
    if (typeof(IAlgorithm).IsAssignableFrom(type))
    {
        // 创建类型实例
        IAlgorithm algorithm = (IAlgorithm)Activator.CreateInstance(type);

        // 执行算法
        algorithm.Execute();
    }
    else
    {
        Console.WriteLine("类型未实现IAlgorithm接口");
    }
}

8.5 使用案例

假设我们有一个配置文件，指定了要使用的算法类型：

{
    "AssemblyPath": "path/to/your/assembly.dll",
    "TypeName": "Namespace.AlgorithmB"
}

我们可以这样使用LoadAndExecuteAlgorithm方法：

string assemblyPath = "path/to/your/assembly.dll"; // 从配置文件获取
string typeName = "Namespace.AlgorithmB"; // 从配置文件获取
LoadAndExecuteAlgorithm(assemblyPath, typeName);

8.6 案例分析

在这个案例中，我们展示了如何使用反射来：

• 动态加载程序集。
• 根据类型名称获取类型信息。
• 检查类型是否实现了特定的接口。
• 动态创建类型实例并调用其方法。

8.7 总结

通过这个案例，我们可以看到反射在实际开发中的应用是非常广泛的。它可以帮助我们构建更加灵活和可扩展的应用程序。同时，我们也需要注意反射的局限性和性能问题，合理地使用反射。

---

第9章：总结与进一步学习

嘿嘿，亲爱的小伙伴们，我们的C#反射之旅即将到达终点！🏁 在这一章，我们将进行一个全面的总结，回顾我们学到的所有知识，并提供一些进一步学习的资源和建议，确保你能够继续在编程的道路上越走越远！

9.1 总结

9.1.1 反射的基本概念

• 反射是C#中一个强大的特性，允许程序在运行时检查和操作对象。
• 反射的核心是System.Reflection命名空间，它提供了丰富的类和方法。

9.1.2 动态操作对象

• 我们学习了如何使用反射动态获取类型信息、创建对象实例、访问和修改属性、调用方法。
• 我们了解了如何通过Type对象获取类的构造函数、属性、方法等信息。

9.1.3 异常处理

• 我们讨论了在使用反射时可能遇到的异常类型，以及如何通过异常处理来确保程序的健壮性。

9.1.4 性能和局限性

• 我们分析了反射的性能开销和局限性，学习了如何优化反射的使用，比如通过缓存反射调用来提高性能。

9.1.5 实际案例分析

• 通过一个实际案例，我们展示了反射在构建灵活和可扩展应用程序中的应用。

9.2 进一步学习资源

9.2.1 官方文档

• Microsoft的官方文档是学习C#和.NET的宝贵资源。你可以在这里找到关于反射的详细信息和示例。
  • Microsoft .NET Documentation

9.2.2 在线教程和课程

• 网络上有许多高质量的C#和反射教程，它们可以帮助你更深入地理解反射的概念和应用。

9.2.3 社区和论坛

• 加入C#和.NET开发者社区，比如Stack Overflow，可以让你向其他开发者学习，并解决遇到的问题。

9.2.4 开源项目

• 参与开源项目是提高编程技能的好方法。你可以在GitHub等平台上找到许多使用反射的项目。

9.3 学习建议

9.3.1 动手实践

• 理论知识很重要，但实践同样不可或缺。尝试自己编写使用反射的程序，加深理解。

9.3.2 逐步深入

• 从简单的反射操作开始，逐步尝试更复杂的应用场景。

9.3.3 理解原理

• 不仅仅满足于知道如何使用反射，更要理解其背后的原理。

9.3.4 关注性能

• 在使用反射时，始终注意其对性能的影响，并学会如何优化。

9.4 结语

通过本章的学习，我们希望你能够对C#的反射机制有一个全面而深入的理解。反射是一个强大的工具，合理使用可以极大地提升你的编程能力。记住，编程是一场马拉松，而不是短跑，持续学习和实践是关键。加油，未来的编程大师！

---

第10章：综合示例 - 动态配置系统

10.1 场景描述

想象一下，我们正在开发一个应用程序，它需要根据不同的配置文件动态地调整其行为。例如，我们有一个配置文件，指定了使用哪个类来处理数据，以及类的属性应该如何设置。

10.2 配置文件示例

假设我们有一个JSON格式的配置文件config.json：

{
    "TypeName": "Namespace.DataService",
    "Properties": {
        "ConnectionString": "Server=myServer;Database=myDb;",
        "Timeout": 120
    }
}

10.3 定义数据服务类

我们先定义一个数据服务类DataService，它具有可配置的属性：

public class DataService
{
    public string ConnectionString { get; set; }
    public int Timeout { get; set; }

    public void LoadData()
    {
        // 使用配置的连接字符串和超时时间加载数据
        Console.WriteLine($"Loading data with connection string: {ConnectionString} and timeout: {Timeout} seconds.");
    }
}

10.4 读取配置文件

我们将使用Newtonsoft.Json库来读取JSON配置文件：

using Newtonsoft.Json;

public static class ConfigLoader
{
    public static T LoadConfig<T>(string filePath) where T : class, new()
    {
        string json = File.ReadAllText(filePath);
        return JsonConvert.DeserializeObject<T>(json);
    }
}

10.5 动态创建对象并设置属性

接下来，我们将使用反射来根据配置文件动态创建对象，并设置其属性：

public static class ObjectCreator
{
    public static object CreateObjectFromConfig(string assemblyPath, string typeName, object config)
    {
        // 加载程序集
        Assembly assembly = Assembly.LoadFrom(assemblyPath);
        // 获取类型
        Type type = assembly.GetType(typeName);
        if (type == null)
        {
            throw new ArgumentException("Type not found.");
        }
        // 创建对象实例
        object obj = Activator.CreateInstance(type);

        // 设置属性
        foreach (PropertyInfo property in type.GetProperties())
        {
            if (config.GetType().GetProperty(property.Name) != null)
            {
                property.SetValue(obj, config.GetType().GetProperty(property.Name).GetValue(config));
            }
        }

        return obj;
    }
}

10.6 使用示例

最后，我们将整合以上代码，根据配置文件创建DataService实例，并调用其方法：

class Program
{
    static void Main(string[] args)
    {
        // 假设配置文件和程序集在同一目录下
        string configFilePath = "config.json";
        string assemblyPath = "YourAssemblyPath";
        string typeName = "Namespace.DataService";

        // 读取配置
        var config = ConfigLoader.LoadConfig<YourConfigClass>(configFilePath);

        // 动态创建对象
        var dataService = ObjectCreator.CreateObjectFromConfig(assemblyPath, typeName, config);

        // 调用方法
        var methodInfo = dataService.GetType().GetMethod("LoadData");
        methodInfo.Invoke(dataService, null);
    }
}

10.7 总结

在本章中，我们通过一个完整的示例，展示了如何使用反射来实现一个动态配置系统。我们学习了如何读取配置文件，动态创建对象，以及如何使用反射来设置对象的属性和调用方法。

这个示例只是一个起点，你可以在此基础上进行扩展，比如增加错误处理、支持更多的配置选项、实现更复杂的逻辑等。

---