public unsafe bool TryGetMetadataForNamedType(RuntimeTypeHandle runtimeTypeHandle, out MetadataReader metadataReader, out TypeDefinitionHandle typeDefHandle) { // Iterate over all modules, starting with the module that defines the EEType foreach (IntPtr moduleHandle in ModuleList.Enumerate(RuntimeAugments.GetModuleFromTypeHandle(runtimeTypeHandle))) { MetadataTable mapTable = MetadataTable.CreateTypeMapTable(moduleHandle); foreach (var ptrEntry in mapTable) { var pCurrentEntry = (TypeMapEntry*)ptrEntry; RuntimeTypeHandle entryTypeHandle = RuntimeAugments.CreateRuntimeTypeHandle(pCurrentEntry->EEType); Handle entryMetadataHandle = pCurrentEntry->TypeDefinitionHandle.AsHandle(); if (entryTypeHandle.Equals(runtimeTypeHandle) && entryMetadataHandle.HandleType == HandleType.TypeDefinition) { metadataReader = ModuleList.Instance.GetMetadataReaderForModule(moduleHandle); typeDefHandle = entryMetadataHandle.ToTypeDefinitionHandle(metadataReader); return true; } } } metadataReader = null; typeDefHandle = default(TypeDefinitionHandle); return false; }
static bool 载入(RuntimeTypeHandle 窗口类型, ref 窗口 欲载入的窗口, IWin32Window 父窗口 = null, bool 是否采用对话框方式 = true) { 欲载入的窗口 = (窗口)Activator.CreateInstance(Type.GetTypeFromHandle(窗口类型)); if (是否采用对话框方式) Application.Run(欲载入的窗口); else 欲载入的窗口.Show(父窗口); return true; }
public TypedReference GetNextArg(RuntimeTypeHandle rth) { if (sigPtr != IntPtr.Zero) { // This is an ordinary ArgIterator capable of determining // types from a signature. Just do a regular GetNextArg. return GetNextArg(); } else { // Prevent abuse of this API with a default ArgIterator (it // doesn't require permission to create a zero-inited value // type). Check that ArgPtr isn't zero or this API will allow a // malicious caller to increment the pointer to an arbitrary // location in memory and read the contents. if (ArgPtr == IntPtr.Zero) throw new ArgumentNullException(); TypedReference result = new TypedReference (); // reference to TypedReference is banned, so have to pass result as pointer unsafe { InternalGetNextArg(&result, rth.GetRuntimeType()); } return result; } }
public OpenMethodResolver(RuntimeTypeHandle declaringTypeOfSlot, int slot, int handle) { _resolveType = DispatchResolve; _declaringType = declaringTypeOfSlot; _methodHandleOrSlotOrCodePointer = new IntPtr(slot); _handle = handle; }
public unsafe OpenMethodResolver(RuntimeTypeHandle declaringTypeOfSlot, RuntimeMethodHandle gvmSlot, int handle) { _resolveType = GVMResolve; _methodHandleOrSlotOrCodePointer = *(IntPtr*)&gvmSlot; _declaringType = declaringTypeOfSlot; _handle = handle; }
public OpenMethodResolver(RuntimeTypeHandle declaringType, IntPtr codePointer, int handle) { _resolveType = OpenNonVirtualResolve; _methodHandleOrSlotOrCodePointer = codePointer; _declaringType = declaringType; _handle = handle; }
/// <summary> /// Saves a named field, by accessing its value using reflection /// </summary> public static void SaveNamedField( IOutput output, RuntimeTypeHandle objTypeHandle, object obj, string fieldName ) { Type objType = Type.GetTypeFromHandle( objTypeHandle ); FieldInfo fieldInfo = objType.GetField( fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance ); object field = fieldInfo.GetValue( obj ); output.Write( field ); }
internal RuntimeType(RuntimeTypeHandle handle) { this.handle = handle; typeStruct = (MetadataTypeStruct*)((uint**)&handle)[0]; assemblyQualifiedName = Mosa.Runtime.Internal.InitializeMetadataString(typeStruct->Name); // TODO name = Mosa.Runtime.Internal.InitializeMetadataString(typeStruct->Name); // TODO @namespace = Mosa.Runtime.Internal.InitializeMetadataString(typeStruct->Name); // TODO fullname = Mosa.Runtime.Internal.InitializeMetadataString(typeStruct->Name); typeCode = (TypeCode)(typeStruct->Attributes >> 24); attributes = (TypeAttributes)(typeStruct->Attributes & 0x00FFFFFF); // Declaring Type if (typeStruct->DeclaringType != null) { RuntimeTypeHandle declaringHandle = new RuntimeTypeHandle(); ((uint**)&declaringHandle)[0] = (uint*)typeStruct->DeclaringType; declaringTypeHandle = declaringHandle; } // Element Type if ((*typeStruct).ElementType != null) { RuntimeTypeHandle elementHandle = new RuntimeTypeHandle(); ((uint**)&elementHandle)[0] = (uint*)typeStruct->ElementType; elementTypeHandle = elementHandle; } }
public bool TryGetGenericVirtualTargetForTypeAndSlot(RuntimeTypeHandle targetHandle, ref RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, ref string methodName, ref RuntimeMethodSignature 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); } }
private NativeFormatRuntimeNamedTypeInfo(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle, RuntimeTypeHandle typeHandle) : base(typeHandle) { _reader = reader; _typeDefinitionHandle = typeDefinitionHandle; _typeDefinition = _typeDefinitionHandle.GetTypeDefinition(reader); }
protected override void SerializeWithXsiType(XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle objectTypeHandle, Type objectType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle, Type declaredType) { DataContract dataContract; bool verifyKnownType = false; bool isInterface = declaredType.IsInterface; if (isInterface && CollectionDataContract.IsCollectionInterface(declaredType)) { dataContract = this.GetDataContract(declaredTypeHandle, declaredType); } else if (declaredType.IsArray) { dataContract = this.GetDataContract(declaredTypeHandle, declaredType); } else { dataContract = this.GetDataContract(objectTypeHandle, objectType); DataContract declaredContract = (declaredTypeID >= 0) ? this.GetDataContract(declaredTypeID, declaredTypeHandle) : this.GetDataContract(declaredTypeHandle, declaredType); verifyKnownType = this.WriteTypeInfo(xmlWriter, dataContract, declaredContract); this.HandleCollectionAssignedToObject(declaredType, ref dataContract, ref obj, ref verifyKnownType); } if (isInterface) { VerifyObjectCompatibilityWithInterface(dataContract, obj, declaredType); } base.SerializeAndVerifyType(dataContract, xmlWriter, obj, verifyKnownType, declaredType.TypeHandle, declaredType); }
public GetFieldBinder(string name, RuntimeTypeHandle classContext, RuntimeTypeHandle returnType, AccessFlags access) { _name = name; _returnType = Type.GetTypeFromHandle(returnType); // should correspond to AccessFlags _classContext = Type.GetTypeFromHandle(classContext); _access = access; }
/// <summary> /// Setter for RuntimeTypeHandle. Seperate from normal property as all uses should be done with great care. /// Must not be set with partially constructed type handles /// </summary> public void SetRuntimeTypeHandleUnsafe(RuntimeTypeHandle runtimeTypeHandle) { Debug.Assert(!runtimeTypeHandle.IsNull()); Debug.Assert(_runtimeTypeHandle.IsNull() || runtimeTypeHandle.Equals(_runtimeTypeHandle)); Debug.Assert(runtimeTypeHandle.GetHashCode() == GetHashCode()); _runtimeTypeHandle = runtimeTypeHandle; }
//XStringMapEnumAttribute xStringMapEnumAttr; //static readonly System.RuntimeTypeHandle METAXStringToEnumAttr=typeof(XStringMapEnumAttribute).TypeHandle; public MapHandler(PropertyInfo pmeta) { this.setvalueToInstance = (Action <T, int>)System.Delegate.CreateDelegate(typeof(Action <T, int>), pmeta.GetSetMethod()); this.getvalueFromInstance = (Func <T, int>)System.Delegate.CreateDelegate(typeof(Func <T, int>), pmeta.GetGetMethod()); //this.xStringMapEnumAttr = pmeta.GetCustomAttributes(System.Type.GetTypeFromHandle(METAXStringToEnumAttr),false).Cast<XStringMapEnumAttribute>().FirstOrDefault(); this.propertyRTH = pmeta.PropertyType.TypeHandle; }
protected CallBinder(RuntimeTypeHandle returnType, int genericParams) { Debug.Assert(genericParams >= 0); _returnType = Type.GetTypeFromHandle(returnType); _genericParamsCount = genericParams; }
public bool IsCanonicallyEquivalent(RuntimeTypeHandle other) { if (_defType != null) { TypeDesc typeToFindAsCanon = _defType.ConvertToCanonForm(_canonKind); TypeDesc otherTypeAsTypeDesc = _defType.Context.ResolveRuntimeTypeHandle(other); TypeDesc otherTypeAsCanon = otherTypeAsTypeDesc.ConvertToCanonForm(_canonKind); return typeToFindAsCanon == otherTypeAsCanon; } if (!_genericDefinition.IsNull()) { if (RuntimeAugments.IsGenericType(other)) { RuntimeTypeHandle otherGenericDefinition; RuntimeTypeHandle[] otherGenericArgs; otherGenericDefinition = RuntimeAugments.GetGenericInstantiation(other, out otherGenericArgs); return _genericDefinition.Equals(otherGenericDefinition) && TypeLoaderEnvironment.Instance.CanInstantiationsShareCode(_genericArgs, otherGenericArgs, _canonKind); } else return false; } else return _typeToFind.Equals(other); }
private static RuntimeTypeHandle GetTypeHandle(void* obj) { // TypeDefinition is located at the beginning of object (i.e. *obj ) RuntimeTypeHandle handle = new RuntimeTypeHandle(); ((uint*)&handle)[0] = ((uint*)obj)[0]; return handle; }
public static void TestUseCase(Assert assert) { assert.Expect(7); var t1 = new Type(); assert.Ok(t1 != null, "#565 t1"); var t2 = new ValueType(); assert.Ok(t2 != null, "#565 t2"); var t3 = new IntPtr(); assert.Ok(t3.GetType() == typeof(IntPtr) , "#565 t3"); var t4 = new UIntPtr(); assert.Ok(t4.GetType() == typeof(UIntPtr), "#565 t4"); var t5 = new ParamArrayAttribute(); assert.Ok(t5 != null, "#565 t5"); var t6 = new RuntimeTypeHandle(); assert.Ok(t6.GetType() == typeof(RuntimeTypeHandle), "#565 t6"); var t7 = new RuntimeFieldHandle(); assert.Ok(t7.GetType() == typeof(RuntimeFieldHandle), "#565 t7"); }
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType) { if (handle.IsNullHandle()) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle")); return RuntimeType.GetFieldInfo(declaringType.GetRuntimeType(), handle.GetRuntimeFieldInfo()); }
static StackObject *GetFieldFromHandle_20(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.RuntimeTypeHandle @declaringType = (System.RuntimeTypeHandle) typeof(System.RuntimeTypeHandle).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); System.RuntimeFieldHandle @handle = (System.RuntimeFieldHandle) typeof(System.RuntimeFieldHandle).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = System.Reflection.FieldInfo.GetFieldFromHandle(@handle, @declaringType); object obj_result_of_this_method = result_of_this_method; if (obj_result_of_this_method is CrossBindingAdaptorType) { return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance)); } return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
/// <summary> /// Used by various parts of the runtime as a replacement for Delegate.Method /// /// The Interop layer uses this to distinguish between different methods on a /// single type, and to get the function pointer for delegates to static functions /// /// The reflection apis use this api to figure out what MethodInfo is related /// to a delegate. /// /// </summary> /// <param name="typeOfFirstParameterIfInstanceDelegate"> /// This value indicates which type an delegate's function pointer is associated with /// This value is ONLY set for delegates where the function pointer points at an instance method /// </param> /// <param name="isOpenResolver"> /// This value indicates if the returned pointer is an open resolver structure. /// </param> /// <returns></returns> unsafe internal IntPtr GetFunctionPointer(out RuntimeTypeHandle typeOfFirstParameterIfInstanceDelegate, out bool isOpenResolver) { typeOfFirstParameterIfInstanceDelegate = default(RuntimeTypeHandle); isOpenResolver = false; if (GetThunk(MulticastThunk) == m_functionPointer) { return IntPtr.Zero; } else if (m_extraFunctionPointerOrData != IntPtr.Zero) { if (GetThunk(OpenInstanceThunk) == m_functionPointer) { typeOfFirstParameterIfInstanceDelegate = ((OpenMethodResolver*)m_extraFunctionPointerOrData)->DeclaringType; isOpenResolver = true; } return m_extraFunctionPointerOrData; } else { if (m_firstParameter != null) typeOfFirstParameterIfInstanceDelegate = new RuntimeTypeHandle(m_firstParameter.EETypePtr); // TODO! Implementation issue for generic invokes here ... we need another IntPtr for uniqueness. return m_functionPointer; } }
private RuntimeTypeHandle GetTypeDefinition(RuntimeTypeHandle typeHandle) { if (RuntimeAugments.IsGenericType(typeHandle)) return RuntimeAugments.GetGenericDefinition(typeHandle); return typeHandle; }
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; }
internal static RuntimeMethodInfo AssignAssociates(int tkMethod, RuntimeTypeHandle declaredTypeHandle, RuntimeTypeHandle reflectedTypeHandle) { if (MetadataToken.IsNullToken(tkMethod)) { return null; } bool flag = !declaredTypeHandle.Equals(reflectedTypeHandle); RuntimeMethodHandle methodHandle = declaredTypeHandle.GetModuleHandle().ResolveMethodHandle(tkMethod, declaredTypeHandle.GetInstantiation(), new RuntimeTypeHandle[0]); MethodAttributes attributes = methodHandle.GetAttributes(); bool flag2 = (attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private; bool flag3 = (attributes & MethodAttributes.Virtual) != MethodAttributes.PrivateScope; if (flag) { if (flag2) { return null; } if (flag3 && ((declaredTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.AnsiClass)) { int slot = methodHandle.GetSlot(); methodHandle = reflectedTypeHandle.GetMethodAt(slot); } } MethodAttributes attributes2 = attributes & MethodAttributes.MemberAccessMask; RuntimeMethodInfo methodBase = RuntimeType.GetMethodBase(reflectedTypeHandle, methodHandle) as RuntimeMethodInfo; if (methodBase == null) { methodBase = reflectedTypeHandle.GetRuntimeType().Module.ResolveMethod(tkMethod, null, null) as RuntimeMethodInfo; } return methodBase; }
public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType) { if (handle.IsNullHandle()) { throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle")); } return RuntimeType.GetMethodBase(declaringType, handle); }
// TODO!! BEGIN REMOVE THIS CODE WHEN WE REMOVE ICASTABLE RuntimeTypeHandle ICastable.GetImplType(RuntimeTypeHandle interfaceType) { // TODO! Remove this hack that forces the il2il pipeline to not remove the ICastableObject interface or the _hiddenCacheField Exception junk; _hiddenCacheField = ((ICastableObject)this).CastToInterface(default(EETypePtr), false, out junk); // ENDTODO! return default(RuntimeTypeHandle); }
internal CanonicallyEquivalentEntryLocator(DefType typeToFind, CanonicalFormKind kind) { _genericArgs = null; _genericDefinition = default(RuntimeTypeHandle); _typeToFind = default(RuntimeTypeHandle); _canonKind = kind; _defType = typeToFind; }
public FuncNoKeyRegistration(IRegistration delegateRegistration) { this.delegateRegistration = delegateRegistration; this.funcType = Expression.GetFuncType(Type.GetTypeFromHandle(delegateRegistration.TypeHandle)).TypeHandle; var registrationContext = Expression.Parameter(typeof(IRegistrationContext), "registrationContext"); this.generator = Expression.Lambda<Func<IRegistrationContext, object>>(this.GetInstanceExpression(registrationContext), registrationContext).Compile(); }
public FixupRuntimeTypeHandle(RuntimeTypeHandle runtimeTypeHandle) { #if CLR_RUNTIMETYPEHANDLE throw new NotImplementedException(); // CORERT-TODO: RuntimeTypeHandle #else _value = *(IntPtr*)&runtimeTypeHandle; #endif }
private RuntimeTypeHandle GetOpenTypeDefinition(RuntimeTypeHandle typeHandle, out RuntimeTypeHandle[] typeArgumentsHandles) { if (RuntimeAugments.IsGenericType(typeHandle)) return RuntimeAugments.GetGenericInstantiation(typeHandle, out typeArgumentsHandles); typeArgumentsHandles = null; return typeHandle; }
public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle) { DataContractSerializer serializer = new DataContractSerializer(Type.GetTypeFromHandle(declaredTypeHandle), this.GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false, null); MemoryStream stream = new MemoryStream(); serializer.WriteObject(stream, obj); stream.Position = 0L; string str = new StreamReader(stream).ReadToEnd(); jsonWriter.WriteString(str); }
static FeatureMerger() { Type adoMergerType = Type.GetType("System.Data.Merger, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); _adoMergerTypeHandle = adoMergerType.TypeHandle; _createMerger = generateCreateMergerDelegate(); _mergeSchema = generateMergeSchemaDelegate(); _getKeyIndex = generateGetKeyIndexDelegate(); }
/// <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) { System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(cspaceNamespaceName) && !String.IsNullOrEmpty(cspaceTypeName), "Mapping information must never be null"); _type = type.TypeHandle; _cspaceNamespaceName = cspaceNamespaceName; _cspaceTypeName = cspaceNamespaceName + "." + cspaceTypeName; this.Abstract = type.IsAbstract; }
/// <summary> /// 在所有的模块中查找并实例化指定的模块提供程序对象 /// </summary> /// <typeparam name="T">模块提供程序对象类型/typeparam> /// <returns>模块提供程序对象</returns> public T ResolveProvider <T>() where T : IModuleProvider { System.RuntimeTypeHandle handle = typeof(T).TypeHandle; foreach (IModuleContext module in this.RegContext.GetAllModules()) { try { return(module.GetProvider <T>()); } catch { } } throw new Exception("类型未在相关的 ModuleRegistration实现类中注册,类型名称:" + typeof(T).Name); }
public MethodInfo GetActionMethod(string providerName, string actionName) { if (dictModuleProviders.ContainsKey(providerName)) { System.RuntimeTypeHandle providerHandle = dictModuleProviders[providerName]; MethodHandleInfo[] actionHandleArr = dictProviderMethods[providerHandle]; MethodHandleInfo actionInfo = actionHandleArr.FirstOrDefault(p => p.MethodName == actionName); if (actionInfo == null) { throw new Exception("未找到名称为 " + actionName + " 并且返回值是IActionResult 类型的方法"); } return((MethodInfo)MethodInfo.GetMethodFromHandle(actionInfo.MethodHandle)); } throw new Exception("未找到名称为" + providerName + " 的模块提供程序,请检查此类型是否在 ModuleRegistration 注册。"); }
static StackObject *GetTypeFromHandle_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.RuntimeTypeHandle @handle = (System.RuntimeTypeHandle) typeof(System.RuntimeTypeHandle).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags) 16); __intp.Free(ptr_of_this_method); var result_of_this_method = System.Type.GetTypeFromHandle(@handle); return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
public T GetProvider <T>() where T : IModuleProvider { System.RuntimeTypeHandle handle = typeof(T).TypeHandle; System.RuntimeTypeHandle providerHandle = dictModuleProviders.Values.FirstOrDefault(p => p.Equals(handle)); if (providerHandle != null) { //Type providerType = Type.GetTypeFromHandle(providerHandle); //return (IModuleProvider)Activator.CreateInstance(providerType); return(Activator.CreateInstance <T>()); } else { throw new Exception("类型未在 ModuleRegistration 注册,类型名称:" + typeof(T).Name); } }
// public IModuleRuntime ModuleRuntime { get; set; } public void AddProvider(IModuleProvider provider) { System.RuntimeTypeHandle providerHandle = provider.GetType().TypeHandle; dictModuleProviders.Add(provider.PrividerName, providerHandle); //反射出所有结果为 IActionResult类型的方法 List <MethodHandleInfo> actionMethods = new List <MethodHandleInfo>(); foreach (MethodInfo method in provider.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public)) { if (method.ReturnType.GetInterfaces().Contains(typeof(IActionResult))) { MethodHandleInfo info = new MethodHandleInfo(); info.MethodHandle = method.MethodHandle; info.MethodName = method.Name; actionMethods.Add(info); } } dictProviderMethods.Add(providerHandle, actionMethods.ToArray()); }
public static extern Type GetTypeFromHandle(RuntimeTypeHandle handle);
internal QCallTypeHandle(ref System.RuntimeTypeHandle rth) { _ptr = Unsafe.AsPointer(ref rth); _handle = rth.Value; }
public static System.Reflection.MethodBase GetMethodFromHandle(System.RuntimeMethodHandle handle, System.RuntimeTypeHandle declaringType) { throw null; }
public static System.Reflection.FieldInfo GetFieldFromHandle(System.RuntimeFieldHandle handle, System.RuntimeTypeHandle declaringType) { throw null; }
public static bool operator ==(Type left, Type right) { return(RuntimeTypeHandle.GetValueInternal(left._typeHandle) == RuntimeTypeHandle.GetValueInternal(right._typeHandle)); }
public override bool IsInstanceOfType([NotNullWhen(true)] object?o) => RuntimeTypeHandle.IsInstanceOfType(this, o);
public override Type GetElementType() => RuntimeTypeHandle.GetElementType(this);
/// <summary> /// Gets the type referenced by the specified type handle. /// </summary> /// <param name="handle">The object that refers to the type.</param> /// <returns></returns> public static Type GetTypeFromHandle(RuntimeTypeHandle handle) { return(Type.GetTypeFromHandleImpl(handle)); }
public System.TypedReference GetNextArg(System.RuntimeTypeHandle rth) { throw new PlatformNotSupportedException(SR.PlatformNotSupported_ArgIterator); // https://github.com/dotnet/coreclr/issues/9204 }
public static IMapHandler Create(PropertyInfo propmeta) { System.RuntimeTypeHandle handle = propmeta.PropertyType.TypeHandle; if (handle.Equals(RTHString)) { return(new MapHandler <T, String>(propmeta, (reader, index) => reader[index].ToString(), x => x)); } else if (handle.Equals(RTHInt)) { return(new MapHandler <T, Int32>(propmeta, (reader, index) => reader.GetInt32(index), x => { Int32 tmp; int.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHIntNullable)) { return(new MapHandler <T, Nullable <Int32> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <Int32>) : reader.GetInt32(index), x => { Int32 tmp; return int.TryParse(x, out tmp) ? tmp : default(Nullable <Int32>); })); } else if (handle.Equals(RTHDateTime)) { return(new MapHandler <T, DateTime>(propmeta, (reader, index) => reader.GetDateTime(index), x => { DateTime tmp; DateTime.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHDateTimeNullable)) { return(new MapHandler <T, Nullable <DateTime> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <DateTime>) : reader.GetDateTime(index), x => { DateTime tmp; return DateTime.TryParse(x, out tmp) ? tmp : default(Nullable <DateTime>); })); } else if (handle.Equals(RTHGuid)) { return(new MapHandler <T, Guid>(propmeta, (reader, index) => reader.GetGuid(index), x => { Guid tmp; Guid.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHGuidNullable)) { return(new MapHandler <T, Nullable <Guid> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <Guid>) : reader.GetGuid(index), x => { Guid tmp; return Guid.TryParse(x, out tmp) ? tmp : default(Nullable <Guid>); })); } else if (handle.Equals(RTHDouble)) { return(new MapHandler <T, double>(propmeta, (reader, index) => reader.GetDouble(index), x => { double tmp; double.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHDoubleNullable)) { return(new MapHandler <T, Nullable <double> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <double>) : reader.GetDouble(index), x => { double tmp; return double.TryParse(x, out tmp) ? tmp : default(Nullable <double>); })); } else if (handle.Equals(RTHInt64)) { return(new MapHandler <T, long>(propmeta, (reader, index) => reader.GetInt64(index), x => { long tmp; long.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHInt64Nullable)) { return(new MapHandler <T, Nullable <long> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <long>) : reader.GetInt64(index), x => { long tmp; return long.TryParse(x, out tmp) ? tmp : default(Nullable <long>); })); } else if (handle.Equals(RTHInt16)) { return(new MapHandler <T, short>(propmeta, (reader, index) => reader.GetInt16(index), x => { short tmp; short.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHInt16Nullable)) { return(new MapHandler <T, Nullable <short> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <short>) : reader.GetInt16(index), x => { short tmp; return short.TryParse(x, out tmp) ? tmp : default(Nullable <short>); })); } else if (handle.Equals(RTHBool)) { return(new MapHandler <T, bool>(propmeta, (reader, index) => reader.GetBoolean(index), x => { bool tmp; bool.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHBoolNullable)) { return(new MapHandler <T, Nullable <bool> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <bool>) : reader.GetBoolean(index), x => { bool tmp; return bool.TryParse(x, out tmp) ? tmp : default(Nullable <bool>); })); } else if (handle.Equals(RTHChar)) { return(new MapHandler <T, char>(propmeta, (reader, index) => reader.GetChar(index), x => { char tmp; char.TryParse(x, out tmp); return tmp; })); } else if (handle.Equals(RTHCharNullable)) { return(new MapHandler <T, Nullable <char> >(propmeta, (reader, index) => reader.IsDBNull(index) ? default(Nullable <char>) : reader.GetChar(index), x => { char tmp; return char.TryParse(x, out tmp) ? tmp : default(Nullable <char>); })); } else if (handle.Equals(RTHBytes)) { return(new MapHandler <T, byte[]>(propmeta, (reader, index) => reader.IsDBNull(index) ? default(byte[]) : (byte[])reader.GetValue(index), x => string.IsNullOrEmpty(x) ? default(byte[]) : System.Text.Encoding.UTF8.GetBytes(x))); } else if (propmeta.PropertyType.IsEnum) { return(new MapHandler <T>(propmeta)); } else { return(new MapHandler(propmeta)); } }
private Type(RuntimeTypeHandle typeHandle) { _typeHandle = typeHandle; }
public static Type GetTypeFromHandle(RuntimeTypeHandle rh) { return(new Type(rh)); }
public bool Equals(RuntimeTypeHandle handle) { return(value == handle.Value); }
private static extern unsafe void InternalMakeTypedReference(void *result, object target, RuntimeFieldHandle[] flds, RuntimeTypeHandle lastFieldType);
extern public TypedReference GetNextArg(RuntimeTypeHandle type);
public MapHandler(PropertyInfo pmeta) { this.setvalueHandler = pmeta.SetValue; this.getvalueHandler = pmeta.GetValue; this.propertyRTH = pmeta.PropertyType.TypeHandle; }
protected override bool IsCOMObjectImpl() => RuntimeTypeHandle.IsComObject(this, false);
public System.TypedReference GetNextArg(System.RuntimeTypeHandle rth) { throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204. }
internal QCallTypeHandle(ref System.RuntimeTypeHandle rth) : this(ref rth.m_type) { }
protected override TypeAttributes GetAttributeFlagsImpl() => RuntimeTypeHandle.GetAttributes(this);
protected override bool IsPointerImpl() => RuntimeTypeHandle.IsPointer(this);
private static extern Type GetTypeFromHandleImpl(RuntimeTypeHandle handle);