企业管理

开发平台：

C#

DataSet11.cs：源码内容

}
internal DataColumn 类型Column {
get {
return this.column类型;
}
}
internal DataColumn 作者Column {
get {
return this.column作者;
}
}
internal DataColumn 译者Column {
get {
return this.column译者;
}
}
internal DataColumn ISBNColumn {
get {
return this.columnISBN;
}
}
internal DataColumn 出版社Column {
get {
return this.column出版社;
}
}
internal DataColumn 价格Column {
get {
return this.column价格;
}
}
internal DataColumn 页码Column {
get {
return this.column页码;
}
}
internal DataColumn 书架名称Column {
get {
return this.column书架名称;
}
}
internal DataColumn 现存量Column {
get {
return this.column现存量;
}
}
internal DataColumn 库存总量Column {
get {
return this.column库存总量;
}
}
internal DataColumn 入库时间Column {
get {
return this.column入库时间;
}
}
internal DataColumn 操作员Column {
get {
return this.column操作员;
}
}
internal DataColumn 简介Column {
get {
return this.column简介;
}
}
internal DataColumn 借出次数Column {
get {
return this.column借出次数;
}
}
internal DataColumn 是否注销Column {
get {
return this.column是否注销;
}
}
public 图书信息Row this[int index] {
get {
return ((图书信息Row)(this.Rows[index]));
}
}
public event 图书信息RowChangeEventHandler 图书信息RowChanged;
public event 图书信息RowChangeEventHandler 图书信息RowChanging;
public event 图书信息RowChangeEventHandler 图书信息RowDeleted;
public event 图书信息RowChangeEventHandler 图书信息RowDeleting;
public void Add图书信息Row(图书信息Row row) {
this.Rows.Add(row);
}
public 图书信息Row Add图书信息Row(
string 条形码,
string 编号,
string 书名,
string 类型,
string 作者,
string 译者,
string ISBN,
string 出版社,
System.Decimal 价格,
int 页码,
string 书架名称,
int 现存量,
int 库存总量,
System.DateTime 入库时间,
string 操作员,
string 简介,
int 借出次数,
bool 是否注销) {
图书信息Row row图书信息Row = ((图书信息Row)(this.NewRow()));
row图书信息Row.ItemArray = new object[] {
条形码,
编号,
书名,
类型,
作者,
译者,
ISBN,
出版社,
价格,
页码,
书架名称,
现存量,
库存总量,
入库时间,
操作员,
简介,
借出次数,
是否注销};
this.Rows.Add(row图书信息Row);
return row图书信息Row;
}
public 图书信息Row FindBy编号(string 编号) {
return ((图书信息Row)(this.Rows.Find(new object[] {
编号})));
}
public System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
public override DataTable Clone() {
图书信息DataTable cln = ((图书信息DataTable)(base.Clone()));
cln.InitVars();
return cln;
}
protected override DataTable CreateInstance() {
return new 图书信息DataTable();
}
internal void InitVars() {
this.column条形码 = this.Columns["条形码"];
this.column编号 = this.Columns["编号"];
this.column书名 = this.Columns["书名"];
this.column类型 = this.Columns["类型"];
this.column作者 = this.Columns["作者"];
this.column译者 = this.Columns["译者"];
this.columnISBN = this.Columns["ISBN"];
this.column出版社 = this.Columns["出版社"];
this.column价格 = this.Columns["价格"];
this.column页码 = this.Columns["页码"];
this.column书架名称 = this.Columns["书架名称"];
this.column现存量 = this.Columns["现存量"];
this.column库存总量 = this.Columns["库存总量"];
this.column入库时间 = this.Columns["入库时间"];
this.column操作员 = this.Columns["操作员"];
this.column简介 = this.Columns["简介"];
this.column借出次数 = this.Columns["借出次数"];
this.column是否注销 = this.Columns["是否注销"];
}
private void InitClass() {
this.column条形码 = new DataColumn("条形码", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column条形码);
this.column编号 = new DataColumn("编号", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column编号);
this.column书名 = new DataColumn("书名", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column书名);
this.column类型 = new DataColumn("类型", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column类型);
this.column作者 = new DataColumn("作者", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column作者);
this.column译者 = new DataColumn("译者", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column译者);
this.columnISBN = new DataColumn("ISBN", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.columnISBN);
this.column出版社 = new DataColumn("出版社", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column出版社);
this.column价格 = new DataColumn("价格", typeof(System.Decimal), null, System.Data.MappingType.Element);
this.Columns.Add(this.column价格);
this.column页码 = new DataColumn("页码", typeof(int), null, System.Data.MappingType.Element);
this.Columns.Add(this.column页码);
this.column书架名称 = new DataColumn("书架名称", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column书架名称);
this.column现存量 = new DataColumn("现存量", typeof(int), null, System.Data.MappingType.Element);
this.Columns.Add(this.column现存量);
this.column库存总量 = new DataColumn("库存总量", typeof(int), null, System.Data.MappingType.Element);
this.Columns.Add(this.column库存总量);
this.column入库时间 = new DataColumn("入库时间", typeof(System.DateTime), null, System.Data.MappingType.Element);
this.Columns.Add(this.column入库时间);
this.column操作员 = new DataColumn("操作员", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column操作员);
this.column简介 = new DataColumn("简介", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column简介);
this.column借出次数 = new DataColumn("借出次数", typeof(int), null, System.Data.MappingType.Element);
this.Columns.Add(this.column借出次数);
this.column是否注销 = new DataColumn("是否注销", typeof(bool), null, System.Data.MappingType.Element);
this.Columns.Add(this.column是否注销);
this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
this.column编号}, true));
this.column编号.AllowDBNull = false;
this.column编号.Unique = true;
this.column是否注销.AllowDBNull = false;
this.column是否注销.DefaultValue = false;
}
public 图书信息Row New图书信息Row() {
return ((图书信息Row)(this.NewRow()));
}
protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
return new 图书信息Row(builder);
}
protected override System.Type GetRowType() {
return typeof(图书信息Row);
}
protected override void OnRowChanged(DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.图书信息RowChanged != null)) {
this.图书信息RowChanged(this, new 图书信息RowChangeEvent(((图书信息Row)(e.Row)), e.Action));
}
}
protected override void OnRowChanging(DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.图书信息RowChanging != null)) {
this.图书信息RowChanging(this, new 图书信息RowChangeEvent(((图书信息Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleted(DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.图书信息RowDeleted != null)) {
this.图书信息RowDeleted(this, new 图书信息RowChangeEvent(((图书信息Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleting(DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.图书信息RowDeleting != null)) {
this.图书信息RowDeleting(this, new 图书信息RowChangeEvent(((图书信息Row)(e.Row)), e.Action));
}
}
public void Remove图书信息Row(图书信息Row row) {
this.Rows.Remove(row);
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书信息Row : DataRow {
private 图书信息DataTable table图书信息;
internal 图书信息Row(DataRowBuilder rb) :
base(rb) {
this.table图书信息 = ((图书信息DataTable)(this.Table));
}
public string 条形码 {
get {
try {
return ((string)(this[this.table图书信息.条形码Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.条形码Column] = value;
}
}
public string 编号 {
get {
return ((string)(this[this.table图书信息.编号Column]));
}
set {
this[this.table图书信息.编号Column] = value;
}
}
public string 书名 {
get {
try {
return ((string)(this[this.table图书信息.书名Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.书名Column] = value;
}
}
public string 类型 {
get {
try {
return ((string)(this[this.table图书信息.类型Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.类型Column] = value;
}
}
public string 作者 {
get {
try {
return ((string)(this[this.table图书信息.作者Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.作者Column] = value;
}
}
public string 译者 {
get {
try {
return ((string)(this[this.table图书信息.译者Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.译者Column] = value;
}
}
public string ISBN {
get {
try {
return ((string)(this[this.table图书信息.ISBNColumn]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.ISBNColumn] = value;
}
}
public string 出版社 {
get {
try {
return ((string)(this[this.table图书信息.出版社Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.出版社Column] = value;
}
}
public System.Decimal 价格 {
get {
try {
return ((System.Decimal)(this[this.table图书信息.价格Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.价格Column] = value;
}
}
public int 页码 {
get {
try {
return ((int)(this[this.table图书信息.页码Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.页码Column] = value;
}
}
public string 书架名称 {
get {
try {
return ((string)(this[this.table图书信息.书架名称Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.书架名称Column] = value;
}
}
public int 现存量 {
get {
try {
return ((int)(this[this.table图书信息.现存量Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.现存量Column] = value;
}
}
public int 库存总量 {
get {
try {
return ((int)(this[this.table图书信息.库存总量Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.库存总量Column] = value;
}
}
public System.DateTime 入库时间 {
get {
try {
return ((System.DateTime)(this[this.table图书信息.入库时间Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.入库时间Column] = value;
}
}
public string 操作员 {
get {
try {
return ((string)(this[this.table图书信息.操作员Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书信息.操作员Column] = value;
}
}
public 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 是否注销 {
get {
return ((bool)(this[this.table图书信息.是否注销Column]));
}
set {
this[this.table图书信息.是否注销Column] = value;
}
}
public bool Is条形码Null() {
return this.IsNull(this.table图书信息.条形码Column);
}
public void Set条形码Null() {
this[this.table图书信息.条形码Column] = System.Convert.DBNull;
}
public bool Is书名Null() {
return this.IsNull(this.table图书信息.书名Column);
}
public void Set书名Null() {
this[this.table图书信息.书名Column] = System.Convert.DBNull;
}
public bool Is类型Null() {
return this.IsNull(this.table图书信息.类型Column);
}
public void Set类型Null() {
this[this.table图书信息.类型Column] = System.Convert.DBNull;
}
public bool Is作者Null() {
return this.IsNull(this.table图书信息.作者Column);
}
public void Set作者Null() {
this[this.table图书信息.作者Column] = System.Convert.DBNull;
}
public bool Is译者Null() {
return this.IsNull(this.table图书信息.译者Column);
}
public void Set译者Null() {
this[this.table图书信息.译者Column] = System.Convert.DBNull;
}
public bool IsISBNNull() {
return this.IsNull(this.table图书信息.ISBNColumn);
}
public void SetISBNNull() {
this[this.table图书信息.ISBNColumn] = System.Convert.DBNull;
}
public bool Is出版社Null() {
return this.IsNull(this.table图书信息.出版社Column);
}
public void Set出版社Null() {
this[this.table图书信息.出版社Column] = System.Convert.DBNull;
}
public bool Is价格Null() {
return this.IsNull(this.table图书信息.价格Column);
}
public void Set价格Null() {
this[this.table图书信息.价格Column] = System.Convert.DBNull;
}
public bool Is页码Null() {
return this.IsNull(this.table图书信息.页码Column);
}
public void Set页码Null() {
this[this.table图书信息.页码Column] = System.Convert.DBNull;
}
public bool Is书架名称Null() {
return this.IsNull(this.table图书信息.书架名称Column);
}
public void Set书架名称Null() {
this[this.table图书信息.书架名称Column] = System.Convert.DBNull;
}
public bool Is现存量Null() {
return this.IsNull(this.table图书信息.现存量Column);
}
public void Set现存量Null() {
this[this.table图书信息.现存量Column] = System.Convert.DBNull;
}
public bool Is库存总量Null() {
return this.IsNull(this.table图书信息.库存总量Column);
}
public void Set库存总量Null() {
this[this.table图书信息.库存总量Column] = System.Convert.DBNull;
}
public bool Is入库时间Null() {
return this.IsNull(this.table图书信息.入库时间Column);
}
public void Set入库时间Null() {
this[this.table图书信息.入库时间Column] = System.Convert.DBNull;
}
public bool Is操作员Null() {
return this.IsNull(this.table图书信息.操作员Column);
}
public void Set操作员Null() {
this[this.table图书信息.操作员Column] = System.Convert.DBNull;
}
public bool Is简介Null() {
return this.IsNull(this.table图书信息.简介Column);
}
public void Set简介Null() {
this[this.table图书信息.简介Column] = System.Convert.DBNull;
}
public bool Is借出次数Null() {
return this.IsNull(this.table图书信息.借出次数Column);
}
public void Set借出次数Null() {
this[this.table图书信息.借出次数Column] = System.Convert.DBNull;
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书信息RowChangeEvent : EventArgs {
private 图书信息Row eventRow;
private DataRowAction eventAction;
public 图书信息RowChangeEvent(图书信息Row row, DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
public 图书信息Row Row {
get {
return this.eventRow;
}
}
public DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书征订DataTable : DataTable, System.Collections.IEnumerable {
private DataColumn column征订编号;
private DataColumn column图书编号;
private DataColumn column订购者;
private DataColumn column订购者联系方式;
private DataColumn column订购数量;
private DataColumn column订购单价;
private DataColumn column订购日期;
private DataColumn column是否验收;
private DataColumn column验收日期;
private DataColumn column操作员;
internal 图书征订DataTable() :
base("图书征订") {
this.InitClass();
}
internal 图书征订DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 征订编号Column {
get {
return this.column征订编号;
}
}
internal DataColumn 图书编号Column {
get {
return this.column图书编号;
}
}
internal DataColumn 订购者Column {
get {
return this.column订购者;
}
}
internal DataColumn 订购者联系方式Column {
get {
return this.column订购者联系方式;
}
}
internal DataColumn 订购数量Column {
get {
return this.column订购数量;
}
}
internal DataColumn 订购单价Column {
get {
return this.column订购单价;
}
}
internal DataColumn 订购日期Column {
get {
return this.column订购日期;
}
}
internal DataColumn 是否验收Column {
get {
return this.column是否验收;
}
}
internal DataColumn 验收日期Column {
get {
return this.column验收日期;
}
}
internal DataColumn 操作员Column {
get {
return this.column操作员;
}
}
public 图书征订Row this[int index] {
get {
return ((图书征订Row)(this.Rows[index]));
}
}
public event 图书征订RowChangeEventHandler 图书征订RowChanged;
public event 图书征订RowChangeEventHandler 图书征订RowChanging;
public event 图书征订RowChangeEventHandler 图书征订RowDeleted;
public event 图书征订RowChangeEventHandler 图书征订RowDeleting;
public void Add图书征订Row(图书征订Row row) {
this.Rows.Add(row);
}
public 图书征订Row Add图书征订Row(string 征订编号, string 图书编号, string 订购者, string 订购者联系方式, int 订购数量, System.Decimal 订购单价, System.DateTime 订购日期, bool 是否验收, System.DateTime 验收日期, string 操作员) {
图书征订Row row图书征订Row = ((图书征订Row)(this.NewRow()));
row图书征订Row.ItemArray = new object[] {
征订编号,
图书编号,
订购者,
订购者联系方式,
订购数量,
订购单价,
订购日期,
是否验收,
验收日期,
操作员};
this.Rows.Add(row图书征订Row);
return row图书征订Row;
}
public 图书征订Row FindBy征订编号(string 征订编号) {
return ((图书征订Row)(this.Rows.Find(new object[] {
征订编号})));
}
public System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
public override DataTable Clone() {
图书征订DataTable cln = ((图书征订DataTable)(base.Clone()));
cln.InitVars();
return cln;
}
protected override DataTable CreateInstance() {
return new 图书征订DataTable();
}
internal void InitVars() {
this.column征订编号 = this.Columns["征订编号"];
this.column图书编号 = this.Columns["图书编号"];
this.column订购者 = this.Columns["订购者"];
this.column订购者联系方式 = this.Columns["订购者联系方式"];
this.column订购数量 = this.Columns["订购数量"];
this.column订购单价 = this.Columns["订购单价"];
this.column订购日期 = this.Columns["订购日期"];
this.column是否验收 = this.Columns["是否验收"];
this.column验收日期 = this.Columns["验收日期"];
this.column操作员 = this.Columns["操作员"];
}
private void InitClass() {
this.column征订编号 = new DataColumn("征订编号", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column征订编号);
this.column图书编号 = new DataColumn("图书编号", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column图书编号);
this.column订购者 = new DataColumn("订购者", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column订购者);
this.column订购者联系方式 = new DataColumn("订购者联系方式", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column订购者联系方式);
this.column订购数量 = new DataColumn("订购数量", typeof(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.DateTime), null, System.Data.MappingType.Element);
this.Columns.Add(this.column订购日期);
this.column是否验收 = new DataColumn("是否验收", typeof(bool), null, System.Data.MappingType.Element);
this.Columns.Add(this.column是否验收);
this.column验收日期 = new DataColumn("验收日期", typeof(System.DateTime), null, System.Data.MappingType.Element);
this.Columns.Add(this.column验收日期);
this.column操作员 = new DataColumn("操作员", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column操作员);
this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
this.column征订编号}, true));
this.column征订编号.AllowDBNull = false;
this.column征订编号.Unique = true;
this.column图书编号.AllowDBNull = false;
this.column是否验收.DefaultValue = 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 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 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.DateTime 订购日期 {
get {
try {
return ((System.DateTime)(this[this.table图书征订.订购日期Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书征订.订购日期Column] = value;
}
}
public bool 是否验收 {
get {
try {
return ((bool)(this[this.table图书征订.是否验收Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书征订.是否验收Column] = value;
}
}
public System.DateTime 验收日期 {
get {
try {
return ((System.DateTime)(this[this.table图书征订.验收日期Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书征订.验收日期Column] = value;
}
}
public string 操作员 {
get {
try {
return ((string)(this[this.table图书征订.操作员Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书征订.操作员Column] = value;
}
}
public bool Is订购者Null() {
return this.IsNull(this.table图书征订.订购者Column);
}
public void Set订购者Null() {
this[this.table图书征订.订购者Column] = System.Convert.DBNull;
}
public bool Is订购者联系方式Null() {
return this.IsNull(this.table图书征订.订购者联系方式Column);
}
public void Set订购者联系方式Null() {
this[this.table图书征订.订购者联系方式Column] = System.Convert.DBNull;
}
public bool Is订购数量Null() {
return this.IsNull(this.table图书征订.订购数量Column);
}
public void Set订购数量Null() {
this[this.table图书征订.订购数量Column] = System.Convert.DBNull;
}
public bool Is订购单价Null() {
return this.IsNull(this.table图书征订.订购单价Column);
}
public void Set订购单价Null() {
this[this.table图书征订.订购单价Column] = System.Convert.DBNull;
}
public bool Is订购日期Null() {
return this.IsNull(this.table图书征订.订购日期Column);
}
public void Set订购日期Null() {
this[this.table图书征订.订购日期Column] = System.Convert.DBNull;
}
public bool Is是否验收Null() {
return this.IsNull(this.table图书征订.是否验收Column);
}
public void Set是否验收Null() {
this[this.table图书征订.是否验收Column] = System.Convert.DBNull;
}
public bool Is验收日期Null() {
return this.IsNull(this.table图书征订.验收日期Column);
}
public void Set验收日期Null() {
this[this.table图书征订.验收日期Column] = System.Convert.DBNull;
}
public bool Is操作员Null() {
return this.IsNull(this.table图书征订.操作员Column);
}
public void Set操作员Null() {
this[this.table图书征订.操作员Column] = System.Convert.DBNull;
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书征订RowChangeEvent : EventArgs {
private 图书征订Row eventRow;
private DataRowAction eventAction;
public 图书征订RowChangeEvent(图书征订Row row, DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
public 图书征订Row Row {
get {
return this.eventRow;
}
}
public DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书借阅DataTable : DataTable, System.Collections.IEnumerable {
private DataColumn column借阅编号;
private DataColumn column姓名;
private DataColumn column读者编号;
private DataColumn column图书编号;
private DataColumn column书名;
private DataColumn column借阅时间;
private DataColumn column应还时间;
private DataColumn column续借次数;
private DataColumn column操作员;
private DataColumn column状态;
internal 图书借阅DataTable() :
base("图书借阅") {
this.InitClass();
}
internal 图书借阅DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 借阅编号Column {
get {
return this.column借阅编号;
}
}
internal DataColumn 姓名Column {
get {
return this.column姓名;
}
}
internal DataColumn 读者编号Column {
get {
return this.column读者编号;
}
}
internal DataColumn 图书编号Column {
get {
return this.column图书编号;
}
}
internal DataColumn 书名Column {
get {
return this.column书名;
}
}
internal DataColumn 借阅时间Column {
get {
return this.column借阅时间;
}
}
internal DataColumn 应还时间Column {
get {
return this.column应还时间;
}
}
internal DataColumn 续借次数Column {
get {
return this.column续借次数;
}
}
internal DataColumn 操作员Column {
get {
return this.column操作员;
}
}
internal DataColumn 状态Column {
get {
return this.column状态;
}
}
public 图书借阅Row this[int index] {
get {
return ((图书借阅Row)(this.Rows[index]));
}
}
public event 图书借阅RowChangeEventHandler 图书借阅RowChanged;
public event 图书借阅RowChangeEventHandler 图书借阅RowChanging;
public event 图书借阅RowChangeEventHandler 图书借阅RowDeleted;
public event 图书借阅RowChangeEventHandler 图书借阅RowDeleting;
public void Add图书借阅Row(图书借阅Row row) {
this.Rows.Add(row);
}
public 图书借阅Row Add图书借阅Row(string 姓名, string 读者编号, string 图书编号, string 书名, System.DateTime 借阅时间, System.DateTime 应还时间, int 续借次数, string 操作员, string 状态) {
图书借阅Row row图书借阅Row = ((图书借阅Row)(this.NewRow()));
row图书借阅Row.ItemArray = new object[] {
null,
姓名,
读者编号,
图书编号,
书名,
借阅时间,
应还时间,
续借次数,
操作员,
状态};
this.Rows.Add(row图书借阅Row);
return row图书借阅Row;
}
public System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
public override DataTable Clone() {
图书借阅DataTable cln = ((图书借阅DataTable)(base.Clone()));
cln.InitVars();
return cln;
}
protected override DataTable CreateInstance() {
return new 图书借阅DataTable();
}
internal void InitVars() {
this.column借阅编号 = this.Columns["借阅编号"];
this.column姓名 = this.Columns["姓名"];
this.column读者编号 = this.Columns["读者编号"];
this.column图书编号 = this.Columns["图书编号"];
this.column书名 = this.Columns["书名"];
this.column借阅时间 = this.Columns["借阅时间"];
this.column应还时间 = this.Columns["应还时间"];
this.column续借次数 = this.Columns["续借次数"];
this.column操作员 = this.Columns["操作员"];
this.column状态 = this.Columns["状态"];
}
private void InitClass() {
this.column借阅编号 = new DataColumn("借阅编号", typeof(int), null, System.Data.MappingType.Element);
this.Columns.Add(this.column借阅编号);
this.column姓名 = new DataColumn("姓名", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column姓名);
this.column读者编号 = new DataColumn("读者编号", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column读者编号);
this.column图书编号 = new DataColumn("图书编号", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column图书编号);
this.column书名 = new DataColumn("书名", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column书名);
this.column借阅时间 = new DataColumn("借阅时间", typeof(System.DateTime), null, System.Data.MappingType.Element);
this.Columns.Add(this.column借阅时间);
this.column应还时间 = new DataColumn("应还时间", typeof(System.DateTime), null, System.Data.MappingType.Element);
this.Columns.Add(this.column应还时间);
this.column续借次数 = new DataColumn("续借次数", typeof(int), null, System.Data.MappingType.Element);
this.Columns.Add(this.column续借次数);
this.column操作员 = new DataColumn("操作员", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column操作员);
this.column状态 = new DataColumn("状态", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column状态);
this.column借阅编号.AutoIncrement = true;
this.column借阅编号.AllowDBNull = false;
this.column借阅编号.ReadOnly = true;
}
public 图书借阅Row New图书借阅Row() {
return ((图书借阅Row)(this.NewRow()));
}
protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
return new 图书借阅Row(builder);
}
protected override System.Type GetRowType() {
return typeof(图书借阅Row);
}
protected override void OnRowChanged(DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.图书借阅RowChanged != null)) {
this.图书借阅RowChanged(this, new 图书借阅RowChangeEvent(((图书借阅Row)(e.Row)), e.Action));
}
}
protected override void OnRowChanging(DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.图书借阅RowChanging != null)) {
this.图书借阅RowChanging(this, new 图书借阅RowChangeEvent(((图书借阅Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleted(DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.图书借阅RowDeleted != null)) {
this.图书借阅RowDeleted(this, new 图书借阅RowChangeEvent(((图书借阅Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleting(DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.图书借阅RowDeleting != null)) {
this.图书借阅RowDeleting(this, new 图书借阅RowChangeEvent(((图书借阅Row)(e.Row)), e.Action));
}
}
public void Remove图书借阅Row(图书借阅Row row) {
this.Rows.Remove(row);
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书借阅Row : DataRow {
private 图书借阅DataTable table图书借阅;
internal 图书借阅Row(DataRowBuilder rb) :
base(rb) {
this.table图书借阅 = ((图书借阅DataTable)(this.Table));
}
public int 借阅编号 {
get {
return ((int)(this[this.table图书借阅.借阅编号Column]));
}
set {
this[this.table图书借阅.借阅编号Column] = value;
}
}
public string 姓名 {
get {
try {
return ((string)(this[this.table图书借阅.姓名Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.姓名Column] = value;
}
}
public string 读者编号 {
get {
try {
return ((string)(this[this.table图书借阅.读者编号Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.读者编号Column] = value;
}
}
public string 图书编号 {
get {
try {
return ((string)(this[this.table图书借阅.图书编号Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.图书编号Column] = value;
}
}
public string 书名 {
get {
try {
return ((string)(this[this.table图书借阅.书名Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.书名Column] = value;
}
}
public System.DateTime 借阅时间 {
get {
try {
return ((System.DateTime)(this[this.table图书借阅.借阅时间Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.借阅时间Column] = value;
}
}
public System.DateTime 应还时间 {
get {
try {
return ((System.DateTime)(this[this.table图书借阅.应还时间Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.应还时间Column] = value;
}
}
public int 续借次数 {
get {
try {
return ((int)(this[this.table图书借阅.续借次数Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.续借次数Column] = value;
}
}
public string 操作员 {
get {
try {
return ((string)(this[this.table图书借阅.操作员Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.操作员Column] = value;
}
}
public string 状态 {
get {
try {
return ((string)(this[this.table图书借阅.状态Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书借阅.状态Column] = value;
}
}
public bool Is姓名Null() {
return this.IsNull(this.table图书借阅.姓名Column);
}
public void Set姓名Null() {
this[this.table图书借阅.姓名Column] = System.Convert.DBNull;
}
public bool Is读者编号Null() {
return this.IsNull(this.table图书借阅.读者编号Column);
}
public void Set读者编号Null() {
this[this.table图书借阅.读者编号Column] = System.Convert.DBNull;
}
public bool Is图书编号Null() {
return this.IsNull(this.table图书借阅.图书编号Column);
}
public void Set图书编号Null() {
this[this.table图书借阅.图书编号Column] = System.Convert.DBNull;
}
public bool Is书名Null() {
return this.IsNull(this.table图书借阅.书名Column);
}
public void Set书名Null() {
this[this.table图书借阅.书名Column] = System.Convert.DBNull;
}
public bool Is借阅时间Null() {
return this.IsNull(this.table图书借阅.借阅时间Column);
}
public void Set借阅时间Null() {
this[this.table图书借阅.借阅时间Column] = System.Convert.DBNull;
}
public bool Is应还时间Null() {
return this.IsNull(this.table图书借阅.应还时间Column);
}
public void Set应还时间Null() {
this[this.table图书借阅.应还时间Column] = System.Convert.DBNull;
}
public bool Is续借次数Null() {
return this.IsNull(this.table图书借阅.续借次数Column);
}
public void Set续借次数Null() {
this[this.table图书借阅.续借次数Column] = System.Convert.DBNull;
}
public bool Is操作员Null() {
return this.IsNull(this.table图书借阅.操作员Column);
}
public void Set操作员Null() {
this[this.table图书借阅.操作员Column] = System.Convert.DBNull;
}
public bool Is状态Null() {
return this.IsNull(this.table图书借阅.状态Column);
}
public void Set状态Null() {
this[this.table图书借阅.状态Column] = System.Convert.DBNull;
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书借阅RowChangeEvent : EventArgs {
private 图书借阅Row eventRow;
private DataRowAction eventAction;
public 图书借阅RowChangeEvent(图书借阅Row row, DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
public 图书借阅Row Row {
get {
return this.eventRow;
}
}
public DataRowAction Action {
get {
return this.eventAction;
}
}
}
}
}