using System;
using System.Globalization;
using System.Runtime.InteropServices;
using Cpp2IlInjected;
namespace System.Reflection
{
/// Selects a member from a list of candidates, and performs type conversion from actual argument type to formal argument type.
// Token: 0x02000215 RID: 533
[Token(Token = "0x2000215")]
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.AutoDual)]
[Serializable]
public abstract class Binder
{
/// Selects a method to invoke from the given set of methods, based on the supplied arguments.
/// A bitwise combination of values.
/// The set of methods that are candidates for matching. For example, when a object is used by , this parameter specifies the set of methods that reflection has determined to be possible matches, typically because they have the correct member name. The default implementation provided by changes the order of this array.
/// The arguments that are passed in. The binder can change the order of the arguments in this array; for example, the default binder changes the order of arguments if the parameter is used to specify an order other than positional order. If a binder implementation coerces argument types, the types and values of the arguments can be changed as well.
/// An array of parameter modifiers that enable binding to work with parameter signatures in which the types have been modified. The default binder implementation does not use this parameter.
/// An instance of that is used to control the coercion of data types, in binder implementations that coerce types. If is , the for the current thread is used.
/// Note For example, if a binder implementation allows coercion of string values to numeric types, this parameter is necessary to convert a that represents 1000 to a value, because 1000 is represented differently by different cultures. The default binder does not do such string coercions.
/// The parameter names, if parameter names are to be considered when matching, or if arguments are to be treated as purely positional. For example, parameter names must be used if arguments are not supplied in positional order.
/// After the method returns, contains a binder-provided object that keeps track of argument reordering. The binder creates this object, and the binder is the sole consumer of this object. If is not when returns, you must pass to the method if you want to restore to its original order, for example, so that you can retrieve the values of parameters ( parameters in Visual Basic).
/// The matching method.
/// For the default binder, contains multiple methods that are equally good matches for . For example, contains a MyClass object that implements the IMyClass interface, and contains a method that takes MyClass and a method that takes IMyClass.
/// For the default binder, contains no methods that can accept the arguments supplied in .
/// For the default binder, is or an empty array.
// Token: 0x060013C5 RID: 5061
[Token(Token = "0x60013C5")]
[Address(Slot = "4")]
public abstract MethodBase BindToMethod(BindingFlags bindingAttr, MethodBase[] match, ref object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] names, out object state);
/// Selects a field from the given set of fields, based on the specified criteria.
/// A bitwise combination of values.
/// The set of fields that are candidates for matching. For example, when a object is used by , this parameter specifies the set of fields that reflection has determined to be possible matches, typically because they have the correct member name. The default implementation provided by changes the order of this array.
/// The field value used to locate a matching field.
/// An instance of that is used to control the coercion of data types, in binder implementations that coerce types. If is , the for the current thread is used.
/// Note For example, if a binder implementation allows coercion of string values to numeric types, this parameter is necessary to convert a that represents 1000 to a value, because 1000 is represented differently by different cultures. The default binder does not do such string coercions.
/// The matching field.
/// For the default binder, includes , and contains multiple fields that are equally good matches for . For example, contains a MyClass object that implements the IMyClass interface, and contains a field of type MyClass and a field of type IMyClass.
/// For the default binder, includes , and contains no fields that can accept .
/// For the default binder, includes , and is or an empty array.
/// -or-
/// includes , and is .
// Token: 0x060013C6 RID: 5062
[Token(Token = "0x60013C6")]
[Address(Slot = "5")]
public abstract FieldInfo BindToField(BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo culture);
/// Selects a method from the given set of methods, based on the argument type.
/// A bitwise combination of values.
/// The set of methods that are candidates for matching. For example, when a object is used by , this parameter specifies the set of methods that reflection has determined to be possible matches, typically because they have the correct member name. The default implementation provided by changes the order of this array.
/// The parameter types used to locate a matching method.
/// An array of parameter modifiers that enable binding to work with parameter signatures in which the types have been modified.
/// The matching method, if found; otherwise, .
/// For the default binder, contains multiple methods that are equally good matches for the parameter types described by . For example, the array in contains a object for MyClass and the array in contains a method that takes a base class of MyClass and a method that takes an interface that MyClass implements.
/// For the default binder, is or an empty array.
/// -or-
/// An element of derives from , but is not of type .
// Token: 0x060013C7 RID: 5063
[Token(Token = "0x60013C7")]
[Address(Slot = "6")]
public abstract MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers);
/// Selects a property from the given set of properties, based on the specified criteria.
/// A bitwise combination of values.
/// The set of properties that are candidates for matching. For example, when a object is used by , this parameter specifies the set of properties that reflection has determined to be possible matches, typically because they have the correct member name. The default implementation provided by changes the order of this array.
/// The return value the matching property must have.
/// The index types of the property being searched for. Used for index properties such as the indexer for a class.
/// An array of parameter modifiers that enable binding to work with parameter signatures in which the types have been modified.
/// The matching property.
/// For the default binder, contains multiple properties that are equally good matches for and .
/// For the default binder, is or an empty array.
// Token: 0x060013C8 RID: 5064
[Token(Token = "0x60013C8")]
[Address(Slot = "7")]
public abstract PropertyInfo SelectProperty(BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers);
/// Changes the type of the given to the given .
/// The object to change into a new .
/// The new that will become.
/// An instance of that is used to control the coercion of data types. If is , the for the current thread is used.
/// Note For example, this parameter is necessary to convert a that represents 1000 to a value, because 1000 is represented differently by different cultures.
/// An object that contains the given value as the new type.
// Token: 0x060013C9 RID: 5065
[Token(Token = "0x60013C9")]
[Address(Slot = "8")]
public abstract object ChangeType(object value, Type type, CultureInfo culture);
/// Upon returning from , restores the argument to what it was when it came from .
/// The actual arguments that are passed in. Both the types and values of the arguments can be changed.
/// A binder-provided object that keeps track of argument reordering.
// Token: 0x060013CA RID: 5066
[Token(Token = "0x60013CA")]
[Address(Slot = "9")]
public abstract void ReorderArgumentArray(ref object[] args, object state);
/// Initializes a new instance of the class.
// Token: 0x060013CB RID: 5067 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60013CB")]
[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080")]
protected Binder()
{
}
}
}