企业管理

开发平台：
C#

DataSet3.cs：源码内容
							﻿//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------
namespace 生产管理系统 {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;
    
    
    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class DataSet3 : DataSet {
        
        private 主生产计划DataTable table主生产计划;
        
        private mrp物料需求计算DataTable tablemrp物料需求计算;
        
        private mrp物料需求历史DataTable tablemrp物料需求历史;
        
        public DataSet3() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected DataSet3(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["主生产计划"] != null)) {
                    this.Tables.Add(new 主生产计划DataTable(ds.Tables["主生产计划"]));
                }
                if ((ds.Tables["mrp物料需求计算"] != null)) {
                    this.Tables.Add(new mrp物料需求计算DataTable(ds.Tables["mrp物料需求计算"]));
                }
                if ((ds.Tables["mrp物料需求历史"] != null)) {
                    this.Tables.Add(new mrp物料需求历史DataTable(ds.Tables["mrp物料需求历史"]));
                }
                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 mrp物料需求计算DataTable mrp物料需求计算 {
            get {
                return this.tablemrp物料需求计算;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public mrp物料需求历史DataTable mrp物料需求历史 {
            get {
                return this.tablemrp物料需求历史;
            }
        }
        
        public override DataSet Clone() {
            DataSet3 cln = ((DataSet3)(base.Clone()));
            cln.InitVars();
            return cln;
        }
        
        protected override bool ShouldSerializeTables() {
            return false;
        }
        
        protected override bool ShouldSerializeRelations() {
            return false;
        }
        
        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["主生产计划"] != null)) {
                this.Tables.Add(new 主生产计划DataTable(ds.Tables["主生产计划"]));
            }
            if ((ds.Tables["mrp物料需求计算"] != null)) {
                this.Tables.Add(new mrp物料需求计算DataTable(ds.Tables["mrp物料需求计算"]));
            }
            if ((ds.Tables["mrp物料需求历史"] != null)) {
                this.Tables.Add(new mrp物料需求历史DataTable(ds.Tables["mrp物料需求历史"]));
            }
            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.tablemrp物料需求计算 = ((mrp物料需求计算DataTable)(this.Tables["mrp物料需求计算"]));
            if ((this.tablemrp物料需求计算 != null)) {
                this.tablemrp物料需求计算.InitVars();
            }
            this.tablemrp物料需求历史 = ((mrp物料需求历史DataTable)(this.Tables["mrp物料需求历史"]));
            if ((this.tablemrp物料需求历史 != null)) {
                this.tablemrp物料需求历史.InitVars();
            }
        }
        
        private void InitClass() {
            this.DataSetName = "DataSet3";
            this.Prefix = "";
            this.Namespace = "http://www.tempuri.org/DataSet3.xsd";
            this.Locale = new System.Globalization.CultureInfo("zh-CN");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.table主生产计划 = new 主生产计划DataTable();
            this.Tables.Add(this.table主生产计划);
            this.tablemrp物料需求计算 = new mrp物料需求计算DataTable();
            this.Tables.Add(this.tablemrp物料需求计算);
            this.tablemrp物料需求历史 = new mrp物料需求历史DataTable();
            this.Tables.Add(this.tablemrp物料需求历史);
        }
        
        private bool ShouldSerialize主生产计划() {
            return false;
        }
        
        private bool ShouldSerializemrp物料需求计算() {
            return false;
        }
        
        private bool ShouldSerializemrp物料需求历史() {
            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 mrp物料需求计算RowChangeEventHandler(object sender, mrp物料需求计算RowChangeEvent e);
        
        public delegate void mrp物料需求历史RowChangeEventHandler(object sender, mrp物料需求历史RowChangeEvent e);
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 主生产计划DataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn column物料名称;
            
            private DataColumn column物料编号;
            
            private DataColumn column编号;
            
            private DataColumn column年份;
            
            private DataColumn column计划期;
            
            private DataColumn column开始日期;
            
            private DataColumn column结束日期;
            
            private DataColumn column期初库存;
            
            private DataColumn column需求数量;
            
            private DataColumn columnMPS数量;
            
            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 MPS数量Column {
                get {
                    return this.columnMPS数量;
                }
            }
            
            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 编号, 
                        int 年份, 
                        int 计划期, 
                        int 开始日期, 
                        int 结束日期, 
                        System.Decimal 期初库存, 
                        System.Decimal 需求数量, 
                        System.Decimal MPS数量, 
                        System.Decimal 生产单数量, 
                        System.Decimal 预计库存, 
                        string 记帐人, 
                        int 修改日期, 
                        string 审核人, 
                        int 审核日期, 
                        string 状态, 
                        string 备注) {
                主生产计划Row row主生产计划Row = ((主生产计划Row)(this.NewRow()));
                row主生产计划Row.ItemArray = new object[] {
                        物料名称,
                        物料编号,
                        编号,
                        年份,
                        计划期,
                        开始日期,
                        结束日期,
                        期初库存,
                        需求数量,
                        MPS数量,
                        生产单数量,
                        预计库存,
                        记帐人,
                        修改日期,
                        审核人,
                        审核日期,
                        状态,
                        备注};
                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.columnMPS数量 = this.Columns["MPS数量"];
                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(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(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(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.columnMPS数量 = new DataColumn("MPS数量", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnMPS数量);
                this.column生产单数量 = new DataColumn("生产单数量", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column生产单数量);
                this.column预计库存 = new DataColumn("预计库存", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column预计库存);
                this.column记帐人 = new DataColumn("记帐人", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column记帐人);
                this.column修改日期 = 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(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物料名称.AllowDBNull = false;
                this.column物料编号.AllowDBNull = false;
                this.column年份.AllowDBNull = false;
                this.column计划期.AllowDBNull = false;
                this.columnMPS数量.AllowDBNull = false;
                this.column状态.AllowDBNull = false;
            }
            
            public 主生产计划Row New主生产计划Row() {
                return ((主生产计划Row)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new 主生产计划Row(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(主生产计划Row);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.主生产计划RowChanged != null)) {
                    this.主生产计划RowChanged(this, new 主生产计划RowChangeEvent(((主生产计划Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.主生产计划RowChanging != null)) {
                    this.主生产计划RowChanging(this, new 主生产计划RowChangeEvent(((主生产计划Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.主生产计划RowDeleted != null)) {
                    this.主生产计划RowDeleted(this, new 主生产计划RowChangeEvent(((主生产计划Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.主生产计划RowDeleting != null)) {
                    this.主生产计划RowDeleting(this, new 主生产计划RowChangeEvent(((主生产计划Row)(e.Row)), e.Action));
                }
            }
            
            public void Remove主生产计划Row(主生产计划Row row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 主生产计划Row : DataRow {
            
            private 主生产计划DataTable table主生产计划;
            
            internal 主生产计划Row(DataRowBuilder rb) : 
                    base(rb) {
                this.table主生产计划 = ((主生产计划DataTable)(this.Table));
            }
            
            public string 物料名称 {
                get {
                    return ((string)(this[this.table主生产计划.物料名称Column]));
                }
                set {
                    this[this.table主生产计划.物料名称Column] = value;
                }
            }
            
            public string 物料编号 {
                get {
                    return ((string)(this[this.table主生产计划.物料编号Column]));
                }
                set {
                    this[this.table主生产计划.物料编号Column] = value;
                }
            }
            
            public string 编号 {
                get {
                    try {
                        return ((string)(this[this.table主生产计划.编号Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.table主生产计划.编号Column] = value;
                }
            }
            
            public int 年份 {
                get {
                    return ((int)(this[this.table主生产计划.年份Column]));
                }
                set {
                    this[this.table主生产计划.年份Column] = value;
                }
            }
            
            public int 计划期 {
                get {
                    return ((int)(this[this.table主生产计划.计划期Column]));
                }
                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 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 MPS数量 {
                get {
                    return ((System.Decimal)(this[this.table主生产计划.MPS数量Column]));
                }
                set {
                    this[this.table主生产计划.MPS数量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 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 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 bool Is编号Null() {
                return this.IsNull(this.table主生产计划.编号Column);
            }
            
            public void Set编号Null() {
                this[this.table主生产计划.编号Column] = System.Convert.DBNull;
            }
            
            public bool Is开始日期Null() {
                return this.IsNull(this.table主生产计划.开始日期Column);
            }
            
            public void Set开始日期Null() {
                this[this.table主生产计划.开始日期Column] = System.Convert.DBNull;
            }
            
            public bool Is结束日期Null() {
                return this.IsNull(this.table主生产计划.结束日期Column);
            }
            
            public void Set结束日期Null() {
                this[this.table主生产计划.结束日期Column] = System.Convert.DBNull;
            }
            
            public bool Is期初库存Null() {
                return this.IsNull(this.table主生产计划.期初库存Column);
            }
            
            public void Set期初库存Null() {
                this[this.table主生产计划.期初库存Column] = System.Convert.DBNull;
            }
            
            public bool Is需求数量Null() {
                return this.IsNull(this.table主生产计划.需求数量Column);
            }
            
            public void Set需求数量Null() {
                this[this.table主生产计划.需求数量Column] = System.Convert.DBNull;
            }
            
            public bool Is生产单数量Null() {
                return this.IsNull(this.table主生产计划.生产单数量Column);
            }
            
            public void Set生产单数量Null() {
                this[this.table主生产计划.生产单数量Column] = System.Convert.DBNull;
            }
            
            public bool Is预计库存Null() {
                return this.IsNull(this.table主生产计划.预计库存Column);
            }
            
            public void Set预计库存Null() {
                this[this.table主生产计划.预计库存Column] = System.Convert.DBNull;
            }
            
            public bool Is记帐人Null() {
                return this.IsNull(this.table主生产计划.记帐人Column);
            }
            
            public void Set记帐人Null() {
                this[this.table主生产计划.记帐人Column] = System.Convert.DBNull;
            }
            
            public bool Is修改日期Null() {
                return this.IsNull(this.table主生产计划.修改日期Column);
            }
            
            public void Set修改日期Null() {
                this[this.table主生产计划.修改日期Column] = System.Convert.DBNull;
            }
            
            public bool Is审核人Null() {
                return this.IsNull(this.table主生产计划.审核人Column);
            }
            
            public void Set审核人Null() {
                this[this.table主生产计划.审核人Column] = System.Convert.DBNull;
            }
            
            public bool Is审核日期Null() {
                return this.IsNull(this.table主生产计划.审核日期Column);
            }
            
            public void Set审核日期Null() {
                this[this.table主生产计划.审核日期Column] = System.Convert.DBNull;
            }
            
            public bool Is备注Null() {
                return this.IsNull(this.table主生产计划.备注Column);
            }
            
            public void Set备注Null() {
                this[this.table主生产计划.备注Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class 主生产计划RowChangeEvent : EventArgs {
            
            private 主生产计划Row eventRow;
            
            private DataRowAction eventAction;
            
            public 主生产计划RowChangeEvent(主生产计划Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public 主生产计划Row Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class mrp物料需求计算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计划投入;
            
            internal mrp物料需求计算DataTable() : 
                    base("mrp物料需求计算") {
                this.InitClass();
            }
            
            internal mrp物料需求计算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计划投入;
                }
            }
            
            public mrp物料需求计算Row this[int index] {
                get {
                    return ((mrp物料需求计算Row)(this.Rows[index]));
                }
            }
            
            public event mrp物料需求计算RowChangeEventHandler mrp物料需求计算RowChanged;
            
            public event mrp物料需求计算RowChangeEventHandler mrp物料需求计算RowChanging;
            
            public event mrp物料需求计算RowChangeEventHandler mrp物料需求计算RowDeleted;
            
            public event mrp物料需求计算RowChangeEventHandler mrp物料需求计算RowDeleting;
            
            public void Addmrp物料需求计算Row(mrp物料需求计算Row row) {
                this.Rows.Add(row);
            }
            
            public mrp物料需求计算Row Addmrp物料需求计算Row(string 物料名称, string 物料编号, int 年份, int 计划期, System.Decimal 期初库存, System.Decimal 毛需求, System.Decimal 预计入库, System.Decimal 预计出库, System.Decimal 预计库存, System.Decimal 净需求, System.Decimal 计划产出, System.Decimal 计划投入) {
                mrp物料需求计算Row rowmrp物料需求计算Row = ((mrp物料需求计算Row)(this.NewRow()));
                rowmrp物料需求计算Row.ItemArray = new object[] {
                        物料名称,
                        物料编号,
                        年份,
                        计划期,
                        期初库存,
                        毛需求,
                        预计入库,
                        预计出库,
                        预计库存,
                        净需求,
                        计划产出,
                        计划投入};
                this.Rows.Add(rowmrp物料需求计算Row);
                return rowmrp物料需求计算Row;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                mrp物料需求计算DataTable cln = ((mrp物料需求计算DataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new mrp物料需求计算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["计划投入"];
            }
            
            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(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(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物料名称.AllowDBNull = false;
                this.column物料编号.AllowDBNull = false;
                this.column年份.AllowDBNull = false;
                this.column计划期.AllowDBNull = false;
            }
            
            public mrp物料需求计算Row Newmrp物料需求计算Row() {
                return ((mrp物料需求计算Row)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new mrp物料需求计算Row(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(mrp物料需求计算Row);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.mrp物料需求计算RowChanged != null)) {
                    this.mrp物料需求计算RowChanged(this, new mrp物料需求计算RowChangeEvent(((mrp物料需求计算Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.mrp物料需求计算RowChanging != null)) {
                    this.mrp物料需求计算RowChanging(this, new mrp物料需求计算RowChangeEvent(((mrp物料需求计算Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.mrp物料需求计算RowDeleted != null)) {
                    this.mrp物料需求计算RowDeleted(this, new mrp物料需求计算RowChangeEvent(((mrp物料需求计算Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.mrp物料需求计算RowDeleting != null)) {
                    this.mrp物料需求计算RowDeleting(this, new mrp物料需求计算RowChangeEvent(((mrp物料需求计算Row)(e.Row)), e.Action));
                }
            }
            
            public void Removemrp物料需求计算Row(mrp物料需求计算Row row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class mrp物料需求计算Row : DataRow {
            
            private mrp物料需求计算DataTable tablemrp物料需求计算;
            
            internal mrp物料需求计算Row(DataRowBuilder rb) : 
                    base(rb) {
                this.tablemrp物料需求计算 = ((mrp物料需求计算DataTable)(this.Table));
            }
            
            public string 物料名称 {
                get {
                    return ((string)(this[this.tablemrp物料需求计算.物料名称Column]));
                }
                set {
                    this[this.tablemrp物料需求计算.物料名称Column] = value;
                }
            }
            
            public string 物料编号 {
                get {
                    return ((string)(this[this.tablemrp物料需求计算.物料编号Column]));
                }
                set {
                    this[this.tablemrp物料需求计算.物料编号Column] = value;
                }
            }
            
            public int 年份 {
                get {
                    return ((int)(this[this.tablemrp物料需求计算.年份Column]));
                }
                set {
                    this[this.tablemrp物料需求计算.年份Column] = value;
                }
            }
            
            public int 计划期 {
                get {
                    return ((int)(this[this.tablemrp物料需求计算.计划期Column]));
                }
                set {
                    this[this.tablemrp物料需求计算.计划期Column] = value;
                }
            }
            
            public System.Decimal 期初库存 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.期初库存Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.期初库存Column] = value;
                }
            }
            
            public System.Decimal 毛需求 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.毛需求Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.毛需求Column] = value;
                }
            }
            
            public System.Decimal 预计入库 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.预计入库Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.预计入库Column] = value;
                }
            }
            
            public System.Decimal 预计出库 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.预计出库Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.预计出库Column] = value;
                }
            }
            
            public System.Decimal 预计库存 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.预计库存Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.预计库存Column] = value;
                }
            }
            
            public System.Decimal 净需求 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.净需求Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.净需求Column] = value;
                }
            }
            
            public System.Decimal 计划产出 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.计划产出Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.计划产出Column] = value;
                }
            }
            
            public System.Decimal 计划投入 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求计算.计划投入Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求计算.计划投入Column] = value;
                }
            }
            
            public bool Is期初库存Null() {
                return this.IsNull(this.tablemrp物料需求计算.期初库存Column);
            }
            
            public void Set期初库存Null() {
                this[this.tablemrp物料需求计算.期初库存Column] = System.Convert.DBNull;
            }
            
            public bool Is毛需求Null() {
                return this.IsNull(this.tablemrp物料需求计算.毛需求Column);
            }
            
            public void Set毛需求Null() {
                this[this.tablemrp物料需求计算.毛需求Column] = System.Convert.DBNull;
            }
            
            public bool Is预计入库Null() {
                return this.IsNull(this.tablemrp物料需求计算.预计入库Column);
            }
            
            public void Set预计入库Null() {
                this[this.tablemrp物料需求计算.预计入库Column] = System.Convert.DBNull;
            }
            
            public bool Is预计出库Null() {
                return this.IsNull(this.tablemrp物料需求计算.预计出库Column);
            }
            
            public void Set预计出库Null() {
                this[this.tablemrp物料需求计算.预计出库Column] = System.Convert.DBNull;
            }
            
            public bool Is预计库存Null() {
                return this.IsNull(this.tablemrp物料需求计算.预计库存Column);
            }
            
            public void Set预计库存Null() {
                this[this.tablemrp物料需求计算.预计库存Column] = System.Convert.DBNull;
            }
            
            public bool Is净需求Null() {
                return this.IsNull(this.tablemrp物料需求计算.净需求Column);
            }
            
            public void Set净需求Null() {
                this[this.tablemrp物料需求计算.净需求Column] = System.Convert.DBNull;
            }
            
            public bool Is计划产出Null() {
                return this.IsNull(this.tablemrp物料需求计算.计划产出Column);
            }
            
            public void Set计划产出Null() {
                this[this.tablemrp物料需求计算.计划产出Column] = System.Convert.DBNull;
            }
            
            public bool Is计划投入Null() {
                return this.IsNull(this.tablemrp物料需求计算.计划投入Column);
            }
            
            public void Set计划投入Null() {
                this[this.tablemrp物料需求计算.计划投入Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class mrp物料需求计算RowChangeEvent : EventArgs {
            
            private mrp物料需求计算Row eventRow;
            
            private DataRowAction eventAction;
            
            public mrp物料需求计算RowChangeEvent(mrp物料需求计算Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public mrp物料需求计算Row Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class mrp物料需求历史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计划投入;
            
            internal mrp物料需求历史DataTable() : 
                    base("mrp物料需求历史") {
                this.InitClass();
            }
            
            internal mrp物料需求历史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计划投入;
                }
            }
            
            public mrp物料需求历史Row this[int index] {
                get {
                    return ((mrp物料需求历史Row)(this.Rows[index]));
                }
            }
            
            public event mrp物料需求历史RowChangeEventHandler mrp物料需求历史RowChanged;
            
            public event mrp物料需求历史RowChangeEventHandler mrp物料需求历史RowChanging;
            
            public event mrp物料需求历史RowChangeEventHandler mrp物料需求历史RowDeleted;
            
            public event mrp物料需求历史RowChangeEventHandler mrp物料需求历史RowDeleting;
            
            public void Addmrp物料需求历史Row(mrp物料需求历史Row row) {
                this.Rows.Add(row);
            }
            
            public mrp物料需求历史Row Addmrp物料需求历史Row(string 物料名称, string 发布编号, System.DateTime 发布时间, string 物料编号, int 年份, int 计划期, System.Decimal 期初库存, System.Decimal 毛需求, System.Decimal 预计入库, string 预计出库, System.Decimal 预计库存, System.Decimal 净需求, System.Decimal 计划产出, System.Decimal 计划投入) {
                mrp物料需求历史Row rowmrp物料需求历史Row = ((mrp物料需求历史Row)(this.NewRow()));
                rowmrp物料需求历史Row.ItemArray = new object[] {
                        物料名称,
                        发布编号,
                        发布时间,
                        物料编号,
                        年份,
                        计划期,
                        期初库存,
                        毛需求,
                        预计入库,
                        预计出库,
                        预计库存,
                        净需求,
                        计划产出,
                        计划投入};
                this.Rows.Add(rowmrp物料需求历史Row);
                return rowmrp物料需求历史Row;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                mrp物料需求历史DataTable cln = ((mrp物料需求历史DataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new mrp物料需求历史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["计划投入"];
            }
            
            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.DateTime), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column发布时间);
                this.column物料编号 = new DataColumn("物料编号", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column物料编号);
                this.column年份 = new DataColumn("年份", typeof(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(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column期初库存);
                this.column毛需求 = new DataColumn("毛需求", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column毛需求);
                this.column预计入库 = new DataColumn("预计入库", typeof(System.Decimal), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column预计入库);
                this.column预计出库 = new DataColumn("预计出库", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column预计出库);
                this.column预计库存 = 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物料名称.AllowDBNull = false;
                this.column物料编号.AllowDBNull = false;
                this.column年份.AllowDBNull = false;
                this.column计划期.AllowDBNull = false;
            }
            
            public mrp物料需求历史Row Newmrp物料需求历史Row() {
                return ((mrp物料需求历史Row)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new mrp物料需求历史Row(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(mrp物料需求历史Row);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.mrp物料需求历史RowChanged != null)) {
                    this.mrp物料需求历史RowChanged(this, new mrp物料需求历史RowChangeEvent(((mrp物料需求历史Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.mrp物料需求历史RowChanging != null)) {
                    this.mrp物料需求历史RowChanging(this, new mrp物料需求历史RowChangeEvent(((mrp物料需求历史Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.mrp物料需求历史RowDeleted != null)) {
                    this.mrp物料需求历史RowDeleted(this, new mrp物料需求历史RowChangeEvent(((mrp物料需求历史Row)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.mrp物料需求历史RowDeleting != null)) {
                    this.mrp物料需求历史RowDeleting(this, new mrp物料需求历史RowChangeEvent(((mrp物料需求历史Row)(e.Row)), e.Action));
                }
            }
            
            public void Removemrp物料需求历史Row(mrp物料需求历史Row row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class mrp物料需求历史Row : DataRow {
            
            private mrp物料需求历史DataTable tablemrp物料需求历史;
            
            internal mrp物料需求历史Row(DataRowBuilder rb) : 
                    base(rb) {
                this.tablemrp物料需求历史 = ((mrp物料需求历史DataTable)(this.Table));
            }
            
            public string 物料名称 {
                get {
                    return ((string)(this[this.tablemrp物料需求历史.物料名称Column]));
                }
                set {
                    this[this.tablemrp物料需求历史.物料名称Column] = value;
                }
            }
            
            public string 发布编号 {
                get {
                    try {
                        return ((string)(this[this.tablemrp物料需求历史.发布编号Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.发布编号Column] = value;
                }
            }
            
            public System.DateTime 发布时间 {
                get {
                    try {
                        return ((System.DateTime)(this[this.tablemrp物料需求历史.发布时间Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.发布时间Column] = value;
                }
            }
            
            public string 物料编号 {
                get {
                    return ((string)(this[this.tablemrp物料需求历史.物料编号Column]));
                }
                set {
                    this[this.tablemrp物料需求历史.物料编号Column] = value;
                }
            }
            
            public int 年份 {
                get {
                    return ((int)(this[this.tablemrp物料需求历史.年份Column]));
                }
                set {
                    this[this.tablemrp物料需求历史.年份Column] = value;
                }
            }
            
            public int 计划期 {
                get {
                    return ((int)(this[this.tablemrp物料需求历史.计划期Column]));
                }
                set {
                    this[this.tablemrp物料需求历史.计划期Column] = value;
                }
            }
            
            public System.Decimal 期初库存 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.期初库存Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.期初库存Column] = value;
                }
            }
            
            public System.Decimal 毛需求 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.毛需求Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.毛需求Column] = value;
                }
            }
            
            public System.Decimal 预计入库 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.预计入库Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.预计入库Column] = value;
                }
            }
            
            public string 预计出库 {
                get {
                    try {
                        return ((string)(this[this.tablemrp物料需求历史.预计出库Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.预计出库Column] = value;
                }
            }
            
            public System.Decimal 预计库存 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.预计库存Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.预计库存Column] = value;
                }
            }
            
            public System.Decimal 净需求 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.净需求Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.净需求Column] = value;
                }
            }
            
            public System.Decimal 计划产出 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.计划产出Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.计划产出Column] = value;
                }
            }
            
            public System.Decimal 计划投入 {
                get {
                    try {
                        return ((System.Decimal)(this[this.tablemrp物料需求历史.计划投入Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tablemrp物料需求历史.计划投入Column] = value;
                }
            }
            
            public bool Is发布编号Null() {
                return this.IsNull(this.tablemrp物料需求历史.发布编号Column);
            }
            
            public void Set发布编号Null() {
                this[this.tablemrp物料需求历史.发布编号Column] = System.Convert.DBNull;
            }
            
            public bool Is发布时间Null() {
                return this.IsNull(this.tablemrp物料需求历史.发布时间Column);
            }
            
            public void Set发布时间Null() {
                this[this.tablemrp物料需求历史.发布时间Column] = System.Convert.DBNull;
            }
            
            public bool Is期初库存Null() {
                return this.IsNull(this.tablemrp物料需求历史.期初库存Column);
            }
            
            public void Set期初库存Null() {
                this[this.tablemrp物料需求历史.期初库存Column] = System.Convert.DBNull;
            }
            
            public bool Is毛需求Null() {
                return this.IsNull(this.tablemrp物料需求历史.毛需求Column);
            }
            
            public void Set毛需求Null() {
                this[this.tablemrp物料需求历史.毛需求Column] = System.Convert.DBNull;
            }
            
            public bool Is预计入库Null() {
                return this.IsNull(this.tablemrp物料需求历史.预计入库Column);
            }
            
            public void Set预计入库Null() {
                this[this.tablemrp物料需求历史.预计入库Column] = System.Convert.DBNull;
            }
            
            public bool Is预计出库Null() {
                return this.IsNull(this.tablemrp物料需求历史.预计出库Column);
            }
            
            public void Set预计出库Null() {
                this[this.tablemrp物料需求历史.预计出库Column] = System.Convert.DBNull;
            }
            
            public bool Is预计库存Null() {
                return this.IsNull(this.tablemrp物料需求历史.预计库存Column);
            }
            
            public void Set预计库存Null() {
                this[this.tablemrp物料需求历史.预计库存Column] = System.Convert.DBNull;
            }
            
            public bool Is净需求Null() {
                return this.IsNull(this.tablemrp物料需求历史.净需求Column);
            }
            
            public void Set净需求Null() {
                this[this.tablemrp物料需求历史.净需求Column] = System.Convert.DBNull;
            }
            
            public bool Is计划产出Null() {
                return this.IsNull(this.tablemrp物料需求历史.计划产出Column);
            }
            
            public void Set计划产出Null() {
                this[this.tablemrp物料需求历史.计划产出Column] = System.Convert.DBNull;
            }
            
            public bool Is计划投入Null() {
                return this.IsNull(this.tablemrp物料需求历史.计划投入Column);
            }
            
            public void Set计划投入Null() {
                this[this.tablemrp物料需求历史.计划投入Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class mrp物料需求历史RowChangeEvent : EventArgs {
            
            private mrp物料需求历史Row eventRow;
            
            private DataRowAction eventAction;
            
            public mrp物料需求历史RowChangeEvent(mrp物料需求历史Row row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public mrp物料需求历史Row Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}

						