dataset2.cs

医院门诊收费系统

            }
            
            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("DataSet2Key1", 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;