C# Language
Odbicie

Wprowadzenie

Uwagi

Uzyskaj System.Type

W przypadku wystąpienia typu:

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

Od samego typu:

var theType = typeof(string);

Zdobądź członków typu

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.");
    }
  }
}

Dane wyjściowe ( patrz uwaga na temat kolejności wyników poniżej ):

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.

Możemy również użyć GetMembers() bez przekazywania BindingFlags . Spowoduje to zwrócenie wszystkich publicznych członków tego określonego typu.

Należy zauważyć, że GetMembers nie zwraca członków w określonej kolejności, więc nigdy nie polegaj na kolejności, w której GetMembers ci zwróci.

Zobacz demo

Uzyskaj metodę i wywołaj ją

Pobierz metodę wystąpienia i wywołaj ją

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);
    }
}

Wynik:

piekło

Zobacz demo

Pobierz metodę statyczną i wywołaj ją

Z drugiej strony, jeśli metoda jest statyczna, nie potrzebujesz instancji, aby ją wywołać.

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

Wynik:

7,38905609893065

Zobacz demo

Pobieranie i ustawianie właściwości

Podstawowe użycie:

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);

Ustawienie właściwości zaimplementowanych automatycznie tylko do odczytu można wykonać za pomocą jego pola kopii zapasowej (w .NET Framework nazwa pola kopii zapasowej to „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);

Niestandardowe atrybuty

Znajdź właściwości z niestandardowym atrybutem - MyAttribute

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

Znajdź wszystkie niestandardowe atrybuty dla danej właściwości

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

Wylicz wszystkie klasy za pomocą niestandardowego atrybutu - MyAttribute

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

Odczytaj wartość niestandardowego atrybutu w czasie wykonywania

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);
        }
    }

Stosowanie

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

Pętla przez wszystkie właściwości klasy

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));
}

Określanie ogólnych argumentów instancji typów ogólnych

Jeśli masz instancję typu ogólnego, ale z jakiegoś powodu nie znasz określonego typu, możesz chcieć określić ogólne argumenty użyte do utworzenia tej instancji.

Powiedzmy, że ktoś stworzył takie wystąpienie List<T> i przekazuje je do metody:

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

gdzie ShowGenericArguments ma ten podpis:

public void ShowGenericArguments(object o)

więc w czasie kompilacji nie masz pojęcia, jakie ogólne argumenty zostały użyte do utworzenia o . Refleksja zapewnia wiele metod kontroli typów ogólnych. Na początku możemy ustalić, czy typ o jest w ogóle typem ogólnym:

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

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

Type.IsGenericType zwraca true jeśli typ jest typem ogólnym, a false jeśli nie.

Ale to nie wszystko, co chcemy wiedzieć. Sama List<> również jest typem ogólnym. Ale chcemy tylko zbadać przypadki określonych skonstruowanych typów ogólnych . Skonstruowany typ ogólny to na przykład List<int> który ma określony typ argumentu dla wszystkich swoich parametrów ogólnych.

Klasa Type udostępnia dwie dodatkowe właściwości, IsConstructedGenericType i IsGenericTypeDefinition , aby odróżnić te zbudowane typy ogólne od definicji typów ogólnych:

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

Aby wyliczyć ogólne argumenty instancji, możemy użyć metody GetGenericArguments() , która zwraca tablicę Type zawierającą ogólne argumenty typu:

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);
}

Tak więc wywołanie z góry ( ShowGenericArguments(myList) ) daje następujące wyniki:

Int32

Uzyskaj ogólną metodę i wywołaj ją

Powiedzmy, że masz klasę z metodami ogólnymi. I musisz wywoływać jego funkcje z refleksją.

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

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

Powiedzmy, że chcemy wywołać GenericMethod z ciągiem znaków.

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

Do metody statycznej nie potrzebujesz instancji. Dlatego pierwszy argument również będzie pusty.

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

Utwórz instancję typu ogólnego i wywołaj jej metodę

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[] { });

Tworzenie instancji klas implementujących interfejs (np. Aktywacja wtyczki)

Jeśli chcesz, aby aplikacja obsługiwała system wtyczek, na przykład ładowała wtyczki z zestawów znajdujących się w folderze plugins :

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

Ta klasa byłaby umieszczona w osobnej bibliotece DLL

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

IPlugin ładujący wtyczkę Twojej aplikacji znalazłby pliki dll, uzyskał wszystkie typy w tych IPlugin , które implementują IPlugin , i utworzyłby ich instancje.

    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>(); 
    }

Tworzenie instancji typu

Najprostszym sposobem jest użycie klasy Activator .

Jednak pomimo poprawy wydajności Activator od .NET 3.5 użycie Activator.CreateInstance() jest czasem złą opcją z powodu (względnie) niskiej wydajności: Test 1 , Test 2 , Test 3 ...

Z klasą 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

Możesz przekazać tablicę obiektów do Activator.CreateInstance jeśli masz więcej niż jeden parametr.

// 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);

Dla typu ogólnego

Metoda MakeGenericType zamienia otwarty typ ogólny (jak List<> ) w konkretny typ (jak List<string> ) poprzez zastosowanie do niego argumentów typu.

// 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);

Składnia List<> nie jest dozwolona poza wyrażeniem typeof .

Bez klasy Activator

Użycie new słowa kluczowego (działa w przypadku konstruktorów bez parametrów)

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

Za pomocą metody 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" });

Korzystanie z drzew wyrażeń

Drzewa wyrażeń reprezentują kod w drzewiastej strukturze danych, gdzie każdy węzeł jest wyrażeniem. Jak wyjaśnia MSDN :

Wyrażenie jest sekwencją jednego lub większej liczby operandów i zerowego lub większej liczby operatorów, które mogą być ocenione jako pojedyncza wartość, obiekt, metoda lub przestrzeń nazw. Wyrażenia mogą składać się z wartości literalnej, wywołania metody, operatora i jego operandów lub prostej nazwy. Prostymi nazwami może być nazwa zmiennej, element typu, parametr metody, przestrzeń nazw lub typ.

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.");
        }
    }

Może być użyty w ten sposób:

 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");
}

Korzystanie z FormatterServices.GetUninitializedObject

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

W przypadku użycia FormatterServices.GetUninitializedObject konstruktory i inicjalizatory pól nie będą wywoływane. Jest przeznaczony do stosowania w serializatorach i silnikach zdalnych

Uzyskaj typ według nazwy z przestrzenią nazw

Aby to zrobić, potrzebujesz odwołania do zestawu, który zawiera typ. Jeśli masz inny typ, o którym wiesz, że jest w tym samym zestawie, co ten, który chcesz, możesz to zrobić:

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

• gdzie typeName jest nazwą typu, którego szukasz (w tym nazw) i KnownType jest typem, wiesz, jest w tym samym zespole.

Mniej wydajne, ale bardziej ogólne, wygląda następująco:

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

Zwróć uwagę na zaznaczenie, aby wykluczyć skanowanie zestawów przestrzeni nazw systemu w celu przyspieszenia wyszukiwania. Jeśli twój typ może być typem CLR, będziesz musiał usunąć te dwa wiersze.

Jeśli masz nazwę typu w pełni kwalifikującą się do złożenia, w tym zestaw, możesz po prostu ją zdobyć

Type.GetType(fullyQualifiedName);

Poprowadź silnie typowanego delegata do metody lub właściwości poprzez odbicie

Gdy wydajność stanowi problem, wywołanie metody za pomocą refleksji (tj. Metody MethodInfo.Invoke ) nie jest idealne. Jednak stosunkowo łatwo jest uzyskać bardziej wydajnego delegata o silnym typie przy użyciu funkcji Delegate.CreateDelegate . Kara wydajnościowa za użycie refleksji jest ponoszona tylko podczas procesu tworzenia delegata. Po utworzeniu delegata istnieje niewielka lub żadna kara za wydajność za jej wywołanie:

// 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));

Technikę tę można również rozszerzyć na właściwości. Jeśli mamy klasę o nazwie MyClass z właściwością int nazwie MyIntProperty , kodem pozwalającym uzyskać silnie typowany getter byłby (w poniższym przykładzie założono, że „target” jest prawidłową instancją 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));

... i to samo można zrobić dla setera:

// 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);