企业管理

开发平台：

C#

DataSet1.cs：源码内容

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是否可拼房;
internal 客房类型DataTable() :
base("客房类型") {
this.InitClass();
}
internal 客房类型DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 类型编号Column {
get {
return this.column类型编号;
}
}
internal DataColumn 类型名称Column {
get {
return this.column类型名称;
}
}
internal DataColumn 价格Column {
get {
return this.column价格;
}
}
internal DataColumn 拼房价格Column {
get {
return this.column拼房价格;
}
}
internal DataColumn 可超预定数Column {
get {
return this.column可超预定数;
}
}
internal DataColumn 是否可拼房Column {
get {
return this.column是否可拼房;
}
}
public 客房类型Row this[int index] {
get {
return ((客房类型Row)(this.Rows[index]));
}
}
public event 客房类型RowChangeEventHandler 客房类型RowChanged;
public event 客房类型RowChangeEventHandler 客房类型RowChanging;
public event 客房类型RowChangeEventHandler 客房类型RowDeleted;
public event 客房类型RowChangeEventHandler 客房类型RowDeleting;
public void Add客房类型Row(客房类型Row row) {
this.Rows.Add(row);
}
public 客房类型Row Add客房类型Row(string 类型编号, string 类型名称, System.Decimal 价格, System.Decimal 拼房价格, System.Decimal 可超预定数, 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(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(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;
}
public 客房类型Row New客房类型Row() {
return ((客房类型Row)(this.NewRow()));
}
protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
return new 客房类型Row(builder);
}
protected override System.Type GetRowType() {
return typeof(客房类型Row);
}
protected override void OnRowChanged(DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.客房类型RowChanged != null)) {
this.客房类型RowChanged(this, new 客房类型RowChangeEvent(((客房类型Row)(e.Row)), e.Action));
}
}
protected override void OnRowChanging(DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.客房类型RowChanging != null)) {
this.客房类型RowChanging(this, new 客房类型RowChangeEvent(((客房类型Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleted(DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.客房类型RowDeleted != null)) {
this.客房类型RowDeleted(this, new 客房类型RowChangeEvent(((客房类型Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleting(DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.客房类型RowDeleting != null)) {
this.客房类型RowDeleting(this, new 客房类型RowChangeEvent(((客房类型Row)(e.Row)), e.Action));
}
}
public void Remove客房类型Row(客房类型Row row) {
this.Rows.Remove(row);
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 客房类型Row : DataRow {
private 客房类型DataTable table客房类型;
internal 客房类型Row(DataRowBuilder rb) :
base(rb) {
this.table客房类型 = ((客房类型DataTable)(this.Table));
}
public string 类型编号 {
get {
return ((string)(this[this.table客房类型.类型编号Column]));
}
set {
this[this.table客房类型.类型编号Column] = value;
}
}
public string 类型名称 {
get {
try {
return ((string)(this[this.table客房类型.类型名称Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table客房类型.类型名称Column] = value;
}
}
public System.Decimal 价格 {
get {
try {
return ((System.Decimal)(this[this.table客房类型.价格Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table客房类型.价格Column] = value;
}
}
public System.Decimal 拼房价格 {
get {
try {
return ((System.Decimal)(this[this.table客房类型.拼房价格Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table客房类型.拼房价格Column] = value;
}
}
public System.Decimal 可超预定数 {
get {
try {
return ((System.Decimal)(this[this.table客房类型.可超预定数Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table客房类型.可超预定数Column] = value;
}
}
public 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备注;
internal 帐单明细DataTable() :
base("帐单明细") {
this.InitClass();
}
internal 帐单明细DataTable(DataTable table) :
base(table.TableName) {
if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
this.CaseSensitive = table.CaseSensitive;
}
if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
this.Locale = table.Locale;
}
if ((table.Namespace != table.DataSet.Namespace)) {
this.Namespace = table.Namespace;
}
this.Prefix = table.Prefix;
this.MinimumCapacity = table.MinimumCapacity;
this.DisplayExpression = table.DisplayExpression;
}
[System.ComponentModel.Browsable(false)]
public int Count {
get {
return this.Rows.Count;
}
}
internal DataColumn 帐单编号Column {
get {
return this.column帐单编号;
}
}
internal DataColumn 入住单号Column {
get {
return this.column入住单号;
}
}
internal DataColumn 消费内容Column {
get {
return this.column消费内容;
}
}
internal DataColumn 消费金额Column {
get {
return this.column消费金额;
}
}
internal DataColumn 消费时间Column {
get {
return this.column消费时间;
}
}
internal DataColumn 备注Column {
get {
return this.column备注;
}
}
public 帐单明细Row this[int index] {
get {
return ((帐单明细Row)(this.Rows[index]));
}
}
public event 帐单明细RowChangeEventHandler 帐单明细RowChanged;
public event 帐单明细RowChangeEventHandler 帐单明细RowChanging;
public event 帐单明细RowChangeEventHandler 帐单明细RowDeleted;
public event 帐单明细RowChangeEventHandler 帐单明细RowDeleting;
public void Add帐单明细Row(帐单明细Row row) {
this.Rows.Add(row);
}
public 帐单明细Row Add帐单明细Row(string 入住单号, string 消费内容, System.Decimal 消费金额, System.DateTime 消费时间, string 备注) {
帐单明细Row row帐单明细Row = ((帐单明细Row)(this.NewRow()));
row帐单明细Row.ItemArray = new object[] {
null,
入住单号,
消费内容,
消费金额,
消费时间,
备注};
this.Rows.Add(row帐单明细Row);
return row帐单明细Row;
}
public 帐单明细Row FindBy帐单编号(int 帐单编号) {
return ((帐单明细Row)(this.Rows.Find(new object[] {
帐单编号})));
}
public System.Collections.IEnumerator GetEnumerator() {
return this.Rows.GetEnumerator();
}
public override DataTable Clone() {
帐单明细DataTable cln = ((帐单明细DataTable)(base.Clone()));
cln.InitVars();
return cln;
}
protected override DataTable CreateInstance() {
return new 帐单明细DataTable();
}
internal void InitVars() {
this.column帐单编号 = this.Columns["帐单编号"];
this.column入住单号 = this.Columns["入住单号"];
this.column消费内容 = this.Columns["消费内容"];
this.column消费金额 = this.Columns["消费金额"];
this.column消费时间 = this.Columns["消费时间"];
this.column备注 = this.Columns["备注"];
}
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(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(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column备注);
this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
this.column帐单编号}, true));
this.column帐单编号.AutoIncrement = true;
this.column帐单编号.AllowDBNull = false;
this.column帐单编号.ReadOnly = true;
this.column帐单编号.Unique = true;
this.column入住单号.AllowDBNull = false;
}
public 帐单明细Row New帐单明细Row() {
return ((帐单明细Row)(this.NewRow()));
}
protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
return new 帐单明细Row(builder);
}
protected override System.Type GetRowType() {
return typeof(帐单明细Row);
}
protected override void OnRowChanged(DataRowChangeEventArgs e) {
base.OnRowChanged(e);
if ((this.帐单明细RowChanged != null)) {
this.帐单明细RowChanged(this, new 帐单明细RowChangeEvent(((帐单明细Row)(e.Row)), e.Action));
}
}
protected override void OnRowChanging(DataRowChangeEventArgs e) {
base.OnRowChanging(e);
if ((this.帐单明细RowChanging != null)) {
this.帐单明细RowChanging(this, new 帐单明细RowChangeEvent(((帐单明细Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleted(DataRowChangeEventArgs e) {
base.OnRowDeleted(e);
if ((this.帐单明细RowDeleted != null)) {
this.帐单明细RowDeleted(this, new 帐单明细RowChangeEvent(((帐单明细Row)(e.Row)), e.Action));
}
}
protected override void OnRowDeleting(DataRowChangeEventArgs e) {
base.OnRowDeleting(e);
if ((this.帐单明细RowDeleting != null)) {
this.帐单明细RowDeleting(this, new 帐单明细RowChangeEvent(((帐单明细Row)(e.Row)), e.Action));
}
}
public void Remove帐单明细Row(帐单明细Row row) {
this.Rows.Remove(row);
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 帐单明细Row : DataRow {
private 帐单明细DataTable table帐单明细;
internal 帐单明细Row(DataRowBuilder rb) :
base(rb) {
this.table帐单明细 = ((帐单明细DataTable)(this.Table));
}
public int 帐单编号 {
get {
return ((int)(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 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 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;
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 帐单明细RowChangeEvent : EventArgs {
private 帐单明细Row eventRow;
private DataRowAction eventAction;
public 帐单明细RowChangeEvent(帐单明细Row row, DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
public 帐单明细Row Row {
get {
return this.eventRow;
}
}
public DataRowAction Action {
get {
return this.eventAction;
}
}
}
[System.Diagnostics.DebuggerStepThrough()]
public class 入住单DataTable : DataTable, System.Collections.IEnumerable {
private DataColumn column入住单号;
private DataColumn column预定单号;
private DataColumn column会员编号;
private DataColumn column抵店时间;
private DataColumn column离店时间;
private DataColumn column客房编号;
private DataColumn column客房价格;
private DataColumn column入住价格;
private DataColumn column是否加床;
private DataColumn column加床价格;
private DataColumn column预收款;
private DataColumn column早餐;
private DataColumn column叫醒;
private DataColumn column保密;
private DataColumn columnvip;
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 vipColumn {
get {
return this.columnvip;
}
}
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 预定单号,
int 会员编号,
System.DateTime 抵店时间,
System.DateTime 离店时间,
string 客房编号,
System.Decimal 客房价格,
System.Decimal 入住价格,
bool 是否加床,
System.Decimal 加床价格,
System.Decimal 预收款,
bool 早餐,
bool 叫醒,
bool 保密,
bool vip,
string 电话等级,
string 特要说明,
System.Decimal 应收帐款,
bool 是否结帐,
System.Decimal 结帐金额,
System.DateTime 结帐日期,
string 付款方式,
int 入住人数) {
入住单Row row入住单Row = ((入住单Row)(this.NewRow()));
row入住单Row.ItemArray = new object[] {
入住单号,
预定单号,
会员编号,
抵店时间,
离店时间,
客房编号,
客房价格,
入住价格,
是否加床,
加床价格,
预收款,
早餐,
叫醒,
保密,
vip,
电话等级,
特要说明,
应收帐款,
是否结帐,
结帐金额,
结帐日期,
付款方式,
入住人数};
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.columnvip = this.Columns["vip"];
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(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(System.Decimal), null, System.Data.MappingType.Element);
this.Columns.Add(this.column客房价格);
this.column入住价格 = new DataColumn("入住价格", typeof(System.Decimal), null, System.Data.MappingType.Element);
this.Columns.Add(this.column入住价格);
this.column是否加床 = new DataColumn("是否加床", typeof(bool), null, System.Data.MappingType.Element);
this.Columns.Add(this.column是否加床);
this.column加床价格 = new DataColumn("加床价格", typeof(System.Decimal), null, System.Data.MappingType.Element);
this.Columns.Add(this.column加床价格);
this.column预收款 = new DataColumn("预收款", typeof(System.Decimal), null, System.Data.MappingType.Element);
this.Columns.Add(this.column预收款);
this.column早餐 = new DataColumn("早餐", typeof(bool), null, System.Data.MappingType.Element);
this.Columns.Add(this.column早餐);
this.column叫醒 = new DataColumn("叫醒", typeof(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.columnvip = new DataColumn("vip", typeof(bool), null, System.Data.MappingType.Element);
this.Columns.Add(this.columnvip);
this.column电话等级 = new DataColumn("电话等级", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column电话等级);
this.column特要说明 = new DataColumn("特要说明", typeof(string), null, System.Data.MappingType.Element);
this.Columns.Add(this.column特要说明);
this.column应收帐款 = new DataColumn("应收帐款", typeof(System.Decimal), null, System.Data.MappingType.Element);
this.Columns.Add(this.column应收帐款);
this.column是否结帐 = new DataColumn("是否结帐", typeof(bool), 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(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 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 System.Decimal 客房价格 {
get {
try {
return ((System.Decimal)(this[this.table入住单.客房价格Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.客房价格Column] = value;
}
}
public System.Decimal 入住价格 {
get {
try {
return ((System.Decimal)(this[this.table入住单.入住价格Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.入住价格Column] = value;
}
}
public bool 是否加床 {
get {
try {
return ((bool)(this[this.table入住单.是否加床Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.是否加床Column] = value;
}
}
public System.Decimal 加床价格 {
get {
try {
return ((System.Decimal)(this[this.table入住单.加床价格Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.加床价格Column] = value;
}
}
public System.Decimal 预收款 {
get {
try {
return ((System.Decimal)(this[this.table入住单.预收款Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.预收款Column] = value;
}
}
public bool 早餐 {
get {
try {
return ((bool)(this[this.table入住单.早餐Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.早餐Column] = value;
}
}
public 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 vip {
get {
try {
return ((bool)(this[this.table入住单.vipColumn]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.vipColumn] = 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.Decimal 应收帐款 {
get {
try {
return ((System.Decimal)(this[this.table入住单.应收帐款Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.应收帐款Column] = value;
}
}
public bool 是否结帐 {
get {
try {
return ((bool)(this[this.table入住单.是否结帐Column]));
}
catch (InvalidCastException e) {
throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
}
}
set {
this[this.table入住单.是否结帐Column] = value;
}
}
public 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 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;
}
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 IsvipNull() {
return this.IsNull(this.table入住单.vipColumn);
}
public void SetvipNull() {
this[this.table入住单.vipColumn] = 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;
}
}
}
}
}