context: namespace Votations.NSurvey.Data
  {
      using System;
      using System.Collections;
      using System.ComponentModel;
      using System.Data;
      using System.Diagnostics;
      using System.Globalization;
      using System.IO;
      using System.Reflection;
      using System.Runtime.CompilerServices;
      using System.Runtime.Serialization;
      using System.Xml;
      using System.Xml.Schema;
  
      [Serializable, DesignerCategory("code"), DebuggerStepThrough, ToolboxItem(true)]
      public class MultiLanguageData : DataSet
      {
          private MultiLanguagesDataTable tableMultiLanguages;
  
          public MultiLanguageData()
          {
              this.InitClass();
              CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
              base.Tables.CollectionChanged += handler;
              base.Relations.CollectionChanged += handler;
          }
  
          protected MultiLanguageData(SerializationInfo info, StreamingContext context)
          {
              string s = (string) info.GetValue("XmlSchema", typeof(string));
              if (s != null)
              {
                  DataSet dataSet = new DataSet();
                  dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                  if (dataSet.Tables["MultiLanguages"] != null)
                  {
                      base.Tables.Add(new MultiLanguagesDataTable(dataSet.Tables["MultiLanguages"]));
                  }
                  base.DataSetName = dataSet.DataSetName;
                  base.Prefix = dataSet.Prefix;
                  base.Namespace = dataSet.Namespace;
                  base.Locale = dataSet.Locale;
                  base.CaseSensitive = dataSet.CaseSensitive;
                  base.EnforceConstraints = dataSet.EnforceConstraints;
                  base.Merge(dataSet, false, MissingSchemaAction.Add);
                  this.InitVars();
              }
              else
              {
                  this.InitClass();
              }
              base.GetSerializationData(info, context);
              CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
              base.Tables.CollectionChanged += handler;
              base.Relations.CollectionChanged += handler;
          }
  
          public override DataSet Clone()
          {
              MultiLanguageData data = (MultiLanguageData) base.Clone();
              data.InitVars();
              return data;
          }
  
          protected override XmlSchema GetSchemaSerializable()
          {
              MemoryStream w = new MemoryStream();
              base.WriteXmlSchema(new XmlTextWriter(w, null));
              w.Position = 0L;
              return XmlSchema.Read(new XmlTextReader(w), null);
          }
  
          private void InitClass()
          {
              base.DataSetName = "MultiLanguageData";
              base.Prefix = "";
              base.Namespace = "http://tempuri.org/MultiLanguagesData.xsd";
              base.Locale = new CultureInfo("en-US");
              base.CaseSensitive = false;
              base.EnforceConstraints = true;
              this.tableMultiLanguages = new MultiLanguagesDataTable();
              base.Tables.Add(this.tableMultiLanguages);
          }
  
          internal void InitVars()
          {
              this.tableMultiLanguages = (MultiLanguagesDataTable) base.Tables["MultiLanguages"];
              if (this.tableMultiLanguages != null)
              {
                  this.tableMultiLanguages.InitVars();
              }
          }
  
          protected override void ReadXmlSerializable(XmlReader reader)
          {
              this.Reset();
              DataSet dataSet = new DataSet();
              dataSet.ReadXml(reader);
              if (dataSet.Tables["MultiLanguages"] != null)
              {
                  base.Tables.Add(new MultiLanguagesDataTable(dataSet.Tables["MultiLanguages"]));
              }
              base.DataSetName = dataSet.DataSetName;
              base.Prefix = dataSet.Prefix;
              base.Namespace = dataSet.Namespace;
              base.Locale = dataSet.Locale;
              base.CaseSensitive = dataSet.CaseSensitive;
              base.EnforceConstraints = dataSet.EnforceConstraints;
              base.Merge(dataSet, false, MissingSchemaAction.Add);
              this.InitVars();
          }
  
          private void SchemaChanged(object sender, CollectionChangeEventArgs e)
          {
              if (e.Action == CollectionChangeAction.Remove)
              {
                  this.InitVars();
              }
          }
  
          private bool ShouldSerializeMultiLanguages()
          {
              return false;
          }
  
          protected override bool ShouldSerializeRelations()
          {
              return false;
          }
  
          protected override bool ShouldSerializeTables()
          {
              return false;
          }
  
          [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
          public MultiLanguagesDataTable MultiLanguages
          {
              get
              {
                  return this.tableMultiLanguages;
              }
          }
  
          [DebuggerStepThrough]
          public class MultiLanguagesDataTable : DataTable, IEnumerable
          {
              private DataColumn columnDefaultLanguage;
              private DataColumn columnLanguageCode;
              private DataColumn columnLanguageDescription;
  
              public event MultiLanguageData.MultiLanguagesRowChangeEventHandler MultiLanguagesRowChanged;
  
              public event MultiLanguageData.MultiLanguagesRowChangeEventHandler MultiLanguagesRowChanging;
  
              public event MultiLanguageData.MultiLanguagesRowChangeEventHandler MultiLanguagesRowDeleted;
  
              public event MultiLanguageData.MultiLanguagesRowChangeEventHandler MultiLanguagesRowDeleting;
  
              internal MultiLanguagesDataTable() : base("MultiLanguages")
              {
                  this.InitClass();
              }
  
              internal MultiLanguagesDataTable(DataTable table) : base(table.TableName)
              {
                  if (table.CaseSensitive != table.DataSet.CaseSensitive)
                  {
                      base.CaseSensitive = table.CaseSensitive;
                  }
                  if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                  {
                      base.Locale = table.Locale;
                  }
                  if (table.Namespace != table.DataSet.Namespace)
                  {
                      base.Namespace = table.Namespace;
                  }
                  base.Prefix = table.Prefix;
                  base.MinimumCapacity = table.MinimumCapacity;
                  base.DisplayExpression = table.DisplayExpression;
              }
  
              public void AddMultiLanguagesRow(MultiLanguageData.MultiLanguagesRow row)
              {
                  base.Rows.Add(row);
              }
  
              public MultiLanguageData.MultiLanguagesRow AddMultiLanguagesRow(string LanguageCode, string LanguageDescription, bool DefaultLanguage)
              {
                  MultiLanguageData.MultiLanguagesRow row = (MultiLanguageData.MultiLanguagesRow) base.NewRow();
                  row.ItemArray = new object[] { LanguageCode, LanguageDescription, DefaultLanguage };
                  base.Rows.Add(row);
                  return row;
              }
  
              public override DataTable Clone()
              {
                  MultiLanguageData.MultiLanguagesDataTable table = (MultiLanguageData.MultiLanguagesDataTable) base.Clone();
                  table.InitVars();
                  return table;
              }
  
              protected override DataTable CreateInstance()
              {
                  return new MultiLanguageData.MultiLanguagesDataTable();
              }
  
              public MultiLanguageData.MultiLanguagesRow FindByLanguageCode(string LanguageCode)
              {
                  return (MultiLanguageData.MultiLanguagesRow) base.Rows.Find(new object[] { LanguageCode });
              }
  
              public IEnumerator GetEnumerator()
              {
                  return base.Rows.GetEnumerator();
              }
  
              protected override System.Type GetRowType()
              {
                  return typeof(MultiLanguageData.MultiLanguagesRow);
              }
  
              private void InitClass()
              {
                  this.columnLanguageCode = new DataColumn("LanguageCode", typeof(string), null, MappingType.Element);
                  base.Columns.Add(this.columnLanguageCode);
                  this.columnLanguageDescription = new DataColumn("LanguageDescription", typeof(string), null, MappingType.Element);
                  base.Columns.Add(this.columnLanguageDescription);
                  this.columnDefaultLanguage = new DataColumn("DefaultLanguage", typeof(bool), null, MappingType.Element);
                  base.Columns.Add(this.columnDefaultLanguage);
                  base.Constraints.Add(new UniqueConstraint("MultiLanguageDataKey1", new DataColumn[] { this.columnLanguageCode }, true));
                  this.columnLanguageCode.AllowDBNull = false;
                  this.columnLanguageCode.Unique = true;
              }
  
              internal void InitVars()
              {
  
gt:                 this.columnLanguageCode = base.Columns["LanguageCode"];