企业管理

开发平台：
C#

DataSet1.cs：源码内容
							﻿//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------
namespace 医院管理系统 {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;
    
    
    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class DataSet1 : DataSet {
        
        private 药品资料DataTable table药品资料;
        
        private 门诊收费项目DataTable table门诊收费项目;
        
        public DataSet1() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected DataSet1(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["药品资料"] != null)) {
                    this.Tables.Add(new 药品资料DataTable(ds.Tables["药品资料"]));
                }
                if ((ds.Tables["门诊收费项目"] != null)) {
                    this.Tables.Add(new 门诊收费项目DataTable(ds.Tables["门诊收费项目"]));
                }
                this.DataSetName = ds.DataSetName;
                this.Prefix = ds.Prefix;
                this.Namespace = ds.Namespace;
                this.Locale = ds.Locale;
                this.CaseSensitive = ds.CaseSensitive;
                this.EnforceConstraints = ds.EnforceConstraints;
                this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
                this.InitVars();
            }
            else {
                this.InitClass();
            }
            this.GetSerializationData(info, context);
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public 药品资料DataTable 药品资料 {
            get {
                return this.table药品资料;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public 门诊收费项目DataTable 门诊收费项目 {
            get {
                return this.table门诊收费项目;
            }
        }
        
        public override DataSet Clone() {
            DataSet1 cln = ((DataSet1)(base.Clone()));
            cln.InitVars();
            return cln;
        }
        
        protected override bool ShouldSerializeTables() {
            return false;
        }
        
        protected override bool ShouldSerializeRelations() {
            return false;
        }
        
        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["药品资料"] != null)) {
                this.Tables.Add(new 药品资料DataTable(ds.Tables["药品资料"]));
            }
            if ((ds.Tables["门诊收费项目"] != null)) {
                this.Tables.Add(new 门诊收费项目DataTable(ds.Tables["门诊收费项目"]));
            }
            this.DataSetName = ds.DataSetName;
            this.Prefix = ds.Prefix;
            this.Namespace = ds.Namespace;
            this.Locale = ds.Locale;
            this.CaseSensitive = ds.CaseSensitive;
            this.EnforceConstraints = ds.EnforceConstraints;
            this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
            this.InitVars();
        }
        
        protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(stream, null));
            stream.Position = 0;
            return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
        }
        
        internal void InitVars() {
            this.table药品资料 = ((药品资料DataTable)(this.Tables["药品资料"]));
            if ((this.table药品资料 != null)) {
                this.table药品资料.InitVars();
            }
            this.table门诊收费项目 = ((门诊收费项目DataTable)(this.Tables["门诊收费项目"]));
            if ((this.table门诊收费项目 != null)) {
                this.table门诊收费项目.InitVars();
            }
        }
        
        private void InitClass() {
            this.DataSetName = "DataSet1";
            this.Prefix = "";
            this.Namespace = "http://www.tempuri.org/DataSet1.xsd";
            this.Locale = new System.Globalization.CultureInfo("zh-CN");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.table药品资料 = new 药品资料DataTable();
            this.Tables.Add(this.table药品资料);
            this.table门诊收费项目 = new 门诊收费项目DataTable();
            this.Tables.Add(this.table门诊收费项目);
        }
        
        private bool ShouldSerialize药品资料() {
            return false;
        }
        
        private bool ShouldSerialize门诊收费项目() {
            return false;
        }
        
        private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
            if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitVars();
            }
        }
        
        public delegate void 药品资料RowChangeEventHandler(object sender, 药品资料RowChangeEvent e);
        
        public delegate void 门诊收费项目RowChangeEventHandler(object sender, 门诊收费项目RowChangeEvent e);
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 药品资料DataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn column编号;
            
            private DataColumn column名称;
            
            private DataColumn column规格;
            
            private DataColumn column整量单位;
            
            private DataColumn column散量单位;
            
            private DataColumn column入库单价;
            
            private DataColumn column出库单价;
            
            private DataColumn column批发价;
            
            private DataColumn column整散比;
            
            private DataColumn column分类;
            
            private DataColumn column费用归类;
            
            private DataColumn column拼音码;
            
            private DataColumn column效期;
            
            private DataColumn column上限;
            
            private DataColumn column下限;
            
            internal 药品资料DataTable() : 
                    base("药品资料") {
                this.InitClass();
            }
            
            internal 药品资料DataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn 编号Column {
                get {
                    return this.column编号;
                }
            }
            
            internal DataColumn 名称Column {
                get {
                    return this.column名称;
                }
            }
            
            internal DataColumn 规格Column {
                get {
                    return this.column规格;
                }
            }
            
            internal DataColumn 整量单位Column {
                get {
                    return this.column整量单位;
                }
            }
            
            internal DataColumn 散量单位Column {
                get {
                    return this.column散量单位;
                }
            }
            
            internal DataColumn 入库单价Column {
                get {
                    return this.column入库单价;
                }
            }
            
            internal DataColumn 出库单价Column {
                get {
                    return this.column出库单价;
                }
            }
            
            internal DataColumn 批发价Column {
                get {
                    return this.column批发价;
                }
            }
            
            internal DataColumn 整散比Column {
                get {
                    return this.column整散比;
                }
            }
            
            internal DataColumn 分类Column {
                get {
                    return this.column分类;
                }
            }
            
            internal DataColumn 费用归类Column {
                get {
                    return this.column费用归类;
                }
            }
            
            internal DataColumn 拼音码Column {
                get {
                    return this.column拼音码;
                }
            }
            
            internal DataColumn 效期Column {
                get {
                    return this.column效期;
                }
            }
            
            internal DataColumn 上限Column {
                get {
                    return this.column上限;
                }
            }
            
            internal DataColumn 下限Column {
                get {
                    return this.column下限;
                }
            }
            
            public 药品资料Row this[int index] {
                get {
                    return ((药品资料Row)(this.Rows[index]));
                }
            }
            
            public event 药品资料RowChangeEventHandler 药品资料RowChanged;
            
            public event 药品资料RowChangeEventHandler 药品资料RowChanging;
            
            public event 药品资料RowChangeEventHandler 药品资料RowDeleted;
            
            public event 药品资料RowChangeEventHandler 药品资料RowDeleting;
            
            public void Add药品资料Row(药品资料Row row) {
                this.Rows.Add(row);
            }
            
            public 药品资料Row Add药品资料Row(string 编号, string 名称, string 规格, string 整量单位, string 散量单位, System.Decimal 入库单价, System.Decimal 出库单价, System.Decimal 批发价, System.Decimal 整散比, string 分类, string 费用归类, string 拼音码, int 效期, System.Decimal 上限, System.Decimal 下限) {
                药品资料Row row药品资料Row = ((药品资料Row)(this.NewRow()));
                row药品资料Row.ItemArray = new object[] {
                        编号,
                        名称,
                        规格,
                        整量单位,
                        散量单位,
                        入库单价,
                        出库单价,
                        批发价,
                        整散比,
                        分类,
                        费用归类,
                        拼音码,
                        效期,
                        上限,
                        下限};
                this.Rows.Add(row药品资料Row);
                return row药品资料Row;
            }
            
            public 药品资料Row FindBy编号(string 编号) {
                return ((药品资料Row)(this.Rows.Find(new object[] {
                            编号})));
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                药品资料DataTable cln = ((药品资料DataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new 药品资料DataTable();
            }
            
            internal void InitVars() {
                this.column编号 = this.Columns["编号"];
                this.column名称 = this.Columns["名称"];
                this.column规格 = this.Columns["规格"];
                this.column整量单位 = this.Columns["整量单位"];
                this.column散量单位 = this.Columns["散量单位"];
                this.column入库单价 = this.Columns["入库单价"];
                this.column出库单价 = this.Columns["出库单价"];
                this.column批发价 = this.Columns["批发价"];
                this.column整散比 = this.Columns["整散比"];
                this.column分类 = this.Columns["分类"];
                this.column费用归类 = this.Columns["费用归类"];
                this.column拼音码 = this.Columns["拼音码"];
                this.column效期 = this.Columns["效期"];
                this.column上限 = this.Columns["上限"];
                this.column下限 = this.Columns["下限"];
            }
            
            private void InitClass() {
                this.column编号 = new DataColumn("编号", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column编号);
                this.column名称 = new DataColumn("名称", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column名称);
                this.column规格 = new DataColumn("规格", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column规格);
                this.column整量单位 = new DataColumn("整量单位", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column整量单位);
                this.column散量单位 = new DataColumn("散量单位", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column散量单位);
                this.column入库单价 = new DataColumn("入库单价", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column入库单价);
                this.column出库单价 = new DataColumn("出库单价", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column出库单价);
                this.column批发价 = new DataColumn("批发价", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column批发价);
                this.column整散比 = new DataColumn("整散比", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column整散比);
                this.column分类 = new DataColumn("分类", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column分类);
                this.column费用归类 = new DataColumn("费用归类", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column费用归类);
                this.column拼音码 = new DataColumn("拼音码", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column拼音码);
                this.column效期 = new DataColumn("效期", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column效期);
                this.column上限 = new DataColumn("上限", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column上限);
                this.column下限 = new DataColumn("下限", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column下限);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.column编号}, true));
                this.column编号.AllowDBNull = false;
                this.column编号.Unique = true;
            }
            
            public 药品资料Row New药品资料Row() {
                return ((药品资料Row)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new 药品资料Row(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(药品资料Row);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.药品资料RowChanged != null)) {
                    this.药品资料RowChanged(this, new 药品资料RowChangeEvent(((药品资料Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.药品资料RowChanging != null)) {
                    this.药品资料RowChanging(this, new 药品资料RowChangeEvent(((药品资料Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.药品资料RowDeleted != null)) {
                    this.药品资料RowDeleted(this, new 药品资料RowChangeEvent(((药品资料Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.药品资料RowDeleting != null)) {
                    this.药品资料RowDeleting(this, new 药品资料RowChangeEvent(((药品资料Row)(e.Row)), e.Action));
                }
            }
            
            public void Remove药品资料Row(药品资料Row row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 药品资料Row : DataRow {
            
            private 药品资料DataTable table药品资料;
            
            internal 药品资料Row(DataRowBuilder rb) : 
                    base(rb) {
                this.table药品资料 = ((药品资料DataTable)(this.Table));
            }
            
            public string 编号 {
                get {
                    return ((string)(this[this.table药品资料.编号Column]));
                }
                set {
                    this[this.table药品资料.编号Column] = value;
                }
            }
            
            public string 名称 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.名称Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.名称Column] = value;
                }
            }
            
            public string 规格 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.规格Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.规格Column] = value;
                }
            }
            
            public string 整量单位 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.整量单位Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.整量单位Column] = value;
                }
            }
            
            public string 散量单位 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.散量单位Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.散量单位Column] = value;
                }
            }
            
            public System.Decimal 入库单价 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table药品资料.入库单价Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.入库单价Column] = value;
                }
            }
            
            public System.Decimal 出库单价 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table药品资料.出库单价Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.出库单价Column] = value;
                }
            }
            
            public System.Decimal 批发价 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table药品资料.批发价Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.批发价Column] = value;
                }
            }
            
            public System.Decimal 整散比 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table药品资料.整散比Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.整散比Column] = value;
                }
            }
            
            public string 分类 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.分类Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.分类Column] = value;
                }
            }
            
            public string 费用归类 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.费用归类Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.费用归类Column] = value;
                }
            }
            
            public string 拼音码 {
                get {
                    try {
                        return ((string)(this[this.table药品资料.拼音码Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.拼音码Column] = value;
                }
            }
            
            public int 效期 {
                get {
                    try {
                        return ((int)(this[this.table药品资料.效期Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.效期Column] = value;
                }
            }
            
            public System.Decimal 上限 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table药品资料.上限Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.上限Column] = value;
                }
            }
            
            public System.Decimal 下限 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table药品资料.下限Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品资料.下限Column] = value;
                }
            }
            
            public bool Is名称Null() {
                return this.IsNull(this.table药品资料.名称Column);
            }
            
            public void Set名称Null() {
                this[this.table药品资料.名称Column] = System.Convert.DBNull;
            }
            
            public bool Is规格Null() {
                return this.IsNull(this.table药品资料.规格Column);
            }
            
            public void Set规格Null() {
                this[this.table药品资料.规格Column] = System.Convert.DBNull;
            }
            
            public bool Is整量单位Null() {
                return this.IsNull(this.table药品资料.整量单位Column);
            }
            
            public void Set整量单位Null() {
                this[this.table药品资料.整量单位Column] = System.Convert.DBNull;
            }
            
            public bool Is散量单位Null() {
                return this.IsNull(this.table药品资料.散量单位Column);
            }
            
            public void Set散量单位Null() {
                this[this.table药品资料.散量单位Column] = System.Convert.DBNull;
            }
            
            public bool Is入库单价Null() {
                return this.IsNull(this.table药品资料.入库单价Column);
            }
            
            public void Set入库单价Null() {
                this[this.table药品资料.入库单价Column] = System.Convert.DBNull;
            }
            
            public bool Is出库单价Null() {
                return this.IsNull(this.table药品资料.出库单价Column);
            }
            
            public void Set出库单价Null() {
                this[this.table药品资料.出库单价Column] = System.Convert.DBNull;
            }
            
            public bool Is批发价Null() {
                return this.IsNull(this.table药品资料.批发价Column);
            }
            
            public void Set批发价Null() {
                this[this.table药品资料.批发价Column] = System.Convert.DBNull;
            }
            
            public bool Is整散比Null() {
                return this.IsNull(this.table药品资料.整散比Column);
            }
            
            public void Set整散比Null() {
                this[this.table药品资料.整散比Column] = System.Convert.DBNull;
            }
            
            public bool Is分类Null() {
                return this.IsNull(this.table药品资料.分类Column);
            }
            
            public void Set分类Null() {
                this[this.table药品资料.分类Column] = System.Convert.DBNull;
            }
            
            public bool Is费用归类Null() {
                return this.IsNull(this.table药品资料.费用归类Column);
            }
            
            public void Set费用归类Null() {
                this[this.table药品资料.费用归类Column] = System.Convert.DBNull;
            }
            
            public bool Is拼音码Null() {
                return this.IsNull(this.table药品资料.拼音码Column);
            }
            
            public void Set拼音码Null() {
                this[this.table药品资料.拼音码Column] = System.Convert.DBNull;
            }
            
            public bool Is效期Null() {
                return this.IsNull(this.table药品资料.效期Column);
            }
            
            public void Set效期Null() {
                this[this.table药品资料.效期Column] = System.Convert.DBNull;
            }
            
            public bool Is上限Null() {
                return this.IsNull(this.table药品资料.上限Column);
            }
            
            public void Set上限Null() {
                this[this.table药品资料.上限Column] = System.Convert.DBNull;
            }
            
            public bool Is下限Null() {
                return this.IsNull(this.table药品资料.下限Column);
            }
            
            public void Set下限Null() {
                this[this.table药品资料.下限Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 药品资料RowChangeEvent : EventArgs {
            
            private 药品资料Row eventRow;
            
            private DataRowAction eventAction;
            
            public 药品资料RowChangeEvent(药品资料Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public 药品资料Row Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 门诊收费项目DataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn column编号;
            
            private DataColumn column名称;
            
            private DataColumn column拼音码;
            
            private DataColumn column费用;
            
            private DataColumn column费用分类;
            
            private DataColumn column病种分类;
            
            private DataColumn column备注;
            
            internal 门诊收费项目DataTable() : 
                    base("门诊收费项目") {
                this.InitClass();
            }
            
            internal 门诊收费项目DataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn 编号Column {
                get {
                    return this.column编号;
                }
            }
            
            internal DataColumn 名称Column {
                get {
                    return this.column名称;
                }
            }
            
            internal DataColumn 拼音码Column {
                get {
                    return this.column拼音码;
                }
            }
            
            internal DataColumn 费用Column {
                get {
                    return this.column费用;
                }
            }
            
            internal DataColumn 费用分类Column {
                get {
                    return this.column费用分类;
                }
            }
            
            internal DataColumn 病种分类Column {
                get {
                    return this.column病种分类;
                }
            }
            
            internal DataColumn 备注Column {
                get {
                    return this.column备注;
                }
            }
            
            public 门诊收费项目Row this[int index] {
                get {
                    return ((门诊收费项目Row)(this.Rows[index]));
                }
            }
            
            public event 门诊收费项目RowChangeEventHandler 门诊收费项目RowChanged;
            
            public event 门诊收费项目RowChangeEventHandler 门诊收费项目RowChanging;
            
            public event 门诊收费项目RowChangeEventHandler 门诊收费项目RowDeleted;
            
            public event 门诊收费项目RowChangeEventHandler 门诊收费项目RowDeleting;
            
            public void Add门诊收费项目Row(门诊收费项目Row row) {
                this.Rows.Add(row);
            }
            
            public 门诊收费项目Row Add门诊收费项目Row(string 编号, string 名称, string 拼音码, System.Decimal 费用, string 费用分类, string 病种分类, string 备注) {
                门诊收费项目Row row门诊收费项目Row = ((门诊收费项目Row)(this.NewRow()));
                row门诊收费项目Row.ItemArray = new object[] {
                        编号,
                        名称,
                        拼音码,
                        费用,
                        费用分类,
                        病种分类,
                        备注};
                this.Rows.Add(row门诊收费项目Row);
                return row门诊收费项目Row;
            }
            
            public 门诊收费项目Row FindBy编号(string 编号) {
                return ((门诊收费项目Row)(this.Rows.Find(new object[] {
                            编号})));
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                门诊收费项目DataTable cln = ((门诊收费项目DataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new 门诊收费项目DataTable();
            }
            
            internal void InitVars() {
                this.column编号 = this.Columns["编号"];
                this.column名称 = this.Columns["名称"];
                this.column拼音码 = this.Columns["拼音码"];
                this.column费用 = this.Columns["费用"];
                this.column费用分类 = this.Columns["费用分类"];
                this.column病种分类 = this.Columns["病种分类"];
                this.column备注 = this.Columns["备注"];
            }
            
            private void InitClass() {
                this.column编号 = new DataColumn("编号", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column编号);
                this.column名称 = new DataColumn("名称", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column名称);
                this.column拼音码 = new DataColumn("拼音码", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column拼音码);
                this.column费用 = new DataColumn("费用", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column费用);
                this.column费用分类 = new DataColumn("费用分类", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column费用分类);
                this.column病种分类 = new DataColumn("病种分类", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column病种分类);
                this.column备注 = new DataColumn("备注", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column备注);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.column编号}, true));
                this.column编号.AllowDBNull = false;
                this.column编号.Unique = true;
            }
            
            public 门诊收费项目Row New门诊收费项目Row() {
                return ((门诊收费项目Row)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new 门诊收费项目Row(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(门诊收费项目Row);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.门诊收费项目RowChanged != null)) {
                    this.门诊收费项目RowChanged(this, new 门诊收费项目RowChangeEvent(((门诊收费项目Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.门诊收费项目RowChanging != null)) {
                    this.门诊收费项目RowChanging(this, new 门诊收费项目RowChangeEvent(((门诊收费项目Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.门诊收费项目RowDeleted != null)) {
                    this.门诊收费项目RowDeleted(this, new 门诊收费项目RowChangeEvent(((门诊收费项目Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.门诊收费项目RowDeleting != null)) {
                    this.门诊收费项目RowDeleting(this, new 门诊收费项目RowChangeEvent(((门诊收费项目Row)(e.Row)), e.Action));
                }
            }
            
            public void Remove门诊收费项目Row(门诊收费项目Row row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 门诊收费项目Row : DataRow {
            
            private 门诊收费项目DataTable table门诊收费项目;
            
            internal 门诊收费项目Row(DataRowBuilder rb) : 
                    base(rb) {
                this.table门诊收费项目 = ((门诊收费项目DataTable)(this.Table));
            }
            
            public string 编号 {
                get {
                    return ((string)(this[this.table门诊收费项目.编号Column]));
                }
                set {
                    this[this.table门诊收费项目.编号Column] = value;
                }
            }
            
            public string 名称 {
                get {
                    try {
                        return ((string)(this[this.table门诊收费项目.名称Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊收费项目.名称Column] = value;
                }
            }
            
            public string 拼音码 {
                get {
                    try {
                        return ((string)(this[this.table门诊收费项目.拼音码Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊收费项目.拼音码Column] = value;
                }
            }
            
            public System.Decimal 费用 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table门诊收费项目.费用Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊收费项目.费用Column] = value;
                }
            }
            
            public string 费用分类 {
                get {
                    try {
                        return ((string)(this[this.table门诊收费项目.费用分类Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊收费项目.费用分类Column] = value;
                }
            }
            
            public string 病种分类 {
                get {
                    try {
                        return ((string)(this[this.table门诊收费项目.病种分类Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊收费项目.病种分类Column] = value;
                }
            }
            
            public string 备注 {
                get {
                    try {
                        return ((string)(this[this.table门诊收费项目.备注Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊收费项目.备注Column] = value;
                }
            }
            
            public bool Is名称Null() {
                return this.IsNull(this.table门诊收费项目.名称Column);
            }
            
            public void Set名称Null() {
                this[this.table门诊收费项目.名称Column] = System.Convert.DBNull;
            }
            
            public bool Is拼音码Null() {
                return this.IsNull(this.table门诊收费项目.拼音码Column);
            }
            
            public void Set拼音码Null() {
                this[this.table门诊收费项目.拼音码Column] = System.Convert.DBNull;
            }
            
            public bool Is费用Null() {
                return this.IsNull(this.table门诊收费项目.费用Column);
            }
            
            public void Set费用Null() {
                this[this.table门诊收费项目.费用Column] = System.Convert.DBNull;
            }
            
            public bool Is费用分类Null() {
                return this.IsNull(this.table门诊收费项目.费用分类Column);
            }
            
            public void Set费用分类Null() {
                this[this.table门诊收费项目.费用分类Column] = System.Convert.DBNull;
            }
            
            public bool Is病种分类Null() {
                return this.IsNull(this.table门诊收费项目.病种分类Column);
            }
            
            public void Set病种分类Null() {
                this[this.table门诊收费项目.病种分类Column] = System.Convert.DBNull;
            }
            
            public bool Is备注Null() {
                return this.IsNull(this.table门诊收费项目.备注Column);
            }
            
            public void Set备注Null() {
                this[this.table门诊收费项目.备注Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 门诊收费项目RowChangeEvent : EventArgs {
            
            private 门诊收费项目Row eventRow;
            
            private DataRowAction eventAction;
            
            public 门诊收费项目RowChangeEvent(门诊收费项目Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public 门诊收费项目Row Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}

						