Reflexion und IOC

Reflexion

Der Reflexionsmechanismus befindet sich im laufenden Zustand und kann alle Attribute und Attribute kennen Diese Klasse. Für jedes Objekt kann jede seiner Methoden aufgerufen werden. Diese Funktion zum dynamischen Abrufen und dynamischen Aufrufen der Methoden des Objekts wird als Reflexionsmechanismus bezeichnet. Der Reflexionsmechanismus ruft Methoden dynamisch ab und verwendet sie. Dies unterscheidet sich völlig vom direkten Erstellen eines Objekts einer Klasse und dem direkten Aufruf. Wenn es beispielsweise eine private Eigenschaft oder Methode in einer Klasse gibt, können wir sie nicht direkt aufrufen, aber wir können den Reflexionsmechanismus verwenden, um sie dynamisch aufzurufen.

IOC

Der größte Vorteil von IOC ist die Objektgenerierung on Es ist in XML definiert. Wenn wir also eine Implementierungsunterklasse ändern müssen, wird es sehr einfach (im Allgemeinen werden solche Objekte in einer Art Schnittstelle implementiert). Modifizieren Sie einfach das XML, damit wir überhaupt die Aktualität der Klasse erkennen können Objekt ein- und ausstecken (ein bisschen wie USB-Schnittstelle und SCSI-Festplatte). Bevor IOC nicht anwendbar ist, müssen wir, wenn ein Objekt von einem anderen Objekt abhängt (im Folgenden werden wir es als abhängiges Objekt und abhängiges Objekt bezeichnen), ein abhängiges Objekt im abhängigen Objekt instanziieren, damit Methoden im abhängigen Objekt aufgerufen werden können . Offensichtlich ist dieser Kopplungsgrad relativ hoch und entspricht nicht unseren Programmierprinzipien. Daher werden wir zu diesem Zeitpunkt ein Drittanbieterobjekt einführen, das für die direkte Übergabe eines abhängigen Objekts an das abhängige Objekt verantwortlich ist, wodurch die Kopplung zwischen den beiden verringert wird. Die folgende Abbildung zeigt den Vergleich der Objektkopplung im System vor und nach dem Hinzufügen des IOC-Containers

Bevor der IOC-Container in das Softwaresystem eingeführt wurde, wie in Abbildung 1 dargestellt, hängt Objekt A von Objekt B ab. Dann muss Objekt A es aktiv erstellen, wenn es initialisiert wird oder läuft bis zu einem bestimmten Punkt oder verwendet ein bereits erstelltes Objekt B. Unabhängig davon, ob Sie Objekt B erstellen oder verwenden, liegt die Kontrolle in Ihren Händen.
Nachdem der IOC-Container in das Softwaresystem eingeführt wurde, änderte sich diese Situation vollständig. Wie in Abbildung 2 gezeigt, ging die direkte Verbindung zwischen Objekt A und Objekt B verloren A läuft zu Wenn Objekt B benötigt wird, erstellt der IOC-Container aktiv ein Objekt B und fügt es an der Stelle ein, an der Objekt A benötigt wird.
Durch den Vergleich vorher und nachher ist es nicht schwer zu erkennen, dass sich der Prozess der Abhängigkeit von Objekt A von Objekt B von aktivem Verhalten zu passivem Verhalten ändert und die Kontrollrechte umgekehrt werden. Dies ist der Ursprung des Namens. Umkehrung der Kontrolle“.

Instanz

Reflection-Instanzcode

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

namespace StudentDAL
{
    public class Student
    {
        //属性
        public string Name{get;set;}
        public int Age { get; set; }

        //无参数构造函数
        public Student()
        {
            this.Name = "无参数";
            this.Age = 0;

        }
        //有参数构造函数
        public Student(string name, int age)
        {
            this.Name = "name";
            this.Age = age;
        }

        //public带参带返回值函数
        public string PublishMethodReturn()
        {
            return string.Format("我叫"+Name+"年龄" +Age);
        }
    }
}</strong></span>

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

namespace ITOO_Reflection
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用 Assembly 定义和加载程序集，
            //加载在程序集清单中列出的模块，
            //以及从此程序集中查找类型并创建该类型的实例.
            //获取程序集
            Assembly assembly = Assembly.Load("StudentDAL");
            //从程序及获取指定对象类型
            Type type = assembly.GetType("StudentDAL.Student");
            var instance = assembly.CreateInstance("StudentDAL.Student");
            //为学生类的属性赋值
            type.GetProperty("Name").SetValue(instance, "shx", null);
            type.GetProperty("Age").SetValue(instance, 18, null);
            //获取Student类的方法
            var method = type.GetMethod("PublishMethodReturn");
            //调用Student类的成员方法PublishMethodReturn
            var S= method.Invoke(instance, null);
          
            Console.WriteLine(S);
            Console.Read();
        }
    }
}</strong></span>

Laufergebnis

IOC-Beispielcode

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#666666;"><strong>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ITOO.IOC.IDAL
{
    public interface IUserDal
    {
        void HelloWord();
    }
}
</strong></span>

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#666666;"><strong>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ITOO.IOC.IDAL;

namespace ITOO.IOC.DAL
{
    public class User:IUserDal
    {
        public void HelloWord()
        {
            Console.WriteLine("helloword");
        }
    }
}
</strong></span>

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#666666;"><strong>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ITOO.IOC.IBLL
{
    public interface IUserBll
    {
        void HelloWord();
    }
}
</strong></span>

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#666666;"><strong>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ITOO.IOC.IBLL;
using ITOO.IOC.IDAL;
using ITOO.Library.Core.AOP;

namespace ITOO.IOC.BLL
{
    public class UserBll:IUserBll
    {
        public void HelloWord()
        {
            //使用底层封装的SpringHelper从IOC容器中拿到D层的类的对象实例
            IUserDal iuser = SpringHelper.GetObject<IUserDal>("User");
            iuser.HelloWord();
        }
    }
}
</strong></span>

<span style="font-family:KaiTi_GB2312;font-size:18px;color:#666666;"><strong>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ITOO.IOC.IBLL;
using ITOO.Library.Core.AOP;

namespace ITOO.IOC.Client
{
    class Program
    {
        static void Main(string[] args)
        {
            //客户端通过底层封装的SpringHelper从IOC容器中根据B层类的对象的id拿到UserBll类的实例
            IUserBll iuserbll = SpringHelper.GetObject<IUserBll>("UserBll");
            //调用UserBll类的方法
            iuserbll.HelloWord();
            Console.Read();
        }
    }
}
</strong></span>

Laufergebnisse

Das Obige ist der Inhalt der Reflexion und des IOC. Weitere verwandte Inhalte finden Sie hier die chinesische PHP-Website (www.php.cn)!