C# ImportContext.Import方法代码示例

		internal static PropertyDefinition Clone (PropertyDefinition prop, ImportContext context)
		{
			PropertyDefinition np = new PropertyDefinition (
				prop.Name,
				context.Import (prop.PropertyType),
				prop.Attributes);

			if (prop.HasConstant)
				np.Constant = prop.Constant;

			if (context.GenericContext.Type is TypeDefinition) {
				TypeDefinition type = context.GenericContext.Type as TypeDefinition;
				if (prop.SetMethod != null)
					np.SetMethod = type.Methods.GetMethod (prop.SetMethod.Name, prop.SetMethod.Parameters);
				if (prop.GetMethod != null)
					np.GetMethod = type.Methods.GetMethod (prop.GetMethod.Name, prop.GetMethod.Parameters);
			}

			foreach (CustomAttribute ca in prop.CustomAttributes)
				np.CustomAttributes.Add (CustomAttribute.Clone (ca, context));

			return np;
		}

		internal static MethodBody Clone (MethodBody body, MethodDefinition parent, ImportContext context)
		{
			MethodBody nb = new MethodBody (parent);
			nb.MaxStack = body.MaxStack;
			nb.InitLocals = body.InitLocals;
			nb.CodeSize = body.CodeSize;

			foreach (VariableDefinition var in body.Variables)
				nb.Variables.Add (new VariableDefinition (
					context.Import (var.VariableType)));

			foreach (Instruction instr in body.Instructions) {
				Instruction ni = new Instruction (instr.OpCode);

				switch (instr.OpCode.OperandType) {
				case OperandType.InlineParam :
				case OperandType.ShortInlineParam :
					int param = body.Method.Parameters.IndexOf ((ParameterDefinition) instr.Operand);
					ni.Operand = parent.Parameters [param];
					break;
				case OperandType.InlineVar :
				case OperandType.ShortInlineVar :
					int var = body.Variables.IndexOf ((VariableDefinition) instr.Operand);
					ni.Operand = nb.Variables [var];
					break;
				case OperandType.InlineField :
					ni.Operand = context.Import ((FieldReference) instr.Operand);
					break;
				case OperandType.InlineMethod :
					ni.Operand = context.Import ((MethodReference) instr.Operand);
					break;
				case OperandType.InlineType :
					ni.Operand = context.Import ((TypeReference) instr.Operand);
					break;
				case OperandType.InlineTok :
					if (instr.Operand is TypeReference)
						ni.Operand = context.Import ((TypeReference) instr.Operand);
					else if (instr.Operand is FieldReference)
						ni.Operand = context.Import ((FieldReference) instr.Operand);
					else if (instr.Operand is MethodReference)
						ni.Operand = context.Import ((MethodReference) instr.Operand);
					break;
				case OperandType.ShortInlineBrTarget :
				case OperandType.InlineBrTarget :
					break;
				default :
					ni.Operand = instr.Operand;
					break;
				}

				nb.Instructions.Add (ni);
			}

			for (int i = 0; i < body.Instructions.Count; i++) {
				Instruction instr = nb.Instructions [i];
				if (instr.OpCode.OperandType != OperandType.ShortInlineBrTarget &&
					instr.OpCode.OperandType != OperandType.InlineBrTarget)
					continue;

				instr.Operand = GetInstruction (body, nb, (Instruction) body.Instructions [i].Operand);
			}

			foreach (ExceptionHandler eh in body.ExceptionHandlers) {
				ExceptionHandler neh = new ExceptionHandler (eh.Type);
				neh.TryStart = GetInstruction (body, nb, eh.TryStart);
				neh.TryEnd = GetInstruction (body, nb, eh.TryEnd);
				neh.HandlerStart = GetInstruction (body, nb, eh.HandlerStart);
				neh.HandlerEnd = GetInstruction (body, nb, eh.HandlerEnd);

				switch (eh.Type) {
				case ExceptionHandlerType.Catch :
					neh.CatchType = context.Import (eh.CatchType);
					break;
				case ExceptionHandlerType.Filter :
					neh.FilterStart = GetInstruction (body, nb, eh.FilterStart);
					neh.FilterEnd = GetInstruction (body, nb, eh.FilterEnd);
					break;
				}

				nb.ExceptionHandlers.Add (neh);
			}

			return nb;
		}

        internal static GenericParameter Clone(GenericParameter gp, ImportContext context)
        {
            GenericParameter ngp;
            if (gp.Owner is TypeReference)
                ngp = new GenericParameter (gp.m_name, context.GenericContext.Type);
            else if (gp.Owner is MethodReference)
                ngp = new GenericParameter (gp.m_name, context.GenericContext.Method);
            else
                throw new NotSupportedException ();

            ngp.Position = gp.Owner.GenericParameters.IndexOf (gp);
            ngp.Attributes = gp.Attributes;

            foreach (TypeReference constraint in gp.Constraints)
                ngp.Constraints.Add (context.Import (constraint));
            foreach (CustomAttribute ca in gp.CustomAttributes)
                ngp.CustomAttributes.Add (CustomAttribute.Clone (ca, context));

            return ngp;
        }

        internal static MethodDefinition Clone(MethodDefinition meth, ImportContext context)
        {
            MethodDefinition nm = new MethodDefinition (
                meth.Name,
                RVA.Zero,
                meth.Attributes,
                meth.ImplAttributes,
                meth.HasThis,
                meth.ExplicitThis,
                meth.CallingConvention);

            context.GenericContext.Method = nm;

            foreach (GenericParameter p in meth.GenericParameters)
                nm.GenericParameters.Add (GenericParameter.Clone (p, context));

            nm.ReturnType.ReturnType = context.Import (meth.ReturnType.ReturnType);

            if (meth.ReturnType.HasConstant)
                nm.ReturnType.Constant = meth.ReturnType.Constant;

            if (meth.ReturnType.MarshalSpec != null)
                nm.ReturnType.MarshalSpec = meth.ReturnType.MarshalSpec;

            foreach (CustomAttribute ca in meth.ReturnType.CustomAttributes)
                nm.ReturnType.CustomAttributes.Add (CustomAttribute.Clone (ca, context));

            if (meth.PInvokeInfo != null)
                nm.PInvokeInfo = meth.PInvokeInfo; // TODO: import module ?
            foreach (ParameterDefinition param in meth.Parameters)
                nm.Parameters.Add (ParameterDefinition.Clone (param, context));
            foreach (MethodReference ov in meth.Overrides)
                nm.Overrides.Add (context.Import (ov));
            foreach (CustomAttribute ca in meth.CustomAttributes)
                nm.CustomAttributes.Add (CustomAttribute.Clone (ca, context));
            foreach (SecurityDeclaration sec in meth.SecurityDeclarations)
                nm.SecurityDeclarations.Add (SecurityDeclaration.Clone (sec));

            if (meth.Body != null)
                nm.Body = MethodBody.Clone (meth.Body, nm, context);

            return nm;
        }

        internal static EventDefinition Clone(EventDefinition evt, ImportContext context)
        {
            EventDefinition ne = new EventDefinition (
                evt.Name,
                context.Import (evt.EventType),
                evt.Attributes);

            if (context != null && context.GenericContext.Type is TypeDefinition) {
                TypeDefinition type = context.GenericContext.Type as TypeDefinition;
                if (evt.AddMethod != null)
                    ne.AddMethod = type.Methods.GetMethod (evt.AddMethod.Name) [0];
                if (evt.InvokeMethod != null)
                    ne.InvokeMethod = type.Methods.GetMethod (evt.InvokeMethod.Name) [0];
                if (evt.RemoveMethod != null)
                    ne.RemoveMethod = type.Methods.GetMethod (evt.RemoveMethod.Name) [0];
            }

            foreach (CustomAttribute ca in evt.CustomAttributes)
                ne.CustomAttributes.Add (CustomAttribute.Clone (ca, context));

            return ne;
        }

		internal static CustomAttribute Clone (CustomAttribute custattr, ImportContext context)
		{
			CustomAttribute ca = new CustomAttribute (context.Import (custattr.Constructor));
			custattr.CopyTo (ca);
			return ca;
		}

		internal static FieldDefinition Clone (FieldDefinition field, ImportContext context)
		{
			FieldDefinition nf = new FieldDefinition (
				field.Name,
				context.Import (field.FieldType),
				field.Attributes);

			if (field.HasConstant)
				nf.Constant = field.Constant;
			if (field.MarshalSpec != null)
				nf.MarshalSpec = field.MarshalSpec.CloneInto (nf);
			if (field.RVA != RVA.Zero)
				nf.InitialValue = field.InitialValue;
			else
				nf.InitialValue = new byte [0];
			if (field.HasLayoutInfo)
				nf.Offset = field.Offset;

			foreach (CustomAttribute ca in field.CustomAttributes)
				nf.CustomAttributes.Add (CustomAttribute.Clone (ca, context));

			return nf;
		}

		internal static MethodBody Clone (MethodBody body, MethodDefinition parent, ImportContext context)
		{
			MethodBody nb = new MethodBody (parent);
			nb.MaxStack = body.MaxStack;
			nb.InitLocals = body.InitLocals;
			nb.CodeSize = body.CodeSize;

			CilWorker worker = nb.CilWorker;

			if (body.HasVariables) {
				foreach (VariableDefinition var in body.Variables)
					nb.Variables.Add (new VariableDefinition (
						var.Name, var.Index, parent,
						context.Import (var.VariableType)));
			}

			foreach (Instruction instr in body.Instructions) {
				Instruction ni = new Instruction (instr.OpCode);

				switch (instr.OpCode.OperandType) {
				case OperandType.InlineParam :
				case OperandType.ShortInlineParam :
					if (instr.Operand == body.Method.This)
						ni.Operand = nb.Method.This;
					else {
						int param = body.Method.Parameters.IndexOf ((ParameterDefinition) instr.Operand);
						ni.Operand = parent.Parameters [param];
					}
					break;
				case OperandType.InlineVar :
				case OperandType.ShortInlineVar :
					int var = body.Variables.IndexOf ((VariableDefinition) instr.Operand);
					ni.Operand = nb.Variables [var];
					break;
				case OperandType.InlineField :
					ni.Operand = context.Import ((FieldReference) instr.Operand);
					break;
				case OperandType.InlineMethod :
					ni.Operand = context.Import ((MethodReference) instr.Operand);
					break;
				case OperandType.InlineType :
					ni.Operand = context.Import ((TypeReference) instr.Operand);
					break;
				case OperandType.InlineTok :
					if (instr.Operand is TypeReference)
						ni.Operand = context.Import ((TypeReference) instr.Operand);
					else if (instr.Operand is FieldReference)
						ni.Operand = context.Import ((FieldReference) instr.Operand);
					else if (instr.Operand is MethodReference)
						ni.Operand = context.Import ((MethodReference) instr.Operand);
					break;
				case OperandType.ShortInlineBrTarget :
				case OperandType.InlineBrTarget :
				case OperandType.InlineSwitch :
					break;
				default :
					ni.Operand = instr.Operand;
					break;
				}

				worker.Append (ni);
			}

			for (int i = 0; i < body.Instructions.Count; i++) {
				Instruction instr = nb.Instructions [i];
				Instruction oldi = body.Instructions [i];

				if (instr.OpCode.OperandType == OperandType.InlineSwitch) {
					Instruction [] olds = (Instruction []) oldi.Operand;
					Instruction [] targets = new Instruction [olds.Length];

					for (int j = 0; j < targets.Length; j++)
						targets [j] = GetInstruction (body, nb, olds [j]);

					instr.Operand = targets;
				} else if (instr.OpCode.OperandType == OperandType.ShortInlineBrTarget || instr.OpCode.OperandType == OperandType.InlineBrTarget)
					instr.Operand = GetInstruction (body, nb, (Instruction) oldi.Operand);
			}

			if (!body.HasExceptionHandlers)
				return nb;

			foreach (ExceptionHandler eh in body.ExceptionHandlers) {
				ExceptionHandler neh = new ExceptionHandler (eh.Type);
				neh.TryStart = GetInstruction (body, nb, eh.TryStart);
				neh.TryEnd = GetInstruction (body, nb, eh.TryEnd);
				neh.HandlerStart = GetInstruction (body, nb, eh.HandlerStart);
				neh.HandlerEnd = GetInstruction (body, nb, eh.HandlerEnd);

				switch (eh.Type) {
				case ExceptionHandlerType.Catch :
					neh.CatchType = context.Import (eh.CatchType);
					break;
				case ExceptionHandlerType.Filter :
					neh.FilterStart = GetInstruction (body, nb, eh.FilterStart);
					neh.FilterEnd = GetInstruction (body, nb, eh.FilterEnd);
					break;
				}

				nb.ExceptionHandlers.Add (neh);
//.........这里部分代码省略.........

		static void CloneConstraints (GenericParameter gp, GenericParameter ngp, ImportContext context)
		{
			if (gp.HasConstraints) {
				foreach (TypeReference constraint in gp.Constraints)
					ngp.Constraints.Add (context.Import (constraint));
			}
		}

        internal static ParameterDefinition Clone(ParameterDefinition param, ImportContext context)
        {
            ParameterDefinition np = new ParameterDefinition (
                param.Name,
                param.Sequence,
                param.Attributes,
                context.Import (param.ParameterType));

            if (param.HasConstant)
                np.Constant = param.Constant;

            if (param.MarshalSpec != null)
                np.MarshalSpec = param.MarshalSpec;

            foreach (CustomAttribute ca in param.CustomAttributes)
                np.CustomAttributes.Add (CustomAttribute.Clone (ca, context));

            return np;
        }

        internal static CustomAttribute Clone(CustomAttribute custattr, ImportContext context)
        {
            CustomAttribute ca = new CustomAttribute (context.Import (custattr.Constructor));
            if (!custattr.IsReadable) {
                ca.IsReadable = false;
                ca.Blob = custattr.Blob;
                return ca;
            }

            foreach (object o in custattr.ConstructorParameters)
                ca.ConstructorParameters.Add (o);
            Clone (custattr.Fields, ca.Fields);
            Clone (custattr.FieldTypes, ca.FieldTypes);
            Clone (custattr.Properties, ca.Properties);
            Clone (custattr.PropertyTypes, ca.PropertyTypes);
            return ca;
        }

        internal static TypeDefinition Clone(TypeDefinition type, ImportContext context)
        {
            TypeDefinition nt = new TypeDefinition (
                type.Name,
                type.Namespace,
                type.Attributes);

            context.GenericContext.Type = nt;

            foreach (GenericParameter p in type.GenericParameters)
                nt.GenericParameters.Add (GenericParameter.Clone (p, context));

            if (type.BaseType != null)
                nt.BaseType = context.Import (type.BaseType);

            if (type.HasLayoutInfo) {
                nt.ClassSize = type.ClassSize;
                nt.PackingSize = type.PackingSize;
            }

            foreach (FieldDefinition field in type.Fields)
                nt.Fields.Add (FieldDefinition.Clone (field, context));
            foreach (MethodDefinition ctor in type.Constructors)
                nt.Constructors.Add (MethodDefinition.Clone (ctor, context));
            foreach (MethodDefinition meth in type.Methods)
                nt.Methods.Add (MethodDefinition.Clone (meth, context));
            foreach (EventDefinition evt in type.Events)
                nt.Events.Add (EventDefinition.Clone (evt, context));
            foreach (PropertyDefinition prop in type.Properties)
                nt.Properties.Add (PropertyDefinition.Clone (prop, context));
            foreach (TypeReference intf in type.Interfaces)
                nt.Interfaces.Add (context.Import (intf));
            foreach (TypeDefinition nested in type.NestedTypes)
                nt.NestedTypes.Add (Clone (nested, context));
            foreach (CustomAttribute ca in type.CustomAttributes)
                nt.CustomAttributes.Add (CustomAttribute.Clone (ca, context));
            foreach (SecurityDeclaration dec in type.SecurityDeclarations)
                nt.SecurityDeclarations.Add (SecurityDeclaration.Clone (dec));

            return nt;
        }