C# CustomModifiers类代码示例

		internal LocalVariableInfo(int index, Type type, bool pinned, CustomModifiers customModifiers)
		{
			this.index = index;
			this.type = type;
			this.pinned = pinned;
			this.customModifiers = customModifiers;
		}

 public void SetSignature(Type returnType, CustomModifiers returnTypeCustomModifiers, Type[] parameterTypes, CustomModifiers[] parameterTypeCustomModifiers)
 {
     method.signature = new MethodSignature(
         returnType ?? method.Module.universe.System_Void,
         Util.Copy(parameterTypes),
         PackedCustomModifiers.CreateFromExternal(returnTypeCustomModifiers, parameterTypeCustomModifiers, parameterTypes.Length),
         method.signature.CallingConvention,
         method.signature.GenericParameterCount);
 }

		internal FieldBuilder(TypeBuilder type, string name, Type fieldType, CustomModifiers customModifiers, FieldAttributes attribs)
		{
			this.typeBuilder = type;
			this.name = name;
			this.pseudoToken = type.ModuleBuilder.AllocPseudoToken();
			this.nameIndex = type.ModuleBuilder.Strings.Add(name);
			this.fieldSig = FieldSignature.Create(fieldType, customModifiers);
			ByteBuffer sig = new ByteBuffer(5);
			fieldSig.WriteSig(this.typeBuilder.ModuleBuilder, sig);
			this.signature = this.typeBuilder.ModuleBuilder.Blobs.Add(sig);
			this.attribs = attribs;
			this.typeBuilder.ModuleBuilder.Field.AddVirtualRecord();
		}

 internal static PackedCustomModifiers CreateFromExternal(CustomModifiers returnTypeCustomModifiers, CustomModifiers[] parameterTypeCustomModifiers, int parameterCount)
 {
     CustomModifiers[] customModifiers = null;
     Pack(ref customModifiers, 0, returnTypeCustomModifiers, parameterCount + 1);
     if (parameterTypeCustomModifiers != null)
     {
         for (int i = 0; i < parameterCount; i++)
         {
             Pack(ref customModifiers, i + 1, parameterTypeCustomModifiers[i], parameterCount + 1);
         }
     }
     return new PackedCustomModifiers(customModifiers);
 }

			public override void __AddArgument(Type argument, bool pinned, CustomModifiers customModifiers)
			{
				if (pinned)
				{
					args.Add(MarkerType.Pinned);
				}
				foreach (CustomModifiers.Entry mod in customModifiers)
				{
					args.Add(mod.IsRequired ? MarkerType.ModReq : MarkerType.ModOpt);
					args.Add(mod.Type);
				}
				args.Add(argument);
				paramCount++;
			}

		public abstract Type[] __ResolveOptionalParameterTypes(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments, out CustomModifiers[] customModifiers);

		private static CustomModifiers ReadCustomModifiers(ModuleReader module, ByteReader br, IGenericContext context)
		{
			CustomModifiers mods = new CustomModifiers();
			byte b = br.PeekByte();
			if (IsCustomModifier(b))
			{
				List<Type> required = new List<Type>();
				List<Type> optional = new List<Type>();
				while (IsCustomModifier(b))
				{
					bool req = br.ReadByte() == ELEMENT_TYPE_CMOD_REQD;
					Type type = ReadTypeDefOrRefEncoded(module, br, context);
					(req ? required : optional).Add(type);
					b = br.PeekByte();
				}
				mods.required = required.ToArray();
				mods.optional = optional.ToArray();
			}
			return mods;
		}

 public void __SetSignature(Type returnType, CustomModifiers returnTypeCustomModifiers, Type[] parameterTypes, CustomModifiers[] parameterTypeCustomModifiers)
 {
     SetSignature(returnType, parameterTypes, PackedCustomModifiers.CreateFromExternal(returnTypeCustomModifiers, parameterTypeCustomModifiers, Util.NullSafeLength(parameterTypes)));
 }

		protected override Type Wrap(Type type, CustomModifiers mods)
		{
			return Make(type, mods);
		}

		protected static void WriteCustomModifiers(ModuleBuilder module, ByteBuffer bb, CustomModifiers modifiers)
		{
			foreach (CustomModifiers.Entry entry in modifiers)
			{
				bb.Write(entry.IsRequired ? ELEMENT_TYPE_CMOD_REQD : ELEMENT_TYPE_CMOD_OPT);
				bb.WriteTypeDefOrRefEncoded(module.GetTypeTokenForMemberRef(entry.Type));
			}
		}

		internal static PackedCustomModifiers Wrap(CustomModifiers[] modifiers)
		{
			return new PackedCustomModifiers(modifiers);
		}

		private PackedCustomModifiers(CustomModifiers[] customModifiers)
		{
			this.customModifiers = customModifiers;
		}

		private FieldSignature(Type fieldType, CustomModifiers mods)
		{
			this.fieldType = fieldType;
			this.mods = mods;
		}

		internal static FieldSignature Create(Type fieldType, CustomModifiers customModifiers)
		{
			return new FieldSignature(fieldType, customModifiers);
		}

		private GenericTypeInstance(Type type, Type[] args, CustomModifiers[] mods)
		{
			this.type = type;
			this.args = args;
			this.mods = mods;
		}