models.smark.cs

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

            _id = new Field();
            _id.Name = "EmployeeID";
            _id.Value = this.EmployeeID;
            _id.GetValueBy = "SELECT @@IDENTITY";
            _id.GetValueAfterInsert = true;
            item = new Field();
            item.Name = "FirstName";
            item.Value = this.FirstName;
            _fields.Add(item);
            item = new Field();
            item.Name = "LastName";
            item.Value = this.LastName;
            _fields.Add(item);
            item = new Field();
            item.Name = "Country";
            item.Value = this.Country;
            _fields.Add(item);
            item = new Field();
            item.Name = "ReportsTo";
            item.Value = this.ReportsTo;
            _fields.Add(item);
            item = new Field();
            item.Name = "HireDate";
            item.Value = this.HireDate;
            _fields.Add(item);
            item = new Field();
            item.Name = "BirthDate";
            item.Value = this.BirthDate;
            _fields.Add(item);
            this.OnSave(context, "Employees", _fields, _id);
            this.EmployeeID = ((int)(this.Convert(typeof(int), _id.Value)));
        }
        
        public virtual void Save() {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                this.Save(_context);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public virtual void Delete(IConnectinContext context) {
            this.OnDeleteObject(context, "Employees", "EmployeeID", this.EmployeeID);
        }
        
        public virtual void Delete() {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                this.Delete(_context);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
    }
    
    /// <summary>
    /// Smark.Data.VSGenerator Copyright 泥水佬
    /// Email:[e-mail]
    /// MappingTable:[order details]
    /// 
    /// </summary>
    [Serializable()]
    public partial class Detail : EntityBase {
        
        private int mOrderID;
        
        public static FieldInfo orderID = new FieldInfo("[order details]", "OrderID");
        
        private int mProductID;
        
        public static FieldInfo productID = new FieldInfo("[order details]", "ProductID");
        
        private decimal mUnitPrice;
        
        public static FieldInfo unitPrice = new FieldInfo("[order details]", "UnitPrice");
        
        private int mQuantity;
        
        public static FieldInfo quantity = new FieldInfo("[order details]", "Quantity");
        
        private int mDiscount;
        
        public static FieldInfo discount = new FieldInfo("[order details]", "Discount");
        
        static string mSelectString = "Select (OrderID) as _OrderID,(ProductID) as _ProductID,(UnitPrice) as _UnitPrice," +
            "(Quantity) as _Quantity,(Discount) as _Discount from [order details]";
        
        static string mGroupString = null;
        
        /// <summary>
        /// 
        /// </summary>
        public virtual int OrderID {
            get {
                return this.mOrderID;
            }
            set {
                this.mOrderID = value;
                this.EntityState.FieldChange("OrderID");
            }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public virtual int ProductID {
            get {
                return this.mProductID;
            }
            set {
                this.mProductID = value;
                this.EntityState.FieldChange("ProductID");
            }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public virtual decimal UnitPrice {
            get {
                return this.mUnitPrice;
            }
            set {
                this.mUnitPrice = value;
                this.EntityState.FieldChange("UnitPrice");
            }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public virtual int Quantity {
            get {
                return this.mQuantity;
            }
            set {
                this.mQuantity = value;
                this.EntityState.FieldChange("Quantity");
            }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public virtual int Discount {
            get {
                return this.mDiscount;
            }
            set {
                this.mDiscount = value;
                this.EntityState.FieldChange("Discount");
            }
        }
        
        public static string Table {
            get {
                return " [order details] ";
            }
        }
        
        public static System.Collections.Generic.IList<Detail> List(IConnectinContext context, Expression expression, Region region, string OrderBy) {
            return EntityBase.OnList<Detail>(context, Detail.mSelectString, expression, region, OrderBy, Detail.mGroupString);
        }
        
        public static System.Collections.Generic.IList<Detail> List(IConnectinContext context, Expression expression) {
            return Detail.List(context, expression, null, null);
        }
        
        public static System.Collections.Generic.IList<Detail> List(Expression expression, Region region, string OrderBy) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.List(_context, expression, region, OrderBy);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static System.Collections.Generic.IList<Detail> List(Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.List(_context, expression, null, null);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static Detail ListFirst(IConnectinContext context, Expression expression, string OrderBy) {
            return EntityBase.OnListFirst<Detail>(context, Detail.mSelectString, expression, OrderBy, Detail.mGroupString);
        }
        
        public static Detail ListFirst(IConnectinContext context, Expression expression) {
            return Detail.ListFirst(context, expression);
        }
        
        public static Detail ListFirst(Expression expression, string OrderBy) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.ListFirst(_context, expression, OrderBy);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static Detail ListFirst(Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.ListFirst(_context, expression, null);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static int Count(IConnectinContext context, Expression expression) {
            return EntityBase.OnCount(context, "[order details]", expression, Detail.mGroupString);
        }
        
        public static int Count(Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.Count(_context, expression);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static object AVG(IConnectinContext context, string field, bool DISTINCT, Expression expression) {
            return EntityBase.OnAggregation(context, "[order details]", "AVG", field, DISTINCT, expression, Detail.mGroupString);
        }
        
        public static object AVG(IConnectinContext context, string field, Expression expression) {
            return Detail.AVG(context, field, false, expression);
        }
        
        public static object AVG(IConnectinContext context, string field) {
            return Detail.AVG(context, field, false, null);
        }
        
        public static object AVG(IConnectinContext context, string field, bool DISTINCT) {
            return Detail.AVG(context, field, DISTINCT, null);
        }
        
        public static object AVG(string field, bool DISTINCT, Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.AVG(_context, field, DISTINCT, expression);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static object AVG(string field, Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.AVG(_context, field, false, expression);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static object AVG(string field) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.AVG(_context, field, false, null);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static object AVG(string field, bool DISTINCT) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.AVG(_context, field, DISTINCT, null);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static object SUM(IConnectinContext context, string field, bool DISTINCT, Expression expression) {
            return EntityBase.OnAggregation(context, "[order details]", "SUM", field, DISTINCT, expression, Detail.mGroupString);
        }
        
        public static object SUM(IConnectinContext context, string field, Expression expression) {
            return Detail.SUM(context, field, false, expression);
        }
        
        public static object SUM(IConnectinContext context, string field) {
            return Detail.SUM(context, field, false, null);
        }
        
        public static object SUM(IConnectinContext context, string field, bool DISTINCT) {
            return Detail.SUM(context, field, DISTINCT, null);
        }
        
        public static object SUM(string field, bool DISTINCT, Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.SUM(_context, field, DISTINCT, expression);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }
        
        public static object SUM(string field, Expression expression) {
            IConnectinContext _context;
            _context = DBContext.Context;
            try {
                return Detail.SUM(_context, field, false, expression);
            }
            catch (System.Exception e_) {
                throw e_;
            }
            finally {
                _context.Dispose();
            }
        }