public static CodeMemberMethod Method(this CodeTypeDeclaration decleration, MemberAttributes attributes,
     Type returnType, string name)
 {
     var method = new CodeMemberMethod() {Name = name, Attributes = attributes};
     decleration.Members.Add(method);
     return method;
 }

        internal static MethodAttributes ConvertToMethodAttributes(MemberAttributes memberAttributes)
        {
            MethodAttributes methodAttributes = MethodAttributes.ReuseSlot;
            // convert access attributes
            if ((memberAttributes & MemberAttributes.AccessMask) == MemberAttributes.Assembly)
                methodAttributes |= MethodAttributes.Assembly;
            else if ((memberAttributes & MemberAttributes.AccessMask) == MemberAttributes.Family)
                methodAttributes |= MethodAttributes.Family;
            else if ((memberAttributes & MemberAttributes.AccessMask) == MemberAttributes.FamilyAndAssembly)
                methodAttributes |= MethodAttributes.FamANDAssem;
            else if ((memberAttributes & MemberAttributes.AccessMask) == MemberAttributes.FamilyOrAssembly)
                methodAttributes |= MethodAttributes.FamORAssem;
            else if ((memberAttributes & MemberAttributes.AccessMask) == MemberAttributes.Private)
                methodAttributes |= MethodAttributes.Private;
            else if ((memberAttributes & MemberAttributes.AccessMask) == MemberAttributes.Public)
                methodAttributes |= MethodAttributes.Public;

            // covert scope attributes 
            if ((memberAttributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract)
                methodAttributes |= MethodAttributes.Abstract;
            else if ((memberAttributes & MemberAttributes.ScopeMask) == MemberAttributes.Final)
                methodAttributes |= MethodAttributes.Final;
            else if ((memberAttributes & MemberAttributes.ScopeMask) == MemberAttributes.Static)
                methodAttributes |= MethodAttributes.Static;
            //else if ((memberAttributes & MemberAttributes.ScopeMask) == MemberAttributes.Override)
            // methodAttributes |= MethodAttributes.ReuseSlot;// 

            // convert vtable slot
            if ((memberAttributes & MemberAttributes.VTableMask) == MemberAttributes.New)
                methodAttributes |= MethodAttributes.NewSlot;
            //if ((memberAttributes & MemberAttributes.VTableMask) == MemberAttributes.Overloaded)
            // methodAttributes |= MethodAttributes.HideBySig; // 

            return methodAttributes;
        }

        public static CodeMemberProperty AddProperty(this CodeTypeMember member,
            string propertyType, MemberAttributes ma, string name)
        {
            var classCode = member.GetDeclaration();

            return classCode.AddProperty(propertyType, ma, name);
        }

        /// <summary>
        /// Checks the class.
        /// </summary>
        /// <param name="codeType">The code type.</param>
        /// <param name="name">The class name.</param>
        /// <param name="modifiers">The class modifiers.</param>
        /// <param name="members">The count of members in the <paramref name="codeType"/>.</param>
        /// <param name="baseTypes">The class base types.</param>
        public static void CheckClass(CodeTypeDeclaration codeType, string name, MemberAttributes modifiers, int members, params string[] baseTypes)
        {
            Assert.IsTrue(codeType.IsClass,
                String.Format(CultureInfo.CurrentCulture, Settings.Default.IsNotClass, codeType.Name));
            Assert.AreEqual(name, codeType.Name, Settings.Default.InvalidName);
            Assert.AreEqual(modifiers, codeType.Attributes,
                String.Format(CultureInfo.CurrentCulture, Settings.Default.InvalidAccessModifier, name));

            if (baseTypes != null)
            {
                Assert.AreEqual(baseTypes.Length, codeType.BaseTypes.Count,
                    String.Format(CultureInfo.CurrentCulture, Settings.Default.WrongNumberBaseTypes, name));
                for (int i = 0; i < baseTypes.Length; i++)
                {
                    Assert.AreEqual(baseTypes[i], codeType.BaseTypes[i].BaseType,
                        String.Format(CultureInfo.CurrentCulture, Settings.Default.InvalidBaseType, name));
                }
            }
            else
            {
                Assert.AreEqual(0, codeType.BaseTypes.Count,
                    String.Format(CultureInfo.CurrentCulture, Settings.Default.WrongNumberBaseTypes, name));
            }

            Assert.AreEqual(members, codeType.Members.Count,
                String.Format(CultureInfo.CurrentCulture, Settings.Default.WrongNumberMembers, name));
        }

 internal static CodeMemberField AddFieldDeclaration(CodeTypeDeclaration type, MemberAttributes memberAttribute, string fieldType, string fieldName)
 {
     CodeMemberField cmf = new CodeMemberField(fieldType, fieldName);
     cmf.Attributes = memberAttribute;
     type.Members.Add(cmf);
     return cmf;
 }

        public static CodeMemberEvent AddEvent(this CodeTypeMember member,
            Type delegateType, MemberAttributes ma, string name)
        {
            var classCode = member.GetDeclaration();

            return classCode.AddEvent(delegateType, ma, name);
        }

        public static CodeTypeDeclaration CreateInterface (string name, MemberAttributes attribute) {
            CodeTypeDeclaration ct = new CodeTypeDeclaration (name);
            ct.Attributes = attribute;
            ct.IsInterface = true;

            return ct;
        }

		MemberAttributes ConvModifiers(TypeMemberModifiers modifier, MemberAttributes defaultVisibility)
		{
			MemberAttributes attr = 0;
			if ((modifier & TypeMemberModifiers.Abstract) == TypeMemberModifiers.Abstract)
				attr |= MemberAttributes.Abstract;
			if ((modifier & TypeMemberModifiers.Final) == TypeMemberModifiers.Final)
				attr |= MemberAttributes.Const;
			if ((modifier & TypeMemberModifiers.Internal) == TypeMemberModifiers.Internal)
				attr |= MemberAttributes.Assembly;
			if ((modifier & TypeMemberModifiers.Override) == TypeMemberModifiers.Override)
				attr |= MemberAttributes.Override;
			if ((modifier & TypeMemberModifiers.Private) == TypeMemberModifiers.Private)
				attr |= MemberAttributes.Private;
			if ((modifier & TypeMemberModifiers.Protected) == TypeMemberModifiers.Protected)
				attr |= MemberAttributes.Family;
			if ((modifier & TypeMemberModifiers.Public) == TypeMemberModifiers.Public)
				attr |= MemberAttributes.Public;
			if ((modifier & TypeMemberModifiers.Static) == TypeMemberModifiers.Static)
				attr |= MemberAttributes.Static;
			if ((modifier & TypeMemberModifiers.Virtual) != TypeMemberModifiers.Virtual)
				attr |= MemberAttributes.Final;
			if ((modifier & TypeMemberModifiers.VisibilityMask) == TypeMemberModifiers.None)
				attr |= defaultVisibility;
			return attr;
		}

 public static CodeTypeDeclaration Struct(string structName, MemberAttributes attributes)
 {
     return new CodeTypeDeclaration(structName)
     {
         Attributes = attributes,
         IsStruct = true
     };
 }

 public DesignConnection(string connectionName, System.Data.Design.ConnectionString cs, string provider)
 {
     this.properties = new HybridDictionary();
     this.modifier = MemberAttributes.Assembly;
     this.name = connectionName;
     this.connectionStringObject = cs;
     this.provider = provider;
 }

        public static CodeMemberProperty AddGetProperty(this CodeTypeMember member,
            string propertyType, MemberAttributes ma, string name,
            params CodeStatement[] statements)
        {
            var classCode = member.GetDeclaration();

            return classCode.AddGetProperty(propertyType, ma, name, statements);
        }

 public static CodeTypeDeclaration Interface(string interfaceName, MemberAttributes attributes)
 {
     return new CodeTypeDeclaration(interfaceName)
     {
         Attributes = attributes,
         IsInterface = true
     };
 }

        public virtual void DrawType(XBaseWindow window)
        {
            XBaseWindow.DoButton("Type", ()=> {
                XCodeTypeTemplate.SelectType(x => type = x);
            });

            memberAttribute = (MemberAttributes)XBaseWindow.CreateEnumPopup( memberAttribute );
        }

 public static CodeTypeDeclaration Enum(string enumName, MemberAttributes attributes)
 {
     return new CodeTypeDeclaration(enumName)
     {
         Attributes = attributes,
         IsEnum = true
     };
 }

        public static CodeTypeDeclaration CreateClass (string name, MemberAttributes attribute,
                CodeTypeReference[] baseTypes) {
            CodeTypeDeclaration ct = new CodeTypeDeclaration (name);
            ct.Attributes = attribute;
            ct.BaseTypes.AddRange (baseTypes);
            ct.IsClass = true;

            return ct;
        }

		public String GetModifier(MemberAttributes memberAttributes)
		{
			switch (memberAttributes & MemberAttributes.ScopeMask)
			{
				case MemberAttributes.Final: return "";
				case MemberAttributes.Abstract: return "abstract ";
				case MemberAttributes.Override: return "override ";
				default: return "virtual ";
			}
		}

 /// <summary>
 /// 字段
 /// <para>eg. public Dictionary<string,string> TestDic = new Dictionary<string,string>();</para>
 /// </summary>
 /// <param name="inLeft">字段类型</param>
 /// <param name="inFieldName"></param>
 /// <param name="inRight"></param>
 public ItemField(string inLeft, string inFieldName, string inRight = "", MemberAttributes inAtt = MemberAttributes.Private)
 {
     field = new CodeMemberField(inLeft, inFieldName);
     if (inRight != "")
     {
         CodeVariableReferenceExpression right = new CodeVariableReferenceExpression(inRight);
         field.InitExpression = right;
     }
     field.Attributes = inAtt;
 }

        public void GenerateField(String name,Type type ,MemberAttributes MemberAttributes = MemberAttributes.Public)
        {
            if (CodeCompileUnit == null)
                throw new Exception("Call Generate Class Before");

            CodeMemberField CodeMemberField = new CodeMemberField();
            CodeMemberField.Attributes = MemberAttributes;
            CodeMemberField.Type = new CodeTypeReference(type);
            CodeMemberField.Name = name;
            derived.Members.Add(CodeMemberField);
        }

        protected override MemberAttributes ModifyMemberAttributes(MemberAttributes memberAttributes)
        {
            // Methods are usually virtual ...
            var result = base.ModifyMemberAttributes(memberAttributes) & ~MemberAttributes.Final;

            // ... and override on derived types
            if (this.m.ObjectClass != this.dt)
                result = result | MemberAttributes.Override;

            return result;
        }

        public static CodeMemberEvent Event(CodeTypeReference delegateType, MemberAttributes ma, string name)
        {
            var c = new CodeMemberEvent
            {
                Name = name,
                Attributes = ma,
                Type = delegateType,
            };

            return c;
        }