dataset1.h

Visual_C++.NET实用编程百例

        }
    };
    
    
    
    
    
    
    
    
    inline DataSet1::gradeDataTable::gradeDataTable() : 
            DataTable(S"grade") {
        this->InitClass();
    }
    
    inline DataSet1::gradeDataTable::gradeDataTable(System::Data::DataTable *  table) : 
            DataTable(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;
    }
    
    inline System::Int32 DataSet1::gradeDataTable::get_Count() {
        return this->Rows->Count;
    }
    
    inline System::Data::DataColumn *  DataSet1::gradeDataTable::get_NameColumn() {
        return this->columnName;
    }
    
    inline System::Data::DataColumn *  DataSet1::gradeDataTable::get_Expr1001Column() {
        return this->columnExpr1001;
    }
    
    inline System::Data::DataColumn *  DataSet1::gradeDataTable::get_MathColumn() {
        return this->columnMath;
    }
    
    inline System::Data::DataColumn *  DataSet1::gradeDataTable::get_LiteraryColumn() {
        return this->columnLiterary;
    }
    
    inline System::Data::DataColumn *  DataSet1::gradeDataTable::get_TotalColumn() {
        return this->columnTotal;
    }
    
    inline sort::DataSet1::gradeRow *  DataSet1::gradeDataTable::get_Item(System::Int32 index) {
        return (__try_cast<sort::DataSet1::gradeRow *  >(this->Rows->Item[index]));
    }
    
    
    
    
    
    inline System::Void DataSet1::gradeDataTable::AddgradeRow(sort::DataSet1::gradeRow *  row) {
        this->Rows->Add(row);
    };
    
    inline sort::DataSet1::gradeRow *  DataSet1::gradeDataTable::AddgradeRow(System::String *  Name, System::Int16 Expr1001, System::Single Math, System::Single Literary, System::Single Total) {
        sort::DataSet1::gradeRow *  rowgradeRow = (__try_cast<sort::DataSet1::gradeRow *  >(this->NewRow()));
        System::Object* __mcTemp__1[] = new System::Object*[5];
                __mcTemp__1[0] = Name;
                __mcTemp__1[1] = __box(Expr1001);
                __mcTemp__1[2] = __box(Math);
                __mcTemp__1[3] = __box(Literary);
                __mcTemp__1[4] = __box(Total);
        rowgradeRow->ItemArray = __mcTemp__1;
        this->Rows->Add(rowgradeRow);
        return rowgradeRow;
    };
    
    inline System::Collections::IEnumerator *  DataSet1::gradeDataTable::GetEnumerator() {
        return this->Rows->GetEnumerator();
    };
    
    inline System::Data::DataTable *  DataSet1::gradeDataTable::Clone() {
        sort::DataSet1::gradeDataTable *  cln = (__try_cast<sort::DataSet1::gradeDataTable *  >(__super::Clone()));
        cln->InitVars();
        return cln;
    };
    
    inline System::Data::DataTable *  DataSet1::gradeDataTable::CreateInstance() {
        return new sort::DataSet1::gradeDataTable();
    };
    
    inline System::Void DataSet1::gradeDataTable::InitVars() {
        this->columnName = this->Columns->Item[S"Name"];
        this->columnExpr1001 = this->Columns->Item[S"Expr1001"];
        this->columnMath = this->Columns->Item[S"Math"];
        this->columnLiterary = this->Columns->Item[S"Literary"];
        this->columnTotal = this->Columns->Item[S"Total"];
    };
    
    inline System::Void DataSet1::gradeDataTable::InitClass() {
        this->columnName = new System::Data::DataColumn(S"Name", __typeof(System::String), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnName);
        this->columnExpr1001 = new System::Data::DataColumn(S"Expr1001", __typeof(System::Int16), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnExpr1001);
        this->columnMath = new System::Data::DataColumn(S"Math", __typeof(System::Single), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnMath);
        this->columnLiterary = new System::Data::DataColumn(S"Literary", __typeof(System::Single), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnLiterary);
        this->columnTotal = new System::Data::DataColumn(S"Total", __typeof(System::Single), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnTotal);
        this->columnExpr1001->ReadOnly = true;
    };
    
    inline sort::DataSet1::gradeRow *  DataSet1::gradeDataTable::NewgradeRow() {
        return (__try_cast<sort::DataSet1::gradeRow *  >(this->NewRow()));
    };
    
    inline System::Data::DataRow *  DataSet1::gradeDataTable::NewRowFromBuilder(System::Data::DataRowBuilder *  builder) {
        return new sort::DataSet1::gradeRow(builder);
    };
    
    inline System::Type *  DataSet1::gradeDataTable::GetRowType() {
        return __typeof(sort::DataSet1::gradeRow);
    };
    
    inline System::Void DataSet1::gradeDataTable::OnRowChanged(System::Data::DataRowChangeEventArgs *  e) {
        __super::OnRowChanged(e);
        if ((this->gradeRowChanged != 0)) {
            this->gradeRowChanged(this, new sort::DataSet1::gradeRowChangeEvent((__try_cast<sort::DataSet1::gradeRow *  >(e->Row)), e->Action));
        }
    };
    
    inline System::Void DataSet1::gradeDataTable::OnRowChanging(System::Data::DataRowChangeEventArgs *  e) {
        __super::OnRowChanging(e);
        if ((this->gradeRowChanging != 0)) {
            this->gradeRowChanging(this, new sort::DataSet1::gradeRowChangeEvent((__try_cast<sort::DataSet1::gradeRow *  >(e->Row)), e->Action));
        }
    };
    
    inline System::Void DataSet1::gradeDataTable::OnRowDeleted(System::Data::DataRowChangeEventArgs *  e) {
        __super::OnRowDeleted(e);
        if ((this->gradeRowDeleted != 0)) {
            this->gradeRowDeleted(this, new sort::DataSet1::gradeRowChangeEvent((__try_cast<sort::DataSet1::gradeRow *  >(e->Row)), e->Action));
        }
    };
    
    inline System::Void DataSet1::gradeDataTable::OnRowDeleting(System::Data::DataRowChangeEventArgs *  e) {
        __super::OnRowDeleting(e);
        if ((this->gradeRowDeleting != 0)) {
            this->gradeRowDeleting(this, new sort::DataSet1::gradeRowChangeEvent((__try_cast<sort::DataSet1::gradeRow *  >(e->Row)), e->Action));
        }
    };
    
    inline System::Void DataSet1::gradeDataTable::RemovegradeRow(sort::DataSet1::gradeRow *  row) {
        this->Rows->Remove(row);
    };
    
    
    
    inline DataSet1::gradeRow::gradeRow(System::Data::DataRowBuilder *  rb) : 
            DataRow(rb) {
        this->tablegrade = (__try_cast<sort::DataSet1::gradeDataTable *  >(this->Table));
    }
    
    inline System::String *  DataSet1::gradeRow::get_Name() {
        try {
            return (__try_cast<System::String *  >(this->Item[this->tablegrade->NameColumn]));
        }
        catch (System::InvalidCastException * e) {
            throw new System::Data::StrongTypingException(S"无法获取值，因为它是 DBNull。", e);
        }
    }
    inline void DataSet1::gradeRow::set_Name(System::String *  value) {
        this->Item[this->tablegrade->NameColumn] = value;
    }
    
    inline System::Int16 DataSet1::gradeRow::get_Expr1001() {
        try {
            return (*__try_cast<__box System::Int16 *  >(this->Item[this->tablegrade->Expr1001Column]));
        }
        catch (System::InvalidCastException * e) {
            throw new System::Data::StrongTypingException(S"无法获取值，因为它是 DBNull。", e);
        }
    }
    inline void DataSet1::gradeRow::set_Expr1001(System::Int16 value) {
        this->Item[this->tablegrade->Expr1001Column] = __box(value);
    }
    
    inline System::Single DataSet1::gradeRow::get_Math() {
        try {
            return (*__try_cast<__box System::Single *  >(this->Item[this->tablegrade->MathColumn]));
        }
        catch (System::InvalidCastException * e) {
            throw new System::Data::StrongTypingException(S"无法获取值，因为它是 DBNull。", e);
        }
    }
    inline void DataSet1::gradeRow::set_Math(System::Single value) {
        this->Item[this->tablegrade->MathColumn] = __box(value);
    }
    
    inline System::Single DataSet1::gradeRow::get_Literary() {
        try {
            return (*__try_cast<__box System::Single *  >(this->Item[this->tablegrade->LiteraryColumn]));
        }
        catch (System::InvalidCastException * e) {
            throw new System::Data::StrongTypingException(S"无法获取值，因为它是 DBNull。", e);
        }
    }
    inline void DataSet1::gradeRow::set_Literary(System::Single value) {
        this->Item[this->tablegrade->LiteraryColumn] = __box(value);
    }
    
    inline System::Single DataSet1::gradeRow::get_Total() {
        try {
            return (*__try_cast<__box System::Single *  >(this->Item[this->tablegrade->TotalColumn]));
        }
        catch (System::InvalidCastException * e) {
            throw new System::Data::StrongTypingException(S"无法获取值，因为它是 DBNull。", e);
        }
    }
    inline void DataSet1::gradeRow::set_Total(System::Single value) {
        this->Item[this->tablegrade->TotalColumn] = __box(value);
    }
    
    inline System::Boolean DataSet1::gradeRow::IsNameNull() {
        return this->IsNull(this->tablegrade->NameColumn);
    };
    
    inline System::Void DataSet1::gradeRow::SetNameNull() {
        this->Item[this->tablegrade->NameColumn] = System::Convert::DBNull;
    };
    
    inline System::Boolean DataSet1::gradeRow::IsExpr1001Null() {
        return this->IsNull(this->tablegrade->Expr1001Column);
    };
    
    inline System::Void DataSet1::gradeRow::SetExpr1001Null() {
        this->Item[this->tablegrade->Expr1001Column] = System::Convert::DBNull;
    };
    
    inline System::Boolean DataSet1::gradeRow::IsMathNull() {
        return this->IsNull(this->tablegrade->MathColumn);
    };
    
    inline System::Void DataSet1::gradeRow::SetMathNull() {
        this->Item[this->tablegrade->MathColumn] = System::Convert::DBNull;
    };
    
    inline System::Boolean DataSet1::gradeRow::IsLiteraryNull() {
        return this->IsNull(this->tablegrade->LiteraryColumn);
    };
    
    inline System::Void DataSet1::gradeRow::SetLiteraryNull() {
        this->Item[this->tablegrade->LiteraryColumn] = System::Convert::DBNull;
    };
    
    inline System::Boolean DataSet1::gradeRow::IsTotalNull() {
        return this->IsNull(this->tablegrade->TotalColumn);
    };
    
    inline System::Void DataSet1::gradeRow::SetTotalNull() {
        this->Item[this->tablegrade->TotalColumn] = System::Convert::DBNull;
    };
    
    
    
    
    inline DataSet1::gradeRowChangeEvent::gradeRowChangeEvent(sort::DataSet1::gradeRow *  row, System::Data::DataRowAction action) {
        this->eventRow = row;
        this->eventAction = action;
    }
    
    inline sort::DataSet1::gradeRow *  DataSet1::gradeRowChangeEvent::get_Row() {
        return this->eventRow;
    }
    
    inline System::Data::DataRowAction DataSet1::gradeRowChangeEvent::get_Action() {
        return this->eventAction;
    }
}