C# TypeNode.IsAssignableTo方法代码示例

    /// <summary>
    /// Returns a list of CfgBlock that are handlers of the current block, handling an exception
    /// of the given type, or a subtype thereof.
    /// </summary>
    /// <param name="exception">Type of exception thrown. It is assumed that any actual subtype could be thrown</param>
    /// <returns>All handlers that could apply directly to this exception.
    ///  In addition, if the method might not handle it, then the ExceptionExit block is
    /// part of this list.</returns>
    public System.Collections.IEnumerable/*CfgBlock*/ HandlersMatching(TypeNode exception) {
      ArrayList handlers = new ArrayList();

      CfgBlock currentBlock = this;

      while (currentBlock != null) {
        CfgBlock handler = this.cfg.ExceptionHandler(currentBlock);

        if (handler == null || handler.Statements == null || handler.Statements.Count < 1) break;

        Catch stat = handler.Statements[0] as Catch;

        if (stat != null) {
          if (exception.IsAssignableTo(stat.Type)) {
            // handles exceptions completely
            handlers.Add(handler);
            break;
          }
          if (stat.Type.IsAssignableTo(exception)) {
            // handles part of it
            handlers.Add(handler);
          }
          currentBlock = handler;
        }
        else {
          // must be the Unwind block
          handlers.Add(handler);
          break;
        }
      }
      return handlers;
    }

        private static bool IsSubclassOf(TypeNode t1, TypeNode t2)
        {
            Contract.Requires(t1 != null);

            if (t2 == null) return false;

            return t1.IsAssignableTo(t2);
        }

        private static Method FindImplementedMethod(MethodList candidates, TypeNode targetTypeInstance)
        {
            if (candidates != null)
            {
                for (int i = 0; i < candidates.Count; i++)
                {
                    var candidate = candidates[i];
                    if (candidate == null) continue;

                    if (targetTypeInstance.IsAssignableTo(candidate.DeclaringType)) return candidate;
                }
            }

            return null;
        }

		public static TypeNode LeastCommonAncestor(TypeNode t1, TypeNode t2) 
		{
			if (t1.IsAssignableTo(t2)) 
			{
				return t2;
			}

			// walk up t1 until assignable to t2
			TypeNode frame = t1;
			while (frame != null) 
			{
				if (t2.IsAssignableTo(frame))
				{
					return frame;
				}

				frame = frame.BaseType;
			}

			// if we get here, we haven't found a common basetype. Return object

			return Cci.SystemTypes.Object;
		}

   public bool TypeMatches(TypeNode t) {
     if (types == null || t == null) return true;
     foreach (TypeNode a in types) {
       if (a == null) return true;
       if (t.IsAssignableTo(a)) return true;
     }
     return false;
 }

        /// <summary>
        /// This is used to see if a type and parameter are valid template arguments
        /// </summary>
        /// <param name="type">The type to check</param>
        /// <param name="parameter">The parameter to check</param>
        /// <returns>True if it is valid, false if not</returns>
        private static bool IsValidTemplateArgument(TypeNode type, TypeNode parameter)
        {
            if(type == null)
                throw new ArgumentNullException("type");

            // Check that the parameter really is a type parameter
            ITypeParameter itp = parameter as ITypeParameter;

            if(itp == null)
                throw new ArgumentException("The 'parameter' argument is null or not an 'ITypeParameter'.");

            // Test constraints
            bool reference = ((itp.TypeParameterFlags & TypeParameterFlags.ReferenceTypeConstraint) > 0);

            if(reference && type.IsValueType)
                return (false);

            bool value = ((itp.TypeParameterFlags & TypeParameterFlags.ValueTypeConstraint) > 0);

            if(value && !type.IsValueType)
                return (false);

            InterfaceList contracts = parameter.Interfaces;

            if(contracts != null)
                foreach(Interface contract in contracts)
                    if(!type.IsAssignableTo(contract))
                        return false;

            TypeNode parent = parameter.BaseType;

            if(parent != null && !type.IsAssignableTo(parent))
                return false;

            // Okay, passed all tests
            return true;
        }