/// <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;
        }

        internal static string GetEntityNameForRepository(CodeClass repo)
        {
            ////使用 Attribute 来进行获取实体类名。
            //foreach (CodeAttribute attri in repo.Attributes)
            //{
            //    //RootEntity or ChildEntity
            //    if (attri.FullName == Consts.RepositoryForAttributeClassFullName)
            //    {
            //    }
            //}

            return repo.Name.Substring(0, repo.Name.Length - Consts.RepositorySuffix.Length);
        }

      public static string GetNextAvailableCopyName(CodeClass codeClass, ref string codeFunctionName, Project project)
      {
         codeFunctionName = "CopyOf" + codeFunctionName;

         if (!CodeSelectionHandler.CanGenerateHandleCodeFunction(
           codeClass,
           codeFunctionName))
         {
            return GetNextAvailableCopyName(codeClass, ref codeFunctionName, project);
         }

         return codeFunctionName;
      }

      internal static bool CanGenerateHandleCodeFunction(CodeClass parentCodeClass, string codeFunctionName)
      {

         foreach (CodeElement codeElement in parentCodeClass.Members)
         {
            if (codeElement is CodeFunction)
            {
               if (codeFunctionName.Equals(((CodeFunction)codeElement).Name))
                  return false;

            }
         }

         return true;
      }

        private void ProcessCodeClass(CodeClass codeClass, IdeBindingSourceProcessor bindingSourceProcessor, params CodeClass[] classParts)
        {
            var filteredAttributes = classParts
                .SelectMany(cc => cc.Attributes.Cast<CodeAttribute2>().Where(attr => CanProcessTypeAttribute(bindingSourceProcessor, attr))).ToArray();
                
            if (!bindingSourceProcessor.PreFilterType(filteredAttributes.Select(attr => attr.FullName)))
                return;

            var bindingSourceType = bindingReflectionFactory.CreateBindingSourceType(classParts, filteredAttributes); //TODO: merge info from parts

            if (!bindingSourceProcessor.ProcessType(bindingSourceType))
                return;

            ProcessCodeFunctions(codeClass, bindingSourceType, bindingSourceProcessor);

            bindingSourceProcessor.ProcessTypeDone();
        }

		protected void SelectObjectClass( CodeClass cc )
		{
			ProjectItem p = cc.ProjectItem;
			//  Open the file as a source code file
			EnvDTE.Window theWindow = p.Open(Constants.vsViewKindCode);

			//Get a handle to the new document in the open window
			TextDocument objTextDoc = (TextDocument)theWindow.Document.Object("TextDocument");
			EditPoint objEditPoint = (EditPoint)objTextDoc.StartPoint.CreateEditPoint();

			theWindow.Visible = true;

			TextSelection ts = (TextSelection) theWindow.Selection;
			ts.StartOfDocument(false);
			objEditPoint.MoveToLineAndOffset(cc.StartPoint.Line,1);
			ts.MoveToPoint( objEditPoint, false );
		}