public virtual FieldReference ImportFieldReference(FieldReference fr, ImportContext context)
        {
            if (fr.DeclaringType.Module == m_module)
                return fr;

            FieldReference field = (FieldReference) GetMemberReference (fr);
            if (field != null)
                return field;

            field = new FieldReference (
                fr.Name,
                ImportTypeReference (fr.DeclaringType, context),
                ImportTypeReference (fr.FieldType, context));

            m_module.MemberReferences.Add (field);
            return field;
        }

		TypeSpecification GetTypeSpec (TypeSpecification original, ImportContext context)
		{
			TypeSpecification typeSpec;

			TypeReference elementType = ImportTypeReference (original.ElementType, context);
			if (original is PointerType) {
				typeSpec = new PointerType (elementType);
			} else if (original is ArrayType) { // deal with complex arrays
				typeSpec = new ArrayType (elementType);
			} else if (original is ReferenceType) {
				typeSpec = new ReferenceType (elementType);
			} else if (original is GenericInstanceType) {
				GenericInstanceType git = original as GenericInstanceType;
				GenericInstanceType genElemType = new GenericInstanceType (elementType);

				context.GenericContext.CheckProvider (genElemType.GetOriginalType (), git.GenericArguments.Count);
				foreach (TypeReference arg in git.GenericArguments)
					genElemType.GenericArguments.Add (ImportTypeReference (arg, context));

				typeSpec = genElemType;
			} else if (original is ModifierOptional) {
				TypeReference mt = (original as ModifierOptional).ModifierType;
				typeSpec = new ModifierOptional (elementType, ImportTypeReference (mt, context));
			} else if (original is ModifierRequired) {
				TypeReference mt = (original as ModifierRequired).ModifierType;
				typeSpec = new ModifierRequired (elementType, ImportTypeReference (mt, context));
			} else if (original is SentinelType) {
				typeSpec = new SentinelType (elementType);
			} else if (original is FunctionPointerType) {
				FunctionPointerType ori = original as FunctionPointerType;

				FunctionPointerType fnptr = new FunctionPointerType (
					ori.HasThis,
					ori.ExplicitThis,
					ori.CallingConvention,
					new MethodReturnType (ImportTypeReference (ori.ReturnType.ReturnType, context)));

				foreach (ParameterDefinition parameter in ori.Parameters)
					fnptr.Parameters.Add (new ParameterDefinition (ImportTypeReference (parameter.ParameterType, context)));

				typeSpec = fnptr;
			} else
				throw new ReflectionException ("Unknown element type: {0}", original.GetType ().Name);

			return typeSpec;
		}

 static GenericParameter GetGenericParameter(Type t, ImportContext context)
 {
     int pos = (int) t.GetType ().GetProperty ("GenericParameterPosition").GetValue (t, null);
     if (GenericParameterOfMethod (t))
         return context.GenericContext.Method.GenericParameters [pos];
     else
         return context.GenericContext.Type.GenericParameters [pos];
 }

 public MethodDefinition ImportMethodDefinition(MethodDefinition meth, ImportContext context)
 {
     return MethodDefinition.Clone (meth, context);
 }

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

		public FieldReference ImportFieldInfo (SR.FieldInfo fi, ImportContext context)
		{
			string sig = GetFieldSignature (fi);
			FieldReference f = (FieldReference) GetMemberReference (sig);
			if (f != null)
				return f;

			f = new FieldReference (
				fi.Name,
				ImportSystemType (fi.DeclaringType, context),
				ImportSystemType (fi.FieldType, context));

			m_module.MemberReferences.Add (f);
			return f;
		}

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

		TypeReference GetTypeSpec (Type t, ImportContext context)
		{
			Stack s = new Stack ();
			while (t.HasElementType || IsGenericTypeSpec (t)) {
				s.Push (t);
				if (t.HasElementType)
					t = t.GetElementType ();
				else if (IsGenericTypeSpec (t)) {
					t = (Type) t.GetType ().GetMethod ("GetGenericTypeDefinition").Invoke (t, null);
					break;
				}
			}

			TypeReference elementType = ImportSystemType (t, context);
			while (s.Count > 0) {
				t = (Type) s.Pop ();
				if (t.IsPointer)
					elementType = new PointerType (elementType);
				else if (t.IsArray)
					elementType = new ArrayType (elementType, t.GetArrayRank ());
				else if (t.IsByRef)
					elementType = new ReferenceType (elementType);
				else if (IsGenericTypeSpec (t))
					elementType = GetGenericType (t, elementType, context);
				else
					throw new ReflectionException ("Unknown element type");
			}

			return elementType;
		}

 public TypeDefinition ImportTypeDefinition(TypeDefinition type, ImportContext context)
 {
     return TypeDefinition.Clone (type, context);
 }

        protected static GenericParameter GetGenericParameter(GenericParameter gp, ImportContext context)
        {
            // walk generic context stack, looking for the generic parameter

            GenericParameter p = null;
            context.SearchGenericContextStack(delegate(GenericContext genericContext)
            {
                if (gp.Owner is TypeReference && genericContext.Type.GenericParameters.Count > gp.Position)
                {
                    p = genericContext.Type.GenericParameters[gp.Position];
                    return true;
                }
                else if (gp.Owner is MethodReference && genericContext.Method.GenericParameters.Count > gp.Position)
                {
                    p = genericContext.Method.GenericParameters[gp.Position];
                    return true;
                }
                else
                {
                    return false;
                }
            });
            if (p == null)
            {
                throw new NotSupportedException("Unable to find generic parameter " + gp + " in context " + context);
            }

            return p;
        }

        protected MethodReference GetMethodSpec(MethodReference meth, ImportContext context)
        {
            if (!(meth is GenericInstanceMethod))
                return null;

            GenericInstanceMethod gim = meth as GenericInstanceMethod;
            GenericInstanceMethod ngim = new GenericInstanceMethod (
                ImportMethodReference (gim.ElementMethod, context));

            context.GenericContext.CheckProvider (ngim.GetOriginalMethod (), gim.GenericArguments.Count);
            foreach (TypeReference arg in gim.GenericArguments)
                ngim.GenericArguments.Add (ImportTypeReference (arg, context));

            return ngim;
        }

		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);
//.........这里部分代码省略.........

        public virtual TypeReference ImportTypeReference(TypeReference t, ImportContext context)
        {
            if (t.Module == m_module)
                return t;

            if (t is TypeSpecification)
                return GetTypeSpec (t as TypeSpecification, context);

            if (t is GenericParameter)
                return GetGenericParameter (t as GenericParameter, context);

            TypeReference type = m_module.TypeReferences [t.FullName];
            if (type != null)
                return type;

            AssemblyNameReference asm;
            if (t.Scope is AssemblyNameReference)
                asm = ImportAssembly ((AssemblyNameReference) t.Scope);
            else if (t.Scope is ModuleDefinition)
                asm = ImportAssembly (((ModuleDefinition) t.Scope).Assembly.Name);
            else
                throw new NotImplementedException ();

            if (t.DeclaringType != null) {
                type = new TypeReference (t.Name, string.Empty, asm, t.IsValueType);
                type.DeclaringType = ImportTypeReference (t.DeclaringType, context);
            } else
                type = new TypeReference (t.Name, t.Namespace, asm, t.IsValueType);

            context.GenericContext.Type = type;

            foreach (GenericParameter gp in t.GenericParameters)
                type.GenericParameters.Add (GenericParameter.Clone (gp, context));

            m_module.TypeReferences.Add (type);
            return type;
        }

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

        MethodReference GetMethodSpec(MethodReference meth, ImportContext context)
        {
            if (!(meth is GenericInstanceMethod))
                return null;

            GenericInstanceMethod gim = meth as GenericInstanceMethod;
            GenericInstanceMethod ngim = new GenericInstanceMethod (
                ImportMethodReference (gim.ElementMethod, context));

            foreach (TypeReference arg in gim.GenericArguments)
                ngim.GenericArguments.Add (ImportTypeReference (arg, context));

            return ngim;
        }

        static GenericParameter GetGenericParameter(GenericParameter gp, ImportContext context)
        {
            GenericParameter p;
            if (gp.Owner is TypeReference)
                p = context.GenericContext.Type.GenericParameters [gp.Position];
            else if (gp.Owner is MethodReference)
                p = context.GenericContext.Method.GenericParameters [gp.Position];
            else
                throw new NotSupportedException ();

            return p;
        }

		GenericInstanceType GetGenericType (Type t, TypeReference element, ImportContext context)
		{
			GenericInstanceType git = new GenericInstanceType (element);
			foreach (Type genArg in GetGenericArguments (t))
				git.GenericArguments.Add (ImportSystemType (genArg, context));

			return git;
		}

		MethodReference ImportGenericInstanceMethod (SR.MethodInfo mi, ImportContext context)
		{
			SR.MethodInfo gmd = (SR.MethodInfo) mi.GetType ().GetMethod ("GetGenericMethodDefinition").Invoke (mi, null);
			GenericInstanceMethod gim = new GenericInstanceMethod (
				ImportMethodBase (gmd, gmd.ReturnType, context));

			foreach (Type genArg in GetGenericArguments (mi))
				gim.GenericArguments.Add (ImportSystemType (genArg, context));

			return gim;
		}

		static GenericParameter GetGenericParameter (Type t, ImportContext context)
		{
			int pos = (int) t.GetType ().GetProperty ("GenericParameterPosition").GetValue (t, null);
			IGenericParameterProvider provider;
			if (GenericParameterOfMethod (t))
				provider = context.GenericContext.Method;
			else
				provider = context.GenericContext.Type;

			if (provider == null)
				throw new InvalidOperationException ("Invalid context");

			return provider.GenericParameters [pos];
		}

		public MethodReference ImportConstructorInfo (SR.ConstructorInfo ci, ImportContext context)
		{
			return ImportMethodBase (ci, typeof (void), context);
		}