<?xml version="1.0"?>
<doc>
    <assembly>
        <name>C1.Data.2</name>
    </assembly>
    <members>
        <member name="T:C1.Util.Localization.StringTables">
            <summary>
            StringTables
            this class contains a single static method InitTables that populates the
            tables used by the Localizer class.
            </summary>
        </member>
        <member name="T:C1.Data.Design.SchemaImporter">
            <summary>
            SchemaImporter imports database structure into internal DataSet object.
            After Open(...) you can access database structure using InternalDataSet property
            Invoke Import() member to actually import database structure into schema object.
            </summary>
        </member>
        <member name="M:C1.Data.Design.SchemaImporter.FormatTablePositions(System.Int32,System.Int32)">
            <summary>
            Formats design-info of the imported tables according to 
            revative position of these tables
            </summary>
            <param name="x"></param>
            <param name="y"></param>
        </member>
        <member name="T:C1.Data.Designer.DesignTimeInfo">
            <summary>
            Summary description for DesignTimeInfo.
            </summary>
        </member>
        <member name="T:C1.Data.BaseComponent">
            <summary>
            Base class for all C1DataObjects components.
            </summary>
        </member>
        <member name="T:C1.Data.ListChangedFlags">
            <summary>
            Specifies how a command string is interpreted.
            </summary>
            <remarks>
            These flags, used in <see cref="P:C1.Data.C1DataSet.NotificationModeFlags"/> property, affect the way change notifications are sent to 
            data bound controls. If none of the flags is set (the default), C1DataObjects uses its regular 
            notification scheme.
            </remarks>
        </member>
        <member name="F:C1.Data.ListChangedFlags.None">
            <summary>
            C1DataObjects uses its regular notification scheme.
            </summary>
        </member>
        <member name="F:C1.Data.ListChangedFlags.SuppressInEditMode">
            <summary>
            ListChanged event with ListChangedType = ItemChanged is not fired when a field is set in edit mode (between BeginEdit and EndEdit).
            </summary>
        </member>
        <member name="F:C1.Data.ListChangedFlags.NotifyEndEdit">
            <summary>
            ListChanged event with ListChangedType = ItemChanged is fired on EndEdit if some fields were changed while the row was in edit mode.
            </summary>
        </member>
        <member name="F:C1.Data.ListChangedFlags.NotifyAddNewTwice">
            <summary>
            For a newly added row, second ListChanged event with ListChangedType = ItemAdded is called on EndEdit (when the row leaves the "detached" state). The first ListChanged event with ItemAdded is always fired on AddNew:C1DataTable, when the row is created in the "detached" state.
            </summary>
        </member>
        <member name="F:C1.Data.ListChangedFlags.AdoNet">
            <summary>
            SuppressInEditMode | NotifyEndEdit | NotifyAddNewTwice
            </summary>
        </member>
        <member name="T:C1.Data.SortComparisonMode">
            <summary>
            Determines the type of string comparison.
            </summary>
        </member>
        <member name="F:C1.Data.SortComparisonMode.C1Data">
            <summary>
            String comparisons are compatible with the previous versions of C1DataObjects.
            </summary>
        </member>
        <member name="F:C1.Data.SortComparisonMode.AdoNet">
            <summary>
            String comparisons are compatible with the standard ADO.NET objects, such as DataTable.
            </summary>
        </member>
        <member name="F:C1.Data.SortComparisonMode.Ordinal">
            <summary>
            Compare strings using ordinal sort rules based on the Unicode values of each character.
            </summary>
        </member>
        <member name="T:C1.Data.C1DataTableCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.C1DataTable"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataTableCollection.CopyTo(C1.Data.C1DataTable[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.C1DataTableCollection.IndexOf(System.String)">
            <summary>
            Gets the index of the data table with a given name (the name is not case-sensitive). 
            </summary>
            <param name="name">The <see cref="P:C1.Data.C1DataTable.Name"/> of the element.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="P:C1.Data.C1DataTableCollection.Count">
            <summary>
            Gets the total number of elements in a collection.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataTableCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="P:C1.Data.C1DataTableCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.C1DataTable.Name"/> of the element.</param>
        </member>
        <member name="P:C1.Data.C1DataTableCollection.Item(C1.Data.SchemaObjects.BaseTable)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="schemaTable">The <see cref="P:C1.Data.C1DataTable.SchemaTable"/> of the element.</param>
        </member>
        <member name="T:C1.Data.PropertyCollection">
            <summary>
            Represents a collection of properties that can be added to <see cref="T:C1.Data.C1DataSet"/>, <see cref="T:C1.Data.C1DataTable"/>, or <see cref="T:C1.Data.SchemaObjects.TableField"/>.
            </summary>
            <remarks>
            This class does not add any new properties or methods to the System.Data.PropertyCollection class.
            <para>The only difference with the base class is that C1.Data.PropertyCollection is marked 
            with [Serializable] attribute and implements the ISerializable interface, so it can be passed 
            as a parameter and returned from a method executed remotely in a different process or on 
            a different computer.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.PropertyCollection.#ctor">
            <summary>
            Initializes a new instance of the PropertyCollection class.
            </summary>
        </member>
        <member name="T:C1.Data.C1DataSet">
            <summary>
            C1DataSet is the main client component of C1DataObjects.
            </summary>
            <remarks>
            It contains the data as it is exposed to the user, that can be used both by data bound controls 
            and programmatically. C1DataSet class has a [Serializable] attribute, so it can be passed 
            as a parameter and returned from a method executed remotely in a different process or on a different computer.
            </remarks>
        </member>
        <member name="T:C1.Data.BaseFormAwareMarshalByValueComponent">
            <summary>
            Base class for <see cref="T:C1.Data.C1DataSet"/>.
            </summary>
        </member>
        <member name="P:C1.Data.BaseFormAwareMarshalByValueComponent.BindingContextCtrl">
            <summary>
            Gets or sets the Form or other Control which has a reference to the BindingContext object.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataSet.#ctor">
            <summary>
            Initializes a new instance of the C1DataSet class.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataSet.Fill">
            <summary>
            Fills the data set with data fetching it from the database.
            </summary>
            <remarks>If data set schema has changed since the last time the data set was filled, 
            you must call one of the Fill overloads with Recreate argument set to True. 
            This recreates the structure of table view and table rowsets in the data set, 
            synchronizing it with the changed schema. Calling Fill without Recreate or Recreate set to False 
            after schema change can cause unpredictable results.
            <para>Filter conditions specify restrictions on the fetched rows. Each filter condition represents 
            a restriction on one of the data set table views. For table views based on bound and SQL-based tables, 
            a filter condition has SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions 
            are arbitrary strings that can be used by BeforeFill event code implementing the fetch.</para>
            <para>Specifying the TableViewNames argument allows you to selectively fetch certain table views without affecting 
            other table views in the data set.</para>
            <para>If the TableViewNames argument is not used, table views with FillIgnore property set to True are not fetched.</para>
            <para>Before fetching data, C1DataObjects fires BeforeFill event. You can either pass filter conditions 
            to the Fill method or set them in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event fires both on calling Fill 
            and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True. After filling the data set, C1DataObjects fires <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.Fill(System.Boolean)">
            <summary>
            Fills the data set with data fetching it from the database.
            </summary>
            <remarks>If data set schema has changed since the last time the data set was filled, 
            you must call one of the Fill overloads with Recreate argument set to True. 
            This recreates the structure of table view and table rowsets in the data set, 
            synchronizing it with the changed schema. Calling Fill without Recreate or Recreate set to False 
            after schema change can cause unpredictable results.
            <para>Filter conditions specify restrictions on the fetched rows. Each filter condition represents 
            a restriction on one of the data set table views. For table views based on bound and SQL-based tables, 
            a filter condition has SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions 
            are arbitrary strings that can be used by BeforeFill event code implementing the fetch.</para>
            <para>Specifying the TableViewNames argument allows you to selectively fetch certain table views without affecting 
            other table views in the data set.</para>
            <para>If the TableViewNames argument is not used, table views with FillIgnore property set to True are not fetched.</para>
            <para>Before fetching data, C1DataObjects fires BeforeFill event. You can either pass filter conditions 
            to the Fill method or set them in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event fires both on calling Fill 
            and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True. After filling the data set, C1DataObjects fires <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.</para>
            </remarks>
            <param name="recreate">Set this parameter to True if data set schema has changed since the last time the data set was filled.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Fill(C1.Data.FilterCondition,System.Boolean)">
            <summary>
            Fills the data set with data fetching it from the database.
            </summary>
            <remarks>If data set schema has changed since the last time the data set was filled, 
            you must call one of the Fill overloads with Recreate argument set to True. 
            This recreates the structure of table view and table rowsets in the data set, 
            synchronizing it with the changed schema. Calling Fill without Recreate or Recreate set to False 
            after schema change can cause unpredictable results.
            <para>Filter conditions specify restrictions on the fetched rows. Each filter condition represents 
            a restriction on one of the data set table views. For table views based on bound and SQL-based tables, 
            a filter condition has SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions 
            are arbitrary strings that can be used by BeforeFill event code implementing the fetch.</para>
            <para>Specifying the TableViewNames argument allows you to selectively fetch certain table views without affecting 
            other table views in the data set.</para>
            <para>If the TableViewNames argument is not used, table views with FillIgnore property set to True are not fetched.</para>
            <para>Before fetching data, C1DataObjects fires BeforeFill event. You can either pass filter conditions 
            to the Fill method or set them in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event fires both on calling Fill 
            and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True. After filling the data set, C1DataObjects fires <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.</para>
            </remarks>
            <param name="filter">Filter condition restricting the fetched rows of one of the data set table views.</param>
            <param name="recreate">Set this parameter to True if data set schema has changed since the last time the data set was filled.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Fill(C1.Data.FilterConditions,System.Boolean)">
            <summary>
            Fills the data set with data fetching it from the database.
            </summary>
            <remarks>If data set schema has changed since the last time the data set was filled, 
            you must call one of the Fill overloads with Recreate argument set to True. 
            This recreates the structure of table view and table rowsets in the data set, 
            synchronizing it with the changed schema. Calling Fill without Recreate or Recreate set to False 
            after schema change can cause unpredictable results.
            <para>Filter conditions specify restrictions on the fetched rows. Each filter condition represents 
            a restriction on one of the data set table views. For table views based on bound and SQL-based tables, 
            a filter condition has SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions 
            are arbitrary strings that can be used by BeforeFill event code implementing the fetch.</para>
            <para>Specifying the TableViewNames argument allows you to selectively fetch certain table views without affecting 
            other table views in the data set.</para>
            <para>If the TableViewNames argument is not used, table views with FillIgnore property set to True are not fetched.</para>
            <para>Before fetching data, C1DataObjects fires BeforeFill event. You can either pass filter conditions 
            to the Fill method or set them in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event fires both on calling Fill 
            and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True. After filling the data set, C1DataObjects fires <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.</para>
            </remarks>
            <param name="filters">Filter conditions restricting the fetched rows of some of the data set table views.</param>
            <param name="recreate">Set this parameter to True if data set schema has changed since the last time the data set was filled.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Fill(System.String[])">
            <summary>
            Fills the data set with data fetching it from the database.
            </summary>
            <remarks>If data set schema has changed since the last time the data set was filled, 
            you must call one of the Fill overloads with Recreate argument set to True. 
            This recreates the structure of table view and table rowsets in the data set, 
            synchronizing it with the changed schema. Calling Fill without Recreate or Recreate set to False 
            after schema change can cause unpredictable results.
            <para>Filter conditions specify restrictions on the fetched rows. Each filter condition represents 
            a restriction on one of the data set table views. For table views based on bound and SQL-based tables, 
            a filter condition has SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions 
            are arbitrary strings that can be used by BeforeFill event code implementing the fetch.</para>
            <para>Specifying the TableViewNames argument allows you to selectively fetch certain table views without affecting 
            other table views in the data set.</para>
            <para>If the TableViewNames argument is not used, table views with FillIgnore property set to True are not fetched.</para>
            <para>Before fetching data, C1DataObjects fires BeforeFill event. You can either pass filter conditions 
            to the Fill method or set them in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event fires both on calling Fill 
            and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True. After filling the data set, C1DataObjects fires <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.</para>
            </remarks>
            <param name="tableViewNames">Array of names specifying table views to be filled with data. Other table views are not changed.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Fill(C1.Data.FilterConditions,System.String[])">
            <summary>
            Fills the data set with data fetching it from the database.
            </summary>
            <remarks>If data set schema has changed since the last time the data set was filled, 
            you must call one of the Fill overloads with Recreate argument set to True. 
            This recreates the structure of table view and table rowsets in the data set, 
            synchronizing it with the changed schema. Calling Fill without Recreate or Recreate set to False 
            after schema change can cause unpredictable results.
            <para>Filter conditions specify restrictions on the fetched rows. Each filter condition represents 
            a restriction on one of the data set table views. For table views based on bound and SQL-based tables, 
            a filter condition has SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions 
            are arbitrary strings that can be used by BeforeFill event code implementing the fetch.</para>
            <para>Specifying the TableViewNames argument allows you to selectively fetch certain table views without affecting 
            other table views in the data set.</para>
            <para>If the TableViewNames argument is not used, table views with FillIgnore property set to True are not fetched.</para>
            <para>Before fetching data, C1DataObjects fires BeforeFill event. You can either pass filter conditions 
            to the Fill method or set them in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event fires both on calling Fill 
            and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True. After filling the data set, C1DataObjects fires <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.</para>
            </remarks>
            <param name="filters">Filter conditions restricting the fetched rows of some of the data set table views.</param>
            <param name="tableViewNames">Array of names specifying table views to be filled with data. Other table views are not changed.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Clear">
            <summary>
            Removes all rows from all data set tables.
            </summary>
            <remarks>Rows removed by the Clear method do not become deleted (DataRowStateEnum.Deleted), they are completely removed, destroyed.</remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.Clear(System.String[])">
            <summary>
            Removes all rows from the specified table views.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataSet.StopAsyncFetch(System.String)">
            <summary>
            For <see cref="P:C1.Data.SchemaObjects.TableView.DataAccessMode"/> = VirtualAutomatic, this property stops the background fetch, if a fetch is in progress.
            </summary>
            <param name="tableViewName">The name of the table view.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Update">
            <summary>
            Updates (commits) all changed data set rows to the database.
            </summary>
            <remarks>Update method without parameters updates the whole data set.
            <para>Update method with tableNames parameter updates only changes in the tables listed in tableNames. 
            The tableNames parameter must contain a list of simple tables (not composite tables or table views).</para>
            <para>Update method with tableNames parameter does not allow updating a table that is used in a composite 
            table as a main constituent table (is connected to its parent in the composite table diagram with a 
            one-to-many relation; the restriction does not apply to those connected many-to-one). 
            If this restriction is not satisfied, the method throws an exception. 
            In such case, always use Update without parameters to update the whole data set.</para>
            <para>An unsuccessful update, including one resulting in an exception, triggers <see cref="E:C1.Data.C1DataSet.UpdateError"/> event. 
            If user code sets the event's Status argument to Continue, an update attempt is made again. 
            This loop continues until either the update succeeds or UpdateError event code does not set Status to Continue. 
            See "Handling Update Errors on the Client" for details.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.Update(System.String[])">
            <summary>
            Updates (commits) all changed data set rows to the database.
            </summary>
            <remarks>Update method without parameters updates the whole data set.
            <para>Update method with tableNames parameter updates only changes in the tables listed in tableNames. 
            The tableNames parameter must contain a list of simple tables (not composite tables or table views).</para>
            <para>Update method with tableNames parameter does not allow updating a table that is used in a composite 
            table as a main constituent table (is connected to its parent in the composite table diagram with a 
            one-to-many relation; the restriction does not apply to those connected many-to-one). 
            If this restriction is not satisfied, the method throws an exception. 
            In such case, always use Update without parameters to update the whole data set.</para>
            <para>An unsuccessful update, including one resulting in an exception, triggers <see cref="E:C1.Data.C1DataSet.UpdateError"/> event. 
            If user code sets the event's Status argument to Continue, an update attempt is made again. 
            This loop continues until either the update succeeds or UpdateError event code does not set Status to Continue. 
            See "Handling Update Errors on the Client" for details.</para>
            </remarks>
            <param name="tableNames">Array containing the names of simple tables to be updated to the database.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.GetChanges">
            <summary>
            Gets a copy of the data set containing all changes to simple tables made since it was last filled, 
            or since <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> was called. Composite tables and table views are empty in the resulting data set.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataSet.GetChanges(System.String[],C1.Data.DataRowStateEnum)">
            <summary>
            Gets a copy of the data set containing all changes to simple tables made since it was last filled, 
            or since <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> was called. Composite tables and table views are empty in the resulting data set.
            </summary>
            <param name="tableNames">Names of the tables whose modified rows are to be included in the resulting data set. If this argument is null, modified rows of all tables are included.</param>
            <param name="rowStates">One or more (combination of) flags Added, Modified, Deleted indicating what rows to include.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.Merge(C1.Data.C1DataSet)">
            <summary>
            Merges the parameter data set containing only simple table data into this (caller) data set.
            </summary>
            <remarks>This method copies the data contained in the dataSet argument to the calling C1DataSet. 
            It is used to refresh a data set after its modified rows are updated to the database in a business method, 
            see "Business Methods". The normal sequence is to obtain a data set with the <see cref="M:C1.Data.C1DataSet.GetChanges"/> method, 
            pass it to the business method, return the passed data set back from the business method and 
            call Merge for the original data set with the returned data set as the parameter.
            <para>The dataSet argument object must contain only simple table rows. If one of its table views or 
            composite tables is not empty, this method throws an exception.</para>
            <para>For example, see CustomFillUpdate sample.</para>
            </remarks>
            <param name="dataSet">The dataSet that will be merged into the calling data set.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.AcceptChanges">
            <summary>
            Commits all changes made to the data set since it was filled with data or the last time <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> or <see cref="M:C1.Data.C1DataSet.RejectChanges"/> was called.
            </summary>
            <remarks>After this method the current state of all data set rows except deleted rows becomes also their original state.
            <para>Any <see cref="T:C1.Data.C1DataRow"/> objects still in edit mode successfully end their edits. 
            The <see cref="P:C1.Data.C1DataRow.RowState"/> property of each <see cref="T:C1.Data.C1DataRow"/> changes: 
            Added and Modified rows become Unchanged, and Deleted rows are removed.</para>
            <para><see cref="M:C1.Data.C1DataTable.AcceptChanges"/> can also be called for a single simple table.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.RejectChanges">
            <summary>
            Rolls back all changes made to the data set since it was filled with data or the last time <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> or <see cref="M:C1.Data.C1DataSet.RejectChanges"/> was called.
            </summary>
            <remarks>
            This method returns all data set rows to their original state.
            <para>When the RejectChanges method is called, any rows still in edit mode successfully cancel 
            their edits. New rows are removed. Modified and deleted rows return back to their original 
            state (See <see cref="T:C1.Data.DataRowStateEnum"/>).</para>
            <para><see cref="M:C1.Data.C1DataTable.RejectChanges"/> can also be called for a single simple table.</para>
            </remarks>
            <seealso cref="M:C1.Data.C1DataTable.RejectChanges"/>
        </member>
        <member name="M:C1.Data.C1DataSet.HasChanges">
            <summary>
            Gets a value indicating whether the data set has changes, including new, deleted, or modified rows, 
            optionally filtered by <see cref="T:C1.Data.DataRowStateEnum"/>.
            </summary>
            <remarks>
            You can examine HasChanges before calling <see cref="M:C1.Data.C1DataSet.GetChanges"/> method.
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.HasChanges(C1.Data.DataRowStateEnum)">
            <summary>
            Gets a value indicating whether the data set has changes, including new, deleted, or modified rows, 
            optionally filtered by <see cref="T:C1.Data.DataRowStateEnum"/>.
            </summary>
            <remarks>
            You can examine HasChanges before calling <see cref="M:C1.Data.C1DataSet.GetChanges"/> method.
            </remarks>
            <param name="rowState">One of the DataRowStateEnum values.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.PushExecutionMode(C1.Data.ExecutionModeEnum)">
            <summary>
            Sets the execution mode affecting actions invoked while handling another action.
            </summary>
            <remarks>
            When <see cref="M:C1.Data.C1DataSet.PopExecutionMode"/> method is called, 
            it restores the last mode that existed before PushExecutionMode call. 
            PushExecutionMode and <see cref="M:C1.Data.C1DataSet.PopExecutionMode"/> are the push/pop operations of a stack.
            </remarks>
            <param name="mode">One of the <see cref="T:C1.Data.ExecutionModeEnum"/> values.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.PopExecutionMode">
            <summary>
            Restores the execution mode affecting actions invoked while handling another action.
            </summary>
            <remarks>
            When PopExecutionMode method is called, it restores the last mode that existed before <see cref="M:C1.Data.C1DataSet.PushExecutionMode(C1.Data.ExecutionModeEnum)"/> call. <see cref="M:C1.Data.C1DataSet.PushExecutionMode(C1.Data.ExecutionModeEnum)"/> and PopExecutionMode are the push/pop operations of a stack.
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.WriteXml(System.String)">
            <summary>
            Writes XML data from the data set.
            </summary>
            <remarks>
            The WriteXml method is used to save the data in an XML form so it can be later restored with <see cref="M:C1.Data.C1DataSet.ReadXml(System.String)"/>. 
            Together, these methods allow to save the whole data contents of a <see cref="T:C1.Data.C1DataSet"/> and restore it later, 
            for example, to save work when no database connection is available to save it in the database, 
            and restore it and send to the database for update when the connection becomes available.
            </remarks>
            <param name="fileName">The file name (including the path) to which to write.</param>
            <seealso cref="M:C1.Data.C1DataSet.ReadXml(System.String)"/>         
        </member>
        <member name="M:C1.Data.C1DataSet.WriteXml(System.IO.Stream)">
            <summary>
            Writes XML data from the data set.
            </summary>
            <remarks>
            The WriteXml method is used to save the data in an XML form so it can be later restored with <see cref="M:C1.Data.C1DataSet.ReadXml(System.String)"/>. 
            Together, these methods allow to save the whole data contents of a <see cref="T:C1.Data.C1DataSet"/> and restore it later, 
            for example, to save work when no database connection is available to save it in the database, 
            and restore it and send to the database for update when the connection becomes available.
            </remarks>
            <param name="stream">The stream to which to write.</param>
            <seealso cref="M:C1.Data.C1DataSet.ReadXml(System.String)"/>         
        </member>
        <member name="M:C1.Data.C1DataSet.WriteXml(System.Xml.XmlTextWriter)">
            <summary>
            Writes XML data from the data set.
            </summary>
            <remarks>
            The WriteXml method is used to save the data in an XML form so it can be later restored with <see cref="M:C1.Data.C1DataSet.ReadXml(System.String)"/>. 
            Together, these methods allow to save the whole data contents of a <see cref="T:C1.Data.C1DataSet"/> and restore it later, 
            for example, to save work when no database connection is available to save it in the database, 
            and restore it and send to the database for update when the connection becomes available.
            </remarks>
            <param name="writer">The XmlReader to which to write.</param>
            <seealso cref="M:C1.Data.C1DataSet.ReadXml(System.String)"/>
        </member>
        <member name="M:C1.Data.C1DataSet.ReadXml(System.String)">
            <summary>
            Reads XML data into the data set.
            </summary>
            <remarks>
            The ReadXml method is used to restore the data previously saved by <see cref="M:C1.Data.C1DataSet.WriteXml(System.String)"/>. 
            Together, these methods allow to save the whole data contents of a <see cref="T:C1.Data.C1DataSet"/> and restore it later, 
            for example, to save work when no database connection is available to save it in the database, 
            and restore it and send to the database for update when the connection becomes available.
            </remarks>
            <param name="fileName">The file name (including the path) from which to read.</param>
            <seealso cref="M:C1.Data.C1DataSet.WriteXml(System.String)"/>
        </member>
        <member name="M:C1.Data.C1DataSet.ReadXml(System.IO.Stream)">
            <summary>
            Reads XML data into the data set.
            </summary>
            <remarks>
            The ReadXml method is used to restore the data previously saved by <see cref="M:C1.Data.C1DataSet.WriteXml(System.String)"/>. 
            Together, these methods allow to save the whole data contents of a <see cref="T:C1.Data.C1DataSet"/> and restore it later, 
            for example, to save work when no database connection is available to save it in the database, 
            and restore it and send to the database for update when the connection becomes available.
            </remarks>
            <param name="stream">The stream from which to read.</param>
            <seealso cref="M:C1.Data.C1DataSet.WriteXml(System.String)"/>
        </member>
        <member name="M:C1.Data.C1DataSet.ReadXml(System.Xml.XmlReader)">
            <summary>
            Reads XML data into the data set.
            </summary>
            <remarks>
            The ReadXml method is used to restore the data previously saved by <see cref="M:C1.Data.C1DataSet.WriteXml(System.String)"/>. 
            Together, these methods allow to save the whole data contents of a <see cref="T:C1.Data.C1DataSet"/> and restore it later, 
            for example, to save work when no database connection is available to save it in the database, 
            and restore it and send to the database for update when the connection becomes available.
            </remarks>
            <param name="reader">The XmlReader which to read.</param>
            <seealso cref="M:C1.Data.C1DataSet.WriteXml(System.String)"/>
        </member>
        <member name="M:C1.Data.C1DataSet.GetExportDataSet">
            <summary>
            Creates and fills with data an ADO.NET data set consisting of this data set's table views.
            </summary>
            <remarks>
            This method can be used to export data and to integrate C1DataObjects with reporters, such as CrystalReports.
            <para>It returns an ADO.NET DataSet containing a table for each table view in the C1DataObjects data set definition, and a relation for each view relation.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.GetExportDataSet(System.Boolean)">
            <summary>
            Creates and fills with data an ADO.NET data set consisting of this data set's table views.
            </summary>
            <remarks>
            This method can be used to export data and to integrate C1DataObjects with reporters, such as CrystalReports.
            <para>It returns an ADO.NET DataSet containing a table for each table view in the C1DataObjects data set definition, and a relation for each view relation.</para>
            </remarks>
            <param name="schemaOnly">If True, System.Data.DataSet is created and returned with schema information but without data rows.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.StorageChangeBegin">
            <summary>
            Begins the process of modifying/synchronizing the underlying ADO.NET DataSet.
            </summary>
            <remarks>
            The process of modifying/synchronizing the underlying ADO.NET DataSet, see <span style="Link Topic">Working with ADO.NET Dataset</span>, 
            consists of two stages:
            <para>First stage (between <see cref="M:C1.Data.C1DataSet.StorageChangeBegin"/> and <see cref="M:C1.Data.C1DataSet.StorageChanged"/>) is for modifying the ADO.NET data 
            set C1DataSet.StorageDataSet by any means available in ADO.NET. Simple tables are filled with rows 
            or modified at this stage.</para>
            <para>Second stage (between <see cref="M:C1.Data.C1DataSet.StorageChanged"/> and <see cref="M:C1.Data.C1DataSet.StorageChangeEnd"/>) is for synchronizing the <see cref="T:C1.Data.C1DataSet"/> 
            with changed underlying data. Table views are filled with rows on this stage, using the <see cref="M:C1.Data.C1DataSet.SetTableViewRows(System.String,System.Collections.ICollection,System.String)"/>
            method.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.StorageChanged">
            <summary>
            Marks the end of the first stage of modifying/synchronizing the underlying ADO.NET DataSet.
            </summary>
            <remarks>
            The process of modifying/synchronizing the underlying ADO.NET DataSet consists of two stages:
            <para>First stage (between <see cref="M:C1.Data.C1DataSet.StorageChangeBegin"/> and StorageChanged) is for modifying the ADO.NET 
            data set <see cref="P:C1.Data.C1DataSet.StorageDataSet"/> by any means available in ADO.NET. 
            Simple tables are filled with rows or modified at this stage.</para>
            <para>Second stage (between StorageChanged and <see cref="M:C1.Data.C1DataSet.StorageChangeEnd"/>) is for synchronizing the <see cref="T:C1.Data.C1DataSet"/> 
            with changed underlying data. Table views are filled with rows on this stage, 
            using the <see cref="M:C1.Data.C1DataSet.SetTableViewRows(System.String,System.Collections.ICollection,System.String)"/> method.</para>
            <para>StorageChanged call is required between <see cref="M:C1.Data.C1DataSet.StorageChangeBegin"/> and <see cref="M:C1.Data.C1DataSet.StorageChangeEnd"/>, 
            to mark the end of the first stage and the beginning of the second.</para>
            <para>Calling StorageChanged with clearTableViews=False allows to make simple changes to 
            <see cref="P:C1.Data.C1DataSet.StorageDataSet"/> without modifying table view rows. 
            For example, you might want to change some field values in the underlying ADO.NET data set, 
            and you are sure that this will not affect table view rows in any way, 
            that is, all table view rows will still point to the same table rows, only data in the table 
            rows will change. In such case, you can use clearTableViews=False and skip the second stage 
            (synchronization). But this must be done with caution, because C1DataObjects does not verify 
            these conditions. If, for example, you delete a table row that was pointed to by a table view row, 
            it will cause unpredictable behavior. Also, using clearTableViews=False means that the collection 
            of table view rows will not change, so any rows added to the ADO.NET data set will not be reflected 
            in the table views.</para>
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataSet.StorageChanged(System.Boolean)">
            <summary>
            Marks the end of the first stage of modifying/synchronizing the underlying ADO.NET DataSet.
            </summary>
            <remarks>
            The process of modifying/synchronizing the underlying ADO.NET DataSet consists of two stages:
            <para>First stage (between <see cref="M:C1.Data.C1DataSet.StorageChangeBegin"/> and StorageChanged) is for modifying the ADO.NET 
            data set <see cref="P:C1.Data.C1DataSet.StorageDataSet"/> by any means available in ADO.NET. 
            Simple tables are filled with rows or modified at this stage.</para>
            <para>Second stage (between StorageChanged and <see cref="M:C1.Data.C1DataSet.StorageChangeEnd"/>) is for synchronizing the <see cref="T:C1.Data.C1DataSet"/> 
            with changed underlying data. Table views are filled with rows on this stage, 
            using the <see cref="M:C1.Data.C1DataSet.SetTableViewRows(System.String,System.Collections.ICollection,System.String)"/> method.</para>
            <para>StorageChanged call is required between <see cref="M:C1.Data.C1DataSet.StorageChangeBegin"/> and <see cref="M:C1.Data.C1DataSet.StorageChangeEnd"/>, 
            to mark the end of the first stage and the beginning of the second.</para>
            <para>Calling StorageChanged with clearTableViews=False allows to make simple changes to 
            <see cref="P:C1.Data.C1DataSet.StorageDataSet"/> without modifying table view rows. 
            For example, you might want to change some field values in the underlying ADO.NET data set, 
            and you are sure that this will not affect table view rows in any way, 
            that is, all table view rows will still point to the same table rows, only data in the table 
            rows will change. In such case, you can use clearTableViews=False and skip the second stage 
            (synchronization). But this must be done with caution, because C1DataObjects does not verify 
            these conditions. If, for example, you delete a table row that was pointed to by a table view row, 
            it will cause unpredictable behavior. Also, using clearTableViews=False means that the collection 
            of table view rows will not change, so any rows added to the ADO.NET data set will not be reflected 
            in the table views.</para>
            </remarks>
            <param name="clearTableViews">Whether to clear all table view rows or not. This parameter is True by default, meaning that table views are cleared at the end of the first stage.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.GetDefaultTableViewRows(System.String)">
            <summary>
            Returns the list of all potential table view rows, pointers to all existing table rows.
            </summary>
            <remarks>
            This method can be used only on the second stage of ADO.NET data set modification/synchronization process, 
            see <span style="Link Topic">Working with ADO.NET Dataset</span>.
            <para>This method returns a list that can be passed as a parameter to <see cref="M:C1.Data.C1DataSet.SetTableViewRows(System.String,System.Collections.ICollection,System.String)"/>. 
            If you pass it unchanged, the table view will contain all existing table rows, unrestricted. 
            Filtering this list, building another list from its elements, you can restrict (filter) the table view.</para>
            <para>Elements of the returned ArrayList are:</para>
            <para>For a table view based on a simple table: <see cref="T:C1.Data.C1DataRow"/> objects, rows of the corresponding table.</para>
            <para>For a table view based on a composite table: arrays of type <see cref="T:C1.Data.C1DataRow"/>[], 
            with length equal to the number of "main" simple tables in the composite table 
            ("main" means connected to its parent with a 1-M relation, not with an M-1 one). 
            That is, every element of the list is an array of table rows, one for each "main" constituent table. 
            A composite table can also contain "linked" constituent tables (connected to their parents with 
            M-1 relations). Since "linked" rows can be uniquely located given the values in "main" rows, 
            they are not used here.</para>
            </remarks>
            <param name="tableViewName">The name of the table view for which to return the list of potential rows.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.SetTableViewRows(System.String,System.Collections.ICollection,System.String)">
            <summary>
            Fills a table view with rows pointing to table rows.
            </summary>
            <remarks>
            This method fills a table view with rows. It can be used only on the second stage of ADO.NET 
            data set modification/synchronization process, see <span style="Link Topic">Working with ADO.NET Dataset</span>.
            <para>The rows are passed in as the tableRows collection. Elements of this collection are pointers 
            to table rows:</para>
            <para>For a table view based on a simple table: <see cref="T:C1.Data.C1DataRow"/> objects, rows of the corresponding table.</para>
            <para>For a table view based on a composite table: arrays of type <see cref="T:C1.Data.C1DataRow"/>[], 
            with length equal to the number of "main" simple tables in the composite table 
            ("main" means connected to its parent with a 1-M relation, not with an M-1 one). 
            That is, every element of the list is an array of table rows, one for each "main" constituent table. 
            A composite table can also contain "linked" constituent tables (connected to their parents 
            with M-1 relations). Since "linked" rows can be uniquely located given the values in "main" rows, 
            they are not used here.</para>
            <para>The input collection of rows can be obtained by one of the two methods.</para>
            <list type="bullet"> 
            <item><term>First is to call <see cref="M:C1.Data.C1DataSet.GetDefaultTableViewRows(System.String)"/> and optionally filter the returned list 
            according to some filtering criteria. This method is convenient, but may be performance-heavy 
            for composite tables where <see cref="M:C1.Data.C1DataSet.GetDefaultTableViewRows(System.String)"/> uses unrestricted joined tables that sometimes 
            can produce a large number of rows, because no conditions are checked except the join 
            conditions of the 1-M relations forming the composite table.</term></item>
            <item><term>The alternative method is to scan rows of constituent tables in nested loops, without 
            calling <see cref="M:C1.Data.C1DataSet.GetDefaultTableViewRows(System.String)"/>. In this case you have more control on which rows you examine 
            and which rows you skip, that in some cases can lead to better performance.</term></item>
            </list>
            <para>After table view rows are created, they are sorted according to the fillSort argument. 
            The sort syntax is the same as in the <see cref="T:C1.Data.SchemaObjects.TableView"/>.<see cref="P:C1.Data.SchemaObjects.TableView.FillSort"/> property, for example, "CustomerID, 
            OrderDate DESC" (DESC means descending order). If fillSort is empty, the value of 
            <see cref="T:C1.Data.SchemaObjects.TableView"/>.<see cref="P:C1.Data.SchemaObjects.TableView.FillSort"/> property is used for sorting. If that is empty, the rows are sorted 
            by primary key.</para>
            </remarks>
            <param name="tableViewName">The name of the table view to fill with rows.</param>
            <param name="tableRows">The list of pointers to table rows.</param>
            <param name="fillSort">Optional sort to apply to the table view row collection.</param>
        </member>
        <member name="M:C1.Data.C1DataSet.StorageChangeEnd">
            <summary>
            Ends the process of modifying/synchronizing the underlying ADO.NET DataSet.
            </summary>
            <remarks>
            Related topics: <see cref="M:C1.Data.C1DataSet.StorageChangeBegin"/> Method, <see cref="M:C1.Data.C1DataSet.StorageChanged"/> Method.
            </remarks>
        </member>
        <member name="E:C1.Data.C1DataSet.BeforeFill">
            <summary>
            Fired before the data set fills with data.
            </summary>
            <remarks>
            This event is fired on the client before calling the server to fill the data set with data. It is fired both when Fill is called and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True.
            <para>In this event, you can add filter conditions to Filter before passing the request on to the server.</para>
            </remarks>
            <seealso cref="M:C1.Data.C1DataSet.Fill"/>
        </member>
        <member name="E:C1.Data.C1DataSet.AfterFill">
            <summary>
            Fired after the data set is filled with data.
            </summary>
            <remarks>
            This event is fired on the client after the data set is filled with data. It is fired both when <see cref="M:C1.Data.C1DataSet.Fill"/> is called and when the data set is filled at startup due to <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> = True.
            <para>In this event, you can modify the data set after it has been filled with data fetched from the server.</para>
            </remarks>
            <seealso cref="M:C1.Data.C1DataSet.Fill"/>
        </member>
        <member name="E:C1.Data.C1DataSet.PositionChanged">
            <summary>
            Fired when one of the data set data members changes current row position.
            </summary>
            <remarks>
            Current row position is managed by the form containing the data set component. Each DataMember has its own current row position that is managed by a System.Windows.Forms.CurrencyManager object attached to it by the form. Data bound controls interact with CurrencyManager to synchronize with current row position and request moving to a new row position.
            <para>Whenever current row position changes for any of the data set data members, the PositionChanged event fires. It allows you to associate business logic with changes in current row position.</para>
            </remarks>
        </member>
        <member name="E:C1.Data.C1DataSet.CurrentRowChanged">
            <summary>
            Fired when there are changes in the current row, whatever their cause, resulting from field change, current row change or complete data refresh.
            </summary>
            <remarks>
            The CurrentRowChanged event is useful in scenarios like synchronizing detail data with the master row on every change occurring in the master row. The CurrentRowChanged event is triggered in two main cases: 
            <para>1.   When row currency changes, another row becomes current, or the whole rowset is refreshed. In this case, event argument property ChangeType is set to RowChangedTypeEnum.CurrentRowChanged.</para>
            <para>2.   When the value of a field (or several fields) in the current row is changed. In this case, event argument property ChangeType is set to RowChangedTypeEnum.FieldsChanged.</para>
            </remarks>
            <seealso cref="E:C1.Data.C1DataSet.PositionChanged"/>
        </member>
        <member name="E:C1.Data.C1DataSet.UpdateError">
            <summary>
            Fired when an error occurs committing changes to the dataset.
            </summary>
            <remarks>
            An unsuccessful update, including one resulting in an exception, triggers UpdateError event. 
            If user code sets the event's Status argument to Continue, an update attempt is made again. 
            This loop continues until either the update succeeds or UpdateError event code does not set Status 
            to Continue. See <span style="Link Topic">Handling Update Errors on the Client</span> for details.
            <para>If the error is a fatal failure (a program or physical error, see 
            <span style="Link Topic">Handling Errors in Update</span>), the Error argument contains the exception 
            object describing the failure. If this is a concurrency conflict that could not be reconciled on 
            the server (see <span style="Link Topic">Handling Concurrency Conflicts</span>), the Error argument 
            is set to null (Nothing in Visual Basic). In case of a concurrency conflict, the rows that failed 
            update can be found in the DataSet using the properties <see cref="P:C1.Data.C1DataRow.RowError"/>, <see cref="P:C1.Data.C1DataSet.HasErrors"/> and 
            <see cref="M:C1.Data.C1DataTable.GetErrors"/>.</para>
            </remarks>
            <seealso cref="M:C1.Data.C1DataSet.Update"/>
        </member>
        <member name="E:C1.Data.C1DataSet.Error">
            <summary>
            Fired when an error occurs.
            </summary>
            <remarks>
            This event gives developers full control over error (exception) handling. It allows to 
            customize/localize error messages or provide a fully customized error handling if necessary. 
            <para>When this event is fired, the Status argument is set either to ErrorsOccured or to Continue. 
            It is set to ErrorsOccured if the error occurred during an action executed from code, and to 
            Continue if it occurred performing an action requested by data bound controls.</para>
            <para>What happens next, whether the error is considered handled or throws an exception, depends 
            on the value you assign to the Status argument:</para>
            <para>1.   If you set Status to ErrorsOccured, an exception is thrown. To specify the exception 
            information, set the Error argument. Use this option in cases where you do not need to override 
            the standard exception handling.</para>
            <para>2.   If you set Status to Skip, the error is considered handled and operation resumes as 
            if the error has not occurred (but subsequent actions may not be executed when they depend on the 
            successful completion of the current action). Use this option when you want to handle the error in 
            your code, suppress the standard error handling and consider the operation successful.</para>
            <para>3.   If you set Status to Continue, C1DataObjects shows a standard error message box and 
            resumes operation without throwing an exception (as in the Skip case). Use this option when you 
            are satisfied with the standard C1DataObjects error message and want to consider the operation successful.</para>
            <para>4.   It is also possible that you need to show a custom error message or otherwise handle 
            the error in the Error event, then throw an exception, but do not want data bound controls to 
            show their own error messages because you have already shown an error message. To accomplish that, 
            set Status to ErrorsOccured and throw an exception derived from <see cref="T:C1.Data.C1DataException"/> 
            with ShowMessage property set to False. Note that this behavior is only supported by data bound 
            controls honoring the ShowMessage property, such as ComponentOne FlexGrid and C1TrueDBGrid.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.DataSetDef">
            <summary>
            Gets or sets the name of the data set in the schema.
            </summary>
            <remarks>
            This property determines the schema data set definition represented by this data set.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.FillOnRequest">
            <summary>
            Gets or sets a value indicating whether the data set will be automatically filled with data when a data bound control requests data from it.
            </summary>
            <remarks>
            If this property is set to True (default), the data set is automatically filled with data at startup, once a control bound to it requests data. 
            <para>If it is set to False, the data set remains empty until the <see cref="M:C1.Data.C1DataSet.Fill"/> method is called.</para>    
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.Filled">
            <summary>
            Gets a value indicating whether the data set is filled with data.
            </summary>
            <remarks>
            This run-time read-only property returns True if the data set has already been filled with data, 
            either by the <see cref="M:C1.Data.C1DataSet.Fill"/> or, if the <see cref="P:C1.Data.C1DataSet.FillOnRequest"/> property was set to True, by a request from a data 
            bound control.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.DataLibrary">
            <summary>
            Gets or sets the name of the data library containing the schema.
            </summary>
            <remarks>
            In a client application using a data library, this property determines the name of the data library containing the schema for this data set. It is the name of a data library assembly included in the project References. The name does not include the ".dll" extension.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.DataLibraryUrl">
            <summary>
            In a 3-tier client application, this property gets or sets the URL of the data library located on the server.
            </summary>
            <remarks>
            In a 3-tier application, data library runs both on the server and on the client. The DataLibrary property identifies the data library on the client. The DataLibraryUrl property identifies data library on the server. Using this URL, client-side data library invokes the data library on the server.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.SchemaDef">
            <summary>
            Returns or sets the <see cref="T:C1.Data.C1SchemaDef"/> component hosting the schema on which the data set is based.
            </summary>
            <remarks>
            This property determines the C1SchemaDef component to which the data set is connected.
            <para>In direct client applications, this property is usually set at design time to a <see cref="T:C1.Data.C1SchemaDef"/> component residing in the same form.</para>
            <para>In a client application using a data library, this property is left empty. The <see cref="T:C1.Data.SchemaObjects.Schema"/> is retrieved from the data library.</para>
            </remarks>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
            <seealso><span style="Link Topic">Application configurations</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.Schema">
            <summary>
            Returns the <see cref="T:C1.Data.SchemaObjects.Schema"/> object representing the schema on which the 
            data set is based.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataSet.SchemaContainer">
            <summary>
            Returns the container object hosting the <see cref="T:C1.Data.C1SchemaDef"/> component in the data library.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataSet.Tables">
            <summary>
            This run-time property returns the collection of tables in the data set.
            </summary>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.TableViews">
            <summary>
            This run-time property returns the collection of table views in the data set.
            </summary>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.StorageDataSet">
            <summary>
            Gets the ADO.NET DataSet where table data rows are stored.
            </summary>
            <seealso><span style="Link Topic">Working with ADO.NET Dataset</span></seealso>
            <seealso><span style="Link Topic">C1DataObjects and ADO.NET</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.ExecutionMode">
            <summary>
            Gets a value indicating whether actions in handling a business logic event are deferred or performed immediately.
            </summary>
            <remarks>
            This property affects how C1DataObjects performs actions while inside a business logic event. 
            If this run-time property is set to Immediate (default), actions are performed immediately. 
            If it is set to Deferred, actions are deferred until the current user action handling is completed.
            <para>This property is read-only. To set execution mode, call the <see cref="M:C1.Data.C1DataSet.PushExecutionMode(C1.Data.ExecutionModeEnum)"/> method, 
            passing it the new mode as a parameter. To restore the previous execution mode, 
            call the <see cref="M:C1.Data.C1DataSet.PopExecutionMode"/> method.</para>
            </remarks>
            <seealso><span style="Link Topic">Action Order and Execution Mode</span></seealso>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.EnforceConstraints">
            <summary>
            Gets or sets a value indicating whether relation constraints must be satisfied while modifying the data set.
            </summary>
            <remarks>
            This run-time property is set to True by default, which means that C1DataObjects enforces 
            relation parent-child constraints when the data set is modified. Relation constraints are 
            imposed by simple relations with <see cref="!:C1.Data.SchemaObjects.Relation.EnforceConstraints"/> property set to True. They do not allow 
            child records without parent.
            </remarks>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.ChangeInProgress">
            <summary>
            Gets or sets a value indicating whether firing <see cref="E:C1.Data.BaseLogic.AfterChanges"/> event is deferred.
            </summary>
            <remarks>
            This property, available only at run time, is set to False by default. 
            Setting it to True, defers firing AfterChanges event until this property is set back to False.
            <para>Normally, <see cref="E:C1.Data.BaseLogic.AfterChanges"/> event is fired after every change to a field value. Sometimes, 
            it is desirable to make multiple field changes in a batch without firing this event, 
            and fire the event only when all changes are done. Setting ChangeInProgress to True enables 
            this mode of firing <see cref="E:C1.Data.BaseLogic.AfterChanges"/> for all rows of the data set.</para>
            </remarks>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.SuppressNotifications">
            <summary>
            Gets or sets a value indicating whether data bound controls must be notified of changes in the data set.
            </summary>
            <remarks>
            This run-time property is set to True by default, which means that data bound controls receive 
            notifications of any change made to the data set. Notifications are issued by C1DataObjects after 
            every end-user or programmatic action causing changes in the data set. C1DataObjects issues notifications 
            when the action is completely handled. Having received a change notification, data bound controls 
            usually repaint themselves to reflect the changed data.
            <para>In some cases, it is necessary to suppress notifications to be able to perform multiple actions 
            in a batch without causing changes in data bound controls. Setting the SuppressNotifications property 
            to False disables sending notifications to data bound controls. If you suppress notifications, 
            data bound controls will not be notified of any changes, so you have to explicitly 
            call <see cref="M:C1.Data.C1DataTable.Refresh"/> for all changed table views to make data bound 
            controls refresh their contents.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.NotificationModeFlags">
            <summary>
            Flags affecting the way change notifications are sent to data bound controls.
            </summary>
            <remarks>
            For data bound controls that rely on specific ADO.NET notification behavior, set 
            NotificationMode=ListChangedFlags.Ado.Net.
            <para>C1DataObjects uses a slightly different notification scheme (calling the 
            IBindingList.ListChanged event) than ADO.NET does. C1DataObjects notifications are fully 
            .NET data binding-compliant and optimized for data bound controls. All ComponentOne bound 
            controls and Microsoft bound controls work properly with this notification scheme. 
            However, some (very few) third-party bound controls may not work properly unless notifications 
            are fully ADO.NET compliant. In fact, all data bound controls should work with C1DataObjects 
            notifications without problems, but in the non-ideal world that can be broken. 
            To prevent this problem and allow using any bound controls, C1DataObjects provides this property.</para>
            <para>If you need this property in C1DataExpress, set C1ExpressConnection.DataSet.NotificationModeFlags or .ExpressConnection.DataSet.NotificationModeFlags in code, at run time.</para>
            <para>The notifications can be turned off altogether using the <see cref="P:C1.Data.C1DataSet.SuppressNotifications"/> property.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.Locale">
            <summary>
            Determines the locale information used in string comparisons within the data set.
            </summary>
            <remarks>
            This property affects string comparison in expression evaluation, sorting table views by 
            the end user (via IBindingList.ApplySort) and sorting in <see cref="T:C1.Data.C1DataView"/> objects.
            <para>By default, all <see cref="T:C1.Data.C1DataTable"/> objects created by a C1DataSet use the Locale property 
            of the C1DataSet, but it can be overridden setting the <see cref="P:C1.Data.C1DataTable.Locale"/> property of the <see cref="T:C1.Data.C1DataTable"/> object.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1DataView"/>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.CaseSensitive">
            <summary>
            Determines whether string comparisons within the data set are case-sensitive.
            </summary>
            <remarks>
            This property affects string comparison in expression evaluation, sorting table views by 
            the end user (via IBindingList.ApplySort) and sorting in <see cref="T:C1.Data.C1DataView"/> objects.
            <para>By default, all <see cref="T:C1.Data.C1DataTable"/> objects created by a C1DataSet use the CaseSensitive property 
            of the C1DataSet, but it can be overridden setting the <see cref="P:C1.Data.C1DataTable.CaseSensitive"/> property of the <see cref="T:C1.Data.C1DataTable"/> object.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.SortComparisonMode">
            <summary>
            Determines the type of string comparison within the data set.
            </summary>
            <remarks>
            This property affects string comparison in expression evaluation, sorting table views by 
            the end user (via IBindingList.ApplySort) and sorting in <see cref="T:C1.Data.C1DataView"/> objects.
            <para>By default, all <see cref="T:C1.Data.C1DataTable"/> objects created by a C1DataSet use the SortComparisonMode property 
            of the C1DataSet, but it can be overridden setting the <see cref="P:C1.Data.C1DataTable.SortComparisonMode"/> property of the <see cref="T:C1.Data.C1DataTable"/> object.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.ExtendedProperties">
            <summary>
            Gets a collection of custom user information associated with the data set.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataSet.HasErrors">
            <summary>
            Gets a value indicating whether there are errors in any of the rows in any of the tables of this data set.
            </summary>
            <remarks>
            You can use the HasErrors property of the data set to determine if any table has errors, 
            before checking individual <see cref="T:C1.Data.C1DataTable"/> objects in the <see cref="P:C1.Data.C1DataSet.Tables"/> collection. 
            To get all errors of an individual <see cref="T:C1.Data.C1DataTable"/>, use its <see cref="M:C1.Data.C1DataTable.GetErrors"/> method.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataSet.DynamicConnections">
            <summary>
            Gets a collection of Connection objects used at run time as substitutes for schema connections.
            </summary>
            <remarks>
            This property changes connection at run time for a single data set. 
            If you need to change schema connection for all data sets at once, set Connection.ConnectionString 
            in the CreateSchema event.
            <para>By default, if C1DataSet.DynamicConnections is empty, data fetch and update for 
            this data set uses the connections specified in the schema.</para>
            <para>Add a connection object for each connection you want to change at run time for this data set. 
            Usually, you will add a copy of a schema connection object(s) using <see cref="M:C1.Data.SchemaObjects.Connection.Clone"/>. 
            Alternatively, you can create new connection objects from scratch, for example, new <see cref="T:C1.Data.SchemaObjects.C1OleDbConnection"/>(). 
            Adding an existing connection object from schema to DynamicConnections throws an exception. 
            This prevents changes unintentionally affecting other data sets attached to the same schema.</para>
            <para>Having added a connection object, set its properties as desired. 
            Usually, only the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionString"/> needs to be changed in connection objects obtained 
            with <see cref="M:C1.Data.SchemaObjects.Connection.Clone"/>. If you created a new connection object, without using <see cref="M:C1.Data.SchemaObjects.Connection.Clone"/>, 
            set its <see cref="P:C1.Data.SchemaObjects.Connection.Name"/> property to the name of the schema connection you want to modify.</para>
            <para>When the data set performs a fetch or update operation while its DynamicConnections 
            collection is not empty, it first looks for connection properties in DynamicConnection, 
            and only then, if not found, in the schema. If DynamicConnections contains a connection with 
            the same <see cref="P:C1.Data.SchemaObjects.Connection.Name"/> as the schema connection, that DynamicConnections element is used instead of the 
            schema connection.</para>
            </remarks>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSet.Credentials">
            <summary>
            Gets or sets username, password and domain used to communicate with the server.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataSet.RemoteDataService">
            <summary>
            Gets the RemoteDataService-derived class of the data library.
            </summary>
            <remarks>
            This property enables the programmer to access the RemoteDataService-derived class in the data library, 
            both in 2-tier and 3-tier configuration. This property is necessary for calling business methods 
            (methods added by the programmer to the RemoteDataService-derived class in the data library). 
            For example, see the CustomFillUpdate sample.
            </remarks>
        </member>
        <member name="T:C1.Data.C1DataView">
            <summary>
            C1DataView is used for sorting and filtering data. 
            </summary>
            <remarks>
            Data bound controls can bind directly 
            to a C1DataView component, see <span style="Link Topic">Using a Data Library</span>. This allows you to use C1DataView to 
            provide separate views into the same data, with different row filter criteria and sorts. 
            Each such view has independent current row, can be independently navigated.
            <para>Another common use of C1DataView is to obtain direct access to simple table data rows. 
            Normal data binding, using <see cref="T:C1.Data.C1DataSet"/> or <see cref="T:C1.Data.C1DataTableSource"/> gives you access to table views. 
            If, for some reason, you need direct access to simple tables behind those table views, you need 
            to use C1DataView with non-empty <see cref="P:C1.Data.C1DataView.TableName"/> property. See <span style="Link Topic">How to Access Table Data</span> for details.</para>
            </remarks>
        </member>
        <member name="T:C1.Data.BaseDataSourceComponent">
            <summary>
            Base class for <see cref="T:C1.Data.C1DataTableSource"/>, <see cref="T:C1.Data.C1DataView"/> and C1DataExpress components.
            </summary>
        </member>
        <member name="T:C1.Data.BaseFormAwareComponent">
            <summary>
            Base class for <see cref="T:C1.Data.C1DataTableSource"/>, <see cref="T:C1.Data.C1DataView"/> and C1DataExpress components.
            </summary>
        </member>
        <member name="E:C1.Data.BaseDataSourceComponent.PositionChanged">
            <summary>
            Fired when controls bound to this component change their current row position.
            </summary>
            <remarks>
            Current row position is managed by the form containing this component, by its 
            CurrencyManager object. Data bound controls interact with CurrencyManager to synchronize 
            with current row position and request moving to a new row position.
            <para>Whenever current row position changes, the PositionChanged event fires. 
            It allows you to associate business logic with changes in current row position.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1DataSet"/>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso cref="P:C1.Data.BaseDataSourceComponent.Position"/>
        </member>
        <member name="E:C1.Data.BaseDataSourceComponent.CurrentRowChanged">
            <summary>
            Fired when there are changes in the current row, whatever their cause, resulting 
            from field change, current row change or complete data refresh.
            </summary>
            <remarks>
            The CurrentRowChanged event is useful in scenarios like synchronizing detail 
            data with the master row on every change occurring in the master row. 
            The CurrentRowChanged event is triggered in two main cases: 
            <para>1.   When row currency changes, another row becomes current, or the whole rowset is refreshed. 
            In this case, event argument property ChangeType is set to <see cref="T:C1.Data.RowChangedTypeEnum"/>.CurrentRowChanged.</para>
            2.   When the value of a field (or several fields) in the current row is changed. 
            In this case, event argument property ChangeType is set to <see cref="T:C1.Data.RowChangedTypeEnum"/>.FieldsChanged.
            </remarks>
            <seealso cref="T:C1.Data.C1DataSet"/>
            <seealso cref="E:C1.Data.BaseDataSourceComponent.PositionChanged"/>
        </member>
        <member name="P:C1.Data.BaseDataSourceComponent.Position">
            <summary>
            Gets or sets the current row position for controls bound to this component.
            </summary>
            <remarks>
            This property gets or sets the Position property of the CurrencyManager 
            (class System.Windows.Forms.CurrencyManager) controlling current row position for controls 
            bound to the component.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
        </member>
        <member name="P:C1.Data.BaseDataSourceComponent.DataTable">
            <summary>
            Gets the source <see cref="T:C1.Data.C1DataTable"/> containing the data.
            </summary>
            <remarks>
            The data table returned by this property is used for programmatic access to the table data.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
        </member>
        <member name="M:C1.Data.C1DataView.#ctor">
            <summary>
            Initializes a new instance of the C1DataView class.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataView.CopyTo(C1.Data.DataItem[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.C1DataView.IndexOf(C1.Data.DataItem)">
            <summary>
            Returns the zero-based index of a given row in the collection.
            </summary>
            <param name="row">The row to locate in the collection.</param>
            <returns>The zero-based index of the row, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.C1DataView.Contains(C1.Data.DataItem)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="row">The row to locate in the collection.</param>
            <returns>True if row is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.C1DataView.CreateChildView(C1.Data.C1DataSet,System.String,C1.Data.C1DataRow)">
            <summary>
            Creates and returns a <see cref="T:C1.Data.C1DataView"/> object containing child rows of a parent row.
            </summary>
            <param name="dataSet">The data set to which the parent row and the child view belong.</param>
            <param name="relationName">The name of the view relation (<see cref="T:C1.Data.SchemaObjects.ViewRelation"/>) between the parent and the child.</param>
            <param name="parentRow">The parent row.</param>
            <remarks>
            This method can be used as an alternative to <see cref="M:C1.Data.C1DataRow.GetChildRows(System.String)"/> for master-detail navigation. 
            For example, you might want to use the resulting <see cref="T:C1.Data.C1DataView"/> as a data source for a data bound control.
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataView.Refresh">
            <summary>
            Refreshes the collection of data view rows.
            </summary>
            <remarks>
            This method re-populates the data view rows, testing the filter conditions and applying sort, 
            if specified. Call this method after changing filter conditions and sort, 
            if <see cref="P:C1.Data.C1DataView.AutoRefresh"/> is set to False.
            </remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataView.Refresh(System.Boolean)">
            <summary>
            Refreshes the collection of data view rows.
            </summary>
            <remarks>
            This method re-populates the data view rows, testing the filter conditions and applying sort, 
            if specified. Call this method after changing filter conditions and sort, 
            if <see cref="P:C1.Data.C1DataView.AutoRefresh"/> is set to False.
            </remarks>
            <param name="thisViewOnly">
            If the thisViewOnly argument is True, only this C1DataView is refreshed. 
            If it is False (default), all C1DataView components based on the same table view are refreshed.
            </param>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataView.AddNew">
            <summary>
            Adds a new row to the data view.
            </summary>
            <remarks>
            This method creates a new empty row and adds it to the source data table of the data view. 
            The new row is filled only with default values, so it may not satisfy the filter conditions 
            if some are set in the <see cref="P:C1.Data.C1DataView.RowFilter"/> property. However, even if this new row does not satisfy filter 
            conditions, it is always included in the data view until <see cref="M:C1.Data.C1DataRow.EndEdit"/> is called, at which time the 
            row is tested for filter conditions and either remains in the data view or not depending on the 
            filter condition.
            </remarks>
            <seealso><span style="Link Topic">Adding Rows and Primary Keys</span></seealso>
        </member>
        <member name="M:C1.Data.C1DataView.Delete(System.Int32)">
            <summary>
            Deletes a row from the source table view or table.
            </summary>
            <remarks>
            After this method, the row is deleted from the source, from the data view and from all other data views based on that source.
            </remarks>
            <param name="index">The index of the row to delete. This is an index in the data view, not in the source table view or table.</param>
        </member>
        <member name="M:C1.Data.C1DataView.Find(System.Object)">
            <summary>
            Finds a row in the data view by the specified sort key value.
            </summary>
            <remarks>
            This method applies only to sorted view, with a non-empty <see cref="P:C1.Data.C1DataView.Sort"/>. It returns the index of the 
            first row in the data view containing the specified sort key value(s). If no such rows are found, 
            it returns a negative number, which is the bitwise complement of the index of the row whose sort 
            key is next to the specified sort key value.
            </remarks>
            <param name="key">The value to search for.</param>
        </member>
        <member name="M:C1.Data.C1DataView.Find(System.Object[])">
            <summary>
            Finds a row in the data view by the specified sort key value.
            </summary>
            <remarks>
            This method applies only to sorted view, with a non-empty <see cref="P:C1.Data.C1DataView.Sort"/>. It returns the index of the 
            first row in the data view containing the specified sort key value(s). If no such rows are found, 
            it returns a negative number, which is the bitwise complement of the index of the row whose sort 
            key is next to the specified sort key value.
            </remarks>
            <param name="key">An array of values to search for.</param>
        </member>
        <member name="E:C1.Data.C1DataView.GetRows">
            <summary>
            Used to programmatically specify the list of rows in a data view.
            </summary>
            <remarks>
            This event can be used to create custom data views in cases where filtering cannot be specified 
            by a simple expression in the <see cref="P:C1.Data.C1DataView.RowFilter"/> property or sorting by a list of fields in the <see cref="P:C1.Data.C1DataView.Sort"/> property.
            <para>The GetRows event is called every time C1DataObjects needs to obtain the list of rows 
            for the data view. It gives the developer an opportunity to specify a list of rows comprising 
            the data view by assigning such list to the e.List event argument. This list can be filtered 
            and sorted in whatever fashion the developer needs it to be, provided it consists of C1DataRow 
            objects belonging to the table view or table on which the data view is based. The list supplied 
            in the event handler will become exactly the list of rows of this data view, unless <see cref="P:C1.Data.C1DataView.RowFilter"/> 
            and/or <see cref="P:C1.Data.C1DataView.Sort"/> properties are not empty, in which case they are applied to the list of rows 
            resulting from the GetRows event.</para>
            <para>Writing code in GetRows event, you can use the e.List argument value passed to the event, 
            which is the complete list of rows as it would appear in the data view if there were no GetRows 
            handler and no <see cref="P:C1.Data.C1DataView.RowFilter"/> and <see cref="P:C1.Data.C1DataView.Sort"/> properties. You can filter and/or sort this list to 
            obtain your custom list, although this is only one possible technique, you can form the 
            resulting list in any other way you need.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.DataSet">
            <summary>
            Gets the data set object to which the data view belongs.
            </summary>
            <remarks>
            This property returns the data set containing this data view's <see cref="P:C1.Data.C1DataView.DataTable"/>.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.TableViewName">
            <summary>
            Gets or sets the name of the source table view for this data view.
            </summary>
            <remarks>
            Only one of the two properties, <see cref="P:C1.Data.C1DataView.TableName"/> or TableViewName can be set to a non-empty string.
            </remarks>
            <seealso cref="P:C1.Data.C1DataView.TableName"/>
        </member>
        <member name="P:C1.Data.C1DataView.TableName">
            <summary>
            Gets or sets the name of the source table for this data view.
            </summary>
            <remarks>
            Only one of the two properties, TableName or <see cref="P:C1.Data.C1DataView.TableViewName"/> can be set to a non-empty string.
            </remarks>
            <seealso cref="P:C1.Data.C1DataView.TableViewName"/>
        </member>
        <member name="P:C1.Data.C1DataView.TableView">
            <summary>
            Gets the schema <see cref="T:C1.Data.SchemaObjects.TableView"/> used in the data view, if the <see cref="P:C1.Data.C1DataView.TableViewName"/> property is set.
            </summary>
            <remarks>
            Only one of the two properties, <see cref="P:C1.Data.C1DataView.TableName"/> or <see cref="P:C1.Data.C1DataView.TableViewName"/> can be set to a non-empty string.
            </remarks>
            <seealso cref="P:C1.Data.C1DataView.Table"/>
        </member>
        <member name="P:C1.Data.C1DataView.Table">
            <summary>
            Gets the schema <see cref="T:C1.Data.SchemaObjects.Table"/> used in the data view, if the <see cref="P:C1.Data.C1DataView.TableName"/> property is set.
            </summary>
            <remarks>
            Only one of the two properties, <see cref="P:C1.Data.C1DataView.TableName"/> or <see cref="P:C1.Data.C1DataView.TableViewName"/> can be set to a non-empty string.
            </remarks>
            <seealso cref="P:C1.Data.C1DataView.TableView"/>
        </member>
        <member name="P:C1.Data.C1DataView.IsDefault">
            <summary>
            Gets or sets a value indicating whether this component's <see cref="P:C1.Data.C1DataView.RowFilter"/> and <see cref="P:C1.Data.C1DataView.Sort"/> settings 
            are applied to any binding to the table view in the data set.
            </summary>
            <remarks>
            This property is False by default, meaning that filtering and sorting affect only the data 
            exposed by this C1DataView component. Binding to a <see cref="T:C1.Data.C1DataSet"/> directly or to another <see cref="T:C1.Data.C1DataView"/> 
            is not affected by this view's filtering and sorting.
            <para>If this property is set to True, filtering and sorting affect the underlying 
            table view data directly. So, all controls bound to that table view, in C1DataSet 
            or in <see cref="T:C1.Data.C1DataView"/>, are filtered and sorted (including parent-child rows in master-detail). 
            See the DefaultDataView sample in the Samples directory.</para>
            <para>Only <see cref="P:C1.Data.C1DataView.RowFilter"/> and <see cref="P:C1.Data.C1DataView.Sort"/> properties affect table view data, other properties of <see cref="T:C1.Data.C1DataView"/> 
            do not affect the whole table view.</para>
            <para>IsDefault = True can be used only with a <see cref="T:C1.Data.C1DataView"/> attached to a table view 
            (<see cref="P:C1.Data.C1DataView.TableViewName"/> specified), it cannot be used with a data view attached to a table (<see cref="P:C1.Data.C1DataView.TableName"/> specified).</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.DefaultDataView">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataView"/> component with IsDefault = True, if one is connected to this data view.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataView.RowFilter">
            <summary>
            Gets or sets the expression used to filter rows in the data view.
            </summary>
            <remarks>
            Expression must return Boolean values. If it evaluates to True on a row, the row is included 
            in the data view. If it evaluates to false, the row is excluded. 
            For example, expression "City = 'London'" selects all rows where field City equals 'London'.
            <para>To select rows with null values in a certain field, use the following expression:</para>
            <para>"IsNull(Field1, 'Null Field') = 'Null Field"</para>
            </remarks>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataView.RowStateFilter">
            <summary>
            Gets or sets the row state filter used in the data view.
            </summary>
            <remarks>
            Using this property you can select only added rows, or only deleted rows, or only 
            modified rows, or a combination of those states, see <see cref="T:C1.Data.DataViewRowStateEnum"/>.
            <para>Using the Deleted row state filter is only allowed for simple tables 
            (<see cref="P:C1.Data.C1DataView.TableName"/> property is set), it is not allowed for 
            table views (<see cref="P:C1.Data.C1DataView.TableViewName"/> property is set).</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.Sort">
            <summary>
            Gets or sets the sort field or fields, and sort order for the data view.
            </summary>
            <remarks>
            A string containing one or more field names followed by "ASC" (ascending; default, can be omitted) 
            or "DESC" (descending). Multiple fields are separated by commas. 
            Examples: "OrderID", "CustomerID DESC", "Quantity DESC, CustomerID".
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.DataTable">
            <summary>
            Gets the data table object which is the source of this data view.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataView.AutoRefresh">
            <summary>
            Gets or sets a value indicating whether the data view is automatically refreshed when 
            one of the following properties changes: <see cref="P:C1.Data.C1DataView.TableViewName"/>, <see cref="P:C1.Data.C1DataView.TableName"/>, 
            <see cref="P:C1.Data.C1DataView.RowFilter"/>, <see cref="P:C1.Data.C1DataView.RowStateFilter"/>, <see cref="P:C1.Data.C1DataView.Sort"/>.
            </summary>
            <remarks>
            This property is True by default. If it is set to False, changing any of 
            the properties at run time does not automatically refresh the data view, 
            refresh occurs when the <see cref="M:C1.Data.C1DataView.Refresh"/> method is called.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.ReadOnly">
            <summary>
            Gets or sets a value indicating whether changes to the rows of this data view are allowed.
            </summary>
            <remarks>
            If the <see cref="T:C1.Data.SchemaObjects.Table"/> or <see cref="T:C1.Data.SchemaObjects.TableView"/> on which the data view is based has <see cref="P:C1.Data.SchemaObjects.BaseTable.ReadOnly"/> = False, 
            changing rows is not allowed regardless of the value of data view's ReadOnly property.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.AllowAddNew">
            <summary>
            Gets or sets a value indicating whether adding new rows to this data view is allowed.
            </summary>
            <remarks>
            If the <see cref="T:C1.Data.SchemaObjects.Table"/> or <see cref="T:C1.Data.SchemaObjects.TableView"/> on which the data view is based has AllowAddNew = False, 
            adding new rows is not allowed regardless of the value of data view's AllowAddNew property.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.AllowDelete">
            <summary>
            Gets or sets a value indicating whether deleting rows from this data view is allowed.
            </summary>
            <remarks>
            If the <see cref="T:C1.Data.SchemaObjects.Table"/> or <see cref="T:C1.Data.SchemaObjects.TableView"/> 
            on which the data view is based has AllowDelete = False, deleting rows is not allowed regardless 
            of the value of data view's AllowDelete property.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.Count">
            <summary>
            Gets the total number of rows in the data view.
            </summary>
            <remarks>
            This property returns the number of rows satisfying the conditions in <see cref="P:C1.Data.C1DataView.RowFilter"/> and <see cref="P:C1.Data.C1DataView.RowStateFilter"/>.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataView.Item(System.Int32)">
            <summary>
            Gets the row at the specified index in the data view.
            </summary>
            <remarks>
            This property returns the rows satisfying the conditions in <see cref="P:C1.Data.C1DataView.RowFilter"/> and <see cref="P:C1.Data.C1DataView.RowStateFilter"/>.
            </remarks>
            <param name="index">The zero-based index of the row.</param>
        </member>
        <member name="T:C1.Data.RunsAtEnum">
            <summary>
            Where the instance of a data library is running.
            </summary>
            <seealso><span style="Link Topic">Application Configurations</span></seealso>
            <seealso cref="P:C1.Data.C1SchemaDef.RunsAt"/>
        </member>
        <member name="F:C1.Data.RunsAtEnum.DirectClient">
            <summary>
            Direct client: there is no data library, no server, database access is performed 
            in the same application, <see cref="T:C1.Data.C1SchemaDef"/> and <see cref="T:C1.Data.C1DataSet"/> components belong to the same 
            container class or form.
            </summary>
        </member>
        <member name="F:C1.Data.RunsAtEnum.TwoTierClient">
            <summary>
            Data library runs on the client in a 2-tier configuration.
            </summary>
        </member>
        <member name="F:C1.Data.RunsAtEnum.ThreeTierServer">
            <summary>
            Data library runs on the server in a 3-tier configuration.
            </summary>
        </member>
        <member name="F:C1.Data.RunsAtEnum.ThreeTierClient">
            <summary>
            Data library runs on the client in a 3-tier configuration.
            </summary>
        </member>
        <member name="F:C1.Data.RunsAtEnum.WebForms">
            <summary>
            <see cref="T:C1.Data.C1SchemaDef"/> component is used in a WebForms (ASP.NET) application.
            </summary>
        </member>
        <member name="T:C1.Data.DataObjectsAssemblyFlags">
            <summary>
            Flags affecting generated classes in the data objects assembly (*.DataObjects.dll).
            </summary>
            <remarks>
            Used in the <see cref="P:C1.Data.C1SchemaDef.DataObjectsAssemblyFlags"/> property.
            </remarks>
        </member>
        <member name="F:C1.Data.DataObjectsAssemblyFlags.None">
            <summary>
            All generated classes belong to a single namespace, no static name fields are generated.
            </summary>
        </member>
        <member name="F:C1.Data.DataObjectsAssemblyFlags.DataSetNamespaces">
            <summary>
            Generated table view classes belong to special namespaces, a namespace for each data set.
            </summary>
        </member>
        <member name="F:C1.Data.DataObjectsAssemblyFlags.StaticNameFields">
            <summary>
            Enables generating static string properties returning field, table, table view and relation names, to be used in code instead of constant strings, to prevent errors in naming objects.
            </summary>
        </member>
        <member name="F:C1.Data.DataObjectsAssemblyFlags.All">
            <summary>
            DataSetNamespaces | StaticNameFields
            </summary>
        </member>
        <member name="T:C1.Data.SchemaBase">
            <summary>
            The SchemaBase class is a common base class from which <see cref="T:C1.Data.C1SchemaDef"/> 
            and <see cref="T:C1.Data.C1SchemaRef"/> component classes are derived.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaBase.Schema">
            <summary>
            Returns or sets the Schema object. This property is overridden in <see cref="T:C1.Data.C1SchemaDef"/> and 
            <see cref="T:C1.Data.C1SchemaRef"/> to return the <see cref="T:C1.Data.C1SchemaDef"/> component's schema.
            </summary>
        </member>
        <member name="T:C1.Data.C1SchemaRef">
            <summary>
            C1SchemaRef components are used in a data library with multiple source code files.
            </summary>
            <remarks>
            A C1SchemaRef component represents the <see cref="T:C1.Data.C1SchemaDef"/> component holding the library's schema 
            when it resides in a different file in the project.
            </remarks>
            <seealso><span style="Link Topic">Creating a Data Library Project</span></seealso>
            <seealso cref="M:C1.Data.C1SchemaDef.Add(C1.Data.C1SchemaRef)"/>
        </member>
        <member name="M:C1.Data.C1SchemaRef.#ctor">
            <summary>
            Initializes a new instance of the C1SchemaRef class.
            </summary>
        </member>
        <member name="P:C1.Data.C1SchemaRef.SchemaDef">
            <summary>
            Returns or sets the name of the <see cref="T:C1.Data.C1SchemaDef"/> component referred to by this component.
            </summary>
            <remarks>
            This property determines the <see cref="T:C1.Data.C1SchemaDef"/> component referred to by this component.
            In addition to setting this property, you must call the <see cref="M:C1.Data.C1SchemaDef.Add(C1.Data.C1SchemaRef)"/> method at run time.
            </remarks>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
        </member>
        <member name="P:C1.Data.C1SchemaRef.Schema">
            <summary>
            Returns the <see cref="T:C1.Data.SchemaObjects.Schema"/> object of the corresponding <see cref="T:C1.Data.C1SchemaDef"/> component.
            </summary>
        </member>
        <member name="T:C1.Data.C1SchemaDef">
            <summary>
            The C1SchemaDef component hosts a Schema object that is the basis of a C1DataObjects 
            data library or direct client.
            </summary>
            <remarks>
            The <see cref="P:C1.Data.C1SchemaDef.Schema"/> object associated with a C1SchemaDef component 
            is created and edited using the Schema Designer invoked from the context menu of a 
            C1SchemaDef component.
            A C1DataObjects data library always contains a single schema, that is, a single C1SchemaDef 
            component. An application that uses C1DataObjects directly, without a data library (<span style="Link Topic">Direct Client</span>) 
            is allowed to have multiple schemas, each stored in its own C1SchemaDef component.
            </remarks>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
            <seealso><span style="Link Topic">Application Configurations</span></seealso>
        </member>
        <member name="M:C1.Data.C1SchemaDef.#ctor">
            <summary>
            Initializes a new instance of the C1SchemaDef class.
            </summary>
        </member>
        <member name="M:C1.Data.C1SchemaDef.Add(C1.Data.C1SchemaRef)">
            <summary>
            Adds an element to the list of <see cref="T:C1.Data.C1SchemaRef"/> components associated with the C1SchemaDef component.
            </summary>
            <remarks>
            This method is used to specify a list of <see cref="T:C1.Data.C1SchemaRef"/> components representing 
            (associated with) a C1SchemaDef component. It is useful in large data library projects where 
            it is desirable to use multiple source code files to write business logic code. 
            A <see cref="T:C1.Data.C1SchemaRef"/> component represents the C1SchemaDef component holding the library's schema 
            when it resides in a different file in the project. Every <see cref="T:C1.Data.C1SchemaRef"/> component representing 
            a C1SchemaDef must have its SchemaDef property set to the C1SchemaDef component and it also 
            has to be associated with the C1SchemaDef component at run time calling the Add method.
            </remarks>
            <seealso><span style="Link Topic">Creating a Data Library Project</span></seealso>
        </member>
        <member name="E:C1.Data.C1SchemaDef.CreateSchema">
            <summary>
            Fired after the <see cref="P:C1.Data.C1SchemaDef.Schema"/> object has been created at startup.
            </summary>
            <remarks>
            In most cases, a schema is created at design time in the Schema Designer, and used at 
            run time without modifications. However, all schema objects are programmatically accessible 
            at run time through the schema object model, with the <see cref="T:C1.Data.SchemaObjects.Schema"/> class being the root of that 
            object model. Using this object model, it is possible to modify the schema or even define 
            it from scratch at run time, using the CreateSchema event. To access and modify the Schema 
            object, use the <see cref="P:C1.Data.C1SchemaDef.Schema"/> property.
            In a <span style="Link Topic">3-Tier Application</span>, this event is called both for the client and server instances of 
            the data library. If you modify schema in this event, you may need to know whether it occurs 
            on the client or on the server, for example, to modify database connections differently 
            depending on where the event occurs. This information can be obtained from the RunsAt property.
            </remarks>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
        </member>
        <member name="P:C1.Data.C1SchemaDef.Schema">
            <summary>
            Returns or sets the <see cref="T:C1.Data.SchemaObjects.Schema"/> object.
            </summary>
            <remarks>
            Normally, this property is not set by user code. It is set by C1DataObjects SchemaDesigner. 
            User code gets the value of this property to gain access to schema objects and possibly 
            modify them at run time, in the <see cref="E:C1.Data.C1SchemaDef.CreateSchema"/> event.
            </remarks>
            <seealso><span style="Link Topic">Schema Objects</span></seealso>
        </member>
        <member name="P:C1.Data.C1SchemaDef.SessionCacheProperties">
            <summary>
            This property is used in ComponentOne WebDataObjects for data caching in web applications. 
            It is ignored if the schema is used in WinForms application or in WebForms application 
            without WebDataObjects.
            </summary>
        </member>
        <member name="P:C1.Data.C1SchemaDef.DataObjectsAssemblyFlags">
            <summary>
            Flags affecting generated classes in the data objects assembly (*.DataObjects.dll).
            </summary>
            <remarks>
            This property affects the way classes are generated in the data objects assembly, that is, 
            the *.DataObjects.dll assembly automatically generated on saving schema, see <span style="Link Topic">Schema Objects</span>.
            <para>Setting flag <see cref="P:C1.Data.C1SchemaDef.DataObjectsAssemblyFlags"/>.DataSetNamespaces makes table view classes belong 
            to special namespaces, a namespace for each data set, for example, 
            Northwind.DataObjects.CustOrders.EmployeesRow for table view Employees in data set CustOrders. 
            Table classes still belong to the root namespace: Northwind.DataObjects.EmployeesRow 
            for table Employees.</para>
            <para>Setting flag <see cref="P:C1.Data.C1SchemaDef.DataObjectsAssemblyFlags"/>.StaticNameFields generates static string properties 
            returning field, table, table view and relation names, so that they can be used instead of 
            constant strings in code thus making it compile-time safe (errors detected at compile time), 
            for example:</para>
            <para>Northwind.DataObjects.EmployeesRow.FieldNameEmployeeID (field name returning "EmployeeID" 
            for field EmployeeID of table Employees),</para>
            <para>Northwind.DataObjects.EmployeesRow.TableName (table name returning "Employees", for table Employees),</para>
            <para>Northwind.DataObjects.EmployeesRow.RelationNameEmployees__Orders (relation name returning 
            "Employees - Orders", for simple relation "Employees - Orders"),</para>
            <para>Northwind.DataObjects.CustOrders.EmployeesRow.TableViewName (table view name returning 
            "Employees", for table view Employees in data set CustOrders),</para>
            <para>Northwind.DataObjects.CustOrders.EmployeesRow.FieldNameEmployeeID (field name returning 
            "EmployeeID" for field EmployeeID of table Employees),</para>
            <para>Northwind.DataObjects.CustOrders.CustOrdersRow.RelationNameCO__ODP (relation name returning 
            "CO - ODP", for view relation "CO - ODP" between table views CustOrders and OrderDetailsProducts 
            in data set CustOrders).</para>
            </remarks>
            <seealso><span style="Using Typed Data Objects"></span></seealso>
        </member>
        <member name="P:C1.Data.C1SchemaDef.RunsAt">
            <summary>
            Returns a value indicating where the instance of the data library is running.
            </summary>
            <remarks>
            The main purpose of this property is to distinguish between <see cref="T:C1.Data.RunsAtEnum"/>.ThreeTierServer 
            and <see cref="T:C1.Data.RunsAtEnum"/>.ThreeTierClient. This is sometimes necessary in business logic to take 
            different actions depending on whether it runs in the client-side or in the server-side 
            instance of a data library. For example, you might want to assign a <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionString"/> in 
            <see cref="E:C1.Data.C1SchemaDef.CreateSchema"/> event on the server, but leave <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionString"/> empty on the client in a 
            3-tier configuration, since the client does not perform database access.
            </remarks>
            <seealso><span style="Link Topic">Application Configurations</span></seealso>
        </member>
        <member name="T:C1.Data.SessionCacheProperties">
            <summary>
            The SessionCacheProperties class is used in ComponentOne WebDataObjects
            to specify settings for session cache. It is not used in WinForms application
            or in WebForms application without WebDataObjects.
            </summary>
        </member>
        <member name="P:C1.Data.SessionCacheProperties.DefaultStorage">
            <summary>
            Gets or sets the cache storage used by default in session cache methods.
            </summary>
        </member>
        <member name="P:C1.Data.SessionCacheProperties.Compressed">
            <summary>
            Gets or sets a value indicating whether the data in cache should be compressed.
            </summary>
        </member>
        <member name="P:C1.Data.SessionCacheProperties.StoragePath">
            <summary>
            Get or sets the path to cache temporary files.
            </summary>
        </member>
        <member name="T:C1.Data.C1DataRow">
            <summary>
            Represents a row of data in a <see cref="T:C1.Data.C1DataTable"/> object.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataRow.FromDataItem(System.Object)">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataRow"/> object associated with a row object (data item) obtained from data binding.
            </summary>
            <param name="dataItem">An object exposed by a C1DataObjects data source to bound controls.</param>
            <remarks>This method allows programmers to obtain the <see cref="T:C1.Data.C1DataRow"/> object corresponding to an object 
            returned by a C1DataObjects data source, from its IList interface (used in data binding). For example, 
            such objects belong to a CurrencyManager.List collection, and CurrencyManager.Current returns one of them.
            <para>Objects obtained by bound controls from a C1DataObjects data source are not C1DataRow objects, 
            although each of them corresponds to a <see cref="T:C1.Data.C1DataRow"/> object. The FromDataItem method represents this correspondence. 
            Bound controls can get all information they need from the objects returned by the IList interface. However, 
            if you want to work with such objects (data items) in code, get or set their field values, you need to treat them 
            as <see cref="T:C1.Data.C1DataRow"/> objects. This method allows you to obtain a <see cref="T:C1.Data.C1DataRow"/> from an untyped row object (data item) returned 
            by the IList interface. For example, C1WebGrid (bound grid control in ComponentOne Studio for ASP.NET) has a 
            C1GridItem.DataItem property. This property returns an object obtained by the grid from the data source. 
            It is not a C1DataRow object, so you must use C1DataRow.FromDataItem(C1GridItem.DataItem) to obtain the C1DataRow object 
            corresponding to that data item.</para>
            </remarks>
            <returns>Returns <see cref="T:C1.Data.C1DataRow"/> object.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>         
        </member>
        <member name="M:C1.Data.C1DataRow.HasVersion(C1.Data.DataRowVersionEnum)">
            <summary>
            Gets a value indicating whether a specified row version exists.
            </summary>
            <param name="version">One of the <see cref="T:C1.Data.DataRowVersionEnum"/> values.</param>
            <returns>True if the version exists; otherwise, False.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>
            <seealso cref="M:C1.Data.C1DataRow.BeginEdit"/>
        </member>
        <member name="M:C1.Data.C1DataRow.BeginEdit">
             <summary>
             Begins an edit operation on the row.
             </summary>
             <remarks>
             Use the BeginEdit method to put a C1DataRow into edit mode. In this mode, validation is temporarily 
             suspended allowing the user to make changes to more than one field in more than one row.
            
             The BeginEdit method is called implicitly when the user positions to a row in a data-bound control; 
             the EndEdit method is called implicitly when you invoke <see cref="M:C1.Data.C1DataRow.AcceptChanges"/> or <see cref="M:C1.Data.C1DataSet.Update"/> methods. 
             While in edit mode, the <see cref="T:C1.Data.C1DataRow"/> stores representations of the current and new proposed values Therefore, as long as the EndEdit 
             method has not been called, you can retrieve either the current or proposed version by passing 
             either DataRowVersionEnum.Current or DataRowVersionEnum.Proposed for the Version parameter of the Item property. 
             You can also cancel any edits by invoking the CancelEdit method.
             
             To see if the row is in edit mode, call the HasVersion method with DataRowVersionEnum.Proposed.
             </remarks>
             <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.EndEdit">
            <summary>
            Ends the edit on the row.
            </summary>
            <remarks>See <see cref="M:C1.Data.C1DataRow.BeginEdit"/> for details.</remarks>
        </member>
        <member name="M:C1.Data.C1DataRow.CancelEdit">
            <summary>
            Cancels the current edit on the row.
            </summary>
            <remarks>See <see cref="M:C1.Data.C1DataRow.BeginEdit"/> for details.</remarks>
        </member>
        <member name="M:C1.Data.C1DataRow.Delete">
            <summary>
            Deletes the row.
            </summary>
            <remarks>
            If the <see cref="P:C1.Data.C1DataRow.RowState"/> of the row is Added, the row is removed from the data table.
            The <see cref="P:C1.Data.C1DataRow.RowState"/> becomes Deleted after calling the <see cref="M:C1.Data.C1DataRow.Delete"/> method.
            Deleted rows can be undeleted by calling <see cref="M:C1.Data.C1DataRow.RejectChanges"/>.
            </remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.AcceptChanges">
            <summary>
            Commits all the changes made to the row since the last time AcceptChanges or RejectChanges was called.
            </summary>
            <remarks>
            This method can be applied only to simple table rows (or to rows of a table view based on such table). 
            It cannot be applied to composite table rows. Also, applying this method to a simple table that is used 
            in a composite table as a main constituent table is not allowed (if it is connected to its parent in the 
            composite table diagram with a one-to-many relation; the restriction does not apply to those connected 
            many-to-one). In such cases, use <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> for the whole data set. 
            If one of these restrictions is not satisfied, the method throws an exception.
            </remarks>
            <seealso cref="M:C1.Data.C1DataTable.AcceptChanges"/>
        </member>
        <member name="M:C1.Data.C1DataRow.RejectChanges">
            <summary>
            Rolls back all the changes made to the row since the last time AcceptChanges or RejectChanges was called.
            </summary>
            <remarks>
            This method can be applied only to simple table rows (or to rows of a table view based on such table). 
            It cannot be applied to composite table rows. Also, it is not allowed to apply this method to a simple 
            table that is used in a composite table as a main constituent table (is connected to its parent in the 
            composite table diagram with a one-to-many relation; the restriction does not apply to those connected 
            many-to-one). In such case, use <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> for the whole data set. 
            If one of these restrictions is not satisfied, the method throws an exception.
            </remarks>
            <seealso cref="M:C1.Data.C1DataTable.RejectChanges"/>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.Refresh">
            <summary>
            Refreshes field values in the row.
            </summary>
            <remarks>
            This method performs <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> for every field that has non-empty <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection. 
            Normally, calculations are performed automatically, without explicit Refresh call, when calculation 
            arguments change. However, some calculation arguments changes cannot be detected automatically, 
            for example, changes in Current, Original or BeforeChange field values, see <span style="Link Topic">C1DataObjects Expressions</span>.
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataRow.GetParentRow(System.String)">
            <summary>
            Gets the parent row of this C1DataRow using the specified relation.
            </summary>
            <remarks>
            The overload without parameters can be used when the parent and the child are connected with a single relation.
            </remarks>
            <param name="relationName">The name of the relation to use.</param>
            <returns>An <see cref="T:C1.Data.C1DataRow"/> object (or null).</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetParentRow">
            <summary>
            Gets the parent row of this C1DataRow using the specified relation.
            </summary>
            <remarks>
            The overload without parameters can be used when the parent and the child are connected with a single relation.
            </remarks>
            <returns>An <see cref="T:C1.Data.C1DataRow"/> object (or null).</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetChildRows(System.String)">
            <summary>
            Gets the child rows of this C1DataRow using the specified relation.
            </summary>
            <remarks>
            The overload without parameters can be used when the parent and the child are connected with a single relation.
            </remarks>
            <param name="relationName">The name of the relation to use.</param>
            <returns>An array of <see cref="T:C1.Data.C1DataRow"/> objects (or a zero-length array).</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetChildRows">
            <summary>
            Gets the child rows of this C1DataRow using the specified relation.
            </summary>
            <remarks>
            The overload without parameters can be used when the parent and the child are connected with a single relation.
            </remarks>
            <returns>An array of <see cref="T:C1.Data.C1DataRow"/> objects (or a zero-length array).</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.IsNull(System.Int32)">
            <summary>
            Gets a value indicating whether the specified field contains a null value in this row.
            </summary>
            <param name="fieldIndex">The zero-based index of the field.</param>
            <seealso cref="T:C1.Data.C1DataRow"/>
            <seealso cref="M:C1.Data.C1DataRow.SetNull(C1.Data.DataField)"/>
        </member>
        <member name="M:C1.Data.C1DataRow.IsNull(System.String)">
            <summary>
            Gets a value indicating whether the specified field contains a null value in this row.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <seealso cref="T:C1.Data.C1DataRow"/>
            <seealso cref="M:C1.Data.C1DataRow.SetNull(C1.Data.DataField)"/>
        </member>
        <member name="M:C1.Data.C1DataRow.SetNull(C1.Data.DataField)">
            <summary>
            Sets the value of the specified field to null.
            </summary>
            <param name="field">A data field.</param>
            <seealso cref="T:C1.Data.C1DataRow"/>
            <seealso cref="M:C1.Data.C1DataRow.IsNull(System.Int32)"/>
        </member>
        <member name="M:C1.Data.C1DataRow.ClearErrors">
            <summary>
            Clears the errors for the row, including the <see cref="P:C1.Data.C1DataRow.RowError"/> and errors set with <see cref="M:C1.Data.C1DataRow.SetFieldError(System.Int32,System.String)"/>.
            </summary>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetFieldsInError">
            <summary>
            Gets an array of fields that have errors in this row.
            </summary>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetFieldError(System.Int32)">
            <summary>
            Gets the error description for a field.
            </summary>
            <param name="fieldIndex">The index of a field.</param>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetFieldError(System.String)">
            <summary>
            Gets the error description for a field.
            </summary>
            <param name="fieldName">The name of a field.</param>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.GetFieldError(C1.Data.DataField)">
            <summary>
            Gets the error description for a field.
            </summary>
            <param name="field">The field in error.</param>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.SetFieldError(System.Int32,System.String)">
            <summary>
            Sets the error description for a field in the row.
            </summary>
            <param name="fieldIndex">The index of a field.</param>
            <param name="errorMsg">The error description.</param>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.SetFieldError(System.String,System.String)">
            <summary>
            Sets the error description for a field in the row.
            </summary>
            <param name="fieldName">The name of a field.</param>
            <param name="errorMsg">The error description.</param>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.SetFieldError(C1.Data.DataField,System.String)">
            <summary>
            Sets the error description for a field in the row.
            </summary>
            <param name="field">A data field.</param>
            <param name="errorMsg">The error description.</param>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="M:C1.Data.C1DataRow.SetRowStateModified">
            <summary>
            Changes <see cref="P:C1.Data.C1DataRow.RowState"/> from Unchanged to Modified without modifying any field in the row.
            </summary>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="P:C1.Data.C1DataRow.DataTable">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataTable"/> to which the row belongs.
            </summary>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="P:C1.Data.C1DataRow.Item(System.Int32)">
            <summary>
            Gets or sets the data stored in the row in one of the fields.
            </summary>
            <param name="fieldIndex">The zero-based index of the field.</param>
            <returns>An Object that contains the data.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="P:C1.Data.C1DataRow.Item(System.String)">
            <summary>
            Gets or sets the data stored in the row in one of the fields.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <returns>An Object that contains the data.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>         
        </member>
        <member name="P:C1.Data.C1DataRow.Item(C1.Data.DataField)">
            <summary>
            Gets or sets the data stored in the row in one of the fields.
            </summary>
            <param name="field">The data field that contains the data.</param>
            <returns>An Object that contains the data.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>         
        </member>
        <member name="P:C1.Data.C1DataRow.Item(System.Int32,C1.Data.DataRowVersionEnum)">
            <summary>
            Gets or sets the data stored in the row in one of the fields.
            </summary>
            <param name="fieldIndex">The data field that contains the data.</param>
            <param name="version">One of the DataRowVersionEnum values that specifies the desired row version. 
            Possible values are Default, Original, Current, and Proposed.</param>
            <returns>An Object that contains the data.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="P:C1.Data.C1DataRow.Item(System.String,C1.Data.DataRowVersionEnum)">
            <summary>
            Gets or sets the data stored in the row in one of the fields.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <param name="version">One of the DataRowVersionEnum values that specifies the desired row version. 
            Possible values are Default, Original, Current, and Proposed.</param>
            <returns>An Object that contains the data.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="P:C1.Data.C1DataRow.Item(C1.Data.DataField,C1.Data.DataRowVersionEnum)">
            <summary>
            Gets or sets the data stored in the row in one of the fields.
            </summary>
            <param name="field">The data field that contains the data.</param>
            <param name="version">One of the DataRowVersionEnum values that specifies the desired row version. 
            Possible values are Default, Original, Current, and Proposed.</param>
            <returns>An Object that contains the data.</returns>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="P:C1.Data.C1DataRow.ItemArray">
            <summary>
            Gets or sets all of the field values for this row through an array.
            </summary>
            <seealso cref="T:C1.Data.C1DataRow"/> 
        </member>
        <member name="P:C1.Data.C1DataRow.RowState">
            <summary>
            Gets the current state of the row.
            </summary>
            <remarks>
            Modifying field values, deleting a row and adding a row changes the row state. 
            While the row is in edit mode (see <see cref="M:C1.Data.C1DataRow.BeginEdit"/>), the state does not change on field modifications 
            until <see cref="M:C1.Data.C1DataRow.EndEdit"/> is called (see also <see cref="P:C1.Data.C1DataRow.Modified"/> property). Calling <see cref="M:C1.Data.C1DataRow.AcceptChanges"/> 
            or <see cref="M:C1.Data.C1DataRow.RejectChanges"/> resets the state of all rows.
            </remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>         
        </member>
        <member name="P:C1.Data.C1DataRow.HasErrors">
            <summary>
            Gets a value indicating whether there are errors in some of the row field values.
            </summary>
            <remarks>
            Validating data, you can set an error on any field in a row. Data bound controls can use this information to show user interface clues for errors.
            <para>Also, an error can be assigned to a whole row using the <see cref="P:C1.Data.C1DataRow.RowError"/> property. Update errors occurring in specific rows set the RowError property for rows with errors.</para>
            <para>Use <see cref="M:C1.Data.C1DataRow.SetFieldError(System.Int32,System.String)"/> to set an error on a field, and <see cref="P:C1.Data.C1DataRow.RowError"/> property to set an error for the whole row.</para>
            <para>Use the <see cref="M:C1.Data.C1DataRow.GetFieldError(System.Int32)"/> and <see cref="M:C1.Data.C1DataRow.GetFieldsInError"/> methods to return field errors.</para>
            <para>Use the <see cref="P:C1.Data.C1DataRow.RowError"/> property to return error information for the whole row.</para>        
            <para>The <see cref="M:C1.Data.C1DataRow.ClearErrors"/> method clears all errors for the row.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>         
        </member>
        <member name="P:C1.Data.C1DataRow.RowError">
            <summary>
            Gets or sets the custom error description for a row.
            </summary>
            <remarks>See <see cref="P:C1.Data.C1DataRow.HasErrors"/> for details.</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="P:C1.Data.C1DataRow.Modified">
            <summary>
            For a row in edit mode, gets a value indicating whether at least one of row values has been changed.
            </summary>
            <remarks>
            For a row not in edit mode (not between <see cref="M:C1.Data.C1DataRow.BeginEdit"/> and <see cref="M:C1.Data.C1DataRow.EndEdit"/>), this property returns False. In this case, use the <see cref="P:C1.Data.C1DataRow.RowState"/> property to determine if the row was changed.
            </remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="P:C1.Data.C1DataRow.DataItem">
            <summary>
            Gets the object representing this row in data binding interface IList.
            </summary>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="P:C1.Data.C1DataRow.Ordinal">
            <summary>
            Gets the position of the row in the <see cref="T:C1.Data.C1DataRowCollection"/>.
            </summary>
            <seealso cref="T:C1.Data.C1DataRow"/>
        </member>
        <member name="P:C1.Data.C1DataRow.ExtendedData">
            <summary>
            Gets a collection of custom user information associated with the row.
            </summary>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="P:C1.Data.C1DataRow.StorageDataRow">
            <summary>
            Gets the ADO.NET DataRow object storing data of this C1DataRow.
            </summary>
            <remarks>The DataRow belongs to the table <see cref="P:C1.Data.C1DataTable.StorageDataTable"/>. 
            This property returns a non-null value only for simple table rows. For rows belonging to <see cref="T:C1.Data.C1DataTable"/> 
            objects representing composite tables and table views, this property returns null (Nothing in Visual Basic).</remarks>
            <seealso cref="T:C1.Data.C1DataRow"/>        
        </member>
        <member name="T:C1.Data.BaseLogic">
            <summary>
            The BaseLogic class is a common base class from which <see cref="T:C1.Data.C1TableLogic"/> and 
            <see cref="T:C1.Data.C1DataSetLogic"/> component classes are derived.
            </summary>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeFieldChange">
            <summary>
            Fired before a field value is set.
            </summary>
            <remarks>
            This event can be used to specify validation logic that cannot be specified in the 
            form of constraint expressions. Throwing an exception in this event disallows the change. 
            When this event occurs, the field value is not yet modified. The new (proposed) value is 
            available in the NewValue argument of the event.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Modifying Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterFieldChange">
            <summary>
            Fired after a field value is set.
            </summary>
            <remarks>
            This event, among other possible actions, allows other fields/rows/tables to be modified 
            depending on this field. The new value is already assigned to the field, and the old field 
            value is also available in this event, in its OldValue argument. Knowing the old value can be 
            useful, for example, in updating counters, where you may need to add the new value and subtract 
            the old one.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Modifying Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeAddNew">
            <summary>
            Fired before a new (empty) row is added.
            </summary>
            <remarks>
            Throwing an exception in this event cancels adding a row.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterAddNew">
            <summary>
            Fired after a new (empty) row is added.
            </summary>
            <remarks>
            This event can be used to fill default values of the fields according to some rules that 
            cannot be specified as simple values of the <see cref="P:C1.Data.SchemaObjects.Field.DefaultValue"/> property. It can also be used 
            to specify the primary key values, see <span style="Link Topic">Keys Assigned by Client: New Row Detached and Attached State</span>.
            <para>The ParentRow argument is used in AfterAddNew event on the data set level 
            (in a <see cref="T:C1.Data.C1DataSetLogic"/> component), in a master-detail situation. When a new row is added to 
            the child (detail) table view, this argument contains the parent row to which the new 
            child row belongs. Under other circumstances and in other events this argument contains null. 
            This argument is necessary because in this case parent row cannot be found using the 
            <see cref="M:C1.Data.C1DataRow.GetParentRow(System.String)"/>, as the new row is yet in detached state, 
            see <span style="Link Topic">Keys Assigned by Client: New Row Detached and Attached State</span>. <see cref="M:C1.Data.C1DataRow.GetParentRow(System.String)"/> becomes accessible only in the 
            <see cref="E:C1.Data.BaseLogic.AfterEndAddNew"/> event.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterChanges">
            <summary>
            Fired when all changes initiated by a field change are done and handled by the business logic code.
            </summary>
            <remarks>
            This event occurs when all changes to a row are finished, including both the changes 
            made directly by the user and those resulting from executing event code that handled those changes. 
            It is designed specifically to ensure that this is the "last change", so the developers can 
            put code that relies on the "finality" of changes to a row. For instance, this event is the 
            best place to put code setting calculated field values (for calculations that cannot be 
            specified as simple calculation expressions.
            <para>When a field value in a row changes, that change can be handled by event code that in its 
            turn can make other changes to row fields, or it could change other rows or other tables. When 
            all such handling is done, C1DataObjects collects all changed rows and fires the AfterChanges 
            event for every row that has changed in the process.</para>
            <para>Setting the <see cref="P:C1.Data.C1DataSet.ChangeInProgress"/> property to True, firing AfterChanges event can be deferred until 
            the property is set back to False. This allows multiple field changes to be performed with 
            AfterChanges firing only once, when all changes are done.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeBeginEdit">
            <summary>
            Fired when the user starts editing a row, before the row enters edit mode.
            </summary>
            <remarks>
            Throwing an exception in this event prevents the row going into edit mode.
            <para>Writing code handling edit mode events, take into account that in addition to 
            explicit programmatic calls to <see cref="M:C1.Data.C1DataRow.BeginEdit"/>/<see cref="M:C1.Data.C1DataRow.EndEdit"/>, edit mode is also used by data bound 
            controls: when a row becomes current, it is automatically placed in edit mode 
            (<see cref="M:C1.Data.C1DataRow.BeginEdit"/> is called implicitly). For example, throwing an exception in BeforeBeginEdit 
            event will prevent bound controls from positioning on a row. This also means that 
            BeforeBeginEdit event does not indicate an attempt to change a row. If you need to 
            execute some code when a row is being changed, consider using <see cref="E:C1.Data.BaseLogic.BeforeFirstChange"/>/<see cref="E:C1.Data.BaseLogic.AfterFirstChange"/> 
            events instead.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterBeginEdit">
            <summary>
            Fired when the user starts editing a row, after the row enters edit mode.
            </summary>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeEndEdit">
            <summary>
            Fired when the user finishes editing a row, before the row leaves edit mode.
            </summary>
            <remarks>
            Throwing an exception in this event prevents the row from leaving edit mode.
            <para>Use this event for validating changes done to a row, testing conditions that 
            depend on multiple fields, so these conditions can be tested only when all the changes are done, 
            the whole row changed, as opposed to conditions depending on a single field. The latter are 
            usually tested in the <see cref="E:C1.Data.BaseLogic.BeforeFieldChange"/> event. See also <see cref="P:C1.Data.SchemaObjects.BaseTable.ConstraintsFieldLevel"/>, and 
            <see cref="P:C1.Data.SchemaObjects.BaseTable.ConstraintsRecordLevel"/> for alternative, codeless ways of specifying validation conditions.</para>
            <para>Writing code handling edit mode events, take into account that in addition to explicit programmatic 
            calls to <see cref="M:C1.Data.C1DataRow.BeginEdit"/>/<see cref="M:C1.Data.C1DataRow.EndEdit"/>, edit mode is also used by data bound controls: when a row 
            becomes current, it is automatically placed in edit mode (<see cref="M:C1.Data.C1DataRow.BeginEdit"/> is called implicitly).</para> 
            <para>When the user moves to another row, the row exits edit mode (EndEdit is called implicitly). 
            For example, throwing and exception in <see cref="E:C1.Data.BaseLogic.BeforeEndEdit"/> event will prevent bound controls from 
            leaving the row.</para> 
            <para>If you want to test validation conditions only when the row has been changed while it was in 
            edit mode and not when it was just moved to and out of edit mode without making changes, use 
            the Modified argument to distinguish between these two cases.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterEndEdit">
            <summary>
            Fired when the user finishes editing a row, after the row leaves edit mode.
            </summary>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeCancelEdit">
            <summary>
            Fired when the user cancels editing a row, before reverting the changes made to the row.
            </summary>
            <remarks>
            Throwing an exception in this event prevents reverting the changes in the row.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterCancelEdit">
            <summary>
            Fired when the user cancels editing a row, after reverting the changes made to the row.
            </summary>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeEndAddNew">
            <summary>
            Fired before a newly added row becomes a regular row in the rowset, that is, when its 
            primary key and other required (<see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false) fields are specified.
            </summary>
            <remarks>
            Throwing an exception in this event aborts the process of attaching the row (making it a 
            regular, that is, attached) row, as opposed to a just added, or detached row) and aborts 
            <see cref="M:C1.Data.C1DataRow.EndEdit"/>, if the row is being attached as a result of an <see cref="M:C1.Data.C1DataRow.EndEdit"/> call.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterEndAddNew">
            <summary>
            Fired after a newly added row becomes a regular row in the rowset, that is, when 
            its primary key and other required (<see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false) fields are specified.
            </summary>
            <remarks>
            A new row is created empty, filled with default values, its primary key undefined. 
            A row with undefined primary key is in a special transitory state called detached, 
            the process of adding this row to the rowset is yet incomplete. For example, 
            such row will not be sent to the database for update. A row becomes a full-fledged 
            table row only after its primary key is set and any fields with <see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false are 
            set too. This is when this event happens.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeFirstChange">
            <summary>
            Fired before first change is made to a row (a field value changes) after the 
            row last entered edit mode.
            </summary>
            <remarks>
            Throwing an exception in this event disallows changes to the row.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterFirstChange">
            <summary>
            Fired after first change is made to a row (a field value changes) after the row last entered edit mode.
            </summary>
            <remarks>
            This event occurs after the first change has been successfully performed on a row. 
            It can be used, for example, for showing some user interface clues indicating that the 
            row has been changed (canceling them in <see cref="E:C1.Data.BaseLogic.AfterCancelEdit"/> and <see cref="E:C1.Data.BaseLogic.AfterEndEdit"/>, if necessary).
             After the <see cref="E:C1.Data.BaseLogic.AfterFirstChange"/> event has been fired for the first time, successive changes 
             to row fields do not fire the <see cref="E:C1.Data.BaseLogic.BeforeFirstChange"/>/AfterFirstChange events until the row leaves edit mode.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeDelete">
            <summary>
            Fired before a row is deleted.
            </summary>
            <remarks>
            Throwing an exception in this event cancels deleting the row.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Deleting Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterDelete">
            <summary>
            Fired after a row has been deleted.
            </summary>
            <remarks>
            To access field values in the deleted row, use the ItemArray argument. The values are 
            not accessible through regular row properties once the row has been deleted.
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Deleting Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.BeforeUpdateRow">
            <summary>
            Fired before modifications made to a row are committed to the database.
            </summary>
            <remarks>
            For a bound table, this event can be used to examine and possibly modify the SQL 
            command performing the update.
            <para>For an SQL-based table, this event must be used to specify the SQL command performing the update. 
            The IDbCommand object is created and passed as an argument to the event. Event code must set 
            the CommandText property of the command object.</para>
            <para>For an unbound table, updating the row must be performed in the event code. C1DataObjects 
            does not create a command object in this case. The result of the update operation must be 
            communicated to C1DataObjects by setting the Status, SqlStatus and Error 
            arguments in the event code.</para>
            <para>Although this is less frequently done, the Status, SqlStatus and Error arguments can 
            be changed in event code for bound and SQL-based tables as well as for unbound tables. 
            This too affects the success/failure status of the operations and determines further 
            course of action followed by C1DataObjects.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
            <seealso><span style="Link Topic">Events in Updating a Row</span></seealso>
            <seealso><span style="Link Topic">Events on Updating Database</span></seealso>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.AfterUpdateRow">
            <summary>
            Fired after modifications made to a row are committed to the database.
            </summary>
            <remarks>
            The AfterUpdateRow event is fired for every row that fired the <see cref="E:C1.Data.BaseLogic.BeforeUpdateRow"/> event, 
            regardless of the outcome of the update operation for that row. If row update was unsuccessful, 
            that is reflected in the values of Status, SqlStatus and Error arguments.
            <para>This event can be used to change the outcome of the operation from failure to success and 
            vice versa, see the description of the Status, SqlStatus and Error arguments.</para>
            <para>This event can also be used to modify values refreshed from the database after the update operation, 
            see the description of the Row argument.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
            <seealso><span style="Link Topic">Events in Updating a Row</span></seealso>
            <seealso><span style="Link Topic">Events on Updating Database</span></seealso>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="E:C1.Data.BaseLogic.ChangesAccepted">
            <summary>
            Fired when <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> has been performed for a table or for the whole data set.
            </summary>
            <remarks>
            Calling <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> triggers this event once in the <see cref="T:C1.Data.C1DataSetLogic"/> component 
            attached to the data set definition, if one exists. In this case the e.DataTable argument is null.
            <para>Calling <see cref="M:C1.Data.C1DataTable.AcceptChanges"/> triggers this event in the <see cref="T:C1.Data.C1TableLogic"/> component 
            attached to the simple table in question (if such <see cref="T:C1.Data.C1TableLogic"/> component exists) and then 
            in the <see cref="T:C1.Data.C1DataSetLogic"/> component. In this case, e.DataTable argument points to the <see cref="T:C1.Data.C1DataTable"/> 
            for which AcceptChanges was called.</para>
            <para>Calling C1DataRow.AcceptChanges also triggers this event in <see cref="T:C1.Data.C1TableLogic"/> component 
            and then in <see cref="T:C1.Data.C1DataSetLogic"/> component.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso cref="E:C1.Data.BaseLogic.ChangesRejected"/>
        </member>
        <member name="E:C1.Data.BaseLogic.ChangesRejected">
            <summary>
            Fired when RejectChanges has been performed for a table or for the whole data set.
            </summary>
            <remarks>
            Calling <see cref="M:C1.Data.C1DataSet.RejectChanges"/> triggers this event once in the <see cref="T:C1.Data.C1DataSetLogic"/> component 
            attached to the data set definition, if one exists. In this case the e.DataTable argument is null.
            <para>Calling <see cref="M:C1.Data.C1DataTable.RejectChanges"/> triggers this event in the <see cref="T:C1.Data.C1TableLogic"/> component attached 
            to the simple table in question (if such <see cref="T:C1.Data.C1TableLogic"/> component exists) and then in the 
            <see cref="T:C1.Data.C1DataSetLogic"/> component. In this case, e.DataTable argument points to the C1DataTable 
            for which RejectChanges was called.</para>
            <para>Calling <see cref="M:C1.Data.C1DataRow.RejectChanges"/> also triggers this event in <see cref="T:C1.Data.C1TableLogic"/> component and then 
            in <see cref="T:C1.Data.C1DataSetLogic"/> component.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso cref="E:C1.Data.BaseLogic.ChangesRejected"/>
        </member>
        <member name="P:C1.Data.BaseLogic.SchemaComponent">
            <summary>
            This property determines the schema owning this business logic component. 
            The component specifies business logic for a table in the schema, if it is a 
            <see cref="T:C1.Data.C1TableLogic"/> component, or to one or more table views in the schema, if 
            it is a <see cref="T:C1.Data.C1DataSetLogic"/> component.
            </summary>
            <see cref="T:C1.Data.C1TableLogic"/>
            <see cref="T:C1.Data.C1DataSetLogic"/>
        </member>
        <member name="P:C1.Data.BaseLogic.Schema">
            <summary>
            Returns or sets the C1SchemaDef component holding the owner schema.
            </summary>
            <see cref="T:C1.Data.C1TableLogic"/>
            <see cref="T:C1.Data.C1DataSetLogic"/>
        </member>
        <member name="T:C1.Data.C1TableLogic">
            <summary>
            A C1TableLogic component hosts business logic event code for a table.
            </summary>
            <remarks>
            It connects to the schema by setting its <see cref="T:C1.Data.SchemaObjects.Schema"/> property, and to a particular table in the schema by setting its 
            Table property. Business logic is then specified in its events inherited from the <see cref="T:C1.Data.BaseLogic"/> class.
            </remarks>
            <seealso><span style="Link Topic">Business Logic</span></seealso>
        </member>
        <member name="P:C1.Data.C1TableLogic.Table">
            <summary>
            Returns or sets the name of the table represented by this component.
            </summary>
            <remarks>
            Normally, this property is not set by user code. It is set by C1DataObjects SchemaDesigner. 
            User code gets the value of this property to gain access to schema objects and possibly 
            modify them at run time, in the <see cref="E:C1.Data.C1SchemaDef.CreateSchema"/> event.
            </remarks>
        </member>
        <member name="P:C1.Data.C1TableLogic.DataAdapter">
            <summary>
            Returns or sets the ADO.NET IDBDataAdapter component used to fill and update the 
            table with <see cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/> = SqlBased.
            </summary>
            <remarks>
            This property allows to support updateable SQL-based tables based on a SQL SELECT statement 
            or a stored procedure, without manual code, using ADO.NET data adapter. This makes working 
            with SQL-based tables in C1DataObjects almost as easy as working with bound tables (when 
            <see cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/>=Bound, <see cref="P:C1.Data.SchemaObjects.DbTable.DbTableName"/> set to a database table name). However, bound tables should 
            be always preferable when you have a choice. Bound tables are more intimately related to 
            database tables, so C1DataObjects can support features, such as virtual mode, that are 
            unavailable for SQL-based tables, see <span style="Link Topic">Bound, SQL-Based and Unbound tables</span>. 
            <para>See the SQLBasedTablesEasy sample in the samples directory for an example of using a data adapter.</para>
            <para>In C1DataObjects Enterprise edition, data adapter is specified in the DataAdapter property 
            of a <see cref="T:C1.Data.C1TableLogic"/> component attached to a table. The table must be SQL-based (<see cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/>=SqlBased). 
            In C1DataExpress, it is specified in the C1ExpressTable DataAdapter property. In both editions, 
            a data adapter component can be created using the Create DataAdapter context menu item or 
            created manually and attached to the DataAdapter property.</para>
            <para>If specified, the DataAdapter is used to fill and update the table. Filling the table, only its 
            SelectCommand property is used, not the whole data adapter component. The SelectCommand is 
            executed to fetch the data on filling the data set. Updating modified rows to the database, 
            C1DataObjects calls the data adapter's method DbDataAdapter.Update(DataRow[]) for each 
            modified row (each call uses a single element in the DataRow[] array).</para>
            <para>A data adapter component must be attached to a Connection component. The Create DataAdapter 
            menu item creates that component automatically. The connection component is used only at 
            design time. At run time, it is always ignored, the schema connection (or, in the Express 
            edition, C1ExpressConnection.ConnectionString) is always used at run time regardless 
            of what you specify in DataAdapter.Connection.</para>
            <para>You are not required to set up the adapter's TableMappings property. It is not used at run time. 
            C1DataObjects always uses the mapping between your table fields and the database fields 
            that you already have in the schema in the fields' <see cref="P:C1.Data.SchemaObjects.DbTableField.DbFieldName"/> property. In fact, the 
            adapter's TableMappings are automatically updated to reflect the mappings specified in 
            the fields' DbFieldName property.</para>
            <para>ADO.NET data adapter supports both SQL statements and stored procedures. To fill a SQL-based 
            table with data returned by a stored procedure, set <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandType"/>=StoredProcedure and 
            type the procedure name in the <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandText"/> property or select it from the dropdown 
            list of stored procedures in SelectCommandText.</para>
            <para>When you set <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandText"/> to a procedure name, the fields returned by the procedure 
            are automatically retrieved (if the procedure returns a recordset; only procedures returning 
            a recordset as return value or one of out parameters can be used in C1DataObjects as well as in ADO.NET).</para>
            <para>When you use a stored procedure as your <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandText"/> (<see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandType"/>=StoredProcedure; 
            in this case your adapter's SelectCommand will also be the same stored procedure), you 
            can specify parameter values in the data adapter's SelectCommand property. Even if you 
            do not use data adapter for update (in which case you can leave its UpdateCommand/
            InsertCommand/DeleteCommand properties empty), you can use it this way to specify 
            parameter values for the stored procedure you use to fill the table.</para>
            <para>Regardless of whether you use a stored procedure or a SQL statement in <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandText"/>, 
            your data adapter commands for updating modified rows (data adapter properties UpdateCommand, 
            InsertCommand, DeleteCommand) can be either SQL statements or stored procedures, as 
            supported by the data adapter (so you can select Create New Stored Procedures or Use 
            Existing Stored Procedures in the wizard).</para>
            <para>If a data adapter is used for update, some C1DataObjects update features become unavailable, 
            as they only relate to update made by SQL commands generated by C1DataObjects itself, not 
            by an external component. These are table properties UpdateLocateMode, UpdateRefreshMode, 
            IgnoreDeleteError, field properties AutoIncrement (only on the server, it still works on 
            the client), UpdateLocate, UpdateRefresh, UpdateSet. This does not mean that features 
            supported by these properties are unavailable, it only means that they must be supported 
            in a different way. All these features are supported by ADO.NET DataAdapter, but may 
            require more property settings and some coding, see the ADO.NET documentation.</para>
            <para>To control the update process for every row, you can use <see cref="E:C1.Data.BaseLogic.BeforeUpdateRow"/> and <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> 
            events in SQL-based tables with DataAdapter as well as in bound tables. You can also use 
            RowUpdating and RowUpdated events of the data adapter component. These events fire between 
            <see cref="E:C1.Data.BaseLogic.BeforeUpdateRow"/> and <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> events. They (and data adapter's ContinueUpdateOnError 
            property) allow you to specify whether to continue or throw an exception, allow to make 
            this decision in the context of the data adapter component itself. If an exception is 
            thrown, it is passed to the <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> event, and, if it is suppressed in the adapter 
            event, then, accordingly, <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> does not receive an error. But using adapter 
            events is optional, you can do all necessary error handling in the <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> event.</para>
            </remarks>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="T:C1.Data.C1DataSetLogic">
            <summary>
            A C1DataSetLogic component hosts business logic event code for a data set, for all table views of that data set.
            </summary>
            <remarks>
            It connects to the schema by setting its Schema property, 
            and to a particular data set definition in the schema by setting its <see cref="P:C1.Data.C1DataSetLogic.DataSetDef"/> property. 
            Business logic is then specified in its events, most of which are inherited from the <see cref="T:C1.Data.BaseLogic"/> class.
            </remarks>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.BeforeGenerateSql">
            <summary>
            Fired before generating the SQL SELECT statement for fetching a table view from the database.
            </summary>
            <remarks>
            This event is used for SQL-based tables to specify the SQL SELECT statement that populates 
            the table, fetches data from the database. The SQL statement is assigned to the Sql 
            argument or to the CommandText property of the Command argument.
            <para>If you use the Command argument, the command does not necessarily have to contain 
            a SELECT statement. You can use a stored procedure instead, or you can use a parameterized 
            SELECT. You can even create your own command object and assign it to the Command 
            argument. The only requirement is that you set up the Command argument passed to 
            the event with all necessary properties so it becomes a valid IDbCommand ready for execution. 
            C1DataObjects executes the command's ExecuteReader method.</para>
            </remarks>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.AfterGenerateSql">
            <summary>
            Fired after generating the SQL SELECT statement for fetching a table view from the database.
            </summary>
            <remarks>
            In this event, you can examine and modify the SQL SELECT statement generated by C1DataObjects.
            </remarks>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.BeforeFetch">
            <summary>
            Fired before a table view is fetched from the database.
            </summary>
            <remarks>
            This event is mainly intended for populating unbound tables. Unbound table fetch 
            is performed in the event code. To provide data, you must create a data reader implementing 
            the System.Data.IDataReader interface and assign it to the Reader argument. 
            C1DataObjects provides a helper class <see cref="T:C1.Data.UnboundDataReader"/> that you can use to 
            create your reader. If you have your data in the form of a System.Data.DataTable, 
            create an <see cref="T:C1.Data.UnboundDataReader"/> passing the DataTable object to its constructor. 
            You can also create standard .NET Framework or third-party objects implementing 
            IDataReader, such as OleDbReader or SqlDataReader, or implement your own custom 
            data reader, if necessary.
            <para>Before any BeforeFetch events are fired for individual table views, a 
            BeforeFetch event is fired for the whole fetch session, with the TableView argument 
            set to null (Nothing in Visual Basic). Use this event to execute code before any 
            table views are fetched.</para>
            </remarks>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.AfterFetch">
            <summary>
            An AfterFetch event is fired after a table view has been fetched from the database. 
            Also, after all AfterFetch events have been fired for individual table views, an 
            AfterFetch event is fired for the whole fetch session, with the TableView argument 
            set to null (Nothing in Visual Basic). Use this event to execute code after all table 
            views have been fetched.
            </summary>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.BeforeUpdate">
            <summary>
            Fired before all changes in the data set are updated to the database.
            </summary>
            <remarks>
            Before any modified rows are committed to the database, the BeforeUpdate event fires. 
            The DataSet argument contains the data set passed to the server for update. By modifying 
            this data set, you can customize the update process, control the set of rows and field 
            values that undergo database update. 
            <para>You can even perform the whole update process in your code in the BeforeUpdate event 
            and tell C1DataObjects to skip further processing, consider it done, by setting the 
            Status argument to Skip. If you detect an unrecoverable error in this event, set the 
            Status argument to ErrorsOccurred and set the Error argument to describe the error.</para>
            </remarks>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
            <seealso><span style="Link Topic">Controlling the Update Process</span></seealso>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.AfterUpdate">
            <summary>
            Fired after all changes in the data set are updated to the database.
            </summary>
            <remarks>
            The AfterUpdate event is fired after the update process is completed or skipped, 
            regardless of whether it was successful or failed. The success status of the update 
            process is passed to the event in the Status argument. The Status argument can also 
            be modified by the event code to make C1DataObjects ignore an error, or vice versa, 
            to make the update fail.
            <para>Among its possible uses, this event allows to control the whole data set 
            (via its Tables argument) sent back to the client for refreshing updated rows, 
            see <span style="Link Topic">Changing Data as a Result of Update (Refresh)</span>.</para>
            </remarks>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
            <seealso><span style="Link Topic">Controlling the Update Process</span></seealso>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.GetChildRows">
            <summary>
            Used to programmatically specify the list of child rows for a relation.
            </summary>
            <remarks>
            This event can be used to create custom view relations, when the rule defining the 
            list of child rows for a parent row cannot be formulated based on a simple relation 
            between tables. For example, see CustomRelations sample in the Samples directory, 
            where a custom relation is used to represent a many-to-many relation.
            <para>If the <see cref="P:C1.Data.SchemaObjects.ViewRelation.GetRowsEvent"/> property is set to True for a view relation, the GetChildRows event 
            is called every time C1DataObjects needs to obtain the list of child rows for a parent 
            row for that relation. Event code sets the argument e.List to a list of rows, thus 
            defining the child rows of the relation. The resulting list, if not empty, must contain 
            <see cref="T:C1.Data.C1DataRow"/> objects belonging to the child table view of the relation.</para>
            </remarks>
            <seealso cref="T:C1.Data.SchemaObjects.ViewRelation"/>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="E:C1.Data.C1DataSetLogic.GetParentRow">
            <summary>
            Used to programmatically specify the parent row for a relation.
            </summary>
            <remarks>
            This event can be used in addition to <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/> event for two-way custom view relations. 
            If the <see cref="P:C1.Data.SchemaObjects.ViewRelation.OneWay"/> property is set to True, the custom relation does not support getting 
            parent row (note that only <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/> is used for master-detail data binding, 
            GetParentRow is not necessary, it may only be needed in code). If <see cref="P:C1.Data.SchemaObjects.ViewRelation.OneWay"/> =False 
            for a custom relation, C1DataObjects calls the GetParentRow event to obtain the 
            parent row whenever <see cref="M:C1.Data.C1DataRow.GetParentRow(System.String)"/> is called.
            </remarks>
            <seealso><span style="Link Topic">C1ExpressConnection Class</span></seealso>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataSetLogic.DataSetDef">
            <summary>
            Returns or sets the name of the data set represented by this component.
            </summary>
        </member>
        <member name="T:C1.Data.FieldChangeEventArgs">
            <summary>
            Provides data for AfterFieldChange and BeforeFieldChange events in 
            <see cref="T:C1.Data.BaseLogic"/> (<see cref="T:C1.Data.C1TableLogic"/>, <see cref="T:C1.Data.C1DataSetLogic"/>) 
            and C1DataExpress components.
            </summary>
            <seealso cref="T:C1.Data.FieldChangeEventHandler"/>
        </member>
        <member name="P:C1.Data.FieldChangeEventArgs.DataTable">
            <summary>
            The table object where the event has occurred.
            </summary>
        </member>
        <member name="P:C1.Data.FieldChangeEventArgs.Row">
            <summary>
            The row where the event has occurred.
            </summary>
        </member>
        <member name="P:C1.Data.FieldChangeEventArgs.Field">
            <summary>
            The field changing value.
            </summary>
        </member>
        <member name="P:C1.Data.FieldChangeEventArgs.NewValue">
            <summary>
            The field value after change.
            </summary>
        </member>
        <member name="P:C1.Data.FieldChangeEventArgs.OldValue">
            <summary>
            The field value before change.
            </summary>
        </member>
        <member name="T:C1.Data.FieldChangeEventHandler">
            <summary>
            Represents the method that handles BeforeFieldChange and AfterFieldChange events.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">A <see cref="T:C1.Data.FieldChangeEventArgs"/> object that contains the event data.</param>
            <seealso cref="E:C1.Data.BaseLogic.BeforeFieldChange"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterFieldChange"/>
        </member>
        <member name="T:C1.Data.DataRowActionEnum">
            <summary>
            Indicates an action performed on a data row.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.Nothing">
            <summary>
            No action.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.BeginEdit">
            <summary>
            Row switched to edit mode.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.EndEdit">
            <summary>
            Row left edit mode.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.CancelEdit">
            <summary>
            Canceled changes made to the row in edit mode. 
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.FirstChange">
            <summary>
            Row changed first time since it entered edit mode.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.AfterChanges">
            <summary>
            All actions directly triggered by the user and by code that handled them, have been 
            handled. After that, C1DataObjects gives the programmer an opportunity to perform 
            whatever actions necessary after handling all the changes.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.AddNew">
            <summary>
            A new (empty) row added. 
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.EndAddNew">
            <summary>
            An added row becomes a regular row in the rowset. It happens when its primary key 
            and other required (<see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false) fields are specified.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.Delete">
            <summary>
            Row deleted.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.AcceptChanges">
            <summary>
            <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> or <see cref="M:C1.Data.C1DataTable.AcceptChanges"/> called.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowActionEnum.RejectChanges">
            <summary>
            <see cref="M:C1.Data.C1DataSet.RejectChanges"/> or <see cref="M:C1.Data.C1DataTable.RejectChanges"/> called.
            </summary>
        </member>
        <member name="T:C1.Data.RowChangeEventArgs">
            <summary>
            Provides data for events which occur when an action is performed on a <see cref="T:C1.Data.C1DataRow"/>.
            </summary>
            <seealso cref="T:C1.Data.RowChangeEventHandler"/>
        </member>
        <member name="P:C1.Data.RowChangeEventArgs.DataTable">
            <summary>
            The table object where the event has occurred.
            </summary>
        </member>
        <member name="P:C1.Data.RowChangeEventArgs.Row">
            <summary>
            The row where the event has occurred.
            </summary>
        </member>
        <member name="P:C1.Data.RowChangeEventArgs.ParentRow">
            <summary>
            Parent row.
            </summary>
        </member>
        <member name="P:C1.Data.RowChangeEventArgs.ItemArray">
            <summary>
            For a deleted row, in <see cref="E:C1.Data.BaseLogic.AfterDelete"/> event, the array of field values in the row before 
            the row was deleted. This property is not set in events other than AfterDelete. This 
            property must be used in <see cref="E:C1.Data.BaseLogic.AfterDelete"/> event to access row values because they are not 
            accessible through regular row properties after the row has been deleted.
            </summary>
            <seealso cref="T:C1.Data.RowChangeEventHandler"/>
        </member>
        <member name="P:C1.Data.RowChangeEventArgs.Modified">
            <summary>
            For events <see cref="E:C1.Data.BaseLogic.BeforeEndEdit"/>, <see cref="E:C1.Data.BaseLogic.AfterEndEdit"/>, this property indicates whether the row has 
            been modified while it was in edit mode. This property is often needed in <see cref="E:C1.Data.BaseLogic.BeforeEndEdit"/>/ 
            <see cref="E:C1.Data.BaseLogic.AfterEndEdit"/> because data-bound controls begin edit mode when they position on a row and 
            end edit mode when they leave the row, even if no changes have been made to the row in the process.
            </summary>
        </member>
        <member name="P:C1.Data.RowChangeEventArgs.Action">
            <summary>
            The action that has occurred.
            </summary>
        </member>
        <member name="T:C1.Data.RowChangeEventHandler">
            <summary>
            Represents the method that handles events which occur when an action is performed on a <see cref="T:C1.Data.C1DataRow"/>.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">A <see cref="T:C1.Data.RowChangeEventArgs"/> object that contains the event data.</param>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterAddNew"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterBeginEdit"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterCancelEdit"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterChanges"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterDelete"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterEndAddNew"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterEndEdit"/>
            <seealso cref="E:C1.Data.BaseLogic.AfterFirstChange"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeAddNew"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeBeginEdit"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeCancelEdit"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeDelete"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeEndAddNew"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeEndEdit"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeFirstChange"/>
        </member>
        <member name="T:C1.Data.FillEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSet.BeforeFill"/> and <see cref="E:C1.Data.C1DataSet.AfterFill"/> events.
            </summary>
            <seealso cref="M:C1.Data.C1DataSet.Fill"/>
            <seealso cref="T:C1.Data.FillEventHandler"/>
        </member>
        <member name="P:C1.Data.FillEventArgs.DataSet">
            <summary>
            The data set where the event has occurred.
            </summary>
        </member>
        <member name="P:C1.Data.FillEventArgs.Filter">
            <summary>
            Filter conditions used to fill the data set. 
            </summary>
        </member>
        <member name="P:C1.Data.FillEventArgs.TableViewNames">
            <summary>
            Used to detect which table views are being filled in the <see cref="E:C1.Data.C1DataSet.AfterFill"/> event.
            </summary>
        </member>
        <member name="T:C1.Data.FillEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.C1DataSet.BeforeFill"/> and <see cref="E:C1.Data.C1DataSet.AfterFill"/> events.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">A <see cref="T:C1.Data.FillEventArgs"/> object that contains the event data.</param>
            <seealso cref="E:C1.Data.C1DataSet.AfterFill"/>
            <seealso cref="E:C1.Data.C1DataSet.BeforeFill"/>
        </member>
        <member name="T:C1.Data.DataSetEventStatusEnum">
            <summary>
            Indicates status before and after an operation on a table view in a data set or on a whole data set.
            </summary>
        </member>
        <member name="F:C1.Data.DataSetEventStatusEnum.Continue">
            <summary>
            Successful operation.
            </summary>
        </member>
        <member name="F:C1.Data.DataSetEventStatusEnum.Skip">
            <summary>
            If this status value is set in event code, operation must be skipped and considered successful. 
            </summary>
        </member>
        <member name="F:C1.Data.DataSetEventStatusEnum.ErrorsOccured">
            <summary>
            Operation failed.
            </summary>
        </member>
        <member name="T:C1.Data.DataSetEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSetLogic.BeforeUpdate"/> and <see cref="E:C1.Data.C1DataSetLogic.AfterUpdate"/> events.
            </summary>
            <seealso><span style="Link Topic">Events in Updating a Row</span></seealso>
            <seealso><span style="Link Topic">Events on Updating Database</span></seealso>
            <seealso cref="T:C1.Data.DataSetEventHandler"/>
        </member>
        <member name="P:C1.Data.DataSetEventArgs.DataSet">
            <summary>
            The data set where the event has occurred.
            </summary>
        </member>
        <member name="P:C1.Data.DataSetEventArgs.Status">
            <summary>
            Success or failure status of the operation. In events occurring before operation and allowing 
            to change the status argument, user code can change the status to indicate whether to proceed 
            with the operation, skip or abort it. 
            </summary>
        </member>
        <member name="P:C1.Data.DataSetEventArgs.Error">
            <summary>
            For an unsuccessful operation, information detailing the error.
            </summary>
        </member>
        <member name="P:C1.Data.DataSetEventArgs.Tables">
            <summary>
            Returns the table collection of the data set. Use this property to gain access to table 
            data in 3-tier configuration, where the DataSet argument is not set because it resides 
            on the client and the event is fired on the server.
            </summary>
        </member>
        <member name="P:C1.Data.DataSetEventArgs.TableViews">
            <summary>
            Returns the table view collection of the data set. Use this property to gain access to table view
            data in 3-tier configuration, where the DataSet argument is not set because it resides 
            on the client and the event is fired on the server.
            </summary>
        </member>
        <member name="T:C1.Data.DataSetEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.C1DataSetLogic.BeforeUpdate"/> and <see cref="E:C1.Data.C1DataSetLogic.AfterUpdate"/> events.
            </summary>
            <seealso cref="E:C1.Data.C1DataSetLogic.BeforeUpdate"/>
            <seealso cref="E:C1.Data.C1DataSetLogic.AfterUpdate"/>
            <param name="sender">The source of the event.</param>
            <param name="e">A <see cref="T:C1.Data.DataSetEventArgs"/> object that contains the event data.</param>
        </member>
        <member name="T:C1.Data.GenerateSqlEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSetLogic.BeforeGenerateSql"/> and <see cref="E:C1.Data.C1DataSetLogic.AfterGenerateSql"/> events.
            </summary>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.TableView">
            <summary>
            The table view populated with the SQL SELECT statement.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.Filter">
            <summary>
            Filter conditions used to fill the data set. These are all filter conditions for 
            all table views in the data set. You need to extract the filter conditions for the 
            particular table view from this argument.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.Command">
            <summary>
            The IDbCommand object containing the generated SQL SELECT statement.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.Sql">
            <summary>
            SQL statement. The programmer can set this argument in the event code to set or modify 
            the SQL SELECT statement used for fetching data. Alternatively, the programmer 
            can set or modify the Command argument to specify the complete command to be executed.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.ClauseSelect">
            <summary>
            ClauseSelect/ClauseFrom/ClauseWhere/ClauseOrderBy are read-only properties that are available 
            in AfterGenerateSql event (not available in BeforeGenerateSql). They contain corresponding 
            parts of the automatically generated SQL SELECT statement (the complete statement is available 
            in the Sql property). They can be used to modify/compose a statement, for example, to add TOP 
            n or another clause after the SELECT clause.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.ClauseFrom">
            <summary>
            ClauseSelect/ClauseFrom/ClauseWhere/ClauseOrderBy are read-only properties that are available 
            in AfterGenerateSql event (not available in BeforeGenerateSql). They contain corresponding parts 
            of the automatically generated SQL SELECT statement (the complete statement is available in the 
            Sql property). They can be used to modify/compose a statement, for example, to add TOP n or 
            another clause after the SELECT clause.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.ClauseWhere">
            <summary>
            ClauseSelect/ClauseFrom/ClauseWhere/ClauseOrderBy are read-only properties that are available 
            in AfterGenerateSql event (not available in BeforeGenerateSql). They contain corresponding 
            parts of the automatically generated SQL SELECT statement (the complete statement is available 
            in the Sql property). They can be used to modify/compose a statement, for example, to add TOP 
            n or another clause after the SELECT clause.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.ClauseOrderBy">
            <summary>
            ClauseSelect/ClauseFrom/ClauseWhere/ClauseOrderBy are read-only properties that are available 
            in AfterGenerateSql event (not available in BeforeGenerateSql). They contain corresponding parts 
            of the automatically generated SQL SELECT statement (the complete statement is available in the 
            Sql property). They can be used to modify/compose a statement, for example, to add TOP n or 
            another clause after the SELECT clause.
            </summary>
        </member>
        <member name="P:C1.Data.GenerateSqlEventArgs.Status">
            <summary>
            Success or failure status of the operation. In events occurring before operation and allowing 
            to change the status argument, user code can change the status to indicate whether to proceed 
            with the operation, skip or abort it. 
            </summary>
        </member>
        <member name="T:C1.Data.GenerateSqlEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.C1DataSetLogic.AfterGenerateSql"/> 
            and <see cref="E:C1.Data.C1DataSetLogic.BeforeGenerateSql"/> events.
            </summary>
            <seealso cref="E:C1.Data.C1DataSetLogic.AfterGenerateSql"/>
            <seealso cref="E:C1.Data.C1DataSetLogic.BeforeGenerateSql"/>
        </member>
        <member name="T:C1.Data.FetchEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSetLogic.BeforeFetch"/> and <see cref="E:C1.Data.C1DataSetLogic.AfterFetch"/> events.
            </summary>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
            <seealso cref="T:C1.Data.FetchEventHandler"/>
        </member>
        <member name="P:C1.Data.FetchEventArgs.TableView">
            <summary>
            The table view being populated.
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.Filter">
            <summary>
            Filter conditions used to fill the data set. These are all filter conditions for all 
            table views in the data set. You need to extract the filter conditions for the particular 
            table view from this argument. 
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.Command">
            <summary>
            For a bound or SQL-based table, the IDbCommand object containing the generated 
            SQL SELECT statement. This argument is null for an unbound table.
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.Sql">
            <summary>
            The generated SQL SELECT statement.
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.Reader">
            <summary>
            The reader object providing the fetched data. 
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.Status">
            <summary>
            Success or failure status of the operation. In events occurring before operation 
            and allowing to change the status argument, user code can change the status to 
            indicate whether to proceed with the operation, skip or abort it. 
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.Tables">
            <summary>
            Returns the table collection of the data set being populated.
            </summary>
        </member>
        <member name="P:C1.Data.FetchEventArgs.TableViews">
            <summary>
            Returns the table views collection of the data set being populated. 
            </summary>
        </member>
        <member name="T:C1.Data.FetchEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.C1DataSetLogic.BeforeFetch"/> and <see cref="E:C1.Data.C1DataSetLogic.AfterFetch"/> events.
            </summary>
            <seealso cref="E:C1.Data.C1DataSetLogic.AfterFetch"/>
            <seealso cref="E:C1.Data.C1DataSetLogic.BeforeFetch"/>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="T:C1.Data.RowEventStatusEnum">
            <summary>
            Indicates status before and after an operation on a data row, e.g., committing (updating) the row to the database.
            </summary>
        </member>
        <member name="F:C1.Data.RowEventStatusEnum.Continue">
            <summary>
            Successful operation.
            </summary>
        </member>
        <member name="F:C1.Data.RowEventStatusEnum.ErrorsOccured">
            <summary>
            Operation failed due to an exception (error) condition that occurred while performing the operation.
            </summary>
        </member>
        <member name="F:C1.Data.RowEventStatusEnum.SkipAllRemainingRows">
            <summary>
            If this status value is set in event code, operation must be considered failed and aborted.
            </summary>
        </member>
        <member name="F:C1.Data.RowEventStatusEnum.SkipCurrentRow">
            <summary>
            If this status value is set in event code, operation must be skipped and considered successful. 
            </summary>
        </member>
        <member name="T:C1.Data.SqlResultStatusEnum">
            <summary>
            This enumeration specifies success or failure of a database access operation, including specific reasons of operation failure.
            </summary>
        </member>
        <member name="F:C1.Data.SqlResultStatusEnum.Succeeded">
            <summary>
            Successful operation.
            </summary>
        </member>
        <member name="F:C1.Data.SqlResultStatusEnum.InsertFailed">
            <summary>
            Operation failed due to an error executing SQL INSERT command.
            </summary>
        </member>
        <member name="F:C1.Data.SqlResultStatusEnum.DeleteFailed">
            <summary>
            Operation failed due to an error executing SQL DELETE command.
            </summary>
        </member>
        <member name="F:C1.Data.SqlResultStatusEnum.UpdateFailed">
            <summary>
            Operation failed due to an error executing SQL UPDATE command.
            </summary>
        </member>
        <member name="F:C1.Data.SqlResultStatusEnum.SelectFailed">
            <summary>
            Operation failed due to an error executing SQL SELECT command.
            </summary>
        </member>
        <member name="F:C1.Data.SqlResultStatusEnum.ConcurrencyConflict">
            <summary>
            Operation failed due to concurrency conflict, that is, the target row could not 
            be found in the database, presumably because another user has modified it.
            </summary>
        </member>
        <member name="T:C1.Data.RowUpdateEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.BaseLogic.BeforeUpdateRow"/> and <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> events.
            </summary>
            <seealso><span style="Link Topic">Events on Updating Database</span></seealso>
            <seealso><span style="Link Topic">Events in Updating a Row</span></seealso>
            <seealso cref="T:C1.Data.RowUpdateEventHandler"/>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.Tables">
            <summary>
            Returns the table collection with all data being updated to the database.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.TableViews">
            <summary>
            Returns the table view collection with all data being updated to the database.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.Row">
            <summary>
            The row that is committed to the database.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.Status">
            <summary>
            Success or failure status of the operation. In events occurring before operation 
            and allowing to change the status argument, user code can change the status to indicate 
            whether to proceed with the operation, skip or abort it. 
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.Error">
            <summary>
            For an unsuccessful operation, information detailing the error.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.SqlStatus">
            <summary>
            Success or failure status of the database access operation. For an unsuccessful operation, 
            specifies the cause of failure.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.InsertCommand">
            <summary>
            For an added row, the object representing the SQL INSERT command used to add the row to the database.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.DeleteCommand">
            <summary>
            For a deleted row, the object representing the SQL DELETE command used to delete the row from the database.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.UpdateCommand">
            <summary>
            For a modified row, the object representing the SQL UPDATE command used to add the row to the database.
            </summary>
        </member>
        <member name="P:C1.Data.RowUpdateEventArgs.SelectCommand">
            <summary>
            For a modified and added row, the object representing the SQL SELELCT command used to refresh the row with database values after the row has been committed to the database.
            </summary>
        </member>
        <member name="T:C1.Data.RowUpdateEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.BaseLogic.BeforeUpdateRow"/> and <see cref="E:C1.Data.BaseLogic.AfterUpdateRow"/> events.
            </summary>
            <seealso cref="E:C1.Data.BaseLogic.AfterUpdateRow"/>
            <seealso cref="E:C1.Data.BaseLogic.BeforeUpdateRow"/>
        </member>
        <member name="T:C1.Data.PositionChangeEventArgs">
            <summary>
            Provides data for PositionChanged event in <see cref="T:C1.Data.C1DataTableSource"/>, <see cref="T:C1.Data.C1DataView"/>, <see cref="T:C1.Data.C1DataSet"/> and C1DataExpress components.
            </summary>
            <seealso cref="T:C1.Data.PositionChangeEventHandler"/>
        </member>
        <member name="P:C1.Data.PositionChangeEventArgs.OldPosition">
            <summary>
            Current row before position change.
            </summary>
        </member>
        <member name="P:C1.Data.PositionChangeEventArgs.NewPosition">
            <summary>
            Current row after position change.
            </summary>
        </member>
        <member name="P:C1.Data.PositionChangeEventArgs.DataMember">
            <summary>
            DataMember string identifying the member (node in master-detail hierarchy) that has 
            changed current row position.
            </summary>
        </member>
        <member name="P:C1.Data.PositionChangeEventArgs.CurrencyManager">
            <summary>
            The CurrencyManager object managing current row position for the data member.
            </summary>
        </member>
        <member name="P:C1.Data.PositionChangeEventArgs.Row">
            <summary>
            The row object that has become current.
            </summary>
        </member>
        <member name="T:C1.Data.PositionChangeEventHandler">
            <summary>
            Represents the method that handles the PositionChanged event in <see cref="T:C1.Data.C1DataTableSource"/>, <see cref="T:C1.Data.C1DataView"/>, <see cref="T:C1.Data.C1DataSet"/> and C1DataExpress components.
            </summary>
            <seealso cref="E:C1.Data.C1DataSet.PositionChanged"/>
            <seealso cref="T:C1.Data.C1DataView"/>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">BaseDataSourceComponent.PositionChanged Event</span></seealso>
        </member>
        <member name="T:C1.Data.ErrorEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSet.UpdateError"/> event in <see cref="!:CDataSet"/> and C1DataExpress components.
            </summary>
            <seealso cref="T:C1.Data.ErrorEventHandler"/>
        </member>
        <member name="P:C1.Data.ErrorEventArgs.ShowMessage">
            <summary>
            Indicates whether an error message is shown. Set this argument to False if you 
            have already shown an error message or otherwise handled the error and do not want the 
            standard error message to appear.
            </summary>
        </member>
        <member name="P:C1.Data.ErrorEventArgs.Error">
            <summary>
            Exception object describing the error.
            </summary>
        </member>
        <member name="T:C1.Data.ErrorEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.C1DataSet.UpdateError"/> event in <see cref="!:CDataSet"/> and C1DataExpress components.
            </summary>
            <seealso cref="E:C1.Data.C1DataSet.UpdateError"/>
            <seealso><span style="Link Topic">C1ExpressTable.UpdateError Event</span></seealso>
            <seealso><span style="Link Topic">C1ExpressConnection.UpdateError Event</span></seealso>
        </member>
        <member name="T:C1.Data.GetListEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/>, <see cref="E:C1.Data.C1DataSetLogic.GetParentRow"/> and <see cref="E:C1.Data.C1DataView.GetRows"/> events.
            </summary>
            <seealso cref="T:C1.Data.GetListEventHandler"/>
        </member>
        <member name="P:C1.Data.GetListEventArgs.List">
            <summary>
            This argument contains the list of rows. In events returning a list, create a new 
            ArrayList object, fill it with rows and assign to the List argument. In events returning 
            a single row (for example, GetParentRow:C1DataSetLogic event), add a single row to the list.
            </summary>
        </member>
        <member name="P:C1.Data.GetListEventArgs.Row">
            <summary>
            The row on which to base the list. In GetParentRow:C1DataSetLogic event, the parent row of the view, 
            if it is a child view. In GetChildRows:C1DataSetLogic event, the parent row for which to return 
            child rows.
            </summary>
        </member>
        <member name="P:C1.Data.GetListEventArgs.RelationName">
            <summary>
            The name of the relation (in GetRows:C1DataView event, empty if the view is not a child view).
            </summary>
        </member>
        <member name="T:C1.Data.GetListEventHandler">
            <summary>
            Represents the method that handles the <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/>, <see cref="E:C1.Data.C1DataSetLogic.GetParentRow"/> and <see cref="E:C1.Data.C1DataView.GetRows"/> events.
            </summary>
            <seealso cref="E:C1.Data.C1DataView.GetRows"/>
            <seealso cref="E:C1.Data.C1DataSetLogic.GetChildRows"/>
            <seealso cref="E:C1.Data.C1DataSetLogic.GetParentRow"/>
        </member>
        <member name="T:C1.Data.RowChangedTypeEnum">
            <summary>
            Indicates a type of change occurring in <see cref="E:C1.Data.C1DataSet.CurrentRowChanged"/> Event.
            </summary>
            <seealso cref="E:C1.Data.C1DataSet.CurrentRowChanged"/>
            <seealso cref="T:C1.Data.CurrentRowChangedEventArgs"/>
        </member>
        <member name="F:C1.Data.RowChangedTypeEnum.FieldsChanged">
            <summary>
            Indicates that the end user or user code modified a field.
            </summary>
        </member>
        <member name="F:C1.Data.RowChangedTypeEnum.CurrentRowChanged">
            <summary>
            Indicates that the current row has changed.
            </summary>
        </member>
        <member name="T:C1.Data.CurrentRowChangedEventArgs">
            <summary>
            Provides data for the <see cref="E:C1.Data.C1DataSet.CurrentRowChanged"/> event in <see cref="T:C1.Data.C1DataSet"/> and C1DataExpress components.
            </summary>
            <seealso cref="T:C1.Data.CurrentRowChangedEventHandler"/>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.ChangeType">
            <summary>
            Indicates a type of change occurred.
            </summary>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.Row">
            <summary>
            Row that became current, or null if there is no current row (empty rowset).
            </summary>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.Position">
            <summary>
            Position of Row in the list.
            </summary>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.TableName">
            <summary>
            Name the of table on which the rowset is based.
            </summary>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.TableViewName">
            <summary>
            Name of the table view on which the rowset is based. In C1DataView, if the rowset 
            represents rows directly from a table, that is, when TableName property is used to define 
            the rowset source, this property value is empty string.
            </summary>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.DataMember">
            <summary>
            For C1DataSet rowsets, that is, when a C1DataSet component is specified as the 
            DataSource value for a bound control, this property returns the DataMember value 
            used to bind to this rowset. In other cases, the value is empty string.
            </summary>
        </member>
        <member name="P:C1.Data.CurrentRowChangedEventArgs.CurrencyManager">
            <summary>
            Returns the CurrencyManager object that manages this rowset.
            </summary>
        </member>
        <member name="T:C1.Data.CurrentRowChangedEventHandler">
            <summary>
            Represents the method that handles the <see cref="!:CurrentRowChanged"/> event in <see cref="T:C1.Data.C1DataSet"/> and C1DataExpress components.
            </summary>
            <seealso cref="E:C1.Data.C1DataSet.CurrentRowChanged"/>
        </member>
        <member name="T:C1.Data.BaseDataTableSource">
            <summary>
            Base class for <see cref="T:C1.Data.C1DataTableSource"/> and C1DataExpress components.
            </summary>
        </member>
        <member name="M:C1.Data.BaseDataTableSource.MoveFirst">
            <summary>
            Moves to the first row.
            </summary>
            <remarks>
            Use this method to navigate the underlying rowset in virtual mode. Although this method is 
            applicable in all modes, it is only necessary in virtual mode. In virtual mode, the underlying 
            <see cref="P:C1.Data.BaseDataTableSource.DataTable"/> contains only a segment of available data. To navigate the whole rowset, you need to 
            use methods MoveFirst, <see cref="M:C1.Data.BaseDataTableSource.MoveLast"/>, <see cref="M:C1.Data.BaseDataTableSource.MoveNext"/>, <see cref="M:C1.Data.BaseDataTableSource.MovePrevious"/>, <see cref="M:C1.Data.BaseDataTableSource.Seek(System.Object[],System.Boolean@)"/>.
            If the rowset contains at least one row, this method moves to the first row and returns 
            True; otherwise, it returns False. After this method, properties <see cref="!:Position"/> and <see cref="P:C1.Data.BaseDataTableSource.CurrentRow"/> 
            point to the first row.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>
        </member>
        <member name="M:C1.Data.BaseDataTableSource.MoveLast">
            <summary>
            Moves to the last row.
            </summary>
            <remarks>
            Use this method to navigate the underlying rowset in virtual mode. Although this method is 
            applicable in all modes, it is only necessary in virtual mode. In virtual mode, the underlying 
            <see cref="P:C1.Data.BaseDataTableSource.DataTable"/> contains only a segment of available data. To navigate the whole rowset, you need to 
            use methods <see cref="M:C1.Data.BaseDataTableSource.MoveFirst"/>, MoveLast, <see cref="M:C1.Data.BaseDataTableSource.MoveNext"/>, <see cref="M:C1.Data.BaseDataTableSource.MovePrevious"/>, <see cref="M:C1.Data.BaseDataTableSource.Seek(System.Object[],System.Boolean@)"/>.
            If the rowset contains at least one row, this method moves to the last row and returns 
            True; otherwise, it returns False. After this method, properties <see cref="!:Position"/> and <see cref="P:C1.Data.BaseDataTableSource.CurrentRow"/> 
            point to the first row.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>        [C1Category("Data")]
        </member>
        <member name="M:C1.Data.BaseDataTableSource.MoveNext">
            <summary>
            Moves to the next row.
            </summary>
            <remarks>
            Use this method to navigate the underlying rowset in virtual mode. Although this method is 
            applicable in all modes, it is only necessary in virtual mode. In virtual mode, the underlying 
            <see cref="P:C1.Data.BaseDataTableSource.DataTable"/> contains only a segment of available data. To navigate the whole rowset, you need to use 
            methods <see cref="M:C1.Data.BaseDataTableSource.MoveFirst"/>, <see cref="M:C1.Data.BaseDataTableSource.MoveLast"/>, MoveNext, <see cref="M:C1.Data.BaseDataTableSource.MovePrevious"/>, <see cref="M:C1.Data.BaseDataTableSource.Seek(System.Object[],System.Boolean@)"/>.
            <para>If the current row is not the last row in the underlying data table, 
            this method moves to the next row and returns True; otherwise, it returns False. 
            After this method, the <see cref="!:Position"/> property is incremented by 1 and the <see cref="P:C1.Data.BaseDataTableSource.CurrentRow"/> returns the next row.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>        [C1Category("Data")]
        </member>
        <member name="M:C1.Data.BaseDataTableSource.MovePrevious">
            <summary>
            Moves to the previous row.
            </summary>
            <remarks>
            Use this method to navigate the underlying rowset in virtual mode. Although this method is 
            applicable in all modes, it is only necessary in virtual mode. In virtual mode, the underlying 
            <see cref="P:C1.Data.BaseDataTableSource.DataTable"/> contains only a segment of available data. To navigate the whole rowset, you need to use 
            methods <see cref="M:C1.Data.BaseDataTableSource.MoveFirst"/>, <see cref="M:C1.Data.BaseDataTableSource.MoveLast"/>, <see cref="M:C1.Data.BaseDataTableSource.MoveNext"/>, MovePrevious, <see cref="M:C1.Data.BaseDataTableSource.Seek(System.Object[],System.Boolean@)"/>.
            <para>If the current row is not the first row in the underlying data table, 
            this method moves to the next row and returns True; otherwise, it returns False. 
            After this method, the <see cref="!:Position"/> property is decremented by 1 and the <see cref="P:C1.Data.BaseDataTableSource.CurrentRow"/> returns the next row.</para>
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>        [C1Category("Data")]
        </member>
        <member name="M:C1.Data.BaseDataTableSource.Seek(System.Object[],System.Boolean@)">
            <summary>
            Seeks a row by its primary key values.
            </summary>
            <remarks>
            Use this method to navigate the underlying rowset in virtual mode. In virtual mode, 
            the underlying <see cref="P:C1.Data.BaseDataTableSource.DataTable"/> contains only a segment of available data. To navigate the whole 
            rowset, you need to use methods <see cref="M:C1.Data.BaseDataTableSource.MoveFirst"/>, <see cref="M:C1.Data.BaseDataTableSource.MoveLast"/>, <see cref="M:C1.Data.BaseDataTableSource.MoveNext"/>, <see cref="M:C1.Data.BaseDataTableSource.MovePrevious"/>, Seek.
            <para>This method seeks for the search key in the whole rowset. If the search key is 
            greater than all the keys in the rowset, the method returns False. Otherwise, it 
            finds the first row with the key greater than or equal to the search key, positions 
            the component on the found row (so the properties <see cref="P:C1.Data.BaseDataSourceComponent.Position"/> and <see cref="P:C1.Data.BaseDataTableSource.CurrentRow"/> point to 
            the found row) and returns true. It also sets the ExactMatch argument to indicate 
            whether an exact match was found or the first row with key value greater than the 
            search key.</para>
            </remarks>
            <param name="key">The primary key value to search for.</param>
            <param name="exactMatch">This parameter is undefined when the method is called. After the method 
            returns, it contains a value indicating whether the found row contains exactly the key value 
            the method searched for, or it is the row with the next key value in the primary key order. 
            It is set to False if the row with exact key match was not found.</param>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>        [C1Category("Data")]
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AsyncFetchComplete">
            <summary>
            Fired in <see cref="!:TableView.DataAccessMode"/> = VirtualAutomatic, when all rows are fetched.
            </summary>
            <remarks>
            This event is fired if the <see cref="P:C1.Data.C1DataTableSource.TableView"/> is in <see cref="!:TableView.DataAccessMode"/> = VirtualAutomatic. 
            It indicates the end of the fetch process.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>        [C1Category("Data")]
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeFieldChange">
            <summary>
            Fired before a field value is set.
            </summary>
            <remarks>
            This event can be used to specify validation logic that cannot be specified in the 
            form of constraint expressions. Throwing an exception in this event disallows the change. 
            When this event occurs, the field value is not yet modified. The new (proposed) value 
            is available in the NewValue argument of the event.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Modifying Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterFieldChange">
            <summary>
            Fired after a field value is set.
            </summary>
            <remarks>
            This event, among other possible actions, allows other fields/rows/tables to be modified 
            depending on this field. The new value is already assigned to the field, and the old field 
            value is also available in this event, in its OldValue argument. Knowing the old value can 
            be useful, for example, in updating counters, where you may need to add the new value and 
            subtract the old one.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Modifying Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeAddNew">
            <summary>
            Fired before a new (empty) row is added.
            </summary>
            <remarks>
            Throwing an exception in this event cancels adding a row.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterAddNew">
            <summary>
            Fired after a new (empty) row is added.
            </summary>
            <remarks>
            This event can be used to fill default values of the fields according to some rules that 
            cannot be specified as simple values of the <see cref="P:C1.Data.SchemaObjects.Field.DefaultValue"/> property. It can also be used to 
            specify the primary key values, see <span style="Link Topic">Keys Assigned by Client: New Row Detached and Attached State</span>.
            The ParentRow argument is used in AfterAddNew event on the data set level (in a 
            <see cref="T:C1.Data.C1DataSetLogic"/> component), in a master-detail situation. When a new row is added to the 
            child (detail) table view, this argument contains the parent row to which the new child 
            row belongs. Under other circumstances and in other events this argument contains null. 
            This argument is necessary because in this case parent row cannot be found using the 
            <see cref="M:C1.Data.C1DataRow.GetParentRow(System.String)"/>, as the new row is yet in detached state, 
            see <span style="Link Topic">Keys Assigned by Client: New Row Detached and Attached State</span>. <see cref="M:C1.Data.C1DataRow.GetParentRow(System.String)"/> becomes accessible only in the <see cref="E:C1.Data.BaseDataTableSource.AfterEndAddNew"/> event.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterChanges">
            <summary>
            Fired when all changes initiated by a field change are done and handled by the business logic code.
            </summary>
            <remarks>
            This event occurs when all changes to a row are finished, including both the changes 
            made directly by the user and those resulting from executing event code that handled 
            those changes. It is designed specifically to ensure that this is the "last change", 
            so the developers can put code that relies on the "finality" of changes to a row. For instance, 
            this event is the best place to put code setting calculated field values (for 
            calculations that cannot be specified as simple calculation expressions.
            <para>When a field value in a row changes, that change can be handled by event code that in 
            its turn can make other changes to row fields, or it could change other rows or other 
            tables. When all such handling is done, C1DataObjects collects all changed rows and 
            fires the AfterChanges event for every row that has changed in the process.</para>
            <para>Setting the <see cref="P:C1.Data.C1DataSet.ChangeInProgress"/> property to True, firing AfterChanges event can be deferred 
            until the property is set back to False. This allows multiple field changes to be performed 
            with AfterChanges firing only once, when all changes are done. </para>
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeBeginEdit">
            <summary>
            Fired when the user starts editing a row, before the row enters edit mode.
            </summary>
            <remarks>
            Throwing an exception in this event prevents the row going into edit mode.
            <para>Writing code handling edit mode events, take into account that in addition to 
            explicit programmatic calls to <see cref="M:C1.Data.C1DataRow.BeginEdit"/>/<see cref="M:C1.Data.C1DataRow.EndEdit"/>, edit mode is also used by data 
            bound controls: when a row becomes current, it is automatically placed in edit 
            mode (<see cref="M:C1.Data.C1DataRow.BeginEdit"/> is called implicitly). For example, throwing an exception in 
            BeforeBeginEdit event will prevent bound controls from positioning on a row. 
            This also means that BeforeBeginEdit event does not indicate an attempt to change a row. 
            If you need to execute some code when a row is being changed, consider using 
            <see cref="E:C1.Data.BaseDataTableSource.BeforeFirstChange"/>/<see cref="E:C1.Data.BaseDataTableSource.AfterFirstChange"/> events instead.</para>
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterBeginEdit">
            <summary>
            Fired when the user starts editing a row, after the row enters edit mode.
            </summary>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
            <seealso cref="E:C1.Data.BaseDataTableSource.AfterAddNew"/>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeEndEdit">
            <summary>
            Fired when the user finishes editing a row, before the row leaves edit mode.
            </summary>
            <remarks>
            Throwing an exception in this event prevents the row from leaving edit mode.
            <para>Use this event for validating changes done to a row, testing conditions that 
            depend on multiple fields, so these conditions can be tested only when all the changes 
            are done, the whole row changed, as opposed to conditions depending on a single field. 
            The latter are usually tested in the <see cref="E:C1.Data.BaseDataTableSource.BeforeFieldChange"/> event. See also 
            <see cref="P:C1.Data.SchemaObjects.BaseTable.ConstraintsFieldLevel"/>, and <see cref="P:C1.Data.SchemaObjects.BaseTable.ConstraintsRecordLevel"/> for alternative, codeless ways of specifying 
            validation conditions.</para>
            <para>Writing code handling edit mode events, take into account that in addition to explicit 
            programmatic calls to <see cref="M:C1.Data.C1DataRow.BeginEdit"/>/<see cref="M:C1.Data.C1DataRow.EndEdit"/>, edit mode is also used by data bound controls: 
            when a row becomes current, it is automatically placed in edit mode (BeginEdit is called 
            implicitly). When the user moves to another row, the row exits edit mode (EndEdit 
            is called implicitly). For example, throwing and exception in BeforeEndEdit event will 
            prevent bound controls from leaving the row. </para>
            <para>If you want to test validation conditions only when the row has been changed while it was in 
            edit mode and not when it was just moved to and out of edit mode without making changes, 
            use the Modified argument to distinguish between these two cases.</para>
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterEndEdit">
            <summary>
            Fired when the user finishes editing a row, after the row leaves edit mode.
            </summary>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeCancelEdit">
            <summary>
            Fired when the user cancels editing a row, before reverting the changes made to the row.
            </summary>
            <remarks>
            Throwing an exception in this event prevents reverting the changes in the row.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterCancelEdit">
            <summary>
            Fired when the user cancels editing a row, after reverting the changes made to the row.
            </summary>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeEndAddNew">
            <summary>
            Fired before a newly added row becomes a regular row in the rowset, that is, when its 
            primary key and other required (<see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false) fields are specified.
            </summary>
            <remarks>
            Throwing an exception in this event aborts the process of attaching the row (making it a 
            regular, that is, attached) row, as opposed to a just added, or detached row) and aborts 
            <see cref="M:C1.Data.C1DataRow.EndEdit"/>, if the row is being attached as a result of an <see cref="M:C1.Data.C1DataRow.EndEdit"/> call.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterEndAddNew">
            <summary>
            Fired after a newly added row becomes a regular row in the rowset, that is, when 
            its primary key and other required (<see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false) fields are specified.
            </summary>
            <remarks>
            A new row is created empty, filled with default values, its primary key undefined. 
            A row with undefined primary key is in a special transitory state called detached, 
            the process of adding this row to the rowset is yet incomplete. For example, such row will 
            not be sent to the database for update. A row becomes a full-fledged table row only after its 
            primary key is set and any fields with <see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/>=false are set too. This is when this event happens.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Adding Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeFirstChange">
            <summary>
            Fired before first change is made to a row (a field value changes) after the row last entered edit mode.
            </summary>
            <remarks>
            Throwing an exception in this event disallows changes to the row.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterFirstChange">
            <summary>
            Fired after first change is made to a row (a field value changes) after the row last entered edit mode.
            </summary>
            <remarks>
            This event occurs after the first change has been successfully performed on a row. 
            It can be used, for example, for showing some user interface clues indicating that the row 
            has been changed (canceling them in <see cref="E:C1.Data.BaseDataTableSource.AfterCancelEdit"/> and <see cref="E:C1.Data.BaseDataTableSource.AfterEndEdit"/>, if necessary). 
            After the AfterFirstChange event has been fired for the first time, successive changes 
            to row fields do not fire the <see cref="E:C1.Data.BaseDataTableSource.BeforeFirstChange"/>/AfterFirstChange events 
            until the row leaves edit mode.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Editing Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.BeforeDelete">
            <summary>
            Fired before a row is deleted.
            </summary>
            <remarks>
            Throwing an exception in this event cancels deleting the row.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Deleting Row</span></seealso>
        </member>
        <member name="E:C1.Data.BaseDataTableSource.AfterDelete">
            <summary>
            Fired after a row has been deleted.
            </summary>
            <remarks>
            To access field values in the deleted row, use the ItemArray argument. 
            The values are not accessible through regular row properties once the row has been deleted.
            </remarks>
            <seealso cref="T:C1.Data.BaseLogic"/>
            <seealso cref="T:C1.Data.C1TableLogic"/>
            <seealso cref="T:C1.Data.C1DataSetLogic"/>
            <seealso><span style="Link Topic">Events on Deleting Row</span></seealso>
        </member>
        <member name="P:C1.Data.BaseDataTableSource.UpdateLeavingRow">
            <summary>
            Gets or sets a value indicating whether modified rows are immediately updated to the database when the end user leaves the row.
            </summary>
            <remarks>
            This property is False by default, which means that you need to call the <see cref="M:C1.Data.C1DataSet.Update"/> method of 
            the <see cref="T:C1.Data.C1DataSet"/> object to commit changes to the database. If it is set True, C1DataObjects 
            automatically calls <see cref="M:C1.Data.C1DataSet.Update"/> when the user changes a row in a control bound to this component 
            and leaves that row.
            </remarks>
            <seealso><span style="Link Topic">When the Database is Updated</span></seealso>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
        </member>
        <member name="P:C1.Data.BaseDataTableSource.DataTable">
            <summary>
            Gets the source <see cref="T:C1.Data.C1DataTable"/> containing the data.
            </summary>
            <remarks>
            The data table returned by this property is used for programmatic access to the table data.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
        </member>
        <member name="P:C1.Data.BaseDataTableSource.CurrentRow">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataRow"/> object representing the current row.
            </summary>
            <remarks>
            This property returns the row data controls bound to this component are currently positioned on. 
            The index of this row is returned by the <see cref="P:C1.Data.BaseDataSourceComponent.Position"/> property.
            </remarks>
            <seealso cref="T:C1.Data.C1DataTableSource"/>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
        </member>
        <member name="T:C1.Data.C1DataTableSource">
            <summary>
            C1DataTableSource has two main uses:
            <para>    You can use C1DataTableSource to handle business logic events in your client application code, 
            in addition to the business logic specified in the data library, see <span style="Link Topic">Business Logic</span> for details.</para>
            <para>    You must use C1DataTableSource as the data source for your bound controls to make 
            them work in virtual mode, see <span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span> for details.</para>
            <para>C1DataTableSource is used as a data source for bound controls, such as grids and others.</para>
            </summary>
            <seealso cref="T:C1.Data.C1DataTableCollection"/>
        </member>
        <member name="M:C1.Data.C1DataTableSource.#ctor">
            <summary>
            Initializes a new instance of the C1DataTableSource class.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataTableSource.DataSet">
            <summary>
            Gets or sets the <see cref="T:C1.Data.C1DataSet"/> to which this component belongs.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataTableSource.TableView">
            <summary>
            Gets or sets the name of the table view represented by this component.
            </summary>
        </member>
        <member name="M:C1.Data.IC1ComplexBoundControl.CanAccessRow">
            <summary>
            Indicates whether the Row property can be used.
            </summary>
        </member>
        <member name="P:C1.Data.IC1ComplexBoundControl.Row">
            <summary>
            Gets or sets the current row index.
            </summary>
        </member>
        <member name="T:C1.Data.ExecutionModeEnum">
            <summary>
            Specifies whether actions in handling business object events are deferred or performed immediately.
            </summary>
            <remarks>
            Use the members of this enumeration to determine the action performed on a data row.
            </remarks>
            <seealso cref="P:C1.Data.C1DataSet.ExecutionMode"/>
            <seealso><span style="LinkTopic">C1ExpressConnection.ExecutionMode Property</span></seealso>
            <span style="LinkTopic">Action Order and Execution Mode</span>
        </member>
        <member name="F:C1.Data.ExecutionModeEnum.Immediate">
            <summary>
            Actions performed immediately.
            </summary>
        </member>
        <member name="F:C1.Data.ExecutionModeEnum.Deferred">
            <summary>
            Actions deferred until the current user action handling is completed.
            </summary>
        </member>
        <member name="T:C1.Data.FieldCalculationInfo">
            <summary>
            An element of a field's <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection.
            </summary>
        </member>
        <member name="P:C1.Data.FieldCalculationInfo.Expression">
            <summary>
            Gets or sets the expression producing the result of a calculation. 
            </summary>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.FieldCalculationInfo.Condition">
            <summary>
            Gets or sets an optional Boolean expression defining applicability of a calculation. 
            </summary>
            <remarks>
            If this expression is empty or evaluates to True, the <see cref="P:C1.Data.SchemaObjects.Field.CalculationExpression"/> is evaluated and assigned to the field. If it evaluates to False, this calculation is skipped. 
            </remarks>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.FieldCalculationInfo.FireEvent">
            <summary>
            Gets or sets a value indicating whether calculation triggers the same events as field modification by the user.
            </summary>
            <remarks>
            This property is set to False by default. If it is set to True, setting the value from calculation 
            expression triggers the same sequence of events (<see cref="E:C1.Data.BaseLogic.BeforeFieldChange"/>, <see cref="E:C1.Data.BaseLogic.AfterFieldChange"/>, <see cref="E:C1.Data.BaseLogic.AfterChanges"/>) 
            as if the end user has modified the value.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="T:C1.Data.FieldCalculationCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.FieldCalculationInfo"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.FieldCalculationCollection.Add(C1.Data.FieldCalculationInfo)">
            <summary>
            Adds an element to the collection.
            </summary>
            <param name="calculation">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.FieldCalculationCollection.Insert(System.Int32,C1.Data.FieldCalculationInfo)">
            <summary>
            Inserts an element into the FieldCalculationCollection at the specified index.
            </summary>
            <param name="index">The zero-based index at which calculation should be inserted.</param>
            <param name="calculation">The object to insert.</param>
        </member>
        <member name="M:C1.Data.FieldCalculationCollection.Remove(C1.Data.FieldCalculationInfo)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="calculation">The object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.FieldCalculationCollection.IndexOf(C1.Data.FieldCalculationInfo)">
            <summary>
            Returns the zero-based index of the calculation object in the collection.
            </summary>
            <param name="calculation">The object to locate in the collection.</param>
            <returns>The zero-based index of the calculation object, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.FieldCalculationCollection.Contains(C1.Data.FieldCalculationInfo)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="calculation">The Object to locate in the collection.</param>
            <returns>True if calculation object is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.FieldCalculationCollection.CopyTo(C1.Data.FieldCalculationInfo[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="P:C1.Data.FieldCalculationCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="T:C1.Data.ConstraintException">
            <summary>
            Represents the exception that is thrown when attempting an action that violates a constraint.
            </summary>
        </member>
        <member name="P:C1.Data.ConstraintException.ErrorTable">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataTable"/> where the exception occured.
            </summary>
        </member>
        <member name="P:C1.Data.ConstraintException.ErrorField">
            <summary>
            Gets the <see cref="T:C1.Data.DataField"/> where the exception occured.
            </summary>
        </member>
        <member name="T:C1.Data.ConstraintInfo">
            <summary>
            An element of a field's <see cref="P:C1.Data.SchemaObjects.Field.Constraints"/> collection.
            </summary>
        </member>
        <member name="P:C1.Data.ConstraintInfo.Expression">
            <summary>
            Gets or sets the Boolean expression used to test a constraint.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.ConstraintInfo.Condition">
            <summary>
            Gets or sets an optional Boolean expression defining applicability of a constraint.
            </summary>
            <remarks>
            If this expression is empty or evaluates to True, the <see cref="P:C1.Data.SchemaObjects.Field.ConstraintExpression"/> is evaluated. 
            If it evaluates to False, this constraint is skipped.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.ConstraintInfo.ErrorDescription">
            <summary>
            Gets or sets the string used as the error description in the exception thrown when a constraint is not satisfied.
            </summary>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="T:C1.Data.ConstraintCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.ConstraintInfo"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.ConstraintCollection.Add(C1.Data.ConstraintInfo)">
            <summary>
            Adds an element to the collection. 
            </summary>
            <param name="constraint">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.ConstraintCollection.Insert(System.Int32,C1.Data.ConstraintInfo)">
            <summary>
            
            </summary>
            <param name="index"></param>
            <param name="constraint"></param>
        </member>
        <member name="M:C1.Data.ConstraintCollection.Remove(C1.Data.ConstraintInfo)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="constraint">The object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.ConstraintCollection.CopyTo(C1.Data.ConstraintInfo[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="ar">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.ConstraintCollection.IndexOf(C1.Data.ConstraintInfo)">
            <summary>
            Returns the zero-based index of the constraint in the collection.
            </summary>
            <param name="constraint">The Object to locate in the collection.</param>
            <returns>The zero-based index of the constraint, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.ConstraintCollection.Contains(C1.Data.ConstraintInfo)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="constraint">The Object to locate in the collection.</param>
            <returns>True if constraint is found in the collection; otherwise, False.</returns>
        </member>
        <member name="P:C1.Data.ConstraintCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
        </member>
        <member name="T:C1.Data.DataRowVersionEnum">
            <summary>
            Specifies the version of a <see cref="T:C1.Data.C1DataRow"/>.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowVersionEnum.Current">
            <summary>
            Current values in the row.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowVersionEnum.Default">
            <summary>
            Default values in an added row, as they were immediately after the row was added.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowVersionEnum.Original">
            <summary>
            Original values in the row, as they were fetched from the database.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowVersionEnum.Proposed">
            <summary>
            Values set in edit mode, they have not yet become current, will become current when edit mode ends.
            </summary>
        </member>
        <member name="T:C1.Data.DataRowStateEnum">
            <summary>
            Specifies the state of a <see cref="T:C1.Data.C1DataRow"/>.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowStateEnum.Added">
            <summary>
            The row was added using the AddNew method of <see cref="T:C1.Data.C1DataTable"/>.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowStateEnum.Deleted">
            <summary>
            The row was deleted using the Delete method of <see cref="T:C1.Data.C1DataRow"/>.
            </summary>
        </member>
        <member name="F:C1.Data.DataRowStateEnum.Detached">
            <summary>
            The row was removed from the table and will be destroyed. Detached rows are not considered deleted, they are completely removed from the data set and will not be accessible. 
            </summary>
        </member>
        <member name="F:C1.Data.DataRowStateEnum.Modified">
            <summary>
            Some row field values were modified. If the modification occurred in edit mode, the edit was ended. 
            </summary>
        </member>
        <member name="F:C1.Data.DataRowStateEnum.Unchanged">
            <summary>
            The row has not changed since <see cref="M:C1.Data.C1DataSet.Fill"/>, <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> or <see cref="M:C1.Data.C1DataSet.RejectChanges"/>.
            </summary>
        </member>
        <member name="T:C1.Data.DataViewRowStateEnum">
            <summary>
            Specifies a subset of rows satisfying certain status and version conditions.
            <para>This enumeration has a FlagsAttribute attribute that allows a bitwise combination of its member values.</para>
            </summary>
            <seealso cref="P:C1.Data.C1DataView.RowStateFilter"/>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.None">
            <summary>
            None
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.OriginalRows">
            <summary>
            Original rows, including ModifiedOriginal, deleted and unchanged.
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.CurrentRows">
            <summary>
            Current rows including unchanged, new, and modified rows.
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.Added">
            <summary>
            New rows.
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.Deleted">
            <summary>
            Deleted rows, not including rows that were first added, then deleted (those are completely removed and cannot be accessed).
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.ModifiedCurrent">
            <summary>
            Modified rows.
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.ModifiedOriginal">
            <summary>
            The original version of modified rows (the modified version is available as ModifiedCurrent).
            </summary>
        </member>
        <member name="F:C1.Data.DataViewRowStateEnum.Unchanged">
            <summary>
            Unchanged rows.
            </summary>
        </member>
        <member name="T:C1.Data.CommandTypeEnum">
            <summary>
            Specifies how a command string is interpreted.
            </summary>
        </member>
        <member name="F:C1.Data.CommandTypeEnum.Text">
            <summary>
            A SQL statement.
            </summary>
        </member>
        <member name="F:C1.Data.CommandTypeEnum.StoredProcedure">
            <summary>
            A stored procedure name.
            </summary>
        </member>
        <member name="T:C1.Data.C1DataException">
            <summary>
            Base class for all C1DataObjects exception classes.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataException.ErrorTable">
            <summary>
            Gets the name of the table or table view where the exception occurred.
            </summary>
            <remarks>To distinguish between tables and table views, use properties <see cref="P:C1.Data.C1DataException.IsTable"/> and <see cref="P:C1.Data.C1DataException.IsTableView"/>.
            This property returns empty string if the exception is not related to a particular table or table view.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataException.IsTable">
            <summary>
            Gets a value indicating whether the object where the exception occurred is a table (as opposed to a table view).
            </summary>
        </member>
        <member name="P:C1.Data.C1DataException.IsTableView">
            <summary>
            Gets a value indicating whether the object where the exception occurred is a table view (as opposed to a table).
            </summary>
        </member>
        <member name="P:C1.Data.C1DataException.ErrorField">
            <summary>
            Gets the name of the field where the exception occurred.
            </summary>
            <remarks>
            This property returns empty string if the exception is not related to a particular field.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataException.ErrorRow">
            <summary>
            Gets the index of the row where the exception occurred.
            </summary>
            <remarks>
            This property returns -1 if the exception is not related to a particular field.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataException.ShowMessage">
            <summary>
            Gets or sets a value determining whether error message must be displayed by bound controls or it should be suppressed since C1DataObjects already handled the error.
            </summary>
            <remarks>
            This property is False by default. If an exception generates error messages in bound controls, 
            and you want to suppress them because you already showed an error message or otherwise handled 
            the error in <see cref="T:C1.Data.C1DataSet"/> object's <see cref="E:C1.Data.C1DataSet.Error"/> event, set this property to true in the <see cref="E:C1.Data.C1DataSet.Error"/> event code.
            This behavior is only supported by data bound controls honoring the ShowMessage property, 
            such as ComponentOne FlexGrid and C1TrueDBGrid.
            </remarks>
        </member>
        <member name="T:C1.Data.DataActionCanceledException">
            <summary>
            Represents an exception that is thrown when an action is canceled by throwing an 
            exception in a business logic event (see <span style="Link Topic">Business Logic</span>).
            </summary>
            <remarks>
            To retrieve the exception thrown 
            by the user code in a business logic event, use the InnerException property belonging 
            to the System.Exception class.
            </remarks>
        </member>
        <member name="T:C1.Data.ExpressionException">
            <summary>
            Represents an exception that is thrown when attempting an operation using an invalid field expression.
            </summary>
        </member>
        <member name="T:C1.Data.DbAccessException">
            <summary>
            Represents an exception that is thrown while performing database access 
            operations fetching data or updating the database.
            </summary>
        </member>
        <member name="P:C1.Data.DbAccessException.Connection">
            <summary>
            Gets the name of the <see cref="T:C1.Data.SchemaObjects.Connection"/> object used to connect to the database.
            </summary>
        </member>
        <member name="T:C1.Data.OperationEnum">
            <summary>
            Specified an operation performed over data or data components.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.None">
            <summary>
            No operation.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.AddNew">
            <summary>
            Adding new row.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.Delete">
            <summary>
            Deleting a row.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.Modify">
            <summary>
            Modifying a row.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.Update">
            <summary>
            Updating the database.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.Initialization">
            <summary>
            Initializing a component.
            </summary>
        </member>
        <member name="F:C1.Data.OperationEnum.Fill">
            <summary>
            Filling a component with data.
            </summary>
        </member>
        <member name="T:C1.Data.DisabledOperationException">
            <summary>
            Represents an exception that is thrown on attempt to perform an action that is disabled 
            by the current property settings.
            </summary>
            <remarks>
            Represents an exception that is thrown on attempt to perform an action that is disabled 
            by the current property settings (such as <see cref="!:C1.Data.SchemaObjects.ReadOnly"/>, <see cref="!:C1.Data.SchemaObjects.AllowDelete"/>, etc.) or the current state of an object.
            </remarks>
        </member>
        <member name="P:C1.Data.DisabledOperationException.Operation">
            <summary>
            Gets the attempted operation.
            </summary>
        </member>
        <member name="T:C1.Data.OperationFailureException">
            <summary>
            Represents an exception that is thrown when an operation, such as updating the database, fails.
            </summary>
        </member>
        <member name="P:C1.Data.OperationFailureException.Operation">
            <summary>
            Gets the attempted operation.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaException">
            <summary>
            Represents an exception that is thrown at run time when C1DataObjects encounters errors 
            in the schema specified in a <see cref="T:C1.Data.C1SchemaDef"/> component. Most of such errors can be detected 
            at design time performing schema verification (select Verify schema from the Schema menu in Schema Designer).
            </summary>
        </member>
        <member name="P:C1.Data.SchemaException.ObjectName">
            <summary>
            Gets the name of the schema object where the error is found.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaException.ObjectTypeName">
            <summary>
            Gets the type name of the schema object where the error is found.
            </summary>
        </member>
        <member name="T:C1.Data.InvalidDataOperationException">
            <summary>
            Represents an exception that is thrown on attempt to perform an operation that cannot be performed.
            </summary>
            <remarks>
            Represents an exception that is thrown on attempt to perform an operation that, although 
            not explicitly disabled by property settings, cannot be performed on the specified 
            object in its current state with specified arguments.
            </remarks>
        </member>
        <member name="T:C1.Data.DataItem">
            <summary>
            Represents a <see cref="T:C1.Data.C1DataRow"/> exposed to data bound controls. The corresponding <see cref="T:C1.Data.C1DataRow"/> 
            object can be obtained as DataItem.DataRow. Alternatively, the same <see cref="T:C1.Data.C1DataRow"/> objects can 
            be obtained as <see cref="M:C1.Data.C1DataRow.FromDataItem(System.Object)"/>(dataItem).
            </summary>
        </member>
        <member name="P:C1.Data.DataItem.DataRow">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataRow"/> object represented by this data item.
            </summary>
        </member>
        <member name="P:C1.Data.DataItem.Item(System.Int32)">
            <summary>
            Gets or sets the data stored in a specified field.
            </summary>
            <param name="fieldIndex">The zero-based index of the field.</param>
            <returns>An Object that contains the data.</returns>
        </member>
        <member name="P:C1.Data.DataItem.Item(System.String)">
            <summary>
            Gets or sets the data stored in a specified field.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <returns>An Object that contains the data.</returns>
        </member>
        <member name="P:C1.Data.DataItem.RowState">
            <summary>
            Gets the current state of the <see cref="T:C1.Data.C1DataRow"/> object represented by this data item.
            </summary>
        </member>
        <member name="T:C1.Data.C1DataTable">
            <summary>
            Represents a table or table view rowset filled with data. Provides programmatic access to 
            table view or table data. To obtain a C1DataTable object, use <see cref="P:C1.Data.C1DataSet.TableViews"/> or <see cref="P:C1.Data.C1DataSet.Tables"/> collection 
            property of a <see cref="T:C1.Data.C1DataSet"/> component.
            </summary>
            <seealso><span style="Link Topic">How to Access Table Data</span></seealso>
            <seealso><span style="Link Topic">How to Access Table View Data</span></seealso>
        </member>
        <member name="M:C1.Data.C1DataTable.AddNew">
            <summary>
            Adds a new row to the data table.
            </summary>
            <remarks>
            This method creates a new empty row and adds it to the data table. The new row is filled only 
            with default values, its primary key undefined. A row with undefined primary key is in a special 
            transitory state called detached, the process of adding this row to the rowset is yet incomplete. 
            For example, such row will not be sent to the database for update. A row becomes a 
            full-fledged table row only after its primary key is set and any fields with 
            <see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/> = False are set too.
            </remarks>
            <seealso><span style="Link Topic">Adding Rows and Primary Keys</span></seealso>
        </member>
        <member name="M:C1.Data.C1DataTable.Refresh">
            <summary>
            Refreshes field values in all data table rows and notifies data bound controls that the 
            rows have changed.
            </summary>
            <remarks>
            This method performs <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> for every field in every row that has non-empty 
            <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection. Normally, calculations are performed automatically, without 
            explicit Refresh call, when calculation arguments change. However, some calculation 
            arguments changes cannot be detected automatically, for example, changes in Current, 
            Original or BeforeChange field values, see <span style="Link Topic">C1DataObjects Expressions</span>. Calling the 
            Refresh method is also necessary when you use the <see cref="P:C1.Data.C1DataSet.SuppressNotifications"/> property of 
            a data set, to notify data bound controls that row values have changed.
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataTable.GetErrors">
            <summary>
            Gets an array of <see cref="T:C1.Data.C1DataRow"/> objects that contain errors.
            </summary>
            <seealso cref="P:C1.Data.C1DataTable.HasErrors"/>
        </member>
        <member name="M:C1.Data.C1DataTable.Compute(System.String,System.Type,System.String)">
            <summary>
            Computes an aggregation expression on the rows that satisfy a filter condition.
            </summary>
            <remarks>
            This function computes aggregation expressions only. For example, you can use it to compute 
            a sum of a field over rows, as in Sum(Quantity) (correct), but not to compute an expression 
            depending on multiple fields in a single row, as in UnitPrice * Quantity (incorrect). For 
            computations involving multiple fields in a single row use field <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/>.
            </remarks>
        </member>
        <member name="M:C1.Data.C1DataTable.AcceptChanges">
            <summary>
            Commits all changes made to the table since it was filled with data or the last time 
            AcceptChanges or <see cref="M:C1.Data.C1DataTable.RejectChanges"/> was called.
            </summary>
            <remarks>
            This method accepts changes in one simple table or simple table view, whereas method 
            <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> accepts changes in the whole data set. This method cannot be 
            applied to composite tables. Also, it is not allowed to apply this method to a simple 
            table that is used in a composite table as a main constituent table (is connected to its 
            parent in the composite table diagram with a one-to-many relation; the restriction does 
            not apply to those connected many-to-one). If one of these restrictions is not satisfied, 
            the method throws an exception. In such case, use <see cref="M:C1.Data.C1DataSet.AcceptChanges"/> for the whole data set.
            </remarks>
            <seealso cref="M:C1.Data.C1DataSet.AcceptChanges"/>
        </member>
        <member name="M:C1.Data.C1DataTable.RejectChanges">
            <summary>
            Rolls back all changes made to the table since it was filled with data or the last 
            time <see cref="M:C1.Data.C1DataTable.AcceptChanges"/> or RejectChanges was called.
            </summary>
            <remarks>
            This method rolls back changes in one simple table or simple table view, whereas method 
            <see cref="M:C1.Data.C1DataSet.RejectChanges"/> rolls back changes in the whole data set. This method cannot be 
            applied to composite tables. Also, it is not allowed to apply this method to a simple 
            table that is used in a composite table as a main constituent table (is connected to 
            its parent in the composite table diagram with a one-to-many relation; the restriction 
            does not apply to those connected many-to-one). If one of these restrictions is not satisfied, 
            the method throws an exception. In such case, use <see cref="M:C1.Data.C1DataSet.RejectChanges"/> for the whole data set.
            </remarks>
            <seealso cref="M:C1.Data.C1DataSet.RejectChanges"/>
        </member>
        <member name="M:C1.Data.C1DataTable.ResetCaseSensitive">
            <summary>
            If the value of the <see cref="P:C1.Data.C1DataTable.CaseSensitive"/> property was overridden in the C1DataTable,
            this method switches C1DataTable to the CaseSensitive property of the owner <see cref="T:C1.Data.C1DataSet"/>.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataTable.ResetSortComparisonMode">
            <summary>
            If the value of the <see cref="P:C1.Data.C1DataTable.SortComparisonMode"/> property was overridden in the C1DataTable,
            this method switches C1DataTable to the SortComparisonMode property of the owner <see cref="T:C1.Data.C1DataSet"/>.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataTable.DataSet">
            <summary>
            Gets the data set this data table belongs to.
            </summary>
        </member>
        <member name="P:C1.Data.C1DataTable.SchemaTable">
            <summary>
            Gets a <see cref="T:C1.Data.SchemaObjects.Table"/> or <see cref="T:C1.Data.SchemaObjects.TableView"/> schema object representing the schema of this data table.
            </summary>
            <seealso cref="T:C1.Data.SchemaObjects.BaseTable"/>
        </member>
        <member name="P:C1.Data.C1DataTable.Name">
            <summary>
            Gets the name of the data table.
            </summary>
            <remarks>
            This property is used to return this data table from the C1DataSet object's two data 
            table collections, <see cref="P:C1.Data.C1DataSet.Tables"/> and <see cref="P:C1.Data.C1DataSet.TableViews"/>.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataTable.Rows">
            <summary>
            This run-time property returns the collection of rows belonging to this data table.
            </summary>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>
        </member>
        <member name="P:C1.Data.C1DataTable.Fields">
            <summary>
            This run-time property returns the collection of fields in the data table.
            </summary>
            <seealso cref="T:C1.Data.DataFieldCollection"/>
        </member>
        <member name="P:C1.Data.C1DataTable.ExtendedProperties">
            <summary>
            Gets a collection of custom user information associated with the data table.
            </summary>
            <remarks>
            This property allows you to store arbitrary custom information with the object.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataTable.Locale">
            <summary>
            Determines the locale information used in string comparisons within the data table.
            </summary>
            <remarks>
            This property affects string comparison in expression evaluation, sorting table views 
            by the end user (via IBindingList.ApplySort) and sorting in <see cref="T:C1.Data.C1DataView"/> objects.
            <para>By default, all C1DataTable objects created by a <see cref="T:C1.Data.C1DataSet"/> use the Locale property of 
            the <see cref="T:C1.Data.C1DataSet"/>, but it can be overridden setting the Locale property of the C1DataTable object.</para>
            </remarks>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataTable.CaseSensitive">
            <summary>
            Determines whether string comparisons within the data table are case-sensitive.
            </summary>
            <remarks>
            This property affects string comparison in expression evaluation, sorting table views 
            by the end user (via IBindingList.ApplySort) and sorting in <see cref="T:C1.Data.C1DataView"/> objects.
            <para>By default, all C1DataTable objects created by a <see cref="T:C1.Data.C1DataSet"/> use the CaseSensitive 
            property of the <see cref="T:C1.Data.C1DataSet"/>, but it can be overridden setting the CaseSensitive property 
            of the C1DataTable object.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataTable.SortComparisonMode">
            <summary>
            Determines the type of string comparison within the data table.
            </summary>
            <remarks>
            This property affects string comparison in expression evaluation, sorting table views by 
            the end user (via IBindingList.ApplySort) and sorting in <see cref="T:C1.Data.C1DataView"/> objects.
            <para>By default, all <see cref="T:C1.Data.C1DataTable"/> objects created by a C1DataSet use the SortComparisonMode property 
            of the C1DataSet, but it can be overridden setting the <see cref="P:C1.Data.C1DataTable.SortComparisonMode"/> property of the <see cref="T:C1.Data.C1DataTable"/> object.</para>
            </remarks>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataTable.HasErrors">
            <summary>
            Gets a value indicating whether there are errors in any of the rows of this data table.
            </summary>
            <remarks>
            To get all errors, use the <see cref="M:C1.Data.C1DataTable.GetErrors"/> method.
            </remarks>
        </member>
        <member name="P:C1.Data.C1DataTable.PrimaryKey">
            <summary>
            Gets an array of fields that function as primary key of this data table.
            </summary>
            <seealso><span style="Link Topic">Table Properties</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataTable.StorageDataTable">
            <summary>
            Gets the ADO.NET DataTable storing data rows for a simple table.
            </summary>
            <remarks>
            This data table belongs to the ADO.NET data set C1DataSet.StorageDataSet.
            <para>This property returns a non-null value only for C1DataTable objects representing 
            simple tables. For C1DataTable objects representing composite tables and table views, 
            this property returns null (Nothing in Visual Basic).</para>
            </remarks>
            <seealso><span style="Link Topic">C1DataObjects and ADO.NET</span></seealso>
            <seealso><span style="Link Topic">Working with ADO.NET Dataset</span></seealso>
        </member>
        <member name="P:C1.Data.C1DataTable.FetchIndex">
            <summary>
            Gets or sets fetch order of the data table representing a table view rowset.
            </summary>
            <remarks>
            This property is used to modify fetch order dynamically in the <see cref="E:C1.Data.C1DataSetLogic.BeforeFetch"/> event when 
            this event is fired with empty an TableView argument before fetching any table views. For example:
            <para>   Visual Basic:
            <code>
            Private Sub DataSet_BeforeFetch(ByVal sender As Object, ByVal e As C1.Data.FetchEventArgs) Handles DataSet.BeforeFetch
              If e.TableView Is Nothing Then
                e.TableViews("maindata").FetchIndex = 0
              End If
            End Sub
            </code></para>
            <para>   C#:
            <code>
            private void dataset_DataSet_BeforeFetch(object sender, C1.Data.FetchEventArgs e)
            {
                if (e.TableView == null)
                    e.TableViews["maindata"].FetchIndex = 0;
            }
            </code></para>
            <para>   Delphi:
            <code>
            procedure TForm.dataset_BeforeFetch(sender: System.Object; e: C1.Data.FetchEventArgs);
            begin
              if e.TableView = nil then
                e.TableViews['maindata'].FetchIndex := 0;
            end;
            </code></para>
            <para>If you only need to modify fetch order statically, it is easier to do it
            setting the <see cref="P:C1.Data.SchemaObjects.TableView.FetchIndex"/> property in Schema Designer.</para>
            <para>Possible values: from 0 up to the number of table views in the dataset.</para>
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.TableView.FetchIndex"/>
        </member>
        <member name="T:C1.Data.DataField">
            <summary>
            Represents a field of a <see cref="T:C1.Data.C1DataTable"/>, an item of the <see cref="P:C1.Data.C1DataTable.Fields"/> collection.
            </summary>
            <remarks>
             Data table fields correspond to schema fields, <see cref="T:C1.Data.SchemaObjects.Field"/> objects of the corresponding schema 
            table or table view. The DataField class contains only a few most important field properties. 
            To access other field property values, use the schema <see cref="T:C1.Data.SchemaObjects.Field"/> accessible through the <see cref="P:C1.Data.DataField.SchemaField"/> property.
            </remarks>
        </member>
        <member name="P:C1.Data.DataField.SchemaField">
            <summary>
            Gets the schema <see cref="T:C1.Data.SchemaObjects.Field"/> object on which the field is based.
            </summary>
            <remarks>
            Data table fields correspond to schema fields, C1.Data.SchemaObjects.Field objects 
            of the corresponding schema table or table view that can be accessed through the 
            SchemaTable property of the <see cref="T:C1.Data.C1DataTable"/>.
            </remarks>
        </member>
        <member name="P:C1.Data.DataField.Name">
            <summary>
            Gets the name of the field in the <see cref="T:C1.Data.DataFieldCollection"/>.
            </summary>
            <remarks>
            This property is used to return this data field from the <see cref="T:C1.Data.C1DataTable"/> object's <see cref="P:C1.Data.C1DataTable.Fields"/> collection.
            </remarks>
        </member>
        <member name="P:C1.Data.DataField.DataType">
            <summary>
            Gets the type of field data.
            </summary>
        </member>
        <member name="P:C1.Data.DataField.DataTable">
            <summary>
            Gets the <see cref="T:C1.Data.C1DataTable"/> to which the field belongs.
            </summary>
        </member>
        <member name="P:C1.Data.DataField.Ordinal">
            <summary>
            Gets the position of the field in the <see cref="T:C1.Data.DataFieldCollection"/>.
            </summary>
            <remarks>
            This property is used to return this data field from the <see cref="T:C1.Data.C1DataTable"/> object's <see cref="P:C1.Data.C1DataTable.Fields"/> collection.
            </remarks>
        </member>
        <member name="P:C1.Data.DataField.ExtendedProperties">
            <summary>
            Gets a collection of custom user information associated with the data set.
            </summary>
            <remarks>
            This property allows you to store arbitrary custom information with the object.
            </remarks>
        </member>
        <member name="P:C1.Data.DataField.StorageDataColumn">
            <summary>
            Gets the ADO.NET DataColumn object storing this field's data.
            </summary>
            <remarks>
            The DataColumn belongs to the table <see cref="P:C1.Data.C1DataTable.StorageDataTable"/>.
            <para>This property returns a non-null value only for fields of C1DataTable objects 
            representing simple tables. For <see cref="T:C1.Data.C1DataTable"/> objects representing composite tables 
            and table views, this property returns null (Nothing in Visual Basic) for all fields.</para>
            </remarks>
            <seealso><span style="Link Topic">C1DataObjects and ADO.NET</span></seealso>
            <seealso><span style="Link Topic">Working with ADO.NET Dataset</span></seealso>
        </member>
        <member name="T:C1.Data.DataFieldCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.DataField"/> objects, fields of a <see cref="T:C1.Data.C1DataTable"/>.
            </summary>
        </member>
        <member name="M:C1.Data.DataFieldCollection.CopyTo(C1.Data.DataField[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.DataFieldCollection.IndexOf(System.String)">
            <summary>
            Returns the zero-based index of the first occurrence of a value in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.DataField.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="P:C1.Data.DataFieldCollection.Count">
            <summary>
            Gets the total number of elements in a collection.
            </summary>
        </member>
        <member name="P:C1.Data.DataFieldCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="P:C1.Data.DataFieldCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.DataField.Name"/> of the element.</param>
        </member>
        <member name="T:C1.Data.C1DataRowCollection">
            <summary>
            Represents a collection of rows in a <see cref="T:C1.Data.C1DataTable"/> object.
            </summary>
        </member>
        <member name="M:C1.Data.C1DataRowCollection.CopyTo(C1.Data.C1DataRow[],System.Int32)">
            <summary>
            Copies elements of the collection to an array starting at a particular array index.
            </summary>
            <param name="array">The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>        
        </member>
        <member name="M:C1.Data.C1DataRowCollection.IndexOf(C1.Data.C1DataRow)">
            <summary>
            Determines the index of a specific item in the collection, return -1 if this item not found.
            </summary>
            <param name="row">The object to locate in the collection.</param>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>
        </member>
        <member name="M:C1.Data.C1DataRowCollection.Contains(C1.Data.C1DataRow)">
            <summary>
            Returns True if the collection contains the specific item, False otherwise.
            </summary>
            <param name="row">The object to locate in the collection.</param>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>        
        </member>
        <member name="M:C1.Data.C1DataRowCollection.Find(System.Object)">
            <summary>
            Gets the row specified by the primary key value.
            </summary>
            <remarks>This method returns the C1DataRow object containing the primary key values specified; 
            otherwise a null value if the primary key values do not exist in the C1DataRowCollection.
            <para>To use the Find method, the <see cref="T:C1.Data.C1DataTable"/> object must have at least one field designated as 
            a primary key field, see PrimaryKey property.</para>
            </remarks>
            <param name="key">The primary key value of the row to find.</param>
            <returns>The <see cref="T:C1.Data.C1DataRow"/> object.</returns>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>
        </member>
        <member name="M:C1.Data.C1DataRowCollection.Find(System.Object[])">
            <summary>
            Gets the row specified by the primary key value.
            </summary>
            <param name="keys">An array of primary key values to find.</param>
            <returns>The <see cref="T:C1.Data.C1DataRow"/> object.</returns>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>         
        </member>
        <member name="P:C1.Data.C1DataRowCollection.Count">
            <summary>
            Gets the total number of rows in the data table.
            </summary>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>
        </member>
        <member name="P:C1.Data.C1DataRowCollection.Item(System.Int32)">
            <summary>
            Gets the row at the specified index.
            </summary>
            <seealso cref="T:C1.Data.C1DataRowCollection"/>        
        </member>
        <member name="T:C1.Data.UnboundDataReader">
            <summary>
            UnboundDataReader is a helper class used in supporting unbound tables in the <see cref="E:C1.Data.C1DataSetLogic.BeforeFetch"/> event. The data is passed to its constructor in a System.Data.DataTable object. It implements the System.Data.IDataReader interface.
            </summary>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="M:C1.Data.UnboundDataReader.#ctor(System.Data.DataTable)">
            <summary>
            Initializes a new instance of the UnboundDataReader class.
            </summary>
            <param name="dataTable">System.Data.DataTable object with data rows.</param>
        </member>
        <member name="M:C1.Data.UnboundDataReader.#ctor">
            <summary>
            Initializes a new instance of the DbTableField class.
            </summary>
        </member>
        <member name="P:C1.Data.UnboundDataReader.DataTable">
            <summary>
            Gets or sets the System.Data.DataTable object that contains data rows for this data reader.
            </summary>
        </member>
        <member name="T:C1.Data.CacheModeEnum">
            <summary>
            Specifies the conditions for enabling caching.
            </summary>
            <seealso cref="T:C1.Data.SchemaObjects.CacheProperties"/>
        </member>
        <member name="F:C1.Data.CacheModeEnum.InWebForms">
            <summary>
            Global caching for this data set is enabled only in WebForms.
            </summary>
        </member>
        <member name="F:C1.Data.CacheModeEnum.NotCached">
            <summary>
            Global caching is disabled for this data set.
            </summary>
        </member>
        <member name="F:C1.Data.CacheModeEnum.Always">
            <summary>
            Reserved for future use (in current version this value is equivalent to InWebForms)
            </summary>
        </member>
        <member name="T:C1.Data.CacheStorageEnum">
            <summary>
            Specifies storage type for saving data.
            </summary>
            <remarks>
            For Memory storage type, storing data in the cache depends on the session state mode for which your web application is configured.
            <para>If SessionStateMode = InProc, in global cache, the data is copied to a persistent object in memory.</para>
            <para>If SessionStateMode = InProc, in session cache, the data stays in the same object, no copying is necessary.</para>
            <para>If SessionStateMode = SqlServer, the data is copied to a persistent object in memory and then the object is persisted, saved in the state database.</para>
            <para>If SessionStateMode = StateServer, the data is copied to a persistent object in memory and then the object is remoted to the state server, where it stays in memory.</para>
            <para>The fastest caching mode is using Memory storage type in session cache when your application is configured for SessionStateMode = InProc. In this case, saving and restoring data in cache is virtually immediate, because it does not involve copying any data, even in memory, it just stores a reference to an internal object. If you use SessionStateMode = StateServer or SqlServer with Memory storage type, C1WebDataObjects copies data in memory to make them persistent. This is also fast, but not immediate, depends on data size.</para>
            </remarks>
            <seealso cref="T:C1.Data.SchemaObjects.CacheProperties"/>
        </member>
        <member name="F:C1.Data.CacheStorageEnum.File">
            <summary>
            Cached data stored in files on the server.
            </summary>
        </member>
        <member name="F:C1.Data.CacheStorageEnum.Memory">
            <summary>
            Cached data stored in server memory. In InProc session state mode, it is always physical memory. 
            In SqlServer session state mode, the actual storage can be a database where the 
            memory-based data is persisted. In StateServer session state mode, it is still server memory, 
            but data ends up on a different server, the state server.
            </summary>
        </member>
        <member name="T:C1.Data.FilterCondition">
            <summary>
            Specifies a restriction on fetched rows when a table view is filled with data.
            </summary>
            <remarks>
            A filter condition specifies a restriction on fetched rows when a table view is filled with 
            data, see Fill. For table views based on bound and SQL-based tables, a filter condition has 
            SQL WHERE syntax with bracketed table view field names as variables (example: [CustomerID] = 'ALFKI'), 
            except for a custom filter condition (<see cref="P:C1.Data.FilterCondition.IsCustom"/> = True) which can be an arbitrary string for 
            use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event. For table views based on unbound tables, filter conditions are 
            arbitrary strings that can be used by <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event code implementing the fetch. 
            See <span style="Link Topic">Bound, SQL-Based and Unbound Tables</span> for details.
            </remarks>
        </member>
        <member name="M:C1.Data.FilterCondition.#ctor(C1.Data.SchemaObjects.TableView,System.String)">
            <summary>
            Initializes a new instance of the FilterCondition class.
            </summary>
            <param name="tableView">The table view to which the conditions belongs.</param>
            <param name="conditionText">The text of the condition</param>
        </member>
        <member name="M:C1.Data.FilterCondition.#ctor(C1.Data.SchemaObjects.TableView,System.String,System.Boolean)">
            <summary>
            Initializes a new instance of the FilterCondition class.
            </summary>
            <param name="tableView">The table view to which the conditions belongs.</param>
            <param name="conditionText">The text of the condition</param>
            <param name="isCustom">A value indicating whether the condition is custom. 
            If this parameter is set to True, the condition is ignored in SQL generation, 
            does not generate an SQL condition, can be used in the <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event.</param>
        </member>
        <member name="M:C1.Data.FilterCondition.#ctor(C1.Data.C1DataSet,System.String,System.String,System.Boolean)">
            <summary>
            Initializes a new instance of the FilterCondition class.
            </summary>
            <param name="dataSet">Data set to which the condition applies. This parameter can be null, 
            which means the data set will be determined later, when the filter condition is used in 
            <see cref="M:C1.Data.C1DataSet.Fill"/> call.</param>
            <param name="tableViewName">The name of the table view to which the conditions applies.</param>
            <param name="conditionText">The text of the condition.</param>
            <param name="isCustom">A value indicating whether the condition is custom. If this parameter 
            is set to True, the condition is ignored in SQL generation, does not generate an SQL condition, 
            can be used in the <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event.</param>
        </member>
        <member name="M:C1.Data.FilterCondition.#ctor(C1.Data.C1DataSet,System.String,System.String)">
            <summary>
            Initializes a new instance of the FilterCondition class.
            </summary>
            <param name="dataSet">Data set to which the condition applies. This parameter can be null, 
            which means the data set will be determined later, when the filter condition is used in 
            <see cref="M:C1.Data.C1DataSet.Fill"/> call.</param>
            <param name="tableViewName">The name of the table view to which the conditions applies.</param>
            <param name="conditionText">The text of the condition.</param>
        </member>
        <member name="M:C1.Data.FilterCondition.#ctor">
            <summary>
            Initializes a new instance of the FilterCondition class.
            </summary>
        </member>
        <member name="P:C1.Data.FilterCondition.TableView">
            <summary>
            Gets the table view (<see cref="T:C1.Data.SchemaObjects.TableView"/>) to which the filter condition belongs.
            </summary>
            <remarks>
            Each filter condition represents a restriction on one of the data set table views.
            </remarks>
        </member>
        <member name="P:C1.Data.FilterCondition.ConditionText">
            <summary>
            Gets or sets the text of the condition.
            </summary>
            <remarks>
            Filter conditions have SQL WHERE syntax with bracketed table view field names as variables 
            (example: [CustomerID] = 'ALFKI'), except for a custom filter condition (IsCustom = True), 
            which can be an arbitrary string for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> event.
            </remarks>
        </member>
        <member name="P:C1.Data.FilterCondition.IsCustom">
            <summary>
            Gets value indicating whether it is a custom condition.
            </summary>
            <remarks>
            A custom filter condition is an arbitrary string. Custom filter conditions are ignored 
            in SQL generation, do not generate SQL conditions. They are intended for use in <see cref="E:C1.Data.C1DataSet.BeforeFill"/> 
            in cases where it is needed to pass custom information to that event.
            </remarks>
        </member>
        <member name="P:C1.Data.FilterCondition.FillSort">
            <summary>
            Gets or sets the sort field or fields, and sort order for filling a table view with data.
            </summary>
            <remarks>
            By default, fetched data is sorted according to the <see cref="!:TableView.FillSort"/> property, 
            or by primary key if <see cref="!:TableView.FillSort"/> is empty. This default order can be 
            overridden at run time, when calling <see cref="M:C1.Data.C1DataSet.Fill"/> by specifying the required sort 
            order in one of the filter conditions passed to the <see cref="M:C1.Data.C1DataSet.Fill"/> method as a parameter. 
            Set this property to the sort field name(s). To specify sort order (ascending/descending), 
            add "ASC" (ascending) or "DESC" (descending) after the field name. If no order is specified, 
            the order is "ASC" (ascending). Multiple field names are separated with commas. 
            Example: "CustomerID DESC, OrderID".
            <para>Fill sort can be set for any filter condition filtering the given table view, or a special 
            filter condition can be created for this purpose (if there are no filtering conditions for 
            this table view), with <see cref="P:C1.Data.FilterCondition.IsCustom"/> = True and empty <see cref="P:C1.Data.FilterCondition.ConditionText"/>.</para>
            <para>Note that in virtual mode (<see cref="!:TableView.DataAccessMode"/> property set to a mode other than Static) 
            FillSort, both in filter conditions and in <see cref="P:C1.Data.FilterCondition.TableView"/> class, must form a unique key. 
            If it does not represent a unique key, a run time exception will occur when two different 
            row with equal key values are fetched in virtual mode. You can always ensure uniqueness 
            of a sort order by adding primary key fields in the end.</para>
            </remarks>
        </member>
        <member name="T:C1.Data.FilterConditions">
            <summary>
            Represents a collection of <see cref="T:C1.Data.FilterCondition"/> objects.
            </summary>
        </member>
        <member name="T:C1.Util.Xml.Serialization.IMemberTypeEncoder">
            <summary>
            This interface is used to allow objects and collection to serialize
            types of their members in a custom way.
            If a collection implements this interface, TypeToString is invoked during
            serialization of collection items, and for all items for which it returns a
            non-null string, that string is used as the element name of the item.
            If a class implements this interface, AND a member of that class has
            attribute TypeNameSerialization.Custom, AND does not have attribute
            XmlAttribute (i.e. is serialized as an element), TypeToString is invoked
            on the owner when that member is serialized, and if that returns a non-null
            string, that string is used as the value of TypeName attribute.
            When deserializing a collection which implements this interface,
            StringToType is invoked for each new item in the collection, and if that
            returns a non-null type, that type is used to create the item. Otherwise,
            TypeNameSerialization attribute is used.
            When deserializing a class which implements this interface, StringToType
            is invoked on that class for members with TypeNameSerialization.Custom
            attribute set.
            </summary>
        </member>
        <member name="M:C1.Util.Xml.Serialization.IMemberTypeEncoder.TypeToString(System.Object)">
            <summary>
            Returns a string representing the type of the object
            </summary>
        </member>
        <member name="M:C1.Util.Xml.Serialization.IMemberTypeEncoder.StringToType(System.String)">
            <summary>
            Returns the type restored from the serialized string
            </summary>
        </member>
        <member name="M:C1.Data.FilterConditions.Add(C1.Data.FilterCondition)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.FilterConditions.Insert(System.Int32,C1.Data.FilterCondition)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.FilterConditions.CopyTo(C1.Data.FilterCondition[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.FilterConditions.IndexOf(C1.Data.FilterCondition)">
            <summary>
            Returns the zero-based index of the filter condition object in the collection.
            </summary>
            <param name="obj">The Object to locate in the collection.</param>
            <returns>The zero-based index of the filter condition object, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.FilterConditions.Contains(C1.Data.FilterCondition)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="obj">The Object to locate in the collection.</param>
            <returns>True if the filter condition object is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.FilterConditions.Remove(C1.Data.FilterCondition)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="obj">The object to remove from the collection.</param>
        </member>
        <member name="P:C1.Data.FilterConditions.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
        </member>
        <member name="T:C1.Data.RemoteDataService">
            <summary>
            A RemoteDataService-derived class is included in every data library. It is used to support 
            automatic remoting in methods C1DataSet.Fill/Update. Calling C1DataSet.Fill/Update on the 
            client automatically calls RemoteDataService.Fill/Update on the server. 
            RemoteDataService.Fill/Update are virtual methods that can be overridden to customize 
            Fill/Update behavior. Also, new "business" methods can be added to the RemoteDataService-derived class, 
            see <span style="Link Topic">Business Methods</span>.
            </summary>
        </member>
        <member name="M:C1.Data.RemoteDataService.Fill(C1.Data.C1DataSet,C1.Data.FilterConditions,System.String[],C1.Data.SchemaObjects.ConnectionCollection,System.Boolean)">
            <summary>
            Called on the server when C1DataSet.Fill is called on the client.
            </summary>
            <param name="dataSet">Data set to be filled with data. This data set is initially empty. 
            After this data set is filled, its data is passed to the client to the data set for which 
            <see cref="M:C1.Data.C1DataSet.Fill"/> was called.</param>
            <param name="filterConditions">Filter conditions used in <see cref="M:C1.Data.C1DataSet.Fill"/> call.</param>
            <param name="tableViewNames"></param>
            <param name="dynamicConnections">Connection object substitutes defined in 
            <see cref="P:C1.Data.C1DataSet.DynamicConnections"/> property.</param>
            <param name="beginTransaction">This parameter is set to False by default. It means 
            C1DataObjects does not use transactions in fetching data. To make it perform fetch 
            in a transaction, override this method and set this parameter to True.</param>
        </member>
        <member name="M:C1.Data.RemoteDataService.Update(C1.Data.C1DataSet,C1.Data.SchemaObjects.ConnectionCollection,System.Boolean)">
            <summary>
            Called on the server when C1DataSet.Update is called on the client.
            </summary>
            <param name="dataSet">Data set containing simple table rows. Only rows with C1DataRow.RowState 
            equal to Added, Deleted or Modified need to be updated to the database. After database update, 
            simple table rows in this data set are passed back to the client to refresh the data set 
            for which C1DataSet.Update was called.</param>
            <param name="dynamicConnections">Connection object substitutes defined in 
            <see cref="P:C1.Data.C1DataSet.DynamicConnections"/> property.</param>
            <param name="beginTransaction">This parameter is set to True by default. It means 
            C1DataObjects performs <see cref="M:C1.Data.C1DataSet.Update"/> inside a database transaction. To make it perform Update 
            without using a database transaction, override this method and set this parameter to False. 
            This is needed to support distributed transactions, see Supporting distributed (COM+) transactions.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.ConnectionTypeEnum">
            <summary>
            Specifies the database engine software used to connect to the database.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ConnectionTypeEnum.Custom">
            <summary>
            A custom, generic ADO.NET data provider, see class C1CustomConnection.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ConnectionTypeEnum.OleDb">
            <summary>
            Connection using OLE DB database access classes in System.Data.OleDb namespace.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ConnectionTypeEnum.SqlServer">
            <summary>
            Connection using SQL Server native database access classes in System.Data.SqlClient namespace.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ConnectionTypeEnum.SqlServerCe">
            <summary>
            Connection using SQL Server Compact native database access classes in System.Data.SqlServerCe namespace.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ConnectionTypeEnum.Oracle">
            <summary>
            Connection using Oracle Data Provider for .NET, namespace Oracle.DataAccess.Client.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ConnectionTypeEnum.MSOracle">
            <summary>
            Connection using Microsoft .NET Framework Data Provider for Oracle, namespace System.Data.OracleClient.OracleType.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.Connection">
            <summary>
            Base class representing a database connection.
            </summary>
            <remarks>
            C1DataObjects supports five types of database connections: 
            OLE DB connection (connecting to any database that has an OLE DB provider), represented by a 
            derived <see cref="T:C1.Data.SchemaObjects.C1OleDbConnection"/> class, native SQL Server connection, represented by a derived 
            <see cref="T:C1.Data.SchemaObjects.C1SqlServerConnection"/> class, two native Oracle connection types (
            <see cref="T:C1.Data.SchemaObjects.C1OracleConnection"/> and <see cref="T:C1.Data.SchemaObjects.C1MSOracleConnection"/>), and any other .NET data provider 
            is represented by the <see cref="T:C1.Data.SchemaObjects.C1CustomConnection"/> class.
            </remarks>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
            <seealso><span style="Link Topic">Native and OLE DB Database Access</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.Clone">
            <summary>
            Creates a copy of the connection object, with the same Name and other properties.
            </summary>
            <returns>A new connection object that is a copy of this instance.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the Connection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.Open">
            <summary>
            Opens database connection.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.Close">
            <summary>
            Closes database connection.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.BeginTransaction">
            <summary>
            Starts a transaction on the connection object.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.CommitTransaction">
            <summary>
            Commits the current transaction.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Connection.RollbackTransaction">
            <summary>
            Rolls back the current transaction.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.Schema">
            <summary>
            Gets the schema to which the connection object belongs.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.Name">
            <summary>
            Gets or sets the name of the connection object.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.CommandTimeout">
            <summary>
            Gets or sets the wait time before terminating an attempt to execute a command and generating an error.
            </summary>
            <remarks>
            The default is 30 seconds.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.SqlInfo">
            <summary>
            Gets the <see cref="T:C1.Data.SchemaObjects.SqlDialectInfo"/> object containing information about SQL dialect supported by the connection.
            </summary>
            <remarks>
            Use the properties of this object to specify various options of SQL syntax relevant to C1DataObjects 
            that can vary between different databases. Normally, these properties are set automatically to their 
            appropriate values, according to the selected <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> or OLE DB provider (when you specify 
            the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionString"/>), but, occasionally, they may need manual adjustment, for example, when using 
            a third-party OLE DB provider or a custom .NET data provider.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.DbConnection">
            <summary>
            Gets .NET IDbConnection object representing open connection.
            </summary>
            <remarks>
            This property returns a non-null object only while the connection is open. Depending on the 
            <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> value, DbConnection returns an object of one of the following classes: 
            <para>    for OleDb: System.Data.OleDb.OleDbConnection,</para>
            <para>    for SqlServer: System.Data.SqlConnection,</para>
            <para>    for Oracle: Oracle.DataAccess.Client.OracleConnection,</para>
            <para>    for MSOracle: System.Data.OracleClient.OracleConnection,</para>
            <para>    for others (Custom): the type is specified in the ConnectionTypeName property.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.DbTransaction">
             <summary>
             Gets .NET IDbTransaction object representing current transaction.
             </summary>
             <remarks>
             This property contains a non-null object only while the database connection is open and is 
             performing a transaction while updating the database. Depending on the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> value, 
             DbTransaction returns an object of one of the following classes:
            <para>    for OleDb: System.Data.OleDb.OleDbTransaction,</para>
            <para>    for SqlServer: System.Data.SqlTransaction,</para>
            <para>    for Oracle: Oracle.DataAccess.Client.OracleTransaction,</para>
            <para>    for MSOracle: System.Data.OracleClient.OracleTransaction,</para>
            <para>    for others (Custom): type depends on the provider.</para>
             </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.ConnectionString">
            <summary>
            Gets or sets the string used to connect to a database.
            </summary>
            <remarks>
            Connection string includes provider name (only for OLE DB connections), data source name, database name, connection timeout, user ID, password and other required and optional parameters for establishing database connection. It contains all information necessary to open the database.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.ConnectionType">
            <summary>
            Gets the type of database connection, either via OLE DB or using one of the native database access options.
            </summary>
            <remarks>
            This property is overridden in each class derived from Connection, indicating the type of database connection the class represents. 
            </remarks>
            <seealso><span style = "Link Topic">Native and OLE DB Database Access</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Connection.Description">
            <summary>
            Gets or sets a description for the connection.
            </summary>
            <remarks>This value is displayed in the Schema Designer's Information window when you select the connection.</remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.ConnectionCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.Connection"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.IndexOf(System.String)">
            <summary>
            Returns the zero-based index of the connection with a given name in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Connection.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>The zero-based index of the connection with a given name, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.IndexOf(C1.Data.SchemaObjects.Connection)">
            <summary>
            Returns the zero-based index of the connection object in the collection.
            </summary>
            <param name="conn">The element of the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Connection.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>True if connection with a given name is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.Add(C1.Data.SchemaObjects.Connection)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.Insert(System.Int32,C1.Data.SchemaObjects.Connection)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.Remove(C1.Data.SchemaObjects.Connection)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="obj">The object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ConnectionCollection.CopyTo(C1.Data.SchemaObjects.Connection[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.ConnectionCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.ConnectionCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.C1OleDbConnection">
            <summary>
            Represents an OLE DB connection to a database, using OLE DB Data Provider for .NET, classes from namespace System.Data.OleDb.
            </summary>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
            <seealso><span style="Link Topic">Native and OLE DB Database Access</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1OleDbConnection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the C1OleDbConnection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1OleDbConnection.#ctor">
            <summary>
            Initializes a new instance of the C1OleDbConnection class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.C1OleDbConnection.ConnectionType">
            <summary>
            In this class this property returns <see cref="T:C1.Data.SchemaObjects.ConnectionTypeEnum"/>.OleDb.
            </summary>
            <remarks>
            See the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> Property.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.C1SqlServerConnection">
            <summary>
            Represents a connection to a database, using SQL Server Data Provider for .NET, classes from namespace System.Data.SqlClient.
            </summary>
            <seealso><span style = "Link Topic">Database Connections</span></seealso>
            <seealso><span style = "Link Topic">Native and OLE DB Database Access</span></seealso> 
        </member>
        <member name="M:C1.Data.SchemaObjects.C1SqlServerConnection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the C1SqlServerConnection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1SqlServerConnection.#ctor">
            <summary>
            Initializes a new instance of the C1SqlServerConnection class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.C1SqlServerConnection.ConnectionType">
            <summary>
            In this class this property returns <see cref="T:C1.Data.SchemaObjects.ConnectionTypeEnum"/>.SqlServer.
            </summary>
            <remarks>
            See the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> Property.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.C1SqlServerCeConnection">
            <summary>
            Represents a connection to a database, using Data Provider for Microsoft SQL Server Compact, classes from namespace System.Data.SqlServerCe.
            </summary>
            <seealso><span style = "Link Topic">Database Connections</span></seealso>
            <seealso><span style = "Link Topic">Native and OLE DB Database Access</span></seealso> 
        </member>
        <member name="M:C1.Data.SchemaObjects.C1SqlServerCeConnection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the C1SqlServerConnection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1SqlServerCeConnection.#ctor">
            <summary>
            Initializes a new instance of the C1SqlServerConnection class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.C1SqlServerCeConnection.ConnectionType">
            <summary>
            In this class this property returns <see cref="T:C1.Data.SchemaObjects.ConnectionTypeEnum"/>.SqlServerCe.
            </summary>
            <remarks>
            See the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> Property.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.C1OracleConnection">
            <summary>
            Represents a connection to a database, using Oracle Data Provider for .NET, classes from namespace Oracle.DataAccess.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1OracleConnection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the C1OracleConnection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1OracleConnection.#ctor">
            <summary>
            Initializes a new instance of the C1OracleConnection class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.C1OracleConnection.ConnectionType">
            <summary>
            In this class this property returns <see cref="T:C1.Data.SchemaObjects.ConnectionTypeEnum"/>.Oracle.
            </summary>
            <remarks>
            See the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> Property.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.C1MSOracleConnection">
            <summary>
            Represents a connection to a database, using Microsoft .NET Framework Data Provider for Oracle, classes from namespace System.Data.OracleClient.
            </summary>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
            <seealso><span style="Link Topic">Native and OLE DB Database Access</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1MSOracleConnection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the C1MSOracleConnection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1MSOracleConnection.#ctor">
            <summary>
            Initializes a new instance of the C1MSOracleConnection class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.C1MSOracleConnection.ConnectionType">
            <summary>
            In this class this property returns <see cref="T:C1.Data.SchemaObjects.ConnectionTypeEnum"/>.MSOracle.
            </summary>
            <remarks>
            See the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> Property.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.C1CustomConnection">
            <summary>
            Represents a connection to a generic ADO.NET data provider.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1CustomConnection.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the C1CustomConnection class.
            </summary>
            <param name="schema">Schema to which this connection object belongs.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.C1CustomConnection.#ctor">
            <summary>
            Initializes a new instance of the C1CustomConnection class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.C1CustomConnection.CustomProviderInfo">
            <summary>
            Gets the <see cref="P:C1.Data.SchemaObjects.C1CustomConnection.CustomProviderInfo"/> object containing information necessary to access a generic .NET data provider.
            </summary>
            <seealso cref="T:C1.Data.SchemaObjects.C1CustomConnection"/>
            <seealso><span style="Link Topic">Using Other (Custom) .NET Data Providers</span></seealso>
            <seealso><span style="Link Topic">Native and OLE DB Database Access</span></seealso>
            <seealso><span style="Link Topic">Database Connections</span></seealso> 
        </member>
        <member name="P:C1.Data.SchemaObjects.C1CustomConnection.ConnectionType">
            <summary>
            In this class this property returns <see cref="T:C1.Data.SchemaObjects.ConnectionTypeEnum"/>.Custom.
            </summary>
            <remarks>
            See the <see cref="P:C1.Data.SchemaObjects.Connection.ConnectionType"/> Property.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.CustomProviderInfo">
            <summary>
            Containing information necessary to access a generic .NET data provider.
            </summary>
            <seealso><span style="Link Topic">Using Other (Custom) .NET Data Providers</span></seealso>
            <seealso><span style="Link Topic">C1CustomConnection.CustomProviderInfo Property</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.AssemblyName">
            <summary>
            Gets or sets the name of the assembly implementing the .NET data provider.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.ConnectionTypeName">
            <summary>
            Gets or sets the full name of the type implementing the IDbConnection interface.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.CommandTypeName">
            <summary>
            Gets or sets the full name of the type implementing the IDbCommand interface.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.ParameterTypeName">
            <summary>
            Gets or sets the full name of the type implementing the IDbDataParameter interface.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.NativeTypeTypeName">
            <summary>
            Gets or sets the full type name of the native database type enumeration.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.DataAdapterTypeName">
            <summary>
            Gets or sets the full name of the type implementing the IDbDataAdapter interface.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.ParameterNativeTypeProperty">
            <summary>
            Gets or sets the name of the property of the parameter class specifying parameter native data type.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.SqlParameterNameFormat">
            <summary>
            Gets or sets a format string used to generate parameter names in SQL statements from parameter number {0} and name {1}.
            </summary>
            <remarks>
            Generating SQL statements, C1DataObjects uses this format string to generate parameter names in the SQL statement. For example, for a SQL Server database, the string can be "@{1}", which will generate parameters like this:
            <para>SELECT ... FROM ... WHERE ... = @aName</para>
            <para>SQL Server accepts named parameters, so we can use the suggested name (parameter name, {1}) in the SQL statement. Suggested name is usually based on a field name, but it is generally at C1DataObjects discretion. Another possible option for SQL Server can be "@Par{0}", which ignores the suggested name and uses the (unique) parameter number to generate parameter names in the SQL statement. For an Oracle database, a correct format string can be ":{1}" or ":Par{0}".</para>
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.CustomProviderInfo.ParameterNameFormat"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.CustomProviderInfo.ParameterNameFormat">
            <summary>
            Gets or sets a format string used to generate the value of parameter.ParameterName from parameter number {0} and name {1}.
            </summary>
            <remarks>
            Generating SQL statements and corresponding commands, C1DataObjects uses this format string to create names to assign to command parameter Name property (IDbDataParameter.Name). For example, for a SQL Server database, the string can be "@{1}" or "@Par{0}". The latter ignores the suggested name and uses the (unique) parameter number to generate the parameter Name property value. For an Oracle database, examples of a correct format string are "{1}" or "Par{0}".
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.CustomProviderInfo.SqlParameterNameFormat"/>
        </member>
        <member name="T:C1.Data.SchemaObjects.DataAccessModeEnum">
            <summary>
            Specifies how data is fetched from the database to a table view.
            </summary>
            <seealso><span style="Link Topic">Virtual Mode - Dealing with Large Datasets</span></seealso>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataAccessModeEnum.Static">
            <summary>
            All data is pre-fetched when the data set is filled with data. 
            No fetches occur until <see cref="M:C1.Data.C1DataSet.Fill"/> method is called.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataAccessModeEnum.Virtual">
            <summary>
            Data is fetched in segments of limited size, and the number of segments cached at the client at any given time is limited, segments are uncached when this limit is exceeded.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataAccessModeEnum.VirtualUnlimited">
            <summary>
            Data is fetched in segments, and the number of segments in the cache is unlimited, and, in addition to that, fetch is continually performed in background mode until all data is fetched.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataAccessModeEnum.VirtualAutomatic">
            <summary>
            Data is fetched in segments of limited size, and the number of segments in the cache is unlimited, segments are never uncached.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.Diagram">
            <summary>
            Base class for data set diagrams (<see cref="T:C1.Data.SchemaObjects.DataSetDef"/>) and composite table diagrams (<see cref="T:C1.Data.SchemaObjects.CompositeTableDef"/>).
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Diagram.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the Diagram class.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Diagram.#ctor">
            <summary>
            Initializes a new instance of the Diagram class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Diagram.Schema">
            <summary>
            Gets the schema the diagram belongs to.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Diagram.Name">
            <summary>
            Gets or sets the name of the diagram object.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Diagram.TableViews">
            <summary>
            Gets the collection of table views.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Diagram.ViewRelations">
            <summary>
            Gets the collection of view relations.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.DataSetDef">
            <summary>
            Represents a data set definition.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDef.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the DataSetDef class.
            </summary>
            <param name="schema">Schema the dataset belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDef.#ctor">
            <summary>
            Initializes a new instance of the DataSetDef class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.DataSetDef.CacheProperties">
            <summary>
            This property is used in ComponentOne WebDataObjects for data caching in web applications. It is ignored if the schema is used in WinForms application or in WebForms application without WebDataObjects.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.DataSetDef.FieldDefaults">
            <summary>
            Gets the <see cref="P:C1.Data.SchemaObjects.DataSetDef.FieldDefaults"/> object containing default settings used for fields accessed through this data set.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.DataSetDef.Description">
            <summary>
            Gets or sets a description for the dataset.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.CacheProperties">
            <summary>
            The CacheProperties class is used to specify global cache settings for a DataSetDef using the <see cref="P:C1.Data.SchemaObjects.DataSetDef.CacheProperties"/> property.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.PoolSize">
            <summary>
            Gets or sets the maximum number of data set objects that can be used simultaneously for fetching data by different threads on a server. PoolSize = 0 means object pool is disabled.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.PoolTimeout">
            <summary>
            Gets or sets the number of seconds to wait while all existing data set objects are busy serving other threads on the server and a new object cannot be created because there the PoolSize limit is already reached. PoolTimeout = 0 means wait indefinitely.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.CacheMode">
            <summary>
            Gets or sets a value indicating under what conditions caching is enabled.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.CacheStorage">
            <summary>
            Gets or sets the storage medium used to cache data.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.CacheCompressed">
            <summary>
            Gets or sets a value indicating whether the data in cache should be compressed.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.CacheStoragePath">
            <summary>
            Gets or sets the path for storing cache data files, if <see cref="P:C1.Data.SchemaObjects.CacheProperties.CacheStorage"/> = File.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.MaxCount">
            <summary>
            Gets or sets the maximum number of data sets that can be stored in the cache for this DataSetDef.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.ChangesCacheStorage">
            <summary>
            Gets or sets the storage medium used to cache changes made by the user.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.ChangesCacheCompressed">
            <summary>
            Gets or sets a value indicating whether the cached changes should be compressed.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CacheProperties.ChangesCacheStoragePath">
            <summary>
            Gets or sets the path for storing cached changes, if ChangesCacheMode = File.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.FieldDefaults">
            <summary>
            Contains various default settings used for fields accessed through a certain data set.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.FieldDefaults.#ctor">
            <summary>
            Initializes a new instance of the FieldDefaults class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.FieldDefaults.ConvertNullToEmpty">
            <summary>
            Gets or sets a value indicating whether DbNull values of string fields are returned as empty strings.
            </summary>
            <remarks>
            If <see cref="P:C1.Data.SchemaObjects.Field.ConvertNullToEmpty"/> is set to Default (default option for a field), 
            the value of this property, defined in <see cref="P:C1.Data.SchemaObjects.DataSetDef.FieldDefaults"/>, takes effect for the field.
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.FieldDefaults.ConvertEmptyToNull"/>
            <seealso cref="P:C1.Data.SchemaObjects.Field.ConvertNullToEmpty"/>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.FieldDefaults.ConvertEmptyToNull">
            <summary>
            Gets or sets a value indicating whether empty strings are stored as DbNull values.
            </summary>
            <remarks>
            If <see cref="P:C1.Data.SchemaObjects.Field.ConvertEmptyToNull"/> is set to Default (default option for a field), 
            the value of this property, defined in <see cref="P:C1.Data.SchemaObjects.DataSetDef.FieldDefaults"/>, takes effect for the field.
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.FieldDefaults.ConvertNullToEmpty"/>
            <seealso cref="P:C1.Data.SchemaObjects.Field.ConvertEmptyToNull"/>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.CompositeTableDef">
            <summary>
            Represents a composite table definition diagram.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeTableDef.CompositeTable">
            <summary>
            Gets the composite table the diagram belongs to.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeTableDef.TableViews">
            <summary>
            Gets the collection of table views.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeTableDef.ViewRelations">
            <summary>
            Gets the collection of view relations.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableViewCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.TableView"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.IndexOf(System.String)">
            <summary>
            Gets the index of the element with a given name in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.TableView.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.IndexOf(C1.Data.SchemaObjects.TableView)">
            <summary>
            Gets the index of an element in the collection.
            </summary>
            <param name="tableView">The element of the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.Add(C1.Data.SchemaObjects.TableView)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.Insert(System.Int32,C1.Data.SchemaObjects.TableView)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.Remove(C1.Data.SchemaObjects.TableView)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="obj">The object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.CopyTo(C1.Data.SchemaObjects.TableView[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.TableView.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>True if element is found in the collection; otherwise, False.</returns>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.TableView.Name"/> of the element. The search is not case-sensitive.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.ViewRelationCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.ViewRelation"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.IndexOf(System.String)">
            <summary>
            Returns the zero-based index of the relation with a given name in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.ViewRelation.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.IndexOf(C1.Data.SchemaObjects.ViewRelation)">
            <summary>
            Returns the zero-based index of an element in the collection.
            </summary>
            <param name="viewRelation">The relation object to locate in the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.Add(C1.Data.SchemaObjects.ViewRelation)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.Insert(System.Int32,C1.Data.SchemaObjects.ViewRelation)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.Remove(C1.Data.SchemaObjects.ViewRelation)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="obj">The object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.CopyTo(C1.Data.SchemaObjects.ViewRelation[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelationCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.ViewRelation.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>True if element with a given name is found in the collection; otherwise, False.</returns>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelationCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelationCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.ViewRelation.Name"/> of the element. The search is not case-sensitive.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableView">
            <summary>
            Objects of the TableView class represent nodes in a data set definition diagram.
            </summary>
            <remarks>
            Objects of the derived <see cref="T:C1.Data.SchemaObjects.CompositeDefView"/> class represent nodes in a composite table definition 
            diagrams. For both kinds of table views, every table view object is based on a table object.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.BaseTable">
            <summary>
            Base class for all tables and table views.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.ReadOnly">
            <summary>
            Gets or sets a value indicating whether modifying table data is allowed.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.EffectiveReadOnly">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.BaseTable.ReadOnly"/> property at run time.
            </summary>
            <remarks>
            Although a table view's <see cref="P:C1.Data.SchemaObjects.BaseTable.ReadOnly"/> property may be False, it will behave as if 
            it is True if it is based on a table with <see cref="P:C1.Data.SchemaObjects.BaseTable.ReadOnly"/> = True.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.UserReadOnly">
            <summary>
            Gets or sets a value indicating whether modifying table data in bound controls is allowed.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.EffectiveUserReadOnly">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.BaseTable.UserReadOnly"/> property at run time.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.AllowAddNew">
            <summary>
            Gets or sets a value indicating whether adding new rows to the table is allowed.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.EffectiveAllowAddNew">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.BaseTable.AllowAddNew"/> property at run time.
            </summary>
            <remarks>
            Although a table view's <see cref="P:C1.Data.SchemaObjects.BaseTable.AllowAddNew"/> property may be True, it will behave as if it 
            is False if it is based on a table with <see cref="P:C1.Data.SchemaObjects.BaseTable.AllowAddNew"/> = False.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.AllowDelete">
            <summary>
            Gets or sets a value indicating whether deleting rows from the table is allowed.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.EffectiveAllowDelete">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.BaseTable.AllowDelete"/> property at run time.
            </summary>
            <remarks>
            Although a table view's <see cref="P:C1.Data.SchemaObjects.BaseTable.AllowDelete"/> property may be True, 
            it will behave as if it is False if it is based on a table with <see cref="P:C1.Data.SchemaObjects.BaseTable.AllowDelete"/> = False.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.ConstraintsRecordLevel">
            <summary>
            Gets the collection of record level constraints.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.ConstraintsFieldLevel">
            <summary>
            Gets the collection of field level constraints.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.PrimaryKey">
            <summary>
            Gets the name(s) of the table primary key field(s).
            </summary>
            <remarks>
            This property returns a comma-delimited string consisting of the names of one 
            or more fields whose <see cref="P:C1.Data.SchemaObjects.Field.PrimaryKey"/> property is set to True.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.Name">
            <summary>
            Gets or sets the table name.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.RowType">
            <summary>
            Gets or sets a class representing rows of this table or view. 
            </summary>
            <remarks>
            This property allows you to define a custom class representing rows of a table or table view. 
            By default, row objects are represented by the C1DataRow class. To define a custom class, 
            do the following:
            <para>1.   In the data library dll, define a class derived from C1DataRow.</para>
            <para>2.   In the C1SchemaDef.CreateSchema event, assign this class to Table.RowType or 
            TableView.RowType property.</para>
            <para>If the RowType property is set for a table, simple or composite (DbTable or CompositeTable), 
            all TableView objects based on this table will automatically use the same class, 
            unless their RowType property is set explicitly, in which case TableView.RowType overrides 
            the table setting.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.BaseTable.Description">
            <summary>
            Gets or sets a description for the table.
            </summary>
            <remarks>
            This value is displayed in the Schema Designer's Information window when you select the table or table view.
            </remarks>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableView.#ctor(C1.Data.SchemaObjects.Diagram,C1.Data.SchemaObjects.Table,C1.Data.C1DataRow)">
            <summary>
            Initializes a new instance of the TableView class.
            </summary>
            <param name="diagram">Diagram the table view belongs to.</param>
            <param name="table">Table the table view is based on.</param>
            <param name="userObjPrototype">Custom row's prototype.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableView.#ctor(C1.Data.SchemaObjects.Diagram,C1.Data.SchemaObjects.Table)">
            <summary>
            Initializes a new instance of the TableView class.
            </summary>
            <param name="diagram">Diagram the table view belongs to.</param>
            <param name="table">Table the table view is based on.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableView.#ctor">
            <summary>
            Initializes a new instance of the TableView class.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableView.RetrieveFields">
            <summary>
            Retrieves table view fields from table specified in the Table property.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.Diagram">
            <summary>
            Gets the diagram this table view belongs to.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.Table">
            <summary>
            Gets the table this table view is based on.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.Name">
            <summary>
            Gets or sets the name of the table view.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.FillSort">
            <summary>
            Gets or sets the sort field or fields, and sort order for filling the table view with data.
            </summary>
            <remarks>
            This property controls the order in which data rows are sorted after fetch. By default, fetched data is sorted by primary key. If a different sort is required, set this property to the sort field name(s). To specify sort order (ascending/descending), add "ASC" (ascending) or "DESC" (descending) after the field name. If no order is specified, the order is "ASC" (ascending). Multiple field names are separated with commas. 
            <para>Example: "CustomerID DESC, OrderID".</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.FillIgnore">
            <summary>
            Gets or sets a value indicating whether this table view is skipped when the data set is filled with data.
            </summary>
            <remarks>
            The default value is False. If this property is set to True, this table view data is not fetched from the database when the data set is filled with data.
            </remarks>
            <seealso cref="M:C1.Data.C1DataSet.Fill"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.AutoEndAddNew">
            <summary>
            Gets or sets a value indicating whether <see cref="M:C1.Data.C1DataRow.EndEdit"/> must be called automatically for 
            newly added rows once their primary key is defined.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.Fields">
            <summary>
            Gets the field collection of the table view.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.DataAccessMode">
            <summary>
            Gets or sets a value specifying how data is fetched from the database to the table view.
            </summary>
            <remarks>
            The default value is Static. The other three possible values specify a virtual fetch mode, 
            where data is fetched in chunks (segments) allowing to work with large datasets.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.VirtualSegmentCount">
            <summary>
            Gets or sets the maximum number of segments in the cache in virtual mode.
            </summary>
            <remarks>
            This property has effect only when <see cref="P:C1.Data.SchemaObjects.TableView.DataAccessMode"/> is set to Virtual. It is a performance 
            tuning property. Do not change the default value unless you thoroughly understand 
            the mechanics of virtual mode. The default value is 4.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.VirtualSegmentSize">
            <summary>
            Gets or sets the size (number of rows) of a segment of rows fetched from the database in virtual mode.
            </summary>
            <remarks>
            This property has effect only in virtual mode (when <see cref="P:C1.Data.SchemaObjects.TableView.DataAccessMode"/> is not Static). 
            It is a performance tuning property. Do not change the default value unless you 
            thoroughly understand the mechanics of virtual mode. The default value is 400.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.VirtualAsyncThreshold">
            <summary>
            Gets or sets a percent value from 0 to 100 determining (in virtual mode) the distance 
            to the end of a segment that is considered a 'preemptive fetch zone'.
            </summary>
            <remarks>
            This property has effect only in virtual mode (when <see cref="P:C1.Data.SchemaObjects.TableView.DataAccessMode"/> is not Static). 
            It is a performance tuning property. Do not change the default value unless you 
            thoroughly understand the mechanics of virtual mode. The default value is 30%.
            <para>This property determines the distance (number of rows) to the end of a 
            segment that is considered a 'preemptive fetch zone', in the sense that a new  
            segment must be fetched from the database (if not found in the cache) when the 
            user positions on a row inside that zone. By default, it is 30% of 400 = 120 rows.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.VirtualSyncThreshold">
            <summary>
            Gets or sets a percent value from 0 to 100 determining (in virtual mode) the distance to 
            the end of a segment that is considered a 'mandatory fetch zone'.
            </summary>
            <remarks>
            This property has effect only in virtual mode (when <see cref="P:C1.Data.SchemaObjects.TableView.DataAccessMode"/> is not Static). 
            It is a performance tuning property. Do not change the default value unless you 
            thoroughly understand the mechanics of virtual mode. The default value is 12%.
            <para>This property determines the distance (number of rows) to the end of a segment 
            that is considered a 'danger zone', or a 'mandatory fetch zone', in the sense that the 
            current segment must be changed to another segment (taken from the cache or fetched from the database) 
            when the user positions on a row inside that zone. By default, it is 12% of 400 = 48 rows.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.VirtualConsolidateRows">
            <summary>
            Gets or sets a value indicating (in VirtualAutomatic mode) whether the table view 
            rebuilds its rowset after all rows are fetched.
            </summary>
            <remarks>
            This property has effect only in virtual automatic mode (when <see cref="P:C1.Data.SchemaObjects.TableView.DataAccessMode"/> = VirtualAutomatic).
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.MemoryResident">
            <summary>
            This property is used in ComponentOne WebData for data caching in web applications. It is ignored if the schema is used in WinForms application or in WebForms application without WebDataObjects.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.ExposedInBinding">
            <summary>
            Gets or sets a value indicating whether table view is used for data binding (shown in the DataMember property of bound controls).
            </summary>
            <remarks>
            The default value of this property is True.
            <para>If this property is set to False, the table view will be available only programmatically 
            (through the C1DataSet.TableViews[] collection), but data binding will not see it. A data bound 
            control, such as a grid, has only table views with ExposedInBinding=True available for selection 
            in its DataMember property for data binding.</para>
            <para>Use this property to hide table views that you only need programmatically and do not need 
            to appear in bound controls for the end user.</para>
            <para>This property shows/hides individual <see cref="T:C1.Data.SchemaObjects.TableView"/> objects in data binding. If you need to 
            show/hide a whole path of TableView objects, use the <see cref="P:C1.Data.SchemaObjects.ViewRelation.ExposedInBinding"/> property.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableView.FetchIndex">
            <summary>
            Gets or sets fetch order of the table view.
            </summary>
            <remarks>
            This property allows you to change the order in which table views in the dataset are fetched. 
            Controlling fetch order can be necessary, for example, if you have both bound and unbound 
            or SQL-based tables in one dataset.
            <para>You can set TableView.FetchIndex at design time in the Schema Designer or programmatically 
            at run time, in the <see cref="E:C1.Data.C1SchemaDef.CreateSchema"/> event. </para>
            <para>Possible values: from 0 up to the number of table views in the dataset.</para>
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.CompositeDefView">
            <summary>
            Represents a node in a composite table definition diagram. 
            </summary>
            <remarks>It is a table view, based on a table object, one of constituent tables.
            </remarks>
            <seealso><span style="Link Topic">Composite Table Diagram</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeDefView.#ctor(C1.Data.SchemaObjects.Diagram,C1.Data.SchemaObjects.Table,C1.Data.C1DataRow)">
            <summary>
            Initializes a new instance of the CompositeDefView class.
            </summary>
            <param name="diagram">Diagram the table view belongs to.</param>
            <param name="table">Table the table view is based on.</param>
            <param name="userObjPrototype">Custom row's prototype.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeDefView.#ctor(C1.Data.SchemaObjects.Diagram,C1.Data.SchemaObjects.Table)">
            <summary>
            Initializes a new instance of the CompositeDefView class.
            </summary>
            <param name="diagram">Diagram the table view belongs to.</param>
            <param name="table">Table the table view is based on.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeDefView.#ctor">
            <summary>
            Initializes a new instance of the CompositeDefView class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeDefView.Alias">
            <summary>
            Gets or sets the alias used for this table view in the SQL statement generated for fetching rows into the composite table.
            </summary>
            <remarks>
            The default value is empty string.
            <para>Generated SQL statement must use aliases for constituent simple tables, because a table 
            can occur more than once in a composite table diagram, so its name may be not unique in the 
            statement, in which case it needs aliasing. By default, view table names are used as aliases, 
            but if you want to change the default alias, you can set it.</para>
            <para>This is rarely needed, this property is supported only for completeness, since all other 
            names in the generated SQL statement can be controlled by developers using <see cref="P:C1.Data.SchemaObjects.DbTable.DbTableName"/> 
            and <see cref="P:C1.Data.SchemaObjects.DbTableField.DbFieldName"/>.</para>
            </remarks>
            <seealso><span style="Link Topic">How Composite Table Data is Fetched, Stored and Updated</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.ViewRelation">
            <summary>
            Represents a view relation, an arc in a <see cref="P:C1.Data.SchemaObjects.ViewRelation.Diagram"/>.
            </summary>
            <remarks>
             A view relation between two table views is 
            always based on a Relation between two tables.
            </remarks>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelation.#ctor(C1.Data.SchemaObjects.Diagram,C1.Data.SchemaObjects.Relation)">
            <summary>
            Initializes a new instance of the ViewRelation class.
            </summary>
            <param name="diagram">Diagram to which this view relation belongs.</param>
            <param name="relation">Relation between tables on which this view relation is based.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.ViewRelation.#ctor">
            <summary>
            Initializes a new instance of the ViewRelation class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Diagram">
            <summary>
            Gets the diagram this view relation belongs to.
            </summary>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Relation">
            <summary>
            Gets or sets the relation between tables this view relation is based on.
            </summary>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Name">
            <summary>
            Gets or sets the name of the view relation.
            </summary>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Parent">
            <summary>
            Gets or sets the parent table view.
            </summary>
            <remarks>
            If the view relation is inverted with respect to the table relation on which it is based, 
            the view relation's <see cref="P:C1.Data.SchemaObjects.ViewRelation.Child"/> is based on the table relation's <see cref="!:Relation.Parent"/>, and the 
            view relation's <see cref="P:C1.Data.SchemaObjects.ViewRelation.Parent"/> is based on the table relation's <see cref="!:Relation.Child"/>.
            </remarks>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Child">
            <summary>
            Gets or sets the child table view.
            </summary>
            <remarks>
            If the view relation is inverted with respect to the table relation on which it is based, 
            the view relation's <see cref="P:C1.Data.SchemaObjects.ViewRelation.Child"/> is based on the table relation's <see cref="!:Relation.Parent"/>, and the 
            view relation's <see cref="P:C1.Data.SchemaObjects.ViewRelation.Parent"/> is based on the table relation's <see cref="!:Relation.Child"/>.
            </remarks>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Cardinality">
            <summary>
            Gets view relation cardinality, which is determined by the relation cardinality with possible inversion.
            </summary>
            <remarks>
            A view relation, as an arc in the data set diagram, can have direction opposite to the 
            direction of the table relation on which it is based. For example, having a one-to-many 
            relation Customers - Orders, we can create a many-to-one view relation Orders - Customers, 
            based on Customers - Orders, but in inverse order (direction). So, if the <see cref="P:C1.Data.SchemaObjects.ViewRelation.Relation"/> 
            object Customers - Orders has <see cref="P:C1.Data.SchemaObjects.ViewRelation.Parent"/> = Customers, <see cref="P:C1.Data.SchemaObjects.ViewRelation.Child"/> = Orders, the view relation, 
            if inverted, will have <see cref="P:C1.Data.SchemaObjects.ViewRelation.Parent"/> = Orders, <see cref="P:C1.Data.SchemaObjects.ViewRelation.Child"/> = Customers.
            </remarks>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.GetRowsEvent">
            <summary>
            Gets or sets a value indicating whether relation is specified in code in 
            <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/> and <see cref="E:C1.Data.C1DataSetLogic.GetParentRow"/> 
            events (and not based on a <see cref="P:C1.Data.SchemaObjects.ViewRelation.Relation"/> between tables).
            </summary>
            <remarks>
            If this property is set to True, the view relation is not based on a table relation 
            (its <see cref="P:C1.Data.SchemaObjects.ViewRelation.Relation"/> property is ignored), it is defined by custom code returning 
            the list of child rows for a parent row in <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/> event 
            (in C1DataExpress, C1ExpressConnection.GetChildRows).
            <para>Only view relations (only relations between table views, not relations between tables) 
            can be custom (have this property set to True). Furthermore, custom relations are allowed 
            only in data set diagrams, not in composite table diagrams. You can define custom relations 
            between table views based on composite tables, but cannot use custom relation inside a 
            composite table diagram.</para>
            <para>Related topic: <see cref="P:C1.Data.SchemaObjects.ViewRelation.OneWay"/></para>
            </remarks>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.OneWay">
            <summary>
            For a relation specified in code in GetChildRows event, indicates whether GetParentRow is not available.
            </summary>
            <remarks>
            This property has effect only for custom relations, those defined in code, 
            with <see cref="P:C1.Data.SchemaObjects.ViewRelation.GetRowsEvent"/>=True. If this property is set to True, code in <see cref="E:C1.Data.C1DataSetLogic.GetParentRow"/> 
            event can be omitted, calling <see cref="E:C1.Data.C1DataSetLogic.GetParentRow"/> for this relation will throw exception. 
            Set this property to True if it is difficult or simply unnecessary to reverse your 
            algorithm enumerating child rows. Note that only <see cref="E:C1.Data.C1DataSetLogic.GetChildRows"/> is used for master-detail 
            data binding, <see cref="E:C1.Data.C1DataSetLogic.GetParentRow"/> is not necessary.
            <para>In C1DataExpress, OneWay is always True for custom relations.</para>
            </remarks>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.ExposedInBinding">
            <summary>
            Gets or sets a value indicating whether relation is used for data binding (shown in the DataMember property of bound controls).
            </summary>
            <remarks>
            Default: True.
            <para>If this property is set to False, the relation will be available only programmatically 
            (through the <see cref="M:C1.Data.C1DataRow.GetChildRows(System.String)"/> method and typed business logic methods), but data binding will not see it. 
            A data bound control, such as a grid, has only relations with ExposedInBinding=True available 
            for selection in its DataMember property for data binding.</para>
            <para>Use this property to hide relations that you only need programmatically, do not need to 
            appear in bound controls for the end user.</para>
            <para>In C1DataExpress, the value of the ExposedInBinding property is determined by the 
            Master-detail check box in the Relations editor. If the check box is unchecked, ExposedInBinding=False. </para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.ViewRelation.Description">
            <summary>
            Gets or sets a description for the view relation.
            </summary>
            <remarks>
            This value is displayed in the Schema Designer's Information window when you select the relation.
            </remarks>   
        </member>
        <member name="T:C1.Data.SchemaObjects.CompositeDefRelation">
            <summary>
            Represents an arc in a composite table definition diagram. 
            </summary>
            <remarks>
            It is a view relation, based on a table relation between two constituent tables.
            </remarks>
            <seealso><span style="Link Topic">Composite Table Diagram</span></seealso>
            <seealso><span style="Link Topic">View Relations</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeDefRelation.#ctor(C1.Data.SchemaObjects.Diagram,C1.Data.SchemaObjects.Relation)">
            <summary>
            Initializes a new instance of the CompositeDefRelation class.
            </summary>
            <param name="diagram">Diagram to which this view relation belongs.</param>
            <param name="relation">Relation between tables on which this view relation is based.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeDefRelation.#ctor">
            <summary>
            Initializes a new instance of the CompositeDefRelation class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeDefRelation.OuterJoinInManyToOne">
            <summary>
            Gets or sets a value indicating whether to use outer join in generated SQL , if <see cref="P:C1.Data.SchemaObjects.Relation.Cardinality"/> = ManyToOne.
            </summary>
            <remarks>
            This property has effect only for many-to-one relations (<see cref="P:C1.Data.SchemaObjects.Relation.Cardinality"/> = ManyToOne).
            <para>The default value is True. This means that a many-to-one relation in a composite table 
            diagram generates outer joins in the SQL statement. This ensures the standard interpretation 
            of many-to-one links, where the child table contains one row corresponding to the parent row, 
            or none. If there are no corresponding row, the child fields receive null values. However, 
            some databases do not implement outer joins, or implement them inadequately, with various 
            limitations (as, for example, MS Access). In this case, and when outer joins are undesirable 
            for other reasons, you can set this property to False. Then C1DataObjects will use inner join 
            for this view relation in the composite table diagram.</para>
            </remarks>
            <seealso><span style="Link Topic">How Composite Table Data is Fetched, Stored and Updated</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableViewFieldCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.TableViewField"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.IndexOf(System.String)">
            <summary>
            Returns the zero-based index of the field with a given name in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Field.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.IndexOf(C1.Data.SchemaObjects.TableViewField)">
            <summary>
            Returns the zero-based index of a field in the collection.
            </summary>
            <param name="tableViewField">The field object to locate in the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Field.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>True if field with a given name is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.Add(C1.Data.SchemaObjects.TableViewField)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.CopyTo(C1.Data.SchemaObjects.TableViewField[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.Insert(System.Int32,C1.Data.SchemaObjects.TableViewField)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewFieldCollection.Remove(C1.Data.SchemaObjects.TableViewField)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="obj">The object to remove from the collection.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewFieldCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewFieldCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Field.Name"/> of the element. The search is not case-sensitive.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewFieldCollection.TableView">
            <summary>
            Gets the table view to which the collection belongs.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.DataModeEnum">
            <summary>
            Specifies how a table is related to the database.
            </summary>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataModeEnum.Bound">
            <summary>
            Table is based on a database table, SQL statements generated automatically.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataModeEnum.SqlBased">
            <summary>
            SQL statements specified in user code.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.DataModeEnum.Unbound">
            <summary>
            Fetch and update performed entirely in user code.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableUpdateLocateModeEnum">
            <summary>
            Specifies which field values participate in locating the database record for update.
            </summary>
            <seealso><span style="Link Topic">Generated SQL Statements</span></seealso>
        </member>
        <member name="F:C1.Data.SchemaObjects.TableUpdateLocateModeEnum.AllFields">
            <summary>
            All field values in the database record must match the original row values.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.TableUpdateLocateModeEnum.PrimaryKey">
            <summary>
            Primary key field values in the database record must match the original row values.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.TableUpdateLocateModeEnum.PrimaryKeyAndChangedFields">
            <summary>
            Primary key field values and those field values that have changed from their original values must match the original row values.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableUpdateRefreshModeEnum">
            <summary>
            Specifies how refresh after update is done.
            </summary>
            <seealso><span style="Link Topic">Changing Data as a Result of Update (Refresh)</span></seealso>
        </member>
        <member name="F:C1.Data.SchemaObjects.TableUpdateRefreshModeEnum.Always">
            <summary>
            Always retrieve the resulting database record after adding or modifying record in the database.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.TableUpdateRefreshModeEnum.Never">
            <summary>
            Do not retrieve the resulting database record after adding or modifying record in the database.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.TableUpdateRefreshModeEnum.IfPossible">
            <summary>
            Try to retrieve the resulting database record after adding or modifying record in the database, but ignore errors if they occur.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.Table">
            <summary>
            Base class for simple and composite tables.
            </summary>
            <seealso><span style="Link Topic">Simple Tables</span></seealso>
            <seealso><span style="Link Topic">Composite Tables</span></seealso> 
        </member>
        <member name="P:C1.Data.SchemaObjects.Table.Schema">
            <summary>
            Gets the schema to which the table belongs.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Table.Fields">
            <summary>
            Gets the collection of table fields.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>         
        </member>
        <member name="P:C1.Data.SchemaObjects.Table.UpdateLocateMode">
            <summary>
            Gets or sets a value specifying which field values participate in locating the database record for update.
            </summary>
            <seealso><span style="Link Topic">Generated SQL Statements</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Table.UpdateRefreshMode">
            <summary>
            Gets or sets a value specifying how refresh after updating the database is done.
            </summary>
            <seealso><span style="Link Topic">Generated SQL Statements</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Table.IgnoreDeleteError">
            <summary>
            Gets or sets a value indicating whether the absence of a record to delete in the database is interpreted as an error.
            </summary>
            <seealso><span style="Link Topic">Generated SQL Statements</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableFieldCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.TableField"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.IndexOf(System.String)">
            <summary>
            Returns the zero-based index of the field with a given name in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Field.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.IndexOf(C1.Data.SchemaObjects.TableField)">
            <summary>
            Returns the zero-based index of a field in the collection.
            </summary>
            <param name="field">The field object to locate in the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Field.Name"/> of the element. The search is not case-sensitive.</param>
            <returns>True if field with a given name is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.Add(C1.Data.SchemaObjects.TableField)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.CopyTo(C1.Data.SchemaObjects.TableField[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.Insert(System.Int32,C1.Data.SchemaObjects.TableField)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="field">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableFieldCollection.Remove(C1.Data.SchemaObjects.TableField)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="obj">The object to remove from the collection.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableFieldCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableFieldCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Field.Name"/> of the element. The search is not case-sensitive.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableFieldCollection.Table">
            <summary>
            Gets the table to which the field collection belongs.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.SimpleTable">
            <summary>
            Base class for simple tables.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.DbTable">
             <summary>
             Represents a simple table.
             </summary>
            <seealso><span style="Link Topic">Simple Tables</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.DbTable.#ctor(C1.Data.SchemaObjects.Schema,C1.Data.C1DataRow)">
            <summary>
            Initializes a new instance of the DbTable class.
            </summary>
            <param name="schema">Schema the table belongs to.</param>
            <param name="userObjPrototype">Custom class representing rows of a table or table view.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DbTable.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the DbTable class.
            </summary>
            <param name="schema">Schema the table belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DbTable.#ctor">
            <summary>
            Initializes a new instance of the DbTable class.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.DbTable.RetrieveFields">
            <summary>
            Retrieves fields from the database table specified in <see cref="P:C1.Data.SchemaObjects.DbTable.DbTableName"/> property.
            </summary>
            <remarks>
            <see cref="P:C1.Data.SchemaObjects.DbTable.Connection"/> property should be non-empty.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTable.Connection">
            <summary>
            Gets or sets the <see cref="T:C1.Data.SchemaObjects.Connection"/> object used for the table.
            </summary>
            <remarks>
            This property is null for an unbound table.
            </remarks>
            <seealso><span style="Link Topic">Table Properties</span></seealso>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
            <seealso cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTable.DbTableName">
            <summary>
            Gets or sets the name of a database table on which the table is based.
            </summary>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTable.DataMode">
            <summary>
            Gets or sets the table data mode.
            </summary>
            <remarks>
            Data mode is one of the <see cref="T:C1.Data.SchemaObjects.DataModeEnum"/> values specifying whether a table is bound, SQL-based or unbound.
            </remarks>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTable.SelectCommandText">
            <summary>
            Gets or sets the command text for fetching data used in <see cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/> = SqlBased.
            </summary>
            <remarks>
            Property <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandType"/> determines whether SelectCommandText is a 
            SQL statement or a stored procedure name.
            <para>If specified, <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandType"/>/SelectCommandText determine the command that is 
            executed to fetch data.</para>
            <para>The command can also be specified dynamically, in code, in <see cref="E:C1.Data.C1DataSetLogic.BeforeGenerateSql"/> or 
            <see cref="E:C1.Data.C1DataSetLogic.AfterGenerateSql"/> events.</para>
            <para>If <see cref="P:C1.Data.C1TableLogic.DataAdapter"/> property is set and its SelectCommand property is not empty, 
            it supersedes the SelectCommandText property.</para>
            <para>The SelectCommandText property can be specified in a <see cref="T:C1.Data.SchemaObjects.DbTable"/> only for a SQL-based table (<see cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/> = SqlBased).</para>
            <para>In C1DataExpress, in a C1ExpressTable component, specifying this property makes the table 
            SQL-based and clears the DbTableName property.</para>
            <para>When this property is set at design time, and a database connection exists, fields are 
            automatically retrieved from the database structure, with user confirmation if it is OK to 
            delete the existing fields.</para>
            </remarks>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTable.SelectCommandType">
            <summary>
            Determines how to interpret <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandText"/> in <see cref="P:C1.Data.SchemaObjects.DbTable.DataMode"/> = SqlBased.
            </summary>
            <remarks>
            This property determines whether <see cref="P:C1.Data.SchemaObjects.DbTable.SelectCommandText"/> is a SQL statement or a stored procedure name.
            </remarks>
            <seealso><span style="Link Topic">C1ExpressTable Class</span></seealso>
            <seealso><span style="Link Topic">Bound, SQL-Based and Unbound Tables</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.CompositeTable">
            <summary>
            Represents a composite table.
            </summary>
            <seealso><span style="Link Topic">Composite Tables</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeTable.#ctor(C1.Data.SchemaObjects.Schema,C1.Data.C1DataRow)">
            <summary>
            Initializes a new instance of the CompositeTable class.
            </summary>
            <param name="schema">Schema the table belongs to.</param>
            <param name="userObjPrototype">Custom class representing rows of a table or table view.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeTable.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the CompositeTable class.
            </summary>
            <param name="schema">Schema the table belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeTable.#ctor">
            <summary>
            Initializes a new instance of the CompositeTable class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeTable.CompositeTableDef">
            <summary>
            Gets the composite table definition diagram.
            </summary>
            <seealso><span style="Link Topic">Composite Table Diagram</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeTable.AllowMultipleConnections">
            <summary>
            Gets or sets a value indicating whether constituent tables are allowed to use different connections.
            </summary>
            <seealso><span style="Link Topic">How Composite Table Data is Fetched, Stored and Updated</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.FieldUpdateSetModeEnum">
            <summary>
            Specifies whether field value is set in the database.
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.DbTableField.UpdateSet"/>
        </member>
        <member name="F:C1.Data.SchemaObjects.FieldUpdateSetModeEnum.Always">
            <summary>
            Value is always assigned to the database field.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.FieldUpdateSetModeEnum.Never">
            <summary>
            Value is never assigned to the database field.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.FieldUpdateSetModeEnum.IfChanged">
            <summary>
            Value is assigned to the database field if the value has been changed since it was fetched from the database.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.AutoIncrementEnum">
            <summary>
            Specifies automatic assignment of field values on adding rows to a table and to the database.
            </summary>
            <seealso cref="!:TableField.Autoincrement"/>
        </member>
        <member name="F:C1.Data.SchemaObjects.AutoIncrementEnum.None">
            <summary>
            No autoincrement functionality.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.AutoIncrementEnum.Client">
            <summary>
            The field automatically receives incremented value in a new row added to the table on the client.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.AutoIncrementEnum.Server">
            <summary>
            The field automatically receives incremented value in a new row added to the database table on the server. 
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.AutoIncrementEnum.ClientAndServer">
            <summary>
            The field automatically receives incremented value in a new row both in a new row 
            added on the client and in a new row added to the database table on the server. 
            These two values can be different. After adding the row to the database table on the server, 
            the client value is refreshed with the value from the database table.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.YesNoDefaultEnum">
            <summary>
            An enumeration used in property values instead of the Boolean type where there is a default option 
            (depending on the context) in addition to Yes (True) and No (False).
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.YesNoDefaultEnum.Yes">
            <summary>
            Property value is True.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.YesNoDefaultEnum.No">
            <summary>
            Property value is False.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.YesNoDefaultEnum.Default">
            <summary>
            This can be Yes or No depending on other properties of the object. Where Default is used, 
            the value of the property is determined by some rules documented with the property.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.Field">
            <summary>
            The base class for <see cref="T:C1.Data.SchemaObjects.TableField"/> and <see cref="T:C1.Data.SchemaObjects.TableViewField"/>. 
            Contains common field properties.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Name">
            <summary>
            Gets or sets the name of the field.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Type">
            <summary>
            Gets or sets the type of field data. 
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.NativeDbType">
            <summary>
            Gets or sets the field data type as a native data type of the underlying database. 
            </summary>
            <remarks>
            NativeDbType contains the numeric value corresponding to one of the values of the enumerated 
            type describing all possible data types for the database access provider. These enumerations are:
            <para>for OleDb: System.Data.OleDb.OleDbType,</para>
            <para>for SqlServer: System.Data.SqlDbType,</para>
            <para>for Oracle: Oracle.DataAccess.Client.OracleDbType,</para>
            <para>for MSOracle: System.Data.OracleClient.OracleType,</para>
            <para>for others (Custom): enumeration type is specified in the <see cref="P:C1.Data.SchemaObjects.CustomProviderInfo.NativeTypeTypeName"/> property.</para>
            <para>This property is used for database update, to specify the type of command parameters 
            containing field values that are written to the database. Sometimes it is essential to 
            specify the type for database update more exactly than it can be inferred from the .NET 
            type of the field (from <see cref="P:C1.Data.SchemaObjects.Field.DataType"/>). For example, DataType = String can be further specialized 
            to be a Unicode or ASCII string. When you create a schema importing it from database structure, 
            Field.NativeDbType is automatically set to the actual type of the database field. 
            In those rare cases when you need to change it, you can set the Field.NativeDbType 
            property to a specific native type you need, or you can use Field.NativeDbType = 
            Any (-1) to indicate that inferring parameter type from <see cref="P:C1.Data.SchemaObjects.Field.DataType"/> is good enough 
            (or not needed at all, as, for example, in calculated fields).</para> 
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.PrimaryKey">
            <summary>
            Gets or sets a value indicating whether the field belongs to the table's primary key.
            </summary>
            <remarks>
            Every modifiable (ReadOnly:Table set to False) table must have primary key, that is, 
            at least one field with PrimaryKey property set to True. Primary key values must be unique 
            in table rows, an attempt to set a duplicate primary key generates an exception. 
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.AllowDbNull">
            <summary>
            Gets or sets a value indicating whether null or empty string values are allowed in this field.
            </summary>
            <remarks>
            If this property is set to False, an attempt to assign null or empty string value to this 
            field generates an exception.
            <para>The effective value of this property at run time (see <see cref="P:C1.Data.SchemaObjects.Field.EffectiveAllowDbNull"/>) for fields based 
            on other fields (composite table fields, table view fields) is False if the base field's 
            property value is False, even though the property value itself is independent of the 
            base field's property value.</para>
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.Field.EffectiveAllowDbNull"/>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Composite Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.EffectiveAllowDbNull">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/> property at run time.
            </summary>
            <remarks>
            Although a field's <see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/> property may be True, it will behave as if it 
            is False if the field is based on another field and that field's <see cref="P:C1.Data.SchemaObjects.Field.AllowDbNull"/> is set to False. 
            The EffectiveAllowDbNull property allows you to get this effective value.
            <para>A table view field is based on a table field if the table view field's <see cref="P:C1.Data.SchemaObjects.TableViewField.TableField"/> 
            property is not empty.</para>
            <para>A composite table field is based on a table field if the composite table field's 
            <see cref="P:C1.Data.SchemaObjects.CompositeTableField.TableViewField"/> property is not empty and <see cref="P:C1.Data.SchemaObjects.TableViewField.TableField"/> is not empty.</para>
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.HasDefaultValueOnServer">
            <summary>
            Gets or sets whether this field has a default value in the database.
            </summary>
            <remarks>
            If this property is set to True, an attempt to assign null or empty string value to this 
            field of the newly added row will not generate an exception even if the AllowDbNull
            property is set to False for this field.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Unique">
            <summary>
            Gets or sets a value indicating whether the values of this field in each row must be unique. 
            </summary>
            <remarks>
            If it is set to True, an attempt to assign a duplicate value to this field generates an exception.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.AutoIncrement">
            <summary>
            Gets or sets a value indicating whether the field automatically receives an 
            incremented value for a new row added to the table.
            </summary>
            <remarks>
            The most common way of implementing the autoincrement functionality is using the ClientAndServer 
            option. In this case, your database field must be an autoincrement field (an integer field 
            having autoincrement functionality in the database), and C1DataObjects implements autoincrement 
            functionality on the client. When a new row is added on the client, the field receives 
            a negative autoincrement value (both <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSeed"/> and <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementStep"/> are 
            equal to -1). C1DataObjects uses negative values on the client to ensure their uniqueness, 
            to distinguish them from autoincremented values assigned by the database. When the new row 
            is added to the database table on the server, C1DataObjects gets the autoincrement value 
            assigned by the database and refreshes the field value on the client with this value.  
            For this functionality to work with Oracle, Interbase and other databases that support 
            sequence/generator objects, you must also set the <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSequenceName"/> property.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Keys Assigned by Server or Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.AutoIncrementSeed">
            <summary>
            Gets or sets the starting value for a field with <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrement"/> value other than None.
            </summary>
            <remarks>
            If <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrement"/> = ClientAndServer, the values of the AutoIncrementSeed and 
            <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementStep"/> properties are equal to -1, to distinguish client autoincrement values 
            from those of the server, see <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrement"/>.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Keys Assigned by Server or Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.AutoIncrementSequenceName">
            <summary>
            Gets or sets the name of a sequence or generator database object used for autoincrement on the server.
            </summary>
            <remarks>
            This property is used to enable autoincrement key field functionality in Oracle, 
            InterBase and other databases that support special database objects used to generate unique 
            (autoincrementing) values. With SQL Server, Access and Sybase, the autoincrement (identity) is 
            assigned automatically by the database and can be retrieved with a special SQL command, see the 
            <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect"/> property. In Oracle and Interbase, setting the key value is not 
            done automatically by the database. It can be done either automatically by C1DataObjects, 
            if you set <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> = BeforeInsertCommand, or by a trigger, in which case you 
            set IdentityColumnRetrieveMode = AfterInsertCommand. In both cases, in addition to setting the 
            IdentityColumnLastValueSelect property that retrieves the autoincremented value, you must set 
            the AutoIncrementSequenceName property to the name of the object generating the value, a sequence 
            in Oracle, a generator in Interbase.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Keys Assigned by Server or Database</span></seealso>
            <seealso cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.AutoIncrementStep">
            <summary>
            Gets or sets the increment for a field with <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrement"/> value other than None.
            </summary>
            <remarks>
            If AutoIncrement = ClientAndServer, the values of the <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSeed"/> and AutoIncrementStep 
            properties are equal to -1, to distinguish client autoincrement values from those of the server, 
            see <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrement"/>.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Keys Assigned by Server or Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.MaxLength">
            <summary>
            Gets or sets the maximum length of a string field, in characters.
            </summary>
            <remarks>
            If the length is unlimited, the value is 0 (default).
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Precision">
            <summary>
            Gets or sets the maximum number of digits used to represent the field value.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Scale">
            <summary>
            Gets or sets the number of decimal places to in the field value.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.DefaultValue">
            <summary>
            Gets or sets the default value for the field when creating new rows.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ReadOnly">
            <summary>
            Gets or sets a value indicating whether modifications to field values are allowed.
            </summary>
            <remarks>
            If this property is set to True, modifying this field's values is not allowed.
            <para>The effective value of this property at run time (see <see cref="P:C1.Data.SchemaObjects.Field.EffectiveReadOnly"/>) for fields 
            based on other fields (composite table fields, table view fields) is True if the base 
            field's property value is True, even though the property value itself is independent 
            of the base field's property value.</para>
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso cref="P:C1.Data.SchemaObjects.Field.EffectiveReadOnly"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.EffectiveReadOnly">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.Field.ReadOnly"/> property at run time.
            </summary>
            <remarks>
            Although a field's ReadOnly property may be False, it will behave as if it is 
            True if the field is based on another field and that field's ReadOnly is set to False. 
            The EffectiveReadOnly property allows you to get this effective value.
            A table view field is based on a table field if the table view field's TableField 
            property is not empty.
            A composite table field is based on a table field if the composite table field's 
            TableViewField property is not empty and TableViewField.TableField is not empty.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.UserReadOnly">
            <summary>
            Gets or sets a value indicating whether the user can change this field value using bound controls.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.EffectiveUserReadOnly">
            <summary>
            Gets the effective value of the UserReadOnly property at run time.
            </summary>
            <remarks>
            Although a field's <see cref="P:C1.Data.SchemaObjects.Field.UserReadOnly"/> property may be False, it will behave as if it is True if the 
            field is based on another field and that field's <see cref="P:C1.Data.SchemaObjects.Field.UserReadOnly"/> is set to False. 
            The EffectiveReadOnly property allows you to get this effective value.
            <para>A table view field is based on a table field if the table view field's TableField property is not empty.</para>
            <para>A composite table field is based on a table field if the composite table field's 
            <see cref="P:C1.Data.SchemaObjects.CompositeTableField.TableViewField"/> property is not empty and <see cref="P:C1.Data.SchemaObjects.TableViewField.TableField"/> is not empty.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ReadOnlyUnlessNew">
            <summary>
            Gets or sets a value indicating whether modifications to field values are allowed 
            only in newly added rows.
            </summary>
            <remarks>
            If this property is set to True, modifying this field's values is allowed only in 
            newly added rows and that only while the row is in detached state (<see cref="M:C1.Data.C1DataRow.EndEdit"/> not yet called, 
            see <span style="Link Topic">Keys Assigned by Client: New Row Detached and Attached State</span>)
            The effective value of this property at run time (see <see cref="P:C1.Data.SchemaObjects.Field.EffectiveReadOnlyUnlessNew"/>) 
            for fields based on other fields (composite table fields, table view fields) is True 
            if the base field's property value is True, even though the property value itself 
            is independent of the base field's property value.
            </remarks>
            <seealso><span style="Link Topic">Keys Assigned by Client: New Row Detached and Attached State</span></seealso>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso cref="P:C1.Data.SchemaObjects.Field.EffectiveReadOnlyUnlessNew"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.EffectiveReadOnlyUnlessNew">
            <summary>
            Gets the effective value of the <see cref="P:C1.Data.SchemaObjects.Field.ReadOnlyUnlessNew"/> property at run time.
            </summary>
            <remarks>
            Although a field's ReadOnlyUnlessNew property may be False, it will behave as if 
            it is True if the field is based on another field and that field's ReadOnlyUnlessNew 
            is set to False. The EffectiveReadOnly property allows you to get this effective value.
            <para>A table view field is based on a table field if the table view field's TableField 
            property is not empty.</para>
            <para>A composite table field is based on a table field if the composite table field's 
            <see cref="P:C1.Data.SchemaObjects.CompositeTableField.TableViewField"/> property is not empty and <see cref="P:C1.Data.SchemaObjects.TableViewField.TableField"/> is not empty.</para>
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.CalculationExpression">
            <summary>
            Gets or sets the expression producing the result of a calculation. 
            </summary>
            <remarks>
            The <see cref="T:C1.Data.SchemaObjects.Field"/>'s CalculationExpression property corresponds to the <see cref="P:C1.Data.FieldCalculationInfo.Expression"/> property of 
            the first <see cref="T:C1.Data.FieldCalculationInfo"/> object in the <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection. Since in most 
            cases <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> consists of a single calculation, this field property, together 
            with <see cref="T:C1.Data.SchemaObjects.Field"/>'s <see cref="P:C1.Data.SchemaObjects.Field.CalculationCondition"/> and <see cref="P:C1.Data.SchemaObjects.Field.CalculationFireEvent"/> makes it easier to specify 
            a single calculation for a field, without using the collection editor.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.CalculationCondition">
            <summary>
            Gets or sets an optional Boolean expression defining applicability of a calculation. 
            </summary>
            <remarks>
            The <see cref="T:C1.Data.SchemaObjects.Field"/>'s CalculationCondition property corresponds to the <see cref="P:C1.Data.FieldCalculationInfo.Condition"/> property of 
            the first <see cref="T:C1.Data.FieldCalculationInfo"/> object in the <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection. Since in most 
            cases <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> consists of a single calculation, this field property, together 
            with <see cref="T:C1.Data.SchemaObjects.Field"/>'s <see cref="P:C1.Data.SchemaObjects.Field.CalculationExpression"/> and <see cref="P:C1.Data.SchemaObjects.Field.CalculationFireEvent"/> makes it easier to specify 
            a single calculation for a field, without using the collection editor.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">C1DataObjects Expressions</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.CalculationFireEvent">
            <summary>
            Gets or sets a value indicating whether calculation triggers the same events as field modification by the user.
            </summary>
            <remarks>
            The Field's CalculationFireEvent property corresponds to the <see cref="P:C1.Data.FieldCalculationInfo.FireEvent"/> property of the 
            first <see cref="T:C1.Data.FieldCalculationInfo"/> object in the <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection. 
            Since in most cases <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> consists of a single calculation, this field property, 
            together with <see cref="T:C1.Data.SchemaObjects.Field"/>'s <see cref="P:C1.Data.SchemaObjects.Field.CalculationExpression"/> and <see cref="P:C1.Data.SchemaObjects.Field.CalculationCondition"/> makes it easier 
            to specify a single calculation for a field, without using the collection editor.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ConstraintExpression">
            <summary>
            Gets or sets the Boolean expression used to test a constraint. 
            </summary>
            <remarks>
            The Field's ConstraintExpression property corresponds to the Expression property of the 
            first <see cref="T:C1.Data.ConstraintInfo"/> object in the <see cref="P:C1.Data.SchemaObjects.Field.Constraints"/> collection. Since in many cases 
            <see cref="P:C1.Data.SchemaObjects.Field.Constraints"/> consists of a single constraint, this field property, together with 
            Field's <see cref="P:C1.Data.SchemaObjects.Field.ConstraintCondition"/> and <see cref="P:C1.Data.SchemaObjects.Field.ConstraintErrorDescription"/> makes it easier to specify a 
            single constraint for a field, without using the collection editor.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ConstraintCondition">
            <summary>
            Gets or sets an optional Boolean expression defining applicability of a calculation.
            </summary>
            <remarks>
            If this expression is empty or evaluates to True, the <see cref="P:C1.Data.SchemaObjects.Field.CalculationExpression"/> is evaluated 
            and assigned to the field. If it evaluates to False, this calculation is skipped.
            <para>The Field's CalculationCondition property corresponds to the Condition property 
            of the first <see cref="T:C1.Data.FieldCalculationInfo"/> object in the <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> collection. 
            Since in most cases <see cref="P:C1.Data.SchemaObjects.Field.Calculations"/> consists of a single calculation, this field property, 
            together with Field's <see cref="P:C1.Data.SchemaObjects.Field.CalculationExpression"/> and <see cref="P:C1.Data.SchemaObjects.Field.CalculationFireEvent"/> makes it easier 
            to specify a single calculation for a field, without using the collection editor.</para>
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ConstraintErrorDescription">
            <summary>
            Gets or sets the string used as the error description in the exception thrown 
            when a constraint is not satisfied.
            </summary>
            <remarks>
            The Field's ConstraintErrorDescription property corresponds to the ErrorDescription property of the 
            first <see cref="T:C1.Data.ConstraintInfo"/> object in the <see cref="P:C1.Data.SchemaObjects.Field.Constraints"/> collection. Since in many cases 
            <see cref="P:C1.Data.SchemaObjects.Field.Constraints"/> consists of a single constraint, this field property, together with 
            Field's <see cref="P:C1.Data.SchemaObjects.Field.ConstraintCondition"/> and <see cref="P:C1.Data.SchemaObjects.Field.ConstraintExpression"/> makes it easier to specify a 
            single constraint for a field, without using the collection editor.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Constraints">
            <summary>
            Gets the collection of field constraints, <see cref="T:C1.Data.ConstraintInfo"/> objects.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Calculations">
            <summary>
            Gets the collection of field calculations, <see cref="T:C1.Data.FieldCalculationInfo"/> objects.
            </summary>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ConvertNullToEmpty">
            <summary>
            Gets or sets a value indicating whether DbNull values of a string field are returned as empty strings.
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.DataSetDef.FieldDefaults"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.ConvertEmptyToNull">
            <summary>
            Gets or sets a value indicating whether empty strings are stored as DbNull values.
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.DataSetDef.FieldDefaults"/>
        </member>
        <member name="P:C1.Data.SchemaObjects.Field.Description">
            <summary>
            Gets or sets a description for the field.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableField">
            <summary>
            The base class for <see cref="T:C1.Data.SchemaObjects.DbTableField"/> and <see cref="T:C1.Data.SchemaObjects.CompositeTableField"/>.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableField.Table">
            <summary>
            Gets the table to which the field belongs.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableField.Unique">
            <summary>
            Gets or sets a value indicating whether the values of this field in each row must be unique. 
            </summary>
            <remarks>
            If it is set to True, an attempt to assign a duplicate value to this field generates an exception.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.DbTableField">
            <summary>
            Represents a simple table field.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.DbTableField.#ctor(C1.Data.SchemaObjects.Table)">
            <summary>
            Initializes a new instance of the DbTableField class.
            </summary>
            <param name="table">Table the field belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DbTableField.#ctor">
            <summary>
            Initializes a new instance of the DbTableField class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.DbFieldName">
            <summary>
            Gets or sets the name of the database field this field is based on.
            </summary>
            <remarks>
            This property value can be empty string, in which case the field is not based 
            on a database field, represents a calculated field.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.DataSourceReadOnly">
            <summary>
            Gets or sets the value indicating whether the field value in the database can be changed.
            </summary>
            <remarks>
            If this property is set to True, the field value will not be set in the database update 
            operation (as with <see cref="P:C1.Data.SchemaObjects.DbTableField.UpdateSet"/> = Never) and it cannot be modified unless it is done 
            in a newly added row, before the <see cref="E:C1.Data.BaseLogic.AfterEndAddNew"/> event (as with <see cref="P:C1.Data.SchemaObjects.Field.ReadOnlyUnlessNew"/> = True).
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.InsertIgnore">
            <summary>
            Gets or sets a value indicating whether the field value is sent to the database (to the server) for insert.
            </summary>
            <remarks>
            If this property is set to True, the field value is not sent to the server for insert, even if the user has modified it. The default is False.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Updating the Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.UpdateIgnore">
            <summary>
            Gets or sets a value indicating whether the field value is sent to the database (to the server) for update.
            </summary>
            <remarks>
            If this property is set to True, the field value is not sent to the server for update, even if the user has modified it. The default is False.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Updating the Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.UpdateLocate">
            <summary>
            Gets or sets the value indicating whether the field value is used to locate the database 
            record that is going to be updated.
            </summary>
            <remarks>
            If this property is set to False, the field is not used for locating the database record, 
            regardless of the value of <see cref="P:C1.Data.SchemaObjects.Table.UpdateLocateMode"/>. If it is set to True (default), 
            this is determined by the value of the <see cref="P:C1.Data.SchemaObjects.Table.UpdateLocateMode"/> property.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Updating the Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.UpdateSet">
            <summary>
            Gets or sets a value indicating whether the field value is set in the database record.
            </summary>
            <remarks>
            If this property is set to Always, the value in the database is always modified, set 
            to the current field value. If it is set to Never, the value in the database is always 
            left unchanged. If it is set to IfChanged (default), the value in the database is set to 
            the current field value if the current field value is different from the original field 
            value as it was last fetched from the database. The original value can be retrieved 
            using <see cref="T:C1.Data.C1DataRow"/>.Item (field, <see cref="T:C1.Data.DataRowVersionEnum"/>.Original).
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Updating the Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.DbTableField.UpdateRefresh">
            <summary>
            Gets or sets the value indicating whether the field value is refreshed, retrieved 
            from the database after updating the database record.
            </summary>
            <remarks>
            If this property is set to False, the field value is not refreshed, regardless of the 
            value of <see cref="P:C1.Data.SchemaObjects.Table.UpdateRefreshMode"/>. If it is set to True (default), this is determined 
            by the value of the <see cref="P:C1.Data.SchemaObjects.Table.UpdateRefreshMode"/> property.
            </remarks>
            <seealso><span style="Link Topic">Table Fields</span></seealso>
            <seealso><span style="Link Topic">Updating the Database</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.CompositeTableField">
            <summary>
            Represents a composite table field.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeTableField.#ctor(C1.Data.SchemaObjects.CompositeTable)">
            <summary>
            Initializes a new instance of the CompositeTableField class.
            </summary>
            <param name="table">Composite table the field belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeTableField.#ctor">
            <summary>
            Initializes a new instance of the CompositeTableField class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeTableField.TableViewField">
            <summary>
            Gets or sets the table view field on which this field is based.
            </summary>
            <remarks>
            This property value can be null, in which case the field is not based on any of the 
            constituent table fields, represents a calculated field belonging to the composite table.
            </remarks>
            <seealso><span style="Link Topic">Composite Table Fields</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableViewField">
            <summary>
            Represents a table view field.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewField.#ctor(C1.Data.SchemaObjects.TableView)">
            <summary>
            Initializes a new instance of the TableViewField class.
            </summary>
            <param name="tableView">Table view the field belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableViewField.#ctor">
            <summary>
            Initializes a new instance of the TableViewField class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewField.TableView">
            <summary>
            Gets the table view to which the field belongs.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableViewField.TableField">
            <summary>
            Gets or sets the table field on which this field is based.
            </summary>
            <remarks>
            This property value can be null, in which case the field is not based on any of 
            the table fields, represents a calculated field belonging to the table view.
            </remarks>
            <seealso><span style="Link Topic">Table View Fields</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.RelationCardinalityEnum">
            <summary>
            Specifies the cardinality of a relation.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="F:C1.Data.SchemaObjects.RelationCardinalityEnum.OneToMany">
            <summary>
            One-to-many relation.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.RelationCardinalityEnum.ManyToOne">
            <summary>
            Many-to-one relation.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.ReferentialIntegrityRuleEnum">
            <summary>
            Specifies the action applied to child rows when their parent key is modified or deleted.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="F:C1.Data.SchemaObjects.ReferentialIntegrityRuleEnum.Cascade">
            <summary>
            Delete or update child rows.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ReferentialIntegrityRuleEnum.None">
            <summary>
            No action taken on child rows.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ReferentialIntegrityRuleEnum.SetDefault">
            <summary>
            Set values in child rows to the value specified by the <see cref="P:C1.Data.SchemaObjects.Field.DefaultValue"/> property.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.ReferentialIntegrityRuleEnum.SetNull">
            <summary>
            Set values in child rows to DbNull.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.Relation">
            <summary>
            Base class for simple and composite relations.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
            <seealso cref="T:C1.Data.SchemaObjects.JoinConditionCollection"/>
        </member>
        <member name="M:C1.Data.SchemaObjects.Relation.#ctor(C1.Data.SchemaObjects.Schema,C1.Data.SchemaObjects.Table,C1.Data.SchemaObjects.Table)">
            <summary>
            Initializes a new instance of the Relation class.
            </summary>
            <param name="schema">Schema the relation belongs to.</param>
            <param name="parentTable">Parent table of the relation.</param>
            <param name="childTable">Child table of the relation.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.Relation.#ctor">
            <summary>
            Initializes a new instance of the Relation class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Relation.Schema">
            <summary>
            Gets the schema the relation belongs to.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Relation.Name">
            <summary>
            Gets or sets the relation name.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Relation.Parent">
            <summary>
            Gets or sets the parent table of the relation.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Relation.Child">
            <summary>
            Gets or sets the child table of the relation.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Relation.Cardinality">
            <summary>
            Gets or sets one of the two <see cref="T:C1.Data.SchemaObjects.RelationCardinalityEnum"/> values.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.Relation.Description">
            <summary>
            Gets or sets a description for the relation.
            </summary>
            <remarks>
            This value is displayed in the Schema Designer's Information window when you select the relation.
            </remarks>
        </member>
        <member name="T:C1.Data.SchemaObjects.SimpleRelation">
            <summary>
            Represents a relation between two simple tables.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.SimpleRelation.#ctor(C1.Data.SchemaObjects.Table,C1.Data.SchemaObjects.Table)">
            <summary>
            Initializes a new instance of the SimpleRelation class.
            </summary>
            <param name="parentTable">Parent table of the relation.</param>
            <param name="childTable">Child table of the relation.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.SimpleRelation.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the SimpleRelation class.
            </summary>
            <param name="schema">Schema the relation belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.SimpleRelation.#ctor">
            <summary>
            Initializes a new instance of the SimpleRelation class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.SimpleRelation.Joins">
            <summary>
            Gets the joins collection of the relation.
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.CompositeRelation.SimpleRelation"/>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SimpleRelation.EnforceConstraints">
            <summary>
            Gets or sets a value indicating whether the rule prohibiting child rows without parent is enforced.
            </summary>
            <remarks>
            The default is True.
            </remarks>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SimpleRelation.UpdateCascadeRule">
            <summary>
            Gets or sets a value specifying the action applied to child rows when their parent key is modified.
            </summary>
            <remarks>
            The default is Cascade.
            </remarks>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SimpleRelation.DeleteCascadeRule">
            <summary>
            Gets or sets a value specifying the action applied to child rows when their parent key is deleted.
            </summary>
            <remarks>
            The default is None.
            </remarks>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SimpleRelation.UpdateCascadeServer">
            <summary>
            Gets or sets a value indicating whether the database performs cascade update of 
            child key values when their parent key value is modified.
            </summary>
            <remarks>
            The default is True.
            <para>Performing database update in a cascade key update situation, C1DataObjects 
            must know whether the database is performing cascade update as well.</para>
            </remarks>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.CompositeRelation">
            <summary>
            Represents a relation between two tables one of which is composite.
            </summary>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeRelation.#ctor(C1.Data.SchemaObjects.SimpleRelation,C1.Data.SchemaObjects.Table,C1.Data.SchemaObjects.Table)">
            <summary>
            Initializes a new instance of the CompositeRelation class.
            </summary>
            <param name="simpleRel">Simple relation on which the composite relation is based.</param>
            <param name="parentTable">Parent table of the relation.</param>
            <param name="childTable">Child table of the relation.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeRelation.#ctor(C1.Data.SchemaObjects.Schema)">
            <summary>
            Initializes a new instance of the CompositeRelation class.
            </summary>
            <param name="schema">Schema the relation belongs to.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.CompositeRelation.#ctor">
            <summary>
            Initializes a new instance of the CompositeRelation class.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeRelation.SimpleRelation">
            <summary>
            Gets or sets the <see cref="P:C1.Data.SchemaObjects.CompositeRelation.SimpleRelation"/> on which this composite relation is based.
            </summary>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeRelation.ParentTableView">
            <summary>
            Gets or sets the table view in the <see cref="P:C1.Data.SchemaObjects.Relation.Parent"/> composite table that is used as the parent 
            table for the <see cref="P:C1.Data.SchemaObjects.CompositeRelation.SimpleRelation"/>.
            </summary>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.CompositeRelation.ChildTableView">
            <summary>
            Gets or sets the table view in the <see cref="P:C1.Data.SchemaObjects.Relation.Child"/> composite table that is used as the child table for 
            the <see cref="P:C1.Data.SchemaObjects.CompositeRelation.SimpleRelation"/>.
            </summary>
            <seealso><span style="Link Topic">Composite Relations</span></seealso>
        </member>
        <member name="T:C1.Data.SchemaObjects.JoinCondition">
            <summary>
            Represents an equality condition between a parent and a child field of a <see cref="T:C1.Data.SchemaObjects.SimpleRelation"/>.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinCondition.#ctor(C1.Data.SchemaObjects.JoinConditionCollection)">
            <summary>
            Initializes a new instance of the JoinCondition class.
            </summary>
            <param name="owner">The collection of join conditions of a relation this join condition belongs to.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.JoinCondition.ParentField">
            <summary>
            Gets or sets the parent field of the join condition.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.JoinCondition.ChildField">
            <summary>
            Gets or sets the child field of the join condition.
            </summary>
            <seealso><span style="Link Topic">Simple Relations</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.JoinCondition.Owner">
            <summary>
            Gets the collection to which the join object belongs.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.JoinConditionCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.JoinCondition"/> objects of a <see cref="T:C1.Data.SchemaObjects.SimpleRelation"/>.
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.SimpleRelation.Joins"/>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinConditionCollection.Add(C1.Data.SchemaObjects.JoinCondition)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="cond">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinConditionCollection.CopyTo(C1.Data.SchemaObjects.JoinCondition[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinConditionCollection.Insert(System.Int32,C1.Data.SchemaObjects.JoinCondition)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which object should be inserted.</param>
            <param name="join">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinConditionCollection.IndexOf(C1.Data.SchemaObjects.JoinCondition)">
            <summary>
            Returns the zero-based index of the join object in the collection.
            </summary>
            <param name="join">The join object to locate in the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinConditionCollection.Contains(C1.Data.SchemaObjects.JoinCondition)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="join">The Object to locate in the collection.</param>
            <returns>True if join is found in the collection; otherwise, False.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.JoinConditionCollection.Remove(C1.Data.SchemaObjects.JoinCondition)">
            <summary>
            Removes the first occurrence of a specific object from the collection.
            </summary>
            <param name="join">The object to remove from the collection.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.JoinConditionCollection.Relation">
            <summary>
            Gets the <see cref="T:C1.Data.SchemaObjects.SimpleRelation"/> this collection belongs to.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.JoinConditionCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The zero-based index of the element.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.Schema">
            <summary>
            The main class of the C1.Data.SchemaObjects namespace, representing a schema.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.Schema.Save(System.String)">
            <summary>
            Saves the schema in a file or stream.
            </summary>
            <param name="path">Full name of the file where the schema is saved.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.Schema.Save(System.IO.Stream)">
            <summary>
            Saves the schema in a file or stream.
            </summary>
            <param name="stream">The stream where the schema is saved.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.Schema.Load(System.String)">
            <summary>
            Loads the schema from a file or stream.
            </summary>
            <param name="path">Full name of the file from which the schema is loaded.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.Schema.Load(System.IO.Stream)">
            <summary>
            Loads the schema from a file or stream.
            </summary>
            <param name="stream">The stream from which the schema is loaded.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.Schema.GetUniqueName(System.Collections.CollectionBase,System.String,System.String,System.Object)">
            <summary>
            Returns unique string index name for collection.
            Can be used for classes inherited from CollectionBase.
            </summary>
            <param name="collection">Collection</param>
            <param name="indexBase">String part which will ahead of number if defaultRelVal already exists in collection</param>
            <param name="defaultRetVal">First checks this value. If does not exist, builds index name as indexBase + [numeric id]</param>
            <param name="skipThis"></param>
            <returns></returns>
        </member>
        <member name="P:C1.Data.SchemaObjects.Schema.DataSetDefs">
            <summary>
            Gets the data set definition collection.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Schema.Tables">
            <summary>
            Gets the table collection.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Schema.Relations">
            <summary>
            Gets the relation collection.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.Schema.Connections">
            <summary>
            Gets the connection collection.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.DataSetDefCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.DataSetDef"/> objects.
            </summary>
            <seealso cref="T:C1.Data.SchemaObjects.DataSetDef"/>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.IndexOf(System.String)">
            <summary>
            Gets the index of an element with a given name in the collection.
            </summary>
            <param name="name">The <see cref="!:DataSetDef.Name"/> of the element.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.IndexOf(C1.Data.SchemaObjects.DataSetDef)">
            <summary>
            Gets the index of a given element in the collection.
            </summary>
            <param name="dataSetDef">The element of the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.Add(C1.Data.SchemaObjects.DataSetDef)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.Insert(System.Int32,C1.Data.SchemaObjects.DataSetDef)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which obj should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.Remove(C1.Data.SchemaObjects.DataSetDef)">
            <summary>
            Removes the first occurrence of a specific object.
            </summary>
            <param name="obj">The Object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.CopyTo(C1.Data.SchemaObjects.DataSetDef[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.DataSetDefCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="!:DataSetDef.Name"/> of the element.</param>
            <returns>True if element is found in the collection; otherwise, False.</returns>
        </member>
        <member name="P:C1.Data.SchemaObjects.DataSetDefCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The index of the object.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.DataSetDefCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="!:DataSetDef.Name"/> of the object.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.TableCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.Table"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.IndexOf(System.String)">
            <summary>
            Gets the index of an object in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Table.Name"/> of the element.</param>
            <returns>Returns the index of the object.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.IndexOf(C1.Data.SchemaObjects.Table)">
            <summary>
            Gets the index of an object in the collection.
            </summary>
            <param name="table">The element of the collection.</param>
            <returns>Gets the index of an object.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.Add(C1.Data.SchemaObjects.Table)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.Insert(System.Int32,C1.Data.SchemaObjects.Table)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which obj should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.Remove(C1.Data.SchemaObjects.Table)">
            <summary>
            Removes the first occurrence of a specific object.
            </summary>
            <param name="obj">The Object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.CopyTo(C1.Data.SchemaObjects.Table[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.TableCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Table.Name"/> of the element.</param>
            <returns>True if table with a given name is found in the collection; otherwise, False.</returns>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The index of the object.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.TableCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Table.Name"/> of the object.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.RelationCollection">
            <summary>
            Represents a collection of <see cref="T:C1.Data.SchemaObjects.Relation"/> objects.
            </summary>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.IndexOf(System.String)">
            <summary>
            Gets the index of the relation object with a given name in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Relation.Name"/> of the element.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.IndexOf(C1.Data.SchemaObjects.Relation)">
            <summary>
            Gets the index of the relation object in the collection.
            </summary>
            <param name="relation">The element of the collection.</param>
            <returns>The zero-based index of an element, if found; otherwise, -1.</returns>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.Add(C1.Data.SchemaObjects.Relation)">
            <summary>
            Adds a new element to the collection.
            </summary>
            <param name="obj">The object to be added to the end of the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.Insert(System.Int32,C1.Data.SchemaObjects.Relation)">
            <summary>
            Inserts an element into the collection at the specified index.
            </summary>
            <param name="index">The zero-based index at which obj should be inserted.</param>
            <param name="obj">The object to insert.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.Remove(C1.Data.SchemaObjects.Relation)">
            <summary>
            Removes the first occurrence of a specific object.
            </summary>
            <param name="obj">The Object to remove from the collection.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.CopyTo(C1.Data.SchemaObjects.Relation[],System.Int32)">
            <summary>
            Copies the collection or a portion of it to a one-dimensional array.
            </summary>
            <param name="array">The one-dimensional Array that is the destination of the elements copied from collection. The Array must have zero-based indexing.</param>
            <param name="index">The zero-based index in array at which copying begins.</param>
        </member>
        <member name="M:C1.Data.SchemaObjects.RelationCollection.Contains(System.String)">
            <summary>
            Determines whether an element is in the collection.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Relation.Name"/> of the element.</param>
            <returns>True if relation with a given name is found in the collection; otherwise, False.</returns>
        </member>
        <member name="P:C1.Data.SchemaObjects.RelationCollection.Item(System.Int32)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="index">The index of the object.</param>
        </member>
        <member name="P:C1.Data.SchemaObjects.RelationCollection.Item(System.String)">
            <summary>
            Gets the element of the collection at the specified index.
            </summary>
            <param name="name">The <see cref="P:C1.Data.SchemaObjects.Relation.Name"/> of the object.</param>
        </member>
        <member name="T:C1.Data.SchemaObjects.SchemaDesignerBase">
            <summary>
            Summary description for SchemaDesignerBase.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.SqlSyntaxEnum">
            <summary>
            Specifies general SQL syntax used by a database.
            </summary>
            <remarks>
            Current C1DataObjects version uses the following features of SQL2 standard, if Syntax = SQL2: Joins in FROM clause.
            </remarks>
            <seealso cref="P:C1.Data.SchemaObjects.SqlDialectInfo.Syntax"/>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlSyntaxEnum.SQL2">
            <summary>
            Compliant with SQL2 standard. Such are, for example, Microsoft SQL Server and Microsoft Access.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlSyntaxEnum.Oracle">
            <summary>
            Oracle SQL syntax.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlSyntaxEnum.SQL1">
            <summary>
            SQL engines supporting only SQL1 standard.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.SqlQuoteEnum">
            <summary>
            Specifies quotation rules for names in SQL statements.
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.SqlDialectInfo.NameQuote"/>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlQuoteEnum.None">
            <summary>
            No quotation. Example: a name
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlQuoteEnum.Brackets">
            <summary>
            Square brackets: Example: [a name]
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlQuoteEnum.DoubleQuote">
            <summary>
            Double quote. Example: "a name"
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.SqlQuoteEnum.SingleQuote">
            <summary>
            Single quote. Example: 'a name'
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.IdentityColumnRetrieveModeEnum">
            <summary>
            Indicates how autoincrement key value is retrieved for inserted row: before, after or in the same scope with the INSERT command.
            Used in the <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> property of a connection.
            </summary>
            <seealso><span style="Link Topic">Key Assigned Automatically by Database</span></seealso>
            <seealso cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect"/>
            <seealso cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/>
        </member>
        <member name="F:C1.Data.SchemaObjects.IdentityColumnRetrieveModeEnum.BeforeInsertCommand">
            <summary>
            Autoincrement key value is obtained (generated by a sequence/generator object) before 
            executing the INSERT command. This option is used with Oracle, Interbase and other databases 
            that support special database objects for generating autoincrement (identity) values. This 
            option is used if there is no on INSERT trigger setting the autoincrement key value. 
            If there is such trigger, the AfterInsertCommand option is used.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.IdentityColumnRetrieveModeEnum.InInsertCommand">
            <summary>
            Autoincrement key value retrieval is done by the same command that inserts the row. 
            The generated command consists of two SQL commands separated by semicolon: first INSERT, 
            then the identity retrieval command. This option is used with Sql Server and can be used 
            with other databases. It is necessary to support the SCOPE_IDENTITY() function that is used 
            for identity retrieval.
            </summary>
        </member>
        <member name="F:C1.Data.SchemaObjects.IdentityColumnRetrieveModeEnum.AfterInsertCommand">
            <summary>
            Autoincrement value is retrieved by a separate command after the INSERT command has been executed. 
            This option is used with Microsoft Access and can be used with other databases.
            </summary>
        </member>
        <member name="T:C1.Data.SchemaObjects.SqlDialectInfo">
            <summary>
            This class contains represents various specifics of SQL syntax relevant to C1DataObjects that can vary between different databases.
            </summary>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.Connection">
            <summary>
            Gets the <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.Connection"/> object to which this object belongs.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.Syntax">
            <summary>
            Gets or sets one of the <see cref="T:C1.Data.SchemaObjects.SqlSyntaxEnum"/> values specifying the SQL dialect syntax.
            </summary>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.NameQuote">
            <summary>
            Gets or sets one of the <see cref="T:C1.Data.SchemaObjects.SqlQuoteEnum"/> values specifying the quotation rule for names.
            </summary>
            <remarks>
            Name that are not well-formed identifiers (not start with a letter or containing characters 
            other than letters and digits) need to be quoted in SQL statements. This property determines 
            the quotation mark used in these cases.
            </remarks>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.AddAsToTableAlias">
            <summary>
            Gets or sets a value indicating whether to add "AS" between table name and table alias.
            </summary>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.DefaultInInsertValues">
            <summary>
            Gets or sets a value indicating whether DEFAULT keyword is supported in the VALUES() list in INSERT statement.
            </summary>
            <remarks>
            This property is used generating an INSERT statement, only if no field values are specified, 
            so all fields in the new row must have default values determined by the database. 
            If this property is True, "VALUES (DEFAULT)" is used in the statement. If it is False, 
            "DEFAULT VALUES" is used.
            </remarks>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect">
            <summary>
            Gets or sets a string representing the SELECT command returning the last assigned identity 
            (autoincrement) value in the current database connection.
            </summary>
            <remarks>
            Implementing autoincrement functionality on adding a row for a field with 
            <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrement"/> = ClientAndServer, C1DataObjects tries to retrieve the 
            autoincrement (identity) values assigned by the database to the field, in order to refresh that 
            value on the client. If your database supports retrieving the last assigned identity value via a 
            single command, you can set this property to a command string retrieving that value. That will be 
            enough for C1DataObjects to implement the autoincrement refresh functionality. 
            <para>This property is used in conjunction with the <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> property. 
            By default, C1DataObjects sets correct values for well-known databases such as SQL Server, MS Access, 
            Oracle, Interbase. For example, in SQL Server 2000, this command is "SELECT SCOPE_IDENTITY()" 
            and <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> is InInsertCommand. In Microsoft Access, this command is 
            "SELECT @@IDENTITY" and the <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> is AfterInsertCommand.</para>
            <para>In Oracle and Interbase, there are two options:</para>
            <para>If you need a trigger setting the autoincrement key value on INSERT, use 
            <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> = AfterInsertCommand and the following properties for Oracle and Interbase:</para>
            <para>    Oracle: set IdentityColumnLastValueSelect = SELECT %AUTOINCREMENTSEQUENCENAME%.CURRVAL FROM DUAL 
            and set the <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSequenceName"/> field property to the corresponding sequence name.</para>
            <para>    Interbase: set IdentityColumnLastValueSelect = SELECT GEN_ID(%AUTOINCREMENTSEQUENCENAME%, 0) FROM RDB$DATABASE 
            and set the <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSequenceName"/> field property to the corresponding generator name.</para>
            <para>Without such trigger, set the <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode"/> = BeforeInsertCommand and the 
            following properties for Oracle and Interbase:</para>
            <para>    Oracle: set <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect"/> = SELECT %AUTOINCREMENTSEQUENCENAME%.NEXTVAL FROM DUAL 
            and set the <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSequenceName"/> field property to the corresponding sequence name.</para>
            <para>    Interbase: set <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect"/> = SELECT GEN_ID(%AUTOINCREMENTSEQUENCENAME%, 1) FROM RDB$DATABASE and 
            set the <see cref="P:C1.Data.SchemaObjects.Field.AutoIncrementSequenceName"/> field property to the corresponding generator name.</para>
            <para>If your database does not support this functionality, you still can implement refreshing 
            autoincrement value in AutoIncrement = ClientAndServer writing code in AfterUpdateRow event as 
            shown in Keys Assigned by Server or Database.</para>
            </remarks>
            <seealso><span style="Link Topic">Keys Assigned by Server or Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnRetrieveMode">
            <summary>
            Gets or sets a value indicating how autoincrement key value is retrieved for inserted row: before, after or in the same scope with the INSERT command. 
            </summary>
            <seealso cref="P:C1.Data.SchemaObjects.SqlDialectInfo.IdentityColumnLastValueSelect"/>
            <seealso><span style="Link Topic">Keys Assigned by Server or Database</span></seealso>
        </member>
        <member name="P:C1.Data.SchemaObjects.SqlDialectInfo.AlwaysEscapeNames">
            <summary>
            Gets or sets a value indicating whether every table and column name must be quoted to 
            avoid collision with reserved keywords.
            </summary>
            <remarks>
            If this property is set to True, table and field names are always escaped in generated 
            SQL statements. This is useful to ensure that the names do not conflict with database-reserved words. 
            The quotation mark is determined by the <see cref="P:C1.Data.SchemaObjects.SqlDialectInfo.NameQuote"/> property value (for example, [field] in 
            MS Access, "field" in SQL Server and Oracle). Default: False.
            </remarks>
            <seealso><span style="Link Topic">Database Connections</span></seealso>
        </member>
        <member name="F:C1.Util.Licensing.AboutForm.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:C1.Util.Licensing.AboutForm.Dispose(System.Boolean)">
            <summary>
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:C1.Util.Licensing.AboutForm.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="T:C1.Util.Licensing.ProviderInfo">
            <summary>
            <para>Provides static <see cref="M:C1.Util.Licensing.ProviderInfo.Validate(System.Type,System.Object)"/> methods that 
            should be called from the constructors of licensed classes.</para>
            <para>Also provides a static <see cref="M:C1.Util.Licensing.ProviderInfo.ShowAboutBox(System.Object)"/> method that can 
            be called to show the about box with product and licensing information.</para>
            </summary>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.Validate(System.Type,System.Object)">
            <summary>
            Perform license validation. Call this method from the licensed object's 
            constructor to save a license key at design time, validate it at runtime, 
            and display a nag dialog if a valid license is not found.
            </summary>
            <param name="type">Type of licensed object (use typeof() and not GetType()).</param>
            <param name="instance">Reference to the licensed object (not currently used).</param>
            <returns>A <see cref="T:C1.Util.Licensing.LicenseInfo"/> object that contains information about the license.</returns>
            <remarks>
            <para>Check the <b>ShouldNag</b> property of the returned <see cref="T:C1.Util.Licensing.LicenseInfo"/> 
            to determine whether the licensed class should nag the user. This value is set
            to true in situations where a valid license was not found but a nag dialog
            could not be displayed. In these cases, the licensed class is supposed to nag
            in some other way (with a watermark for example).</para>
            </remarks>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.Validate(System.Type,System.Object,System.Boolean)">
            <summary>
            Perform license validation. Call this method from the licensed object's 
            constructor to save a license key at design time, validate it at runtime, 
            and display a nag dialog if a valid license is not found.
            </summary>
            <param name="type">Type of licensed object (use typeof() and not GetType()).</param>
            <param name="instance">Reference to the licensed object (not currently used).</param>
            <param name="showNagDialog">Whether the nag dialog should be displayed when a valid license is not found.</param>
            <returns>A <see cref="T:C1.Util.Licensing.LicenseInfo"/> object that contains information about the license.</returns>
            <remarks>
            <para>This overload was created for use in WPF. It should be called in the control's constructor
            in order to support license persistence correctly. But it should not show the nag dialog until the
            control is fully loaded, or the VS designer may remain blank.</para>
            <para>So the solution is this:</para>
            <code>
            LicenseInfo _licInfo;
            public LicensedControl()
            {
              // check license but don't nag yet
              _licInfo = ProviderInfo.Validate(typeof(LicensedControl), this, false);
              
              // perform licensing after control is fully loaded
              Loaded += LicensedControl_Loaded;
            }
            void LicensedControl_Loaded(object sender, RoutedEventArgs e)
            {
              // nag after loading
              if (_licInfo.ShouldNag)
              {
                ProviderInfo.ShowAboutBox(this);
              }
            }
            </code>
            </remarks>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.Nag(System.Type,C1.Util.Licensing.LicenseInfo,System.Boolean)">
            <summary>
            Nag user by showing AboutBox with license information.
            Show it only once per day per assembly.
            </summary>
            <param name="type">Type of licensed object (use typeof() and not GetType()).</param>
            <param name="li"><see cref="T:C1.Util.Licensing.LicenseInfo"/> object that contains information about the license.</param>
            <param name="designTime">Whether we're running at design or run time.</param>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.Validate(System.Type,System.Object,System.Reflection.Assembly,System.String)">
            <summary>
            Version of Validate used by constructors that take runtime keys.
            </summary>
            <param name="type">Type of licensed object (use typeof() and not GetType()).</param>
            <param name="instance">Reference to the licensed object.</param>
            <param name="callingAsm">Assembly that contains the owner licensed control.</param>
            <param name="runtimeKey">Any valid C1 runtime key.</param>
            <returns>A <see cref="T:C1.Util.Licensing.LicenseInfo"/> with information about the runtime key.</returns>
            <remarks>
            <para>This allows a licensed C1 class to create other C1 objects bypassing 
            license verification for the child objects.</para>
            <para>For extra safety, we check that the owner object is defined in an assembly
            the contains a 'C1ProductInfo' attribute.</para>
            </remarks>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.ValidateDesigntime(System.Type,System.ComponentModel.LicenseContext)">
            <summary>
            Design time validation. Looks for a license in the registry and saves it in the
            provided <see cref="T:System.ComponentModel.LicenseContext"/>.
            </summary>
            <param name="type">Type of licensed object (use typeof() and not GetType()).</param>
            <param name="context"><see cref="T:System.ComponentModel.LicenseContext"/> where the runtime key will be stored.</param>
            <returns>A <see cref="T:C1.Util.Licensing.LicenseInfo"/> with information about the license.</returns>
            <remarks>
            Call this method from application-type products (that always require a license to be
            installed in the registry). In this case, the <paramref name="context"/> parameter 
            should be set to null.
            </remarks>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.ValidateRuntime(System.Type,System.ComponentModel.LicenseContext)">
            <summary>
            Runtime validation.
            Looks for a runtime key stored in the current application's resources.
            </summary>
            <param name="type">Type of licensed object (use typeof() and not GetType()).</param>
            <param name="context"><see cref="T:System.ComponentModel.LicenseContext"/> where the runtime key will be stored.</param>
            <returns>A <see cref="T:C1.Util.Licensing.LicenseInfo"/> with information about the license.</returns>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.ShowAboutBox(System.Object)">
            <summary>
            Shows the About Box for an instance of a C1 product.
            </summary>
        </member>
        <member name="M:C1.Util.Licensing.ProviderInfo.GetC1Type(System.Object)">
            <summary>
            Get the type whose assembly contains a 'C1ProductInfoAttribute'.
            </summary>
            <param name="instance">Instance of an object whose type is to be checked.</param>
            <returns>The type whose assembly contains a 'C1ProductInfoAttribute'</returns>
        </member>
        <member name="T:C1.Util.Licensing.LicenseInfo">
            <summary>
            Contains information about a license stored in an application.
            </summary>
        </member>
        <member name="M:C1.Util.Licensing.LicenseInfo.#ctor(System.Type,C1.Util.Licensing.LicenseStatus,C1.Util.Licensing.ProductLicense)">
            <summary>
            Initializes a new instance of a <see cref="T:C1.Util.Licensing.LicenseInfo"/> class.
            </summary>
        </member>
        <member name="M:C1.Util.Licensing.LicenseInfo.#ctor(System.Type,C1.Util.Licensing.LicenseStatus)">
            <summary>
            Initializes a new instance of a <see cref="T:C1.Util.Licensing.LicenseInfo"/> class.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.LicenseStatus">
            <summary>
            Gets or sets the status of this license (valid, expired, unlicensed).
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.License">
            <summary>
            Gets or sets the <see cref="T:C1.Util.Licensing.ProductLicense"/> associated with this license.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.Type">
            <summary>
            Gets or sets the <see cref="P:C1.Util.Licensing.LicenseInfo.Type"/> associated with this license.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.EvaluationDaysElapsed">
            <summary>
            Gets the number of evaluation days elapsed.
            Returns -1 for valid licenses.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.EvaluationDaysLeft">
            <summary>
            Gets the number of evaluation days still left.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.ShouldNag">
            <summary>
            Gets or sets a value that determines whether the caller should
            nag the user. This is the case when the component/control is 
            not licensed, but is not running in interactive mode. So we can't
            show a dialog and the caller is supposed to nag some other way
            (typically by adding watermarks to the UI or output).
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.IsValid">
            <summary>
            Gets a value that determines whether the license found is valid.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.IsExpired">
            <summary>
            Gets a value that determines whether the license found is expired.
            </summary>
        </member>
        <member name="P:C1.Util.Licensing.LicenseInfo.IsLocalHost">
            <summary>
            Gets a value that determines whether the component is running under
            localhost and therefore should not nag the user with alert dialogs.
            </summary>
        </member>
        <member name="T:C1.Util.Licensing.SafeLicenseContext">
            <summary>
            
            Provides a version of GetSavedLicenseKey that doesn't require
            special permissions.
            
            The code was mostly copied from the .NET framework, but then changed 
            in a few places to require fewer permissions (assembly name, file io, 
            etc). 
            
            The main change is the use of a custom deserializer to read Hashtable 
            objects instead of the original BinaryFormatter, which requires
            permissions.
            
            </summary>
        </member>
        <member name="T:C1.Util.Licensing.C1AboutNameAttribute">
            <summary>
            Attribute used to specify the product name shown on the About Box.
            </summary>
        </member>
        <member name="T:C1.Util.Licensing.C1ProductInfoAttribute">
            <summary>
            Attribute used to attach licensing/product information to assemblies.
            </summary>
        </member>
        <member name="T:C1.Util.Localization.C1DescriptionAttribute">
            <summary>
            C1DescriptionAttribute replaces the DescriptionAttribute
            and uses the C1Localizer class to return the localized Attribute string
            </summary>
        </member>
        <member name="T:C1.Util.Localization.C1CategoryAttribute">
            <summary>
            C1CategoryAttribute replaces the CategoryAttribute
            and uses the C1Localizer class to return the localized Attribute string
            </summary>
        </member>
        <member name="T:C1.Util.Localization.C1Localizer">
            <summary>
            Localization tables and methods for looking up localized strings.
            </summary>
        </member>
        <member name="T:C1.Util.Licensing.ProductLicense">
            <summary>
            Represents a license for a product (e.g. C1BarCode, C1Studio Enterprise).
            
            Provides methods for:
            - generating new license keys (administrative task)
            - checking license key validity (used by installer and products)
            - generating and checking runtime keys (used by products)
            - installing/uninstalling licenses (used by installer)
            
            The install/uninstall code requires elevated permissions, and is
            used only by setups and utilities (not by controls). The code is 
            implemented in the ProductLicense.Installer.cs, which controls should
            not include since it won't be useful to them.
            
            When a product is sold, we send the user a license KEY. The user installs
            a license on his machine by providing his name, his company name, and the 
            key.
            
            The <see cref="P:C1.Util.Licensing.ProductLicense.Key"/> is a string in the following format:
            
                AAQYYCC-XX-NNNNNN-DD-DZZZZZZ
                
            Where:
            
                AA:     Product code (should match one of the products in the 
                        product catalog (see ProductInformation.GetProductCatalog()).
                Q:      Quarter when the license key was issued (1, 2, or 3)
                YY:     Year when the license key was issued (e.g., 10 for 2010)
                CC:     Order code, two chars that indicate whether this is a 
                        new sale, upgrade, renewal, special offer, etc.
                XX:     Hash code to ensure key validity.
                NNNNNN: Unique serial number.
                DDD:    Vendor code, three chars
                ZZZZZZ: Combination of random numbers for uniqueness and extra hash.
                
            </summary>
        </member>
        <member name="T:C1.Util.IOnLongOpInProgressProvider">
            <summary>
            Interface used to provide feedback and the ability to cancel potentially long operations
            </summary>
        </member>
        <member name="T:C1.Util.Xml.Serialization.TypeSerialization">
            <summary>
            Determines how item types are serialized
            </summary>
        </member>
        <member name="F:C1.Util.Xml.Serialization.TypeSerialization.None">
            <summary>
            Item type is not serialized (this is the default)
            </summary>
        </member>
        <member name="F:C1.Util.Xml.Serialization.TypeSerialization.FullName">
            <summary>
            Item type is serialized as a fully qualified name
            </summary>
        </member>
        <member name="F:C1.Util.Xml.Serialization.TypeSerialization.AssemblyQualifiedName">
            <summary>
            Item type is serialized as a fully qualified name and assembly name
            </summary>
        </member>
        <member name="F:C1.Util.Xml.Serialization.TypeSerialization.Custom">
            <summary>
            Use owner's IMemberTypeEncoder for members
            (for collection items, this is done automatically).
            </summary>
        </member>
        <member name="T:C1.Util.Xml.Serialization.MemberTypeEncoderHelper">
            <summary>
            Helper class for implementors of IMemberTypeEncoder
            </summary>
        </member>
        <member name="T:C1.Util.Xml.Serialization.TypeSerializationAttribute">
            <summary>
            Forces the serializer to serialize the type name of a property or field
            </summary>
        </member>
        <member name="T:C1.Util.Xml.Serialization.CollectionElementTypeAttribute">
            <summary>
            This attribute allows to specify collection's element type name
            (in that case there is no need to store it).
            </summary>
        </member>
        <member name="T:C1.Util.Xml.Serialization.Serializer">
            <summary>
            Serializes and deserializes objects into and from XML.
            </summary>
            <remarks>
            All the methods in this class are static (Shared in Visual Basic).
            You cannot create an instance of this class.
            </remarks>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.IO.Stream,System.Object,System.Xml.Serialization.XmlSerializerNamespaces,System.Xml.XmlTextWriter@)">
            <summary>
            Serializes the specified Object and writes the XML-document instance to a file using the specified Stream. 
            DOES NOT close the underlying stream. Useful for copying objects.
            Caller is responsible to call out writer.Close() to close writer and underlying stream.
            </summary>
            <param name="stream">The Stream used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
            <param name="namespaces">The XmlSerializerNamespaces referenced by the object</param>
            <param name="writer">The XmlWriter object reference. Call writer.Close after working with stream/writer.</param> 
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.IO.Stream,System.Object,System.Xml.Serialization.XmlSerializerNamespaces)">
            <summary>
            Serializes the specified Object and writes the XML-document instance to a file using the specified Stream.
            </summary>
            <param name="stream">The Stream used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
            <param name="namespaces">The XmlSerializerNamespaces referenced by the object</param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.Xml.XmlTextWriter,System.Object,System.Xml.Serialization.XmlSerializerNamespaces)">
            <summary>
            Serializes the specified Object and writes the XML-document instance to a file using the specified XmlWriter
            </summary>
            <param name="writer">The XmlWriter used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
            <param name="namespaces">The XmlSerializerNamespaces referenced by the object</param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.IO.Stream,System.Object,System.Reflection.MemberInfo,System.Xml.Serialization.XmlSerializerNamespaces,System.Xml.XmlTextWriter@)">
            <summary>
            Serializes the specified Object and writes the XML-document instance to a file using the specified Stream. 
            DOES NOT close the underlying stream. Useful for copying objects.
            Caller is responsible to call out writer.Close() to close writer and underlying stream.
            </summary>
            <param name="stream">The Stream used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
            <param name="mi">The FieldInfo or MemberInfo object context for the object to serialize</param>
            <param name="namespaces">The XmlSerializerNamespaces referenced by the object</param>
            <param name="writer">The XmlWriter object reference. Call writer.Close after working with stream/writer.</param> 
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.IO.Stream,System.Object,System.Reflection.MemberInfo,System.Xml.Serialization.XmlSerializerNamespaces)">
            <summary>
            Serializes the specified Object and writes the XML-document instance to a file using the specified Stream.
            </summary>
            <param name="stream">The Stream used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
            <param name="mi">The FieldInfo or MemberInfo object context for the object to serialize</param>
            <param name="namespaces">The XmlSerializerNamespaces referenced by the object</param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.Xml.XmlTextWriter,System.Object,System.Reflection.MemberInfo,System.Xml.Serialization.XmlSerializerNamespaces)">
            <summary>
            Serializes the specified Object and writes the XML-document instance to a file using the specified XmlWriter
            </summary>
            <param name="writer">The XmlWriter used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
            <param name="mi">The FieldInfo or MemberInfo object context for the object to serialize</param>
            <param name="namespaces">The XmlSerializerNamespaces referenced by the object</param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Serialize(System.Object,System.Reflection.MemberInfo,System.Xml.Serialization.XmlSerializerNamespaces)">
            <summary>
            Serializes the specified object to an XML formatted string.
            </summary>
            <param name="o"></param>
            <param name="mi"></param>
            <param name="namespaces"></param>
            <returns></returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.writeNamespaces(System.Xml.XmlTextWriter,System.Xml.Serialization.XmlSerializerNamespaces)">
            <summary>
            Used to write the namespaces as attributes for the initial object
            </summary>
            <param name="writer"></param>
            <param name="namespaces"></param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.isVisible(System.Object[])">
            <summary>
            Given a list of Field or Property attributes returns visibility
            </summary>
            <param name="attributes"></param>
            <returns></returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.MapType(System.Xml.XmlTextWriter,System.Object)">
            <summary>
            Enumerates and serializes all public fields and properties
            </summary>
            <param name="writer">The XmlWriter used to write the XML-document instance</param>
            <param name="o">The Object to serialize</param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Deserialize(System.IO.Stream,System.Type)">
            <summary>
            Deserializes an XML-document instance
            </summary>
            <param name="stream">The Stream containing the XML-document instance to deserialize</param>
            <param name="type">The type of object being deserialized</param>
            <returns>The Object being deserialized</returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Deserialize(System.IO.Stream,System.Type,System.Type)">
            <summary>
            Deserializes an XML-document instance
            </summary>
            <param name="stream">The Stream containing the XML-document instance to deserialize</param>
            <param name="type">The type of object being deserialized</param>
            <param name="elementType">The type of array elements (in case the object is an array)</param>
            <returns>The Object being deserialized</returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Deserialize(System.Xml.XmlTextReader,System.Type)">
            <summary>
            Deserializes an XML-document instance
            </summary>
            <param name="reader">The XmlReader containing the XML-document instance to deserialize</param>
            <param name="type">The type of object being deserialized</param>
            <returns>The Object being deserialized</returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Deserialize(System.Xml.XmlTextReader,System.Object,System.Type,System.Type)">
            <summary>
            Deserializes object
            </summary>
            <param name="reader">The XmlReader containing the XML-document instance to deserialize</param>
            <param name="o">The Object being deserialized</param>
            <param name="type">The type of object being deserialized</param>
            <param name="elementType">The type of array elements (in case the object is an array)</param>
            <returns>The Object being deserialized</returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Deserialize(System.String,System.Type)">
            <summary>
            Deserializes an XML document string 
            </summary>
            <param name="text"></param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.Deserialize(System.String,System.Type,System.Type)">
            <summary>
            Deserializes an XML document string 
            </summary>
            <param name="text"></param>
            <param name="type"></param>
            <param name="elementType"></param>
            <returns></returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.DeserializeText(System.Xml.XmlTextReader,System.Type)">
            <summary>
            Deserializes text of element or attribute into object of appropriate type
            </summary>
            <param name="reader">The XmlReader containing the XML-document instance to deserialize</param>
            <param name="type">The type of object being deserialized</param>
            <returns>The Object being deserialized</returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.DeserializeType(System.Xml.XmlTextReader,System.Type,C1.Util.Xml.Serialization.IMemberTypeEncoder)">
            <summary>
            Recognizes type of object serialized in element
            </summary>
            <param name="reader">The XmlReader containing the XML-document instance to deserialize</param>
            <param name="type">The default type of object being deserialized</param>
            <param name="mte"></param>
            <returns>The type of object being deserialized</returns>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.DeserializeArray(System.Xml.XmlTextReader,System.Type,System.Collections.IList)">
            <summary>
            Deserializes array or collection
            </summary>
            <param name="reader">The XmlReader containing the XML-document instance to deserialize</param>
            <param name="elementType">Collection item type</param>
            <param name="container">The array or collection being deserialized</param>
        </member>
        <member name="M:C1.Util.Xml.Serialization.Serializer.GetAssemblyQualifiedTypeName(System.Type)">
            <summary>
            Returns the "almost" fully qualified type name - i.e. with assembly name,
            but without version, culture, and public key.
            </summary>
            <param name="type">Type</param>
            <returns>Type name, assembly name</returns>
        </member>
        <member name="P:C1.Util.Xml.Serialization.Serializer.OnLongOpInProgressProvider">
            <summary>
            Sets or returns the object implementing IOnLongOpInProgressProvider interface
            (can be used to provide visual feedback to the user during serialization).
            </summary>
        </member>
        <member name="P:C1.Util.Xml.Serialization.Serializer.Formatting">
            <summary>
            Sets or returns formatting used by the XML writer.
            </summary>
        </member>
        <member name="P:C1.Util.Xml.Serialization.Serializer.Indentation">
            <summary>
            Sets or returns indentation used by the XML writer.
            </summary>
        </member>
        <member name="P:C1.Util.Xml.Serialization.Serializer.NonPublic">
            <summary>
            Sets or returns serialization of non-public properties.  If true non-public properties
            are included, but are hidden by default. Public properties are always visible by default.
            </summary>
        </member>
    </members>
</doc>
