企业管理

开发平台：
C#

DataSet3.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 DataSet3 : DataSet {
        
        private 门诊划价明细DataTable table门诊划价明细;
        
        private 门诊划价DataTable table门诊划价;
        
        private 门诊挂号DataTable table门诊挂号;
        
        private 药品库存DataTable table药品库存;
        
        public DataSet3() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected DataSet3(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["门诊划价"]));
                }
                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门诊划价;
            }
        }
        
        [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() {
            DataSet3 cln = ((DataSet3)(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["门诊划价"]));
            }
            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();
            }
            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 = "DataSet3";
            this.Prefix = "";
            this.Namespace = "http://www.tempuri.org/DataSet3.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门诊划价);
            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 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);
        
        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划价编号;
            
            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 名称, System.Decimal 单价, System.Decimal 数量, System.Decimal 金额, string 划价编号) {
                门诊划价明细Row row门诊划价明细Row = ((门诊划价明细Row)(this.NewRow()));
                row门诊划价明细Row.ItemArray = new object[] {
                        null,
                        药品编号,
                        名称,
                        单价,
                        数量,
                        金额,
                        划价编号};
                this.Rows.Add(row门诊划价明细Row);
                return row门诊划价明细Row;
            }
            
            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(int), 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(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column划价编号);
                this.column编号.AutoIncrement = true;
                this.column编号.AllowDBNull = false;
                this.column编号.ReadOnly = true;
                this.column药品编号.AllowDBNull = false;
                this.column划价编号.AllowDBNull = false;
            }
            
            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 int 编号 {
                get {
                    return ((int)(this[this.table门诊划价明细.编号Column]));
                }
                set {
                    this[this.table门诊划价明细.编号Column] = value;
                }
            }
            
            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 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 {
                    return ((string)(this[this.table门诊划价明细.划价编号Column]));
                }
                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;
            }
        }
        
        [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划价时间;
            
            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 挂号编号, string 医生, System.DateTime 划价时间, string 划价员, string 是否收费, string 收费员, System.DateTime 收费时间, System.Decimal 划价金额, string 是否发药, System.DateTime 发药时间, string 发药员) {
                门诊划价Row row门诊划价Row = ((门诊划价Row)(this.NewRow()));
                row门诊划价Row.ItemArray = new object[] {
                        姓名,
                        性别,
                        编号,
                        科室,
                        挂号编号,
                        医生,
                        划价时间,
                        划价员,
                        是否收费,
                        收费员,
                        收费时间,
                        划价金额,
                        是否发药,
                        发药时间,
                        发药员};
                this.Rows.Add(row门诊划价Row);
                return row门诊划价Row;
            }
            
            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(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column医生);
                this.column划价时间 = new DataColumn("划价时间", typeof(System.DateTime), 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.DateTime), 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(System.DateTime), 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编号.AllowDBNull = false;
                this.column划价时间.AllowDBNull = false;
                this.column划价金额.AllowDBNull = false;
            }
            
            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 {
                    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 {
                    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 System.DateTime 划价时间 {
                get {
                    return ((System.DateTime)(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 System.DateTime 收费时间 {
                get {
                    try {
                        return ((System.DateTime)(this[this.table门诊划价.收费时间Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table门诊划价.收费时间Column] = value;
                }
            }
            
            public System.Decimal 划价金额 {
                get {
                    return ((System.Decimal)(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 System.DateTime 发药时间 {
                get {
                    try {
                        return ((System.DateTime)(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;
            }
            
            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挂号金额;
            
            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挂号金额;
                }
            }
            
            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 挂号科室, int 人数, System.Decimal 挂号金额) {
                门诊挂号Row row门诊挂号Row = ((门诊挂号Row)(this.NewRow()));
                row门诊挂号Row.ItemArray = new object[] {
                        挂号科室,
                        人数,
                        挂号金额};
                this.Rows.Add(row门诊挂号Row);
                return row门诊挂号Row;
            }
            
            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["挂号金额"];
            }
            
            private void InitClass() {
                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人数.ReadOnly = true;
                this.column挂号金额.ReadOnly = 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 {
                    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 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备注;
            
            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备注;
                }
            }
            
            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 备注) {
                药品库存Row row药品库存Row = ((药品库存Row)(this.NewRow()));
                row药品库存Row.ItemArray = new object[] {
                        名称,
                        null,
                        库房,
                        药品编号,
                        药品数量,
                        备注};
                this.Rows.Add(row药品库存Row);
                return row药品库存Row;
            }
            
            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["备注"];
            }
            
            private void InitClass() {
                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(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编号.AutoIncrement = true;
                this.column编号.AllowDBNull = false;
                this.column编号.ReadOnly = true;
                this.column药品编号.AllowDBNull = false;
            }
            
            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 {
                    try {
                        return ((string)(this[this.table药品库存.名称Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table药品库存.名称Column] = value;
                }
            }
            
            public int 编号 {
                get {
                    return ((int)(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 {
                    return ((string)(this[this.table药品库存.药品编号Column]));
                }
                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 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;
                }
            }
        }
    }
}

						