企业管理

开发平台：
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 图书信息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["图书信息"] != 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图书罚款;
            }
        }
        
        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["图书信息"] != 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();
            }
        }
        
        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.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 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);
        
        [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 columnISBN;
            
            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 ISBNColumn {
                get {
                    return this.columnISBN;
                }
            }
            
            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 ISBN, string 出版社, System.Decimal 价格, int 页码, string 书架名称, int 现存量, int 库存总量, string 简介, bool 是否注销) {
                图书信息Row row图书信息Row = ((图书信息Row)(this.NewRow()));
                row图书信息Row.ItemArray = new object[] {
                        编号,
                        书名,
                        条形码,
                        类型,
                        作者,
                        译者,
                        ISBN,
                        出版社,
                        价格,
                        页码,
                        书架名称,
                        现存量,
                        库存总量,
                        简介,
                        是否注销};
                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.columnISBN = this.Columns["ISBN"];
                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.columnISBN = new DataColumn("ISBN", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnISBN);
                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(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(int), 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(bool), 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;
                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 {
                    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 ISBN {
                get {
                    try {
                        return ((string)(this[this.table图书信息.ISBNColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书信息.ISBNColumn] = 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 int 页码 {
                get {
                    try {
                        return ((int)(this[this.table图书信息.页码Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书信息.页码Column] = value;
                }
            }
            
            public string 书架名称 {
                get {
                    try {
                        return ((string)(this[this.table图书信息.书架名称Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书信息.书架名称Column] = value;
                }
            }
            
            public int 现存量 {
                get {
                    try {
                        return ((int)(this[this.table图书信息.现存量Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书信息.现存量Column] = value;
                }
            }
            
            public int 库存总量 {
                get {
                    try {
                        return ((int)(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 是否注销 {
                get {
                    return ((bool)(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;
            }
            
            public bool Is译者Null() {
                return this.IsNull(this.table图书信息.译者Column);
            }
            
            public void Set译者Null() {
                this[this.table图书信息.译者Column] = System.Convert.DBNull;
            }
            
            public bool IsISBNNull() {
                return this.IsNull(this.table图书信息.ISBNColumn);
            }
            
            public void SetISBNNull() {
                this[this.table图书信息.ISBNColumn] = 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应还时间;
            
            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状态;
                }
            }
            
            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 书名, System.DateTime 借阅时间, System.DateTime 应还时间, int 续借次数, string 操作员, 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["应还时间"];
                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(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.DateTime), 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借阅编号.AutoIncrement = true;
                this.column借阅编号.AllowDBNull = false;
                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 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 {
                    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.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 int 续借次数 {
                get {
                    try {
                        return ((int)(this[this.table图书借阅.续借次数Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书借阅.续借次数Column] = value;
                }
            }
            
            public string 操作员 {
                get {
                    try {
                        return ((string)(this[this.table图书借阅.操作员Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书借阅.操作员Column] = value;
                }
            }
            
            public string 状态 {
                get {
                    try {
                        return ((string)(this[this.table图书借阅.状态Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书借阅.状态Column] = value;
                }
            }
            
            public bool Is姓名Null() {
                return this.IsNull(this.table图书借阅.姓名Column);
            }
            
            public void Set姓名Null() {
                this[this.table图书借阅.姓名Column] = System.Convert.DBNull;
            }
            
            public bool Is读者编号Null() {
                return this.IsNull(this.table图书借阅.读者编号Column);
            }
            
            public void Set读者编号Null() {
                this[this.table图书借阅.读者编号Column] = System.Convert.DBNull;
            }
            
            public bool Is图书编号Null() {
                return this.IsNull(this.table图书借阅.图书编号Column);
            }
            
            public void Set图书编号Null() {
                this[this.table图书借阅.图书编号Column] = System.Convert.DBNull;
            }
            
            public bool Is书名Null() {
                return this.IsNull(this.table图书借阅.书名Column);
            }
            
            public void Set书名Null() {
                this[this.table图书借阅.书名Column] = System.Convert.DBNull;
            }
            
            public bool Is借阅时间Null() {
                return this.IsNull(this.table图书借阅.借阅时间Column);
            }
            
            public void Set借阅时间Null() {
                this[this.table图书借阅.借阅时间Column] = System.Convert.DBNull;
            }
            
            public bool Is应还时间Null() {
                return this.IsNull(this.table图书借阅.应还时间Column);
            }
            
            public void Set应还时间Null() {
                this[this.table图书借阅.应还时间Column] = System.Convert.DBNull;
            }
            
            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备注;
            
            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备注;
                }
            }
            
            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 姓名, System.DateTime 罚款日期, System.Decimal 应罚金额, System.Decimal 实收金额, bool 是否交款, 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["应罚金额"];
                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(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(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column实收金额);
                this.column是否交款 = new DataColumn("是否交款", typeof(bool), 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;
            }
            
            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 {
                    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.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 {
                    try {
                        return ((System.Decimal)(this[this.table图书罚款.应罚金额Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书罚款.应罚金额Column] = value;
                }
            }
            
            public System.Decimal 实收金额 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table图书罚款.实收金额Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table图书罚款.实收金额Column] = value;
                }
            }
            
            public bool 是否交款 {
                get {
                    try {
                        return ((bool)(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;
            }
        }
        
        [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;
                }
            }
        }
    }
}

						