C# TypeNode.GetConstructors方法代码示例

        public override ProblemCollection Check(TypeNode type)
        {
            Type runtimeType = type.GetRuntimeType();
            if ( IsTestFixture( runtimeType ) && !runtimeType.IsAbstract && type.IsVisibleOutsideAssembly )
            {
                MemberList constructors = type.GetConstructors();

                for ( int i = 0; i < constructors.Length; ++i )
                {
                    Member constructor = constructors[i];

                    // only examine non-static constructors
                    Microsoft.Cci.InstanceInitializer instanceConstructor =
                        constructor as Microsoft.Cci.InstanceInitializer;

                    if ( instanceConstructor == null )
                        continue;

                    // trigger errors for non-default constructors.
                    if ( ( instanceConstructor.Parameters.Length != 0 ) &&
                         ( !instanceConstructor.IsPrivate ) )
                    {
                        Resolution resolution = GetResolution( runtimeType.Name );
                        Problem problem = new Problem( resolution );
                        base.Problems.Add( problem );
                    }
                }

                if ( base.Problems.Count > 0 )
                    return base.Problems;
            }

            return base.Check (type);
        }

        public override ProblemCollection Check(TypeNode type)
        {
            if (type == null) return Problems;

            if (!IsPresenterImplementation(type)) return Problems;

            var basePresenter = GetBasePresenterTypeNode(type);
            if (basePresenter == null)
                throw new InvalidOperationException("Failed to find WebFormsMvp.Presenter`1 even though we found WebFormsMvp.IPresenter.");

            var presenterBaseType = type;
            // We have an extra level of base type checking here so that we skip System.Object
            while (presenterBaseType.BaseType != null &&
                   presenterBaseType.BaseType.BaseType != null)
            {
                presenterBaseType = presenterBaseType.BaseType;
            }

            if (presenterBaseType.Template != basePresenter) return Problems;

            var viewTypeFromGenericTypeArgument = presenterBaseType.TemplateArguments.Single();

            var iViewType = GetIViewTypeNode(type);
            if (iViewType == null)
                throw new InvalidOperationException("Failed to find WebFormsMvp.IView even though we found WebFormsMvp.IPresenter.");

            var badParameters = type
                .GetConstructors()
                .Cast<InstanceInitializer>()
                .SelectMany(c => c.Parameters.Where(p => p.Type.IsAssignableTo(iViewType)))
                .Where(p => p.Type != viewTypeFromGenericTypeArgument);

            foreach(var param in badParameters)
            {
                Problems.Add(new Problem(GetResolution(new[]
                             {
                                 type.Name.Name,
                                 viewTypeFromGenericTypeArgument.Name.Name,
                                 param.Type.Name.Name
                             }),
                             param)
                             {
                                 Certainty = 100,
                                 FixCategory = FixCategories.NonBreaking,
                                 MessageLevel = MessageLevel.Error
                             });
            }

            return Problems;
        }

    /// <summary>
    /// See if any of the constructors of a given type (possibly) accepts a delayed parameter. 
    /// If a class is not sealed, it may have a derived class that, for example, has a constructor
    /// accepting a delayed parameter.
    /// We conservatively consider this case as "may have" and return true.
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    private bool hasConstructorAcceptingDelay(TypeNode t) {
      MemberList ml = t.GetConstructors();
      if (!t.IsSealed) return true; 
      if (ml.Count == 0) return false;
      foreach (Member m in ml) {
        if (m is InstanceInitializer) {
          InstanceInitializer ii = m as InstanceInitializer;
          
          ParameterList pl = ii.Parameters;
          foreach (Parameter p in pl) {
            if (p is This) continue; // will "this" show up here?
            if (p.IsUniversallyDelayed) {
              return true;
            }
          }

          // no need to look at base types
          /*
          TypeNode parentType = t.BaseType;
          while (parentType != null) {
            if (hasConstructorAcceptingDelay(parentType)) {
              return true;
            }
            parentType = parentType.BaseType;
          }
          */
          
        }
      }
      return false;
    }

 public virtual bool TypeHasNoVisibleConstructorsOrIsAbstract(TypeNode type, TypeNode referringType){
   if (type == null || referringType == null || type.IsAbstract) return true;
   if (type is Struct || type is EnumNode) return false;
   TypeNode dummy = referringType;
   MemberList constructors = type.GetConstructors();
   for (int i = 0, n = constructors == null ? 0 : constructors.Count; i < n; i++){
     Member constr = constructors[i];
     if (constr == null) continue;
     if (!Checker.NotAccessible(constr, ref dummy, referringType.DeclaringModule, referringType, null)) return false;
   }
   return true;
 }

 protected virtual Overloads GetConstructors(int line, int col, TypeNode type){
   Node node;
   Scope scope;
   int identContext;
   this.languageService.SearchForNodeAtPosition(line+1, col+1, out node, out scope, out identContext);
   TypeNode referringType = null;
   Module referringModule = null;
   while (scope != null){
     TypeScope tScope = scope as TypeScope;
     if (tScope != null){
       referringType = tScope.Type;
       if (referringType != null){
         referringModule = referringType.DeclaringModule;
         break;
       }
     }
     NamespaceScope nScope = scope as NamespaceScope;
     if (nScope != null){
       referringModule = nScope.AssociatedModule;
       break;
     }
     scope = scope.OuterScope;
   }
   bool showPrivate = referringType == type;
   bool showFamily = referringType != null && referringType.IsAssignableTo(type);
   bool showInternal = this.MayAccessInternals(referringType, type) || this.MayAccessInternals(referringModule, type);
   Member selectedMember = this.GetMember(line, col);
   MemberList members = type == null ? null : type.GetConstructors();
   int positionOfSelectedMember = 0;
   MemberList filteredMembers = new MemberList();
   if (type != null && type.IsValueType){
     //Add dummy default constructor
     InstanceInitializer cons = new InstanceInitializer(type, null, null, null);
     cons.Flags |= MethodFlags.Public;
     filteredMembers.Add(cons);
   }
   for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++){
     Method meth = members[i] as Method;
     if (meth == null) continue;
     if (meth.IsCompilerControlled) continue;
     if (meth.IsPrivate && !showPrivate) continue;
     if ((meth.IsFamily || meth.IsFamilyAndAssembly) && !showFamily) continue;
     if ((meth.IsAssembly || meth.IsFamilyOrAssembly) && !showInternal) continue;
     if (meth == selectedMember) positionOfSelectedMember = filteredMembers.Count;
     filteredMembers.Add(meth);
   }
   if (filteredMembers.Count == 0) return null;
   return new Overloads(filteredMembers, scope, positionOfSelectedMember, this.helper, OverloadKind.Constructors);
 }