MethodBase.Invoke Metoda

Definicja

Przestrzeń nazw:

System.Reflection

Zestawy:

netstandard.dll, System.Runtime.dll

Wywołuje metodę lub konstruktor odzwierciedlone przez to MethodInfo wystąpienie.

Przeciążenia

Invoke(Object, Object[])	Wywołuje metodę lub konstruktor reprezentowany przez bieżące wystąpienie przy użyciu określonych parametrów.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Podczas zastępowania w klasie pochodnej wywołuje odbitą metodę lub konstruktor z podanymi parametrami.

Invoke(Object, Object[])

Źródło:

MethodBase.cs

Wywołuje metodę lub konstruktor reprezentowany przez bieżące wystąpienie przy użyciu określonych parametrów.

C#

public object? Invoke(object? obj, object?[]? parameters);

Parametry

obj

Object

Obiekt, na którym należy wywołać metodę lub konstruktor. Jeśli metoda jest statyczna, ten argument jest ignorowany. Jeśli konstruktor jest statyczny, ten argument musi być null lub wystąpieniem klasy definiującej konstruktor.

parameters

Object[]

Lista argumentów dla wywoływanej metody lub konstruktora. Jest to tablica obiektów o tej samej liczbie, kolejności i typie co parametry metody lub konstruktora do wywołania. Jeśli nie ma parametrów, parameters powinien mieć wartość null.

Jeśli metoda lub konstruktor reprezentowany przez to wystąpienie przyjmuje ref parametr (ByRef w Visual Basic), żaden atrybut specjalny nie jest wymagany dla tego parametru w celu wywołania metody lub konstruktora przy użyciu tej funkcji. Każdy obiekt w tej tablicy, który nie jest jawnie zainicjowany z wartością, będzie zawierać wartość domyślną dla tego typu obiektu. W przypadku elementów typu odwołania ta wartość to null. W przypadku elementów typu wartości wartość domyślna to 0, 0,0 lub false, w zależności od określonego typu elementu.

Zwraca

Object

Obiekt zawierający wartość zwracaną wywoływanej metody lub null w przypadku konstruktora.

Wyjątki

TargetException

Parametr obj to null , a metoda nie jest statyczna.

-lub-

Metoda nie jest zadeklarowana ani dziedziczona przez klasę obj.

-lub-

Wywoływany jest konstruktor statyczny i obj nie jest ani null wystąpieniem klasy, która zadeklarowała konstruktor.

Uwaga: w programie .NET dla aplikacji ze Sklepu Windows lub w bibliotece klas przenośnych przechwyć Exception zamiast tego.

ArgumentException

Elementy parameters tablicy nie pasują do podpisu metody lub konstruktora odzwierciedlonego przez to wystąpienie.

TargetInvocationException

Wywołana metoda lub konstruktor zgłasza wyjątek.

-lub-

Bieżące wystąpienie jest elementem zawierającym DynamicMethod nieweryfikowalny kod. Zobacz sekcję "Weryfikacja" w uwagach dotyczących DynamicMethodelementu .

TargetParameterCountException

Tablica parameters nie ma poprawnej liczby argumentów.

MethodAccessException

Obiekt wywołujący nie ma uprawnień do wykonywania metody lub konstruktora reprezentowanego przez bieżące wystąpienie.

Uwaga: na platformie .NET dla aplikacji ze Sklepu Windows lub biblioteki klas przenośnych przechwyć wyjątek klasy bazowej , MemberAccessExceptionzamiast tego.

InvalidOperationException

Typ, który deklaruje metodę, jest otwartym typem ogólnym. Oznacza to, że ContainsGenericParameters właściwość jest zwracana true dla typu deklarowania.

NotSupportedException

Bieżące wystąpienie to MethodBuilder.

Przykłady

W poniższym przykładzie kodu pokazano dynamiczne wyszukiwanie metody przy użyciu odbicia. Należy pamiętać, że nie można użyć MethodInfo obiektu z klasy bazowej, aby wywołać metodę przesłoniętą w klasie pochodnej, ponieważ opóźnione powiązanie nie może rozpoznać przesłonięć.

C#

using System;
using System.Reflection;

public class MagicClass
{
    private int magicBaseValue;

    public MagicClass()
    {
        magicBaseValue = 9;
    }

    public int ItsMagic(int preMagic)
    {
        return preMagic * magicBaseValue;
    }
}

public class TestMethodInfo
{
    public static void Main()
    {
        // Get the constructor and create an instance of MagicClass

        Type magicType = Type.GetType("MagicClass");
        ConstructorInfo magicConstructor = magicType.GetConstructor(Type.EmptyTypes);
        object magicClassObject = magicConstructor.Invoke(new object[]{});

        // Get the ItsMagic method and invoke with a parameter value of 100

        MethodInfo magicMethod = magicType.GetMethod("ItsMagic");
        object magicValue = magicMethod.Invoke(magicClassObject, new object[]{100});

        Console.WriteLine("MethodInfo.Invoke() Example\n");
        Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue);
    }
}

// The example program gives the following output:
//
// MethodInfo.Invoke() Example
//
// MagicClass.ItsMagic() returned: 900

Uwagi

Jest to metoda wygody, która wywołuje Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) przeciążenie metody, przekazując Default wartości invokeAttr i dla binder i culturenull .

Jeśli wywołana metoda zgłasza wyjątek, Exception.GetBaseException metoda zwraca wyjątek źródłowy.

Aby wywołać metodę statyczną przy użyciu jej MethodInfo obiektu, przekaż null dla objmetody .

Uwaga

Jeśli to przeciążenie metody jest używane do wywoływania konstruktora wystąpienia, obiekt dostarczony dla obj jest ponownie inicjowany. Oznacza to, że wszystkie inicjatory wystąpień są wykonywane. Zwracana wartość to null. Jeśli wywoływany jest konstruktor klasy, klasa jest ponownie inicjowana; oznacza to, że wszystkie inicjatory klas są wykonywane. Zwracana wartość to null.

Uwaga

Począwszy od programu .NET Framework 2.0, ta metoda może służyć do uzyskiwania dostępu do elementów członkowskich innych niż publiczne, jeśli obiekt wywołujący otrzymał ReflectionPermission flagę ReflectionPermissionFlag.RestrictedMemberAccess i jeśli zestaw dotacji niepublicyjnych członków jest ograniczony do zestawu dotacji obiektu wywołującego lub jego podzbioru. (Zobacz Zagadnienia dotyczące zabezpieczeń dotyczące odbicia). Aby korzystać z tej funkcji, aplikacja powinna być docelowa dla programu .NET Framework 3.5 lub nowszego.

Jeśli parametr metody odzwierciedlonej jest typem wartości, a odpowiadający mu argument w parameters metodzie to null, środowisko uruchomieniowe przekazuje wystąpienie typu wartości zainicjowane przez zero.

Zobacz też

• BindingFlags
• Missing
• InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Źródło:

MethodBase.cs

Po zastąpieniu w klasie pochodnej wywołuje odzwierciedlonej metody lub konstruktora z podanymi parametrami.

C#

public abstract object? Invoke(object? obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object?[]? parameters, System.Globalization.CultureInfo? culture);

Parametry

obj

Object

Obiekt, na którym należy wywołać metodę lub konstruktor. Jeśli metoda jest statyczna, ten argument jest ignorowany. Jeśli konstruktor jest statyczny, ten argument musi być null lub wystąpieniem klasy definiującej konstruktor.

invokeAttr

BindingFlags

Maska bitów, która jest kombinacją flag 0 lub więcej bitów z .BindingFlags

binder

Binder

Obiekt, który umożliwia powiązanie, przymus typów argumentów, wywołanie elementów członkowskich i pobieranie MemberInfo obiektów za pośrednictwem odbicia. Jeśli binder parametr ma nullwartość , jest używany domyślny binder.

parameters

Object[]

Lista argumentów dla wywoływanej metody lub konstruktora. Jest to tablica obiektów o tej samej liczbie, kolejności i typie co parametry metody lub konstruktora do wywołania. Jeśli nie ma parametrów, powinna to być nullwartość .

Jeśli metoda lub konstruktor reprezentowany przez to wystąpienie przyjmuje parametr ByRef, nie ma specjalnego atrybutu wymaganego dla tego parametru w celu wywołania metody lub konstruktora przy użyciu tej funkcji. Każdy obiekt w tej tablicy, który nie jest jawnie zainicjowany z wartością, będzie zawierać wartość domyślną dla tego typu obiektu. W przypadku elementów typu odwołania ta wartość to null. W przypadku elementów typu wartości ta wartość to 0, 0,0 lub false, w zależności od określonego typu elementu.

culture

CultureInfo

Wystąpienie używane do nadzorowania CultureInfo przymusu typów. Jeśli jest nullto wartość , CultureInfo używany jest element dla bieżącego wątku. (Jest to konieczne, aby przekonwertować ciąg reprezentujący 1000 na Double wartość, na przykład ponieważ 1000 jest reprezentowane inaczej przez różne kultury).

Zwraca

Object

Element Object zawierający wartość zwracaną metody wywoływanej lub null w przypadku konstruktora lub null jeśli zwracany typ metody to void. Przed wywołaniem metody lub konstruktora sprawdza, Invoke czy użytkownik ma uprawnienia dostępu i sprawdza, czy parametry są prawidłowe.

Wyjątki

TargetException

Parametr obj to null , a metoda nie jest statyczna.

-lub-

Metoda nie jest zadeklarowana ani dziedziczona przez klasę obj.

-lub-

Wywoływany jest konstruktor statyczny i obj nie jest ani null wystąpieniem klasy, która zadeklarowała konstruktor.

ArgumentException

Typ parametru parameters nie jest zgodny z podpisem metody lub konstruktora odzwierciedlonego przez to wystąpienie.

TargetParameterCountException

Tablica parameters nie ma poprawnej liczby argumentów.

TargetInvocationException

Wywołana metoda lub konstruktor zgłasza wyjątek.

MethodAccessException

Obiekt wywołujący nie ma uprawnień do wykonywania metody lub konstruktora reprezentowanego przez bieżące wystąpienie.

InvalidOperationException

Typ, który deklaruje metodę, jest otwartym typem ogólnym. Oznacza to, że ContainsGenericParameters właściwość jest zwracana true dla typu deklarowania.

Przykłady

W poniższym przykładzie pokazano wszystkie składowe System.Reflection.Binder klasy przy użyciu przeciążenia klasy Type.InvokeMember. Metoda CanConvertFrom prywatna znajduje zgodne typy dla danego typu. Aby zapoznać się z innym przykładem wywoływania elementów członkowskich w scenariuszu powiązania niestandardowego, zobacz Dynamiczne ładowanie i używanie typów.

C#

using System;
using System.Reflection;
using System.Globalization;

public class MyBinder : Binder
{
    public MyBinder() : base()
    {
    }
    private class BinderState
    {
        public object[] args;
    }
    public override FieldInfo BindToField(
        BindingFlags bindingAttr,
        FieldInfo[] match,
        object value,
        CultureInfo culture
        )
    {
        if(match == null)
            throw new ArgumentNullException("match");
        // Get a field for which the value parameter can be converted to the specified field type.
        for(int i = 0; i < match.Length; i++)
            if(ChangeType(value, match[i].FieldType, culture) != null)
                return match[i];
        return null;
    }
    public override MethodBase BindToMethod(
        BindingFlags bindingAttr,
        MethodBase[] match,
        ref object[] args,
        ParameterModifier[] modifiers,
        CultureInfo culture,
        string[] names,
        out object state
        )
    {
        // Store the arguments to the method in a state object.
        BinderState myBinderState = new BinderState();
        object[] arguments = new Object[args.Length];
        args.CopyTo(arguments, 0);
        myBinderState.args = arguments;
        state = myBinderState;
        if(match == null)
            throw new ArgumentNullException();
        // Find a method that has the same parameters as those of the args parameter.
        for(int i = 0; i < match.Length; i++)
        {
            // Count the number of parameters that match.
            int count = 0;
            ParameterInfo[] parameters = match[i].GetParameters();
            // Go on to the next method if the number of parameters do not match.
            if(args.Length != parameters.Length)
                continue;
            // Match each of the parameters that the user expects the method to have.
            for(int j = 0; j < args.Length; j++)
            {
                // If the names parameter is not null, then reorder args.
                if(names != null)
                {
                    if(names.Length != args.Length)
                        throw new ArgumentException("names and args must have the same number of elements.");
                    for(int k = 0; k < names.Length; k++)
                        if(String.Compare(parameters[j].Name, names[k].ToString()) == 0)
                            args[j] = myBinderState.args[k];
                }
                // Determine whether the types specified by the user can be converted to the parameter type.
                if(ChangeType(args[j], parameters[j].ParameterType, culture) != null)
                    count += 1;
                else
                    break;
            }
            // Determine whether the method has been found.
            if(count == args.Length)
                return match[i];
        }
        return null;
    }
    public override object ChangeType(
        object value,
        Type myChangeType,
        CultureInfo culture
        )
    {
        // Determine whether the value parameter can be converted to a value of type myType.
        if(CanConvertFrom(value.GetType(), myChangeType))
            // Return the converted object.
            return Convert.ChangeType(value, myChangeType);
        else
            // Return null.
            return null;
    }
    public override void ReorderArgumentArray(
        ref object[] args,
        object state
        )
    {
        // Return the args that had been reordered by BindToMethod.
        ((BinderState)state).args.CopyTo(args, 0);
    }
    public override MethodBase SelectMethod(
        BindingFlags bindingAttr,
        MethodBase[] match,
        Type[] types,
        ParameterModifier[] modifiers
        )
    {
        if(match == null)
            throw new ArgumentNullException("match");
        for(int i = 0; i < match.Length; i++)
        {
            // Count the number of parameters that match.
            int count = 0;
            ParameterInfo[] parameters = match[i].GetParameters();
            // Go on to the next method if the number of parameters do not match.
            if(types.Length != parameters.Length)
                continue;
            // Match each of the parameters that the user expects the method to have.
            for(int j = 0; j < types.Length; j++)
                // Determine whether the types specified by the user can be converted to parameter type.
                if(CanConvertFrom(types[j], parameters[j].ParameterType))
                    count += 1;
                else
                    break;
            // Determine whether the method has been found.
            if(count == types.Length)
                return match[i];
        }
        return null;
    }
    public override PropertyInfo SelectProperty(
        BindingFlags bindingAttr,
        PropertyInfo[] match,
        Type returnType,
        Type[] indexes,
        ParameterModifier[] modifiers
        )
    {
        if(match == null)
            throw new ArgumentNullException("match");
        for(int i = 0; i < match.Length; i++)
        {
            // Count the number of indexes that match.
            int count = 0;
            ParameterInfo[] parameters = match[i].GetIndexParameters();
            // Go on to the next property if the number of indexes do not match.
            if(indexes.Length != parameters.Length)
                continue;
            // Match each of the indexes that the user expects the property to have.
            for(int j = 0; j < indexes.Length; j++)
                // Determine whether the types specified by the user can be converted to index type.
                if(CanConvertFrom(indexes[j], parameters[j].ParameterType))
                    count += 1;
                else
                    break;
            // Determine whether the property has been found.
            if(count == indexes.Length)
                // Determine whether the return type can be converted to the properties type.
                if(CanConvertFrom(returnType, match[i].PropertyType))
                    return match[i];
                else
                    continue;
        }
        return null;
    }
    // Determines whether type1 can be converted to type2. Check only for primitive types.
    private bool CanConvertFrom(Type type1, Type type2)
    {
        if(type1.IsPrimitive && type2.IsPrimitive)
        {
            TypeCode typeCode1 = Type.GetTypeCode(type1);
            TypeCode typeCode2 = Type.GetTypeCode(type2);
            // If both type1 and type2 have the same type, return true.
            if(typeCode1 == typeCode2)
                return true;
            // Possible conversions from Char follow.
            if(typeCode1 == TypeCode.Char)
                switch(typeCode2)
                {
                    case TypeCode.UInt16 : return true;
                    case TypeCode.UInt32 : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Byte follow.
            if(typeCode1 == TypeCode.Byte)
                switch(typeCode2)
                {
                    case TypeCode.Char   : return true;
                    case TypeCode.UInt16 : return true;
                    case TypeCode.Int16  : return true;
                    case TypeCode.UInt32 : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from SByte follow.
            if(typeCode1 == TypeCode.SByte)
                switch(typeCode2)
                {
                    case TypeCode.Int16  : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from UInt16 follow.
            if(typeCode1 == TypeCode.UInt16)
                switch(typeCode2)
                {
                    case TypeCode.UInt32 : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Int16 follow.
            if(typeCode1 == TypeCode.Int16)
                switch(typeCode2)
                {
                    case TypeCode.Int32  : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from UInt32 follow.
            if(typeCode1 == TypeCode.UInt32)
                switch(typeCode2)
                {
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Int32 follow.
            if(typeCode1 == TypeCode.Int32)
                switch(typeCode2)
                {
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from UInt64 follow.
            if(typeCode1 == TypeCode.UInt64)
                switch(typeCode2)
                {
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Int64 follow.
            if(typeCode1 == TypeCode.Int64)
                switch(typeCode2)
                {
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Single follow.
            if(typeCode1 == TypeCode.Single)
                switch(typeCode2)
                {
                    case TypeCode.Double : return true;
                    default              : return false;
                }
        }
        return false;
    }
}
public class MyClass1
{
    public short myFieldB;
    public int myFieldA;
    public void MyMethod(long i, char k)
    {
        Console.WriteLine("\nThis is MyMethod(long i, char k)");
    }
    public void MyMethod(long i, long j)
    {
        Console.WriteLine("\nThis is MyMethod(long i, long j)");
    }
}
public class Binder_Example
{
    public static void Main()
    {
        // Get the type of MyClass1.
        Type myType = typeof(MyClass1);
        // Get the instance of MyClass1.
        MyClass1 myInstance = new MyClass1();
        Console.WriteLine("\nDisplaying the results of using the MyBinder binder.\n");
        // Get the method information for MyMethod.
        MethodInfo myMethod = myType.GetMethod("MyMethod", BindingFlags.Public | BindingFlags.Instance,
            new MyBinder(), new Type[] {typeof(short), typeof(short)}, null);
        Console.WriteLine(myMethod);
        // Invoke MyMethod.
        myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, new MyBinder(), new Object[] {(int)32, (int)32}, CultureInfo.CurrentCulture);
    }
}

Uwagi

Ta metoda dynamicznie wywołuje metodę odzwierciedlona przez to wystąpienie w obiekcie obji przekazuje określone parametry. Jeśli metoda jest statyczna, obj parametr jest ignorowany. W przypadku metod obj niestacyjnych należy być wystąpieniem klasy, która dziedziczy lub deklaruje metodę i musi być tym samym typem co ta klasa. Jeśli metoda nie ma parametrów, wartość powinna mieć nullwartość parameters . W przeciwnym razie liczba, typ i kolejność elementów w parameters obiekcie powinny być identyczne z liczbą, typem i kolejnością parametrów dla metody odzwierciedlanej przez to wystąpienie.

Nie można pominąć parametrów opcjonalnych w wywołaniach do elementu Invoke. Aby wywołać metodę i pominąć parametry opcjonalne, wywołaj zamiast tego wywołaj Type.InvokeMember metodę.

Uwaga

Jeśli to przeciążenie metody jest używane do wywoływania konstruktora wystąpienia, obiekt dostarczony dla obj jest ponownie inicjowany. Oznacza to, że wszystkie inicjatory wystąpień są wykonywane. Zwracana wartość to null. Jeśli wywoływany jest konstruktor klasy, klasa jest ponownie inicjowana; oznacza to, że wszystkie inicjatory klas są wykonywane. Zwracana wartość to null.

W przypadku parametrów pierwotnych pass-by-value wykonywane jest normalne rozszerzanie (na przykład Int16 —> Int32). W przypadku parametrów referencyjnych typu pass-by-value dozwolone jest normalne rozszerzanie odwołania (klasa pochodna do klasy bazowej i klasa bazowa na typ interfejsu). Jednak w przypadku parametrów pierwotnych typu pass-by-reference typy muszą być dokładnie zgodne. W przypadku parametrów odwołania przekazywanego po odwołaniu nadal ma zastosowanie normalne rozszerzanie.

Jeśli na przykład metoda odzwierciedlana przez to wystąpienie jest zadeklarowana jako public boolean Compare(String a, String b), parameters powinna być tablicą o Objects długości 2, tak aby parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").

Jeśli parametr bieżącej metody jest typem wartości, a odpowiadający mu argument w parameters metodzie to null, środowisko uruchomieniowe przekazuje wystąpienie typu wartości zainicjowane przez zero.

Odbicie używa dynamicznego wyszukiwania metody podczas wywoływania metod wirtualnych. Załóżmy na przykład, że klasa B dziedziczy z klasy A i implementuje metodę wirtualną o nazwie M. Załóżmy teraz, że masz MethodInfo obiekt reprezentujący język M w klasie A. Jeśli używasz Invoke metody do wywołania języka M na obiekcie typu B, odbicie użyje implementacji podanej przez klasę B. Nawet jeśli obiekt typu B jest rzutowany na A, jest używana implementacja podana przez klasę B (zobacz przykładowy kod poniżej).

Z drugiej strony, jeśli metoda jest inna niż wirtualna, odbicie użyje implementacji podanej przez typ, z którego MethodInfo został uzyskany, niezależnie od typu obiektu przekazanego jako obiekt docelowy.

Ograniczenia dostępu są ignorowane dla w pełni zaufanego kodu. Oznacza to, że prywatne konstruktory, metody, pola i właściwości mogą być dostępne i wywoływane za pośrednictwem odbicia, gdy kod jest w pełni zaufany.

Jeśli wywołana metoda zgłasza wyjątek, Exception.GetBaseException metoda zwraca wyjątek źródłowy.

Uwaga

Począwszy od programu .NET Framework 2.0, ta metoda może służyć do uzyskiwania dostępu do niepublizowanych elementów członkowskich, jeśli obiekt wywołujący otrzymał ReflectionPermissionReflectionPermissionFlag.RestrictedMemberAccess flagę, a zestaw dotacji niepublizowanych członków jest ograniczony do zestawu dotacji obiektu wywołującego lub jego podzbioru. (Zobacz Zagadnienia dotyczące zabezpieczeń do odbicia). Aby korzystać z tej funkcji, aplikacja powinna być docelowa dla programu .NET Framework 3.5 lub nowszego.

Zobacz też

• InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
• Dynamiczne ładowanie i używanie typów