public static String ComputeToString(MethodBase contextMethod, RuntimeType[] methodTypeArguments, RuntimeParameterInfo[] runtimeParametersAndReturn)
{
StringBuilder sb = new StringBuilder(30);
sb.Append(runtimeParametersAndReturn[0].ParameterTypeString);
sb.Append(' ');
sb.Append(contextMethod.Name);
if (methodTypeArguments.Length != 0)
{
String sep = "";
sb.Append('[');
foreach (RuntimeType methodTypeArgument in methodTypeArguments)
{
sb.Append(sep);
sep = ",";
String name = methodTypeArgument.InternalNameIfAvailable;
if (name == null)
name = ToStringUtils.UnavailableType;
sb.Append(methodTypeArgument.Name);
}
sb.Append(']');
}
sb.Append('(');
sb.Append(ComputeParametersString(runtimeParametersAndReturn, 1));
sb.Append(')');
return sb.ToString();
}
//
// Returns the ParameterInfo objects for the method parameters and return parameter.
//
// The ParameterInfo objects will report "contextMethod" as their Member property and use it to get type variable information from
// the contextMethod's declaring type. The actual metadata, however, comes from "this."
//
// The methodTypeArguments provides the fill-ins for any method type variable elements in the parameter type signatures.
//
// Does not array-copy.
//
public RuntimeParameterInfo[] GetRuntimeParameters(MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments, out RuntimeParameterInfo returnParameter)
{
MetadataReader reader = _reader;
TypeContext typeContext = contextMethod.DeclaringType.CastToRuntimeTypeInfo().TypeContext;
typeContext = new TypeContext(typeContext.GenericTypeArguments, methodTypeArguments);
MethodSignature methodSignature = this.MethodSignature;
Handle[] typeSignatures = new Handle[methodSignature.Parameters.Count + 1];
typeSignatures[0] = methodSignature.ReturnType;
int paramIndex = 1;
foreach (Handle parameterTypeSignatureHandle in methodSignature.Parameters)
{
typeSignatures[paramIndex++] = parameterTypeSignatureHandle;
}
int count = typeSignatures.Length;
VirtualRuntimeParameterInfoArray result = new VirtualRuntimeParameterInfoArray(count);
foreach (ParameterHandle parameterHandle in _method.Parameters)
{
Parameter parameterRecord = parameterHandle.GetParameter(_reader);
int index = parameterRecord.Sequence;
result[index] =
RuntimeFatMethodParameterInfo.GetRuntimeFatMethodParameterInfo(
contextMethod,
_methodHandle,
index - 1,
parameterHandle,
reader,
typeSignatures[index],
typeContext);
}
for (int i = 0; i < count; i++)
{
if (result[i] == null)
{
result[i] =
RuntimeThinMethodParameterInfo.GetRuntimeThinMethodParameterInfo(
contextMethod,
i - 1,
reader,
typeSignatures[i],
typeContext);
}
}
returnParameter = result.First;
return result.Remainder;
}
//
// private implementation
//
internal ParameterInfo[] LoadParameters() {
if (m_parameters == null) {
Type[] parameterTypes = m_owner.m_parameterTypes;
ParameterInfo[] parameters = new ParameterInfo[parameterTypes.Length];
for (int i = 0; i < parameterTypes.Length; i++)
parameters[i] = new RuntimeParameterInfo(this, null, parameterTypes[i], i);
if (m_parameters == null)
// should we interlockexchange?
m_parameters = parameters;
}
return m_parameters;
}
public sealed override String ToString()
{
StringBuilder sb = new StringBuilder(30);
ReflectionDomain reflectionDomain = _contextTypeInfo.ReflectionDomain;
TypeContext typeContext = _contextTypeInfo.TypeContext;
Handle typeHandle = _property.Signature.GetPropertySignature(_reader).Type;
sb.Append(typeHandle.FormatTypeName(_reader, typeContext, reflectionDomain));
sb.Append(' ');
sb.Append(this.Name);
ParameterInfo[] indexParameters = this.GetIndexParameters();
if (indexParameters.Length != 0)
{
RuntimeParameterInfo[] indexRuntimeParameters = new RuntimeParameterInfo[indexParameters.Length];
for (int i = 0; i < indexParameters.Length; i++)
indexRuntimeParameters[i] = (RuntimeParameterInfo)(indexParameters[i]);
sb.Append(" [");
sb.Append(RuntimeMethodCommon.ComputeParametersString(indexRuntimeParameters, 0));
sb.Append(']');
}
return sb.ToString();
}
internal override sealed RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
return _common.GetRuntimeParameters(contextMethod, contextMethod.RuntimeGenericArgumentsOrParameters, out returnParameter);
}
internal sealed override RuntimeParameterInfo[] GetRuntimeParametersAndReturn(RuntimeMethodInfo contextMethod)
{
RuntimeParameterInfo[] runtimeParametersAndReturn = _lazyRuntimeParametersAndReturn;
if (runtimeParametersAndReturn == null)
{
runtimeParametersAndReturn = new RuntimeParameterInfo[_runtimeParameterTypesAndReturn.Length];
for (int i = 0; i < runtimeParametersAndReturn.Length; i++)
{
runtimeParametersAndReturn[i] = RuntimeSyntheticParameterInfo.GetRuntimeSyntheticParameterInfo(this, i - 1, _runtimeParameterTypesAndReturn[i]);
}
_lazyRuntimeParametersAndReturn = runtimeParametersAndReturn;
}
return runtimeParametersAndReturn;
}
internal static String ComputeToString(MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments, RuntimeParameterInfo[] parameters, RuntimeParameterInfo returnParameter)
{
StringBuilder sb = new StringBuilder(30);
sb.Append(returnParameter == null ? "Void" : returnParameter.ParameterTypeString); // ConstructorInfos allowed to pass in null rather than craft a ReturnParameterInfo that's always of type void.
sb.Append(' ');
sb.Append(contextMethod.Name);
if (methodTypeArguments.Length != 0)
{
String sep = "";
sb.Append('[');
foreach (RuntimeTypeInfo methodTypeArgument in methodTypeArguments)
{
sb.Append(sep);
sep = ",";
String name = methodTypeArgument.InternalNameIfAvailable;
if (name == null)
{
name = ToStringUtils.UnavailableType;
}
sb.Append(methodTypeArgument.Name);
}
sb.Append(']');
}
sb.Append('(');
sb.Append(ComputeParametersString(parameters));
sb.Append(')');
return(sb.ToString());
}
internal sealed override RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
RuntimeTypeInfo[] runtimeParameterTypes = _runtimeParameterTypes;
RuntimeParameterInfo[] parameters = new RuntimeParameterInfo[runtimeParameterTypes.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = RuntimeSyntheticParameterInfo.GetRuntimeSyntheticParameterInfo(this, i, runtimeParameterTypes[i]);
}
returnParameter = RuntimeSyntheticParameterInfo.GetRuntimeSyntheticParameterInfo(this, -1, _returnType);
return(parameters);
}
//
// Returns the ParameterInfo objects for the method parameters and return parameter.
//
// The ParameterInfo objects will report "contextMethod" as their Member property and use it to get type variable information from
// the contextMethod's declaring type. The actual metadata, however, comes from "this."
//
// The methodTypeArguments provides the fill-ins for any method type variable elements in the parameter type signatures.
//
// Does not array-copy.
//
public RuntimeParameterInfo[] GetRuntimeParameters(MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments, out RuntimeParameterInfo returnParameter)
{
MetadataReader reader = _reader;
TypeContext typeContext = contextMethod.DeclaringType.CastToRuntimeTypeInfo().TypeContext;
typeContext = new TypeContext(typeContext.GenericTypeArguments, methodTypeArguments);
MethodSignature methodSignature = this.MethodSignature;
Handle[] typeSignatures = new Handle[methodSignature.Parameters.Count + 1];
typeSignatures[0] = methodSignature.ReturnType;
int paramIndex = 1;
foreach (Handle parameterTypeSignatureHandle in methodSignature.Parameters)
{
typeSignatures[paramIndex++] = parameterTypeSignatureHandle;
}
int count = typeSignatures.Length;
VirtualRuntimeParameterInfoArray result = new VirtualRuntimeParameterInfoArray(count);
foreach (ParameterHandle parameterHandle in _method.Parameters)
{
Parameter parameterRecord = parameterHandle.GetParameter(_reader);
int index = parameterRecord.Sequence;
result[index] =
NativeFormatMethodParameterInfo.GetNativeFormatMethodParameterInfo(
contextMethod,
_methodHandle,
index - 1,
parameterHandle,
new QSignatureTypeHandle(reader, typeSignatures[index]),
typeContext);
}
for (int i = 0; i < count; i++)
{
if (result[i] == null)
{
result[i] =
RuntimeThinMethodParameterInfo.GetRuntimeThinMethodParameterInfo(
contextMethod,
i - 1,
new QSignatureTypeHandle(reader, typeSignatures[i]),
typeContext);
}
}
returnParameter = result.First;
return(result.Remainder);
}
//
// Returns the ParameterInfo objects for the method parameters and return parameter.
//
// The ParameterInfo objects will report "contextMethod" as their Member property and use it to get type variable information from
// the contextMethod's declaring type. The actual metadata, however, comes from "this."
//
// The methodTypeArguments provides the fill-ins for any method type variable elements in the parameter type signatures.
//
// Does not array-copy.
//
internal static RuntimeParameterInfo[] GetRuntimeParameters <TRuntimeMethodCommon>(ref TRuntimeMethodCommon runtimeMethodCommon, MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments, out RuntimeParameterInfo returnParameter)
where TRuntimeMethodCommon : IRuntimeMethodCommon <TRuntimeMethodCommon>, IEquatable <TRuntimeMethodCommon>
{
TypeContext typeContext = contextMethod.DeclaringType.CastToRuntimeTypeInfo().TypeContext;
typeContext = new TypeContext(typeContext.GenericTypeArguments, methodTypeArguments);
QTypeDefRefOrSpec[] typeSignatures = runtimeMethodCommon.QualifiedMethodSignature;
int count = typeSignatures.Length;
VirtualRuntimeParameterInfoArray result = new VirtualRuntimeParameterInfoArray(count);
runtimeMethodCommon.FillInMetadataDescribedParameters(ref result, typeSignatures, contextMethod, typeContext);
for (int i = 0; i < count; i++)
{
if (result[i] == null)
{
result[i] =
RuntimeThinMethodParameterInfo.GetRuntimeThinMethodParameterInfo(
contextMethod,
i - 1,
typeSignatures[i],
typeContext);
}
}
returnParameter = result.First;
return(result.Remainder);
}
internal sealed override RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
throw NotImplemented.ByDesign;
}
// Token: 0x0600556D RID: 21869 RVA: 0x0012E6D8 File Offset: 0x0012C8D8
internal static RemotingCachedData GetReflectionCachedData(RuntimeParameterInfo reflectionObject)
{
return(reflectionObject.RemotingCache);
}
internal sealed override RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
return(_common.GetRuntimeParameters(contextMethod, contextMethod.RuntimeGenericArgumentsOrParameters, out returnParameter));
}
internal abstract RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter);
internal sealed override RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
return(_genericMethodDefinition.GetRuntimeParameters(this, out returnParameter));
}
private RuntimeParameterInfo RI; // reflection structure on which this data structure is stored
internal RemotingParameterCachedData(RuntimeParameterInfo ri)
{
RI = ri;
}
//
// Returns the ParameterInfo objects for the method parameters and return parameter.
//
// The ParameterInfo objects will report "contextMethod" as their Member property and use it to get type variable information from
// the contextMethod's declaring type. The actual metadata, however, comes from "this."
//
// The methodTypeArguments provides the fill-ins for any method type variable elements in the parameter type signatures.
//
// Does not array-copy.
//
public RuntimeParameterInfo[] GetRuntimeParameters(MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments, out RuntimeParameterInfo returnParameter)
{
MetadataReader reader = _reader;
TypeContext typeContext = contextMethod.DeclaringType.CastToRuntimeTypeInfo().TypeContext;
typeContext = new TypeContext(typeContext.GenericTypeArguments, methodTypeArguments);
QSignatureTypeHandle[] typeSignatures = this.MethodSignature;
int count = typeSignatures.Length;
VirtualRuntimeParameterInfoArray result = new VirtualRuntimeParameterInfoArray(count);
foreach (ParameterHandle parameterHandle in _method.GetParameters())
{
Parameter parameterRecord = _reader.GetParameter(parameterHandle);
int index = parameterRecord.SequenceNumber;
result[index] =
EcmaFormatMethodParameterInfo.GetEcmaFormatMethodParameterInfo(
contextMethod,
_methodHandle,
index - 1,
parameterHandle,
typeSignatures[index],
typeContext);
}
for (int i = 0; i < count; i++)
{
if (result[i] == null)
{
result[i] =
RuntimeThinMethodParameterInfo.GetRuntimeThinMethodParameterInfo(
contextMethod,
i - 1,
typeSignatures[i],
typeContext);
}
}
returnParameter = result.First;
return(result.Remainder);
}
private RuntimePropertyIndexParameterInfo(RuntimePropertyInfo member, RuntimeParameterInfo backingParameter)
: base(member, backingParameter.Position)
{
_backingParameter = backingParameter;
}
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
{
return(GetCustomAttribute(parameter.MetadataToken, parameter.GetRuntimeModule()));
}
// Used by method and property ToString() methods to display the list of parameter types. Replicates the behavior of MethodBase.ConstructParameters()
// but in a pay-to-play-safe way.
public static String ComputeParametersString(RuntimeParameterInfo[] runtimeParametersAndReturn, int startIndex)
{
StringBuilder sb = new StringBuilder(30);
for (int i = startIndex; i < runtimeParametersAndReturn.Length; i++)
{
if (i != startIndex)
sb.Append(", ");
String parameterTypeString = runtimeParametersAndReturn[i].ParameterTypeString;
// Legacy: Why use "ByRef" for by ref parameters? What language is this?
// VB uses "ByRef" but it should precede (not follow) the parameter name.
// Why don't we just use "&"?
if (parameterTypeString.EndsWith("&"))
parameterTypeString = parameterTypeString.Substring(0, parameterTypeString.Length - 1) + " ByRef";
sb.Append(parameterTypeString);
}
return sb.ToString();
}
internal static bool IsDefined(RuntimeParameterInfo parameter)
{
return(GetCustomAttribute(parameter) != null);
}
public sealed override String ToString()
{
StringBuilder sb = new StringBuilder(30);
TypeContext typeContext = ContextTypeInfo.TypeContext;
sb.Append(PropertyTypeHandle.FormatTypeName(typeContext));
sb.Append(' ');
sb.Append(this.Name);
ParameterInfo[] indexParameters = this.GetIndexParameters();
if (indexParameters.Length != 0)
{
RuntimeParameterInfo[] indexRuntimeParameters = new RuntimeParameterInfo[indexParameters.Length];
for (int i = 0; i < indexParameters.Length; i++)
indexRuntimeParameters[i] = (RuntimeParameterInfo)(indexParameters[i]);
sb.Append(" [");
sb.Append(RuntimeMethodHelpers.ComputeParametersString(indexRuntimeParameters));
sb.Append(']');
}
return sb.ToString();
}
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
{
return(parameter.IsIn ? new InAttribute() : null);
}
internal abstract RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter);
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
{
return(parameter.IsOptional ? new OptionalAttribute() : null);
}
internal sealed override RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
return _genericMethodDefinition.GetRuntimeParameters(this, out returnParameter);
}
internal static bool IsDefined(RuntimeParameterInfo parameter)
{
return(parameter.IsOptional);
}
internal sealed override RuntimeParameterInfo[] GetRuntimeParameters(RuntimeMethodInfo contextMethod, out RuntimeParameterInfo returnParameter)
{
RuntimeTypeInfo[] runtimeParameterTypes = _runtimeParameterTypes;
RuntimeParameterInfo[] parameters = new RuntimeParameterInfo[runtimeParameterTypes.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = RuntimeSyntheticParameterInfo.GetRuntimeSyntheticParameterInfo(this, i, runtimeParameterTypes[i]);
}
returnParameter = RuntimeSyntheticParameterInfo.GetRuntimeSyntheticParameterInfo(this, -1, _returnType);
return parameters;
}
public static String ComputeToString(MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments, RuntimeParameterInfo[] parameters, RuntimeParameterInfo returnParameter)
{
StringBuilder sb = new StringBuilder(30);
sb.Append(returnParameter == null ? "Void" : returnParameter.ParameterTypeString); // ConstructorInfos allowed to pass in null rather than craft a ReturnParameterInfo that's always of type void.
sb.Append(' ');
sb.Append(contextMethod.Name);
if (methodTypeArguments.Length != 0)
{
String sep = "";
sb.Append('[');
foreach (RuntimeTypeInfo methodTypeArgument in methodTypeArguments)
{
sb.Append(sep);
sep = ",";
String name = methodTypeArgument.InternalNameIfAvailable;
if (name == null)
name = ToStringUtils.UnavailableType;
sb.Append(methodTypeArgument.Name);
}
sb.Append(']');
}
sb.Append('(');
sb.Append(ComputeParametersString(parameters));
sb.Append(')');
return sb.ToString();
}
