datasetimporttable.h

Visual C++.net数据库开发经典案例

            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;
    }
    
    inline My::DataSetImportTable::ImportTableDataTable *  DataSetImportTable::get_ImportTable() {
        return this->tableImportTable;
    }
    
    inline System::Data::DataSet *  DataSetImportTable::Clone() {
        My::DataSetImportTable *  cln = (__try_cast<My::DataSetImportTable *  >(__super::Clone()));
        cln->InitVars();
        return cln;
    };
    
    inline System::Boolean DataSetImportTable::ShouldSerializeTables() {
        return false;
    };
    
    inline System::Boolean DataSetImportTable::ShouldSerializeRelations() {
        return false;
    };
    
    inline System::Void DataSetImportTable::ReadXmlSerializable(System::Xml::XmlReader *  reader) {
        this->Reset();
        System::Data::DataSet *  ds = new System::Data::DataSet();
        ds->ReadXml(reader);
        if ((ds->Tables->Item[S"ImportTable"] != 0)) {
            this->Tables->Add(new My::DataSetImportTable::ImportTableDataTable(ds->Tables->Item[S"ImportTable"]));
        }
        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();
    };
    
    inline System::Xml::Schema::XmlSchema *  DataSetImportTable::GetSchemaSerializable() {
        System::IO::MemoryStream *  stream = new System::IO::MemoryStream();
        this->WriteXmlSchema(new System::Xml::XmlTextWriter(stream, 0));
        stream->Position = 0;
        return System::Xml::Schema::XmlSchema::Read(new System::Xml::XmlTextReader(stream), 0);
    };
    
    inline System::Void DataSetImportTable::InitVars() {
        this->tableImportTable = (__try_cast<My::DataSetImportTable::ImportTableDataTable *  >(this->Tables->Item[S"ImportTable"]));
        if ((this->tableImportTable != 0)) {
            this->tableImportTable->InitVars();
        }
    };
    
    inline System::Void DataSetImportTable::InitClass() {
        this->DataSetName = S"DataSetImportTable";
        this->Prefix = S"";
        this->Namespace = S"http://www.tempuri.org/DataSetImportTable.xsd";
        this->Locale = new System::Globalization::CultureInfo(S"zh-CN");
        this->CaseSensitive = false;
        this->EnforceConstraints = true;
        this->tableImportTable = new My::DataSetImportTable::ImportTableDataTable();
        this->Tables->Add(this->tableImportTable);
    };
    
    inline System::Boolean DataSetImportTable::ShouldSerializeImportTable() {
        return false;
    };
    
    inline System::Void DataSetImportTable::SchemaChanged(System::Object *  sender, System::ComponentModel::CollectionChangeEventArgs *  e) {
        if ((e->Action == System::ComponentModel::CollectionChangeAction::Remove)) {
            this->InitVars();
        }
    };
    
    
    
    
    
    
    
    
    
    
    
    
    
    inline DataSetImportTable::ImportTableDataTable::ImportTableDataTable() : 
            DataTable(S"ImportTable") {
        this->InitClass();
    }
    
    inline DataSetImportTable::ImportTableDataTable::ImportTableDataTable(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 DataSetImportTable::ImportTableDataTable::get_Count() {
        return this->Rows->Count;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_DateColumn() {
        return this->columnDate;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_TotalColumn() {
        return this->columnTotal;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_QuantityColumn() {
        return this->columnQuantity;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_PriceColumn() {
        return this->columnPrice;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_DetailTotalColumn() {
        return this->columnDetailTotal;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_DiscountColumn() {
        return this->columnDiscount;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_TaxRateColumn() {
        return this->columnTaxRate;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_DepotColumn() {
        return this->columnDepot;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_WareNameColumn() {
        return this->columnWareName;
    }
    
    inline System::Data::DataColumn *  DataSetImportTable::ImportTableDataTable::get_StockerNameColumn() {
        return this->columnStockerName;
    }
    
    inline My::DataSetImportTable::ImportTableRow *  DataSetImportTable::ImportTableDataTable::get_Item(System::Int32 index) {
        return (__try_cast<My::DataSetImportTable::ImportTableRow *  >(this->Rows->Item[index]));
    }
    
    
    
    
    
    inline System::Void DataSetImportTable::ImportTableDataTable::AddImportTableRow(My::DataSetImportTable::ImportTableRow *  row) {
        this->Rows->Add(row);
    };
    
    inline My::DataSetImportTable::ImportTableRow *  DataSetImportTable::ImportTableDataTable::AddImportTableRow(System::DateTime Date, System::Decimal Total, System::Decimal Quantity, System::Decimal Price, System::Decimal DetailTotal, System::Decimal Discount, System::Decimal TaxRate, System::String *  Depot, System::String *  WareName, System::String *  StockerName) {
        My::DataSetImportTable::ImportTableRow *  rowImportTableRow = (__try_cast<My::DataSetImportTable::ImportTableRow *  >(this->NewRow()));
        System::Object* __mcTemp__1[] = new System::Object*[10];
                __mcTemp__1[0] = __box(Date);
                __mcTemp__1[1] = __box(Total);
                __mcTemp__1[2] = __box(Quantity);
                __mcTemp__1[3] = __box(Price);
                __mcTemp__1[4] = __box(DetailTotal);
                __mcTemp__1[5] = __box(Discount);
                __mcTemp__1[6] = __box(TaxRate);
                __mcTemp__1[7] = Depot;
                __mcTemp__1[8] = WareName;
                __mcTemp__1[9] = StockerName;
        rowImportTableRow->ItemArray = __mcTemp__1;
        this->Rows->Add(rowImportTableRow);
        return rowImportTableRow;
    };
    
    inline System::Collections::IEnumerator *  DataSetImportTable::ImportTableDataTable::GetEnumerator() {
        return this->Rows->GetEnumerator();
    };
    
    inline System::Data::DataTable *  DataSetImportTable::ImportTableDataTable::Clone() {
        My::DataSetImportTable::ImportTableDataTable *  cln = (__try_cast<My::DataSetImportTable::ImportTableDataTable *  >(__super::Clone()));
        cln->InitVars();
        return cln;
    };
    
    inline System::Data::DataTable *  DataSetImportTable::ImportTableDataTable::CreateInstance() {
        return new My::DataSetImportTable::ImportTableDataTable();
    };
    
    inline System::Void DataSetImportTable::ImportTableDataTable::InitVars() {
        this->columnDate = this->Columns->Item[S"Date"];
        this->columnTotal = this->Columns->Item[S"Total"];
        this->columnQuantity = this->Columns->Item[S"Quantity"];
        this->columnPrice = this->Columns->Item[S"Price"];
        this->columnDetailTotal = this->Columns->Item[S"DetailTotal"];
        this->columnDiscount = this->Columns->Item[S"Discount"];
        this->columnTaxRate = this->Columns->Item[S"TaxRate"];
        this->columnDepot = this->Columns->Item[S"Depot"];
        this->columnWareName = this->Columns->Item[S"WareName"];
        this->columnStockerName = this->Columns->Item[S"StockerName"];
    };
    
    inline System::Void DataSetImportTable::ImportTableDataTable::InitClass() {
        this->columnDate = new System::Data::DataColumn(S"Date", __typeof(System::DateTime), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnDate);
        this->columnTotal = new System::Data::DataColumn(S"Total", __typeof(System::Decimal), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnTotal);
        this->columnQuantity = new System::Data::DataColumn(S"Quantity", __typeof(System::Decimal), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnQuantity);
        this->columnPrice = new System::Data::DataColumn(S"Price", __typeof(System::Decimal), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnPrice);
        this->columnDetailTotal = new System::Data::DataColumn(S"DetailTotal", __typeof(System::Decimal), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnDetailTotal);
        this->columnDiscount = new System::Data::DataColumn(S"Discount", __typeof(System::Decimal), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnDiscount);
        this->columnTaxRate = new System::Data::DataColumn(S"TaxRate", __typeof(System::Decimal), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnTaxRate);
        this->columnDepot = new System::Data::DataColumn(S"Depot", __typeof(System::String), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnDepot);
        this->columnWareName = new System::Data::DataColumn(S"WareName", __typeof(System::String), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnWareName);
        this->columnStockerName = new System::Data::DataColumn(S"StockerName", __typeof(System::String), 0, System::Data::MappingType::Element);
        this->Columns->Add(this->columnStockerName);
        this->columnQuantity->AllowDBNull = false;
    };
    
    inline My::DataSetImportTable::ImportTableRow *  DataSetImportTable::ImportTableDataTable::NewImportTableRow() {
        return (__try_cast<My::DataSetImportTable::ImportTableRow *  >(this->NewRow()));
    };
    
    inline System::Data::DataRow *  DataSetImportTable::ImportTableDataTable::NewRowFromBuilder(System::Data::DataRowBuilder *  builder) {
        return new My::DataSetImportTable::ImportTableRow(builder);