Refleksi dalam C#

Refleksi dalam C# ialah proses mengumpul maklumat tentang ciri-cirinya dan beroperasi pada dirinya sendiri. Maklumat pengumpulan termasuk sifat, jenis, peristiwa dan kaedah objek; refleksi berguna dalam mencari semua jenis perhimpunan. Secara dinamik ia menggunakan kaedah pemasangan yang kita boleh mengikat atau mendapatkan jenis secara dinamik ke atau daripada objek sedia ada; refleksi digunakan untuk mencipta contoh jenis. Kami boleh mengakses sifat dan medannya tujuan utama refleksi yang digunakan untuk membaca metadatanya untuk mencari himpunan semasa masa jalan.

Mengapa kita memerlukan Refleksi dalam C#?

Kami memerlukan pantulan dalam C# untuk mendapatkan maklumat jenis semasa runtime; ia adalah proses memerhati kod terurus untuk membaca metadatanya untuk mencari modul dan pemasangan semasa masa jalan. Refleksi mencerminkan dalam program dengan mengekstrak metadata daripada himpunannya, yang digunakan untuk mengubah suai tingkah lakunya.  Sistem. Ruang nama refleksi membolehkan anda mengakses paparan terurus kaedah, jenis dimuatkan dan medan untuk mencipta secara dinamik dan menggunakan jenis. Kami memerlukan refleksi untuk proses permohonan berikut dilakukan di sana,

• Semasa proses masa jalan, pantulan membenarkan paparan maklumat atribut.
• Refleksi membolehkan pengikatan lewat pada sifat dan kaedah
• Ia meneliti beberapa jenis perhimpunan dan jenisnya
• Ia membolehkan penciptaan jenis baharu semasa masa jalan dan melaksanakan pelbagai tugas dengan mengikut jenis tersebut.

Bagaimana Refleksi berfungsi dalam C#?

C# Reflection membolehkan aplikasi mendapatkan maklumat itu sendiri, dan juga ia beroperasi pada dirinya sendiri. Ia mencari semua jenis perhimpunan dengan berkesan dan menggunakan kaedah pemasangan secara dinamik.

Kelas penting utama yang digunakan dalam refleksi ialah Sistem. Kelas jenis ialah kelas abstrak yang mewakili jenis yang dipanggil CTS (Common Type System). Menggunakan kelas ini, kita boleh mencari jenis yang kita gunakan dalam modul ruang nama dan mengesahkan bahawa jenis yang diberikan ialah nilai atau jenis rujukan. Dengan menggunakan item berikut, kita boleh menghuraikan jadual metadata,

• Kaedah
• Hartanah
• Acara
• Lapangan

Menggunakan refleksi, Pengikatan Lewat dicapai; semasa masa penyusunan, kami mungkin tidak tahu pemasangan mana yang hendak dimuatkan atas sebab ini; kami memuatkan pemasangan yang sesuai dengan meminta pengguna memasukkan nama pemasangan dan menaip semasa pelaksanaan masa berjalan. Dengan menghampiri pemuatan langsung pada perhimpunan, kami menggunakan Sistem. Refleksi. Perhimpunan dengan mendapatkan tiga jenis statik ialah,

• Muat Daripada
• Modul Muatan
• MuatDenganSeparaNama

Memandangkan pemasangan ialah fail exe atau dll menjadikan fail itu sebagai fail boleh laku mudah alih untuk Sistem Jenis Biasa, yang mempunyai sambungan .dll atau .exe. Fail Boleh laku mudah alih ialah metadata yang mengandungi beberapa jadual seperti berikut,

• Jadual definisi kaedah
• Taip jadual definisi
• Jadual definisi medan

Contoh Refleksi dalam C#

Diberikan di bawah adalah contoh Refleksi dalam C#:

Contoh #1

using System;
using System.Reflection;
namespace Reflection_Sample {
class Program_1 {
// Main Method
static void Main(string[] args)
{
// to initialize _type as typeof string
Type _type = typeof(string);
// by using the Reflection to find and in any sort of data related to _type
Console.WriteLine("Name : {0}", _type.Name);
Console.WriteLine("Full Name : {0}", _type.FullName);
Console.WriteLine("Namespace : {0}", _type.Namespace);
Console.WriteLine("Base Type : {0}", _type.BaseType);
}
}
}

Dalam kod di atas, kami memuatkan jenis _type sebagai rentetan menggunakan kaedah typeof. Kemudian kami mengaitkan refleksi pada _type untuk mencari maklumat tentang kelas rentetan, termasuk ruang nama, nama, nama penuh dan jenis asas.

Output:

Contoh #2

Dalam program ini, kami mendapat pemasangan dengan mentakrifkan kaedah jenis dan melalui cara ini _type. Perhimpunan. Mari lihat contoh program

using System;
using System.Reflection;
public class ReflectionExample
{
public static void Main()
{
Type _type = typeof(System.String);
Console.WriteLine(_type.Assembly);
}
}

Output:

Contoh #3

Dalam program ini, kami menunjukkan metadata menggunakan pantulan; ia termasuk kaedah, kelas, dan pelbagai pembina parameter. Mari lihat contoh di bawah,

using System;
using System.Reflection;
namespace Sample_ReflectionMetadata
{
// to define a class StudentDetails
class StudentDetails
{
// defining the Properties
public int _RollNo
{
get;
set;
}
public string _Name
{
get;
set;
}
// Constructor with no arguments
public StudentDetails()
{
_RollNo = 0;
_Name = string.Empty;
}
// this is a Parameterised Constructor with 2 parameters
public StudentDetails(int _Srollno, string _Sname)
{
_RollNo = _Srollno;
_Name = _Sname;
}
// to invoke method to Display Student Details
public void StudentDisplayData()
{
Console.WriteLine("Roll Number : {0}", _RollNo);
Console.WriteLine("Name : {0}", _Name);
}
}
class ReflectionClass
{
// Main Method
static void Main(string[] args)
{
// to declare Assembly and loading the current assembly
Assembly _executing = Assembly.GetExecutingAssembly();
Type[] _types = _executing.GetTypes();
foreach(var item in _types)
{
Console.WriteLine("Class : {0}", item.Name);
// storing the methods  in array
MethodInfo[] methods = item.GetMethods();
foreach(var method in methods)
{
// for displaying each method
Console.WriteLine("--> Method : {0}", method.Name);
// to store the parameters in array
ParameterInfo[] parameters = method.GetParameters();
foreach(var arg in parameters)
{
Console.WriteLine(" Parameter : {0} Type : {1}",
arg.Name, arg.ParameterType);
}
}
}
}
}
}

Output:

Contoh #4

Refleksi ialah proses memerhati dan mengubah struktur dan tingkah laku sebenar secara dinamik. Dalam program contoh di bawah, Reflection berfungsi yang kami boleh menganalisis dan mengubah maklumat dalam aplikasi semasa masa jalan.  Mari lihat contoh,

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
namespace ReflectionSample
{
class Program
{
private static int value_1= 15, value_2 = 25, value_3 = 30;
static void Main(string[] args)
{
Console.WriteLine("The Values are = " + (value_1 + value_2 + value_3));
Console.WriteLine("Input the Name of variable to be altered:");
string _varName = Console.ReadLine();
Type _type = typeof(Program);
FieldInfo _fieldInfo = _type.GetField(_varName, BindingFlags.NonPublic | BindingFlags.Static);
if(_fieldInfo != null)
{
Console.WriteLine("The Latest Value of " + _fieldInfo.Name + " is " + _fieldInfo.GetValue(null) + ". Input NeW Value:");
string newValue = Console.ReadLine();
int newInt;
if(int.TryParse(newValue, out newInt))
{
_fieldInfo.SetValue(null, newInt);
Console.WriteLine(" Final Values are = " + (value_1 + value_2 + value_3));
}
Console.ReadKey();
}
}
}
}

Di sini kita boleh menukar nilai pembolehubah semasa masa jalan dengan mengetahui namanya. Dengan menggunakan refleksi, kita boleh mencapai jenis kaedah ini. Mari lihat output di bawah seperti berikut,

Output:

Kesimpulan

Saya harap anda telah menikmati artikel itu; C# Reflection merangkumi fungsi penting dalam .Net di sini; kami telah mempelajari cara Reflection berfungsi dalam C#.Net dengan beberapa contoh. Saya harap artikel ini akan membantu anda dengan pemahaman yang baik.

Atas ialah kandungan terperinci Refleksi dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!