企业管理

开发平台：
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余额方向;
            
            internal 帐簿初始化表DataTable() : 
                    base("帐簿初始化表") {
                this.InitClass();
            }
            
            internal 帐簿初始化表DataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn 科目代码Column {
                get {
                    return this.column科目代码;
                }
            }
            
            internal DataColumn 科目名称Column {
                get {
                    return this.column科目名称;
                }
            }
            
            internal DataColumn 累计借方Column {
                get {
                    return this.column累计借方;
                }
            }
            
            internal DataColumn 累计贷方Column {
                get {
                    return this.column累计贷方;
                }
            }
            
            internal DataColumn 期初余额Column {
                get {
                    return this.column期初余额;
                }
            }
            
            internal DataColumn 余额方向Column {
                get {
                    return this.column余额方向;
                }
            }
            
            public 帐簿初始化表Row this[int index] {
                get {
                    return ((帐簿初始化表Row)(this.Rows[index]));
                }
            }
            
            public event 帐簿初始化表RowChangeEventHandler 帐簿初始化表RowChanged;
            
            public event 帐簿初始化表RowChangeEventHandler 帐簿初始化表RowChanging;
            
            public event 帐簿初始化表RowChangeEventHandler 帐簿初始化表RowDeleted;
            
            public event 帐簿初始化表RowChangeEventHandler 帐簿初始化表RowDeleting;
            
            public void Add帐簿初始化表Row(帐簿初始化表Row row) {
                this.Rows.Add(row);
            }
            
            public 帐簿初始化表Row Add帐簿初始化表Row(string 科目代码, string 科目名称, System.Decimal 累计借方, System.Decimal 累计贷方, System.Decimal 期初余额, 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["余额方向"];
            }
            
            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(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.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 System.Decimal 累计借方 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table帐簿初始化表.累计借方Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table帐簿初始化表.累计借方Column] = value;
                }
            }
            
            public System.Decimal 累计贷方 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table帐簿初始化表.累计贷方Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table帐簿初始化表.累计贷方Column] = value;
                }
            }
            
            public System.Decimal 期初余额 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table帐簿初始化表.期初余额Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table帐簿初始化表.期初余额Column] = value;
                }
            }
            
            public string 余额方向 {
                get {
                    try {
                        return ((string)(this[this.table帐簿初始化表.余额方向Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table帐簿初始化表.余额方向Column] = value;
                }
            }
            
            public bool Is科目名称Null() {
                return this.IsNull(this.table帐簿初始化表.科目名称Column);
            }
            
            public void Set科目名称Null() {
                this[this.table帐簿初始化表.科目名称Column] = System.Convert.DBNull;
            }
            
            public bool Is累计借方Null() {
                return this.IsNull(this.table帐簿初始化表.累计借方Column);
            }
            
            public void Set累计借方Null() {
                this[this.table帐簿初始化表.累计借方Column] = System.Convert.DBNull;
            }
            
            public bool Is累计贷方Null() {
                return this.IsNull(this.table帐簿初始化表.累计贷方Column);
            }
            
            public void Set累计贷方Null() {
                this[this.table帐簿初始化表.累计贷方Column] = System.Convert.DBNull;
            }
            
            public bool Is期初余额Null() {
                return this.IsNull(this.table帐簿初始化表.期初余额Column);
            }
            
            public void Set期初余额Null() {
                this[this.table帐簿初始化表.期初余额Column] = System.Convert.DBNull;
            }
            
            public bool Is余额方向Null() {
                return this.IsNull(this.table帐簿初始化表.余额方向Column);
            }
            
            public void Set余额方向Null() {
                this[this.table帐簿初始化表.余额方向Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 帐簿初始化表RowChangeEvent : EventArgs {
            
            private 帐簿初始化表Row eventRow;
            
            private DataRowAction eventAction;
            
            public 帐簿初始化表RowChangeEvent(帐簿初始化表Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public 帐簿初始化表Row Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 系统参数表DataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn column编号;
            
            private DataColumn column参数名称;
            
            private DataColumn column取值;
            
            internal 系统参数表DataTable() : 
                    base("系统参数表") {
                this.InitClass();
            }
            
            internal 系统参数表DataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn 编号Column {
                get {
                    return this.column编号;
                }
            }
            
            internal DataColumn 参数名称Column {
                get {
                    return this.column参数名称;
                }
            }
            
            internal DataColumn 取值Column {
                get {
                    return this.column取值;
                }
            }
            
            public 系统参数表Row this[int index] {
                get {
                    return ((系统参数表Row)(this.Rows[index]));
                }
            }
            
            public event 系统参数表RowChangeEventHandler 系统参数表RowChanged;
            
            public event 系统参数表RowChangeEventHandler 系统参数表RowChanging;
            
            public event 系统参数表RowChangeEventHandler 系统参数表RowDeleted;
            
            public event 系统参数表RowChangeEventHandler 系统参数表RowDeleting;
            
            public void Add系统参数表Row(系统参数表Row row) {
                this.Rows.Add(row);
            }
            
            public 系统参数表Row Add系统参数表Row(string 参数名称, int 取值) {
                系统参数表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["取值"];
            }
            
            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(int), 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 int 取值 {
                get {
                    try {
                        return ((int)(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;
            }
        }
        
        [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其他负债;
            
            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其他负债;
                }
            }
            
            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(
                        int 会计期间, 
                        System.Decimal 现金及现金等价物, 
                        System.Decimal 应收账款, 
                        System.Decimal 坏账准备, 
                        System.Decimal 应收账款净值, 
                        System.Decimal 流动资产总计, 
                        System.Decimal 固定资产原值, 
                        System.Decimal 累计折旧, 
                        System.Decimal 固定资产总计, 
                        System.Decimal 其他资产, 
                        System.Decimal 资产总计, 
                        System.Decimal 应付账款, 
                        System.Decimal 预收账款, 
                        System.Decimal 应付工资, 
                        System.Decimal 其他负债, 
                        System.Decimal 负债总计, 
                        System.Decimal 实收资本, 
                        System.Decimal 资本公积, 
                        System.Decimal 赢余公积, 
                        System.Decimal 未分配利润, 
                        System.Decimal 所有者权益总计, 
                        System.Decimal 负债及所有者权益总计) {
                资产负债表Row row资产负债表Row = ((资产负债表Row)(this.NewRow()));
                row资产负债表Row.ItemArray = new object[] {
                        会计期间,
                        现金及现金等价物,
                        应收账款,
                        坏账准备,
                        应收账款净值,
                        流动资产总计,
                        固定资产原值,
                        累计折旧,
                        固定资产总计,
                        其他资产,
                        资产总计,
                        应付账款,
                        预收账款,
                        应付工资,
                        其他负债,
                        负债总计,
                        实收资本,
                        资本公积,
                        赢余公积,
                        未分配利润,
                        所有者权益总计,
                        负债及所有者权益总计};
                this.Rows.Add(row资产负债表Row);
                return row资产负债表Row;
            }
            
            public 资产负债表Row FindBy会计期间(int 会计期间) {
                return ((资产负债表Row)(this.Rows.Find(new object[] {
                            会计期间})));
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                资产负债表DataTable cln = ((资产负债表DataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new 资产负债表DataTable();
            }
            
            internal void InitVars() {
                this.column会计期间 = this.Columns["会计期间"];
                this.column现金及现金等价物 = this.Columns["现金及现金等价物"];
                this.column应收账款 = this.Columns["应收账款"];
                this.column坏账准备 = this.Columns["坏账准备"];
                this.column应收账款净值 = this.Columns["应收账款净值"];
                this.column流动资产总计 = this.Columns["流动资产总计"];
                this.column固定资产原值 = this.Columns["固定资产原值"];
                this.column累计折旧 = this.Columns["累计折旧"];
                this.column固定资产总计 = this.Columns["固定资产总计"];
                this.column其他资产 = this.Columns["其他资产"];
                this.column资产总计 = this.Columns["资产总计"];
                this.column应付账款 = this.Columns["应付账款"];
                this.column预收账款 = this.Columns["预收账款"];
                this.column应付工资 = this.Columns["应付工资"];
                this.column其他负债 = this.Columns["其他负债"];
                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(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column现金及现金等价物);
                this.column应收账款 = new DataColumn("应收账款", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column应收账款);
                this.column坏账准备 = new DataColumn("坏账准备", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column坏账准备);
                this.column应收账款净值 = new DataColumn("应收账款净值", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column应收账款净值);
                this.column流动资产总计 = new DataColumn("流动资产总计", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column流动资产总计);
                this.column固定资产原值 = new DataColumn("固定资产原值", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column固定资产原值);
                this.column累计折旧 = new DataColumn("累计折旧", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column累计折旧);
                this.column固定资产总计 = new DataColumn("固定资产总计", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column固定资产总计);
                this.column其他资产 = new DataColumn("其他资产", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column其他资产);
                this.column资产总计 = new DataColumn("资产总计", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column资产总计);
                this.column应付账款 = new DataColumn("应付账款", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column应付账款);
                this.column预收账款 = new DataColumn("预收账款", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column预收账款);
                this.column应付工资 = new DataColumn("应付工资", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column应付工资);
                this.column其他负债 = new DataColumn("其他负债", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column其他负债);
                this.column负债总计 = new DataColumn("负债总计", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column负债总计);
                this.column实收资本 = new DataColumn("实收资本", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column实收资本);
                this.column资本公积 = new DataColumn("资本公积", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column资本公积);
                this.column赢余公积 = new DataColumn("赢余公积", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column赢余公积);
                this.column未分配利润 = new DataColumn("未分配利润", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column未分配利润);
                this.column所有者权益总计 = new DataColumn("所有者权益总计", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column所有者权益总计);
                this.column负债及所有者权益总计 = new DataColumn("负债及所有者权益总计", typeof(System.Decimal), 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 int 会计期间 {
                get {
                    return ((int)(this[this.table资产负债表.会计期间Column]));
                }
                set {
                    this[this.table资产负债表.会计期间Column] = value;
                }
            }
            
            public System.Decimal 现金及现金等价物 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.现金及现金等价物Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.现金及现金等价物Column] = value;
                }
            }
            
            public System.Decimal 应收账款 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.应收账款Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.应收账款Column] = value;
                }
            }
            
            public System.Decimal 坏账准备 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.坏账准备Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.坏账准备Column] = value;
                }
            }
            
            public System.Decimal 应收账款净值 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.应收账款净值Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.应收账款净值Column] = value;
                }
            }
            
            public System.Decimal 流动资产总计 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.流动资产总计Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.流动资产总计Column] = value;
                }
            }
            
            public System.Decimal 固定资产原值 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.固定资产原值Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.固定资产原值Column] = value;
                }
            }
            
            public System.Decimal 累计折旧 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.累计折旧Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.累计折旧Column] = value;
                }
            }
            
            public System.Decimal 固定资产总计 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.固定资产总计Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.固定资产总计Column] = value;
                }
            }
            
            public System.Decimal 其他资产 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.其他资产Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.其他资产Column] = value;
                }
            }
            
            public System.Decimal 资产总计 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.资产总计Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.资产总计Column] = value;
                }
            }
            
            public System.Decimal 应付账款 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.应付账款Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.应付账款Column] = value;
                }
            }
            
            public System.Decimal 预收账款 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.预收账款Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.预收账款Column] = value;
                }
            }
            
            public System.Decimal 应付工资 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.应付工资Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.应付工资Column] = value;
                }
            }
            
            public System.Decimal 其他负债 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.其他负债Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.其他负债Column] = value;
                }
            }
            
            public System.Decimal 负债总计 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.负债总计Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.负债总计Column] = value;
                }
            }
            
            public System.Decimal 实收资本 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.实收资本Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.实收资本Column] = value;
                }
            }
            
            public System.Decimal 资本公积 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.资本公积Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.资本公积Column] = value;
                }
            }
            
            public System.Decimal 赢余公积 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.赢余公积Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.赢余公积Column] = value;
                }
            }
            
            public System.Decimal 未分配利润 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.未分配利润Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.未分配利润Column] = value;
                }
            }
            
            public System.Decimal 所有者权益总计 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.所有者权益总计Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.所有者权益总计Column] = value;
                }
            }
            
            public System.Decimal 负债及所有者权益总计 {
                get {
                    try {
                        return ((System.Decimal)(this[this.table资产负债表.负债及所有者权益总计Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table资产负债表.负债及所有者权益总计Column] = value;
                }
            }
            
            public bool Is现金及现金等价物Null() {
                return this.IsNull(this.table资产负债表.现金及现金等价物Column);
            }
            
            public void Set现金及现金等价物Null() {
                this[this.table资产负债表.现金及现金等价物Column] = System.Convert.DBNull;
            }
            
            public bool Is应收账款Null() {
                return this.IsNull(this.table资产负债表.应收账款Column);
            }
            
            public void Set应收账款Null() {
                this[this.table资产负债表.应收账款Column] = System.Convert.DBNull;
            }
            
            public bool Is坏账准备Null() {
                return this.IsNull(this.table资产负债表.坏账准备Column);
            }
            
            public void Set坏账准备Null() {
                this[this.table资产负债表.坏账准备Column] = System.Convert.DBNull;
            }
            
            public bool Is应收账款净值Null() {
                return this.IsNull(this.table资产负债表.应收账款净值Column);
            }
            
            public void Set应收账款净值Null() {
                this[this.table资产负债表.应收账款净值Column] = System.Convert.DBNull;
            }
            
            public bool Is流动资产总计Null() {
                return this.IsNull(this.table资产负债表.流动资产总计Column);
            }
            
            public void Set流动资产总计Null() {
                this[this.table资产负债表.流动资产总计Column] = System.Convert.DBNull;
            }
            
            public bool Is固定资产原值Null() {
                return this.IsNull(this.table资产负债表.固定资产原值Column);
            }
            
            public void Set固定资产原值Null() {
                this[this.table资产负债表.固定资产原值Column] = System.Convert.DBNull;
            }
            
            public bool Is累计折旧Null() {
                return this.IsNull(this.table资产负债表.累计折旧Column);
            }
            
            public void Set累计折旧Null() {
                this[this.table资产负债表.累计折旧Column] = System.Convert.DBNull;
            }
            
            public bool Is固定资产总计Null() {
                return this.IsNull(this.table资产负债表.固定资产总计Column);
            }
            
            public void Set固定资产总计Null() {
                this[this.table资产负债表.固定资产总计Column] = System.Convert.DBNull;
            }
            
            public bool Is其他资产Null() {
                return this.IsNull(this.table资产负债表.其他资产Column);
            }
            
            public void Set其他资产Null() {
                this[this.table资产负债表.其他资产Column] = System.Convert.DBNull;
            }
            
            public bool Is资产总计Null() {
                return this.IsNull(this.table资产负债表.资产总计Column);
            }
            
            public void Set资产总计Null() {
                this[this.table资产负债表.资产总计Column] = System.Convert.DBNull;
            }
            
            public bool Is应付账款Null() {
                return this.IsNull(this.table资产负债表.应付账款Column);
            }
            
            public void Set应付账款Null() {
                this[this.table资产负债表.应付账款Column] = System.Convert.DBNull;
            }
            
            public bool Is预收账款Null() {
                return this.IsNull(this.table资产负债表.预收账款Column);
            }
            
            public void Set预收账款Null() {
                this[this.table资产负债表.预收账款Column] = System.Convert.DBNull;
            }
            
            public bool Is应付工资Null() {
                return this.IsNull(this.table资产负债表.应付工资Column);
            }
            
            public void Set应付工资Null() {
                this[this.table资产负债表.应付工资Column] = System.Convert.DBNull;
            }
            
            public bool Is其他负债Null() {
                return this.IsNull(this.table资产负债表.其他负债Column);
            }
            
            public void Set其他负债Null() {
                this[this.table资产负债表.其他负债Column] = System.Convert.DBNull;
            }
            
            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;
                }
            }
        }
    }
}

						