protected ExampleDatabaseDataSet(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected DocumentsBetta2DataSet(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["docs"] != null)) {
             base.Tables.Add(new docsDataTable(ds.Tables["docs"]));
         }
         if ((ds.Tables["typedocsExt"] != null)) {
             base.Tables.Add(new typedocsExtDataTable(ds.Tables["typedocsExt"]));
         }
         if ((ds.Tables["ourorgs"] != null)) {
             base.Tables.Add(new ourorgsDataTable(ds.Tables["ourorgs"]));
         }
         if ((ds.Tables["typeorgs"] != null)) {
             base.Tables.Add(new typeorgsDataTable(ds.Tables["typeorgs"]));
         }
         if ((ds.Tables["objects"] != null)) {
             base.Tables.Add(new objectsDataTable(ds.Tables["objects"]));
         }
         if ((ds.Tables["typedocsInt"] != null)) {
             base.Tables.Add(new typedocsIntDataTable(ds.Tables["typedocsInt"]));
         }
         if ((ds.Tables["fizlico"] != null)) {
             base.Tables.Add(new fizlicoDataTable(ds.Tables["fizlico"]));
         }
         if ((ds.Tables["jurlico"] != null)) {
             base.Tables.Add(new jurlicoDataTable(ds.Tables["jurlico"]));
         }
         if ((ds.Tables["partners"] != null)) {
             base.Tables.Add(new partnersDataTable(ds.Tables["partners"]));
         }
         if ((ds.Tables["docsView"] != null)) {
             base.Tables.Add(new docsViewDataTable(ds.Tables["docsView"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected Tier2Set(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((IsBinarySerialized(info, context) == true)) {
         InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(SchemaChanged);
         Tables.CollectionChanged += schemaChangedHandler1;
         Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["SoldProducts"] != null)) {
             base.Tables.Add(new SoldProductsDataTable(ds.Tables["SoldProducts"]));
         }
         DataSetName = ds.DataSetName;
         Prefix = ds.Prefix;
         Namespace = ds.Namespace;
         Locale = ds.Locale;
         CaseSensitive = ds.CaseSensitive;
         EnforceConstraints = ds.EnforceConstraints;
         Merge(ds, false, global::System.Data.MissingSchemaAction.Add);
         InitVars();
     }
     else {
         ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     Relations.CollectionChanged += schemaChangedHandler;
 }
 protected CallButlerDataset(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["Greetings"] != null)) {
             base.Tables.Add(new GreetingsDataTable(ds.Tables["Greetings"]));
         }
         if ((ds.Tables["LocalizedGreetings"] != null)) {
             base.Tables.Add(new LocalizedGreetingsDataTable(ds.Tables["LocalizedGreetings"]));
         }
         if ((ds.Tables["CallHistory"] != null)) {
             base.Tables.Add(new CallHistoryDataTable(ds.Tables["CallHistory"]));
         }
         if ((ds.Tables["Departments"] != null)) {
             base.Tables.Add(new DepartmentsDataTable(ds.Tables["Departments"]));
         }
         if ((ds.Tables["Extensions"] != null)) {
             base.Tables.Add(new ExtensionsDataTable(ds.Tables["Extensions"]));
         }
         if ((ds.Tables["ExtensionContactNumbers"] != null)) {
             base.Tables.Add(new ExtensionContactNumbersDataTable(ds.Tables["ExtensionContactNumbers"]));
         }
         if ((ds.Tables["Voicemails"] != null)) {
             base.Tables.Add(new VoicemailsDataTable(ds.Tables["Voicemails"]));
         }
         if ((ds.Tables["PersonalizedGreetings"] != null)) {
             base.Tables.Add(new PersonalizedGreetingsDataTable(ds.Tables["PersonalizedGreetings"]));
         }
         if ((ds.Tables["Providers"] != null)) {
             base.Tables.Add(new ProvidersDataTable(ds.Tables["Providers"]));
         }
         if ((ds.Tables["ScriptSchedules"] != null)) {
             base.Tables.Add(new ScriptSchedulesDataTable(ds.Tables["ScriptSchedules"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected DashboardTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["DashboardUnassignedServiceRequests"] != null)) {
             base.Tables.Add(new DashboardUnassignedServiceRequestsDataTable(ds.Tables["DashboardUnassignedServiceRequests"]));
         }
         if ((ds.Tables["DashboardExpiredServiceRequests"] != null)) {
             base.Tables.Add(new DashboardExpiredServiceRequestsDataTable(ds.Tables["DashboardExpiredServiceRequests"]));
         }
         if ((ds.Tables["DashboardItemsAboutToExpire"] != null)) {
             base.Tables.Add(new DashboardItemsAboutToExpireDataTable(ds.Tables["DashboardItemsAboutToExpire"]));
         }
         if ((ds.Tables["DashboardMyServiceRequests"] != null)) {
             base.Tables.Add(new DashboardMyServiceRequestsDataTable(ds.Tables["DashboardMyServiceRequests"]));
         }
         if ((ds.Tables["DashboardInProgressServiceRequests"] != null)) {
             base.Tables.Add(new DashboardInProgressServiceRequestsDataTable(ds.Tables["DashboardInProgressServiceRequests"]));
         }
         if ((ds.Tables["DashboardChecklistAlarms"] != null)) {
             base.Tables.Add(new DashboardChecklistAlarmsDataTable(ds.Tables["DashboardChecklistAlarms"]));
         }
         if ((ds.Tables["DashboardMyToDoList"] != null)) {
             base.Tables.Add(new DashboardMyToDoListDataTable(ds.Tables["DashboardMyToDoList"]));
         }
         if ((ds.Tables["DashboardMyToDoListOnHold"] != null)) {
             base.Tables.Add(new DashboardMyToDoListOnHoldDataTable(ds.Tables["DashboardMyToDoListOnHold"]));
         }
         if ((ds.Tables["DashboardToDoListAssignedToMe"] != null)) {
             base.Tables.Add(new DashboardToDoListAssignedToMeDataTable(ds.Tables["DashboardToDoListAssignedToMe"]));
         }
         if ((ds.Tables["DashboardToDoListAssignedToMeOnHold"] != null)) {
             base.Tables.Add(new DashboardToDoListAssignedToMeOnHoldDataTable(ds.Tables["DashboardToDoListAssignedToMeOnHold"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected WAYBILL_ADDITION(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context)
     :
         base(info, context, false)
 {
     if ((this.IsBinarySerialized(info, context) == true))
     {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema))
     {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["SUBREGION"] != null))
         {
             base.Tables.Add(new SUBREGIONDataTable(ds.Tables["SUBREGION"]));
         }
         if ((ds.Tables["DESTINATION_CODE"] != null))
         {
             base.Tables.Add(new DESTINATION_CODEDataTable(ds.Tables["DESTINATION_CODE"]));
         }
         if ((ds.Tables["BOX"] != null))
         {
             base.Tables.Add(new BOXDataTable(ds.Tables["BOX"]));
         }
         if ((ds.Tables["UDF_HEADER"] != null))
         {
             base.Tables.Add(new UDF_HEADERDataTable(ds.Tables["UDF_HEADER"]));
         }
         if ((ds.Tables["UDF_DETAIL"] != null))
         {
             base.Tables.Add(new UDF_DETAILDataTable(ds.Tables["UDF_DETAIL"]));
         }
         if ((ds.Tables["UDF_BOX"] != null))
         {
             base.Tables.Add(new UDF_BOXDataTable(ds.Tables["UDF_BOX"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else
     {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected TDSLFSRecord(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["LFS_MASTER_AREA"] != null)) {
             base.Tables.Add(new LFS_MASTER_AREADataTable(ds.Tables["LFS_MASTER_AREA"]));
         }
         if ((ds.Tables["LFS_M2_TABLES"] != null)) {
             base.Tables.Add(new LFS_M2_TABLESDataTable(ds.Tables["LFS_M2_TABLES"]));
         }
         if ((ds.Tables["LFS_POINT_REPAIRS"] != null)) {
             base.Tables.Add(new LFS_POINT_REPAIRSDataTable(ds.Tables["LFS_POINT_REPAIRS"]));
         }
         if ((ds.Tables["LFS_MASTER_AREA_RCT"] != null)) {
             base.Tables.Add(new LFS_MASTER_AREA_RCTDataTable(ds.Tables["LFS_MASTER_AREA_RCT"]));
         }
         if ((ds.Tables["LFS_POINT_REPAIRS_RCT"] != null)) {
             base.Tables.Add(new LFS_POINT_REPAIRS_RCTDataTable(ds.Tables["LFS_POINT_REPAIRS_RCT"]));
         }
         if ((ds.Tables["LFS_M2_TABLES_RCT"] != null)) {
             base.Tables.Add(new LFS_M2_TABLES_RCTDataTable(ds.Tables["LFS_M2_TABLES_RCT"]));
         }
         if ((ds.Tables["LFS_JUNCTION_LINER"] != null)) {
             base.Tables.Add(new LFS_JUNCTION_LINERDataTable(ds.Tables["LFS_JUNCTION_LINER"]));
         }
         if ((ds.Tables["LFS_JUNCTION_LINER_RCT"] != null)) {
             base.Tables.Add(new LFS_JUNCTION_LINER_RCTDataTable(ds.Tables["LFS_JUNCTION_LINER_RCT"]));
         }
         if ((ds.Tables["LFS_JUNCTION_LINER2"] != null)) {
             base.Tables.Add(new LFS_JUNCTION_LINER2DataTable(ds.Tables["LFS_JUNCTION_LINER2"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
Example #8
0
 protected AFIPartsDataSet(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["Customer"] != null)) {
             base.Tables.Add(new CustomerDataTable(ds.Tables["Customer"]));
         }
         if ((ds.Tables["PartCustLink"] != null)) {
             base.Tables.Add(new PartCustLinkDataTable(ds.Tables["PartCustLink"]));
         }
         if ((ds.Tables["PO"] != null)) {
             base.Tables.Add(new PODataTable(ds.Tables["PO"]));
         }
         if ((ds.Tables["STATES"] != null)) {
             base.Tables.Add(new STATESDataTable(ds.Tables["STATES"]));
         }
         if ((ds.Tables["CustBillShipAddr"] != null)) {
             base.Tables.Add(new CustBillShipAddrDataTable(ds.Tables["CustBillShipAddr"]));
         }
         if ((ds.Tables["Color"] != null)) {
             base.Tables.Add(new ColorDataTable(ds.Tables["Color"]));
         }
         if ((ds.Tables["Parts"] != null)) {
             base.Tables.Add(new PartsDataTable(ds.Tables["Parts"]));
         }
         if ((ds.Tables["LINESPEED"] != null)) {
             base.Tables.Add(new LINESPEEDDataTable(ds.Tables["LINESPEED"]));
         }
         if ((ds.Tables["Shippers"] != null)) {
             base.Tables.Add(new ShippersDataTable(ds.Tables["Shippers"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
Example #9
0
 protected UIDataSet(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["ShipPimperBaseList"] != null)) {
             base.Tables.Add(new ShipPimperBaseListDataTable(ds.Tables["ShipPimperBaseList"]));
         }
         if ((ds.Tables["ShipPimperItemList"] != null)) {
             base.Tables.Add(new ShipPimperItemListDataTable(ds.Tables["ShipPimperItemList"]));
         }
         if ((ds.Tables["RepFixerItemList"] != null)) {
             base.Tables.Add(new RepFixerItemListDataTable(ds.Tables["RepFixerItemList"]));
         }
         if ((ds.Tables["RepFixerItemFactions"] != null)) {
             base.Tables.Add(new RepFixerItemFactionsDataTable(ds.Tables["RepFixerItemFactions"]));
         }
         if ((ds.Tables["ShipPurchaseRestrictionItems"] != null)) {
             base.Tables.Add(new ShipPurchaseRestrictionItemsDataTable(ds.Tables["ShipPurchaseRestrictionItems"]));
         }
         if ((ds.Tables["StandardBannerList"] != null)) {
             base.Tables.Add(new StandardBannerListDataTable(ds.Tables["StandardBannerList"]));
         }
         if ((ds.Tables["BaseGoodNoBuyList"] != null)) {
             base.Tables.Add(new BaseGoodNoBuyListDataTable(ds.Tables["BaseGoodNoBuyList"]));
         }
         if ((ds.Tables["EquipPurchaseRestrictionItems"] != null)) {
             base.Tables.Add(new EquipPurchaseRestrictionItemsDataTable(ds.Tables["EquipPurchaseRestrictionItems"]));
         }
         if ((ds.Tables["SysSensorList"] != null)) {
             base.Tables.Add(new SysSensorListDataTable(ds.Tables["SysSensorList"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
		[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]protected SPDataProxy(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : base(info, context, false)
		{
			if (this.IsBinarySerialized(info, context) == true)
			{
				this.InitVars(false);
				global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
				this.Tables.CollectionChanged += new System.ComponentModel.CollectionChangeEventHandler(schemaChangedHandler1);
				this.Relations.CollectionChanged += new System.ComponentModel.CollectionChangeEventHandler(schemaChangedHandler1);
				return;
			}
			string strSchema = System.Convert.ToString(info.GetValue("XmlSchema", typeof(string)));
			if (this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)
			{
				global::System.Data.DataSet ds = new global::System.Data.DataSet();
				ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
				if (!(ds.Tables["SPMaster"]) == null)
				{
					base.Tables.Add(new SPMasterDataTable(ds.Tables["SPMaster"]));
				}
				if (!(ds.Tables["SPNotes"]) == null)
				{
					base.Tables.Add(new SPNotesDataTable(ds.Tables["SPNotes"]));
				}
				if (!(ds.Tables["SPAutoId"]) == null)
				{
					base.Tables.Add(new SPAutoIdDataTable(ds.Tables["SPAutoId"]));
				}
				if (!(ds.Tables["SPCompany"]) == null)
				{
					base.Tables.Add(new SPCompanyDataTable(ds.Tables["SPCompany"]));
				}
				if (!(ds.Tables["SPPayMode"]) == null)
				{
					base.Tables.Add(new SPPayModeDataTable(ds.Tables["SPPayMode"]));
				}
				if (!(ds.Tables["SPLookup"]) == null)
				{
					base.Tables.Add(new SPLookupDataTable(ds.Tables["SPLookup"]));
				}
				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, global::System.Data.MissingSchemaAction.Add);
				this.InitVars();
			}
			else
			{
				this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
			}
			this.GetSerializationData(info, context);
			global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
			base.Tables.CollectionChanged += new System.ComponentModel.CollectionChangeEventHandler(schemaChangedHandler);
			this.Relations.CollectionChanged += new System.ComponentModel.CollectionChangeEventHandler(schemaChangedHandler);
		}
 protected DSFichaPropiedadv2(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["Propiedad"] != null)) {
             base.Tables.Add(new PropiedadDataTable(ds.Tables["Propiedad"]));
         }
         if ((ds.Tables["Superficies"] != null)) {
             base.Tables.Add(new SuperficiesDataTable(ds.Tables["Superficies"]));
         }
         if ((ds.Tables["CaracteristicasPrincipales"] != null)) {
             base.Tables.Add(new CaracteristicasPrincipalesDataTable(ds.Tables["CaracteristicasPrincipales"]));
         }
         if ((ds.Tables["Region1"] != null)) {
             base.Tables.Add(new Region1DataTable(ds.Tables["Region1"]));
         }
         if ((ds.Tables["Region2"] != null)) {
             base.Tables.Add(new Region2DataTable(ds.Tables["Region2"]));
         }
         if ((ds.Tables["Region3"] != null)) {
             base.Tables.Add(new Region3DataTable(ds.Tables["Region3"]));
         }
         if ((ds.Tables["Region4"] != null)) {
             base.Tables.Add(new Region4DataTable(ds.Tables["Region4"]));
         }
         if ((ds.Tables["Region5"] != null)) {
             base.Tables.Add(new Region5DataTable(ds.Tables["Region5"]));
         }
         if ((ds.Tables["Encabezados"] != null)) {
             base.Tables.Add(new EncabezadosDataTable(ds.Tables["Encabezados"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected SchemaReader(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["Entities"] != null)) {
             base.Tables.Add(new EntitiesDataTable(ds.Tables["Entities"]));
         }
         if ((ds.Tables["FieldDefinitions"] != null)) {
             base.Tables.Add(new FieldDefinitionsDataTable(ds.Tables["FieldDefinitions"]));
         }
         if ((ds.Tables["ChildRelations"] != null)) {
             base.Tables.Add(new ChildRelationsDataTable(ds.Tables["ChildRelations"]));
         }
         if ((ds.Tables["ForeignRelations"] != null)) {
             base.Tables.Add(new ForeignRelationsDataTable(ds.Tables["ForeignRelations"]));
         }
         if ((ds.Tables["KeyInfo"] != null)) {
             base.Tables.Add(new KeyInfoDataTable(ds.Tables["KeyInfo"]));
         }
         if ((ds.Tables["TABLE_CONSTRAINTS"] != null)) {
             base.Tables.Add(new TABLE_CONSTRAINTSDataTable(ds.Tables["TABLE_CONSTRAINTS"]));
         }
         if ((ds.Tables["CONSTRAINT_COLUMN_USAGE"] != null)) {
             base.Tables.Add(new CONSTRAINT_COLUMN_USAGEDataTable(ds.Tables["CONSTRAINT_COLUMN_USAGE"]));
         }
         if ((ds.Tables["SCHEMATA"] != null)) {
             base.Tables.Add(new SCHEMATADataTable(ds.Tables["SCHEMATA"]));
         }
         if ((ds.Tables["DBObjProperties"] != null)) {
             base.Tables.Add(new DBObjPropertiesDataTable(ds.Tables["DBObjProperties"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected TeamProjectTime2TDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["LFS_TEAM_PROJECT_TIME_DETAIL"] != null)) {
             base.Tables.Add(new LFS_TEAM_PROJECT_TIME_DETAILDataTable(ds.Tables["LFS_TEAM_PROJECT_TIME_DETAIL"]));
         }
         if ((ds.Tables["LFS_TEAM_PROJECT_TIME_DETAIL_TEMP"] != null)) {
             base.Tables.Add(new LFS_TEAM_PROJECT_TIME_DETAIL_TEMPDataTable(ds.Tables["LFS_TEAM_PROJECT_TIME_DETAIL_TEMP"]));
         }
         if ((ds.Tables["Template"] != null)) {
             base.Tables.Add(new TemplateDataTable(ds.Tables["Template"]));
         }
         if ((ds.Tables["TEAM_PROJECT_TIME_WORK_FUNCTION_CONCAT"] != null)) {
             base.Tables.Add(new TEAM_PROJECT_TIME_WORK_FUNCTION_CONCATDataTable(ds.Tables["TEAM_PROJECT_TIME_WORK_FUNCTION_CONCAT"]));
         }
         if ((ds.Tables["LFS_TEAM_PROJECT_TIME"] != null)) {
             base.Tables.Add(new LFS_TEAM_PROJECT_TIMEDataTable(ds.Tables["LFS_TEAM_PROJECT_TIME"]));
         }
         if ((ds.Tables["LFS_TEAM_PROJECT_TIME_SECTION"] != null)) {
             base.Tables.Add(new LFS_TEAM_PROJECT_TIME_SECTIONDataTable(ds.Tables["LFS_TEAM_PROJECT_TIME_SECTION"]));
         }
         if ((ds.Tables["LFS_TEAM_PROJECT_TIME_SECTION_LATERAL"] != null)) {
             base.Tables.Add(new LFS_TEAM_PROJECT_TIME_SECTION_LATERALDataTable(ds.Tables["LFS_TEAM_PROJECT_TIME_SECTION_LATERAL"]));
         }
         if ((ds.Tables["LFS_TEAM_PROJECT_TIME_SECTION_MH"] != null)) {
             base.Tables.Add(new LFS_TEAM_PROJECT_TIME_SECTION_MHDataTable(ds.Tables["LFS_TEAM_PROJECT_TIME_SECTION_MH"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected dsLanguageData(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["Card"] != null)) {
             base.Tables.Add(new CardDataTable(ds.Tables["Card"]));
         }
         if ((ds.Tables["CardList"] != null)) {
             base.Tables.Add(new CardListDataTable(ds.Tables["CardList"]));
         }
         if ((ds.Tables["CardListData"] != null)) {
             base.Tables.Add(new CardListDataDataTable(ds.Tables["CardListData"]));
         }
         if ((ds.Tables["Collection"] != null)) {
             base.Tables.Add(new CollectionDataTable(ds.Tables["Collection"]));
         }
         if ((ds.Tables["SoundClip"] != null)) {
             base.Tables.Add(new SoundClipDataTable(ds.Tables["SoundClip"]));
         }
         if ((ds.Tables["Dictionary"] != null)) {
             base.Tables.Add(new DictionaryDataTable(ds.Tables["Dictionary"]));
         }
         if ((ds.Tables["RecentPlaylist"] != null)) {
             base.Tables.Add(new RecentPlaylistDataTable(ds.Tables["RecentPlaylist"]));
         }
         if ((ds.Tables["Picture"] != null)) {
             base.Tables.Add(new PictureDataTable(ds.Tables["Picture"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
Example #15
0
 protected DataSet1(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["viewPayrollByInstructor"] != null)) {
             base.Tables.Add(new viewPayrollByInstructorDataTable(ds.Tables["viewPayrollByInstructor"]));
         }
         if ((ds.Tables["GetPayrollByInstructor"] != null)) {
             base.Tables.Add(new GetPayrollByInstructorDataTable(ds.Tables["GetPayrollByInstructor"]));
         }
         if ((ds.Tables["viewInstructorPaymentDetails"] != null)) {
             base.Tables.Add(new viewInstructorPaymentDetailsDataTable(ds.Tables["viewInstructorPaymentDetails"]));
         }
         if ((ds.Tables["viewSimpleProgramInfo"] != null)) {
             base.Tables.Add(new viewSimpleProgramInfoDataTable(ds.Tables["viewSimpleProgramInfo"]));
         }
         if ((ds.Tables["ViewProgramReport"] != null)) {
             base.Tables.Add(new ViewProgramReportDataTable(ds.Tables["ViewProgramReport"]));
         }
         if ((ds.Tables["viewProgramReportClassDetails"] != null)) {
             base.Tables.Add(new viewProgramReportClassDetailsDataTable(ds.Tables["viewProgramReportClassDetails"]));
         }
         if ((ds.Tables["PivotReport"] != null)) {
             base.Tables.Add(new PivotReportDataTable(ds.Tables["PivotReport"]));
         }
         if ((ds.Tables["viewPivotCourseDetails"] != null)) {
             base.Tables.Add(new viewPivotCourseDetailsDataTable(ds.Tables["viewPivotCourseDetails"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected datasetRetailStore(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["Warehouse"] != null)) {
             base.Tables.Add(new WarehouseDataTable(ds.Tables["Warehouse"]));
         }
         if ((ds.Tables["Stock"] != null)) {
             base.Tables.Add(new StockDataTable(ds.Tables["Stock"]));
         }
         if ((ds.Tables["Vendor"] != null)) {
             base.Tables.Add(new VendorDataTable(ds.Tables["Vendor"]));
         }
         if ((ds.Tables["Purchase"] != null)) {
             base.Tables.Add(new PurchaseDataTable(ds.Tables["Purchase"]));
         }
         if ((ds.Tables["Product"] != null)) {
             base.Tables.Add(new ProductDataTable(ds.Tables["Product"]));
         }
         if ((ds.Tables["Customer"] != null)) {
             base.Tables.Add(new CustomerDataTable(ds.Tables["Customer"]));
         }
         if ((ds.Tables["Sales"] != null)) {
             base.Tables.Add(new SalesDataTable(ds.Tables["Sales"]));
         }
         if ((ds.Tables["Purchase Reciept"] != null)) {
             base.Tables.Add(new Purchase_RecieptDataTable(ds.Tables["Purchase Reciept"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected LfsAssetsTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["LFS_ASSET"] != null)) {
             base.Tables.Add(new LFS_ASSETDataTable(ds.Tables["LFS_ASSET"]));
         }
         if ((ds.Tables["LFS_ASSET_SEWER"] != null)) {
             base.Tables.Add(new LFS_ASSET_SEWERDataTable(ds.Tables["LFS_ASSET_SEWER"]));
         }
         if ((ds.Tables["LFS_ASSET_SEWER_LATERAL"] != null)) {
             base.Tables.Add(new LFS_ASSET_SEWER_LATERALDataTable(ds.Tables["LFS_ASSET_SEWER_LATERAL"]));
         }
         if ((ds.Tables["LFS_ASSET_SEWER_LATERAL_CLIENT"] != null)) {
             base.Tables.Add(new LFS_ASSET_SEWER_LATERAL_CLIENTDataTable(ds.Tables["LFS_ASSET_SEWER_LATERAL_CLIENT"]));
         }
         if ((ds.Tables["LFS_ASSET_SEWER_SECTION"] != null)) {
             base.Tables.Add(new LFS_ASSET_SEWER_SECTIONDataTable(ds.Tables["LFS_ASSET_SEWER_SECTION"]));
         }
         if ((ds.Tables["LFS_ASSET_SEWER_SECTION_THICKNESS"] != null)) {
             base.Tables.Add(new LFS_ASSET_SEWER_SECTION_THICKNESSDataTable(ds.Tables["LFS_ASSET_SEWER_SECTION_THICKNESS"]));
         }
         if ((ds.Tables["LFS_ASSET_SEWER_MH"] != null)) {
             base.Tables.Add(new LFS_ASSET_SEWER_MHDataTable(ds.Tables["LFS_ASSET_SEWER_MH"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected UnitsTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["LFS_FM_UNIT_COST_HISTORY"] != null)) {
             base.Tables.Add(new LFS_FM_UNIT_COST_HISTORYDataTable(ds.Tables["LFS_FM_UNIT_COST_HISTORY"]));
         }
         if ((ds.Tables["LFS_FM_UNIT_COST_HISTORY_EXCEPTIONS"] != null)) {
             base.Tables.Add(new LFS_FM_UNIT_COST_HISTORY_EXCEPTIONSDataTable(ds.Tables["LFS_FM_UNIT_COST_HISTORY_EXCEPTIONS"]));
         }
         if ((ds.Tables["LFS_FM_UNIT"] != null)) {
             base.Tables.Add(new LFS_FM_UNITDataTable(ds.Tables["LFS_FM_UNIT"]));
         }
         if ((ds.Tables["LFS_FM_UNIT_NOTE"] != null)) {
             base.Tables.Add(new LFS_FM_UNIT_NOTEDataTable(ds.Tables["LFS_FM_UNIT_NOTE"]));
         }
         if ((ds.Tables["LFS_FM_UNIT_CATEGORY"] != null)) {
             base.Tables.Add(new LFS_FM_UNIT_CATEGORYDataTable(ds.Tables["LFS_FM_UNIT_CATEGORY"]));
         }
         if ((ds.Tables["LFS_FM_UNIT_INSPECTION"] != null)) {
             base.Tables.Add(new LFS_FM_UNIT_INSPECTIONDataTable(ds.Tables["LFS_FM_UNIT_INSPECTION"]));
         }
         if ((ds.Tables["LFS_FM_UNIT_VEHICLE"] != null)) {
             base.Tables.Add(new LFS_FM_UNIT_VEHICLEDataTable(ds.Tables["LFS_FM_UNIT_VEHICLE"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
Example #19
0
 protected Adjudication(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["AdjudicationRequest"] != null)) {
             base.Tables.Add(new AdjudicationRequestDataTable(ds.Tables["AdjudicationRequest"]));
         }
         if ((ds.Tables["ValuationForm"] != null)) {
             base.Tables.Add(new ValuationFormDataTable(ds.Tables["ValuationForm"]));
         }
         if ((ds.Tables["AdjudicationFeeDetails"] != null)) {
             base.Tables.Add(new AdjudicationFeeDetailsDataTable(ds.Tables["AdjudicationFeeDetails"]));
         }
         if ((ds.Tables["DocumentChecklistTable"] != null)) {
             base.Tables.Add(new DocumentChecklistTableDataTable(ds.Tables["DocumentChecklistTable"]));
         }
         if ((ds.Tables["FeeMaster"] != null)) {
             base.Tables.Add(new FeeMasterDataTable(ds.Tables["FeeMaster"]));
         }
         if ((ds.Tables["DocumentMaster"] != null)) {
             base.Tables.Add(new DocumentMasterDataTable(ds.Tables["DocumentMaster"]));
         }
         if ((ds.Tables["ValuationSheet"] != null)) {
             base.Tables.Add(new ValuationSheetDataTable(ds.Tables["ValuationSheet"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected FullLengthLiningTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["WorkDetails"] != null)) {
             base.Tables.Add(new WorkDetailsDataTable(ds.Tables["WorkDetails"]));
         }
         if ((ds.Tables["SectionDetails"] != null)) {
             base.Tables.Add(new SectionDetailsDataTable(ds.Tables["SectionDetails"]));
         }
         if ((ds.Tables["LateralDetails"] != null)) {
             base.Tables.Add(new LateralDetailsDataTable(ds.Tables["LateralDetails"]));
         }
         if ((ds.Tables["CommentDetails"] != null)) {
             base.Tables.Add(new CommentDetailsDataTable(ds.Tables["CommentDetails"]));
         }
         if ((ds.Tables["AllComments"] != null)) {
             base.Tables.Add(new AllCommentsDataTable(ds.Tables["AllComments"]));
         }
         if ((ds.Tables["WetOutCommentsDetails"] != null)) {
             base.Tables.Add(new WetOutCommentsDetailsDataTable(ds.Tables["WetOutCommentsDetails"]));
         }
         if ((ds.Tables["WetOutCatalystsDetails"] != null)) {
             base.Tables.Add(new WetOutCatalystsDetailsDataTable(ds.Tables["WetOutCatalystsDetails"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected other_ds(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["tblIller"] != null)) {
             base.Tables.Add(new tblIllerDataTable(ds.Tables["tblIller"]));
         }
         if ((ds.Tables["tblSaglikTesisiList"] != null)) {
             base.Tables.Add(new tblSaglikTesisiListDataTable(ds.Tables["tblSaglikTesisiList"]));
         }
         if ((ds.Tables["st_iller"] != null)) {
             base.Tables.Add(new st_illerDataTable(ds.Tables["st_iller"]));
         }
         if ((ds.Tables["st_kamu_ozel"] != null)) {
             base.Tables.Add(new st_kamu_ozelDataTable(ds.Tables["st_kamu_ozel"]));
         }
         if ((ds.Tables["st_tesis_turleri"] != null)) {
             base.Tables.Add(new st_tesis_turleriDataTable(ds.Tables["st_tesis_turleri"]));
         }
         if ((ds.Tables["st_tesisler"] != null)) {
             base.Tables.Add(new st_tesislerDataTable(ds.Tables["st_tesisler"]));
         }
         if ((ds.Tables["tblDoktorList"] != null)) {
             base.Tables.Add(new tblDoktorListDataTable(ds.Tables["tblDoktorList"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected WhatsnewDataSet(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["search_eip_t_whatsnew"] != null)) {
             base.Tables.Add(new search_eip_t_whatsnewDataTable(ds.Tables["search_eip_t_whatsnew"]));
         }
         if ((ds.Tables["eip_t_whatsnew_blog"] != null)) {
             base.Tables.Add(new eip_t_whatsnew_blogDataTable(ds.Tables["eip_t_whatsnew_blog"]));
         }
         if ((ds.Tables["eip_t_whatsnew_blog_comment"] != null)) {
             base.Tables.Add(new eip_t_whatsnew_blog_commentDataTable(ds.Tables["eip_t_whatsnew_blog_comment"]));
         }
         if ((ds.Tables["eip_t_whatsnew_workflow"] != null)) {
             base.Tables.Add(new eip_t_whatsnew_workflowDataTable(ds.Tables["eip_t_whatsnew_workflow"]));
         }
         if ((ds.Tables["eip_t_whatsnew_schedule"] != null)) {
             base.Tables.Add(new eip_t_whatsnew_scheduleDataTable(ds.Tables["eip_t_whatsnew_schedule"]));
         }
         if ((ds.Tables["eip_t_whatsnew_memo"] != null)) {
             base.Tables.Add(new eip_t_whatsnew_memoDataTable(ds.Tables["eip_t_whatsnew_memo"]));
         }
         if ((ds.Tables["eip_t_whatsnew_msgboard"] != null)) {
             base.Tables.Add(new eip_t_whatsnew_msgboardDataTable(ds.Tables["eip_t_whatsnew_msgboard"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected DescriptionPokemon(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["POKEMON"] != null)) {
             base.Tables.Add(new POKEMONDataTable(ds.Tables["POKEMON"]));
         }
         if ((ds.Tables["EFFORT_POINT"] != null)) {
             base.Tables.Add(new EFFORT_POINTDataTable(ds.Tables["EFFORT_POINT"]));
         }
         if ((ds.Tables["CAPACITE"] != null)) {
             base.Tables.Add(new CAPACITEDataTable(ds.Tables["CAPACITE"]));
         }
         if ((ds.Tables["CAPACITESPE"] != null)) {
             base.Tables.Add(new CAPACITESPEDataTable(ds.Tables["CAPACITESPE"]));
         }
         if ((ds.Tables["EVOLUTION"] != null)) {
             base.Tables.Add(new EVOLUTIONDataTable(ds.Tables["EVOLUTION"]));
         }
         if ((ds.Tables["DEPENDEVO"] != null)) {
             base.Tables.Add(new DEPENDEVODataTable(ds.Tables["DEPENDEVO"]));
         }
         if ((ds.Tables["FORME_PRIMAIRE"] != null)) {
             base.Tables.Add(new FORME_PRIMAIREDataTable(ds.Tables["FORME_PRIMAIRE"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
Example #24
0
 protected f00_ds(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["tblDoktorBilgisiDVO"] != null)) {
             base.Tables.Add(new tblDoktorBilgisiDVODataTable(ds.Tables["tblDoktorBilgisiDVO"]));
         }
         if ((ds.Tables["tblTaniBilgisiDVO"] != null)) {
             base.Tables.Add(new tblTaniBilgisiDVODataTable(ds.Tables["tblTaniBilgisiDVO"]));
         }
         if ((ds.Tables["tblHastaYatisBilgisi"] != null)) {
             base.Tables.Add(new tblHastaYatisBilgisiDataTable(ds.Tables["tblHastaYatisBilgisi"]));
         }
         if ((ds.Tables["tblCocukBilgisi"] != null)) {
             base.Tables.Add(new tblCocukBilgisiDataTable(ds.Tables["tblCocukBilgisi"]));
         }
         if ((ds.Tables["tblMalzemeBilgisi"] != null)) {
             base.Tables.Add(new tblMalzemeBilgisiDataTable(ds.Tables["tblMalzemeBilgisi"]));
         }
         if ((ds.Tables["tblTedaviIslemBilgisi"] != null)) {
             base.Tables.Add(new tblTedaviIslemBilgisiDataTable(ds.Tables["tblTedaviIslemBilgisi"]));
         }
         if ((ds.Tables["tblBransGorusBilgisi"] != null)) {
             base.Tables.Add(new tblBransGorusBilgisiDataTable(ds.Tables["tblBransGorusBilgisi"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
Example #25
0
 protected ReportDataSet(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.ExcludeSchema)) {
             this.InitExpressions();
         }
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["FinishedWorksheetReportSource"] != null)) {
             base.Tables.Add(new FinishedWorksheetReportSourceDataTable(ds.Tables["FinishedWorksheetReportSource"]));
         }
         if ((ds.Tables["UnfinishedWorksheetReportSource"] != null)) {
             base.Tables.Add(new UnfinishedWorksheetReportSourceDataTable(ds.Tables["UnfinishedWorksheetReportSource"]));
         }
         if ((ds.Tables["UnitPriceReport"] != null)) {
             base.Tables.Add(new UnitPriceReportDataTable(ds.Tables["UnitPriceReport"]));
         }
         if ((ds.Tables["LineLaborHourReportSource"] != null)) {
             base.Tables.Add(new LineLaborHourReportSourceDataTable(ds.Tables["LineLaborHourReportSource"]));
         }
         if ((ds.Tables["InspectListReport"] != null)) {
             base.Tables.Add(new InspectListReportDataTable(ds.Tables["InspectListReport"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         this.InitExpressions();
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected ActualCostsTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_SUBCONTRACTOR_COSTS"] != null)) {
             base.Tables.Add(new LFS_LABOUR_HOURS_ACTUAL_COSTS_SUBCONTRACTOR_COSTSDataTable(ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_SUBCONTRACTOR_COSTS"]));
         }
         if ((ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_CATEGORY"] != null)) {
             base.Tables.Add(new LFS_LABOUR_HOURS_ACTUAL_COSTS_CATEGORYDataTable(ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_CATEGORY"]));
         }
         if ((ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_BONDING_COSTS"] != null)) {
             base.Tables.Add(new LFS_LABOUR_HOURS_ACTUAL_COSTS_BONDING_COSTSDataTable(ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_BONDING_COSTS"]));
         }
         if ((ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_HOTEL_COSTS"] != null)) {
             base.Tables.Add(new LFS_LABOUR_HOURS_ACTUAL_COSTS_HOTEL_COSTSDataTable(ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_HOTEL_COSTS"]));
         }
         if ((ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_INSURANCE_COSTS"] != null)) {
             base.Tables.Add(new LFS_LABOUR_HOURS_ACTUAL_COSTS_INSURANCE_COSTSDataTable(ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_INSURANCE_COSTS"]));
         }
         if ((ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_OTHER_COSTS"] != null)) {
             base.Tables.Add(new LFS_LABOUR_HOURS_ACTUAL_COSTS_OTHER_COSTSDataTable(ds.Tables["LFS_LABOUR_HOURS_ACTUAL_COSTS_OTHER_COSTS"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected ActualCostsReportTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["SubcontractorCosts"] != null)) {
             base.Tables.Add(new SubcontractorCostsDataTable(ds.Tables["SubcontractorCosts"]));
         }
         if ((ds.Tables["BondingCosts"] != null)) {
             base.Tables.Add(new BondingCostsDataTable(ds.Tables["BondingCosts"]));
         }
         if ((ds.Tables["InsuranceCosts"] != null)) {
             base.Tables.Add(new InsuranceCostsDataTable(ds.Tables["InsuranceCosts"]));
         }
         if ((ds.Tables["HotelCosts"] != null)) {
             base.Tables.Add(new HotelCostsDataTable(ds.Tables["HotelCosts"]));
         }
         if ((ds.Tables["OtherCosts"] != null)) {
             base.Tables.Add(new OtherCostsDataTable(ds.Tables["OtherCosts"]));
         }
         if ((ds.Tables["PrintActualCostsGeneral"] != null)) {
             base.Tables.Add(new PrintActualCostsGeneralDataTable(ds.Tables["PrintActualCostsGeneral"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
 protected ProjectCombinedCostingSheetAddTDS(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : 
         base(info, context, false) {
     if ((this.IsBinarySerialized(info, context) == true)) {
         this.InitVars(false);
         global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
         this.Tables.CollectionChanged += schemaChangedHandler1;
         this.Relations.CollectionChanged += schemaChangedHandler1;
         return;
     }
     string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
     if ((this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)) {
         global::System.Data.DataSet ds = new global::System.Data.DataSet();
         ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
         if ((ds.Tables["BasicInformation"] != null)) {
             base.Tables.Add(new BasicInformationDataTable(ds.Tables["BasicInformation"]));
         }
         if ((ds.Tables["FunctionList"] != null)) {
             base.Tables.Add(new FunctionListDataTable(ds.Tables["FunctionList"]));
         }
         if ((ds.Tables["LabourHoursInformation"] != null)) {
             base.Tables.Add(new LabourHoursInformationDataTable(ds.Tables["LabourHoursInformation"]));
         }
         if ((ds.Tables["EmployeePayPeriod"] != null)) {
             base.Tables.Add(new EmployeePayPeriodDataTable(ds.Tables["EmployeePayPeriod"]));
         }
         if ((ds.Tables["EmployeeList"] != null)) {
             base.Tables.Add(new EmployeeListDataTable(ds.Tables["EmployeeList"]));
         }
         if ((ds.Tables["OriginalLabourHour"] != null)) {
             base.Tables.Add(new OriginalLabourHourDataTable(ds.Tables["OriginalLabourHour"]));
         }
         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, global::System.Data.MissingSchemaAction.Add);
         this.InitVars();
     }
     else {
         this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
     }
     this.GetSerializationData(info, context);
     global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
     base.Tables.CollectionChanged += schemaChangedHandler;
     this.Relations.CollectionChanged += schemaChangedHandler;
 }
		public void Serialization02Test()
		{

			// Create and initialize formatter:
			Sfmt.Binary.BinaryFormatter formatter = new Sfmt.Binary.BinaryFormatter();
			formatter.AssemblyFormat = Sfmt.FormatterAssemblyStyle.Simple;

			// Create DS:
			global::System.Data.DataSet ds = new global::System.Data.DataSet();
			global::System.Data.DataTable dt = ds.Tables.Add("SomeTable");
			global::System.Data.DataColumn dc1 = dt.Columns.Add("ID", typeof(global::System.Int32));
			ds.AcceptChanges();

			// Create MockableCall:
			MockingProxy callee = new MockingProxy(typeof(Sample.FooBar), null, "m1");
			MockableCall call = new MockableCall(callee, typeof(Sample.FooBar).GetMethod("SomeMethodWithInsAndOuts"), new object[] { 1, 2, null, 3 });

			// Set dataset as callresult:
			call.SetCallResult(ds);

			Assert.IsNotNull(call.ReturnValue, "Test setup failure, test could not even be run !");

			// Serialize call:
			MemoryStream buffer = new MemoryStream();
			formatter.Serialize(buffer, call);

			// Reset buffer:
			buffer.Flush();
			buffer.Position = 0;

			// Deserialize call:
			call = (MockableCall)formatter.Deserialize(buffer);

			// Verify results (expect returnValue to be non-null):
			Assert.IsNotNull(call);
			Assert.IsNotNull(call.ReturnValue, "ReturnValue is null, the old implementation issue has reoccured...");
			Assert.IsTrue(call.ReturnValue is global::System.Data.DataSet, "What the heck ? returnValue should have been a dataset !");
		}
		global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "4.0.0.0")]protected DS_LICENSESOFTWARE(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : base(info, context, false)
		{
			if (this.IsBinarySerialized(info, context) == true)
			{
				this.InitVars(false);
				global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler1 = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
				this.Tables.CollectionChanged += schemaChangedHandler1;
				this.Relations.CollectionChanged += schemaChangedHandler1;
				return ;
			}
			string strSchema = System.Convert.ToString(info.GetValue("XmlSchema", typeof(string)));
			if (this.DetermineSchemaSerializationMode(info, context) == global::System.Data.SchemaSerializationMode.IncludeSchema)
			{
				global::System.Data.DataSet ds = new global::System.Data.DataSet();
				ds.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
				if (!((ds.Tables["LICENSESOFTWARE"]) == null))
				{
					base.Tables.Add(new LICENSESOFTWAREDataTable(ds.Tables["LICENSESOFTWARE"]));
				}
				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, global::System.Data.MissingSchemaAction.Add);
				this.InitVars();
			}
			else
			{
				this.ReadXmlSchema(new global::System.Xml.XmlTextReader(new global::System.IO.StringReader(strSchema)));
			}
			this.GetSerializationData(info, context);
			global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
			base.Tables.CollectionChanged += schemaChangedHandler;
			this.Relations.CollectionChanged += schemaChangedHandler;
		}