private bool FindMatchingInterfaceSlot(IntPtr moduleHandle, NativeReader nativeLayoutReader, ref NativeParser entryParser, ref ExternalReferencesTable extRefs, ref RuntimeTypeHandle declaringType, ref MethodNameAndSignature methodNameAndSignature, RuntimeTypeHandle openTargetTypeHandle, RuntimeTypeHandle[] targetTypeInstantiation, bool variantDispatch)
{
uint numTargetImplementations = entryParser.GetUnsigned();
for (uint j = 0; j < numTargetImplementations; j++)
{
uint nameAndSigToken = extRefs.GetRvaFromIndex(entryParser.GetUnsigned());
MethodNameAndSignature targetMethodNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, nameAndSigToken);
RuntimeTypeHandle targetTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine(" Searching for GVM implementation on targe type = " + GetTypeNameDebug(targetTypeHandle));
#endif
uint numIfaceImpls = entryParser.GetUnsigned();
for (uint k = 0; k < numIfaceImpls; k++)
{
RuntimeTypeHandle implementingTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
uint numIfaceSigs = entryParser.GetUnsigned();
if (!openTargetTypeHandle.Equals(implementingTypeHandle))
{
// Skip over signatures data
for (uint l = 0; l < numIfaceSigs; l++)
entryParser.GetUnsigned();
continue;
}
for (uint l = 0; l < numIfaceSigs; l++)
{
RuntimeTypeHandle currentIfaceTypeHandle = default(RuntimeTypeHandle);
NativeParser ifaceSigParser = new NativeParser(nativeLayoutReader, extRefs.GetRvaFromIndex(entryParser.GetUnsigned()));
IntPtr currentIfaceSigPtr = ifaceSigParser.Reader.OffsetToAddress(ifaceSigParser.Offset);
if (TypeLoaderEnvironment.Instance.GetTypeFromSignatureAndContext(currentIfaceSigPtr, targetTypeInstantiation, null, out currentIfaceTypeHandle, out currentIfaceSigPtr))
{
Debug.Assert(!currentIfaceTypeHandle.IsNull());
if ((!variantDispatch && declaringType.Equals(currentIfaceTypeHandle)) ||
(variantDispatch && RuntimeAugments.IsAssignableFrom(declaringType, currentIfaceTypeHandle)))
{
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine(" " + (declaringType.Equals(currentIfaceTypeHandle) ? "Exact" : "Variant-compatible") + " match found on this target type!");
#endif
// We found the GVM slot target for the input interface GVM call, so let's update the interface GVM slot and return success to the caller
declaringType = targetTypeHandle;
methodNameAndSignature = targetMethodNameAndSignature;
return true;
}
}
}
}
}
return false;
}
public unsafe override sealed bool TryGetGenericVirtualTargetForTypeAndSlot(RuntimeTypeHandle targetHandle, ref RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, ref string methodName, ref IntPtr methodSignature, out IntPtr methodPointer, out IntPtr dictionaryPointer, out bool slotUpdated)
{
MethodNameAndSignature methodNameAndSignature = new MethodNameAndSignature(methodName, methodSignature);
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine("GVM resolution starting for " + GetTypeNameDebug(declaringType) + "." + methodNameAndSignature.Name + "(...) on a target of type " + GetTypeNameDebug(targetHandle) + " ...");
#endif
if (RuntimeAugments.IsInterface(declaringType))
{
methodPointer = IntPtr.Zero;
dictionaryPointer = IntPtr.Zero;
slotUpdated = ResolveInterfaceGenericVirtualMethodSlot(targetHandle, ref declaringType, ref methodNameAndSignature);
methodName = methodNameAndSignature.Name;
methodSignature = methodNameAndSignature.Signature;
return slotUpdated;
}
else
{
slotUpdated = false;
return ResolveGenericVirtualMethodTarget(targetHandle, declaringType, genericArguments, methodNameAndSignature, out methodPointer, out dictionaryPointer);
}
}
public static RuntimeType GetTypeFromHandle(RuntimeTypeHandle handle)
{
// handle is really a vtable
VTable vtable = var.Cast<RuntimeTypeHandle>(handle).Cast<VTable>();
return GetTypeFromClass(vtable.Class);
}
public static void RunClassConstructor (RuntimeTypeHandle type)
{
if (type.Value == IntPtr.Zero)
throw new ArgumentException ("Handle is not initialized.", "type");
RunClassConstructor (type.Value);
}
public SyntheticMethodInvoker(RuntimeTypeHandle thisType, RuntimeTypeHandle[] parameterTypes, InvokerOptions options, Func<Object, Object[], Object> invoker)
{
_invoker = invoker;
_options = options;
_thisType = thisType;
_parameterTypes = parameterTypes;
}
public override Delegate CreateDelegate(RuntimeTypeHandle delegateType, Object target, bool isStatic, bool isVirtual, bool isOpen)
{
return RuntimeAugments.CreateDelegate(
delegateType,
MethodInvokeInfo.LdFtnResult,
target,
isStatic: isStatic,
isOpen: isOpen);
}
public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
{
if (IsULong)
{
jsonWriter.WriteUnsignedLong(((IConvertible)obj).ToUInt64(null));
}
else
{
jsonWriter.WriteLong(((IConvertible)obj).ToInt64(null));
}
}
public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(Type.GetTypeFromHandle(declaredTypeHandle),
GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false); // maxItemsInObjectGraph // ignoreExtensionDataObject // preserveObjectReferences
MemoryStream memoryStream = new MemoryStream();
dataContractSerializer.WriteObject(memoryStream, obj);
memoryStream.Position = 0;
string serialized = new StreamReader(memoryStream).ReadToEnd();
jsonWriter.WriteString(serialized);
}
//
// Creates the appropriate flavor of Invoker depending on the calling convention "shape" (static, instance or virtual.)
//
internal static MethodInvoker CreateMethodInvoker(MetadataReader reader, RuntimeTypeHandle declaringTypeHandle, MethodHandle methodHandle, MethodInvokeInfo methodInvokeInfo)
{
Method method = methodHandle.GetMethod(reader);
MethodAttributes methodAttributes = method.Flags;
if (0 != (methodAttributes & MethodAttributes.Static))
return new StaticMethodInvoker(methodInvokeInfo);
else if (methodInvokeInfo.VirtualResolveData != IntPtr.Zero)
return new VirtualMethodInvoker(methodInvokeInfo, declaringTypeHandle);
else
return new InstanceMethodInvoker(methodInvokeInfo, declaringTypeHandle);
}
/// <summary>
/// Initializes a new instance of ClrEnumType class with properties from the CLR type.
/// </summary>
/// <param name="clrType">The CLR type to construct from.</param>
/// <param name="cspaceNamespaceName">CSpace namespace name.</param>
/// <param name="cspaceTypeName">CSpace type name.</param>
internal ClrEnumType(Type clrType, string cspaceNamespaceName, string cspaceTypeName)
: base(clrType)
{
Debug.Assert(clrType != null, "clrType != null");
Debug.Assert(clrType.IsEnum, "enum type expected");
Debug.Assert(
!String.IsNullOrEmpty(cspaceNamespaceName) && !String.IsNullOrEmpty(cspaceTypeName),
"Mapping information must never be null");
_type = clrType.TypeHandle;
_cspaceTypeName = cspaceNamespaceName + "." + cspaceTypeName;
}
public NullableInstanceMethodInvoker(MetadataReader reader, MethodHandle methodHandle, RuntimeTypeHandle nullableTypeHandle, MethodInvokeInfo methodInvokeInfo)
{
_id = NullableMethodId.None;
_nullableTypeHandle = nullableTypeHandle;
Method method = methodHandle.GetMethod(reader);
if (MethodAttributes.Public == (method.Flags & MethodAttributes.MemberAccessMask))
{
// Note: Since we control the definition of Nullable<>, we're not checking signatures here.
String name = method.Name.GetConstantStringValue(reader).Value;
switch (name)
{
case "GetType":
_id = NullableMethodId.GetType;
break;
case "ToString":
_id = NullableMethodId.ToString;
break;
case "Equals":
_id = NullableMethodId.Equals;
break;
case "GetHashCode":
_id = NullableMethodId.GetHashCode;
break;
case ".ctor":
_id = NullableMethodId.Ctor;
break;
case "get_HasValue":
_id = NullableMethodId.get_HasValue;
break;
case "get_Value":
_id = NullableMethodId.get_Value;
break;
case "GetValueOrDefault":
IEnumerator<ParameterTypeSignatureHandle> parameters = method.Signature.GetMethodSignature(reader).Parameters.GetEnumerator();
if (parameters.MoveNext())
_id = NullableMethodId.GetValueOrDefault_1;
else
_id = NullableMethodId.GetValueOrDefault_0;
break;
default:
break;
}
}
}
/// <summary>
/// Initializes a new instance of Complex Type with properties from the type.
/// </summary>
/// <param name="type">The CLR type to construct from</param>
internal ClrEntityType(Type type, string cspaceNamespaceName, string cspaceTypeName)
: base(EntityUtil.GenericCheckArgumentNull(type, "type").Name, type.Namespace ?? string.Empty,
DataSpace.OSpace)
{
Debug.Assert(
!String.IsNullOrEmpty(cspaceNamespaceName) &&
!String.IsNullOrEmpty(cspaceTypeName), "Mapping information must never be null");
_type = type.TypeHandle;
_cspaceNamespaceName = cspaceNamespaceName;
_cspaceTypeName = cspaceNamespaceName + "." + cspaceTypeName;
Abstract = type.IsAbstract;
}
internal override object InternalDeserialize(XmlReaderDelegator xmlReader, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle, string name, string ns)
{
if (_mode == SerializationMode.SharedContract)
{
if (_serializationSurrogateProvider == null)
return base.InternalDeserialize(xmlReader, declaredTypeID, declaredTypeHandle, name, ns);
else
return InternalDeserializeWithSurrogate(xmlReader, Type.GetTypeFromHandle(declaredTypeHandle), null /*surrogateDataContract*/, name, ns);
}
else
{
return InternalDeserializeInSharedTypeMode(xmlReader, declaredTypeID, Type.GetTypeFromHandle(declaredTypeHandle), name, ns);
}
}
public static void RunClassConstructor(RuntimeTypeHandle type)
{
if (type.IsNull)
throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized);
IntPtr pStaticClassConstructionContext = RuntimeAugments.Callbacks.TryGetStaticClassConstructionContext(type);
if (pStaticClassConstructionContext == IntPtr.Zero)
return;
unsafe
{
ClassConstructorRunner.EnsureClassConstructorRun((StaticClassConstructionContext*)pStaticClassConstructionContext);
}
}
public static bool TryGetConstructedGenericTypeComponents(RuntimeTypeHandle runtimeTypeHandle, out RuntimeTypeHandle genericTypeDefinitionHandle, out RuntimeTypeHandle[] genericTypeArgumentHandles)
{
genericTypeDefinitionHandle = default(RuntimeTypeHandle);
genericTypeArgumentHandles = null;
// Check the regular tables first.
if (ReflectionExecution.ExecutionEnvironment.TryGetConstructedGenericTypeComponents(runtimeTypeHandle, out genericTypeDefinitionHandle, out genericTypeArgumentHandles))
return true;
// Now check the diagnostic tables.
if (ReflectionExecution.ExecutionEnvironment.TryGetConstructedGenericTypeComponentsDiag(runtimeTypeHandle, out genericTypeDefinitionHandle, out genericTypeArgumentHandles))
return true;
return false;
}
public static void ValidateThis(Object thisObject, RuntimeTypeHandle declaringTypeHandle)
{
if (thisObject == null)
throw new TargetException(SR.RFLCT_Targ_StatMethReqTarg);
RuntimeTypeHandle srcTypeHandle = thisObject.GetType().TypeHandle;
if (RuntimeAugments.IsAssignableFrom(declaringTypeHandle, srcTypeHandle))
return;
if (RuntimeAugments.IsInterface(declaringTypeHandle))
{
if (RuntimeAugments.IsInstanceOfInterface(thisObject, declaringTypeHandle))
return;
}
throw new TargetException(SR.RFLCT_Targ_ITargMismatch);
}
public override sealed Delegate CreateDelegate(RuntimeTypeHandle delegateType, Object target, bool isStatic, bool isVirtual, bool isOpen)
{
if (isOpen)
{
return RuntimeAugments.CreateDelegate(
delegateType,
new OpenMethodResolver(_declaringTypeHandle, MethodInvokeInfo.LdFtnResult, 0).ToIntPtr(),
target,
isStatic: isStatic,
isOpen: isOpen);
}
else
{
return base.CreateDelegate(delegateType, target, isStatic, isVirtual, isOpen);
}
}
/// <summary>
/// Initializes a new OSpace instance of the property class
/// </summary>
/// <param name="name">name of the property</param>
/// <param name="typeUsage">TypeUsage object containing the property type and its facets</param>
/// <param name="propertyInfo">for the property</param>
/// <param name="entityDeclaringType">The declaring type of the entity containing the property</param>
internal EdmProperty(string name, TypeUsage typeUsage, PropertyInfo propertyInfo, RuntimeTypeHandle entityDeclaringType)
: this(name, typeUsage)
{
Debug.Assert(name == propertyInfo.Name, "different PropertyName");
if (null != propertyInfo)
{
MethodInfo method;
method = propertyInfo.GetGetMethod(true); // return public or non-public getter
PropertyGetterHandle = ((null != method) ? method.MethodHandle : default(RuntimeMethodHandle));
method = propertyInfo.GetSetMethod(true); // return public or non-public getter
PropertySetterHandle = ((null != method) ? method.MethodHandle : default(RuntimeMethodHandle));
EntityDeclaringType = entityDeclaringType;
}
}
//
// This overload of GetMethodHandle can handle all method handles.
//
public sealed override MethodBase GetMethodFromHandle(RuntimeMethodHandle runtimeMethodHandle, RuntimeTypeHandle declaringTypeHandle)
{
ExecutionEnvironment executionEnvironment = ReflectionCoreExecution.ExecutionEnvironment;
MethodHandle methodHandle;
RuntimeTypeHandle[] genericMethodTypeArgumentHandles;
if (!executionEnvironment.TryGetMethodFromHandleAndType(runtimeMethodHandle, declaringTypeHandle, out methodHandle, out genericMethodTypeArgumentHandles))
{
// This may be a method declared on a non-generic type: this api accepts that too so try the other table.
RuntimeTypeHandle actualDeclaringTypeHandle;
if (!executionEnvironment.TryGetMethodFromHandle(runtimeMethodHandle, out actualDeclaringTypeHandle, out methodHandle, out genericMethodTypeArgumentHandles))
throw new ArgumentException(SR.Argument_InvalidHandle);
if (!actualDeclaringTypeHandle.Equals(declaringTypeHandle))
throw new ArgumentException(SR.Format(SR.Argument_ResolveMethodHandle,
ReflectionCoreNonPortable.GetTypeForRuntimeTypeHandle(declaringTypeHandle),
ReflectionCoreNonPortable.GetTypeForRuntimeTypeHandle(actualDeclaringTypeHandle)));
}
MethodBase methodBase = ReflectionCoreExecution.ExecutionDomain.GetMethod(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles);
return methodBase;
}
// Get the diagnostic name string for a type. This attempts to reformat the string into something that is essentially human readable.
// Returns true if the function is successful.
// runtimeTypeHandle represents the type to get a name for
// diagnosticName is the name that is returned
//
// the genericParameterOffsets list is an optional parameter that contains the list of the locations of where generic parameters may be inserted
// to make the string represent an instantiated generic.
//
// For example for Dictionary<K,V>, metadata names the type Dictionary`2, but this function will return Dictionary<,>
// For consumers of this function that will be inserting generic arguments, the genericParameterOffsets list is used to find where to insert the generic parameter name.
//
// That isn't all that interesting for Dictionary, but it becomes substantially more interesting for nested generic types, or types which are compiler named as
// those may contain embedded <> pairs and such.
public static bool TryGetDiagnosticStringForNamedType(RuntimeTypeHandle runtimeTypeHandle, out String diagnosticName, List<int> genericParameterOffsets)
{
diagnosticName = null;
ExecutionEnvironmentImplementation executionEnvironment = ReflectionExecution.ExecutionEnvironment;
MetadataReader reader;
TypeReferenceHandle typeReferenceHandle;
if (executionEnvironment.TryGetTypeReferenceForNamedType(runtimeTypeHandle, out reader, out typeReferenceHandle))
{
diagnosticName = GetTypeFullNameFromTypeRef(typeReferenceHandle, reader, genericParameterOffsets);
return true;
}
TypeDefinitionHandle typeDefinitionHandle;
if (executionEnvironment.TryGetMetadataForNamedType(runtimeTypeHandle, out reader, out typeDefinitionHandle))
{
diagnosticName = GetTypeFullNameFromTypeDef(typeDefinitionHandle, reader, genericParameterOffsets);
return true;
}
return false;
}
public static int Main(String[] args)
{
Type t = typeof(int);
Type t2 = typeof(long);
RuntimeTypeHandle th = t.TypeHandle;
RuntimeTypeHandle th2 = t2.TypeHandle;
Console.WriteLine(th.Equals(th2));
Console.WriteLine(th.Equals(th));
RuntimeTypeHandle[] arr = new RuntimeTypeHandle[2];
arr[0] = t.TypeHandle;
arr[1] = t2.TypeHandle;
if (arr[0].Equals(arr[1]))
{
Console.WriteLine("ERR");
return 0;
}
return 100;
}
public static void ValidateThis(Object thisObject, RuntimeTypeHandle declaringTypeHandle)
{
if (thisObject == null)
throw new TargetException(SR.RFLCT_Targ_StatMethReqTarg);
RuntimeTypeHandle srcTypeHandle = thisObject.GetType().TypeHandle;
if (RuntimeAugments.IsAssignableFrom(declaringTypeHandle, srcTypeHandle))
return;
// if Object supports ICastable interface and the declaringType is interface
// try to call ICastable.IsInstanceOfInterface to determine whether object suppport declaringType interface
if (RuntimeAugments.IsInterface(declaringTypeHandle))
{
ICastable castable = thisObject as ICastable;
Exception castError;
// ICastable.IsInstanceOfInterface isn't supposed to throw exception
if (castable != null && castable.IsInstanceOfInterface(declaringTypeHandle, out castError))
return;
}
throw new TargetException(SR.RFLCT_Targ_ITargMismatch);
}
public override sealed Delegate CreateDelegate(RuntimeTypeHandle delegateType, Object target, bool isStatic, bool isVirtual, bool isOpen)
{
if (!isOpen)
{
// We're creating a delegate to a virtual override of this method, so resolve the virtual now.
IntPtr resolvedVirtual = OpenMethodResolver.ResolveMethod(MethodInvokeInfo.VirtualResolveData, target);
return RuntimeAugments.CreateDelegate(
delegateType,
resolvedVirtual,
target,
isStatic: false,
isOpen: isOpen);
}
else
{
// Create an open virtual method by providing the virtual resolver to the delegate type.
return RuntimeAugments.CreateDelegate(
delegateType,
MethodInvokeInfo.VirtualResolveData,
target,
isStatic: false,
isOpen: isOpen);
}
}
public abstract IntPtr TryGetStaticClassConstructionContext(RuntimeTypeHandle runtimeTypeHandle);
public abstract Type GetByRefTypeForHandle(RuntimeTypeHandle typeHandle);
public abstract Delegate CreateDelegate(RuntimeTypeHandle delegateType, Object target, bool isStatic, bool isVirtual, bool isOpen);
public virtual void InternalSerialize(XmlWriterDelegator xmlWriter, object obj, bool isDeclaredType, bool writeXsiType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle)
{
if (writeXsiType)
{
Type declaredType = Globals.TypeOfObject;
SerializeWithXsiType(xmlWriter, obj, Type.GetTypeHandle(obj), null /*type*/, -1, declaredType.TypeHandle, declaredType);
}
else if (isDeclaredType)
{
DataContract contract = GetDataContract(declaredTypeID, declaredTypeHandle);
SerializeWithoutXsiType(contract, xmlWriter, obj, declaredTypeHandle);
}
else
{
RuntimeTypeHandle objTypeHandle = Type.GetTypeHandle(obj);
if (declaredTypeHandle.Equals(objTypeHandle))
{
DataContract dataContract = (declaredTypeID >= 0)
? GetDataContract(declaredTypeID, declaredTypeHandle)
: GetDataContract(declaredTypeHandle, null /*type*/);
SerializeWithoutXsiType(dataContract, xmlWriter, obj, declaredTypeHandle);
}
else
{
SerializeWithXsiType(xmlWriter, obj, objTypeHandle, null /*type*/, declaredTypeID, declaredTypeHandle, Type.GetTypeFromHandle(declaredTypeHandle));
}
}
}
internal virtual void SerializeWithXsiTypeAtTopLevel(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle originalDeclaredTypeHandle, Type graphType)
{
bool verifyKnownType = false;
Type declaredType = rootTypeDataContract.OriginalUnderlyingType;
if (declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType))
{
if (DataContractResolver != null)
{
WriteResolvedTypeInfo(xmlWriter, graphType, declaredType);
}
}
else if (!declaredType.IsArray) //Array covariance is not supported in XSD. If declared type is array do not write xsi:type. Instead write xsi:type for each item
{
verifyKnownType = WriteTypeInfo(xmlWriter, dataContract, rootTypeDataContract);
}
SerializeAndVerifyType(dataContract, xmlWriter, obj, verifyKnownType, originalDeclaredTypeHandle, declaredType);
}
public abstract string GetBetterDiagnosticInfoIfAvailable(RuntimeTypeHandle runtimeTypeHandle);
public PhpValue Evaluate(Context ctx, PhpArray locals, object @this, RuntimeTypeHandle self)
{
return(_entryPoint(ctx, locals, @this, self));
}
public abstract Type GetArrayTypeForHandle(RuntimeTypeHandle typeHandle);
internal static MissingMetadataException Create(RuntimeTypeHandle pertainant)
{
return CreateFromMetadataObject(SR.Reflection_InsufficientMetadata_EdbNeeded, pertainant);
}
/// <summary>
/// Gets a <see cref="T:System.Reflection.MethodBase"/> object for the constructor or method represented by the specified handle, for the specified generic type.
/// </summary>
///
/// <returns>
/// A <see cref="T:System.Reflection.MethodBase"/> object representing the method or constructor specified by <paramref name="handle"/>, in the generic type specified by <paramref name="declaringType"/>.
/// </returns>
/// <param name="handle">A handle to the internal metadata representation of a constructor or method.</param><param name="declaringType">A handle to the generic type that defines the constructor or method.</param><exception cref="T:System.ArgumentException"><paramref name="handle"/> is invalid.</exception>
public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
{
throw new NotImplementedException();
}
public ReferenceTypeFieldAccessorForThreadStaticFields(IntPtr cctorContext, RuntimeTypeHandle declaringTypeHandle, IntPtr cookie, RuntimeTypeHandle fieldTypeHandle)
: base(cctorContext, fieldTypeHandle)
{
_cookie = cookie;
_declaringTypeHandle = declaringTypeHandle;
}
public abstract Type GetMdArrayTypeForHandle(RuntimeTypeHandle typeHandle, int rank);
/// <summary> /// Retrieves the default value for a parameter of a method. /// </summary> /// <param name="defaultParametersContext">The default parameters context used to invoke the method, /// this should identify the method in question. This is passed to the RuntimeAugments.CallDynamicInvokeMethod.</param> /// <param name="thType">The type of the parameter to retrieve.</param> /// <param name="argIndex">The index of the parameter on the method to retrieve.</param> /// <param name="defaultValue">The default value of the parameter if available.</param> /// <returns>true if the default parameter value is available, otherwise false.</returns> public abstract bool TryGetDefaultParameterValue(object defaultParametersContext, RuntimeTypeHandle thType, int argIndex, out object defaultValue);
public abstract Assembly GetAssemblyForHandle(RuntimeTypeHandle typeHandle);
public static unsafe Object GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
{
CorElementType corElementType = 0;
long buffer = 0;
int length;
String stringVal;
stringVal = scope.GetDefaultValue(token, out buffer, out length, out corElementType);
RuntimeType fieldType = fieldTypeHandle.GetRuntimeType();
if (fieldType.IsEnum && raw == false)
{
long defaultValue = 0;
switch (corElementType)
{
#region Switch
case CorElementType.Void:
return(DBNull.Value);
case CorElementType.Char:
defaultValue = *(char *)&buffer;
break;
case CorElementType.I1:
defaultValue = *(sbyte *)&buffer;
break;
case CorElementType.U1:
defaultValue = *(byte *)&buffer;
break;
case CorElementType.I2:
defaultValue = *(short *)&buffer;
break;
case CorElementType.U2:
defaultValue = *(ushort *)&buffer;
break;
case CorElementType.I4:
defaultValue = *(int *)&buffer;
break;
case CorElementType.U4:
defaultValue = *(uint *)&buffer;
break;
case CorElementType.I8:
defaultValue = buffer;
break;
case CorElementType.U8:
defaultValue = buffer;
break;
default:
throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
#endregion
}
return(RuntimeType.CreateEnum(fieldType, defaultValue));
}
else if (fieldType == typeof(DateTime))
{
long defaultValue = 0;
switch (corElementType)
{
#region Switch
case CorElementType.Void:
return(DBNull.Value);
case CorElementType.I8:
defaultValue = buffer;
break;
case CorElementType.U8:
defaultValue = buffer;
break;
default:
throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
#endregion
}
return(new DateTime(defaultValue));
}
else
{
switch (corElementType)
{
#region Switch
case CorElementType.Void:
return(DBNull.Value);
case CorElementType.Char:
return(*(char *)&buffer);
case CorElementType.I1:
return(*(sbyte *)&buffer);
case CorElementType.U1:
return(*(byte *)&buffer);
case CorElementType.I2:
return(*(short *)&buffer);
case CorElementType.U2:
return(*(ushort *)&buffer);
case CorElementType.I4:
return(*(int *)&buffer);
case CorElementType.U4:
return(*(uint *)&buffer);
case CorElementType.I8:
return(buffer);
case CorElementType.U8:
return((ulong)buffer);
case CorElementType.Boolean:
// The boolean value returned from the metadata engine is stored as a
// BOOL, which actually maps to an int. We need to read it out as an int
// to avoid problems on big-endian machines.
return(*(int *)&buffer != 0);
case CorElementType.R4:
return(*(float *)&buffer);
case CorElementType.R8:
return(*(double *)&buffer);
case CorElementType.String:
// A string constant can be empty but never null.
// A nullref constant can only be type CorElementType.Class.
return(stringVal == null ? String.Empty : stringVal);
case CorElementType.Class:
return(null);
default:
throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
#endregion
}
}
}
static Type \u206F([In] RuntimeTypeHandle obj0)
{
// ISSUE: unable to decompile the method.
}
protected virtual void WriteDataContractValue(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle declaredTypeHandle)
{
dataContract.WriteXmlValue(xmlWriter, obj, this);
}
//
// This overload of GetMethodHandle can handle all method handles.
//
public sealed override MethodBase GetMethodFromHandle(RuntimeMethodHandle runtimeMethodHandle, RuntimeTypeHandle declaringTypeHandle)
{
ExecutionEnvironment executionEnvironment = ReflectionCoreExecution.ExecutionEnvironment;
QMethodDefinition methodHandle;
RuntimeTypeHandle[] genericMethodTypeArgumentHandles;
if (!executionEnvironment.TryGetMethodFromHandleAndType(runtimeMethodHandle, declaringTypeHandle, out methodHandle, out genericMethodTypeArgumentHandles))
{
// This may be a method declared on a non-generic type: this api accepts that too so try the other table.
RuntimeTypeHandle actualDeclaringTypeHandle;
if (!executionEnvironment.TryGetMethodFromHandle(runtimeMethodHandle, out actualDeclaringTypeHandle, out methodHandle, out genericMethodTypeArgumentHandles))
{
throw new ArgumentException(SR.Argument_InvalidHandle);
}
if (!actualDeclaringTypeHandle.Equals(declaringTypeHandle))
{
throw new ArgumentException(SR.Format(SR.Argument_ResolveMethodHandle,
declaringTypeHandle.GetTypeForRuntimeTypeHandle(),
actualDeclaringTypeHandle.GetTypeForRuntimeTypeHandle()));
}
}
MethodBase methodBase = ReflectionCoreExecution.ExecutionDomain.GetMethod(declaringTypeHandle, methodHandle, genericMethodTypeArgumentHandles);
return(methodBase);
}
public abstract Type GetConstructedGenericTypeForHandle(RuntimeTypeHandle typeHandle);
protected void SerializeAndVerifyType(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, bool verifyKnownType, RuntimeTypeHandle declaredTypeHandle, Type declaredType)
{
bool knownTypesAddedInCurrentScope = false;
if (dataContract.KnownDataContracts != null)
{
scopedKnownTypes.Push(dataContract.KnownDataContracts);
knownTypesAddedInCurrentScope = true;
}
if (verifyKnownType)
{
if (!IsKnownType(dataContract, declaredType))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.DcTypeNotFoundOnSerialize, DataContract.GetClrTypeFullName(dataContract.UnderlyingType), dataContract.StableName.Name, dataContract.StableName.Namespace)));
}
}
WriteDataContractValue(dataContract, xmlWriter, obj, declaredTypeHandle);
if (knownTypesAddedInCurrentScope)
{
scopedKnownTypes.Pop();
}
}
public abstract MethodBase GetMethodFromHandle(RuntimeMethodHandle runtimeMethodHandle, RuntimeTypeHandle declaringTypeHandle);
protected virtual void SerializeWithXsiType(XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle objectTypeHandle, Type objectType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle, Type declaredType)
{
DataContract dataContract;
bool verifyKnownType = false;
if (declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType))
{
dataContract = GetDataContractSkipValidation(DataContract.GetId(objectTypeHandle), objectTypeHandle, objectType);
if (OnHandleIsReference(xmlWriter, dataContract, obj))
{
return;
}
if (this.Mode == SerializationMode.SharedType && dataContract.IsValidContract(this.Mode))
{
dataContract = dataContract.GetValidContract(this.Mode);
}
else
{
dataContract = GetDataContract(declaredTypeHandle, declaredType);
}
if (!WriteClrTypeInfo(xmlWriter, dataContract) && DataContractResolver != null)
{
if (objectType == null)
{
objectType = Type.GetTypeFromHandle(objectTypeHandle);
}
WriteResolvedTypeInfo(xmlWriter, objectType, declaredType);
}
}
else if (declaredType.IsArray)//Array covariance is not supported in XSD. If declared type is array do not write xsi:type. Instead write xsi:type for each item
{
// A call to OnHandleIsReference is not necessary here -- arrays cannot be IsReference
dataContract = GetDataContract(objectTypeHandle, objectType);
WriteClrTypeInfo(xmlWriter, dataContract);
dataContract = GetDataContract(declaredTypeHandle, declaredType);
}
else
{
dataContract = GetDataContract(objectTypeHandle, objectType);
if (OnHandleIsReference(xmlWriter, dataContract, obj))
{
return;
}
if (!WriteClrTypeInfo(xmlWriter, dataContract))
{
DataContract declaredTypeContract = (declaredTypeID >= 0)
? GetDataContract(declaredTypeID, declaredTypeHandle)
: GetDataContract(declaredTypeHandle, declaredType);
verifyKnownType = WriteTypeInfo(xmlWriter, dataContract, declaredTypeContract);
}
}
SerializeAndVerifyType(dataContract, xmlWriter, obj, verifyKnownType, declaredTypeHandle, declaredType);
}
public abstract FieldInfo GetFieldFromHandle(RuntimeFieldHandle runtimeFieldHandle, RuntimeTypeHandle declaringTypeHandle);
internal void SerializeWithoutXsiType(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle declaredTypeHandle)
{
if (OnHandleIsReference(xmlWriter, dataContract, obj))
{
return;
}
if (dataContract.KnownDataContracts != null)
{
scopedKnownTypes.Push(dataContract.KnownDataContracts);
WriteDataContractValue(dataContract, xmlWriter, obj, declaredTypeHandle);
scopedKnownTypes.Pop();
}
else
{
WriteDataContractValue(dataContract, xmlWriter, obj, declaredTypeHandle);
}
}
//======================================================================================= // This group of methods jointly service the Type.GetTypeFromHandle() path. The caller // is responsible for analyzing the RuntimeTypeHandle to figure out which flavor to call. //======================================================================================= public abstract Type GetNamedTypeForHandle(RuntimeTypeHandle typeHandle, bool isGenericTypeDefinition);
public void InternalSerializeReference(XmlWriterDelegator xmlWriter, object obj, bool isDeclaredType, bool writeXsiType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle)
{
if (!OnHandleReference(xmlWriter, obj, true /*canContainCyclicReference*/))
{
InternalSerialize(xmlWriter, obj, isDeclaredType, writeXsiType, declaredTypeID, declaredTypeHandle);
}
OnEndHandleReference(xmlWriter, obj, true /*canContainCyclicReference*/);
}
public abstract bool IsReflectionBlocked(RuntimeTypeHandle typeHandle);
static Type \u200D([In] RuntimeTypeHandle obj0)
{
// ISSUE: unable to decompile the method.
}
public abstract Type GetPointerTypeForHandle(RuntimeTypeHandle typeHandle);
public void WriteJsonValue(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
{
PushKnownDataContracts(context);
WriteJsonValueCore(jsonWriter, obj, context, declaredTypeHandle);
PopKnownDataContracts(context);
}
[System.Security.SecuritySafeCritical] // auto-generated
internal override RuntimeModule GetRuntimeModule()
{
return(RuntimeTypeHandle.GetModule(RuntimeFieldHandle.GetApproxDeclaringType(this)));
}
public static MethodBase GetMethodFromHandle (RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
{
return GetMethodFromIntPtr (handle.Value, declaringType.Value);
}
internal RuntimeModule GetRuntimeModule()
{
return(RuntimeTypeHandle.GetModule((RuntimeType)DeclaringType));
}
public ValueTypeFieldAccessorForStaticFields(IntPtr cctorContext, IntPtr fieldAddress, RuntimeTypeHandle fieldTypeHandle)
: base(cctorContext, fieldTypeHandle)
{
_fieldAddress = fieldAddress;
}
//
// This overload of GetFieldHandle can handle all field handles.
//
public sealed override FieldInfo GetFieldFromHandle(RuntimeFieldHandle runtimeFieldHandle, RuntimeTypeHandle declaringTypeHandle)
{
ExecutionEnvironment executionEnvironment = ReflectionCoreExecution.ExecutionEnvironment;
FieldHandle fieldHandle;
if (!executionEnvironment.TryGetFieldFromHandleAndType(runtimeFieldHandle, declaringTypeHandle, out fieldHandle))
{
// This may be a field declared on a non-generic type: this api accepts that too so try the other table.
RuntimeTypeHandle actualDeclaringTypeHandle;
if (!executionEnvironment.TryGetFieldFromHandle(runtimeFieldHandle, out actualDeclaringTypeHandle, out fieldHandle))
{
throw new ArgumentException(SR.Argument_InvalidHandle);
}
if (!actualDeclaringTypeHandle.Equals(declaringTypeHandle))
{
throw new ArgumentException(SR.Format(SR.Argument_ResolveFieldHandle,
declaringTypeHandle.GetTypeForRuntimeTypeHandle(),
actualDeclaringTypeHandle.GetTypeForRuntimeTypeHandle()));
}
}
FieldInfo fieldInfo = GetFieldInfo(declaringTypeHandle, fieldHandle);
return(fieldInfo);
}
public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
{
jsonWriter.WriteAttributeString(null, JsonGlobals.typeString, null, JsonGlobals.objectString);
JsonFormatWriterDelegate(jsonWriter, obj, context, TraditionalClassDataContract, MemberNames);
}
public sealed override IntPtr GetFunctionPointer(RuntimeMethodHandle runtimeMethodHandle, RuntimeTypeHandle declaringTypeHandle)
{
MethodBase method = GetMethodFromHandle(runtimeMethodHandle, declaringTypeHandle);
switch (method)
{
case RuntimeMethodInfo methodInfo:
return(methodInfo.LdFtnResult);
case RuntimeConstructorInfo constructorInfo:
return(constructorInfo.LdFtnResult);
default:
throw new PlatformNotSupportedException();
}
}
