C# TypeWrapper.GetClassLoader方法代码示例

		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 override bool InternalsVisibleToImpl(TypeWrapper wrapper, TypeWrapper friend)
 {
     ClassLoaderWrapper other = friend.GetClassLoader();
     if (this == other)
     {
         return true;
     }
     AssemblyName otherName;
     #if STATIC_COMPILER
     CompilerClassLoader ccl = other as CompilerClassLoader;
     if (ccl == null)
     {
         return false;
     }
     otherName = ccl.GetAssemblyName();
     #else
     AssemblyClassLoader acl = other as AssemblyClassLoader;
     if (acl == null)
     {
         return false;
     }
     otherName = acl.GetAssembly(friend).GetName();
     #endif
     return GetLoader(GetAssembly(wrapper)).InternalsVisibleTo(otherName);
 }

 internal Assembly GetAssembly(TypeWrapper wrapper)
 {
     Debug.Assert(wrapper.GetClassLoader() == this);
     while (wrapper.IsFakeNestedType)
     {
         wrapper = wrapper.DeclaringTypeWrapper;
     }
     return wrapper.TypeAsBaseType.Assembly;
 }

		internal override bool InternalsVisibleToImpl(TypeWrapper wrapper, TypeWrapper friend)
		{
			Debug.Assert(wrapper.GetClassLoader() == this);
			ClassLoaderWrapper other = friend.GetClassLoader();
			// TODO ideally we should also respect InternalsVisibleToAttribute.Annotation here
			if (this == other || internalsVisibleTo.Contains(other))
			{
				return true;
			}
			CompilerClassLoader ccl = other as CompilerClassLoader;
			if (ccl != null)
			{
				AddInternalsVisibleToAttribute(ccl);
				return true;
			}
			return false;
		}

		private static string AssemblyQualifiedName(TypeWrapper tw)
		{
			ClassLoaderWrapper loader = tw.GetClassLoader();
			AssemblyClassLoader acl = loader as AssemblyClassLoader;
			if(acl != null)
			{
				return tw.Name + ", " + acl.GetAssembly(tw).FullName;
			}
			CompilerClassLoader ccl = loader as CompilerClassLoader;
			if(ccl != null)
			{
				return tw.Name + ", " + ccl.GetTypeWrapperFactory().ModuleBuilder.Assembly.FullName;
			}
			return tw.Name + " (unknown assembly)";
		}

			internal override void Link(TypeWrapper thisType)
			{
				lock (this)
				{
					if (argTypeWrappers != null)
					{
						return;
					}
				}
				ClassLoaderWrapper classLoader = thisType.GetClassLoader();
				TypeWrapper[] args = classLoader.ArgTypeWrapperListFromSigNoThrow(descriptor);
				TypeWrapper ret = classLoader.RetTypeWrapperFromSigNoThrow(descriptor);
				lock (this)
				{
					if (argTypeWrappers == null)
					{
						argTypeWrappers = args;
						retTypeWrapper = ret;
					}
				}
			}

 private static string GetAssemblyName(TypeWrapper tw)
 {
     ClassLoaderWrapper loader = tw.GetClassLoader();
     AssemblyClassLoader acl = loader as AssemblyClassLoader;
     if (acl != null)
     {
         return acl.GetAssembly(tw).FullName;
     }
     else
     {
         return ((GenericClassLoaderWrapper)loader).GetName();
     }
 }

 internal override bool InternalsVisibleToImpl(TypeWrapper wrapper, TypeWrapper friend)
 {
     ClassLoaderWrapper other = friend.GetClassLoader();
     if (this == other)
     {
     #if STATIC_COMPILER || STUB_GENERATOR
         return true;
     #else
         // we're OK if the type being accessed (wrapper) is a dynamic type
         // or if the dynamic assembly has internal access
         return GetAssembly(wrapper).Equals(GetTypeWrapperFactory().ModuleBuilder.Assembly)
             || GetTypeWrapperFactory().HasInternalAccess;
     #endif
     }
     AssemblyName otherName;
     #if STATIC_COMPILER
     CompilerClassLoader ccl = other as CompilerClassLoader;
     if (ccl == null)
     {
         return false;
     }
     otherName = ccl.GetAssemblyName();
     #else
     AssemblyClassLoader acl = other as AssemblyClassLoader;
     if (acl == null)
     {
         return false;
     }
     otherName = acl.GetAssembly(friend).GetName();
     #endif
     return GetLoader(GetAssembly(wrapper)).InternalsVisibleTo(otherName);
 }

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

        internal static bool TryGet(TypeWrapper wrapper, PropertyInfo property, out FieldWrapper accessStub)
        {
            NameSigAttribute nameSig = AttributeHelper.GetNameSig(property);
            bool hideFromReflection = AttributeHelper.IsHideFromReflection(property);

            if (nameSig != null || hideFromReflection)
            {
                TypeWrapper type;
                string name;
                string sig;
                if (nameSig == null)
                {
                    type = ClassLoaderWrapper.GetWrapperFromType(property.PropertyType);
                    name = property.Name;
                    sig = type.SigName;
                }
                else
                {
                    type = wrapper.GetClassLoader().FieldTypeWrapperFromSigNoThrow(nameSig.Sig);
                    name = nameSig.Name;
                    sig = nameSig.Sig;
                }
                Modifiers modifiers;
                MemberFlags flags = MemberFlags.AccessStub;
                if (hideFromReflection)
                {
                    // it's a Type 1 access stub (to make inherited fields visible)
                    flags |= MemberFlags.HideFromReflection;
                    modifiers = GetModifiers(property);
                }
                else
                {
                    // it's a Type 2 access stub (to make fields that have a non-public field type visible)
                    ModifiersAttribute attr = AttributeHelper.GetModifiersAttribute(property);
                    modifiers = attr.Modifiers;
                    if (attr.IsInternal)
                    {
                        flags |= MemberFlags.InternalAccess;
                    }
                }
                accessStub = new CompiledAccessStubFieldWrapper(wrapper, property, type, name, sig, modifiers, flags);
                return true;
            }
            else
            {
                accessStub = null;
                return false;
            }
        }