C# TypeReference.GetType方法代碼示例

        public static bool AreSame(TypeReference a, TypeReference b)
        {
            if (a.IsGenericParameter || b.IsGenericParameter)
            {
                return true;
            }
                //return AreSame((GenericParameter)a, (GenericParameter)b);

            if (a.MetadataType != b.MetadataType)
               return false;

            if (a is TypeSpecification || b is TypeSpecification)
            {
                if (a.GetType() != b.GetType())
                    return false;

                return AreSame((TypeSpecification)a, (TypeSpecification)b);
            }

            return a.FullName == b.FullName;
        }

 /// <summary>
 /// This method resolves a type. This method ignores the methods and fields. You have to
 /// resolve them manually.
 /// </summary>
 /// <param name="hostModule">The module in which the changes are made.</param>
 /// <param name="type">The type to resolve.</param>
 /// <param name="AddedClasses">Newly added classes to lookup while resolving.</param>
 /// <param name="TypesMap">A map of types to lookup while resolving.</param>
 /// <returns></returns>
 protected static TypeReference Resolve(
     ModuleDefinition hostModule,
     TypeReference type,
     Dictionary<TypeReference, TypeDefinition> AddedClasses,
     Dictionary<TypeReference, TypeReference> TypesMap)
 {
     if (type is GenericInstanceType)
     {
         GenericInstanceType gType = (GenericInstanceType)type;
         GenericInstanceType nType = new GenericInstanceType(Resolve(hostModule, gType.ElementType, AddedClasses, TypesMap));
         foreach (TypeReference t in gType.GenericArguments)
         {
             nType.GenericArguments.Add(Resolve(hostModule, t, AddedClasses, TypesMap));
         }
         return nType;
     }
     if (type == null || type is GenericParameter || (type.IsArray && type.GetElementType() is GenericParameter))
         return type;
     if (TypesMap.ContainsKey(type))
         return hostModule.Import(TypesMap[type]);
     foreach (TypeReference addedType in AddedClasses.Keys)
     {
         if (addedType == type)
         {
             return hostModule.Import(AddedClasses[addedType]);
         }
     }
     if (type.Module != hostModule)
     {
         TypeDefinition t = hostModule.GetType(type.FullName);
         if (t != null)
         {
             return (TypeReference)t;
         }
         if (hostModule == null || type == null)
             return type;
         else
         {
             try
             {
                 return hostModule.Import(type);
             }
             catch (Exception e)
             {
                 System.Console.WriteLine(type.GetElementType());
                 System.Console.WriteLine(type.GetType().FullName);
                 throw e;
             }
         }
     }
     else
         return type;
 }

        public static bool TypeMatch(TypeReference a, TypeReference b)
        {
            if (a is GenericParameter)
                return true;

            if (a is TypeSpecification || b is TypeSpecification) {
                if (a.GetType () != b.GetType ())
                    return false;

                return TypeMatch ((TypeSpecification) a, (TypeSpecification) b);
            }

            return a.FullName == b.FullName;
        }

		static bool TypeMatch (TypeReference a, TypeReference b, ref Dictionary<string,string> gp)
		{
			var gpa = a as GenericParameter;
			if (gpa != null) {
				if (gp == null)
					gp = new Dictionary<string, string> ();
				string match;
				if (!gp.TryGetValue (gpa.FullName, out match)) {
					// first use, we assume it will always be used this way
					gp.Add (gpa.FullName, b.ToString ());
					return true;
				}
				// re-use, it should match the previous usage
				return match == b.ToString ();
			}

			if (a is TypeSpecification || b is TypeSpecification) {
				if (a.GetType () != b.GetType ())
					return false;

				return TypeMatch ((TypeSpecification) a, (TypeSpecification) b, ref gp);
			}

			return a.FullName == b.FullName;
		}

        static bool TypeMatch(TypeReference a, TypeReference b)
        {
            if (a is GenericParameter)
                return true; // not exact, but a guess is enough for us

            if (a is TypeSpecification || b is TypeSpecification)
            {
                if (a.GetType() != b.GetType())
                    return false;

                return TypeMatch((TypeSpecification)a, (TypeSpecification)b);
            }

            return a.FullName == b.FullName;
        }

        // a must be exactly a TypeReference or a TypeDefinition
        static int typeReferenceHashCode(TypeReference a)
        {
            if (a == null)
                return 0;

            if (a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition))
                throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");

            int res = 0;

            res += a.Name.GetHashCode();
            res += a.Namespace.GetHashCode();
            res += typeHashCode(a.DeclaringType);
            res += scopeHashCode(a.Scope);

            return res;
        }

        // a and b must be either exactly a TypeReference or exactly a TypeDefinition
        static bool compareTypeReferences(TypeReference a, TypeReference b)
        {
            if ((a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition)) ||
                (b.GetType() != typeof(TypeReference) && b.GetType() != typeof(TypeDefinition)))
                throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");

            if (ReferenceEquals(a, b))
                return true;

            return a.Name == b.Name &&
                a.Namespace == b.Namespace &&
                compareTypes(a.DeclaringType, b.DeclaringType) &&
                compareScope(a.Scope, b.Scope);
        }

        public static bool compareTypes(TypeReference a, TypeReference b)
        {
            if (ReferenceEquals(a, b))
                return true;
            if (a == null || b == null)
                return false;

            var atype = a.GetType();
            var btype = b.GetType();
            if (atype != btype) {
                if ((atype == typeof(TypeReference) || atype == typeof(TypeDefinition)) &&
                    (btype == typeof(TypeReference) || btype == typeof(TypeDefinition)))
                    return compareTypeReferences(a, b);
                return false;
            }

            var type = getMemberReferenceType(a);
            switch (type) {
            case CecilType.ArrayType:
                return compareArrayTypes((ArrayType)a, (ArrayType)b);
            case CecilType.ByReferenceType:
                return compareByReferenceTypes((ByReferenceType)a, (ByReferenceType)b);
            case CecilType.FunctionPointerType:
                return compareFunctionPointerTypes((FunctionPointerType)a, (FunctionPointerType)b);
            case CecilType.GenericInstanceType:
                return compareGenericInstanceTypes((GenericInstanceType)a, (GenericInstanceType)b);
            case CecilType.GenericParameter:
                return compareGenericParameters((GenericParameter)a, (GenericParameter)b);
            case CecilType.OptionalModifierType:
                return compareOptionalModifierTypes((OptionalModifierType)a, (OptionalModifierType)b);
            case CecilType.PinnedType:
                return comparePinnedTypes((PinnedType)a, (PinnedType)b);
            case CecilType.PointerType:
                return comparePointerTypes((PointerType)a, (PointerType)b);
            case CecilType.RequiredModifierType:
                return compareRequiredModifierTypes((RequiredModifierType)a, (RequiredModifierType)b);
            case CecilType.SentinelType:
                return compareSentinelTypes((SentinelType)a, (SentinelType)b);
            case CecilType.TypeDefinition:
                return compareTypeDefinitions((TypeDefinition)a, (TypeDefinition)b);
            case CecilType.TypeReference:
                return compareTypeReferences((TypeReference)a, (TypeReference)b);
            default:
                throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
            }
        }

		static bool AreSame (TypeReference a, TypeReference b)
		{
			while (a is TypeSpecification || b is TypeSpecification) {
				if (a.GetType () != b.GetType ())
					return false;

				a = ((TypeSpecification) a).ElementType;
				b = ((TypeSpecification) b).ElementType;
			}

			if (a is GenericParameter || b is GenericParameter) {
				if (a.GetType() != b.GetType())
					return false;

				GenericParameter pa = (GenericParameter) a;
				GenericParameter pb = (GenericParameter) b;

				return pa.Position == pb.Position;
			}

			return a.FullName == b.FullName;
		}

		static bool AreSame (TypeReference a, TypeReference b)
		{
			if (a is TypeSpecification || b is TypeSpecification) {
				if (a.GetType () != b.GetType ())
					return false;

				return AreSame ((TypeSpecification) a, (TypeSpecification) b);
			}

			if (a is GenericParameter || b is GenericParameter) {
				if (a.GetType () != b.GetType ())
					return false;

				return AreSame ((GenericParameter) a, (GenericParameter) b);
			}

			return a.FullName == b.FullName;
		}

        private void DoValidateRoot(string label, TypeReference type)
        {
            string mesg = null;

            if (type != null)
            {
                if (type is TypeSpecification)
                    mesg = string.Format("{0} is a {1} ({2})", label, type.GetType(), type.FullName);

                else
                    // Probably not neccesary to do these checks but it shouldn't hurt.
                    DoValidateRoot(label, type.FullName);
            }

            if (mesg != null)
                Contract.Assert(false, mesg);
        }

        TypeReference GetTypeSpec(TypeReference t, ImportContext context)
        {
            Stack s = new Stack ();
            while (t is TypeSpecification) {
                s.Push (t);
                t = (t as TypeSpecification).ElementType;
            }

            TypeReference elementType = ImportTypeReference (t, context);
            while (s.Count > 0) {
                t = s.Pop () as TypeReference;
                if (t is PointerType)
                    elementType = new PointerType (elementType);
                else if (t is ArrayType) // deal with complex arrays
                    elementType = new ArrayType (elementType);
                else if (t is ReferenceType)
                    elementType = new ReferenceType (elementType);
                else if (t is GenericInstanceType) {
                    GenericInstanceType git = t as GenericInstanceType;
                    GenericInstanceType genElemType = new GenericInstanceType (elementType);
                    foreach (TypeReference arg in git.GenericArguments)
                        genElemType.GenericArguments.Add (ImportTypeReference (arg, context));

                    elementType = genElemType;
                } else
                    throw new ReflectionException ("Unknown element type: {0}", t.GetType ().Name);
            }

            return elementType;
        }

 public static void DumpType(TypeReference type)
 {
     TraceVerbose("TYPE DUMP: {0}: {1}", type, type.GetType());
       DumpGenericParameters(type);
       DumpGenericArguments(type);
 }

 private void AssertTypeReferencesAreIdentical(TypeReference expected, TypeReference actual)
 {
     Assert.Equal(expected.GetType(), actual.GetType());
     this.AssertGenericParametersAreIdentical(expected, actual);
     if (expected is GenericInstanceType)
     {
         this.AssertGenericArgumentsAreIdentical((GenericInstanceType)expected, (GenericInstanceType)actual);
     }
 }

        public static bool IsMatch(TypeReference a, TypeReference b)
        {
            if (a is TypeSpecification || b is TypeSpecification) {
            if (a.GetType() != b.GetType()) {
              return false;
            }
            return IsMatch((TypeSpecification)a, (TypeSpecification)b);
              }

              if (a is GenericParameter || b is GenericParameter) {
            if (a.GetType() != b.GetType()) {
              return false;
            }
              }

              return a.FullName == b.FullName;
        }