企业管理

开发平台：
C#

DataSet2.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 DataSet2 : DataSet {
        
        private v收费项目及药品DataTable tablev收费项目及药品;
        
        private 门诊挂号DataTable table门诊挂号;
        
        private 门诊划价明细DataTable table门诊划价明细;
        
        private 门诊划价DataTable table门诊划价;
        
        public DataSet2() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected DataSet2(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["v收费项目及药品"] != null)) {
                    this.Tables.Add(new v收费项目及药品DataTable(ds.Tables["v收费项目及药品"]));
                }
                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 v收费项目及药品DataTable v收费项目及药品 {
            get {
                return this.tablev收费项目及药品;
            }
        }
        
        [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() {
            DataSet2 cln = ((DataSet2)(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["v收费项目及药品"] != null)) {
                this.Tables.Add(new v收费项目及药品DataTable(ds.Tables["v收费项目及药品"]));
            }
            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.tablev收费项目及药品 = ((v收费项目及药品DataTable)(this.Tables["v收费项目及药品"]));
            if ((this.tablev收费项目及药品 != null)) {
                this.tablev收费项目及药品.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 = "DataSet2";
            this.Prefix = "";
            this.Namespace = "http://www.tempuri.org/DataSet2.xsd";
            this.Locale = new System.Globalization.CultureInfo("zh-CN");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.tablev收费项目及药品 = new v收费项目及药品DataTable();
            this.Tables.Add(this.tablev收费项目及药品);
            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 ShouldSerializev收费项目及药品() {
            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 v收费项目及药品RowChangeEventHandler(object sender, v收费项目及药品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 v收费项目及药品DataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn column编号;
            
            private DataColumn column名称;
            
            private DataColumn column规格;
            
            private DataColumn column单位;
            
            private DataColumn column单价;
            
            private DataColumn column拼音码;
            
            internal v收费项目及药品DataTable() : 
                    base("v收费项目及药品") {
                this.InitClass();
            }
            
            internal v收费项目及药品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 v收费项目及药品Row this[int index] {
                get {
                    return ((v收费项目及药品Row)(this.Rows[index]));
                }
            }
            
            public event v收费项目及药品RowChangeEventHandler v收费项目及药品RowChanged;
            
            public event v收费项目及药品RowChangeEventHandler v收费项目及药品RowChanging;
            
            public event v收费项目及药品RowChangeEventHandler v收费项目及药品RowDeleted;
            
            public event v收费项目及药品RowChangeEventHandler v收费项目及药品RowDeleting;
            
            public void Addv收费项目及药品Row(v收费项目及药品Row row) {
                this.Rows.Add(row);
            }
            
            public v收费项目及药品Row Addv收费项目及药品Row(string 编号, string 名称, string 规格, string 单位, System.Decimal 单价, string 拼音码) {
                v收费项目及药品Row rowv收费项目及药品Row = ((v收费项目及药品Row)(this.NewRow()));
                rowv收费项目及药品Row.ItemArray = new object[] {
                        编号,
                        名称,
                        规格,
                        单位,
                        单价,
                        拼音码};
                this.Rows.Add(rowv收费项目及药品Row);
                return rowv收费项目及药品Row;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                v收费项目及药品DataTable cln = ((v收费项目及药品DataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new v收费项目及药品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(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编号.AllowDBNull = false;
            }
            
            public v收费项目及药品Row Newv收费项目及药品Row() {
                return ((v收费项目及药品Row)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new v收费项目及药品Row(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(v收费项目及药品Row);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.v收费项目及药品RowChanged != null)) {
                    this.v收费项目及药品RowChanged(this, new v收费项目及药品RowChangeEvent(((v收费项目及药品Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.v收费项目及药品RowChanging != null)) {
                    this.v收费项目及药品RowChanging(this, new v收费项目及药品RowChangeEvent(((v收费项目及药品Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.v收费项目及药品RowDeleted != null)) {
                    this.v收费项目及药品RowDeleted(this, new v收费项目及药品RowChangeEvent(((v收费项目及药品Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.v收费项目及药品RowDeleting != null)) {
                    this.v收费项目及药品RowDeleting(this, new v收费项目及药品RowChangeEvent(((v收费项目及药品Row)(e.Row)), e.Action));
                }
            }
            
            public void Removev收费项目及药品Row(v收费项目及药品Row row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class v收费项目及药品Row : DataRow {
            
            private v收费项目及药品DataTable tablev收费项目及药品;
            
            internal v收费项目及药品Row(DataRowBuilder rb) : 
                    base(rb) {
                this.tablev收费项目及药品 = ((v收费项目及药品DataTable)(this.Table));
            }
            
            public string 编号 {
                get {
                    return ((string)(this[this.tablev收费项目及药品.编号Column]));
                }
                set {
                    this[this.tablev收费项目及药品.编号Column] = value;
                }
            }
            
            public string 名称 {
                get {
                    try {
                        return ((string)(this[this.tablev收费项目及药品.名称Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablev收费项目及药品.名称Column] = value;
                }
            }
            
            public string 规格 {
                get {
                    try {
                        return ((string)(this[this.tablev收费项目及药品.规格Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablev收费项目及药品.规格Column] = value;
                }
            }
            
            public string 单位 {
                get {
                    try {
                        return ((string)(this[this.tablev收费项目及药品.单位Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablev收费项目及药品.单位Column] = value;
                }
            }
            
            public System.Decimal 单价 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablev收费项目及药品.单价Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablev收费项目及药品.单价Column] = value;
                }
            }
            
            public string 拼音码 {
                get {
                    try {
                        return ((string)(this[this.tablev收费项目及药品.拼音码Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablev收费项目及药品.拼音码Column] = value;
                }
            }
            
            public bool Is名称Null() {
                return this.IsNull(this.tablev收费项目及药品.名称Column);
            }
            
            public void Set名称Null() {
                this[this.tablev收费项目及药品.名称Column] = System.Convert.DBNull;
            }
            
            public bool Is规格Null() {
                return this.IsNull(this.tablev收费项目及药品.规格Column);
            }
            
            public void Set规格Null() {
                this[this.tablev收费项目及药品.规格Column] = System.Convert.DBNull;
            }
            
            public bool Is单位Null() {
                return this.IsNull(this.tablev收费项目及药品.单位Column);
            }
            
            public void Set单位Null() {
                this[this.tablev收费项目及药品.单位Column] = System.Convert.DBNull;
            }
            
            public bool Is单价Null() {
                return this.IsNull(this.tablev收费项目及药品.单价Column);
            }
            
            public void Set单价Null() {
                this[this.tablev收费项目及药品.单价Column] = System.Convert.DBNull;
            }
            
            public bool Is拼音码Null() {
                return this.IsNull(this.tablev收费项目及药品.拼音码Column);
            }
            
            public void Set拼音码Null() {
                this[this.tablev收费项目及药品.拼音码Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class v收费项目及药品RowChangeEvent : EventArgs {
            
            private v收费项目及药品Row eventRow;
            
            private DataRowAction eventAction;
            
            public v收费项目及药品RowChangeEvent(v收费项目及药品Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public v收费项目及药品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是否已划价;
            
            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是否已划价;
                }
            }
            
            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 费用类型, string 挂号类型, 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 门诊挂号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["是否已划价"];
            }
            
            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(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(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.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 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 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;
            }
        }
        
        [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 名称, 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;
                }
            }
        }
    }
}

						