C# TypeWrapper类代码示例

		internal static ConstructorInfo AddAutomagicSerialization(TypeWrapper wrapper)
		{
			ConstructorInfo serializationCtor = null;
			if (wrapper.GetClassLoader().NoAutomagicSerialization)
			{
				// do nothing
			}
			else if ((wrapper.Modifiers & IKVM.Attributes.Modifiers.Enum) != 0)
			{
				MarkSerializable(wrapper);
			}
			else if (wrapper.IsSubTypeOf(serializable) && IsSafeForAutomagicSerialization(wrapper))
			{
				if (wrapper.IsSubTypeOf(externalizable))
				{
					MethodWrapper ctor = wrapper.GetMethodWrapper("<init>", "()V", false);
					if (ctor != null && ctor.IsPublic)
					{
						MarkSerializable(wrapper);
						ctor.Link();
						serializationCtor = AddConstructor(wrapper.TypeAsBuilder, ctor, null, true);
						if (!wrapper.BaseTypeWrapper.IsSubTypeOf(serializable))
						{
							AddGetObjectData(wrapper);
						}
						if (wrapper.BaseTypeWrapper.GetMethodWrapper("readResolve", "()Ljava.lang.Object;", true) != null)
						{
							RemoveReadResolve(wrapper);
						}
					}
				}
				else if (wrapper.BaseTypeWrapper.IsSubTypeOf(serializable))
				{
					ConstructorInfo baseCtor = wrapper.GetBaseSerializationConstructor();
					if (baseCtor != null && (baseCtor.IsFamily || baseCtor.IsFamilyOrAssembly))
					{
						MarkSerializable(wrapper);
						serializationCtor = AddConstructor(wrapper.TypeAsBuilder, null, baseCtor, false);
						AddReadResolve(wrapper);
					}
				}
				else
				{
					MethodWrapper baseCtor = wrapper.BaseTypeWrapper.GetMethodWrapper("<init>", "()V", false);
					if (baseCtor != null && baseCtor.IsAccessibleFrom(wrapper.BaseTypeWrapper, wrapper, wrapper))
					{
						MarkSerializable(wrapper);
						AddGetObjectData(wrapper);
#if STATIC_COMPILER
						// because the base type can be a __WorkaroundBaseClass__, we may need to replace the constructor
						baseCtor = ((AotTypeWrapper)wrapper).ReplaceMethodWrapper(baseCtor);
#endif
						baseCtor.Link();
						serializationCtor = AddConstructor(wrapper.TypeAsBuilder, baseCtor, null, true);
						AddReadResolve(wrapper);
					}
				}
			}
			return serializationCtor;
		}

 internal Meta(ScriptEngine engine, ModelInstance instance)
     : base(engine, engine.Object.InstancePrototype)
 {
     this.PopulateFunctions();
     this.instance = instance;
     this.typeWrapper = new TypeWrapper(engine, instance.Type);
 }

 internal static bool Emit(DynamicTypeWrapper.FinishContext context, TypeWrapper wrapper, CodeEmitter ilgen, ClassFile classFile, int i, ClassFile.Method.Instruction[] code, InstructionFlags[] flags)
 {
     if (i >= 3
         && (flags[i - 0] & InstructionFlags.BranchTarget) == 0
         && (flags[i - 1] & InstructionFlags.BranchTarget) == 0
         && (flags[i - 2] & InstructionFlags.BranchTarget) == 0
         && (flags[i - 3] & InstructionFlags.BranchTarget) == 0
         && code[i - 1].NormalizedOpCode == NormalizedByteCode.__ldc
         && code[i - 2].NormalizedOpCode == NormalizedByteCode.__ldc
         && code[i - 3].NormalizedOpCode == NormalizedByteCode.__ldc)
     {
         // we now have a structural match, now we need to make sure that the argument values are what we expect
         TypeWrapper tclass = classFile.GetConstantPoolClassType(code[i - 3].Arg1);
         TypeWrapper vclass = classFile.GetConstantPoolClassType(code[i - 2].Arg1);
         string fieldName = classFile.GetConstantPoolConstantString(code[i - 1].Arg1);
         if (tclass == wrapper && !vclass.IsUnloadable && !vclass.IsPrimitive && !vclass.IsNonPrimitiveValueType)
         {
             FieldWrapper field = wrapper.GetFieldWrapper(fieldName, vclass.SigName);
             if (field != null && !field.IsStatic && field.IsVolatile && field.DeclaringType == wrapper && field.FieldTypeWrapper == vclass)
             {
                 // everything matches up, now call the actual emitter
                 DoEmit(context, wrapper, ilgen, field);
                 return true;
             }
         }
     }
     return false;
 }

        private IList<Test> GetFixtures(Assembly assembly, IList names)
        {
            var fixtures = new List<Test>();
            var testTypes = GetCandidateFixtureTypes(assembly, names);
            int testcases = 0;
            foreach (Type testType in testTypes)
            {
                var typeInfo = new TypeWrapper(testType);

                try
                {
                    if (_unitySuiteBuilder.CanBuildFrom(typeInfo))
                    {
                        Test fixture = _unitySuiteBuilder.BuildFrom(typeInfo);
                        fixtures.Add(fixture);
                        testcases += fixture.TestCaseCount;
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogException(ex);
                }
            }


            return fixtures;
        }

        internal static bool IsEnabled(TypeWrapper tw)
        {
            string className = tw.Name;

            // match class name
            for (OptionNode n = classes; n != null; n = n.next)
            {
                if (n.name == className)
                {
                    return n.enabled;
                }
            }

            // match package name
            if (packages != null)
            {
                int len = className.Length;
                while (len > 0 && className[--len] != '.') ;

                do
                {
                    for (OptionNode n = packages; n != null; n = n.next)
                    {
                        if (String.Compare(n.name, 0, className, 0, len, false, CultureInfo.InvariantCulture) == 0 && len == n.name.Length)
                        {
                            return n.enabled;
                        }
                    }
                    while (len > 0 && className[--len] != '.') ;
                } while (len > 0);
            }

            return tw.GetClassLoader() == ClassLoaderWrapper.GetBootstrapClassLoader() ? sysAsserts : userAsserts;
        }

        public void WriteTypeName(TypeWrapper type)
        {
            if (this._builder.Length > 0)
                this._builder.Append(" ");

            string typeName = type.GetDisplayName(false);
            if (typeName == "Void")
                typeName = "void";

            WriteValue(typeName);
        }

		private static bool HasJavaMethods(TypeWrapper tw)
		{
			foreach (MethodWrapper mw in tw.GetMethods())
			{
				if (!mw.IsHideFromReflection && mw.Name != StringConstants.CLINIT)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasJavaMethods(TypeWrapper tw)
		{
			foreach (MethodWrapper mw in tw.GetMethods())
			{
				if (!mw.IsHideFromReflection && !mw.IsClassInitializer)
				{
					return true;
				}
			}
			return false;
		}

        public string GenerateSyntax(TypeWrapper type)
        {
            var syntax = new SyntaxWriter(this._version);

            if (type.IsPublic)
                syntax.WriteToken("public");

            if (type.IsEnum)
            {
                syntax.WriteToken("enum");
                syntax.WriteTypeName(type);
            }
            else
            {
                if (type.IsSealed)
                    syntax.WriteToken("sealed");
                if (type.IsAbstract)
                    syntax.WriteToken("abstract");
                if (type.IsStatic)
                    syntax.WriteToken("static");

                if (type.IsClass)
                    syntax.WriteToken("class");
                else if (type.IsInterface)
                    syntax.WriteToken("interface");
                else if (type.IsValueType)
                    syntax.WriteToken("struct");

                syntax.WriteTypeName(type);

                var baseType = type.BaseType;
                if (baseType != null)
                {
                    syntax.WriteRaw(" :");
                    syntax.WriteTypeName(baseType);
                }

                var interfaces = type.GetInterfaces();
                if (interfaces.Count > 0)
                {
                    syntax.WriteNewLineWithTab();

                    syntax.BeginCommaDelimitedList();
                    foreach (var face in interfaces.OrderBy(x => x.Name))
                    {
                        syntax.WriteTypeName(face);
                    }
                    syntax.EndCommaDelimitedList();
                }
            }

            return syntax.CurrentSyntax;
        }

		private static void WriteModifiers(BigEndianStream bes, TypeWrapper tw)
		{
			Modifiers mods = tw.ReflectiveModifiers & (Modifiers.Public | Modifiers.Final | Modifiers.Interface | Modifiers.Abstract);
			if ((mods & Modifiers.Interface) != 0)
			{
				mods &= ~Modifiers.Abstract;
				if (HasJavaMethods(tw))
				{
					mods |= Modifiers.Abstract;
				}
			}
			bes.WriteUInt32((uint)mods);
		}

 public void Test_ToStringShouldReturnTypeToString()
 {
     //---------------Set up test pack-------------------
     var type = MockRepository.GenerateMock<Type>();
     var expectedToString = GetRandomString();
     type.Stub(type1 => type1.ToString()).Return(expectedToString);
     TypeWrapper wrapper = new TypeWrapper(type);
     //---------------Assert Precondition----------------
     Assert.AreEqual(expectedToString, type.ToString());
     //---------------Execute Test ----------------------
     var toString = wrapper.ToString();
     //---------------Test Result -----------------------
     Assert.AreEqual(expectedToString, toString);
 }

		internal static long Compute(TypeWrapper tw)
		{
			MemoryStream mem = new MemoryStream();
			BigEndianStream bes = new BigEndianStream(mem);
			WriteClassName(bes, tw);
			WriteModifiers(bes, tw);
			WriteInterfaces(bes, tw);
			WriteFields(bes, tw);
			WriteStaticInitializer(bes, tw);
			WriteConstructors(bes, tw);
			WriteMethods(bes, tw);
			byte[] buf = sha1.ComputeHash(mem.ToArray());
			long hash = 0;
			for (int i = 7; i >= 0; i--)
			{
				hash <<= 8;
				hash |= buf[i];
			}
			return hash;
		}

		internal static void Create(CompilerClassLoader loader, string proxy)
		{
			string[] interfaces = proxy.Split(',');
			TypeWrapper[] wrappers = new TypeWrapper[interfaces.Length];
			for (int i = 0; i < interfaces.Length; i++)
			{
				try
				{
					wrappers[i] = loader.LoadClassByDottedNameFast(interfaces[i]);
				}
				catch (RetargetableJavaException)
				{
				}
				if (wrappers[i] == null)
				{
					StaticCompiler.IssueMessage(Message.UnableToCreateProxy, proxy, "unable to load interface " + interfaces[i]);
					return;
				}
			}
			Create(loader, proxy, wrappers);
		}

 public static IAsymmetricCipherKeyPairGenerator CreateGenerator(SecureRandom random, TypeWrapper kpGen,
                                                                 int keystrength)
 {
     var keypairGen = kpGen.Instance<IAsymmetricCipherKeyPairGenerator>();
     //var random = SecureRandomUtils.GetInstance(Model.RandomGenerator, Model.RandomGeneratorArgument);
     if (keypairGen is DsaKeyPairGenerator)
     {
         DsaParametersGenerator pGen = new DsaParametersGenerator();
         pGen.Init(keystrength, 80, random); //TODO:
         DsaParameters parameters = pGen.GenerateParameters();
         DsaKeyGenerationParameters genParam = new DsaKeyGenerationParameters(random, parameters);
         keypairGen.Init(genParam);
         return keypairGen;
     }
     if (keypairGen is ECKeyPairGenerator)
     {
         keypairGen.Init(new KeyGenerationParameters(random, keystrength));
         return keypairGen;
     }
     keypairGen.Init(new KeyGenerationParameters(random, keystrength));
     return keypairGen;
 }

	private static void DoEmit(DynamicTypeWrapper.FinishContext context, TypeWrapper wrapper, CodeEmitter ilgen, FieldWrapper field)
	{
		ConstructorBuilder cb;
		bool exists;
		lock (map)
		{
			exists = map.TryGetValue(field, out cb);
		}
		if (!exists)
		{
			// note that we don't need to lock here, because we're running as part of FinishCore, which is already protected by a lock
			TypeWrapper arfuTypeWrapper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.IntrinsicAtomicReferenceFieldUpdater");
			TypeBuilder tb = wrapper.TypeAsBuilder.DefineNestedType("__<ARFU>_" + field.Name + field.Signature.Replace('.', '/'), TypeAttributes.NestedPrivate | TypeAttributes.Sealed, arfuTypeWrapper.TypeAsBaseType);
			EmitCompareAndSet("compareAndSet", tb, field.GetField());
			EmitGet(tb, field.GetField());
			EmitSet("set", tb, field.GetField());

			cb = tb.DefineConstructor(MethodAttributes.Assembly, CallingConventions.Standard, Type.EmptyTypes);
			lock (map)
			{
				map.Add(field, cb);
			}
			CodeEmitter ctorilgen = CodeEmitter.Create(cb);
			ctorilgen.Emit(OpCodes.Ldarg_0);
			MethodWrapper basector = arfuTypeWrapper.GetMethodWrapper("<init>", "()V", false);
			basector.Link();
			basector.EmitCall(ctorilgen);
			ctorilgen.Emit(OpCodes.Ret);
			context.RegisterPostFinishProc(delegate
			{
				arfuTypeWrapper.Finish();
				tb.CreateType();
			});
		}
		ilgen.LazyEmitPop();
		ilgen.LazyEmitPop();
		ilgen.LazyEmitPop();
		ilgen.Emit(OpCodes.Newobj, cb);
	}