C# Language
отражение

Вступление

замечания

Получить System.Type

Для экземпляра типа:

var theString = "hello";
var theType = theString.GetType();

Из самого типа:

var theType = typeof(string);

Получить членов типа

using System;
using System.Reflection;
using System.Linq;
                
public class Program
{
  public static void Main()
  {
    var members = typeof(object)
                    .GetMembers(BindingFlags.Public |
                                BindingFlags.Static |
                                BindingFlags.Instance);
    
    foreach (var member in members)
    {
      bool inherited = member.DeclaringType.Equals( typeof(object).Name );
      Console.WriteLine($"{member.Name} is a {member.MemberType}, " +
                        $"it has {(inherited ? "":"not")} been inherited.");
    }
  }
}

Выход ( см. Примечание о порядке вывода ниже ):

GetType is a Method, it has not been inherited.
GetHashCode is a Method, it has not been inherited.
ToString is a Method, it has not been inherited.
Equals is a Method, it has not been inherited.
Equals is a Method, it has not been inherited.
ReferenceEquals is a Method, it has not been inherited.
.ctor is a Constructor, it has not been inherited.

Мы также можем использовать GetMembers() без передачи каких-либо BindingFlags . Это вернет всех публичных членов этого конкретного типа.

Следует отметить, что GetMembers не возвращает членов в каком-либо конкретном порядке, поэтому никогда не полагайтесь на то, что GetMembers вернет вас.

Посмотреть демо

Получить метод и вызвать его

Получить экземпляр метода и вызвать его

using System;
                
public class Program
{
    public static void Main()
    {
        var theString = "hello";
        var method = theString
                     .GetType()
                     .GetMethod("Substring",
                                new[] {typeof(int), typeof(int)}); //The types of the method arguments
         var result = method.Invoke(theString, new object[] {0, 4});
         Console.WriteLine(result);
    }
}

Выход:

ад

Посмотреть демо

Получить метод Static и вызвать его

С другой стороны, если метод статичен, для его вызова не требуется экземпляр.

var method = typeof(Math).GetMethod("Exp");
var result = method.Invoke(null, new object[] {2});//Pass null as the first argument (no need for an instance)
Console.WriteLine(result); //You'll get e^2

Выход:

+7,38905609893065

Посмотреть демо

Получение и настройка свойств

Основное использование:

PropertyInfo prop = myInstance.GetType().GetProperty("myProperty");
// get the value myInstance.myProperty
object value = prop.GetValue(myInstance);

int newValue = 1;
// set the value myInstance.myProperty to newValue
prop.setValue(myInstance, newValue);

Настройка автоматически реализованных свойств только для чтения может быть выполнена через его поле поддержки (в .NET Framework имя поля поддержки - «k__BackingField»):

// get backing field info
FieldInfo fieldInfo = myInstance.GetType()
    .GetField("<myProperty>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

int newValue = 1;
// set the value of myInstance.myProperty backing field to newValue
fieldInfo.SetValue(myInstance, newValue);

Пользовательские атрибуты

Поиск свойств с помощью настраиваемого атрибута - MyAttribute

var props = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | 
            BindingFlags.Instance).Where(
            prop => Attribute.IsDefined(prop, typeof(MyAttribute)));

Найти все пользовательские атрибуты для данного свойства

var attributes = typeof(t).GetProperty("Name").GetCustomAttributes(false);

Перечислить все классы с помощью настраиваемого атрибута - MyAttribute

static IEnumerable<Type> GetTypesWithAttribute(Assembly assembly) {
    foreach(Type type in assembly.GetTypes()) {
        if (type.GetCustomAttributes(typeof(MyAttribute), true).Length > 0) {
            yield return type;
        }
    }
}

Чтение значения настраиваемого атрибута во время выполнения

public static class AttributeExtensions
{

        /// <summary>
        /// Returns the value of a member attribute for any member in a class.
        ///     (a member is a Field, Property, Method, etc...)    
        /// <remarks>
        /// If there is more than one member of the same name in the class, it will return the first one (this applies to overloaded methods)
        /// </remarks>
        /// <example>
        /// Read System.ComponentModel Description Attribute from method 'MyMethodName' in class 'MyClass': 
        ///     var Attribute = typeof(MyClass).GetAttribute("MyMethodName", (DescriptionAttribute d) => d.Description);
        /// </example>
        /// <param name="type">The class that contains the member as a type</param>
        /// <param name="MemberName">Name of the member in the class</param>
        /// <param name="valueSelector">Attribute type and property to get (will return first instance if there are multiple attributes of the same type)</param>
        /// <param name="inherit">true to search this member's inheritance chain to find the attributes; otherwise, false. This parameter is ignored for properties and events</param>
        /// </summary>    
        public static TValue GetAttribute<TAttribute, TValue>(this Type type, string MemberName, Func<TAttribute, TValue> valueSelector, bool inherit = false) where TAttribute : Attribute
        {
            var att = type.GetMember(MemberName).FirstOrDefault().GetCustomAttributes(typeof(TAttribute), inherit).FirstOrDefault() as TAttribute;
            if (att != null)
            {
                return valueSelector(att);
            }
            return default(TValue);
        }
    }

использование

//Read System.ComponentModel Description Attribute from method 'MyMethodName' in class 'MyClass'
var Attribute = typeof(MyClass).GetAttribute("MyMethodName", (DescriptionAttribute d) => d.Description);

Пересечение всех свойств класса

Type type = obj.GetType();
//To restrict return properties. If all properties are required don't provide flag.
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; 
PropertyInfo[] properties = type.GetProperties(flags);

foreach (PropertyInfo property in properties)
{
    Console.WriteLine("Name: " + property.Name + ", Value: " + property.GetValue(obj, null));
}

Определение общих аргументов экземпляров родовых типов

Если у вас есть экземпляр родового типа, но по какой-то причине не знаю определенного типа, вы можете определить общие аргументы, которые были использованы для создания этого экземпляра.

Предположим, кто-то создал экземпляр List<T> и передал его методу:

var myList = new List<int>();
ShowGenericArguments(myList);

где ShowGenericArguments имеет эту подпись:

public void ShowGenericArguments(object o)

поэтому во время компиляции вы не знаете, какие общие аргументы были использованы для создания o . Отражение предоставляет множество методов для проверки типичных типов. Сначала мы можем определить, является ли тип o общим типом:

public void ShowGenericArguments(object o)
{
    if (o == null) return;

    Type t = o.GetType();
    if (!t.IsGenericType) return;
    ...

Type.IsGenericType возвращает true если тип является общим типом и false если нет.

Но это еще не все, что мы хотим знать. List<> сам также является общим типом. Но мы хотим только изучить экземпляры конкретных построенных общих типов. Построенный общий тип - это, например, List<int> который имеет аргумент определенного типа для всех его общих параметров .

Класс Type предоставляет еще два свойства: IsConstructedGenericType и IsGenericTypeDefinition , чтобы отличать эти построенные общие типы от общих описаний типов:

typeof(List<>).IsGenericType // true
typeof(List<>).IsGenericTypeDefinition // true
typeof(List<>).IsConstructedGenericType// false

typeof(List<int>).IsGenericType // true
typeof(List<int>).IsGenericTypeDefinition // false
typeof(List<int>).IsConstructedGenericType// true

Чтобы перечислить общие аргументы экземпляра, мы можем использовать метод GetGenericArguments() который возвращает массив Type содержащий аргументы общего типа:

public void ShowGenericArguments(object o)
{
    if (o == null) return;   
    Type t = o.GetType();
    if (!t.IsConstructedGenericType) return;

    foreach(Type genericTypeArgument in t.GetGenericArguments())
        Console.WriteLine(genericTypeArgument.Name);
}

Таким образом, вызов сверху ( ShowGenericArguments(myList) ) приводит к этому выводу:

Int32

Получить общий метод и вызвать его

Предположим, у вас есть класс с общими методами. И вам нужно вызвать его функции с отражением.

public class Sample
{
    public void GenericMethod<T>()
    {
        // ...
    }

    public static void StaticMethod<T>()
    {
        //...
    }
}

Предположим, мы хотим вызвать GenericMethod с строкой типа.

Sample sample = new Sample();//or you can get an instance via reflection

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(typeof(string));
generic.Invoke(sample, null);//Since there are no arguments, we are passing null

Для статического метода вам не нужен экземпляр. Поэтому первый аргумент также будет нулевым.

MethodInfo method = typeof(Sample).GetMethod("StaticMethod");
MethodInfo generic = method.MakeGenericMethod(typeof(string));
generic.Invoke(null, null);

Создайте экземпляр типа Generic и вызовите его метод

var baseType = typeof(List<>);
var genericType = baseType.MakeGenericType(typeof(String));
var instance = Activator.CreateInstance(genericType);
var method = genericType.GetMethod("GetHashCode");
var result = method.Invoke(instance, new object[] { });

Создание экземпляров классов, реализующих интерфейс (например, активация плагина)

Если вы хотите, чтобы ваше приложение поддерживало подключаемую систему, например, для загрузки плагинов из сборок, расположенных в папке plugins :

interface IPlugin
{
    string PluginDescription { get; }
    void DoWork();
}

Этот класс будет располагаться в отдельной dll

class HelloPlugin : IPlugin
{
    public string PluginDescription => "A plugin that says Hello";
    public void DoWork()
    {
        Console.WriteLine("Hello");
    }
}

Плагин-загрузчик вашего приложения найдет файлы DLL, получит все типы в тех сборках, которые реализуют IPlugin , и создаст экземпляры этих файлов.

    public IEnumerable<IPlugin> InstantiatePlugins(string directory)
    {
        var pluginAssemblyNames = Directory.GetFiles(directory, "*.addin.dll").Select(name => new FileInfo(name).FullName).ToArray();
        //load the assemblies into the current AppDomain, so we can instantiate the types later
        foreach (var fileName in pluginAssemblyNames)
            AppDomain.CurrentDomain.Load(File.ReadAllBytes(fileName));
        var assemblies = pluginAssemblyNames.Select(System.Reflection.Assembly.LoadFile);
        var typesInAssembly = assemblies.SelectMany(asm => asm.GetTypes());
        var pluginTypes = typesInAssembly.Where(type => typeof (IPlugin).IsAssignableFrom(type));
        return pluginTypes.Select(Activator.CreateInstance).Cast<IPlugin>(); 
    }

Создание экземпляра типа

Самый простой способ - использовать класс Activator .

Однако, несмотря на то, что производительность Activator была улучшена с .NET 3.5, использование Activator.CreateInstance() иногда является плохим вариантом из-за (относительно) низкой производительности: Test 1 , Test 2 , Test 3 ...

С классом Activator

Type type = typeof(BigInteger);
object result = Activator.CreateInstance(type); //Requires parameterless constructor.
Console.WriteLine(result); //Output: 0
result = Activator.CreateInstance(type, 123); //Requires a constructor which can receive an 'int' compatible argument.
Console.WriteLine(result); //Output: 123

Вы можете передать массив объектов Activator.CreateInstance если у вас есть несколько параметров.

// With a constructor such as MyClass(int, int, string)
Activator.CreateInstance(typeof(MyClass), new object[] { 1, 2, "Hello World" });

Type type = typeof(someObject);
var instance = Activator.CreateInstance(type);

Для общего типа

Метод MakeGenericType превращает открытый общий тип (например, List<> ) в конкретный тип (например, List<string> ), применяя к нему аргументы типа.

// generic List with no parameters
Type openType = typeof(List<>);

// To create a List<string>
Type[] tArgs = { typeof(string) };
Type target = openType.MakeGenericType(tArgs);

// Create an instance - Activator.CreateInstance will call the default constructor.
// This is equivalent to calling new List<string>().
List<string> result = (List<string>)Activator.CreateInstance(target);

Синтаксис List<> не допускается вне выражения typeof .

Без класса Activator

Использование new ключевого слова (сделайте для конструкторов без параметров)

T GetInstance<T>() where T : new()
{
    T instance = new T();
    return instance;
}

Использование метода Invoke

// Get the instance of the desired constructor (here it takes a string as a parameter).
ConstructorInfo c = typeof(T).GetConstructor(new[] { typeof(string) }); 
// Don't forget to check if such constructor exists
if (c == null) 
    throw new InvalidOperationException(string.Format("A constructor for type '{0}' was not found.", typeof(T)));
T instance = (T)c.Invoke(new object[] { "test" });

Использование деревьев выражений

Деревья выражений представляют код в древовидной структуре данных, где каждый узел является выражением. Как объясняет MSDN :

Выражение представляет собой последовательность из одного или нескольких операндов и ноль или более операторов, которые могут быть оценены по одному значению, объекту, методу или пространству имен. Выражения могут состоять из буквального значения, вызова метода, оператора и его операндов или простого имени. Простыми именами могут быть имя переменной, член типа, параметр метода, пространство имен или тип.

public class GenericFactory<TKey, TType>
    {
       private readonly Dictionary<TKey, Func<object[], TType>> _registeredTypes; // dictionary, that holds constructor functions.
       private object _locker = new object(); // object for locking dictionary, to guarantee thread safety

        public GenericFactory()
        {
            _registeredTypes = new Dictionary<TKey, Func<object[], TType>>();
        }

        /// <summary>
        /// Find and register suitable constructor for type
        /// </summary>
        /// <typeparam name="TType"></typeparam>
        /// <param name="key">Key for this constructor</param>
        /// <param name="parameters">Parameters</param>
        public void Register(TKey key, params Type[] parameters)
        {
            ConstructorInfo ci = typeof(TType).GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, CallingConventions.HasThis, parameters, new ParameterModifier[] { }); // Get the instance of ctor.
            if (ci == null)
                throw new InvalidOperationException(string.Format("Constructor for type '{0}' was not found.", typeof(TType)));

            Func<object[], TType> ctor;

            lock (_locker)
            {
                if (!_registeredTypes.TryGetValue(key, out ctor)) // check if such ctor already been registered
                {
                    var pExp = Expression.Parameter(typeof(object[]), "arguments"); // create parameter Expression
                    var ctorParams = ci.GetParameters(); // get parameter info from constructor

                    var argExpressions = new Expression[ctorParams.Length]; // array that will contains parameter expessions
                    for (var i = 0; i < parameters.Length; i++)
                    {

                        var indexedAcccess = Expression.ArrayIndex(pExp, Expression.Constant(i));

                        if (!parameters[i].IsClass && !parameters[i].IsInterface) // check if parameter is a value type
                        {
                            var localVariable = Expression.Variable(parameters[i], "localVariable"); // if so - we should create local variable that will store paraameter value

                            var block = Expression.Block(new[] { localVariable },
                                    Expression.IfThenElse(Expression.Equal(indexedAcccess, Expression.Constant(null)),
                                        Expression.Assign(localVariable, Expression.Default(parameters[i])),
                                        Expression.Assign(localVariable, Expression.Convert(indexedAcccess, parameters[i]))
                                    ),
                                    localVariable
                                );

                            argExpressions[i] = block;

                        }
                        else
                            argExpressions[i] = Expression.Convert(indexedAcccess, parameters[i]);
                    }
                    var newExpr = Expression.New(ci, argExpressions); // create expression that represents call to specified ctor with the specified arguments.
  
                    _registeredTypes.Add(key, Expression.Lambda(newExpr, new[] { pExp }).Compile() as Func<object[], TType>); // compile expression to create delegate, and add fucntion to dictionary
                }
            }
        }

        /// <summary>
        /// Returns instance of registered type by key.
        /// </summary>
        /// <typeparam name="TType"></typeparam>
        /// <param name="key"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public TType Create(TKey key, params object[] args)
        {
            Func<object[], TType> foo;
            if (_registeredTypes.TryGetValue(key, out foo))
            {
                return (TType)foo(args);
            }

            throw new ArgumentException("No type registered for this key.");
        }
    }

Может использоваться следующим образом:

 public class TestClass
 {
        public TestClass(string parameter)
        {
            Console.Write(parameter);
        }
 } 


public void TestMethod()
{
       var factory = new GenericFactory<string, TestClass>();
       factory.Register("key", typeof(string));
       TestClass newInstance = factory.Create("key", "testParameter");
}

Использование FormatterServices.GetUninitializedObject

T instance = (T)FormatterServices.GetUninitializedObject(typeof(T));

В случае использования FormatterServices.GetUninitializedObject конструкторы и инициализаторы полей не будут вызываться. Он предназначен для использования в сериализаторах и удаленных двигателях

Получить тип по имени с пространством имен

Для этого вам нужна ссылка на сборку, которая содержит этот тип. Если у вас есть другой тип, который, как вы знаете, находится в той же сборке, что и тот, который вы хотите, вы можете сделать это:

typeof(KnownType).Assembly.GetType(typeName);

• где typeName - это имя типа, который вы ищете (включая пространство имен), а KnownType - тот тип, который, как вы знаете, находится в той же сборке.

Менее эффективным, но более общим является следующее:

Type t = null;
foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
{
    if (ass.FullName.StartsWith("System."))
        continue;
    t = ass.GetType(typeName);
    if (t != null)
        break;
}

Обратите внимание на проверку, чтобы исключить возможности сканирования системного пространства System namespace для ускорения поиска. Если ваш тип может быть CLR-типом, вам придется удалить эти две строки.

Если у вас есть полное имя типа сборки, включая сборку, вы можете просто получить ее с помощью

Type.GetType(fullyQualifiedName);

Получить строго типизированного делегата для метода или свойства посредством отражения

Когда производительность вызывает беспокойство, вызов метода через отражение (т. MethodInfo.Invoke Методом MethodInfo.Invoke ) не идеален. Тем не менее, относительно просто получить более производительный сильно типизированный делегат, используя функцию Delegate.CreateDelegate . Снижение производительности за использование отражения происходит только во время процесса создания делегата. Как только делегат создан, для его активации есть мало шансов на производительность:

// Get a MethodInfo for the Math.Max(int, int) method...
var maxMethod = typeof(Math).GetMethod("Max", new Type[] { typeof(int), typeof(int) });
// Now get a strongly-typed delegate for Math.Max(int, int)...
var stronglyTypedDelegate = (Func<int, int, int>)Delegate.CreateDelegate(typeof(Func<int, int, int>), null, maxMethod);
// Invoke the Math.Max(int, int) method using the strongly-typed delegate...
Console.WriteLine("Max of 3 and 5 is: {0}", stronglyTypedDelegate(3, 5));

Этот метод можно распространить и на свойства. Если у нас есть класс с именем MyClass с свойством int именем MyIntProperty , то код для получения сильно типизированного getter будет (следующий пример предполагает, что «target» является допустимым экземпляром MyClass ):

// Get a MethodInfo for the MyClass.MyIntProperty getter...
var theProperty = typeof(MyClass).GetProperty("MyIntProperty");
var theGetter = theProperty.GetGetMethod();
// Now get a strongly-typed delegate for MyIntProperty that can be executed against any MyClass instance...
var stronglyTypedGetter = (Func<MyClass, int>)Delegate.CreateDelegate(typeof(Func<MyClass, int>), theGetter);
// Invoke the MyIntProperty getter against MyClass instance 'target'...
Console.WriteLine("target.MyIntProperty is: {0}", stronglyTypedGetter(target));

... и то же самое можно сделать для сеттера:

// Get a MethodInfo for the MyClass.MyIntProperty setter...
var theProperty = typeof(MyClass).GetProperty("MyIntProperty");
var theSetter = theProperty.GetSetMethod();
// Now get a strongly-typed delegate for MyIntProperty that can be executed against any MyClass instance...
var stronglyTypedSetter = (Action<MyClass, int>)Delegate.CreateDelegate(typeof(Action<MyClass, int>), theSetter);
// Set MyIntProperty to 5...
stronglyTypedSetter(target, 5);