File: DbDataAdapter.xml

package info (click to toggle)
mono-reference-assemblies 3.12.1%2Bdfsg-2
links: PTS, VCS
area: main
in suites: stretch
size: 604,240 kB
ctags: 625,505
sloc: cs: 3,967,741; xml: 2,793,081; ansic: 418,042; java: 60,435; sh: 14,833; makefile: 11,576; sql: 7,956; perl: 1,467; cpp: 1,446; yacc: 1,203; python: 598; asm: 422; sed: 16; php: 1
file content (2308 lines) | stat: -rw-r--r-- 195,583 bytes
parent folder | download | duplicates (8)
<?xml version="1.0" encoding="utf-8"?>
<Type Name="DbDataAdapter" FullName="System.Data.Common.DbDataAdapter">
  <TypeSignature Language="C#" Maintainer="auto" Value="public abstract class DbDataAdapter : System.Data.Common.DataAdapter, ICloneable, System.Data.IDbDataAdapter" />
  <AssemblyInfo>
    <AssemblyName>System.Data</AssemblyName>
    <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00]</AssemblyPublicKey>
    <AssemblyVersion>1.0.3300.0</AssemblyVersion>
    <AssemblyVersion>1.0.5000.0</AssemblyVersion>
    <AssemblyVersion>2.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the &lt;link location="node:gtk-sharp/programming/threads"&gt;Gtk# Thread Programming&lt;/link&gt; for details.</ThreadSafetyStatement>
  <Base>
    <BaseTypeName>System.Data.Common.DataAdapter</BaseTypeName>
  </Base>
  <Interfaces>
    <Interface>
      <InterfaceName>System.Data.IDbDataAdapter</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.ICloneable</InterfaceName>
    </Interface>
  </Interfaces>
  <Docs>
    <remarks>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>The <see cref="T:System.Data.Common.DbDataAdapter" /> class inherits from the <see cref="T:System.Data.Common.DataAdapter" /> class and helps a class implement a DataAdapter designed for use with a relational database.</para>
      <para>An application does not create an instance of the <see cref="T:System.Data.Common.DbDataAdapter" /> interface directly, but creates an instance of a class that inherits <see cref="T:System.Data.IDbDataAdapter" /> and <see cref="T:System.Data.Common.DbDataAdapter" />.</para>
      <para>Classes that inherit <see cref="T:System.Data.Common.DbDataAdapter" /> must implement the inherited members, and typically define additional members to add provider-specific functionality. For example, the <see cref="T:System.Data.Common.DbDataAdapter" /> class defines the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> property, and the <see cref="T:System.Data.Common.DbDataAdapter" /> interface defines eight overloads of the <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> method. In turn, the <see cref="T:System.Data.OleDb.OleDbDataAdapter" /> class inherits the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method, and also defines two additional overloads of <see cref="M:System.Data.OleDb.OleDbDataAdapter.Fill(System.Data.DataTable,System.Object)" /> that take an ADO Recordset object as a parameter.</para>
    </remarks>
    <summary>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>Aids implementation of the <see cref="T:System.Data.IDbDataAdapter" /> interface. Inheritors of <see cref="T:System.Data.Common.DbDataAdapter" /> implement a set of functions to provide strong typing, but inherit most of the functionality needed to fully implement a DataAdapter. </para>
    </summary>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected DbDataAdapter ();" />
      <MemberType>Constructor</MemberType>
      <ReturnValue />
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When you create an instance of <see cref="T:System.Data.Common.DbDataAdapter" />, the following read/write properties are set to the following initial values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Properties </para>
                </term>
                <description>
                  <para>Initial value </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>
                  <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> </para>
              </term>
              <description>
                <para>A new <see cref="T:System.Data.IDbCommand" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Data.IDbDataAdapter.InsertCommand" /> </para>
              </term>
              <description>
                <para>A new <see cref="T:System.Data.IDbCommand" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Data.IDbDataAdapter.DeleteCommand" /> </para>
              </term>
              <description>
                <para>A new <see cref="T:System.Data.IDbCommand" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Data.IDbDataAdapter.UpdateCommand" /> </para>
              </term>
              <description>
                <para>A new <see cref="T:System.Data.IDbCommand" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Data.Common.DataAdapter.MissingMappingAction" /> </para>
              </term>
              <description>
                <para>MissingMappingAction.Passthrough </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Data.Common.DataAdapter.MissingSchemaAction" /> </para>
              </term>
              <description>
                <para>MissingSchemaAction.Add </para>
              </description>
            </item>
          </list>
          <para>You can change the value of any of these properties through a separate call to the property.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of a DataAdapter class.</para>
        </summary>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected DbDataAdapter (System.Data.Common.DbDataAdapter adapter);" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="adapter" Type="System.Data.Common.DbDataAdapter" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This overload of the <see cref="T:System.Data.Common.DbDataAdapter" /> constructor is designed for use by a .NET Framework data provider when implementing a similar constructor for use in a clone implementation.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of a DataAdapter class from an existing object of the same type.</para>
        </summary>
        <param name="adapter">
          <attribution license="cc4" from="Microsoft" modified="false" />A DataAdapter object used to create the new DataAdapter. </param>
      </Docs>
    </Member>
    <Member MemberName="AddToBatch">
      <MemberSignature Language="C#" Value="protected virtual int AddToBatch (System.Data.IDbCommand command);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="command" Type="System.Data.IDbCommand" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>In <see cref="T:System.Data.Common.DbDataAdapter" />, this method throws <see cref="T:System.NotSupportedException" />. Classes that inherit from <see cref="T:System.Data.Common.DbDataAdapter" /> override this method to provide support for batches.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds a <see cref="T:System.Data.IDbCommand" /> to the current batch.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of commands in the batch before adding the <see cref="T:System.Data.IDbCommand" />.</para>
        </returns>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.IDbCommand" /> to add to the batch.</param>
      </Docs>
    </Member>
    <Member MemberName="ClearBatch">
      <MemberSignature Language="C#" Value="protected virtual void ClearBatch ();" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>In <see cref="T:System.Data.Common.DbDataAdapter" />, this method throws <see cref="T:System.NotSupportedException" />. Classes that inherit from <see cref="T:System.Data.Common.DbDataAdapter" /> override this method to provide support for batches.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Removes all <see cref="T:System.Data.IDbCommand" /> objects from the batch.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="CreateRowUpdatedEvent">
      <MemberSignature Language="C#" Value="protected virtual System.Data.Common.RowUpdatedEventArgs CreateRowUpdatedEvent (System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.Common.RowUpdatedEventArgs</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataRow" Type="System.Data.DataRow" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="statementType" Type="System.Data.StatementType" />
        <Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
      </Parameters>
      <Docs>
        <remarks>To be added</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> class.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A new instance of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> class.</para>
        </returns>
        <param name="dataRow">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataRow" /> used to update the data source. </param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.IDbCommand" /> executed during the <see cref="M:System.Data.IDataAdapter.Update(System.Data.DataSet)" />. </param>
        <param name="statementType">
          <attribution license="cc4" from="Microsoft" modified="false" />Whether the command is an UPDATE, INSERT, DELETE, or SELECT statement. </param>
        <param name="tableMapping">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.Common.DataTableMapping" /> object. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="CreateRowUpdatingEvent">
      <MemberSignature Language="C#" Value="protected virtual System.Data.Common.RowUpdatingEventArgs CreateRowUpdatingEvent (System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.Common.RowUpdatingEventArgs</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataRow" Type="System.Data.DataRow" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="statementType" Type="System.Data.StatementType" />
        <Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
      </Parameters>
      <Docs>
        <remarks>To be added</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Data.Common.RowUpdatingEventArgs" /> class.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A new instance of the <see cref="T:System.Data.Common.RowUpdatingEventArgs" /> class.</para>
        </returns>
        <param name="dataRow">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataRow" /> that updates the data source. </param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.IDbCommand" /> to execute during the <see cref="M:System.Data.IDataAdapter.Update(System.Data.DataSet)" />. </param>
        <param name="statementType">
          <attribution license="cc4" from="Microsoft" modified="false" />Whether the command is an UPDATE, INSERT, DELETE, or SELECT statement. </param>
        <param name="tableMapping">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.Common.DataTableMapping" /> object. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="DefaultSourceTableName">
      <MemberSignature Language="C#" Value="public const string DefaultSourceTableName;" />
      <MemberType>Field</MemberType>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>"Table" is the default name used by the <see cref="T:System.Data.Common.DataAdapter" /> object for table mappings.</para>
          <para>
            <see cref="F:System.Data.Common.DbDataAdapter.DefaultSourceTableName" /> is when an application adds a table mapping to be used with <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" />, but does not specify a <see cref="T:System.Data.DataTable" /> name.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The default name used by the <see cref="T:System.Data.Common.DataAdapter" /> object for table mappings.</para>
        </summary>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="DeleteCommand">
      <MemberSignature Language="C#" Value="public System.Data.Common.DbCommand DeleteCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Data.Common.DbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>During <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, if this property is not set and primary key information is present in the <see cref="T:System.Data.DataSet" />, the <see cref="P:System.Data.IDbDataAdapter.DeleteCommand" /> is automatically generated.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a command for deleting records from the data set.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Dispose">
      <MemberSignature Language="C#" Value="protected override void Dispose (bool disposing);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="disposing" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <remarks>To be added</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Releases the unmanaged resources used by the <see cref="T:System.Data.Common.DbDataAdapter" /> and optionally releases the managed resources.</para>
        </summary>
        <param name="disposing">
          <attribution license="cc4" from="Microsoft" modified="false" />true to release both managed and unmanaged resources; false to release only unmanaged resources. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="ExecuteBatch">
      <MemberSignature Language="C#" Value="protected virtual int ExecuteBatch ();" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>In <see cref="T:System.Data.Common.DbDataAdapter" />, this method throws <see cref="T:System.NotSupportedException" />. Classes that inherit from <see cref="T:System.Data.Common.DbDataAdapter" /> override this method to provide support for batches.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Executes the current batch.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The return value from the last command in the batch.</para>
        </returns>
      </Docs>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="public override int Fill (System.Data.DataSet dataSet);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method retrieves the data from the data source using a SELECT statement. The <see cref="T:System.Data.IDbConnection" /> object associated with the select command must be valid, but it does not need to be open. If the <see cref="T:System.Data.IDbConnection" /> is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data and then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted.</para>
          <para>If a command does not return any rows, no tables are added to the <see cref="T:System.Data.DataSet" />, and no exception is raised.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> object encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on.</para>
          <para>When the query specified returns multiple results, the result set for each row returning query is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Because no table is created for a query that does not return rows, if you process an insert query followed by a select query, the table created for the select query is named "Table" because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>When the SELECT statement used to populate the <see cref="T:System.Data.DataSet" /> returns multiple results, such as batch SQL statements, if one of the results contains an error, all subsequent results are skipped and are not added to the <see cref="T:System.Data.DataSet" />.</para>
          <para>When using subsequent <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> calls to refresh the contents of the <see cref="T:System.Data.DataSet" />, two conditions must be met: </para>
          <list type="ordered">
            <item>
              <para>The SQL statement should match the one initially used to populate the <see cref="T:System.Data.DataSet" />.</para>
            </item>
            <item>
              <para>The Key column information must be present.</para>
            </item>
          </list>
          <para>If primary key information is present, any duplicate rows are reconciled and only appear once in the <see cref="T:System.Data.DataTable" /> that corresponds to the <see cref="T:System.Data.DataSet" />. Primary key information may be set either through <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, by specifying the <see cref="P:System.Data.DataTable.PrimaryKey" /> property of the <see cref="T:System.Data.DataTable" />, or by setting the <see cref="P:System.Data.Common.DataAdapter.MissingSchemaAction" /> property to AddWithKey.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see <format type="text/html"><a href="2ea85959-e763-4669-8bd9-46a9dab894bd">Defining a Primary Key for a Table</a></format>.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in the <see cref="T:System.Data.DataSet" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to fill with records and, if necessary, schema. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="public int Fill (System.Data.DataTable dataTable);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTable" Type="System.Data.DataTable" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method retrieves rows from the data source using the SELECT statement specified by an associated <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> property. The connection object associated with the SELECT statement must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> operation then adds the rows to destination <see cref="T:System.Data.DataTable" /> objects in the <see cref="T:System.Data.DataSet" />, creating the <see cref="T:System.Data.DataTable" /> objects if they do not already exist. When creating <see cref="T:System.Data.DataTable" /> objects, the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> operation normally creates only column name metadata. However, if the <see cref="P:System.Data.IDataAdapter.MissingSchemaAction" /> property is set to AddWithKey, appropriate primary keys and constraints are also created.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table.</para>
          <para>The overload of <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> that takes <paramref name="DataTable" /> as a parameter only obtains the first result. Use an overload of <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> that takes <paramref name="DataSet" /> as a parameter to obtain multiple results.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code>DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
    adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code>DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
    adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>You can use the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method multiple times on the same <see cref="T:System.Data.DataTable" />. If a primary key exists, incoming rows are merged with matching rows that already exist. If no primary key exists, incoming rows are appended to the <see cref="T:System.Data.DataTable" />.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see <format type="text/html"><a href="2ea85959-e763-4669-8bd9-46a9dab894bd">Defining a Primary Key for a Table</a></format>.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> and <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for a .NET Framework data provider retrieves schema information for only the first result.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in a specified range in the <see cref="T:System.Data.DataSet" /> to match those in the data source using the <see cref="T:System.Data.DataTable" /> name.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the <see cref="T:System.Data.DataTable" /> to use for table mapping. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="public int Fill (System.Data.DataSet dataSet, string srcTable);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="srcTable" Type="System.String" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method retrieves the data from the data source using a SELECT statement. The <see cref="T:System.Data.IDbConnection" /> object associated with the select command must be valid, but it does not need to be open. If the <see cref="T:System.Data.IDbConnection" /> is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>If a command does not return any rows, no tables are added to the <see cref="T:System.Data.DataSet" />, and no exception is raised.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> object encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on.</para>
          <para>When the query specified returns multiple results, each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Since no table is created for a query that does not return rows, if you were to process an insert query followed by a select query, the table created for the select query would be named "Table", because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
 adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted.</para>
          <para>When the SELECT statement used to populate the <see cref="T:System.Data.DataSet" /> returns multiple results, such as a batch SQL statement, be aware of the following: </para>
          <list type="bullet">
            <item>
              <para>If one of the results contains an error, all subsequent results are skipped and not added to the <see cref="T:System.Data.DataSet" />.</para>
            </item>
          </list>
          <para>When using subsequent <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> calls to refresh the contents of the <see cref="T:System.Data.DataSet" />, two conditions must be met: </para>
          <list type="ordered">
            <item>
              <para>The SQL statement should match the one initially used to populate the <see cref="T:System.Data.DataSet" />.</para>
            </item>
            <item>
              <para>The Key column information must be present. If primary key information is present, any duplicate rows are reconciled and only appear once in the <see cref="T:System.Data.DataTable" /> that corresponds to the <see cref="T:System.Data.DataSet" />. Primary key information may be set either through <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, by specifying the <see cref="P:System.Data.DataTable.PrimaryKey" /> property of the <see cref="T:System.Data.DataTable" />, or by setting the <see cref="P:System.Data.Common.DataAdapter.MissingSchemaAction" /> property to AddWithKey.</para>
            </item>
          </list>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see<format type="text/html"><a href="2ea85959-e763-4669-8bd9-46a9dab894bd"> Defining a Primary Key for a Table</a></format>.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in the <see cref="T:System.Data.DataSet" /> to match those in the data source using the <see cref="T:System.Data.DataSet" /> and <see cref="T:System.Data.DataTable" /> names.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to fill with records and, if necessary, schema. </param>
        <param name="srcTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the source table to use for table mapping. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="protected virtual int Fill (System.Data.DataTable dataTable, System.Data.IDataReader dataReader);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTable" Type="System.Data.DataTable" />
        <Parameter Name="dataReader" Type="System.Data.IDataReader" />
      </Parameters>
      <Docs>
        <param name="dataTable">To be added.</param>
        <param name="dataReader">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="protected virtual int Fill (System.Data.DataTable dataTable, System.Data.IDbCommand command, System.Data.CommandBehavior behavior);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTable" Type="System.Data.DataTable" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="behavior" Type="System.Data.CommandBehavior" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method retrieves rows from the data source using the SELECT statement specified by an associated <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> property. The connection object associated with the SELECT statement must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data and then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> operation then adds the rows to the specified destination <see cref="T:System.Data.DataTable" /> object in the <see cref="T:System.Data.DataSet" />, creating the <see cref="T:System.Data.DataTable" /> object if it does not already exist. When creating a <see cref="T:System.Data.DataTable" /> object, the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> operation normally creates only column name metadata. However, if the <see cref="P:System.Data.IDataAdapter.MissingSchemaAction" /> property is set to AddWithKey, appropriate primary keys and constraints are also created.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> object encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on.</para>
          <para>The overload of <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> that takes <paramref name="DataTable" /> as a parameter only obtains the first result. Use an overload of <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> that takes <paramref name="DataSet" /> as a parameter to obtain multiple results.</para>
          <para>You can use the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method multiple times on the same <see cref="T:System.Data.DataTable" />. If a primary key exists, incoming rows are merged with matching rows that already exist. If no primary key exists, incoming rows are appended to the <see cref="T:System.Data.DataTable" />.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see <format type="text/html"><a href="2ea85959-e763-4669-8bd9-46a9dab894bd">Defining a Primary Key for a Table</a></format>.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in a <see cref="T:System.Data.DataTable" /> to match those in the data source using the specified <see cref="T:System.Data.DataTable" />, <see cref="T:System.Data.IDbCommand" /> and <see cref="T:System.Data.CommandBehavior" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataTable">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataTable" /> to fill with records and, if necessary, schema. </param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The SQL SELECT statement used to retrieve rows from the data source. </param>
        <param name="behavior">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.CommandBehavior" /> values.</param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="public int Fill (int startRecord, int maxRecords, System.Data.DataTable[] dataTables);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="startRecord" Type="System.Int32" />
        <Parameter Name="maxRecords" Type="System.Int32" />
        <Parameter Name="dataTables" Type="System.Data.DataTable[]">
          <Attributes>
            <Attribute>
              <AttributeName>System.ParamArray</AttributeName>
            </Attribute>
          </Attributes>
        </Parameter>
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DataAdapter.Fill(System.Data.DataSet)" /> method retrieves rows from the data source using the SELECT statement specified by an associated <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> property. The connection object associated with the SELECT statement must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data, and then it is closed. If the connection is open before <see cref="M:System.Data.Common.DataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>The <see cref="M:System.Data.Common.DataAdapter.Fill(System.Data.DataSet)" /> operation then adds the rows to destination <see cref="T:System.Data.DataTable" /> objects in the <see cref="T:System.Data.DataSet" />, creating the <see cref="T:System.Data.DataTable" /> objects if they do not already exist. When creating <see cref="T:System.Data.DataTable" /> objects, the <see cref="M:System.Data.Common.DataAdapter.Fill(System.Data.DataSet)" /> operation normally creates only column name metadata. However, if the <see cref="P:System.Data.IDataAdapter.MissingSchemaAction" /> property is set to AddWithKey, appropriate primary keys and constraints are also created.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see <format type="text/html"><a href="2EA85959-E763-4669-8BD9-46A9DAB894BD">Defining a Primary Key for a Table</a></format>.</para>
          <para>If the data adapter encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" />, each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>When the SELECT statement used to populate the <see cref="T:System.Data.DataSet" /> returns multiple results, such as a batch SQL statements, if one of the results contains an error, all subsequent results are skipped and not added to the <see cref="T:System.Data.DataSet" />.</para>
          <para>You can use the <see cref="M:System.Data.Common.DataAdapter.Fill(System.Data.DataSet)" /> method multiple times on the same <see cref="T:System.Data.DataTable" />. If a primary key exists, incoming rows are merged with matching rows that already exist. If no primary key exists, incoming rows are appended to the <see cref="T:System.Data.DataTable" />.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in a <see cref="T:System.Data.DataTable" /> to match those in the data source starting at the specified record and retrieving up to the specified maximum number of records.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable" />. This value does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="startRecord">
          <attribution license="cc4" from="Microsoft" modified="false" />The zero-based record number to start with. </param>
        <param name="maxRecords">
          <attribution license="cc4" from="Microsoft" modified="false" />The maximum number of records to retrieve. </param>
        <param name="dataTables">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataTable" /> objects to fill from the data source.</param>
      </Docs>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="public int Fill (System.Data.DataSet dataSet, int startRecord, int maxRecords, string srcTable);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="startRecord" Type="System.Int32" />
        <Parameter Name="maxRecords" Type="System.Int32" />
        <Parameter Name="srcTable" Type="System.String" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A <paramref name="maxRecords" /> value of 0 gets all records found after the start record. If <paramref name="maxRecords" /> is greater than the number of remaining rows, only the remaining rows are returned, and no error is issued.</para>
          <para>If the corresponding select command is a statement returning multiple results, <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> only applies <paramref name="maxRecords" /> to the first result.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method retrieves the data from the data source using a SELECT statement. The <see cref="T:System.Data.IDbConnection" /> object associated with the SELECT statement must be valid, but it does not need to be open. If the <see cref="T:System.Data.IDbConnection" /> is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data and then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>If a command does not return any rows, no tables are added to the <see cref="T:System.Data.DataSet" />, but no exception is raised.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> object encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on.</para>
          <para>When the query specified returns multiple results, each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Because no table is created for a query that does not return rows, if you process an insert query followed by a select query, the table created for the select query is named "Table", because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code>DataSet dataset = new DataSet();
dataset.Tables.Add("aaa");
dataset.Tables.Add("AAA");
adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code>DataSet dataset = new DataSet();
dataset.Tables.Add("aaa");
adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted.</para>
          <para>When the SELECT statement used to populate the <see cref="T:System.Data.DataSet" /> returns multiple results, such as batch SQL statements, be aware of the following: </para>
          <list type="bullet">
            <item>
              <para>When processing multiple results from a batch SQL statement, <paramref name="maxRecords" /> only applies to the first result. The same is true for rows containing chaptered results (.NET Framework Data Provider for OLE DB only). The top level result is limited by <paramref name="maxRecords" />, but all child rows are added.</para>
            </item>
            <item>
              <para>If one of the results contains an error, all subsequent results are skipped and not added to the <see cref="T:System.Data.DataSet" />.</para>
            </item>
          </list>
          <para>When using subsequent <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> calls to refresh the contents of the <see cref="T:System.Data.DataSet" />, two conditions must be met: </para>
          <list type="ordered">
            <item>
              <para>The SQL statement should match the one initially used to populate the <see cref="T:System.Data.DataSet" />.</para>
            </item>
            <item>
              <para>The Key column information must be present.</para>
            </item>
          </list>
          <para>If primary key information is present, any duplicate rows will be reconciled and only appear once in the <see cref="T:System.Data.DataTable" /> that corresponds to the <see cref="T:System.Data.DataSet" />. Primary key information may be set either through <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, by specifying the <see cref="P:System.Data.DataTable.PrimaryKey" /> property of the <see cref="T:System.Data.DataTable" />, or by setting the <see cref="P:System.Data.Common.DataAdapter.MissingSchemaAction" /> property to AddWithKey.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see <format type="text/html"><a href="2ea85959-e763-4669-8bd9-46a9dab894bd">Defining a Primary Key for a Table</a></format>.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
          <block subset="none" type="note">
            <para>The DataSet will not contain more than the number of records indicated by <paramref name="maxRecords" />. However, the entire result set generated by the query is still returned from the server.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in a specified range in the <see cref="T:System.Data.DataSet" /> to match those in the data source using the <see cref="T:System.Data.DataSet" /> and <see cref="T:System.Data.DataTable" /> names.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to fill with records and, if necessary, schema. </param>
        <param name="startRecord">
          <attribution license="cc4" from="Microsoft" modified="false" />The zero-based record number to start with. </param>
        <param name="maxRecords">
          <attribution license="cc4" from="Microsoft" modified="false" />The maximum number of records to retrieve. </param>
        <param name="srcTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the source table to use for table mapping. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="protected virtual int Fill (System.Data.DataSet dataSet, string srcTable, System.Data.IDataReader dataReader, int startRecord, int maxRecords);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="srcTable" Type="System.String" />
        <Parameter Name="dataReader" Type="System.Data.IDataReader" />
        <Parameter Name="startRecord" Type="System.Int32" />
        <Parameter Name="maxRecords" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="dataSet">To be added: an object of type 'Data.DataSet'</param>
        <param name="srcTable">To be added: an object of type 'string'</param>
        <param name="dataReader">To be added: an object of type 'Data.IDataReader'</param>
        <param name="startRecord">To be added: an object of type 'int'</param>
        <param name="maxRecords">To be added: an object of type 'int'</param>
        <summary>To be added</summary>
        <returns>To be added: an object of type 'int'</returns>
        <remarks>To be added</remarks>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="protected virtual int Fill (System.Data.DataTable[] dataTables, int startRecord, int maxRecords, System.Data.IDbCommand command, System.Data.CommandBehavior behavior);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTables" Type="System.Data.DataTable[]" />
        <Parameter Name="startRecord" Type="System.Int32" />
        <Parameter Name="maxRecords" Type="System.Int32" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="behavior" Type="System.Data.CommandBehavior" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A <paramref name="maxRecords" /> value of 0 gets all records found after the start record. If <paramref name="maxRecords" /> is greater than the number of remaining rows, only the remaining rows are returned and no error is issued.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataTable[],System.Int32,System.Int32,System.Data.IDbCommand,System.Data.CommandBehavior)" /> method retrieves the data from the data source using a SELECT statement. The <see cref="T:System.Data.IDbConnection" /> object associated with the SELECT statement must be valid, but it does not need to be open. If the <see cref="T:System.Data.IDbConnection" /> is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>If a command does not return any rows, no tables are added to the <see cref="T:System.Data.DataSet" />, but no exception is raised.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> object encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on.</para>
          <para>When the query specified returns multiple results, each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Since no table is created for a query that does not return rows, if you were to process an insert query followed by a select query, the table created for the select query would be named "Table", because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataTable[],System.Int32,System.Int32,System.Data.IDbCommand,System.Data.CommandBehavior)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
 adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted.</para>
          <para>When the SELECT statement used to populate the <see cref="T:System.Data.DataTable" /> objects returns multiple results, such as a batch SQL statement, be aware of the following: </para>
          <list type="bullet">
            <item>
              <para>When processing multiple results from a batch SQL statement, <paramref name="maxRecords" /> only applies to the first result. The same is true for rows containing chaptered results (.NET Framework Data Provider for OLE DB only). The top level result is limited by <paramref name="maxRecords" />, but all child rows are added.</para>
            </item>
            <item>
              <para>If one of the results contains an error, all subsequent results are skipped.</para>
            </item>
          </list>
          <block subset="none" type="note">
            <para>The DataSet will not contain more than the number of records indicated by <paramref name="maxRecords" />. However, the entire resultset generated by the query is still returned from the server.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in a specified range in the <see cref="T:System.Data.DataSet" /> to match those in the data source using the <see cref="T:System.Data.DataSet" /> and <see cref="T:System.Data.DataTable" /> names.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows added to or refreshed in the data tables.</para>
        </returns>
        <param name="dataTables">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataTable" /> objects to fill from the data source.</param>
        <param name="startRecord">
          <attribution license="cc4" from="Microsoft" modified="false" />The zero-based record number to start with.</param>
        <param name="maxRecords">
          <attribution license="cc4" from="Microsoft" modified="false" />The maximum number of records to retrieve.</param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.IDbCommand" /> executed to fill the <see cref="T:System.Data.DataTable" /> objects.</param>
        <param name="behavior">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.CommandBehavior" /> values.</param>
      </Docs>
    </Member>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="protected virtual int Fill (System.Data.DataSet dataSet, int startRecord, int maxRecords, string srcTable, System.Data.IDbCommand command, System.Data.CommandBehavior behavior);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="startRecord" Type="System.Int32" />
        <Parameter Name="maxRecords" Type="System.Int32" />
        <Parameter Name="srcTable" Type="System.String" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="behavior" Type="System.Data.CommandBehavior" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method retrieves rows from the data source using the SELECT statement specified by an associated <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> property. The connection object associated with the SELECT statement must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> operation then adds the rows to destination <see cref="T:System.Data.DataTable" /> objects in the <see cref="T:System.Data.DataSet" />, creating the <see cref="T:System.Data.DataTable" /> objects if they do not already exist. When creating <see cref="T:System.Data.DataTable" /> objects, the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> operation normally creates only column name metadata. However, if the <see cref="P:System.Data.IDataAdapter.MissingSchemaAction" /> property is set to AddWithKey, appropriate primary keys and constraints are also created.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
 adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>You can use the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method multiple times on the same <see cref="T:System.Data.DataTable" />. If a primary key exists, incoming rows are merged with matching rows that already exist. If no primary key exists, incoming rows are appended to the <see cref="T:System.Data.DataTable" />.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see<format type="text/html"><a href="2ea85959-e763-4669-8bd9-46a9dab894bd"> Defining a Primary Key for a Table</a></format>.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> and <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for a .NET Framework data provider retrieves schema information for only the first result.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or refreshes rows in a specified range in the <see cref="T:System.Data.DataSet" /> to match those in the data source using the <see cref="T:System.Data.DataSet" /> and source table names, command string, and command behavior.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to fill with records and, if necessary, schema. </param>
        <param name="startRecord">
          <attribution license="cc4" from="Microsoft" modified="false" />The zero-based record number to start with. </param>
        <param name="maxRecords">
          <attribution license="cc4" from="Microsoft" modified="false" />The maximum number of records to retrieve. </param>
        <param name="srcTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the source table to use for table mapping. </param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The SQL SELECT statement used to retrieve rows from the data source. </param>
        <param name="behavior">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.CommandBehavior" /> values. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FillCommandBehavior">
      <MemberSignature Language="C#" Value="protected System.Data.CommandBehavior FillCommandBehavior { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Data.CommandBehavior</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets the behavior of the command used to fill the data adapter.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="FillError">
      <MemberSignature Language="C#" Value="public event System.Data.FillErrorEventHandler FillError;" />
      <MemberType>Event</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.FillErrorEventHandler</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>To be added</summary>
        <remarks>To be added</remarks>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Data.DataSysDescription(Description="Event triggered when a recoverable error occurs during Fill.")</AttributeName>
        </Attribute>
      </Attributes>
    </Member>
    <Member MemberName="FillSchema">
      <MemberSignature Language="C#" Value="public override System.Data.DataTable[] FillSchema (System.Data.DataSet dataSet, System.Data.SchemaType schemaType);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.DataTable[]</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="schemaType" Type="System.Data.SchemaType" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This method retrieves the schema information from the data source using the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />.</para>
          <para>A <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> operation adds a <see cref="T:System.Data.DataTable" /> to the destination <see cref="T:System.Data.DataSet" />. It then adds columns to the <see cref="T:System.Data.DataColumnCollection" /> of the <see cref="T:System.Data.DataTable" />, and configures the following <see cref="T:System.Data.DataColumn" /> properties if they exist at the data source: </para>
          <list type="bullet">
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AllowDBNull" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AutoIncrement" />. You must set <see cref="P:System.Data.DataColumn.AutoIncrementStep" /> and <see cref="P:System.Data.DataColumn.AutoIncrementSeed" /> separately.</para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.MaxLength" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.ReadOnly" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.Unique" /> </para>
            </item>
          </list>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> also configures the <see cref="P:System.Data.DataTable.PrimaryKey" /> and <see cref="P:System.Data.DataTable.Constraints" /> properties according to the following rules: </para>
          <list type="bullet">
            <item>
              <para>If one or more primary key columns are returned by the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />, they are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
            <item>
              <para>If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a <see cref="T:System.Data.UniqueConstraint" /> is added to the <see cref="T:System.Data.ConstraintCollection" />, but the <see cref="P:System.Data.DataTable.PrimaryKey" /> property is not set.</para>
            </item>
            <item>
              <para>If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
          </list>
          <para>Note that primary keys and unique constraints are added to the <see cref="T:System.Data.ConstraintCollection" /> according to the preceding rules, but other constraint types are not added.</para>
          <para>If a unique clustered index is defined on a column or columns in a SQL Server table and the primary key constraint is defined on a separate set of columns, then the names of the columns in the clustered index will be returned. To return the name or names of the primary key columns, use a query hint with the SELECT statement that specifies the name of the primary key index. For more information about specifying query hints, see <see cref="http://msdn.microsoft.com/library/ms181714.aspx">Query Hint (Transact-SQL)</see>.</para>
          <para>Primary key information is used during <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> to find and replace any rows whose key columns match. If this is not the desired behavior, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> without requesting schema information.</para>
          <para>If the <see cref="T:System.Data.IDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on.). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="T:System.Data.IDbConnection" /> object associated with the select command must be valid, but it does not need to open. If the <see cref="T:System.Data.IDbConnection" /> is closed before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is left open.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds a <see cref="T:System.Data.DataTable" /> named "Table" to the specified <see cref="T:System.Data.DataSet" /> and configures the schema to match that in the data source based on the specified <see cref="T:System.Data.SchemaType" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A reference to a collection of <see cref="T:System.Data.DataTable" /> objects that were added to the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to insert the schema in. </param>
        <param name="schemaType">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.SchemaType" /> values that specify how to insert the schema. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FillSchema">
      <MemberSignature Language="C#" Value="public System.Data.DataTable FillSchema (System.Data.DataTable dataTable, System.Data.SchemaType schemaType);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.DataTable</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTable" Type="System.Data.DataTable" />
        <Parameter Name="schemaType" Type="System.Data.SchemaType" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> method retrieves the schema from the data source using the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />. The connection object associated with the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it remains open.</para>
          <para>A <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> operation returns a <see cref="T:System.Data.DataTable" />. It then adds columns to the <see cref="T:System.Data.DataColumnCollection" /> of the <see cref="T:System.Data.DataTable" />, and configures the following <see cref="T:System.Data.DataColumn" /> properties if they exist at the data source: </para>
          <list type="bullet">
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AllowDBNull" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AutoIncrement" />. You must set <see cref="P:System.Data.DataColumn.AutoIncrementStep" /> and <see cref="P:System.Data.DataColumn.AutoIncrementSeed" /> separately.</para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.MaxLength" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.ReadOnly" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.Unique" /> </para>
            </item>
          </list>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> also configures the <see cref="P:System.Data.DataTable.PrimaryKey" /> and <see cref="P:System.Data.DataTable.Constraints" /> properties according to the following rules: </para>
          <list type="bullet">
            <item>
              <para>If a <see cref="P:System.Data.DataTable.PrimaryKey" /> has already been defined for the DataTable, or the DataTable contains data, the PrimaryKey property will not be set.</para>
            </item>
            <item>
              <para>If one or more primary key columns are returned by the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />, they are used as the primary key columns for the DataTable.</para>
            </item>
            <item>
              <para>If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a <see cref="T:System.Data.UniqueConstraint" /> is added to the <see cref="T:System.Data.ConstraintCollection" />, but the PrimaryKey property is not set.</para>
            </item>
            <item>
              <para>If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the DataTable.</para>
            </item>
          </list>
          <para>Note that primary keys and unique constraints are added to the <see cref="T:System.Data.ConstraintCollection" /> according to the preceding rules, but other constraint types are not added. This process may require several round-trips to the server.</para>
          <para>If a unique clustered index is defined on a column or columns in a SQL Server table and the primary key constraint is defined on a separate set of columns, then the names of the columns in the clustered index will be returned. To return the name or names of the primary key columns, use a query hint with the SELECT statement that specifies the name of the primary key index. For more information about specifying query hints, see <see cref="http://msdn.microsoft.com/library/ms181714.aspx">Query Hint (Transact-SQL)</see>.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on.). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> does not return any rows. Use the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method to add rows to a <see cref="T:System.Data.DataTable" />.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Configures the schema of the specified <see cref="T:System.Data.DataTable" /> based on the specified <see cref="T:System.Data.SchemaType" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A <see cref="T:System.Data.DataTable" /> that contains schema information returned from the data source.</para>
        </returns>
        <param name="dataTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataTable" /> to be filled with the schema from the data source. </param>
        <param name="schemaType">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.SchemaType" /> values. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FillSchema">
      <MemberSignature Language="C#" Value="public System.Data.DataTable[] FillSchema (System.Data.DataSet dataSet, System.Data.SchemaType schemaType, string srcTable);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.DataTable[]</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="schemaType" Type="System.Data.SchemaType" />
        <Parameter Name="srcTable" Type="System.String" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This method retrieves the schema information from the data source using the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />.</para>
          <para>A <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> operation adds a <see cref="T:System.Data.DataTable" /> to the destination <see cref="T:System.Data.DataSet" />. It then adds columns to the <see cref="T:System.Data.DataColumnCollection" /> of the <see cref="T:System.Data.DataTable" />, and configures the following <see cref="T:System.Data.DataColumn" /> properties if they exist at the data source: </para>
          <list type="bullet">
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AllowDBNull" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AutoIncrement" />. You must set <see cref="P:System.Data.DataColumn.AutoIncrementStep" /> and <see cref="P:System.Data.DataColumn.AutoIncrementSeed" /> separately.</para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.MaxLength" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.ReadOnly" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.Unique" /> </para>
            </item>
          </list>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> also configures the <see cref="P:System.Data.DataTable.PrimaryKey" /> and <see cref="P:System.Data.DataTable.Constraints" /> properties according to the following rules: </para>
          <list type="bullet">
            <item>
              <para>If one or more primary key columns are returned by the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />, they are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
            <item>
              <para>If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a <see cref="T:System.Data.UniqueConstraint" /> is added to the <see cref="T:System.Data.ConstraintCollection" />, but the <see cref="P:System.Data.DataTable.PrimaryKey" /> property is not set.</para>
            </item>
            <item>
              <para>If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
          </list>
          <para>Note that primary keys and unique constraints are added to the <see cref="T:System.Data.ConstraintCollection" /> according to the preceding rules, but other constraint types are not added.</para>
          <para>If a unique clustered index is defined on a column or columns in a SQL Server table and the primary key constraint is defined on a separate set of columns, then the names of the columns in the clustered index will be returned. To return the name or names of the primary key columns, use a query hint with the SELECT statement that specifies the name of the primary key index. For more information about specifying query hints, see <see cref="http://msdn.microsoft.com/library/ms181714.aspx">Query Hint (Transact-SQL)</see>.</para>
          <para>Primary key information is used during <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> to find and replace any rows whose key columns match. If this is not the desired behavior, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> without requesting schema information.</para>
          <para>If the <see cref="T:System.Data.Common.DbDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on.). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.FillSchema(dataset, "aaa"); // Fills the schema of "aaa", which already exists in the DataSet.
 adapter.FillSchema(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.FillSchema(dataset, "AAA"); // Fills the schema of table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>The <see cref="T:System.Data.IDbConnection" /> object associated with the select command must be valid, but it does not need to open. If the <see cref="T:System.Data.IDbConnection" /> is closed before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is left open.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds a <see cref="T:System.Data.DataTable" /> to the specified <see cref="T:System.Data.DataSet" /> and configures the schema to match that in the data source based upon the specified <see cref="T:System.Data.SchemaType" /> and <see cref="T:System.Data.DataTable" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A reference to a collection of <see cref="T:System.Data.DataTable" /> objects that were added to the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to insert the schema in. </param>
        <param name="schemaType">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.SchemaType" /> values that specify how to insert the schema. </param>
        <param name="srcTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the source table to use for table mapping. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FillSchema">
      <MemberSignature Language="C#" Value="protected virtual System.Data.DataTable FillSchema (System.Data.DataTable dataTable, System.Data.SchemaType schemaType, System.Data.IDbCommand command, System.Data.CommandBehavior behavior);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.DataTable</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTable" Type="System.Data.DataTable" />
        <Parameter Name="schemaType" Type="System.Data.SchemaType" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="behavior" Type="System.Data.CommandBehavior" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> method retrieves the schema from the data source using the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />. The connection object associated with the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it remains open.</para>
          <para>A <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> operation adds a <see cref="T:System.Data.DataTable" /> to the destination <see cref="T:System.Data.DataSet" />. It then adds columns to the <see cref="T:System.Data.DataColumnCollection" /> of the <see cref="T:System.Data.DataTable" />, and configures the following <see cref="T:System.Data.DataColumn" /> properties if they exist at the data source: </para>
          <list type="bullet">
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AllowDBNull" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AutoIncrement" />. You must set <see cref="P:System.Data.DataColumn.AutoIncrementStep" /> and <see cref="P:System.Data.DataColumn.AutoIncrementSeed" /> separately.</para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.MaxLength" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.ReadOnly" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.Unique" /> </para>
            </item>
          </list>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> also configures the <see cref="P:System.Data.DataTable.PrimaryKey" /> and <see cref="P:System.Data.DataTable.Constraints" /> properties according to the following rules: </para>
          <list type="bullet">
            <item>
              <para>If one or more primary key columns are returned by the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />, they are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
            <item>
              <para>If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a <see cref="T:System.Data.UniqueConstraint" /> is added to the <see cref="T:System.Data.ConstraintCollection" />, but the <see cref="P:System.Data.DataTable.PrimaryKey" /> property is not set.</para>
            </item>
            <item>
              <para>If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
          </list>
          <para>Note that primary keys and unique constraints are added to the <see cref="T:System.Data.ConstraintCollection" /> according to the preceding rules, but other constraint types are not added.</para>
          <para>If a unique clustered index is defined on a column or columns in a SQL Server table and the primary key constraint is defined on a separate set of columns, then the names of the columns in the clustered index will be returned. To return the name or names of the primary key columns, use a query hint with the SELECT statement that specifies the name of the primary key index. For more information about specifying query hints, see <see cref="http://msdn.microsoft.com/library/ms181714.aspx">Query Hint (Transact-SQL)</see>.</para>
          <para>If the <see cref="T:System.Data.IDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on.). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> does not return any rows. Use the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method to add rows to a <see cref="T:System.Data.DataTable" />.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Configures the schema of the specified <see cref="T:System.Data.DataTable" /> based on the specified <see cref="T:System.Data.SchemaType" />, command string, and <see cref="T:System.Data.CommandBehavior" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A of <see cref="T:System.Data.DataTable" /> object that contains schema information returned from the data source.</para>
        </returns>
        <param name="dataTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataTable" /> to be filled with the schema from the data source. </param>
        <param name="schemaType">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.SchemaType" /> values. </param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The SQL SELECT statement used to retrieve rows from the data source. </param>
        <param name="behavior">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.CommandBehavior" /> values. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FillSchema">
      <MemberSignature Language="C#" Value="protected virtual System.Data.DataTable[] FillSchema (System.Data.DataSet dataSet, System.Data.SchemaType schemaType, System.Data.IDbCommand command, string srcTable, System.Data.CommandBehavior behavior);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.DataTable[]</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="schemaType" Type="System.Data.SchemaType" />
        <Parameter Name="command" Type="System.Data.IDbCommand" />
        <Parameter Name="srcTable" Type="System.String" />
        <Parameter Name="behavior" Type="System.Data.CommandBehavior" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> method retrieves the schema from the data source using the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />. The connection object associated with the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called, it remains open.</para>
          <para>A <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> operation adds a <see cref="T:System.Data.DataTable" /> to the destination <see cref="T:System.Data.DataSet" />. It then adds columns to the <see cref="T:System.Data.DataColumnCollection" /> of the <see cref="T:System.Data.DataTable" />, and configures the following <see cref="T:System.Data.DataColumn" /> properties if they exist at the data source: </para>
          <list type="bullet">
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AllowDBNull" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AutoIncrement" />. You must set <see cref="P:System.Data.DataColumn.AutoIncrementStep" /> and <see cref="P:System.Data.DataColumn.AutoIncrementSeed" /> separately.</para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.MaxLength" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.ReadOnly" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.Unique" /> </para>
            </item>
          </list>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> also configures the <see cref="P:System.Data.DataTable.PrimaryKey" /> and <see cref="P:System.Data.DataTable.Constraints" /> properties according to the following rules: </para>
          <list type="bullet">
            <item>
              <para>If one or more primary key columns are returned by the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />, they are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
            <item>
              <para>If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a <see cref="T:System.Data.UniqueConstraint" /> is added to the <see cref="T:System.Data.ConstraintCollection" />, but the <see cref="P:System.Data.DataTable.PrimaryKey" /> property is not set.</para>
            </item>
            <item>
              <para>If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
          </list>
          <para>Note that primary keys and unique constraints are added to the <see cref="T:System.Data.ConstraintCollection" /> according to the preceding rules, but other constraint types are not added.</para>
          <para>If a unique clustered index is defined on a column or columns in a SQL Server table and the primary key constraint is defined on a separate set of columns, then the names of the columns in the clustered index will be returned. To return the name or names of the primary key columns, use a query hint with the SELECT statement that specifies the name of the primary key index. For more information about specifying query hints, see <see cref="http://msdn.microsoft.com/library/ms181714.aspx">Query Hint (Transact-SQL)</see>.</para>
          <para>If the <see cref="T:System.Data.IDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" /> each result set is placed in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on.). Applications using column and table names should ensure that conflicts with these naming patterns does not occur.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. In such situations, <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.FillSchema(dataset, "aaa"); // Fills the schema of "aaa", which already exists in the DataSet.
 adapter.FillSchema(dataset, "Aaa"); // Adds a new table called "Aaa".</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code> DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.FillSchema(dataset, "AAA"); // Fills the schema of table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>
            <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> does not return any rows. Use the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method to add rows to a <see cref="T:System.Data.DataTable" />.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" /> for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> with the <see cref="T:System.Data.MissingSchemaAction" /> set to AddWithKey.</para>
          </block>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />, the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds a <see cref="T:System.Data.DataTable" /> to the specified <see cref="T:System.Data.DataSet" /> and configures the schema to match that in the data source based on the specified <see cref="T:System.Data.SchemaType" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>An array of <see cref="T:System.Data.DataTable" /> objects that contain schema information returned from the data source.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataSet" /> to be filled with the schema from the data source. </param>
        <param name="schemaType">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.SchemaType" /> values. </param>
        <param name="command">
          <attribution license="cc4" from="Microsoft" modified="false" />The SQL SELECT statement used to retrieve rows from the data source. </param>
        <param name="srcTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the source table to use for table mapping. </param>
        <param name="behavior">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.CommandBehavior" /> values. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="GetBatchedParameter">
      <MemberSignature Language="C#" Value="protected virtual System.Data.IDataParameter GetBatchedParameter (int commandIdentifier, int parameterIndex);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Data.IDataParameter</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="commandIdentifier" Type="System.Int32" />
        <Parameter Name="parameterIndex" Type="System.Int32" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>In <see cref="T:System.Data.Common.DbDataAdapter" />, this method throws <see cref="T:System.NotSupportedException" />. Classes that inherit from <see cref="T:System.Data.Common.DbDataAdapter" /> override this method to provide support for batches.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a <see cref="T:System.Data.IDataParameter" /> from one of the commands in the current batch.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="T:System.Data.IDataParameter" /> specified.</para>
        </returns>
        <param name="commandIdentifier">
          <attribution license="cc4" from="Microsoft" modified="false" />The index of the command to retrieve the parameter from.</param>
        <param name="parameterIndex">
          <attribution license="cc4" from="Microsoft" modified="false" />The index of the parameter within the command.</param>
      </Docs>
    </Member>
    <Member MemberName="GetBatchedRecordsAffected">
      <MemberSignature Language="C#" Value="protected virtual bool GetBatchedRecordsAffected (int commandIdentifier, out int recordsAffected, out Exception error);" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="commandIdentifier" Type="System.Int32" />
        <Parameter Name="recordsAffected" Type="System.Int32&amp;" RefType="out" />
        <Parameter Name="error" Type="System.Exception&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="commandIdentifier">To be added.</param>
        <param name="recordsAffected">To be added.</param>
        <param name="error">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetFillParameters">
      <MemberSignature Language="C#" Value="public override System.Data.IDataParameter[] GetFillParameters ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.IDataParameter[]</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>To be added</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets the parameters set by the user when executing an SQL SELECT statement.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>An array of <see cref="T:System.Data.IDataParameter" /> objects that contains the parameters set by the user.</para>
        </returns>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
    </Member>
    <Member MemberName="InitializeBatching">
      <MemberSignature Language="C#" Value="protected virtual void InitializeBatching ();" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>In <see cref="T:System.Data.Common.DbDataAdapter" />, this method throws <see cref="T:System.NotSupportedException" />. Classes that inherit from <see cref="T:System.Data.Common.DbDataAdapter" /> override this method to provide support for batches.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes batching for the <see cref="T:System.Data.Common.DbDataAdapter" />.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="InsertCommand">
      <MemberSignature Language="C#" Value="public System.Data.Common.DbCommand InsertCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Data.Common.DbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>During <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, if this property is not set and primary key information is present in the <see cref="T:System.Data.DataSet" />, the <see cref="P:System.Data.IDbDataAdapter.InsertCommand" /> will be automatically generated.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a command used to insert new records into the data source.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="OnFillError">
      <MemberSignature Language="C#" Value="protected virtual void OnFillError (System.Data.FillErrorEventArgs value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Data.FillErrorEventArgs" />
      </Parameters>
      <Docs>
        <param name="value">To be added: an object of type 'Data.FillErrorEventArgs'</param>
        <summary>To be added</summary>
        <remarks>To be added</remarks>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="OnRowUpdated">
      <MemberSignature Language="C#" Value="protected virtual void OnRowUpdated (System.Data.Common.RowUpdatedEventArgs value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Data.Common.RowUpdatedEventArgs" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Raising an event invokes the event handler through a delegate. For an overview, see <format type="text/html"><a href="f2adaf01-1ed1-42e1-8c31-8d467e7e0ee2">Raising an Event</a></format>.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Raises the RowUpdated event of a .NET Framework data provider.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> that contains the event data. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="OnRowUpdating">
      <MemberSignature Language="C#" Value="protected virtual void OnRowUpdating (System.Data.Common.RowUpdatingEventArgs value);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Data.Common.RowUpdatingEventArgs" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Raising an event invokes the event handler through a delegate. For an overview, see <format type="text/html"><a href="f2adaf01-1ed1-42e1-8c31-8d467e7e0ee2">Raising an Event</a></format>.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Raises the RowUpdating event of a .NET Framework data provider.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />An <see cref="T:System.Data.Common.RowUpdatingEventArgs" />  that contains the event data. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="SelectCommand">
      <MemberSignature Language="C#" Value="public System.Data.Common.DbCommand SelectCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Data.Common.DbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a command used to select records in the data source.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="System.Data.IDbDataAdapter.DeleteCommand">
      <MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.DeleteCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Data.IDbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This member is an explicit interface member implementation. It can be used only when the <see cref="T:System.Data.Common.DbDataAdapter" /> instance is cast to an <see cref="T:System.Data.IDbDataAdapter" /> interface.</para>
          <para>For more information, see <see cref="P:System.Data.IDbDataAdapter.DeleteCommand" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets an SQL statement for deleting records from the data set.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="System.Data.IDbDataAdapter.InsertCommand">
      <MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.InsertCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Data.IDbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This member is an explicit interface member implementation. It can be used only when the <see cref="T:System.Data.Common.DbDataAdapter" /> instance is cast to an <see cref="T:System.Data.IDbDataAdapter" /> interface.</para>
          <para>For more information, see <see cref="P:System.Data.IDbDataAdapter.InsertCommand" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets an SQL statement used to insert new records into the data source.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="System.Data.IDbDataAdapter.SelectCommand">
      <MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.SelectCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Data.IDbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This member is an explicit interface member implementation. It can be used only when the <see cref="T:System.Data.Common.DbDataAdapter" /> instance is cast to an <see cref="T:System.Data.IDbDataAdapter" /> interface.</para>
          <para>For more information, see <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets an SQL statement used to select records in the data source.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="System.Data.IDbDataAdapter.UpdateCommand">
      <MemberSignature Language="C#" Value="System.Data.IDbCommand System.Data.IDbDataAdapter.UpdateCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Data.IDbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This member is an explicit interface member implementation. It can be used only when the <see cref="T:System.Data.Common.DbDataAdapter" /> instance is cast to an <see cref="T:System.Data.IDbDataAdapter" /> interface.</para>
          <para>For more information, see <see cref="P:System.Data.IDbDataAdapter.UpdateCommand" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets an SQL statement used to update records in the data source.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="System.ICloneable.Clone">
      <MemberSignature Language="C#" Value="object ICloneable.Clone ();" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("use 'protected DbDataAdapter(DbDataAdapter)' ctor")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Object</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This member is an explicit interface member implementation. It can be used only when the <see cref="T:System.Data.Common.DbDataAdapter" /> instance is cast to an <see cref="T:System.ICloneable" /> interface.</para>
          <para>For more information, see <see cref="M:System.ICloneable.Clone" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Creates a new object that is a copy of the current instance.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A new object that is a copy of this instance.</para>
        </returns>
      </Docs>
    </Member>
    <Member MemberName="TerminateBatching">
      <MemberSignature Language="C#" Value="protected virtual void TerminateBatching ();" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>In <see cref="T:System.Data.Common.DbDataAdapter" />, this method throws <see cref="T:System.NotSupportedException" />. Classes that inherit from <see cref="T:System.Data.Common.DbDataAdapter" /> override this method to provide support for batches.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Ends batching for the <see cref="T:System.Data.Common.DbDataAdapter" />.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public int Update (System.Data.DataRow[] dataRows);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataRows" Type="System.Data.DataRow[]" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When an application calls the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method, the <see cref="T:System.Data.Common.DbDataAdapter" /> examines the <see cref="P:System.Data.DataRow.RowState" /> property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the <see cref="T:System.Data.DataSet" />. For example, <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the <see cref="T:System.Data.DataTable" />.</para>
          <para>It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the <see cref="M:System.Data.DataSet.GetChanges" /> method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see <format type="text/html"><a href="d1bd9a8c-0e29-40e3-bda8-d89176b72fb1">Updating the Database with a DataAdapter and the DataSet</a></format>.</para>
          <para>If INSERT, UPDATE, or DELETE statements have not been specified, the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method generates an exception. However, you can create a <see cref="T:System.Data.SqlClient.SqlCommandBuilder" /> or <see cref="T:System.Data.OleDb.OleDbCommandBuilder" /> object to automatically generate SQL statements for single-table updates if you set the SelectCommand property of a .NET Framework data provider. Then, any additional SQL statements that you do not set are generated by the CommandBuilder. This generation logic requires key column information to be present in the <see cref="T:System.Data.DataSet" />. For more information see <format type="text/html"><a href="6e3fb8b5-373b-4f9e-ab03-a22693df8e91">Automatically Generated Commands</a></format>.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method retrieves rows from the table listed in the first mapping before performing an update. The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> then refreshes the row using the value of the <see cref="P:System.Data.IDbCommand.UpdatedRowSource" /> property. Any additional rows returned are ignored.</para>
          <para>After any data is loaded back into the <see cref="T:System.Data.DataSet" />, the <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised, allowing the user to inspect the reconciled <see cref="T:System.Data.DataSet" /> row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted.</para>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, the order of execution is as follows: </para>
          <list type="ordered">
            <item>
              <para>The values in the <see cref="T:System.Data.DataRow" /> are moved to the parameter values.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>The command executes.</para>
            </item>
            <item>
              <para>If the command is set to FirstReturnedRecord, the first returned result is placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>If there are output parameters, they are placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>
                <see cref="M:System.Data.DataRow.AcceptChanges" /> is called.</para>
            </item>
          </list>
          <para>Each command associated with the <see cref="T:System.Data.Common.DbDataAdapter" /> usually has a parameters collection associated with it. Parameters are mapped to the current row through the SourceColumn and SourceVersion properties of a .NET Framework data provider's Parameter class. SourceColumn refers to a <see cref="T:System.Data.DataTable" /> column that the <see cref="T:System.Data.Common.DbDataAdapter" /> references to obtain parameter values for the current row.</para>
          <para>SourceColumn refers to the unmapped column name before any table mappings have been applied. If SourceColumn refers to a nonexistent column, the action taken depends on one of the following <see cref="T:System.Data.MissingMappingAction" /> values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Enumeration value </para>
                </term>
                <description>
                  <para>Action taken </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>MissingMappingAction.Passthrough </para>
              </term>
              <description>
                <para>Use the source column names and table names in the <see cref="T:System.Data.DataSet" /> if no mapping is present. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Ignore </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Error </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. </para>
              </description>
            </item>
          </list>
          <para>The SourceColumn property is also used to map the value for output or input/output parameters back to the DataSet. An exception is generated if it refers to a nonexistent column.</para>
          <para>The SourceVersion property of a .NET Framework data provider's Parameter class determines whether to use the Original, Current, or Proposed version of the column value. This capability is often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations.</para>
          <block subset="none" type="note">
            <para>If an error occurs while updating a row, an exception is thrown and execution of the update is discontinued. To continue the update operation without generating exceptions when an error is encountered, set the <see cref="P:System.Data.Common.DataAdapter.ContinueUpdateOnError" /> property to true before calling <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />. You may also respond to errors on a per-row basis within the RowUpdated event of a DataAdapter. To continue the update operation without generating an exception within the RowUpdated event, set the <see cref="P:System.Data.Common.RowUpdatedEventArgs.Status" /> property of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> to <see cref="F:System.Data.UpdateStatus.Continue" />.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified array in the <see cref="T:System.Data.DataSet" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully updated from the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataRows">
          <attribution license="cc4" from="Microsoft" modified="false" />An array of <see cref="T:System.Data.DataRow" /> objects used to update the data source. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public override int Update (System.Data.DataSet dataSet);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When an application calls the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method, the <see cref="T:System.Data.Common.DbDataAdapter" /> examines the <see cref="P:System.Data.DataRow.RowState" /> property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the <see cref="T:System.Data.DataSet" />. For example, <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the <see cref="T:System.Data.DataTable" />.</para>
          <para>It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the <see cref="M:System.Data.DataSet.GetChanges" /> method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see <format type="text/html"><a href="D1BD9A8C-0E29-40E3-BDA8-D89176B72FB1">Updating the Database With a DataAdapter and a DataSet</a></format>.</para>
          <para>If INSERT, UPDATE, or DELETE statements have not been specified, the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method generates an exception. However, you can create a <see cref="T:System.Data.SqlClient.SqlCommandBuilder" /> or <see cref="T:System.Data.OleDb.OleDbCommandBuilder" /> object to automatically generate SQL statements for single-table updates if you set the SelectCommand property of a .NET Framework data provider. Then, any additional SQL statements that you do not set are generated by the CommandBuilder. This generation logic requires key column information to be present in the <see cref="T:System.Data.DataSet" />. For more information see <format type="text/html"><a href="6e3fb8b5-373b-4f9e-ab03-a22693df8e91">Automatically Generated Commands</a></format>.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method retrieves rows from the table listed in the first mapping before performing an update. The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> then refreshes the row using the value of the <see cref="P:System.Data.IDbCommand.UpdatedRowSource" /> property. Any additional rows returned are ignored.</para>
          <para>After any data is loaded back into the <see cref="T:System.Data.DataSet" />, the <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised, allowing the user to inspect the reconciled <see cref="T:System.Data.DataSet" /> row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted.</para>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, the order of execution is as follows: </para>
          <list type="ordered">
            <item>
              <para>The values in the <see cref="T:System.Data.DataRow" /> are moved to the parameter values.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>The command executes.</para>
            </item>
            <item>
              <para>If the command is set to FirstReturnedRecord, then the first returned result is placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>If there are output parameters, they are placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>
                <see cref="M:System.Data.DataRow.AcceptChanges" /> is called.</para>
            </item>
          </list>
          <para>Each command associated with the <see cref="T:System.Data.Common.DbDataAdapter" /> usually has a parameters collection associated with it. Parameters are mapped to the current row through the SourceColumn and SourceVersion properties of a .NET Framework data provider's Parameter class. SourceColumn refers to a <see cref="T:System.Data.DataTable" /> column that the <see cref="T:System.Data.Common.DbDataAdapter" /> references to obtain parameter values for the current row.</para>
          <para>SourceColumn refers to the unmapped column name before any table mappings have been applied. If SourceColumn refers to a nonexistent column, the action taken depends on one of the following <see cref="T:System.Data.MissingMappingAction" /> values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Enumeration value </para>
                </term>
                <description>
                  <para>Action taken </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>MissingMappingAction.Passthrough </para>
              </term>
              <description>
                <para>Use the source column names and table names in the <see cref="T:System.Data.DataSet" /> if no mapping is present. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Ignore </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Error </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. </para>
              </description>
            </item>
          </list>
          <para>The SourceColumn property is also used to map the value for output or input/output parameters back to the DataSet. An exception is generated if it refers to a nonexistent column.</para>
          <para>The SourceVersion property of a .NET Framework data provider's Parameter class determines whether to use the Original, Current, or Proposed version of the column value. This capability is often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations.</para>
          <block subset="none" type="note">
            <para>If an error occurs while updating a row, an exception is thrown and execution of the update is discontinued. To continue the update operation without generating exceptions when an error is encountered, set the <see cref="P:System.Data.Common.DataAdapter.ContinueUpdateOnError" /> property to true before calling <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />. You may also respond to errors on a per-row basis within the RowUpdated event of a DataAdapter. To continue the update operation without generating an exception within the RowUpdated event, set the <see cref="P:System.Data.Common.RowUpdatedEventArgs.Status" /> property of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> to <see cref="F:System.Data.UpdateStatus.Continue" />.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified <see cref="T:System.Data.DataSet" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully updated from the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataSet" /> used to update the data source. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public int Update (System.Data.DataTable dataTable);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataTable" Type="System.Data.DataTable" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When an application calls the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method, the <see cref="T:System.Data.Common.DbDataAdapter" /> examines the <see cref="P:System.Data.DataRow.RowState" /> property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the <see cref="T:System.Data.DataSet" />. For example, <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the <see cref="T:System.Data.DataTable" />.</para>
          <para>It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the <see cref="M:System.Data.DataSet.GetChanges" /> method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see <format type="text/html"><a href="D1BD9A8C-0E29-40E3-BDA8-D89176B72FB1">Updating the Database With a DataAdapter and a DataSet</a></format>.</para>
          <para>If INSERT, UPDATE, or DELETE statements have not been specified, the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method generates an exception. However, you can create a <see cref="T:System.Data.SqlClient.SqlCommandBuilder" /> or <see cref="T:System.Data.OleDb.OleDbCommandBuilder" /> object to automatically generate SQL statements for single-table updates if you set the SelectCommand property of a .NET Framework data provider. Then, any additional SQL statements that you do not set are generated by the CommandBuilder. This generation logic requires key column information to be present in the <see cref="T:System.Data.DataSet" />. For more information see <format type="text/html"><a href="6e3fb8b5-373b-4f9e-ab03-a22693df8e91">Automatically Generated Commands</a></format>.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method retrieves rows from the table listed in the first mapping before performing an update. The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> then refreshes the row using the value of the <see cref="P:System.Data.IDbCommand.UpdatedRowSource" /> property. Any additional rows returned are ignored.</para>
          <para>After any data is loaded back into the <see cref="T:System.Data.DataSet" />, the <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised, allowing the user to inspect the reconciled <see cref="T:System.Data.DataSet" /> row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted.</para>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, the order of execution is as follows: </para>
          <list type="ordered">
            <item>
              <para>The values in the <see cref="T:System.Data.DataRow" /> are moved to the parameter values.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>The command executes.</para>
            </item>
            <item>
              <para>If the command is set to FirstReturnedRecord, then the first returned result is placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>If there are output parameters, they are placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>
                <see cref="M:System.Data.DataRow.AcceptChanges" /> is called.</para>
            </item>
          </list>
          <para>Each command associated with the <see cref="T:System.Data.Common.DbDataAdapter" /> usually has a parameters collection associated with it. Parameters are mapped to the current row through the SourceColumn and SourceVersion properties of a .NET Framework data provider's Parameter class. SourceColumn refers to a <see cref="T:System.Data.DataTable" /> column that the <see cref="T:System.Data.Common.DbDataAdapter" /> references to obtain parameter values for the current row.</para>
          <para>SourceColumn refers to the unmapped column name before any table mappings have been applied. If SourceColumn refers to a nonexistent column, the action taken depends on one of the following <see cref="T:System.Data.MissingMappingAction" /> values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Enumeration value </para>
                </term>
                <description>
                  <para>Action taken </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>MissingMappingAction.Passthrough </para>
              </term>
              <description>
                <para>Use the source column names and table names in the <see cref="T:System.Data.DataSet" /> if no mapping is present. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Ignore </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Error </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. </para>
              </description>
            </item>
          </list>
          <para>The SourceColumn property is also used to map the value for output or input/output parameters back to the DataSet. An exception is generated if it refers to a nonexistent column.</para>
          <para>The SourceVersion property of a .NET Framework data provider's Parameter class determines whether to use the Original, Current, or Proposed version of the column value. This capability is often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations.</para>
          <block subset="none" type="note">
            <para>If an error occurs while updating a row, an exception is thrown and execution of the update is discontinued. To continue the update operation without generating exceptions when an error is encountered, set the <see cref="P:System.Data.Common.DataAdapter.ContinueUpdateOnError" /> property to true before calling <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />. You may also respond to errors on a per-row basis within the RowUpdated event of a DataAdapter. To continue the update operation without generating an exception within the RowUpdated event, set the <see cref="P:System.Data.Common.RowUpdatedEventArgs.Status" /> property of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> to <see cref="F:System.Data.UpdateStatus.Continue" />.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified <see cref="T:System.Data.DataTable" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully updated from the <see cref="T:System.Data.DataTable" />.</para>
        </returns>
        <param name="dataTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataTable" /> used to update the data source. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="protected virtual int Update (System.Data.DataRow[] dataRows, System.Data.Common.DataTableMapping tableMapping);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataRows" Type="System.Data.DataRow[]" />
        <Parameter Name="tableMapping" Type="System.Data.Common.DataTableMapping" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When an application calls the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method, the <see cref="T:System.Data.Common.DbDataAdapter" /> examines the <see cref="P:System.Data.DataRow.RowState" /> property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the <see cref="T:System.Data.DataSet" />. For example, <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the <see cref="T:System.Data.DataTable" />.</para>
          <para>It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the <see cref="M:System.Data.DataSet.GetChanges" /> method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see <format type="text/html"><a href="d1bd9a8c-0e29-40e3-bda8-d89176b72fb1">Updating the Database with a DataAdapter and the DataSet</a></format>.</para>
          <para>If INSERT, UPDATE, or DELETE statements have not been specified, the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method generates an exception. However, you can create a <see cref="T:System.Data.SqlClient.SqlCommandBuilder" /> or <see cref="T:System.Data.OleDb.OleDbCommandBuilder" /> object to automatically generate SQL statements for single-table updates if you set the SelectCommand property of a .NET Framework data provider. Then, any additional SQL statements that you do not set are generated by the CommandBuilder. This generation logic requires key column information to be present in the <see cref="T:System.Data.DataSet" />. For more information see <format type="text/html"><a href="6e3fb8b5-373b-4f9e-ab03-a22693df8e91">Automatically Generated Commands</a></format>.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method retrieves rows from the table listed in the first mapping before performing an update. The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> then refreshes the row using the value of the <see cref="P:System.Data.IDbCommand.UpdatedRowSource" /> property. Any additional rows returned are ignored.</para>
          <para>After any data is loaded back into the <see cref="T:System.Data.DataSet" />, the <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised, allowing the user to inspect the reconciled <see cref="T:System.Data.DataSet" /> row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted.</para>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, the order of execution is as follows: </para>
          <list type="ordered">
            <item>
              <para>The values in the <see cref="T:System.Data.DataRow" /> are moved to the parameter values.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>The command executes.</para>
            </item>
            <item>
              <para>If the command is set to FirstReturnedRecord, then the first returned result is placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>If there are output parameters, they are placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>
                <see cref="M:System.Data.DataRow.AcceptChanges" /> is called.</para>
            </item>
          </list>
          <para>Each command associated with the <see cref="T:System.Data.Common.DbDataAdapter" /> usually has a parameters collection associated with it. Parameters are mapped to the current row through the SourceColumn and SourceVersion properties of a .NET Framework data provider's Parameter class. SourceColumn refers to a <see cref="T:System.Data.DataTable" /> column that the <see cref="T:System.Data.Common.DbDataAdapter" /> references to obtain parameter values for the current row.</para>
          <para>SourceColumn refers to the unmapped column name before any table mappings have been applied. If SourceColumn refers to a nonexistent column, the action taken depends on one of the following <see cref="T:System.Data.MissingMappingAction" /> values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Enumeration value </para>
                </term>
                <description>
                  <para>Action taken </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>MissingMappingAction.Passthrough </para>
              </term>
              <description>
                <para>Use the source column names and table names in the <see cref="T:System.Data.DataSet" /> if no mapping is present. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Ignore </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Error </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. </para>
              </description>
            </item>
          </list>
          <para>The SourceColumn property is also used to map the value for output or input/output parameters back to the DataSet. An exception is generated if it refers to a nonexistent column.</para>
          <para>The SourceVersion property of a .NET Framework data provider's Parameter class determines whether to use the Original, Current, or Proposed version of the column value. This capability is often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations.</para>
          <block subset="none" type="note">
            <para>If an error occurs while updating a row, an exception is thrown and execution of the update is discontinued. To continue the update operation without generating exceptions when an error is encountered, set the <see cref="P:System.Data.Common.DataAdapter.ContinueUpdateOnError" /> property to true before calling <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />. You may also respond to errors on a per-row basis within the RowUpdated event of a DataAdapter. To continue the update operation without generating an exception within the RowUpdated event, set the <see cref="P:System.Data.Common.RowUpdatedEventArgs.Status" /> property of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> to <see cref="F:System.Data.UpdateStatus.Continue" />.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified array of <see cref="T:System.Data.DataSet" /> objects.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully updated from the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataRows">
          <attribution license="cc4" from="Microsoft" modified="false" />An array of <see cref="T:System.Data.DataRow" /> objects used to update the data source. </param>
        <param name="tableMapping">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="P:System.Data.IDataAdapter.TableMappings" /> collection to use. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public int Update (System.Data.DataSet dataSet, string srcTable);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="srcTable" Type="System.String" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When an application calls the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method, the <see cref="T:System.Data.Common.DbDataAdapter" /> examines the <see cref="P:System.Data.DataRow.RowState" /> property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the <see cref="T:System.Data.DataSet" />. For example, <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the <see cref="T:System.Data.DataTable" />.</para>
          <para>It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the <see cref="M:System.Data.DataSet.GetChanges" /> method in situations where you must control the sequence of statement types (for example, INSERT before UPDATE). For more information, see <format type="text/html"><a href="D1BD9A8C-0E29-40E3-BDA8-D89176B72FB1">Updating the Database With a DataAdapter and a DataSet</a></format>.</para>
          <para>If INSERT, UPDATE, or DELETE statements have not been specified, the <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method generates an exception. However, you can create a <see cref="T:System.Data.SqlClient.SqlCommandBuilder" /> or <see cref="T:System.Data.OleDb.OleDbCommandBuilder" /> object to automatically generate SQL statements for single-table updates if you set the SelectCommand property of a .NET Framework data provider. Then, any additional SQL statements that you do not set are generated by the CommandBuilder. This generation logic requires key column information to be present in the <see cref="T:System.Data.DataSet" />. For more information see <format type="text/html"><a href="6e3fb8b5-373b-4f9e-ab03-a22693df8e91">Automatically Generated Commands</a></format>.</para>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method supports scenarios where the <see cref="T:System.Data.DataSet" /> contains multiple <see cref="T:System.Data.DataTable" /> objects whose names differ only by case. When multiple tables with the same name, but different case, exist in a DataSet, <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> performs a case-sensitive comparison to find the corresponding table, and generates an exception if no exact match exists. The following C# code illustrates this behavior.</para>
          <code>DataSet ds = new DataSet();
 ds.Tables.Add("aaa");
 ds.Tables.Add("AAA");
 adapter.Update(ds, "aaa"); // Updates "aaa", which already exists in the DataSet.
 adapter.Update(ds, "AAA"); // Updates "AAA", which already exists in the DataSet.
    adapter.Update(ds, "Aaa"); // Results in an exception.</code>
          <para>If <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> is called and the <see cref="T:System.Data.DataSet" /> contains only one <see cref="T:System.Data.DataTable" /> whose name differs only by case, that <see cref="T:System.Data.DataTable" /> is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.</para>
          <code>DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
    adapter.Update(dataset, "AAA"); // Updates table "aaa" because only one similarly named table is in the DataSet.</code>
          <para>The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> method retrieves rows from the table listed in the first mapping before performing an update. The <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> then refreshes the row using the value of the <see cref="P:System.Data.IDbCommand.UpdatedRowSource" /> property. Any additional rows returned are ignored.</para>
          <para>After any data is loaded back into the <see cref="T:System.Data.DataSet" />, the <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised, allowing the user to inspect the reconciled <see cref="T:System.Data.DataSet" /> row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted.</para>
          <para>When using <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, the order of execution is as follows: </para>
          <list type="ordered">
            <item>
              <para>The values in the <see cref="T:System.Data.DataRow" /> are moved to the parameter values.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>The command executes.</para>
            </item>
            <item>
              <para>If the command is set to FirstReturnedRecord, then the first returned result is placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>If there are output parameters, they are placed in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>
                <see cref="M:System.Data.DataRow.AcceptChanges" /> is called.</para>
            </item>
          </list>
          <para>Each command associated with the <see cref="T:System.Data.Common.DbDataAdapter" /> usually has a parameters collection associated with it. Parameters are mapped to the current row through the SourceColumn and SourceVersion properties of a .NET Framework data provider's Parameter class. SourceColumn refers to a <see cref="T:System.Data.DataTable" /> column that the <see cref="T:System.Data.Common.DbDataAdapter" /> references to obtain parameter values for the current row.</para>
          <para>SourceColumn refers to the unmapped column name before any table mappings have been applied. If SourceColumn refers to a nonexistent column, the action taken depends on one of the following <see cref="T:System.Data.MissingMappingAction" /> values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Enumeration value </para>
                </term>
                <description>
                  <para>Action taken </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>MissingMappingAction.Passthrough </para>
              </term>
              <description>
                <para>Use the source column names and table names in the <see cref="T:System.Data.DataSet" /> if no mapping is present. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Ignore </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Error </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. </para>
              </description>
            </item>
          </list>
          <para>The SourceColumn property is also used to map the value for output or input/output parameters back to the DataSet. An exception is generated if it refers to a nonexistent column.</para>
          <para>The SourceVersion property of a .NET Framework data provider's Parameter class determines whether to use the Original, Current, or Proposed version of the column value. This capability is often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations.</para>
          <block subset="none" type="note">
            <para>If an error occurs while updating a row, an exception is thrown and execution of the update is discontinued. To continue the update operation without generating exceptions when an error is encountered, set the <see cref="P:System.Data.Common.DataAdapter.ContinueUpdateOnError" /> property to true before calling <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />. You may also respond to errors on a per-row basis within the RowUpdated event of a DataAdapter. To continue the update operation without generating an exception within the RowUpdated event, set the <see cref="P:System.Data.Common.RowUpdatedEventArgs.Status" /> property of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> to <see cref="F:System.Data.UpdateStatus.Continue" />.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the <see cref="T:System.Data.DataSet" />  with the specified <see cref="T:System.Data.DataTable" /> name.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully updated from the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataSet" /> to use to update the data source. </param>
        <param name="srcTable">
          <attribution license="cc4" from="Microsoft" modified="false" />The name of the source table to use for table mapping. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="UpdateBatchSize">
      <MemberSignature Language="C#" Value="public virtual int UpdateBatchSize { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.DefaultValue(1)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Use the <see cref="P:System.Data.Common.DbDataAdapter.UpdateBatchSize" /> property to update a data source with changes from a <see cref="T:System.Data.DataSet" />. If the data provider supports batch processing, this can increase application performance by reducing the number of round-trips to the server. In ADO.NET 2.0, this property is supported for the .NET data providers for SQL Server (SqlClient) and Oracle (OracleClient). </para>
          <para>Executing an extremely large batch could decrease performance. Therefore, you should test for the optimum batch size setting before implementing your application.</para>
          <para>An <see cref="T:System.ArgumentOutOfRangeException" /> will be thrown if the value is set to a number less than zero.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a value that enables or disables batch processing support, and specifies the number of commands that can be executed in a batch. </para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="UpdateCommand">
      <MemberSignature Language="C#" Value="public System.Data.Common.DbCommand UpdateCommand { set; get; }" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Data.Common.DbCommand</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>During <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, if this property is not set and primary key information is present in the <see cref="T:System.Data.DataSet" />, the <see cref="P:System.Data.IDbDataAdapter.UpdateCommand" /> will be automatically generated.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a command used to update records in the data source.</para>
        </summary>
      </Docs>
    </Member>
  </Members>
</Type>