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;
 }
Example #2
0
        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;
        }
Example #3
0
        public static CodeMemberProperty AddProperty(this CodeTypeMember member,
            string propertyType, MemberAttributes ma, string name)
        {
            var classCode = member.GetDeclaration();

            return classCode.AddProperty(propertyType, ma, name);
        }
Example #4
0
        /// <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));
        }
Example #5
0
 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;
 }
Example #6
0
        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;
		}
Example #9
0
 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;
 }
Example #11
0
        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);
        }
Example #12
0
 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 );
        }
Example #14
0
 public static CodeTypeDeclaration Enum(string enumName, MemberAttributes attributes)
 {
     return new CodeTypeDeclaration(enumName)
     {
         Attributes = attributes,
         IsEnum = true
     };
 }
Example #15
0
        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;
        }
Example #16
0
        public static CodeTypeDeclaration CreateClass (string name, MemberAttributes attribute,
                TypeAttributes typeAttr) {
            CodeTypeDeclaration ct = new CodeTypeDeclaration (name);
            ct.Attributes = attribute;
            ct.TypeAttributes = typeAttr;
            ct.IsClass = true;

            return ct;
        }
Example #17
0
        public static CodeMemberProperty AddProperty(this CodeTypeDeclaration classCode,
            string propertyType, MemberAttributes ma, string name, string fieldName)
        {
            var prop = Define.Property(propertyType, CorrectAttributes(classCode, ma), name, fieldName);

            classCode.Members_Add(prop);

            return prop;
        }
Example #18
0
        public static CodeMemberProperty AddGetProperty(this CodeTypeDeclaration classCode,
            CodeTypeReference propertyType, MemberAttributes ma, string name,
            params CodeStatement[] statements)
        {
            var prop = Define.GetProperty(propertyType, CorrectAttributes(classCode, ma), name, statements);

            classCode.Members_Add(prop);

            return prop;
        }
Example #19
0
		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 ";
			}
		}
Example #20
0
 /// <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);
        }
Example #22
0
        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;
        }
Example #23
0
        public static CodeMemberEvent Event(CodeTypeReference delegateType, MemberAttributes ma, string name)
        {
            var c = new CodeMemberEvent
            {
                Name = name,
                Attributes = ma,
                Type = delegateType,
            };

            return c;
        }
Example #24
0
        public static CodeTypeDeclaration Struct(string structName, MemberAttributes attributes, bool partial)
        {
            var c = new CodeTypeDeclaration(structName)
            {
                Attributes = attributes,
                IsPartial = partial,
                IsStruct = true
            };

            return c;
        }
Example #25
0
 /// <summary>Initializes the extension</summary>
 /// <param name="parameters">Initialization parameters: This class expects following parameters:
 /// <list type="table"><listheader><term>Parameter</term><description>Description</description>
 /// <item><term><c>PropertyName</c></term><description>Name of the property</description>. Required.</item>
 /// <item><term><c>TypeName</c></term><description>Name of type property <c>PropertyName</c> is property of. Required.</description></item>
 /// <item><term><c>NewName</c></term><description>Specified a new name of the property. Optional.</description></item>
 /// <item><term><c>OrAttributes</c></term><description>Represents attributes of the property as <see cref="MemberAttributes"/> value. These new attribuets are OR-ed with exising property attributes. Must be string representation of integer value in invariant culture. Optional.</description></item>
 /// <item><term><c>AndAttributes</c></term><description>Represents attributes of the property as <see cref="MemberAttributes"/> value. These new attributes are AND-ed with exising property attributes. Must be string representation of integer value in invariant culture. Optional.</description></item>
 /// <item><term><c>NewType</c></term><description>Change type of the property. Recognizes last character ? as <see cref="Nullable{T}"/>. Optional.</description></item>
 /// <item><term><c>FieldName</c></term><description>Only used with <c>NewType</c>. Name of backing field. Optional.</description></item>
 /// </listheader></list></param>
 /// <exception cref="KeyNotFoundException">A required parameter is not present in the <paramref name="parameters"/> dictionary.</exception>
 /// <exception cref="FormatException">Value for <c>AndAttributes</c> or <c>OrAttributes</c> cannot be parsed as integer in invariant culture.</exception>
 /// <exception cref="OverflowException">Value for <c>AndAttributes</c> or <c>OrAttributes</c> does not fall to range of <see cref="int"/>.</exception>
 public void Initialize(System.Collections.Generic.IDictionary<string, string> parameters)
 {
     propertyName = parameters["PropertyName"];
     typeName = parameters["TypeName"];
     if (parameters.ContainsKey("NewName")) newName = parameters["NewName"];
     if (parameters.ContainsKey("OrAttributes")) orAttributes = (MemberAttributes)int.Parse(parameters["OrAttributes"], System.Globalization.CultureInfo.InvariantCulture);
     if (parameters.ContainsKey("AndAttributes")) andAttributes = (MemberAttributes)int.Parse(parameters["AndAttributes"], System.Globalization.CultureInfo.InvariantCulture);
     if (parameters.ContainsKey("NewType")) newPropertyType = parameters["NewType"];
     if (parameters.ContainsKey("NewRank")) newArrayRank = int.Parse(parameters["NewRank"]);
     if (parameters.ContainsKey("FieldName")) backingField = parameters["FieldName"];//Only to change type if property type changes
 }
Example #26
0
        public ClassBuilder(string namespc, string className, MemberAttributes attributes)
        {
            _compUnit = new CodeCompileUnit();
            _assemblies = new List<Assembly>();

            _namespace = new CodeNamespace(namespc);
            _class = new CodeTypeDeclaration(className) {Attributes = attributes};

            _compUnit.Namespaces.Add(_namespace);
            _namespace.Types.Add(_class);
        }
Example #27
0
    public ItemMethod(string inName, MemberAttributes inAtt, List<string> inParameters)
    {
        method = new CodeMemberMethod();
        method.Name = inName;
        method.Attributes = inAtt;
        for (int i = 0; i < inParameters.Count; i++)
        {

            method.Parameters.Add(new CodeParameterDeclarationExpression(inParameters[i], "inArg" + i));
        }
        statement = new CodeConditionStatement();
    }
Example #28
0
        public static CodeCustomEvent Event(CodeTypeReference delegateType, MemberAttributes ma, string name,
            CodeMemberProperty add, CodeMemberProperty remove, CodeMemberMethod raise)
        {
            var c = new CodeMemberEvent
            {
                Name = name,
                Attributes = ma,
                Type = delegateType,
            };

            return new CodeCustomEvent(c, add, remove, raise);
        }
 public DesignConnection(string connectionName, IDbConnection conn)
 {
     this.properties = new HybridDictionary();
     this.modifier = MemberAttributes.Assembly;
     if (conn == null)
     {
         throw new ArgumentNullException("conn");
     }
     this.name = connectionName;
     DbProviderFactory factoryFromType = ProviderManager.GetFactoryFromType(conn.GetType(), ProviderManager.ProviderSupportedClasses.DbConnection);
     this.provider = ProviderManager.GetInvariantProviderName(factoryFromType);
     this.connectionStringObject = new System.Data.Design.ConnectionString(this.provider, conn.ConnectionString);
 }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="member"></param>
        /// <param name="inner"></param>
        /// <param name="attrs"></param>
        /// <returns></returns>
        public CodeTypeMember CreateMember(MemberInfo member, CodeFieldReferenceExpression inner, MemberAttributes attrs)
        {
            Debug.Assert(member is MethodInfo);
            MethodInfo method = member as MethodInfo;
            CodeMemberMethod codeMethod = new CodeMemberMethod();

            codeMethod.Name = method.Name;
            codeMethod.ReturnType = new CodeTypeReference(method.ReturnType);
            codeMethod.Attributes = attrs;

            // try
            CodeTryCatchFinallyStatement tryCode = new CodeTryCatchFinallyStatement();

            // decleare parameters
            List<CodeArgumentReferenceExpression> codeParamiteRefrs = new List<CodeArgumentReferenceExpression>();

            foreach (ParameterInfo codeParameter in method.GetParameters()) {
                CodeParameterDeclarationExpression codeParameterDeclare = new CodeParameterDeclarationExpression(codeParameter.ParameterType, codeParameter.Name);
                codeMethod.Parameters.Add(codeParameterDeclare);
                codeParamiteRefrs.Add(new CodeArgumentReferenceExpression(codeParameter.Name));
            }

            // invoke
            CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression(
                inner, method.Name, codeParamiteRefrs.ToArray());
            if (method.ReturnType.Name.ToLower() == "void") {
                tryCode.TryStatements.Add(invokeMethod);
            } else {
                CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(method.ReturnType, "returnObject", invokeMethod);
                //CodeAssignStatement assign = new CodeAssignStatement(var, invokeMethod);
                tryCode.TryStatements.Add(var);

                CodeCommentStatement todo = new CodeCommentStatement("TODO: your code", false);
                tryCode.TryStatements.Add(todo);

                CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("returnObject");
                CodeMethodReturnStatement codeReturn = new CodeMethodReturnStatement(varRef);
                tryCode.TryStatements.Add(codeReturn);
            }

            // catch
            CodeTypeReference codeTypeRef = new CodeTypeReference(typeof(Exception));
            CodeCatchClause catchClause = new CodeCatchClause("ex", codeTypeRef);
            catchClause.Statements.Add(new CodeThrowExceptionStatement());
            tryCode.CatchClauses.Add(catchClause);

            codeMethod.Statements.Add(tryCode);
            return codeMethod;
        }