企业管理

开发平台：

C#

DataSet11.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 DataSet1 : DataSet {
private 读者信息DataTable table读者信息;
private 图书类型DataTable table图书类型;
private 读者类型DataTable table读者类型;
private 图书信息DataTable table图书信息;
private 图书征订DataTable table图书征订;
private 图书借阅DataTable table图书借阅;
public DataSet1() {
this.InitClass();
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
this.Tables.CollectionChanged += schemaChangedHandler;
this.Relations.CollectionChanged += schemaChangedHandler;
}
protected DataSet1(SerializationInfo info, StreamingContext context) {
string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
if ((strSchema != null)) {
DataSet ds = new DataSet();
ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
if ((ds.Tables["读者信息"] != null)) {
this.Tables.Add(new 读者信息DataTable(ds.Tables["读者信息"]));
}
if ((ds.Tables["图书类型"] != null)) {
this.Tables.Add(new 图书类型DataTable(ds.Tables["图书类型"]));
}
if ((ds.Tables["读者类型"] != null)) {
this.Tables.Add(new 读者类型DataTable(ds.Tables["读者类型"]));
}
if ((ds.Tables["图书信息"] != null)) {
this.Tables.Add(new 图书信息DataTable(ds.Tables["图书信息"]));
}
if ((ds.Tables["图书征订"] != null)) {
this.Tables.Add(new 图书征订DataTable(ds.Tables["图书征订"]));
}
if ((ds.Tables["图书借阅"] != null)) {
this.Tables.Add(new 图书借阅DataTable(ds.Tables["图书借阅"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
else {
this.InitClass();
}
this.GetSerializationData(info, context);
System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
this.Tables.CollectionChanged += schemaChangedHandler;
this.Relations.CollectionChanged += schemaChangedHandler;
}
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
public 读者信息DataTable 读者信息 {
get {
return this.table读者信息;
}
}
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
public 图书类型DataTable 图书类型 {
get {
return this.table图书类型;
}
}
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
public 读者类型DataTable 读者类型 {
get {
return this.table读者类型;
}
}
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
public 图书信息DataTable 图书信息 {
get {
return this.table图书信息;
}
}
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
public 图书征订DataTable 图书征订 {
get {
return this.table图书征订;
}
}
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
public 图书借阅DataTable 图书借阅 {
get {
return this.table图书借阅;
}
}
public override DataSet Clone() {
DataSet1 cln = ((DataSet1)(base.Clone()));
cln.InitVars();
return cln;
}
protected override bool ShouldSerializeTables() {
return false;
}
protected override bool ShouldSerializeRelations() {
return false;
}
protected override void ReadXmlSerializable(XmlReader reader) {
this.Reset();
DataSet ds = new DataSet();
ds.ReadXml(reader);
if ((ds.Tables["读者信息"] != null)) {
this.Tables.Add(new 读者信息DataTable(ds.Tables["读者信息"]));
}
if ((ds.Tables["图书类型"] != null)) {
this.Tables.Add(new 图书类型DataTable(ds.Tables["图书类型"]));
}
if ((ds.Tables["读者类型"] != null)) {
this.Tables.Add(new 读者类型DataTable(ds.Tables["读者类型"]));
}
if ((ds.Tables["图书信息"] != null)) {
this.Tables.Add(new 图书信息DataTable(ds.Tables["图书信息"]));
}
if ((ds.Tables["图书征订"] != null)) {
this.Tables.Add(new 图书征订DataTable(ds.Tables["图书征订"]));
}
if ((ds.Tables["图书借阅"] != null)) {
this.Tables.Add(new 图书借阅DataTable(ds.Tables["图书借阅"]));
}
this.DataSetName = ds.DataSetName;
this.Prefix = ds.Prefix;
this.Namespace = ds.Namespace;
this.Locale = ds.Locale;
this.CaseSensitive = ds.CaseSensitive;
this.EnforceConstraints = ds.EnforceConstraints;
this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
this.InitVars();
}
protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
System.IO.MemoryStream stream = new System.IO.MemoryStream();
this.WriteXmlSchema(new XmlTextWriter(stream, null));
stream.Position = 0;
return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
}
internal void InitVars() {
this.table读者信息 = ((读者信息DataTable)(this.Tables["读者信息"]));
if ((this.table读者信息 != null)) {
this.table读者信息.InitVars();
}
this.table图书类型 = ((图书类型DataTable)(this.Tables["图书类型"]));
if ((this.table图书类型 != null)) {
this.table图书类型.InitVars();
}
this.table读者类型 = ((读者类型DataTable)(this.Tables["读者类型"]));
if ((this.table读者类型 != null)) {
this.table读者类型.InitVars();
}
this.table图书信息 = ((图书信息DataTable)(this.Tables["图书信息"]));
if ((this.table图书信息 != null)) {
this.table图书信息.InitVars();
}
this.table图书征订 = ((图书征订DataTable)(this.Tables["图书征订"]));
if ((this.table图书征订 != null)) {
this.table图书征订.InitVars();
}
this.table图书借阅 = ((图书借阅DataTable)(this.Tables["图书借阅"]));
if ((this.table图书借阅 != null)) {
this.table图书借阅.InitVars();
}
}
private void InitClass() {
this.DataSetName = "DataSet1";
this.Prefix = "";
this.Namespace = "http://www.tempuri.org/DataSet1.xsd";
this.Locale = new System.Globalization.CultureInfo("zh-CN");
this.CaseSensitive = false;
this.EnforceConstraints = true;
this.table读者信息 = new 读者信息DataTable();
this.Tables.Add(this.table读者信息);
this.table图书类型 = new 图书类型DataTable();
this.Tables.Add(this.table图书类型);
this.table读者类型 = new 读者类型DataTable();
this.Tables.Add(this.table读者类型);
this.table图书信息 = new 图书信息DataTable();
this.Tables.Add(this.table图书信息);
this.table图书征订 = new 图书征订DataTable();
this.Tables.Add(this.table图书征订);
this.table图书借阅 = new 图书借阅DataTable();
this.Tables.Add(this.table图书借阅);
}
private bool ShouldSerialize读者信息() {
return false;
}
private bool ShouldSerialize图书类型() {
return false;
}
private bool ShouldSerialize读者类型() {
return false;
}
private bool ShouldSerialize图书信息() {
return false;
}
private bool ShouldSerialize图书征订() {
return false;
}
private bool ShouldSerialize图书借阅() {
return false;
}
private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
this.InitVars();
}
}
public delegate void 读者信息RowChangeEventHandler(object sender, 读者信息RowChangeEvent e);
public delegate void 图书类型RowChangeEventHandler(object sender, 图书类型RowChangeEvent e);
public delegate void 读者类型RowChangeEventHandler(object sender, 读者类型RowChangeEvent e);
public delegate void 图书信息RowChangeEventHandler(object sender, 图书信息RowChangeEvent e);
public delegate void 图书征订RowChangeEventHandler(object sender, 图书征订RowChangeEvent e);
public delegate void 图书借阅RowChangeEventHandler(object sender, 图书借阅RowChangeEvent e);
[System.Diagnostics.DebuggerStepThrough()]
public class 读者信息DataTable : DataTable, System.Collections.IEnumerable {
private DataColumn column条形码;
private DataColumn column编号;
private DataColumn column姓名;
private DataColumn column性别;
private DataColumn column类型;
private DataColumn column出生日期;
private DataColumn column有效证件;
private DataColumn column证件号码;
private DataColumn column联系方式;
private DataColumn column登记日期;
private DataColumn column有限期至;
private DataColumn column操作员;
private DataColumn column备注;
private DataColumn column图书借阅次数;
private DataColumn column期刊借阅次数;
private DataColumn column是否挂失;
internal 读者信息DataTable() :
base("读者信息") {
this.InitClass();
}
internal 读者信息DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 条形码Column {
get {
return this.column条形码;
}
}
internal DataColumn 编号Column {
get {
return this.column编号;
}
}
internal DataColumn 姓名Column {
get {
return this.column姓名;
}
}
internal DataColumn 性别Column {
get {
return this.column性别;
}
}
internal DataColumn 类型Column {
get {
return this.column类型;
}
}
internal DataColumn 出生日期Column {
get {
return this.column出生日期;
}
}
internal DataColumn 有效证件Column {
get {
return this.column有效证件;
}
}
internal DataColumn 证件号码Column {
get {
return this.column证件号码;
}
}
internal DataColumn 联系方式Column {
get {
return this.column联系方式;
}
}
internal DataColumn 登记日期Column {
get {
return this.column登记日期;
}
}
internal DataColumn 有限期至Column {
get {
return this.column有限期至;
}
}
internal DataColumn 操作员Column {
get {
return this.column操作员;
}
}
internal DataColumn 备注Column {
get {
return this.column备注;
}
}
internal DataColumn 图书借阅次数Column {
get {
return this.column图书借阅次数;
}
}
internal DataColumn 期刊借阅次数Column {
get {
return this.column期刊借阅次数;
}
}
internal DataColumn 是否挂失Column {
get {
return this.column是否挂失;
}
}
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 类型,
System.DateTime 出生日期,
string 有效证件,
string 证件号码,
string 联系方式,
System.DateTime 登记日期,
System.DateTime 有限期至,
string 操作员,
string 备注,
int 图书借阅次数,
int 期刊借阅次数,
bool 是否挂失) {
读者信息Row row读者信息Row = ((读者信息Row)(this.NewRow()));
row读者信息Row.ItemArray = new object[] {
条形码,
编号,
姓名,
性别,
类型,
出生日期,
有效证件,
证件号码,
联系方式,
登记日期,
有限期至,
操作员,
备注,
图书借阅次数,
期刊借阅次数,
是否挂失};
this.Rows.Add(row读者信息Row);
return row读者信息Row;
}
public 读者信息Row FindBy编号(string 编号) {
return ((读者信息Row)(this.Rows.Find(new object[] {
编号})));
}
public System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
public override DataTable Clone() {
读者信息DataTable cln = ((读者信息DataTable)(base.Clone()));
cln.InitVars();
return cln;
}
protected override DataTable CreateInstance() {
return new 读者信息DataTable();
}
internal void InitVars() {
this.column条形码 = this.Columns["条形码"];
this.column编号 = this.Columns["编号"];
this.column姓名 = this.Columns["姓名"];
this.column性别 = this.Columns["性别"];
this.column类型 = this.Columns["类型"];
this.column出生日期 = this.Columns["出生日期"];
this.column有效证件 = this.Columns["有效证件"];
this.column证件号码 = this.Columns["证件号码"];
this.column联系方式 = this.Columns["联系方式"];
this.column登记日期 = this.Columns["登记日期"];
this.column有限期至 = this.Columns["有限期至"];
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(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(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(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(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是否挂失.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 {
return ((string)(this[this.table读者信息.类型Column]));
}
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 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 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 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 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可借天数;
internal 图书类型DataTable() :
base("图书类型") {
this.InitClass();
}
internal 图书类型DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 类型编号Column {
get {
return this.column类型编号;
}
}
internal DataColumn 类型名称Column {
get {
return this.column类型名称;
}
}
internal DataColumn 可借天数Column {
get {
return this.column可借天数;
}
}
public 图书类型Row this[int index] {
get {
return ((图书类型Row)(this.Rows[index]));
}
}
public event 图书类型RowChangeEventHandler 图书类型RowChanged;
public event 图书类型RowChangeEventHandler 图书类型RowChanging;
public event 图书类型RowChangeEventHandler 图书类型RowDeleted;
public event 图书类型RowChangeEventHandler 图书类型RowDeleting;
public void Add图书类型Row(图书类型Row row) {
this.Rows.Add(row);
}
public 图书类型Row Add图书类型Row(string 类型编号, string 类型名称, int 可借天数) {
图书类型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["可借天数"];
}
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.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
this.column类型编号}, true));
this.column类型编号.AllowDBNull = false;
this.column类型编号.Unique = true;
}
public 图书类型Row New图书类型Row() {
return ((图书类型Row)(this.NewRow()));
}
protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
return new 图书类型Row(builder);
}
protected override System.Type GetRowType() {
return typeof(图书类型Row);
}
protected override void OnRowChanged(DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.图书类型RowChanged != null)) {
this.图书类型RowChanged(this, new 图书类型RowChangeEvent(((图书类型Row)(e.Row)), e.Action));
}
}
protected override void OnRowChanging(DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.图书类型RowChanging != null)) {
this.图书类型RowChanging(this, new 图书类型RowChangeEvent(((图书类型Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleted(DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.图书类型RowDeleted != null)) {
this.图书类型RowDeleted(this, new 图书类型RowChangeEvent(((图书类型Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleting(DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.图书类型RowDeleting != null)) {
this.图书类型RowDeleting(this, new 图书类型RowChangeEvent(((图书类型Row)(e.Row)), e.Action));
}
}
public void Remove图书类型Row(图书类型Row row) {
this.Rows.Remove(row);
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书类型Row : DataRow {
private 图书类型DataTable table图书类型;
internal 图书类型Row(DataRowBuilder rb) :
base(rb) {
this.table图书类型 = ((图书类型DataTable)(this.Table));
}
public string 类型编号 {
get {
return ((string)(this[this.table图书类型.类型编号Column]));
}
set {
this[this.table图书类型.类型编号Column] = value;
}
}
public string 类型名称 {
get {
try {
return ((string)(this[this.table图书类型.类型名称Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书类型.类型名称Column] = value;
}
}
public int 可借天数 {
get {
try {
return ((int)(this[this.table图书类型.可借天数Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table图书类型.可借天数Column] = value;
}
}
public bool Is类型名称Null() {
return this.IsNull(this.table图书类型.类型名称Column);
}
public void Set类型名称Null() {
this[this.table图书类型.类型名称Column] = System.Convert.DBNull;
}
public bool Is可借天数Null() {
return this.IsNull(this.table图书类型.可借天数Column);
}
public void Set可借天数Null() {
this[this.table图书类型.可借天数Column] = System.Convert.DBNull;
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 图书类型RowChangeEvent : EventArgs {
private 图书类型Row eventRow;
private DataRowAction eventAction;
public 图书类型RowChangeEvent(图书类型Row row, DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
public 图书类型Row Row {
get {
return this.eventRow;
}
}
public DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 读者类型DataTable : DataTable, System.Collections.IEnumerable {
private DataColumn column类型;
private DataColumn column图书册书;
private DataColumn column期刊册书;
private DataColumn column续借次数;
private DataColumn column限制图书;
private DataColumn column限制期刊;
internal 读者类型DataTable() :
base("读者类型") {
this.InitClass();
}
internal 读者类型DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 类型Column {
get {
return this.column类型;
}
}
internal DataColumn 图书册书Column {
get {
return this.column图书册书;
}
}
internal DataColumn 期刊册书Column {
get {
return this.column期刊册书;
}
}
internal DataColumn 续借次数Column {
get {
return this.column续借次数;
}
}
internal DataColumn 限制图书Column {
get {
return this.column限制图书;
}
}
internal DataColumn 限制期刊Column {
get {
return this.column限制期刊;
}
}
public 读者类型Row this[int index] {
get {
return ((读者类型Row)(this.Rows[index]));
}
}
public event 读者类型RowChangeEventHandler 读者类型RowChanged;
public event 读者类型RowChangeEventHandler 读者类型RowChanging;
public event 读者类型RowChangeEventHandler 读者类型RowDeleted;
public event 读者类型RowChangeEventHandler 读者类型RowDeleting;
public void Add读者类型Row(读者类型Row row) {
this.Rows.Add(row);
}
public 读者类型Row Add读者类型Row(string 类型, short 图书册书, short 期刊册书, int 续借次数, bool 限制图书, bool 限制期刊) {
读者类型Row row读者类型Row = ((读者类型Row)(this.NewRow()));
row读者类型Row.ItemArray = new object[] {
类型,
图书册书,
期刊册书,
续借次数,
限制图书,
限制期刊};
this.Rows.Add(row读者类型Row);
return row读者类型Row;
}
public 读者类型Row FindBy类型(string 类型) {
return ((读者类型Row)(this.Rows.Find(new object[] {
类型})));
}
public System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
public override DataTable Clone() {
读者类型DataTable cln = ((读者类型DataTable)(base.Clone()));
cln.InitVars();
return cln;
}
protected override DataTable CreateInstance() {
return new 读者类型DataTable();
}
internal void InitVars() {
this.column类型 = this.Columns["类型"];
this.column图书册书 = this.Columns["图书册书"];
this.column期刊册书 = this.Columns["期刊册书"];
this.column续借次数 = this.Columns["续借次数"];
this.column限制图书 = this.Columns["限制图书"];
this.column限制期刊 = this.Columns["限制期刊"];
}
private void InitClass() {
this.column类型 = new DataColumn("类型", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column类型);
this.column图书册书 = new DataColumn("图书册书", typeof(short), null, System.Data.MappingType.Element);
this.Columns.Add(this.column图书册书);
this.column期刊册书 = new DataColumn("期刊册书", typeof(short), 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.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限制图书.DefaultValue = 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 short 图书册书 {
get {
try {
return ((short)(this[this.table读者类型.图书册书Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table读者类型.图书册书Column] = value;
}
}
public short 期刊册书 {
get {
try {
return ((short)(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 {
try {
return ((bool)(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 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 columnISBN;
private DataColumn column出版社;
private DataColumn column价格;
private DataColumn column页码;
private DataColumn column书架名称;
private DataColumn column现存量;
private DataColumn column库存总量;
private DataColumn column入库时间;
private DataColumn column操作员;
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书名;
}