C# ClassInfo类代码示例

        public AnalysisResult Analyze(CommonSyntaxTree tree, SemanticModel model, ClassInfo classInfo)
        {
            //TODO: Refactor this whole method later and make it more robust

            if (classInfo.GuardedFields.Count <= 1)
            {
                return AnalysisResult.Succeeded;
            }

            foreach (GuardedFieldInfo first in classInfo.GuardedFields)
            {
                foreach (GuardedFieldInfo second in classInfo.GuardedFields)
                {
                    if (first == second)
                    {
                        continue;
                    }

                    if (LockHierarchy.Conflicts(first.DeclaredLockHierarchy, second.DeclaredLockHierarchy))
                    {
                        return new AnalysisResult(new Issue(
                            ErrorCode.GUARDED_FIELD_LOCK_HIERARCHY_DECLARATION_CONFLICT,
                            second.Declaration,
                            second.Symbol));
                    }
                }
            }

            return AnalysisResult.Succeeded;
        }

 public GetFieldRunnable(IClassRepository repository, ClassInfo classInfo, Instruction instruction, BlockDecomposer block)
 {
     this.repository = repository;
     this.classInfo = classInfo;
     this.instruction = instruction;
     this.block = block;
 }

 public void AddClass(ClassInfo classInfo)
 {
     _rapidAccessForClassesByName.Add(classInfo.UnderlyingType, classInfo);
     _existingClasses.Add(classInfo.UnderlyingType);
     _rapidAccessForClassesByOid.Add(classInfo.ClassInfoId, classInfo);
     _allClassInfos.Add(classInfo);
 }

 public void AddClass(ClassInfo classInfo)
 {
     if (!classes.Contains(classInfo.Name))
     {
         classes.Add(classInfo.Name, classInfo);
     }
 }

        public ClassInfo GetClassInfo(ClassDeclarationSyntax classDeclaration)
        {
            _walker.Visit(classDeclaration);

            ClassInfo classInfo = new ClassInfo(classDeclaration, _semanticModel, _semanticModel.GetDeclaredSymbol(classDeclaration));

            classInfo.Locks.AddRange(_walker.Locks);
            classInfo.GuardedFields.AddRange(_walker.GuardedFields);
            classInfo.Members.AddRange(_walker.Members);

            foreach (LockInfo lockInfo in classInfo.Locks)
            {
                lockInfo.Parent = classInfo;
            }

            foreach (GuardedFieldInfo fieldInfo in classInfo.GuardedFields)
            {
                fieldInfo.Parent = classInfo;
            }

            foreach (MemberInfo memberInfo in classInfo.Members)
            {
                memberInfo.Parent = classInfo;
            }

            return classInfo;
        }

 private bool TryGetClass(ModuleDefinition module, string className, out ClassInfo clazz)
 {
     var visitor = new ModuleInfoVisitor(this, className);
     module.Accept(visitor);
     clazz = visitor.GetClassInfo();
     return clazz != null;
 }

        //public FieldVisitor(ClassInfo classInfo, string name, string descriptor, string signature, object value, 
        //    bool isFinal, bool isStatic, bool isPrivate)
        //{
        //    Type type = ClrType.FromDescriptor(descriptor);

        //    classInfo.AddField(new FieldInfo(classInfo, name, type, isFinal, isStatic, isPrivate));
        //}

        public FieldVisitor(ClassInfo classInfo, FieldDefinition fieldDefinition)
        {
            //classInfo.AddField();
            //Type type = ClrType.FromName(fieldDefinition.FieldType.FullName);
            Type type = ClrType.FromDescriptor(fieldDefinition.FieldType.FullName);
            classInfo.AddField(new FieldInfo(classInfo, fieldDefinition.Name, type, false, fieldDefinition.IsStatic, fieldDefinition.IsPrivate));
        }

        public IList<TeacherClass> Fill(ClassInfo classInfo)
        {
            if (classInfo == null)
            {
                return null;
            }

            IList<Core.Business.TeacherClass> teacherClasslist = new List<Core.Business.TeacherClass>();

            SqlServerUtility sql = new SqlServerUtility();

            sql.AddParameter("@ClassCode", SqlDbType.NVarChar, classInfo.ClassCode, 30);

            SqlDataReader reader = sql.ExecuteSqlReader(SqlFillTeacherClassByClassInfo);

            if (reader != null)
            {
                while (reader.Read())
                {
                    Core.Business.TeacherClass teacherClass = new Core.Business.TeacherClass();

                    if (!reader.IsDBNull(0)) teacherClass.Id = reader.GetInt32(0);
                    if (!reader.IsDBNull(1)) teacherClass.TeacherCode = reader.GetString(1);
                    if (!reader.IsDBNull(2)) teacherClass.ClassCode = reader.GetString(2);
                    if (!reader.IsDBNull(3)) teacherClass.IsState = reader.GetBoolean(3);

                    teacherClass.MarkOld();
                    teacherClasslist.Add(teacherClass);
                }
                reader.Close();
            }
            return teacherClasslist;
        }

        private Issue AnalyzeMember(MemberInfo memberInfo, SemanticModel model, ClassInfo classInfo)
        {
            foreach (BlockSyntax block in memberInfo.Blocks)
            {
                var identifiers = block.DescendantNodes().OfType<IdentifierNameSyntax>().ToList();

                foreach (IdentifierNameSyntax identifierName in identifiers)
                {
                    SymbolInfo identifierSymbol = model.GetSymbolInfo(identifierName);

                    //Does this symbol refer to a GuardedField?
                    GuardedFieldInfo foundGuardedField = classInfo.GuardedFields.FirstOrDefault(field => field.Symbol == identifierSymbol.Symbol);

                    if (foundGuardedField != null)
                    {
                        //We must be inside a lock statement
                        LockHierarchy controlFlowHierarchy = CreateLockHiearchyFromIdentifier(identifierName);

                        bool lockHierarchySatisfied = LockHierarchy.IsSatisfiedBy(foundGuardedField.DeclaredLockHierarchy, controlFlowHierarchy);

                        if (!lockHierarchySatisfied)
                        {
                            return new Issue(
                                ErrorCode.GUARDED_FIELD_ACCESSED_OUTSIDE_OF_LOCK,
                                identifierName,
                                identifierSymbol.Symbol);
                        }
                    }
                }
            }

            return null;
        }

 public MethodNotFoundException(ClassInfo classInfo, string methodName)
     : base("Method '" + methodName + "' not found in class '"
            + classInfo.Name + "'")
 {
     this.MethodName = methodName;
     this.ClassInfo = classInfo;
 }

        public Class Parse(String json, String className)
        {
            Class result = new Class(AccessModifier.Public, className);

            var oo = JsonConvert.DeserializeObject(json);
            var c = new ClassInfo(className);
            if (oo is JArray)
            {
                foreach (var jo in (JArray)oo)
                {
                    if (jo is JObject)
                    {
                        SetProperties(c, (JObject)jo);
                    }
                    else if (jo is JValue)
                    {
                        var pi = new PropertyInfo();
                        pi.Validate(jo);
                        return new Class(AccessModifier.Public, pi.GetCSharpTypeName());
                    }
                }
            }
            else if (oo is JObject)
            {
                SetProperties(c, (JObject)oo);
            }
            SetProperties(result, c);

            return result;
        }

 /// <summary>Constructor.</summary>
 /// <param name="classInfo">The test-class that this method is a member of.</param>
 /// <param name="name">The name of the method.</param>
 public MethodInfo(ClassInfo classInfo, string name)
 {
     this.classInfo = classInfo;
     this.name = name;
     displayName = FormatName(name);
     isSpecial = MethodHelper.IsSpecial(Name);
 }

        /// <summary>Constructor.</summary>
        /// <param name="classInfo">The test-class this node represents.</param>
        public ClassListItem(ClassInfo classInfo)
        {
            // Setup initial conditions.
            this.classInfo = classInfo;

            // Set default values.
            Text = classInfo.DisplayName;
        }

 /**
    * Computing the ClassCost for a ClassInfo involves tallying up all the MethodCosts contained
    * in the class. Then an overall cost is calculated, based on the {@code CostModel} the metric
    * computer is using.
    *
    * @param clazz to compute the metric for.
    * @return classCost
    */
 public ClassCost compute(ClassInfo clazz)
 {
     IList<MethodCost> methods = new ArrayList<MethodCost>();
     foreach (MethodInfo method in clazz.GetMethods())
     {
         methods.Add(compute(method));
     }
     return new ClassCost(clazz.Name, methods);
 }

 public FieldInfo(string fieldName, ClassInfo fieldClass, bool isPrimitive, bool isArray
     , bool isNArray)
 {
     _fieldName = fieldName;
     _fieldClass = fieldClass;
     _isPrimitive = isPrimitive;
     _isArray = isArray;
     _isNArray = isNArray;
 }