element.cs

smark.data是基于C#开发的轻量级数据访问组件。 提供以下功能封： 1）提供了跨数据库类型操作能力 2）基于程线存储的数据访问上下文对象

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio.Shell.Interop;
using System.ComponentModel;
using System.CodeDom.Compiler;
using Microsoft.VisualStudio.Shell;
using VSOLE = Microsoft.VisualStudio.OLE.Interop;
using System.CodeDom;
using System.IO;
using System.Xml;

namespace Smark.Data.VSGenerator
{
    class CodeGenerator {
        public static CodeCompileUnit GeneratorByCodeDom(XmlDocument doc, CodeDomProvider codeprovider) {
            CodeCompileUnit codeunit = new CodeCompileUnit();
            CodeNamespace nspace = null;
            try {
                nspace = new CodeNamespace(
                     doc.ChildNodes[1].Attributes["namespace"].Value);
                codeunit.Namespaces.Add(nspace);
                nspace.Imports.Add(new CodeNamespaceImport("System"));
                nspace.Imports.Add(new CodeNamespaceImport("System.Data"));
                nspace.Imports.Add(new CodeNamespaceImport("Smark.Data"));
                foreach (XmlNode cls in doc.ChildNodes[1].ChildNodes) {
                    if (cls.Name == "Class")
                        CreateClass(nspace, cls);
                }


            } catch (Exception e_) {
                nspace.Comments.Add(new CodeCommentStatement(e_.Message));
            }
            return codeunit;
        }
        private static void CreateClass(CodeNamespace nspace, XmlNode cls) {
            Model model = new Model(cls);
            model.Builder(nspace);
            
        }
        private static string FirstToUpper(string value) {
            string first = value.Substring(0, 1).ToUpper();
            return first + value.Substring(1, value.Length - 1);
        }

    }

    class Element {
        public Element(XmlNode node) {
            OnInit(node);
        }
        protected virtual void OnInit(XmlNode node) {
            mNode = node;
        }
        private XmlNode mNode;
        public XmlNode Node {

            get {
                return mNode;
            }
        }
        public string GetAttribute(string name) {
            if (Node.Attributes[name] == null)
                return string.Empty;
            return Node.Attributes[name].Value;
        }
        public string Name {
            get {
                string value = GetAttribute("Name");
                return value.Substring(0, 1).ToUpper() + value.Substring(1, value.Length - 1);
            }
        }
        public string Comment {
            get {
                return GetAttribute("Comment");

            }
        }

    }

    class Model : Element {
        public Model(XmlNode node) : base(node) { }
        protected override void OnInit(XmlNode node) {
            base.OnInit(node);
            foreach (XmlNode snode in node.ChildNodes) {
                if (snode.Name == "ID") {
                    ID = new IDProperty(snode);
                } else {
                    Properties.Add(new Property(snode));
                }
            }
        }

        public string DBContext
        {
            get
            {
                return GetAttribute("DBContext");
            }
        }
        public IDProperty ID {
            get;
            set;
        }
        private IList<Property> mProperties = new List<Property>();
        public IList<Property> Properties {
            get {
                return mProperties;
            }
        }
        public string Table {
            get {
                string value = GetAttribute("Table");
                if (value == string.Empty)
                    value = Name;
                return value;
            }
        }
       
        public bool View {
            get {
                bool isview = false;
                bool.TryParse(GetAttribute("View"), out isview);
                return isview;
            }
        }
        CodeTypeDeclaration mEntity;
       
        public void Builder(CodeNamespace nspace) {

            mEntity = new CodeTypeDeclaration(Name);
            nspace.Types.Add(mEntity);
            mEntity.BaseTypes.Add("EntityBase");
            mEntity.CustomAttributes.Add(new CodeAttributeDeclaration("Serializable"));
            mEntity.IsPartial = true;
            mEntity.Comments.Add(new CodeCommentStatement("<summary>", true));
            mEntity.Comments.Add(new CodeCommentStatement("Smark.Data.VSGenerator Copyright 泥水佬", true));
            mEntity.Comments.Add(new CodeCommentStatement("Email:[e-mail]", true));
            mEntity.Comments.Add(new CodeCommentStatement("MappingTable:"+Table, true));
            mEntity.Comments.Add(new CodeCommentStatement(Comment, true));
            mEntity.Comments.Add(new CodeCommentStatement("</summary>", true));
           
            BuilderList();
            BuilderListFirst();
            BuilderCount();
            BuilderAVG();
            BuilderSUM();
            BuilderMAX();
            BuilderMIN();
            BuilderProperty();
            BuilderReader();
            BuilderSelectAndGroup();
            BuilderTable();
            if (!View) {
                BuilderDelete();
            }
            if (ID != null) {
                BuilderLoad();
            }
            if (ID != null && !View) {
                BuilderSave();
                BuilderDeleteObject();
            }
        }

        private void BuilderProperty() {
            if (ID != null)
                 BuilderPropertyItem(ID);
            foreach (Property p in Properties) {
                BuilderPropertyItem(p);
            }

        }
        private void BuilderPropertyItem(Property p) {
            string  fname;
            CodeMemberField mfield;
            CodeMemberProperty mproperty;
            mfield = new CodeMemberField(p.Type, "m" + p.Name);
            mEntity.Members.Add(mfield);
            mproperty = new CodeMemberProperty();
            mproperty.Type = new CodeTypeReference(p.Type);
           
            mproperty.Name = p.Name;
            mproperty.Attributes = MemberAttributes.Public;
            mproperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "m" + p.Name)));
            mproperty.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "m" + p.Name), new CodePropertySetValueReferenceExpression()));
            mproperty.SetStatements.Add(new CodeMethodInvokeExpression(
                new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(
                    new CodeThisReferenceExpression(),"EntityState"), "FieldChange"),
                new CodePrimitiveExpression(p.Column)));
            mproperty.Comments.Add(new CodeCommentStatement("<summary>", true));
            mproperty.Comments.Add(new CodeCommentStatement(p.Comment, true));
            mproperty.Comments.Add(new CodeCommentStatement("</summary>", true));
            mEntity.Members.Add(mproperty);


            fname = p.Name.Substring(0, 1).ToLower();
            fname += p.Name.Substring(1, p.Name.Length - 1);
            mfield = new CodeMemberField( new CodeTypeReference("FieldInfo"), fname);
            mfield.Attributes = MemberAttributes.Static | MemberAttributes.Public;
            mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("FieldInfo"),
                 new CodePrimitiveExpression(this.Table), new CodePrimitiveExpression(p.Column));

            mEntity.Members.Add(mfield);
        }
        private void BuilderReader() {
            CodeMemberMethod reader = new CodeMemberMethod();
            reader.Name = "OnLoadData";
            reader.Parameters.Add(new CodeParameterDeclarationExpression(
                new CodeTypeReference(typeof(System.Data.IDataReader)), "reader"));
                
            reader.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            mEntity.Members.Add(reader);
            if (ID != null) {
                BuilderReaderItem(ID, reader);

            }
            foreach (Property p in Properties) {
                BuilderReaderItem(p, reader);
            }

        }
        private void BuilderReaderItem(Property p,CodeMemberMethod method) {
            CodeConditionStatement ifcode = new CodeConditionStatement();
            ifcode.Condition = new CodeBinaryOperatorExpression(
                new CodeIndexerExpression(
                    new CodeArgumentReferenceExpression("reader")
                    , new CodePrimitiveExpression("_"+p.Name)), CodeBinaryOperatorType.IdentityInequality,
                    new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(TypeReferenceFactory.DBNull()), "Value"));
            ifcode.TrueStatements.Add(
                new CodeAssignStatement(
                    new CodePropertyReferenceExpression(
                        new CodeThisReferenceExpression(), p.Name),
                        new CodeCastExpression(new CodeTypeReference(p.Type),
                        new CodeMethodInvokeExpression(
                            new CodeThisReferenceExpression(), "Convert",
                            new CodeTypeOfExpression(new CodeTypeReference(p.Type)),
                            new CodeIndexerExpression(new CodeArgumentReferenceExpression("reader")
                                    , new CodePrimitiveExpression("_" + p.Name))))));
            method.Statements.Add(ifcode);
                           

            

        }
        private void BuilderTable()
        {
            CodeMemberProperty table = new CodeMemberProperty();
            table.Name = "Table";
            table.Type = TypeReferenceFactory.StringType();
            table.Attributes = MemberAttributes.Public | MemberAttributes.Static;
            table.GetStatements.Add(
                new CodeMethodReturnStatement(
                    new CodePrimitiveExpression(" " +Table+" ")));
            mEntity.Members.Add(table);