C# CodeClass类代码示例

        /// <summary>
        /// Adds the property.
        /// </summary>
        /// <param name="codeClass">The code class.</param>
        /// <param name="var">The var.</param>
        /// <returns></returns>
        public static CodeProperty AddProperty(CodeClass codeClass, CodeVariable var)
        {
            CodeProperty prop = null;

            try
            {
                prop = codeClass.AddProperty(
                    FormatPropertyName(var.Name),
                    FormatPropertyName(var.Name),
                    var.Type.AsFullName, -1,
                    vsCMAccess.vsCMAccessPublic, null);

                EditPoint editPoint = prop.Getter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();

                //Delete return default(int); added by codeClass.AddProperty
                editPoint.Delete(editPoint.LineLength);

                editPoint.Indent(null, 4);
                editPoint.Insert(string.Format(CultureInfo.InvariantCulture, "return {0};", var.Name));

                editPoint = prop.Setter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();

                editPoint.Indent(null, 1);
                editPoint.Insert(string.Format(CultureInfo.InvariantCulture, "{0} = value;", var.Name));
                editPoint.SmartFormat(editPoint);

                return prop;
            }
            catch
            {
                //Property already exists
                return null;
            }
        }

 protected override void VisitClass(CodeClass codeClass)
 {
     if (codeClass.FullName == _classFullName)
     {
         _result = codeClass.ProjectItem;
     }
 }

 // Methods
 public static bool HaveAClass(object target, out CodeClass codeClass)
 {
     ProjectItem projectItem = null;
     if (target is SelectedItems)
     {
         SelectedItems items = (SelectedItems)target;
         if ((items.Count > 1) && (items.Item(1).ProjectItem != null))
         {
             projectItem = items.Item(1).ProjectItem;
         }
     }
     else if (target is ProjectItem)
     {
         projectItem = (ProjectItem)target;
     }
     if ((projectItem != null) && (projectItem.FileCodeModel != null))
     {
         foreach (CodeElement element in projectItem.FileCodeModel.CodeElements)
         {
             if (element is CodeNamespace)
             {
                 CodeNamespace namespace2 = (CodeNamespace)element;
                 if ((namespace2.Members.Count > 0) && (namespace2.Members.Item(1) is CodeClass))
                 {
                     codeClass = (CodeClass)namespace2.Members.Item(1);
                     return true;
                 }
             }
         }
     }
     codeClass = null;
     return false;
 }

        /// <summary>
        /// Gets the declaration of the specified code class as a string.
        /// </summary>
        /// <param name="codeClass">The code class.</param>
        /// <returns>The string declaration.</returns>
        internal static string GetClassDeclaration(CodeClass codeClass)
        {
            // Get the start point after the attributes.
            var startPoint = codeClass.GetStartPoint(vsCMPart.vsCMPartHeader);

            return TextDocumentHelper.GetTextToFirstMatch(startPoint, @"\{");
        }

 /// <summary>
 /// Adds the attribute.
 /// </summary>
 /// <param name="element">The element.</param>
 /// <param name="attributeName">Name of the attribute.</param>
 /// <param name="attributeValue">The attribute value.</param>
 public static void AddAttribute(CodeClass element, string attributeName, string attributeValue)
 {
     if(!HasAttribute(element, attributeName))
     {
         element.AddAttribute(attributeName, attributeValue, 0);
     }
 }

      internal static bool CanGenerateHandleCodeProperty(string testClassFixturePostFix, CodeClass parentCodeClass, CodeProperty codeProperty, Project unitTestProject)
      {
         foreach (ProjectItem projectItem in unitTestProject.ProjectItems)
         {
            List<CodeClass> lstProjectCodeClasses = UTGManagerAndExaminor.ProjectItemExaminor.GetCodeClasses(projectItem.FileCodeModel);

            foreach (CodeClass codeClass in lstProjectCodeClasses)
            {
               if ((parentCodeClass.Name + testClassFixturePostFix).Equals(codeClass.Name))
               {
                  foreach (CodeElement codeElement in codeClass.Members)
                  {
                     if (codeElement is CodeProperty)
                     {
                        if (codeProperty.Name.Equals(((CodeProperty)codeElement).Name))
                           return false;

                     }
                  }
               }
            }
         }

         return true;
      }

        /// <summary>
        /// 解析出实体的命令空间。
        /// </summary>
        /// <param name="repo"></param>
        /// <returns></returns>
        private static bool ParseDomainNamespace(CodeClass repo, string entityName, IList<CodeClass> entities, out string domainNamespace)
        {
            domainNamespace = null;

            //如果实体和仓库都是在这同一个项目中时，直接在实体列表中找到对应实体的命令空间。
            if (entities.Count > 0)
            {
                var entity = entities.FirstOrDefault(c => c.Name == entityName);
                if (entity != null)
                {
                    domainNamespace = entity.Namespace.FullName;
                    return true;
                }
            }

            //实体不在同一个项目中，则通过约定查找实体的命名空间：
            //Repository.g.cs 文件中的最后一个命名空间，即是实体的命名空间。
            var item = repo.ProjectItem;
            var fileName = item.get_FileNames(1);
            var gFileName = Path.GetFileNameWithoutExtension(fileName) + ".g.cs";
            var gFile = Path.Combine(Path.GetDirectoryName(fileName), gFileName);

            //Repository 的层基类是没有 .g.cs 文件的，这时不需要为它生成。
            if (File.Exists(gFile))
            {
                var code = File.ReadAllText(gFile);
                var match = Regex.Match(code, @"using (?<domainNamespace>\S+?);\s+namespace");
                domainNamespace = match.Groups["domainNamespace"].Value;
                return !string.IsNullOrWhiteSpace(domainNamespace);
            }
            return false;
        }

 private void ProcessCodeFunctions(CodeClass codeClass, BindingSourceType bindingSourceType, IdeBindingSourceProcessor bindingSourceProcessor)
 {
     foreach (var codeFunction in codeClass.Children.OfType<CodeFunction>())
     {
         var bindingSourceMethod = CreateBindingSourceMethod(codeFunction, bindingSourceType, bindingSourceProcessor);
         if (bindingSourceMethod != null)
             bindingSourceProcessor.ProcessMethod(bindingSourceMethod);
     }
 }

        protected override void VisitClass(CodeClass codeClass)
        {
            this.ShowName(codeClass, "Class");

            _level++;

            base.VisitClass(codeClass);

            _level--;
        }

 static public bool IsBindingClass(CodeClass codeClass)
 {
     try
     {
         return codeClass.Attributes.Cast<CodeAttribute>().Any(attr => typeof(BindingAttribute).FullName.Equals(attr.FullName));
     }
     catch(Exception)
     {
         return false;
     }
 }

 static public bool IsBindingClass(CodeClass codeClass)
 {
     try
     {
         return codeClass.Attributes.Cast<CodeAttribute>().Any(attr => "TechTalk.SpecFlow.BindingAttribute".Equals(attr.FullName));
     }
     catch(Exception)
     {
         return false;
     }
 }

        public ClassTraverser(CodeClass codeClass, Action<CodeProperty> withProperty)
        {
            if (codeClass == null) throw new ArgumentNullException("codeClass");
            if (withProperty == null) throw new ArgumentNullException("withProperty");

            CodeClass = codeClass;
            WithProperty = withProperty;

            if (codeClass.Members != null)
                Traverse(codeClass.Members);
        }

 static internal bool IsPotentialBindingClass(CodeClass codeClass)
 {
     try
     {
         var filteredAttributes = codeClass.Attributes.OfType<CodeAttribute2>();
         return BindingSourceProcessor.IsPotentialBindingClass(filteredAttributes.Select(attr => attr.FullName));
     }
     catch(Exception)
     {
         return false;
     }
 }

 protected override void VisitClass(CodeClass codeClass)
 {
     if (Helper.IsEntity(codeClass))
     {
         _fileFinised = true;
     }
     else if (Helper.IsRepository(codeClass))
     {
         _result.Add(codeClass);
         _fileFinised = true;
     }
 }

        private static bool DerivedFromBaseTest(CodeClass classElement)
        {
            if (classElement.Name == "BaseTest")
            {
                return true;
            }

            return classElement.Bases
                       .Cast<CodeElement>()
                       .Where(e => e.Kind == vsCMElement.vsCMElementClass)
                       .Count(c => DerivedFromBaseTest((CodeClass)c)) > 0;
        }