反射+IOC容器

最新推荐文章于 2023-04-20 17:30:13 发布

gaibian0823

最新推荐文章于 2023-04-20 17:30:13 发布

阅读量1.3k

点赞数

CC 4.0 BY-SA版权

分类专栏： .net

本文链接：https://blog.youkuaiyun.com/gaibian0823/article/details/47170855

.net 专栏收录该内容

12 篇文章

订阅专栏

本文深入探讨反射在IOC容器中的应用，包括依赖注入和依赖查找的概念和区别。通过实例展示了如何使用反射与配置文件进行对象创建和调用。依赖注入是被动的，依赖查找则是主动的，两者都利用反射来实现对象间的交互。文章强调了主动整理和总结这些基础知识的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

说起反射，我们并不陌生，并且我在之前的博客中，http://blog.youkuaiyun.com/gaibian0823/article/details/44624423也已经提到过，一个是这里面提到的只是理解层面上的，二是反射一般很少自己出现，都是结合着其他知识点出现。所以这次不会再体现在理解层面上，我们从例子中看问题。

一、反射

反射就是在我们不去引用另外一个程序集或者模块，而直接调用他的属性、方法。

1.首先是这个程序，我要在Program中调用User中的属性以及方法。

2.类User中的代码：

<span style="font-family:KaiTi_GB2312;font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ITOO_DAL
{
    public class User
    {
        //字段
        public string Field = "Hello World";

        //属性
        public string Name { get; set; }

        //无参构造
        public User()
        {
            this.Name = "无参构造";     
        }

        //有参构造
        public User(string UserName)
        {
            this.Name = UserName;
        }

        //public函数
        public void publicFunction()
        {
            Console.WriteLine(string.Format("调用的是我public方法"));
        }

        //private函数
        private void privateFunction()
        {
            Console.WriteLine(string.Format("调用的是我private方法"));
        }

        //static函数
        public static void staticFunction()
        {
            Console.WriteLine(string.Format("调用的是我静态static方法"));
        }

        //public带参带返回值函数
        public string publicFunctionPara(string UserName)
        {
            return string.Format("调用带参带返回值函数,参数为:{0}",UserName);
        }
    }
}
</span>

3.主函数

<span style="font-family:KaiTi_GB2312;font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ITOO_Reflection
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用 Assembly 定义和加载程序集，
            //加载在程序集清单中列出的模块，
            //以及从此程序集中查找类型并创建该类型的实例.
            //获取程序集
            Assembly assembly = Assembly.Load("ITOO_DAL");

            //从程序集中获取指定对象类型;
            Type type = assembly.GetType("ITOO_DAL.User");

            //方法一：创建类的实例 

           //使用Activator创建实例(无参数构造函数)
            var userNoParameter = Activator.CreateInstance(type);

            //使用Activator创建实例(带参数构造函数)
            var userParameter = Activator.CreateInstance(type, "wangjinbo");
  
            //方法二：创建类的实例

            //使用无参构造函数创建类（先反射创建构造函数，再使用构造函数创建类）
            ConstructorInfo constructorNoParameter = type.GetConstructor(new Type[] { });
            var userNoParameterByConstructorInfo = constructorNoParameter.Invoke(new object[] { });

            //使用有参构造函数创建类（先反射创建构造函数，再使用构造函数创建类） 
            ConstructorInfo constructorParameter = type.GetConstructor(new Type[] { typeof(string) });
            var userParameterByConstructorInfo = constructorParameter.Invoke(new object[] { "wangjinbo" });

            //调用public函数(无参数)
            type.InvokeMember("publicFunction",
                              BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, userNoParameter,
                              null);

            //调用public函数(带参数)
            string returnValuePublic =
                type.InvokeMember("publicFunctionPara",
                                  BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, userNoParameter,
                                  new object[] { "wangjinbo" }) as string;
            Console.WriteLine(returnValuePublic);

            //调用静态方法       
            string returnValueStatic =
                type.InvokeMember("staticFunction", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                                  null, null, new object[] { }) as string;
            Console.WriteLine(returnValueStatic);

            //反射属性
            var Name =
                type.InvokeMember("Name", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null,
                                  userNoParameter, new object[] { }) as string;
            Console.WriteLine(Name);

            //设置属性(设置Name属性为"NewName")
            type.InvokeMember("Name", BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.Instance, null,
                                  userNoParameter, new object[] { "NewName" });


            //反射字段
            string Field =
                type.InvokeMember("Field", BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance, null,
                                  userNoParameter, new object[] { }) as string;
            Console.WriteLine(Field);

            //设置字段（设置Field字段为"NewField"）
            type.InvokeMember("Field", BindingFlags.SetField | BindingFlags.Public | BindingFlags.Instance, null,
                                  userNoParameter, new object[] { "NewField" });

        }
    }
}
</span>

上面就是通过反射从一个类中调用了另一个类中的属性以及方法。

二、反射+IOC容器

1.什么是IOC？

IOC即控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。

当然这是官方解释，我的解释是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器负责将这些联系在一起。简单的来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。

2.反射+依赖注入、依赖查找

首先，我们来看依赖注入：

配置文件中