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