C# IType.AcceptVisitor方法代码示例

        public static MethodBuilder Compile(IType functorType, string variableName, 
            TypeBuilder utilityClass, string[] genericParameters, IRuntimeContainer runtimeContainer)
        {
            var genericParameterNames = new[]
            {
                Constants.FMapMethodInputParameterName,
                Constants.FMapMethodOutputParameterName
            }.Concat(genericParameters).ToArray();

            var fmap = utilityClass.DefineMethod(Constants.FMapMethodName, MethodAttributes.Public | MethodAttributes.Static);
            var fmapParameters = fmap.DefineGenericParameters(genericParameterNames);

            fmap.SetReturnType(typeof(IFunction<,>).MakeGenericType(fmapParameters.Take(2).Select(t => FunctorTypeMapper.Map(functorType, variableName, t, fmapParameters, runtimeContainer)).ToArray()));

            fmap.SetParameters(typeof(IFunction<,>).MakeGenericType(fmapParameters.Take(2).ToArray()));

            var fmapBody = fmap.GetILGenerator();

            functorType.AcceptVisitor(new FmapCompiler(fmapBody, variableName, fmapParameters, runtimeContainer));

            fmapBody.Emit(OpCodes.Ret);

            return fmap;
        }

 /// <summary>
 /// Gets the entity that owns the type parameters occurring in the specified type.
 /// If both class and method type parameters are present, the method is returned.
 /// Returns null if the specified type is closed.
 /// </summary>
 /// <seealso cref="IsOpen"/>
 static IEntity GetTypeParameterOwner(IType type)
 {
     if (type == null)
         throw new ArgumentNullException("type");
     TypeClassificationVisitor v = new TypeClassificationVisitor();
     type.AcceptVisitor(v);
     return v.typeParameterOwner;
 }

		void AddRelationshipsForType(NodeBase node, IType type)
		{
			type.AcceptVisitor(new AnalysisTypeVisitor(this, node));
		}

		/// <summary>
		/// Substitutes the class type parameters in the <paramref name="type"/> with the
		/// type arguments of this parameterized type.
		/// </summary>
		public IType SubstituteInType(IType type)
		{
			return type.AcceptVisitor(new TypeParameterSubstitution(typeArguments, null));
		}

 internal static IType Substitute(IType type, TypeVisitor substitution)
 {
     if (substitution == null)
         return type;
     else
         return type.AcceptVisitor(substitution);
 }

		/// <summary>
		/// Replaces all occurrences of method type parameters in the given type
		/// by normalized type parameters. This allows comparing parameter types from different
		/// generic methods.
		/// </summary>
		public static IType NormalizeMethodTypeParameters(IType type)
		{
			return type.AcceptVisitor(normalizeMethodTypeParameters);
		}

			public override IType VisitOtherType(IType type)
			{
				return NullableType.Create(compilation, type.AcceptVisitor(typeParameterSubstitution));
			}

 /// <summary>
 /// Substitutes the class type parameters in the <paramref name="type"/> with the
 /// type arguments of this parameterized type.
 /// </summary>
 public IType SubstituteInType(IType type)
 {
     return type.AcceptVisitor(new Substitution(typeArguments));
 }

		/// <summary>
		/// Gets whether there is an identity conversion from <paramref name="fromType"/> to <paramref name="toType"/>
		/// </summary>
		public bool IdentityConversion(IType fromType, IType toType)
		{
			// C# 4.0 spec: §6.1.1
			return fromType.AcceptVisitor(dynamicErasure).Equals(toType.AcceptVisitor(dynamicErasure));
		}