<?xml version="1.0"?>
<doc>
    <assembly>
        <name>libdb_dotnet48</name>
    </assembly>
    <members>
        <member name="T:BerkeleyDB.LSN">
            <summary>
            A log sequence number, which specifies a unique location in a log file.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LSN.LogFileNumber">
            <summary>
            The log file number.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LSN.Offset">
            <summary>
            The offset in the log file. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.LSN.#ctor(System.UInt32,System.UInt32)">
            <summary>
            Instantiate a new LSN object
            </summary>
            <param name="file">The log file number.</param>
            <param name="off">The offset in the log file.</param>
        </member>
        <member name="M:BerkeleyDB.LSN.Compare(BerkeleyDB.LSN,BerkeleyDB.LSN)">
            <summary>
            Compare two LSNs.
            </summary>
            <param name="lsn1">The first LSN to compare</param>
            <param name="lsn2">The second LSN to compare</param>
            <returns>
            0 if they are equal, 1 if lsn1 is greater than lsn2, and -1 if lsn1
            is less than lsn2.
            </returns>
        </member>
        <member name="T:BerkeleyDB.HashDatabase">
            <summary>
            A class representing a HashDatabase. The Hash format is an extensible,
            dynamic hashing scheme.
            </summary>
        </member>
        <member name="T:BerkeleyDB.Database">
            <summary>
            A class representing a Berkeley DB database, a base class for access
            method specific classes.
            </summary>
        </member>
        <member name="T:BerkeleyDB.BaseDatabase">
            <summary>
            The base class from which all database classes inherit
            </summary>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.#ctor(BerkeleyDB.DatabaseEnvironment,System.UInt32)">
            <summary>
            Protected constructor
            </summary>
            <param name="envp">
            The environment in which to create this database
            </param>
            <param name="flags">Flags to pass to the DB->create() method</param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.#ctor(BerkeleyDB.BaseDatabase)">
            <summary>
            Create a new database object with the same underlying DB handle as
            <paramref name="clone"/>.  Used during Database.Open to get an
            object of the correct DBTYPE.
            </summary>
            <param name="clone">Database to clone</param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Open(System.String,System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Protected factory method to create and open a new database object.
            </summary>
            <param name="Filename">The database's filename</param>
            <param name="DatabaseName">The subdatabase's name</param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            The transaction in which to open the database
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Close">
            <summary>
            Flush any cached database information to disk, close any open
            <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/> objects, free any
            allocated resources, and close any underlying files.
            </summary>
            <overloads>
            <para>
            Although closing a database will close any open cursors, it is
            recommended that applications explicitly close all their Cursor
            objects before closing the database. The reason why is that when the
            cursor is explicitly closed, the memory allocated for it is
            reclaimed; however, this will not happen if you close a database
            while cursors are still opened.
            </para>
            <para>
            The same rule, for the same reasons, hold true for
            <see cref="T:BerkeleyDB.Transaction"/> objects. Simply make sure you resolve
            all your transaction objects before closing your database handle.
            </para>
            <para>
            Because key/data pairs are cached in memory, applications should
            make a point to always either close database handles or sync their
            data to disk (using <see cref="M:BerkeleyDB.BaseDatabase.Sync"/> before exiting, to
            ensure that any data cached in main memory are reflected in the
            underlying file system.
            </para>
            <para>
            When called on a database that is the primary database for a
            secondary index, the primary database should be closed only after
            all secondary indices referencing it have been closed.
            </para>
            <para>
            When multiple threads are using the object concurrently, only a
            single thread may call the Close method.
            </para>
            <para>
            The object may not be accessed again after Close is called,
            regardless of its outcome.
            </para>
            </overloads>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Close(System.Boolean)">
            <summary>
            Optionally flush any cached database information to disk, close any
            open <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/> objects, free
            any allocated resources, and close any underlying files.
            </summary>
            <param name="sync">
            If false, do not flush cached information to disk.
            </param>
            <remarks>
            <para>
            The sync parameter is a dangerous option. It should be set to false 
            only if the application is doing logging (with transactions) so that
            the database is recoverable after a system or application crash, or
            if the database is always generated from scratch after any system or
            application crash.
            </para>
            <para>
            It is important to understand that flushing cached information to
            disk only minimizes the window of opportunity for corrupted data.
            Although unlikely, it is possible for database corruption to happen
            if a system or application crash occurs while writing data to the
            database. To ensure that database corruption never occurs,
            applications must either use transactions and logging with automatic
            recovery or edit a copy of the database, and once all applications
            using the database have successfully called Close, atomically
            replace the original database with the updated copy.
            </para>
            <para>
            Note that this parameter only works when the database has been
            opened using an environment. 
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Cursor">
            <summary>
            Create a database cursor.
            </summary>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Cursor(BerkeleyDB.CursorConfig)">
            <summary>
            Create a database cursor with the given configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Cursor(BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor.
            </summary>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Cursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor with the given
            configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Delete(BerkeleyDB.DatabaseEntry)">
            <summary>
            Remove key/data pairs from the database. The key/data pair
            associated with <paramref name="key"/> is discarded from the
            database. In the presence of duplicate key values, all records
            associated with the designated key will be discarded.
            </summary>
            <remarks>
            <para>
            When called on a secondary database, remove the key/data pair from
            the primary database and all secondary indices.
            </para>
            <para>
            If the operation occurs in a transactional database, the operation
            will be implicitly transaction protected.
            </para>
            </remarks>
            <param name="key">
            Discard the key/data pair associated with <paramref name="key"/>.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Delete(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Remove key/data pairs from the database. The key/data pair
            associated with <paramref name="key"/> is discarded from the
            database. In the presence of duplicate key values, all records
            associated with the designated key will be discarded.
            </summary>
            <remarks>
            <para>
            When called on a secondary database, remove the key/data pair from
            the primary database and all secondary indices.
            </para>
            <para>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </para>
            </remarks>
            <param name="key">
            Discard the key/data pair associated with <paramref name="key"/>.
            </param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Exists(BerkeleyDB.DatabaseEntry)">
            <summary>
            Check whether <paramref name="key"/> appears in the database.
            </summary>
            <remarks>
            If the operation occurs in a transactional database, the operation
            will be implicitly transaction protected.
            </remarks>
            <param name="key">The key to search for.</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            True if <paramref name="key"/> appears in the database, false
            otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Exists(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Check whether <paramref name="key"/> appears in the database.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="key">The key to search for.</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            True if <paramref name="key"/> appears in the database, false
            otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Exists(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            Check whether <paramref name="key"/> appears in the database.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="key">The key to search for.</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            True if <paramref name="key"/> appears in the database, false
            otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry)">
            <summary>
            Retrieve a key/data pair from the database.  In the presence of
            duplicate key values, Get will return the first data item for 
            <paramref name="key"/>.
            </summary>
            <remarks>
            If the operation occurs in a transactional database, the operation
            will be implicitly transaction protected.
            </remarks>
            <param name="key">The key to search for</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Retrieve a key/data pair from the database.  In the presence of
            duplicate key values, Get will return the first data item for 
            <paramref name="key"/>.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="key">The key to search for</param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            Retrieve a key/data pair from the database.  In the presence of
            duplicate key values, Get will return the first data item for 
            <paramref name="key"/>.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="key">The key to search for</param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo,System.UInt32)">
            <summary>
            Protected method to retrieve data from the underlying DB handle.
            </summary>
            <param name="key">
            The key to search for.  If null a new DatabaseEntry is created.
            </param>
            <param name="data">
            The data to search for.  If null a new DatabaseEntry is created.
            </param>
            <param name="txn">The txn for this operation.</param>
            <param name="info">Locking info for this operation.</param>
            <param name="flags">
            Flags value specifying which type of get to perform.  Passed
            directly to DB-&gt;get().
            </param>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.GetBoth(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
            <summary>
            Retrieve a key/data pair from the database which matches
            <paramref name="key"/> and <paramref name="data"/>.
            </summary>
            <remarks>
            If the operation occurs in a transactional database, the operation
            will be implicitly transaction protected.
            </remarks>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is
            <paramref name="data"/>.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.GetBoth(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Retrieve a key/data pair from the database which matches
            <paramref name="key"/> and <paramref name="data"/>.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is
            <paramref name="data"/>.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.GetBoth(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            Retrieve a key/data pair from the database which matches
            <paramref name="key"/> and <paramref name="data"/>.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is
            <paramref name="data"/>.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.PrintFastStats">
            <summary>
            Display the database statistical information which does not require
            traversal of the database. 
            </summary>
            <remarks>
            Among other things, this method makes it possible for applications
            to request key and record counts without incurring the performance
            penalty of traversing the entire database. 
            </remarks>
            <overloads>
            The statistical information is described by the
            <see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
            <see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes. 
            </overloads>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.PrintFastStats(System.Boolean)">
            <summary>
            Display the database statistical information which does not require
            traversal of the database. 
            </summary>
            <remarks>
            Among other things, this method makes it possible for applications
            to request key and record counts without incurring the performance
            penalty of traversing the entire database. 
            </remarks>
            <param name="PrintAll">
            If true, display all available information.
            </param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.PrintStats">
            <summary>
            Display the database statistical information.
            </summary>
            <overloads>
            The statistical information is described by the
            <see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
            <see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes. 
            </overloads>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.PrintStats(System.Boolean)">
            <summary>
            Display the database statistical information.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Remove(System.String)">
            <summary>
            Remove the underlying file represented by
            <paramref name="Filename"/>, incidentally removing all of the
            databases it contained.
            </summary>
            <param name="Filename">The file to remove</param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Remove(System.String,BerkeleyDB.DatabaseEnvironment)">
            <summary>
            Remove the underlying file represented by
            <paramref name="Filename"/>, incidentally removing all of the
            databases it contained.
            </summary>
            <param name="Filename">The file to remove</param>
            <param name="DbEnv">
            The DatabaseEnvironment the database belongs to
            </param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Remove(System.String,System.String)">
            <summary>
            Remove the database specified by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <param name="Filename">The file to remove</param>
            <param name="DatabaseName">The database to remove</param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Remove(System.String,System.String,BerkeleyDB.DatabaseEnvironment)">
            <summary>
            Remove the database specified by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <overloads>
            <para>
            Applications should never remove databases with open DB handles, or
            in the case of removing a file, when any database in the file has an
            open handle. For example, some architectures do not permit the
            removal of files with open system handles. On these architectures,
            attempts to remove databases currently in use by any thread of
            control in the system may fail.
            </para>
            <para>
            Remove should not be called if the remove is intended to be
            transactionally safe;
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.Boolean)"/> should be
            used instead. 
            </para>
            </overloads>
            <param name="Filename">The file to remove</param>
            <param name="DatabaseName">The database to remove</param>
            <param name="DbEnv">
            The DatabaseEnvironment the database belongs to
            </param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String)">
            <summary>
            Rename the underlying file represented by
            <paramref name="Filename"/>, incidentally renaming all of the
            databases it contained.
            </summary>
            <param name="Filename">The file to rename</param>
            <param name="NewName">The new filename</param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String,BerkeleyDB.DatabaseEnvironment)">
            <summary>
            Rename the underlying file represented by
            <paramref name="Filename"/>, incidentally renaming all of the
            databases it contained.
            </summary>
            <param name="Filename">The file to rename</param>
            <param name="NewName">The new filename</param>
            <param name="DbEnv">
            The DatabaseEnvironment the database belongs to
            </param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String,System.String)">
            <summary>
            Rename the database specified by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <param name="Filename">The file to rename</param>
            <param name="DatabaseName">The database to rename</param>
            <param name="NewName">The new database name</param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String,System.String,BerkeleyDB.DatabaseEnvironment)">
            <summary>
            Rename the database specified by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <overloads>
            <para>
            Applications should not rename databases that are currently in use.
            If an underlying file is being renamed and logging is currently
            enabled in the database environment, no database in the file may be
            open when Rename is called. In particular, some architectures do not
            permit renaming files with open handles. On these architectures,
            attempts to rename databases that are currently in use by any thread
            of control in the system may fail. 
            </para>
            <para>
            Rename should not be called if the rename is intended to be
            transactionally safe;
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.Boolean)"/> should be
            used instead. 
            </para>
            </overloads>
            <param name="Filename">The file to rename</param>
            <param name="DatabaseName">The database to rename</param>
            <param name="NewName">The new database name</param>
            <param name="DbEnv">
            The DatabaseEnvironment the database belongs to
            </param>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Sync">
            <summary>
            Flush any cached information to disk.
            </summary>
            <remarks>
            <para>
            If the database is in memory only, Sync has no effect and will
            always succeed.
            </para>
            <para>
            It is important to understand that flushing cached information to
            disk only minimizes the window of opportunity for corrupted data.
            Although unlikely, it is possible for database corruption to happen
            if a system or application crash occurs while writing data to the
            database. To ensure that database corruption never occurs, 
            applications must either: use transactions and logging with
            automatic recovery or edit a copy of the database, and once all
            applications using the database have successfully called
            <see cref="M:BerkeleyDB.BaseDatabase.Close"/>, atomically replace
            the original database with the updated copy.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Truncate">
             <summary>
             Empty the database, discarding all records it contains.
             </summary>
             <remarks>
             If the operation occurs in a transactional database, the operation
             will be implicitly transaction protected.
             </remarks>
             <overloads>
             When called on a database configured with secondary indices, 
             Truncate will truncate the primary database and all secondary
             indices. A count of the records discarded from the primary database
             is returned. 
             </overloads>
             <returns>
             The number of records discarded from the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Truncate(BerkeleyDB.Transaction)">
             <summary>
             Empty the database, discarding all records it contains.
             </summary>
             <remarks>
             If <paramref name="txn"/> is null and the operation occurs in a
             transactional database, the operation will be implicitly transaction
             protected.
             </remarks>
             <param name="txn">
             <paramref name="txn"/> is a Transaction object returned from
             <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
             the operation is part of a Berkeley DB Concurrent Data Store group,
             <paramref name="txn"/> is a handle returned from
             <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
             </param>
             <returns>
             The number of records discarded from the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseDatabase.Dispose">
            <summary>
            Release the resources held by this object, and close the database if
            it's still open.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.AutoCommit">
            <summary>
            If true, all database modification operations based on this object
            will be transactionally protected.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.CacheSize">
            <summary>
            The size of the shared memory buffer pool -- that is, the cache.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Creation">
            <summary>
            The CreatePolicy with which this database was opened.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.DatabaseName">
            <summary>
            The name of this database, if it has one.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.DoChecksum">
            <summary>
            If true, do checksum verification of pages read into the cache from
            the backing filestore.
            </summary>
            <remarks>
            Berkeley DB uses the SHA1 Secure Hash Algorithm if encryption is
            configured and a general hash algorithm if it is not.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.EncryptAlgorithm">
            <summary>
            The algorithm used by the Berkeley DB library to perform encryption
            and decryption. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Encrypted">
            <summary>
            If true, encrypt all data stored in the database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Endianness">
            <summary>
            The database byte order.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.ErrorFeedback">
            <summary>
            The mechanism for reporting detailed error messages to the
            application.
            </summary>
            <remarks>
            <para>
            When an error occurs in the Berkeley DB library, a
            <see cref="T:BerkeleyDB.DatabaseException"/>, or subclass of DatabaseException,
            is thrown. In some cases, however, the exception may be insufficient
            to completely describe the cause of the error, especially during
            initial application debugging.
            </para>
            <para>
            In some cases, when an error occurs, Berkeley DB will call the given
            delegate with additional error information. It is up to the delegate
            to display the error message in an appropriate manner.
            </para>
            <para>
            Setting ErrorFeedback to NULL unconfigures the callback interface.
            </para>
            <para>
            This error-logging enhancement does not slow performance or
            significantly increase application size, and may be run during
            normal operation as well as during application debugging.
            </para>
            <para>
            For databases opened inside of a DatabaseEnvironment, setting
            ErrorFeedback affects the entire environment and is equivalent to
            setting DatabaseEnvironment.ErrorFeedback.
            </para>
            <para>
            For databases not opened in an environment, setting ErrorFeedback
            configures operations performed using the specified object, not all
            operations performed on the underlying database. 
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.ErrorPrefix">
            <summary>
            The prefix string that appears before error messages issued by
            Berkeley DB.
            </summary>
            <remarks>
            <para>
            For databases opened inside of a DatabaseEnvironment, setting
            ErrorPrefix affects the entire environment and is equivalent to
            setting <see cref="P:BerkeleyDB.DatabaseEnvironment.ErrorPrefix"/>.
            </para>
            <para>
            Setting ErrorPrefix configures operations performed using the
            specified object, not all operations performed on the underlying
            database. 
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Feedback">
            <summary>
            Monitor progress within long running operations.
            </summary>
            <remarks>
            <para>
            Some operations performed by the Berkeley DB library can take
            non-trivial amounts of time. The Feedback delegate can be used by
            applications to monitor progress within these operations. When an
            operation is likely to take a long time, Berkeley DB will call the
            specified delegate with progress information.
            </para>
            <para>
            It is up to the delegate to display this information in an
            appropriate manner. 
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.FileName">
            <summary>
            The filename of this database, if it has one.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.FreeThreaded">
            <summary>
            If true, the object is free-threaded; that is, concurrently usable
            by multiple threads in the address space. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.HasMultiple">
            <summary>
            If true, the object references a physical file supporting multiple
            databases.
            </summary>
            <remarks>
            If true, the object is a handle on a database whose key values are
            the names of the databases stored in the physical file and whose
            data values are opaque objects. No keys or data values may be
            modified or stored using the database handle. 
            </remarks>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.InHostOrder">
            <summary>
            If true, the underlying database files were created on an
            architecture of the same byte order as the current one.  This
            information may be used to determine whether application data needs
            to be adjusted for this architecture or not. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.NoMMap">
            <summary>
            <para>
            If true, this database is not mapped into process memory.
            </para>
            <para>
            See <see cref="P:BerkeleyDB.DatabaseEnvironment.MMapSize"/> for further
            information. 
            </para>
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.NonDurableTxns">
            <summary>
            If true, Berkeley DB will not write log records for this database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Pagesize">
            <summary>
            The database's current page size.
            </summary>
            <remarks>  If <see cref="P:BerkeleyDB.DatabaseConfig.PageSize"/> was not set by
            your application, then the default pagesize is selected based on the
            underlying filesystem I/O block size.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Priority">
            <summary>
            The cache priority for pages referenced by this object.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.ReadOnly">
            <summary>
            If true, this database has been opened for reading only. Any attempt
            to modify items in the database will fail, regardless of the actual
            permissions of any underlying files. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.ReadUncommitted">
            <summary>
            If true, this database supports transactional read operations with
            degree 1 isolation. Read operations on the database may request the
            return of modified but not yet committed data.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Transactional">
            <summary>
            If true, this database has been opened in a transactional mode.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Truncated">
            <summary>
            If true, the underlying file was physically truncated upon open,
            discarding all previous databases it might have held.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.Type">
            <summary>
            The type of the underlying access method (and file format). This
            value may be used to determine the type of the database after an
            <see cref="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)"/>. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BaseDatabase.UseMVCC">
            <summary>
            If true, the database was opened with support for multiversion
            concurrency control.
            </summary>
        </member>
        <member name="M:BerkeleyDB.Database.#ctor(BerkeleyDB.DatabaseEnvironment,System.UInt32)">
            <summary>
            Protected constructor
            </summary>
            <param name="env">
            The environment in which to create this database
            </param>
            <param name="flags">Flags to pass to the DB->create() method</param>
        </member>
        <member name="M:BerkeleyDB.Database.#ctor(BerkeleyDB.BaseDatabase)">
            <summary>
            Create a new database object with the same underlying DB handle as
            <paramref name="clone"/>.  Used during Database.Open to get an
            object of the correct DBTYPE.
            </summary>
            <param name="clone">Database to clone</param>
        </member>
        <member name="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)">
            <summary>
            Instantiate a new Database object and open the database represented
            by <paramref name="Filename"/>. The file specified by
            <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.Database.Open(System.String,System.String,BerkeleyDB.DatabaseConfig)">
            <summary>
            Instantiate a new Database object and open the database represented
            by <paramref name="Filename"/> and <paramref name="DatabaseName"/>.
            The file specified by <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null and 
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.</param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new Database object and open the database represented
            by <paramref name="Filename"/>. The file specified by
            <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.Database.Open(System.String,System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new Database object and open the database represented
            by <paramref name="Filename"/> and <paramref name="DatabaseName"/>. 
            The file specified by <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
            <summary>
            If a key/data pair in the database matches <paramref name="key"/>
            and <paramref name="data"/>, return the key and all duplicate data
            items.
            </summary>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)">
            <summary>
            If a key/data pair in the database matches <paramref name="key"/>
            and <paramref name="data"/>, return the key and all duplicate data
            items.
            </summary>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <param name="BufferSize">
            The initial size of the buffer to fill with duplicate data items. If
            the buffer is not large enough, it will be automatically resized.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction)">
            <summary>
            If a key/data pair in the database matches <paramref name="key"/>
            and <paramref name="data"/>, return the key and all duplicate data
            items.
            </summary>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <param name="BufferSize">
            The initial size of the buffer to fill with duplicate data items. If
            the buffer is not large enough, it will be automatically resized.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            If a key/data pair in the database matches <paramref name="key"/>
            and <paramref name="data"/>, return the key and all duplicate data
            items.
            </summary>
            <param name="key">The key to search for</param>
            <param name="data">The data to search for</param>
            <param name="BufferSize">
            The initial size of the buffer to fill with duplicate data items. If
            the buffer is not large enough, it will be automatically resized.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> and
            <paramref name="data"/> are not in the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry)">
            <summary>
            Retrieve a key and all duplicate data items from the database.
            </summary>
            <param name="key">The key to search for</param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry,System.Int32)">
            <summary>
            Retrieve a key and all duplicate data items from the database.
            </summary>
            <param name="key">The key to search for</param>
            <param name="BufferSize">
            The initial size of the buffer to fill with duplicate data items. If
            the buffer is not large enough, it will be automatically resized.
            </param>
            <exception cref="T:BerkeleyDB.NotFoundException">
            A NotFoundException is thrown if <paramref name="key"/> is not in
            the database. 
            </exception>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            A KeyEmptyException is thrown if the database is a
            <see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/> 
            database and <paramref name="key"/> exists, but was never explicitly
            created by the application or was later deleted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction)">
            <summary>
            Retrieve a key and all duplicate data items from the database.
            </summary>
            <param name="key">The key to search for</param>
            <param name="BufferSize">
            The initial size of the buffer to fill with duplicate data items. If
            the buffer is not large enough, it will be automatically resized.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            Retrieve a key and all duplicate data items from the database.
            </summary>
            <param name="key">The key to search for</param>
            <param name="BufferSize">
            The initial size of the buffer to fill with duplicate data items. If
            the buffer is not large enough, it will be automatically resized.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            whose Key parameter is <paramref name="key"/> and whose Value
            parameter is the retrieved data items.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)">
            <summary>
            Create a specialized join cursor for use in performing equality or
            natural joins on secondary indices.
            </summary>
            <remarks>
            <para>
            Once the cursors have been passed as part of <paramref name="lst"/>,
            they should not be accessed or modified until the newly created
            <see cref="T:BerkeleyDB.JoinCursor"/>has been closed, or else inconsistent
            results may be returned.
            </para>
            <para>
            Joined values are retrieved by doing a sequential iteration over the
            first cursor in <paramref name="lst"/>, and a nested iteration over
            each secondary cursor in the order they are specified in the
            curslist parameter. This requires database traversals to search for
            the current datum in all the cursors after the first. For this
            reason, the best join performance normally results from sorting the
            cursors from the one that refers to the least number of data items
            to the one that refers to the most.
            </para>
            </remarks>
            <param name="lst">
            An array of SecondaryCursors. Each cursor must have been initialized
            to refer to the key on which the underlying database should be
            joined.
            </param>
            <param name="sortCursors">
            If true, sort the cursors from the one that refers to the least
            number of data items to the one that refers to the most.  If the
            data are structured so that cursors with many data items also share
            many common elements, higher performance will result from listing
            those cursors before cursors with fewer data items; that is, a sort
            order other than the default. A setting of false permits
            applications to perform join optimization prior to calling Join.
            </param>
            <returns>
            A specialized join cursor for use in performing equality or natural
            joins on secondary indices.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
            <summary>
            Store the key/data pair in the database, replacing any previously
            existing key if duplicates are disallowed, or adding a duplicate
            data item if duplicates are allowed.
            </summary>
            <overloads>
            <para>
            If the database supports duplicates, add the new data value at the
            end of the duplicate set. If the database supports sorted
            duplicates, the new data value is inserted at the correct sorted
            location.
            </para>
            </overloads>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
        </member>
        <member name="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Store the key/data pair in the database, replacing any previously
            existing key if duplicates are disallowed, or adding a duplicate
            data item if duplicates are allowed.
            </summary>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.PutNoOverwrite(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
            <summary>
            Store the key/data pair in the database, only if the key does not
            already appear in the database.
            </summary>
            <remarks>
            This enforcement of uniqueness of keys applies only to the primary
            key, the behavior of insertions into secondary databases is not
            affected. In particular, the insertion of a record that would result
            in the creation of a duplicate key in a secondary database that
            allows duplicates would not be prevented by the use of this flag.
            </remarks>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
        </member>
        <member name="M:BerkeleyDB.Database.PutNoOverwrite(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Store the key/data pair in the database, only if the key does not
            already appear in the database.
            </summary>
            <remarks>
            This enforcement of uniqueness of keys applies only to the primary
            key, the behavior of insertions into secondary databases is not
            affected. In particular, the insertion of a record that would result
            in the creation of a duplicate key in a secondary database that
            allows duplicates would not be prevented by the use of this flag.
            </remarks>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,System.UInt32)">
            <summary>
            Protected wrapper for DB->put.  Used by subclasses for access method
            specific operations.
            </summary>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
            <param name="txn">Transaction with which to protect the put</param>
            <param name="flags">Flags to pass to DB->put</param>
        </member>
        <member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig)">
            <summary>
            Write the key/data pairs from all databases in the file to 
            <see cref="P:System.Console.Out"/>. Key values are written for Btree, Hash
            and Queue databases, but not for Recno databases.
            </summary>
            <param name="file">
            The physical file in which the databases to be salvaged are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be salvaged.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean)">
            <summary>
            Write the key/data pairs from all databases in the file to 
            <see cref="P:System.Console.Out"/>. Key values are written for Btree, Hash
            and Queue databases, but not for Recno databases.
            </summary>
            <param name="file">
            The physical file in which the databases to be salvaged are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be salvaged.
            </param>
            <param name="Printable">
            If true and characters in either the key or data items are printing
            characters (as defined by isprint(3)), use printing characters to
            represent them. This setting permits users to use standard text
            editors and tools to modify the contents of databases or selectively
            remove data from salvager output. 
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.IO.TextWriter)">
            <summary>
            Write the key/data pairs from all databases in the file to 
            <paramref name="OutputStream"/>. Key values are written for Btree,
            Hash and Queue databases, but not for Recno databases.
            </summary>
            <param name="file">
            The physical file in which the databases to be salvaged are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be salvaged.
            </param>
            <param name="OutputStream">
            The TextWriter to which the databases' key/data pairs are written.
            If null, <see cref="P:System.Console.Out"/> will be used.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean,System.IO.TextWriter)">
            <summary>
            Write the key/data pairs from all databases in the file to 
            <paramref name="OutputStream"/>. Key values are written for Btree,
            Hash and Queue databases, but not for Recno databases.
            </summary>
            <param name="file">
            The physical file in which the databases to be salvaged are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be salvaged.
            </param>
            <param name="Printable">
            If true and characters in either the key or data items are printing
            characters (as defined by isprint(3)), use printing characters to
            represent them. This setting permits users to use standard text
            editors and tools to modify the contents of databases or selectively
            remove data from salvager output. 
            </param>
            <param name="OutputStream">
            The TextWriter to which the databases' key/data pairs are written.
            If null, <see cref="P:System.Console.Out"/> will be used.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean,System.Boolean)">
            <summary>
            Write the key/data pairs from all databases in the file to 
            <see cref="P:System.Console.Out"/>. Key values are written for Btree, Hash
            and Queue databases, but not for Recno databases.
            </summary>
            <param name="file">
            The physical file in which the databases to be salvaged are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be salvaged.
            </param>
            <param name="Printable">
            If true and characters in either the key or data items are printing
            characters (as defined by isprint(3)), use printing characters to
            represent them. This setting permits users to use standard text
            editors and tools to modify the contents of databases or selectively
            remove data from salvager output. 
            </param>
            <param name="Aggressive">
            If true, output all the key/data pairs in the file that can be
            found.  Corruption will be assumed and key/data pairs that are
            corrupted or have been deleted may appear in the output (even if the
            file being salvaged is in no way corrupt), and the output will
            almost certainly require editing before being loaded into a
            database.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean,System.Boolean,System.IO.TextWriter)">
            <summary>
            Write the key/data pairs from all databases in the file to 
            <paramref name="OutputStream"/>. Key values are written for Btree,
            Hash and Queue databases, but not for Recno databases.
            </summary>
            <param name="file">
            The physical file in which the databases to be salvaged are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be salvaged.
            </param>
            <param name="Printable">
            If true and characters in either the key or data items are printing
            characters (as defined by isprint(3)), use printing characters to
            represent them. This setting permits users to use standard text
            editors and tools to modify the contents of databases or selectively
            remove data from salvager output. 
            </param>
            <param name="Aggressive">
            If true, output all the key/data pairs in the file that can be
            found.  Corruption will be assumed and key/data pairs that are
            corrupted or have been deleted may appear in the output (even if the
            file being salvaged is in no way corrupt), and the output will
            almost certainly require editing before being loaded into a
            database.
            </param>
            <param name="OutputStream">
            The TextWriter to which the databases' key/data pairs are written.
            If null, <see cref="P:System.Console.Out"/> will be used.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Upgrade(System.String,BerkeleyDB.DatabaseConfig)">
            <summary>
            Upgrade all of the databases included in the file
            <paramref name="file"/>, if necessary. If no upgrade is necessary,
            Upgrade always returns successfully.
            </summary>
            <param name="file">
            The physical file containing the databases to be upgraded.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be upgraded.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Upgrade(System.String,BerkeleyDB.DatabaseConfig,System.Boolean)">
            <summary>
            Upgrade all of the databases included in the file
            <paramref name="file"/>, if necessary. If no upgrade is necessary,
            Upgrade always returns successfully.
            </summary>
            <overloads>
            Database upgrades are done in place and are destructive. For
            example, if pages need to be allocated and no disk space is
            available, the database may be left corrupted. Backups should be
            made before databases are upgraded. See Upgrading databases in the
            Programmer's Reference Guide for more information.
            </overloads>
            <remarks>
            <para>
            As part of the upgrade from the Berkeley DB 3.0 release to the 3.1
            release, the on-disk format of duplicate data items changed. To
            correctly upgrade the format requires applications to specify
            whether duplicate data items in the database are sorted or not.
            Specifying <paramref name="dupSortUpgraded"/> informs Upgrade that
            the duplicates are sorted; otherwise they are assumed to be
            unsorted. Incorrectly specifying the value of this flag may lead to
            database corruption.
            </para>
            <para>
            Further, because this method upgrades a physical file (including all
            the databases it contains), it is not possible to use Upgrade to
            upgrade files in which some of the databases it includes have sorted
            duplicate data items, and some of the databases it includes have
            unsorted duplicate data items. If the file does not have more than a
            single database, if the databases do not support duplicate data
            items, or if all of the databases that support duplicate data items
            support the same style of duplicates (either sorted or unsorted), 
            Upgrade will work correctly as long as
            <paramref name="dupSortUpgraded"/> is correctly specified.
            Otherwise, the file cannot be upgraded using Upgrade it must be
            upgraded manually by dumping and reloading the databases.
            </para>
            </remarks>
            <param name="file">
            The physical file containing the databases to be upgraded.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be upgraded.
            </param>
            <param name="dupSortUpgraded">
            If true, the duplicates in the upgraded database are sorted;
            otherwise they are assumed to be unsorted.  This setting is only 
            meaningful when upgrading databases from releases before the
            Berkeley DB 3.1 release.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Verify(System.String,BerkeleyDB.DatabaseConfig)">
            <summary>
            Verify the integrity of all databases in the file specified by 
            <paramref name="file"/>.
            </summary>
            <overloads>
            Verify does not perform any locking, even in Berkeley DB
            environments that are configured with a locking subsystem. As such,
            it should only be used on files that are not being modified by
            another thread of control.
            </overloads>
            <param name="file">
            The physical file in which the databases to be verified are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be verified.
            </param>
        </member>
        <member name="M:BerkeleyDB.Database.Verify(System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Database.VerifyOperation)">
            <summary>
            Verify the integrity of all databases in the file specified by 
            <paramref name="file"/>.
            </summary>
            <remarks>
            <para>
            Berkeley DB normally verifies that btree keys and duplicate items
            are correctly sorted, and hash keys are correctly hashed. If the
            file being verified contains multiple databases using differing
            sorting or hashing algorithms, some of them must necessarily fail
            database verification because only one sort order or hash function
            can be specified in <paramref name="cfg"/>. To verify files with
            multiple databases having differing sorting orders or hashing
            functions, first perform verification of the file as a whole by
            using <see cref="F:BerkeleyDB.Database.VerifyOperation.NO_ORDER_CHECK"/>, and then
            individually verify the sort order and hashing function for each
            database in the file using
            <see cref="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY"/>.
            </para>
            </remarks>
            <param name="file">
            The physical file in which the databases to be verified are found.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be verified.
            </param>
            <param name="op">The extent of verification</param>
        </member>
        <member name="M:BerkeleyDB.Database.Verify(System.String,System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Database.VerifyOperation)">
            <summary>
            Verify the integrity of the database specified by 
            <paramref name="file"/> and <paramref name="database"/>.
            </summary>
            <remarks>
            <para>
            Berkeley DB normally verifies that btree keys and duplicate items
            are correctly sorted, and hash keys are correctly hashed. If the
            file being verified contains multiple databases using differing
            sorting or hashing algorithms, some of them must necessarily fail
            database verification because only one sort order or hash function
            can be specified in <paramref name="cfg"/>. To verify files with
            multiple databases having differing sorting orders or hashing
            functions, first perform verification of the file as a whole by
            using <see cref="F:BerkeleyDB.Database.VerifyOperation.NO_ORDER_CHECK"/>, and then
            individually verify the sort order and hashing function for each
            database in the file using
            <see cref="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY"/>.
            </para>
            </remarks>
            <param name="file">
            The physical file in which the databases to be verified are found.
            </param>
            <param name="database">
            The database in <paramref name="file"/> on which the database checks
            for btree and duplicate sort order and for hashing are to be
            performed.  A non-null value for database is only allowed with
            <see cref="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY"/>.
            </param>
            <param name="cfg">
            Configuration parameters for the databases to be verified.
            </param>
            <param name="op">The extent of verification</param>
        </member>
        <member name="T:BerkeleyDB.Database.VerifyOperation">
            <summary>
            Specifies the type of verification to perform
            </summary>
        </member>
        <member name="F:BerkeleyDB.Database.VerifyOperation.DEFAULT">
            <summary>
            Perform database checks and check sort order
            </summary>
        </member>
        <member name="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY">
            <summary>
            Perform the database checks for btree and duplicate sort order
            and for hashing
            </summary>
        </member>
        <member name="F:BerkeleyDB.Database.VerifyOperation.NO_ORDER_CHECK">
            <summary>
            Skip the database checks for btree and duplicate sort order and
            for hashing. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)">
            <summary>
            Instantiate a new HashDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Open(System.String,System.String,BerkeleyDB.HashDatabaseConfig)">
            <summary>
            Instantiate a new HashDatabase object and open the database
            represented by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new HashDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Open(System.String,System.String,BerkeleyDB.HashDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new HashDatabase object and open the database
            represented by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Cursor">
            <summary>
            Create a database cursor.
            </summary>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Cursor(BerkeleyDB.CursorConfig)">
            <summary>
            Create a database cursor with the given configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Cursor(BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor.
            </summary>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Cursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor with the given
            configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.FastStats">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.FastStats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.FastStats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <overloads>
            <para>
            Among other things, this method makes it possible for applications
            to request key and record counts without incurring the performance
            penalty of traversing the entire database. 
            </para>
            <para>
            The statistical information is described by the
            <see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
            <see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes. 
            </para>
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.TruncateUnusedPages">
            <summary>
            Return pages to the filesystem that are already free and at the end
            of the file.
            </summary>
            <returns>
            The number of database pages returned to the filesystem
            </returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.TruncateUnusedPages(BerkeleyDB.Transaction)">
            <summary>
            Return pages to the filesystem that are already free and at the end
            of the file.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The number of database pages returned to the filesystem
            </returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
            <summary>
            Store the key/data pair in the database only if it does not already
            appear in the database. 
            </summary>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Store the key/data pair in the database only if it does not already
            appear in the database. 
            </summary>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Stats">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Stats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.HashDatabase.Stats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <overloads>
            The statistical information is described by
            <see cref="T:BerkeleyDB.BTreeStats"/>. 
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="P:BerkeleyDB.HashDatabase.Compare">
            <summary>
            The Hash key comparison function. The comparison function is called
            whenever it is necessary to compare a key specified by the
            application with a key currently stored in the tree. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashDatabase.DupCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashDatabase.Duplicates">
            <summary>
            Whether the insertion of duplicate data items in the database is
            permitted, and whether duplicates items are sorted.
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashDatabase.FillFactor">
            <summary>
            The desired density within the hash table.
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashDatabase.HashFunction">
            <summary>
            A user-defined hash function; if no hash function is specified, a
            default hash function is used. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashDatabase.TableSize">
            <summary>
            An estimate of the final size of the hash table.
            </summary>
        </member>
        <member name="T:BerkeleyDB.DatabaseEnvironment">
            <summary>
            A class representing a Berkeley DB database environment - a collection
            including support for some or all of caching, locking, logging and
            transaction subsystems, as well as databases and log files.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepSetClockskew(System.UInt32,System.UInt32)">
            <summary>
            Set the clock skew ratio among replication group members based on
            the fastest and slowest measurements among the group for use with
            master leases.
            </summary>
            <remarks>
            <para>
            Calling this method is optional, the default values for clock skew
            assume no skew. The user must also configure leases via
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepUseMasterLeases"/>. Additionally, the user must also
            set the master lease timeout via <see cref="P:BerkeleyDB.DatabaseEnvironment.RepLeaseTimeout"/> and
            the number of sites in the replication group via
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/>. These settings may be configured in any
            order. For a description of the clock skew values, see Clock skew 
            in the Berkeley DB Programmer's Reference Guide. For a description
            of master leases, see Master leases in the Berkeley DB Programmer's
            Reference Guide.
            </para>
            <para>
            These arguments can be used to express either raw measurements of a
            clock timing experiment or a percentage across machines. For
            instance a group of sites have a 2% variance, then
            <paramref name="fast"/> should be set to 102, and
            <paramref name="slow"/> should be set to 100. Or, for a 0.03%
            difference, you can use 10003 and 10000 respectively.
            </para>
            </remarks>
            <param name="fast">
            The value, relative to <paramref name="slow"/>, of the fastest clock
            in the group of sites.
            </param>
            <param name="slow">
            The value of the slowest clock in the group of sites.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepSetRetransmissionRequest(System.UInt32,System.UInt32)">
            <summary>
            Set a threshold for the minimum and maximum time that a client waits
            before requesting retransmission of a missing message.
            </summary>
            <remarks>
            <para>
            If the client detects a gap in the sequence of incoming log records
            or database pages, Berkeley DB will wait for at least
            <paramref name="min"/> microseconds before requesting retransmission
            of the missing record. Berkeley DB will double that amount before
            requesting the same missing record again, and so on, up to a
            maximum threshold of <paramref name="max"/> microseconds.
            </para>
            <para>
            These values are thresholds only. Since Berkeley DB has no thread
            available in the library as a timer, the threshold is only checked
            when a thread enters the Berkeley DB library to process an incoming
            replication message. Any amount of time may have passed since the
            last message arrived and Berkeley DB only checks whether the amount
            of time since a request was made is beyond the threshold value or
            not.
            </para>
            <para>
            By default the minimum is 40000 and the maximum is 1280000 (1.28
            seconds). These defaults are fairly arbitrary and the application
            likely needs to adjust these. The values should be based on expected
            load and performance characteristics of the master and client host
            platforms and transport infrastructure as well as round-trip message
            time.
            </para></remarks>
            <param name="min">
            The minimum number of microseconds a client waits before requesting
            retransmission.
            </param>
            <param name="max">
            The maximum number of microseconds a client waits before requesting
            retransmission.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepSetTransmitLimit(System.UInt32,System.UInt32)">
            <summary>
            Set a byte-count limit on the amount of data that will be
            transmitted from a site in response to a single message processed by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>. The limit is not a hard limit, and
            the record that exceeds the limit is the last record to be sent. 
            </summary>
            <remarks>
            <para>
            Record transmission throttling is turned on by default with a limit
            of 10MB.
            </para>
            <para>
            If both <paramref name="GBytes"/> and <paramref name="Bytes"/> are
            zero, then the transmission limit is turned off.
            </para>
            </remarks>
            <param name="GBytes">
            The number of gigabytes which, when added to
            <paramref name="Bytes"/>, specifies the maximum number of bytes that
            will be sent in a single call to <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </param>
            <param name="Bytes">
            The number of bytes which, when added to 
            <paramref name="GBytes"/>, specifies the maximum number of bytes
            that will be sent in a single call to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepSetTransport(System.Int32,BerkeleyDB.ReplicationTransportDelegate)">
            <summary>
            Initialize the communication infrastructure for a database
            environment participating in a replicated application.
            </summary>
            <remarks>
            RepSetTransport is not called by most replication applications. It
            should only be called by applications implementing their own network
            transport layer, explicitly holding replication group elections and
            handling replication messages outside of the replication manager
            framework.
            </remarks>
            <param name="envid">
            The local environment's ID. It must be a non-negative integer and
            uniquely identify this Berkeley DB database environment (see
            Replication environment IDs in the Programmer's Reference Guide for
            more information).
            </param>
            <param name="transport">
            The delegate used to transmit data using the replication
            application's communication infrastructure.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)">
            <summary>
            Instantiate a new DatabaseEnvironment object and open the Berkeley
            DB environment represented by <paramref name="home"/>.
            </summary>
            <param name="home">
            The database environment's home directory.  For more information on
            home, and filename resolution in general, see Berkeley DB File
            Naming in the Programmer's Reference Guide.
            </param>
            <param name="cfg">The environment's configuration</param>
            <returns>A new, open DatabaseEnvironment object</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Remove(System.String)">
            <summary>
            Destroy a Berkeley DB environment if it is not currently in use.
            </summary>
            <overloads>
            <para>
            The environment regions, including any backing files, are removed.
            Any log or database files and the environment directory are not
            removed.
            </para>
            <para>
            If there are processes that have called <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> without
            calling <see cref="M:BerkeleyDB.DatabaseEnvironment.Close"/> (that is, there are processes currently
            using the environment), Remove will fail without further action.
            </para>
            <para>
            Calling Remove should not be necessary for most applications because
            the Berkeley DB environment is cleaned up as part of normal database
            recovery procedures. However, applications may want to call Remove
            as part of application shut down to free up system resources. For
            example, if <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.SystemMemory"/> was
            specified to <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/>, it may be useful to call Remove in
            order to release system shared memory segments that have been
            allocated. Or, on architectures in which mutexes require allocation
            of underlying system resources, it may be useful to call Remove in
            order to release those resources. Alternatively, if recovery is not
            required because no database state is maintained across failures,
            and no system resources need to be released, it is possible to clean
            up an environment by simply removing all the Berkeley DB files in
            the database environment's directories.
            </para>
            <para>
            In multithreaded applications, only a single thread may call Remove.
            </para>
            </overloads>
            <param name="db_home">
            The database environment to be removed.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Remove(System.String,System.Boolean)">
            <summary>
            Destroy a Berkeley DB environment if it is not currently in use.
            </summary>
            <remarks>
            <para>
            Generally, <paramref name="force"/> is specified only when
            applications were unable to shut down cleanly, and there is a risk
            that an application may have died holding a Berkeley DB lock.)
            </para>
            <para>
            The result of attempting to forcibly destroy the environment when it
            is in use is unspecified. Processes using an environment often
            maintain open file descriptors for shared regions within it. On UNIX
            systems, the environment removal will usually succeed, and processes
            that have already joined the region will continue to run in that
            region without change. However, processes attempting to join the
            environment will either fail or create new regions. On other systems
            in which the unlink(2) system call will fail if any process has an
            open file descriptor for the file (for example Windows/NT), the
            region removal will fail.
            </para>
            </remarks>
            <param name="db_home">
            The database environment to be removed.
            </param>
            <param name="force">
            If true, the environment is removed, regardless of any processes
            that may still using it, and no locks are acquired during this
            process.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection">
            <summary>
            Hold an election for the master of a replication group.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection(System.UInt32)">
            <summary>
            Hold an election for the master of a replication group.
            </summary>
            <param name="nsites">
            The number of replication sites expected to participate in the
            election. Once the current site has election information from that
            many sites, it will short-circuit the election and immediately cast
            its vote for a new master. This parameter must be no less than
            <paramref name="nvotes"/>, or 0 if the election should use
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/>. If an application is using master leases,
            then the value must be 0 and <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/> must be used.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection(System.UInt32,System.UInt32)">
            <summary>
            Hold an election for the master of a replication group.
            </summary>
            <overloads>
            <para>
            RepHoldElection is not called by most replication applications. It
            should only be called by applications implementing their own network
            transport layer, explicitly holding replication group elections and
            handling replication messages outside of the replication manager
            framework.
            </para>
            <para>
            If the election is successful, Berkeley DB will notify the
            application of the results of the election by means of either the 
            <see cref="F:BerkeleyDB.NotificationEvent.REP_ELECTED"/> or 
            <see cref="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER"/> events (see 
            <see cref="P:BerkeleyDB.DatabaseEnvironment.EventNotify"/>for more information). The application is
            responsible for adjusting its relationship to the other database
            environments in the replication group, including directing all
            database updates to the newly selected master, in accordance with
            the results of the election.
            </para>
            <para>
            The thread of control that calls RepHoldElection must not be the
            thread of control that processes incoming messages; processing the
            incoming messages is necessary to successfully complete an election.
            </para>
            <para>
            Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate 
            must already have been configured to send replication messages.
            </para>
            </overloads>
            <param name="nsites">
            The number of replication sites expected to participate in the
            election. Once the current site has election information from that
            many sites, it will short-circuit the election and immediately cast
            its vote for a new master. This parameter must be no less than
            <paramref name="nvotes"/>, or 0 if the election should use
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/>. If an application is using master leases,
            then the value must be 0 and <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/> must be used.
            </param>
            <param name="nvotes">
            The minimum number of replication sites from which the current site
            must have election information, before the current site will cast a
            vote for a new master. This parameter must be no greater than
            <paramref name="nsites"/>, or 0 if the election should use the value
            ((<paramref name="nsites"/> / 2) + 1).
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress)">
            <summary>
            Add a new replication site to the replication manager's list of
            known sites. It is not necessary for all sites in a replication
            group to know about all other sites in the group. 
            </summary>
            <param name="Host">The remote site's address</param>
            <returns>The environment ID assigned to the remote site</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress,System.Boolean)">
            <summary>
            Add a new replication site to the replication manager's list of
            known sites. It is not necessary for all sites in a replication
            group to know about all other sites in the group. 
            </summary>
            <remarks>
            Currently, the replication manager framework only supports a single
            client peer, and the last specified peer is used.
            </remarks>
            <param name="Host">The remote site's address</param>
            <param name="isPeer">
            If true, configure client-to-client synchronization with the
            specified remote site.
            </param>
            <returns>The environment ID assigned to the remote site</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)">
            <summary>
            Start the replication manager as a client site, and do not call for
            an election.
            </summary>
            <overloads>
            <para>
            There are two ways to build Berkeley DB replication applications:
            the most common approach is to use the Berkeley DB library
            "replication manager" support, where the Berkeley DB library manages
            the replication group, including network transport, all replication
            message processing and acknowledgment, and group elections.
            Applications using the replication manager support generally make
            the following calls:
            </para>
            <list type="number">
            <item>
            Configure the local site in the replication group,
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrLocalSite"/>.
            </item>
            <item>
            Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress)"/> to configure the remote
            site(s) in the replication group.
            </item>
            <item>Configure the message acknowledgment policy
            (<see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrAckPolicy"/>) which provides the replication group's
            transactional needs.
            </item>
            <item>
            Configure the local site's election priority,
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepPriority"/>.
            </item>
            <item>
            Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/> or
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/> to start the replication
            application.
            </item>
            </list>
            <para>
            For more information on building replication manager applications,
            please see the Replication Getting Started Guide included in the
            Berkeley DB documentation.
            </para>
            <para>
            Applications with special needs (for example, applications using
            network protocols not supported by the Berkeley DB replication
            manager), must perform additional configuration and call other
            Berkeley DB replication methods. For more information on building
            advanced replication applications, please see the Base Replication
            API section in the Berkeley DB Programmer's Reference Guide for more
            information.
            </para>
            <para>
            Starting the replication manager consists of opening the TCP/IP
            listening socket to accept incoming connections, and starting all
            necessary background threads. When multiple processes share a
            database environment, only one process can open the listening
            socket; <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/> (and
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/>) automatically open the socket in
            the first process to call it, and skips this step in the later calls
            from other processes.
            </para>
            </overloads>
            <param name="nthreads">
            Specify the number of threads of control created and dedicated to
            processing replication messages. In addition to these message
            processing threads, the replication manager creates and manages a
            few of its own threads of control.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32,System.Boolean)">
            <summary>
            Start the replication manager as a client site, and optionally call
            for an election.
            </summary>
            <param name="nthreads">
            Specify the number of threads of control created and dedicated to
            processing replication messages. In addition to these message
            processing threads, the replication manager creates and manages a
            few of its own threads of control.
            </param>
            <param name="holdElection">
            If true, start as a client, and call for an election if no master is
            found.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)">
            <summary>
            Start the replication manager as a master site, and do not call for
            an election.
            </summary>
            <remarks>
            <para>
            There are two ways to build Berkeley DB replication applications:
            the most common approach is to use the Berkeley DB library
            "replication manager" support, where the Berkeley DB library manages
            the replication group, including network transport, all replication
            message processing and acknowledgment, and group elections.
            Applications using the replication manager support generally make
            the following calls:
            </para>
            <list type="number">
            <item>
            Configure the local site in the replication group,
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrLocalSite"/>.
            </item>
            <item>
            Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress)"/> to configure the remote
            site(s) in the replication group.
            </item>
            <item>Configure the message acknowledgment policy
            (<see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrAckPolicy"/>) which provides the replication group's
            transactional needs.
            </item>
            <item>
            Configure the local site's election priority,
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepPriority"/>.
            </item>
            <item>
            Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/> or
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/> to start the replication
            application.
            </item>
            </list>
            <para>
            For more information on building replication manager applications,
            please see the Replication Getting Started Guide included in the
            Berkeley DB documentation.
            </para>
            <para>
            Applications with special needs (for example, applications using
            network protocols not supported by the Berkeley DB replication
            manager), must perform additional configuration and call other
            Berkeley DB replication methods. For more information on building
            advanced replication applications, please see the Base Replication
            API section in the Berkeley DB Programmer's Reference Guide for more
            information.
            </para>
            <para>
            Starting the replication manager consists of opening the TCP/IP
            listening socket to accept incoming connections, and starting all
            necessary background threads. When multiple processes share a
            database environment, only one process can open the listening
            socket; <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/> (and
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/>) automatically open the socket in
            the first process to call it, and skips this step in the later calls
            from other processes.
            </para>
            </remarks>
            <param name="nthreads">
            Specify the number of threads of control created and dedicated to
            processing replication messages. In addition to these message
            processing threads, the replication manager creates and manages a
            few of its own threads of control.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)">
            <summary>
            Process an incoming replication message sent by a member of the
            replication group to the local database environment. 
            </summary>
            <remarks>
            <para>
            RepProcessMessage is not called by most replication applications. It
            should only be called by applications implementing their own network
            transport layer, explicitly holding replication group elections and
            handling replication messages outside of the replication manager
            framework.
            </para>
            <para>
            For implementation reasons, all incoming replication messages must
            be processed using the same <see cref="T:BerkeleyDB.DatabaseEnvironment"/>
            object. It is not required that a single thread of control process
            all messages, only that all threads of control processing messages
            use the same object.
            </para>
            <para>
            Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate 
            must already have been configured to send replication messages.
            </para>
            </remarks>
            <param name="control">
            A copy of the control parameter specified by Berkeley DB on the
            sending environment.
            </param>
            <param name="rec">
            A copy of the rec parameter specified by Berkeley DB on the sending
            environment.
            </param>
            <param name="envid">
            The local identifier that corresponds to the environment that sent
            the message to be processed (see Replication environment IDs in the
            Programmer's Reference Guide for more information)..
            </param>
            <returns>The result of processing a message</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepStartClient">
            <summary>
            Configure the database environment as a client in a group of
            replicated database environments.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepStartClient(BerkeleyDB.DatabaseEntry)">
            <summary>
            Configure the database environment as a client in a group of
            replicated database environments.
            </summary>
            <overloads>
            <para>
            RepStartClient is not called by most replication applications. It
            should only be called by applications implementing their own network
            transport layer, explicitly holding replication group elections and
            handling replication messages outside of the replication manager
            framework.
            </para>
            <para>
            Replication master environments are the only database environments
            where replicated databases may be modified. Replication client
            environments are read-only as long as they are clients. Replication
            client environments may be upgraded to be replication master
            environments in the case that the current master fails or there is
            no master present. If master leases are in use, this method cannot
            be used to appoint a master, and should only be used to configure a
            database environment as a master as the result of an election.
            </para>
            <para>
            Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate 
            must already have been configured to send replication messages.
            </para>
            </overloads>
            <param name="cdata">
            An opaque data item that is sent over the communication
            infrastructure when the client comes online (see Connecting to a new
            site in the Programmer's Reference Guide for more information). If
            no such information is useful, cdata should be null.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster">
            <summary>
            Configure the database environment as a master in a group of
            replicated database environments.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster(BerkeleyDB.DatabaseEntry)">
            <summary>
            Configure the database environment as a master in a group of
            replicated database environments.
            </summary>
            <overloads>
            <para>
            RepStartMaster is not called by most replication applications. It
            should only be called by applications implementing their own network
            transport layer, explicitly holding replication group elections and
            handling replication messages outside of the replication manager
            framework.
            </para>
            <para>
            Replication master environments are the only database environments
            where replicated databases may be modified. Replication client
            environments are read-only as long as they are clients. Replication
            client environments may be upgraded to be replication master
            environments in the case that the current master fails or there is
            no master present. If master leases are in use, this method cannot
            be used to appoint a master, and should only be used to configure a
            database environment as a master as the result of an election.
            </para>
            <para>
            Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate 
            must already have been configured to send replication messages.
            </para>
            </overloads>
            <param name="cdata">
            An opaque data item that is sent over the communication
            infrastructure when the client comes online (see Connecting to a new
            site in the Programmer's Reference Guide for more information). If
            no such information is useful, cdata should be null.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepSync">
            <summary>
            Force master synchronization to begin for this client.
            </summary>
            <remarks>
            <para>
            This method is the other half of setting
            <see cref="P:BerkeleyDB.DatabaseEnvironment.RepDelayClientSync"/>.
            </para>
            <para>
            If an application has configured delayed master synchronization, the
            application must synchronize explicitly (otherwise the client will
            remain out-of-date and will ignore all database changes forwarded
            from the replication group master). RepSync may be called any time
            after the client application learns that the new master has been
            established (by receiving
            <see cref="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER"/>).
            </para>
            <para>
            Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate 
            must already have been configured to send replication messages.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.ArchivableLogFiles(System.Boolean)">
            <summary>
            The names of all of the log files that are no longer in use (for
            example, that are no longer involved in active transactions), and
            that may safely be archived for catastrophic recovery and then
            removed from the system.
            </summary>
            <remarks>
            <para>
            The Berkeley DB interfaces to the database environment logging
            subsystem (for example, <see cref="M:BerkeleyDB.Transaction.Abort"/>) may
            allocate log cursors and have open file descriptors for log files
            as well. On operating systems where filesystem related system calls
            (for example, rename and unlink on Windows/NT) can fail if a process
            has an open file descriptor for the affected file, attempting to
            move or remove the log files listed by ArchivableLogFiles may fail.
            All Berkeley DB internal use of log cursors operates on active log
            files only and furthermore, is short-lived in nature. So, an
            application seeing such a failure should be restructured to retry
            the operation until it succeeds. (Although this is not likely to be
            necessary; it is hard to imagine a reason to move or rename a log
            file in which transactions are being logged or aborted.)
            </para>
            <para>
            See the db_archive utility for more information on database archival
            procedures.
            </para>
            </remarks>
            <param name="AbsolutePaths">
            If true, all pathnames are returned as absolute pathnames, instead 
            of relative to the database home directory.
            </param>
            <returns>
            The names of all of the log files that are no longer in use
            </returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.ArchivableDatabaseFiles(System.Boolean)">
            <summary>
            The database files that need to be archived in order to recover the
            database from catastrophic failure. If any of the database files
            have not been accessed during the lifetime of the current log files,
            they will not included in this list. It is also possible that some
            of the files referred to by the log have since been deleted from the
            system. 
            </summary>
            <remarks>
            <para>
            See the db_archive utility for more information on database archival
            procedures.
            </para>
            </remarks>
            <param name="AbsolutePaths">
            If true, all pathnames are returned as absolute pathnames, instead 
            of relative to the database home directory.
            </param>
            <returns>
            The database files that need to be archived in order to recover the
            database from catastrophic failure.
            </returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LogFiles(System.Boolean)">
            <summary>
            The names of all of the log files
            </summary>
            <remarks>
            <para>
            The Berkeley DB interfaces to the database environment logging
            subsystem (for example, <see cref="M:BerkeleyDB.Transaction.Abort"/>) may
            allocate log cursors and have open file descriptors for log files
            as well. On operating systems where filesystem related system calls
            (for example, rename and unlink on Windows/NT) can fail if a process
            has an open file descriptor for the affected file, attempting to
            move or remove the log files listed by LogFiles may fail. All
            Berkeley DB internal use of log cursors operates on active log files
            only and furthermore, is short-lived in nature. So, an application
            seeing such a failure should be restructured to retry the operation
            until it succeeds. (Although this is not likely to be necessary; it
            is hard to imagine a reason to move or rename a log file in which
            transactions are being logged or aborted.)
            </para>
            <para>
            See the db_archive utility for more information on database archival
            procedures.
            </para>
            </remarks>
            <param name="AbsolutePaths">
            If true, all pathnames are returned as absolute pathnames, instead 
            of relative to the database home directory.
            </param>
            <returns>
            All the log filenames, regardless of whether or not they are in use.
            </returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RemoveUnusedLogFiles">
            <summary>
            Remove log files that are no longer needed. Automatic log file
            removal is likely to make catastrophic recovery impossible. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup">
            <summary>
            Allocate a locker ID in an environment configured for Berkeley DB
            Concurrent Data Store applications.
            </summary>
            <remarks>
            <para>
            Calling <see cref="M:BerkeleyDB.Transaction.Commit"/> will discard the allocated
            locker ID.
            </para>
            <para>
            See Berkeley DB Concurrent Data Store applications in the
            Programmer's Reference Guide for more information about when this is
            required.
            </para>
            </remarks>
            <returns>
            A Transaction object that uniquely identifies the locker ID
            </returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction">
            <summary>
            Create a new transaction in the environment, with the default 
            configuration.
            </summary>
            <returns>A new transaction object</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction(BerkeleyDB.TransactionConfig)">
            <summary>
            Create a new transaction in the environment.
            </summary>
            <param name="cfg">
            The configuration properties for the transaction
            </param>
            <returns>A new transaction object</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction(BerkeleyDB.TransactionConfig,BerkeleyDB.Transaction)">
            <summary>
            Create a new transaction in the environment.
            </summary>
            <remarks>
            In the presence of distributed transactions and two-phase commit,
            only the parental transaction, that is a transaction without a
            parent specified, should be passed as an parameter to 
            <see cref="M:BerkeleyDB.Transaction.Prepare(System.Byte[])"/>.
            </remarks>
            <param name="cfg">
            The configuration properties for the transaction
            </param>
            <param name="parent">
            If the non-null, the new transaction will be a nested transaction,
            with <paramref name="parent"/> as the new transaction's parent.
            Transactions may be nested to any level.
            </param>
            <returns>A new transaction object</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Checkpoint">
            <summary>
            Flush the underlying memory pool, write a checkpoint record to the
            log, and then flush the log, even if there has been no activity
            since the last checkpoint.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Checkpoint(System.UInt32,System.UInt32)">
            <summary>
            If there has been any logging activity in the database environment
            since the last checkpoint, flush the underlying memory pool, write a
            checkpoint record to the log, and then flush the log.
            </summary>
            <param name="kbytesWritten">
            A checkpoint will be done if more than kbytesWritten kilobytes of
            log data have been written since the last checkpoint.
            </param>
            <param name="minutesElapsed">
            A checkpoint will be done if more than minutesElapsed minutes have
            passed since the last checkpoint.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Close">
            <summary>
            Close the Berkeley DB environment, freeing any allocated resources
            and closing any underlying subsystems. 
            </summary>
            <remarks>
            <para>
            The object should not be closed while any other handle that refers
            to it is not yet closed; for example, database environment handles
            must not be closed while database objects remain open, or
            transactions in the environment have not yet been committed or
            aborted.
            </para>
            <para>
            Where the environment was configured with
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/>, calling Close
            aborts any unresolved transactions. Applications should not depend
            on this behavior for transactions involving Berkeley DB databases;
            all such transactions should be explicitly resolved. The problem
            with depending on this semantic is that aborting an unresolved
            transaction involving database operations requires a database
            handle. Because the database handles should have been closed before
            calling Close, it will not be possible to abort the transaction, and
            recovery will have to be run on the Berkeley DB environment before
            further operations are done.
            </para>
            <para>
            In multithreaded applications, only a single thread may call Close.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.DetectDeadlocks(BerkeleyDB.DeadlockPolicy)">
            <summary>
            Run one iteration of the deadlock detector. The deadlock detector
            traverses the lock table and marks one of the participating lock
            requesters for rejection in each deadlock it finds.
            </summary>
            <param name="atype">Specify which lock request(s) to reject</param>
            <returns>The number of lock requests that were rejected.</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.FailCheck">
            <summary>
            Check for threads of control (either a true thread or a process)
            that have exited while manipulating Berkeley DB library data
            structures, while holding a logical database lock, or with an
            unresolved transaction (that is, a transaction that was never
            aborted or committed).
            </summary>
            <remarks>
            <para>
            For more information, see Architecting Data Store and Concurrent
            Data Store applications, and Architecting Transactional Data Store
            applications, both in the Berkeley DB Programmer's Reference Guide.
            </para>
            <para>
            FailCheck is based on the <see cref="P:BerkeleyDB.DatabaseEnvironment.SetThreadID"/> and
            <see cref="P:BerkeleyDB.DatabaseEnvironment.ThreadIsAlive"/> delegates. Applications calling
            FailCheck must have already set <see cref="P:BerkeleyDB.DatabaseEnvironment.ThreadIsAlive"/>, and
            must have configured <see cref="P:BerkeleyDB.DatabaseEnvironment.ThreadCount"/>.
            </para>
            <para>
            If FailCheck determines a thread of control exited while holding
            database read locks, it will release those locks. If FailCheck
            determines a thread of control exited with an unresolved
            transaction, the transaction will be aborted. In either of these
            cases, FailCheck will return successfully and the application may
            continue to use the database environment.
            </para>
            <para>
            In either of these cases, FailCheck will also report the process and
            thread IDs associated with any released locks or aborted
            transactions. The information is printed to a specified output
            channel (see <see cref="!:MessageFile"/> for more information), or
            passed to an application delegate (see <see cref="!:MessageCall"/> for
            more information).
            </para>
            <para>
            If FailCheck determines a thread of control has exited such that
            database environment recovery is required, it will throw
            <see cref="T:BerkeleyDB.RunRecoveryException"/>. In this case, the application
            should not continue to use the database environment. For a further
            description as to the actions the application should take when this
            failure occurs, see Handling failure in Data Store and Concurrent
            Data Store applications, and Handling failure in Transactional Data
            Store applications, both in the Berkeley DB Programmer's Reference
            Guide.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LogFile(BerkeleyDB.LSN)">
            <summary>
            Map an LSN object to a log filename
            </summary>
            <param name="logSeqNum">
            The DB_LSN structure for which a filename is wanted.
            </param>
            <returns>
            The name of the file containing the record named by
            <paramref name="logSeqNum"/>.
            </returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LogFlush">
            <summary>
            Write all log records to disk.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LogFlush(BerkeleyDB.LSN)">
            <summary>
            Write log records to disk.
            </summary>
            <param name="logSeqNum">
            All log records with LSN values less than or equal to
            <paramref name="logSeqNum"/> are written to disk. If null, all
            records in the log are flushed.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LogWrite(BerkeleyDB.DatabaseEntry,System.Boolean)">
            <summary>
            Append a record to the log
            </summary>
            <param name="dbt">The record to write to the log.</param>
            <param name="flush">
            If true, the log is forced to disk after this record is written,
            guaranteeing that all records with LSN values less than or equal to
            the one being "put" are on disk before LogWrite returns.
            </param>
            <returns>The LSN of the written record</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Panic">
            <summary>
            Set the panic state for the database environment. (Database
            environments in a panic state normally refuse all attempts to call
            Berkeley DB functions, throwing <see cref="T:BerkeleyDB.RunRecoveryException"/>.)
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)">
            <summary>
            Restore transactions that were prepared, but not yet resolved at the
            time of the system shut down or crash, to their state prior to the
            shut down or crash, including any locks previously held.
            </summary>
            <remarks>
            Calls to Recover from different threads of control should not be
            intermixed in the same environment.
            </remarks>
            <param name="count">
            The maximum number of <see cref="T:BerkeleyDB.PreparedTransaction"/> objects
            to return.
            </param>
            <param name="resume">
            If true, continue returning a list of prepared, but not yet resolved
            transactions, starting where the last call to Recover left off.  If 
            false, begins a new pass over all prepared, but not yet completed
            transactions, regardless of whether they have already been returned
            in previous calls to Recover.
            </param>
            <returns>A list of the prepared transactions</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.Boolean)">
            <summary>
            Remove the underlying file represented by <paramref name="file"/>,
            incidentally removing all of the databases it contained.
            </summary>
            <param name="file">The physical file to be removed.</param>
            <param name="autoCommit">
            If true, enclose RemoveDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.String,System.Boolean)">
            <summary>
            Remove the database specified by <paramref name="file"/> and
            <paramref name="database"/>.  If no database is specified, the
            underlying file represented by <paramref name="file"/> is removed,
            incidentally removing all of the databases it contained.
            </summary>
            <param name="file">
            The physical file which contains the database(s) to be removed.
            </param>
            <param name="database">The database to be removed.</param>
            <param name="autoCommit">
            If true, enclose RemoveDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.Boolean,BerkeleyDB.Transaction)">
            <summary>
            Remove the underlying file represented by <paramref name="file"/>,
            incidentally removing all of the databases it contained.
            </summary>
            <param name="file">The physical file to be removed.</param>
            <param name="autoCommit">
            If true, enclose RemoveDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.  If
            null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
            is true, the operation will be implicitly transaction protected. 
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.String,System.Boolean,BerkeleyDB.Transaction)">
            <summary>
            Remove the database specified by <paramref name="file"/> and
            <paramref name="database"/>.  If no database is specified, the
            underlying file represented by <paramref name="file"/> is removed,
            incidentally removing all of the databases it contained.
            </summary>
            <param name="file">
            The physical file which contains the database(s) to be removed.
            </param>
            <param name="database">The database to be removed.</param>
            <param name="autoCommit">
            If true, enclose RemoveDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.  If
            null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
            is true, the operation will be implicitly transaction protected. 
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.Boolean)">
            <summary>
            Rename the underlying file represented by <paramref name="file"/>
            using the value supplied to <paramref name="newname"/>, incidentally
            renaming all of the databases it contained.
            </summary>
            <param name="file">The physical file to be renamed.</param>
            <param name="newname">The new name of the database or file.</param>
            <param name="autoCommit">
            If true, enclose RenameDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.String,System.Boolean)">
            <summary>
            Rename the database specified by <paramref name="file"/> and
            <paramref name="database"/> to <paramref name="newname"/>. If no
            database is specified, the underlying file represented by
            <paramref name="file"/> is renamed using the value supplied to
            <paramref name="newname"/>, incidentally renaming all of the
            databases it contained.
            </summary>
            <param name="file">
            The physical file which contains the database(s) to be renamed.
            </param>
            <param name="database">The database to be renamed.</param>
            <param name="newname">The new name of the database or file.</param>
            <param name="autoCommit">
            If true, enclose RenameDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.Boolean,BerkeleyDB.Transaction)">
            <summary>
            Rename the underlying file represented by <paramref name="file"/>
            using the value supplied to <paramref name="newname"/>, incidentally
            renaming all of the databases it contained.
            </summary>
            <param name="file">The physical file to be renamed.</param>
            <param name="newname">The new name of the database or file.</param>
            <param name="autoCommit">
            If true, enclose RenameDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.  If
            null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
            is true, the operation will be implicitly transaction protected. 
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.String,System.Boolean,BerkeleyDB.Transaction)">
            <summary>
            Rename the database specified by <paramref name="file"/> and
            <paramref name="database"/> to <paramref name="newname"/>. If no
            database is specified, the underlying file represented by
            <paramref name="file"/> is renamed using the value supplied to
            <paramref name="newname"/>, incidentally renaming all of the
            databases it contained.
            </summary>
            <param name="file">
            The physical file which contains the database(s) to be renamed.
            </param>
            <param name="database">The database to be renamed.</param>
            <param name="newname">The new name of the database or file.</param>
            <param name="autoCommit">
            If true, enclose RenameDB within a transaction. If the call
            succeeds, changes made by the operation will be recoverable. If the
            call fails, the operation will have made no changes.
            </param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.  If
            null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
            is true, the operation will be implicitly transaction protected. 
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.ResetFileID(System.String,System.Boolean)">
            <summary>
            Allow database files to be copied, and then the copy used in the
            same database environment as the original.
            </summary>
            <remarks>
            <para>
            All databases contain an ID string used to identify the database in
            the database environment cache. If a physical database file is
            copied, and used in the same environment as another file with the
            same ID strings, corruption can occur. ResetFileID creates new ID
            strings for all of the databases in the physical file.
            </para>
            <para>
            ResetFileID modifies the physical file, in-place. Applications
            should not reset IDs in files that are currently in use.
            </para>
            </remarks>
            <param name="file">
            The name of the physical file in which new file IDs are to be created.
            </param>
            <param name="encrypted">
            If true, he file contains encrypted databases.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.ResetLSN(System.String,System.Boolean)">
            <summary>
            Allow database files to be moved from one transactional database
            environment to another. 
            </summary>
            <remarks>
            <para>
            Database pages in transactional database environments contain
            references to the environment's log files (that is, log sequence
            numbers, or <see cref="T:BerkeleyDB.LSN"/>s). Copying or moving a database file
            from one database environment to another, and then modifying it, can
            result in data corruption if the LSNs are not first cleared.
            </para>
            <para>
            Note that LSNs should be reset before moving or copying the database
            file into a new database environment, rather than moving or copying
            the database file and then resetting the LSNs. Berkeley DB has
            consistency checks that may be triggered if an application calls 
            ResetLSN on a database in a new environment when the database LSNs
            still reflect the old environment.
            </para>
            <para>
            The ResetLSN method modifies the physical file, in-place.
            Applications should not reset LSNs in files that are currently in
            use.
            </para>
            </remarks>
            <param name="file"></param>
            <param name="encrypted"></param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.SetMaxSequentialWrites(System.Int32,System.UInt32)">
            <summary>
            Limit the number of sequential write operations scheduled by the
            library when flushing dirty pages from the cache.
            </summary>
            <param name="maxWrites">
            The maximum number of sequential write operations scheduled by the
            library when flushing dirty pages from the cache, or 0 if there is
            no limitation on the number of sequential write operations.
            </param>
            <param name="pause">
            The number of microseconds the thread of control should pause before
            scheduling further write operations. It must be specified as an
            unsigned 32-bit number of microseconds, limiting the maximum pause
            to roughly 71 minutes.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.SyncMemPool">
            <summary>
            Flush all modified pages in the cache to their backing files. 
            </summary>
            <remarks>
            Pages in the cache that cannot be immediately written back to disk
            (for example, pages that are currently in use by another thread of
            control) are waited for and written to disk as soon as it is
            possible to do so.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.SyncMemPool(BerkeleyDB.LSN)">
            <summary>
            Flush modified pages in the cache with log sequence numbers less 
            than <paramref name="minLSN"/> to their backing files. 
            </summary>
            <remarks>
            Pages in the cache that cannot be immediately written back to disk
            (for example, pages that are currently in use by another thread of
            control) are waited for and written to disk as soon as it is
            possible to do so.
            </remarks>
            <param name="minLSN">
            All modified pages with a log sequence number less than the minLSN
            parameter are written to disk. If null, all modified pages in the
            cache are written to disk.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.TrickleCleanMemPool(System.Int32)">
            <summary>
            Ensure that a specified percent of the pages in the cache are clean,
            by writing dirty pages to their backing files. 
            </summary>
            <param name="pctClean">
            The percent of the pages in the cache that should be clean.
            </param>
            <returns>
            The number of pages written to reach the specified percentage is
            copied.
            </returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.WriteToLog(System.String)">
            <summary>
            Append an informational message to the Berkeley DB database
            environment log files. 
            </summary>
            <overloads>
            WriteToLog allows applications to include information in the
            database environment log files, for later review using the
            db_printlog  utility. This method is intended for debugging and
            performance tuning.
            </overloads>
            <param name="str">The message to append to the log files</param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.WriteToLog(System.String,BerkeleyDB.Transaction)">
            <summary>
            Append an informational message to the Berkeley DB database
            environment log files. 
            </summary>
            <overloads>
            WriteToLog allows applications to include information in the
            database environment log files, for later review using the
            db_printlog  utility. This method is intended for debugging and
            performance tuning.
            </overloads>
            <param name="str">The message to append to the log files</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; 
            otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LockingSystemStats">
            <summary>
            The locking subsystem statistics
            </summary>
            <returns>The locking subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LockingSystemStats(System.Boolean)">
            <summary>
            The locking subsystem statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The locking subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LoggingSystemStats">
            <summary>
            The logging subsystem statistics
            </summary>
            <returns>The logging subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.LoggingSystemStats(System.Boolean)">
            <summary>
            The logging subsystem statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The logging subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.MPoolSystemStats">
            <summary>
            The memory pool (that is, the buffer cache) subsystem statistics
            </summary>
            <returns>The memory pool subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.MPoolSystemStats(System.Boolean)">
            <summary>
            The memory pool (that is, the buffer cache) subsystem statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The memory pool subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.MutexSystemStats">
            <summary>
            The mutex subsystem statistics
            </summary>
            <returns>The mutex subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.MutexSystemStats(System.Boolean)">
            <summary>
            The mutex subsystem statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The mutex subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrSystemStats">
            <summary>
            The replication manager statistics
            </summary>
            <returns>The replication manager statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrSystemStats(System.Boolean)">
            <summary>
            The replication manager statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The replication manager statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.ReplicationSystemStats">
            <summary>
            The replication subsystem statistics
            </summary>
            <returns>The replication subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.ReplicationSystemStats(System.Boolean)">
            <summary>
            The replication subsystem statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The replication subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats">
            <summary>
            The transaction subsystem statistics
            </summary>
            <returns>The transaction subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats(System.Boolean)">
            <summary>
            The transaction subsystem statistics
            </summary>
            <param name="clearStats">
            If true, reset statistics after returning their values.
            </param>
            <returns>The transaction subsystem statistics</returns>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintLockingSystemStats">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintLockingSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintLockingSystemStats(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
            <param name="ConflictMatrix">
            If true, display the lock conflict matrix.
            </param>
            <param name="Lockers">
            If true, Display the lockers within hash chains.
            </param>
            <param name="Objects">
            If true, display the lock objects within hash chains.
            </param>
            <param name="Parameters">
            If true, display the locking subsystem parameters.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintLoggingSystemStats">
            <summary>
            Display the logging subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LogStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintLoggingSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the logging subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LogStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintMPoolSystemStats">
            <summary>
            Display the memory pool (that is, buffer cache) subsystem
            statistical information, as described by <see cref="T:BerkeleyDB.MPoolStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintMPoolSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the memory pool (that is, buffer cache) subsystem
            statistical information, as described by <see cref="T:BerkeleyDB.MPoolStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintMPoolSystemStats(System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Display the memory pool (that is, buffer cache) subsystem
            statistical information, as described by <see cref="T:BerkeleyDB.MPoolStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
            <param name="HashChains">
            If true, display the buffers with hash chains.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintMutexSystemStats">
            <summary>
            Display the mutex subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.MutexStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintMutexSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the mutex subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.MutexStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintRepMgrSystemStats">
            <summary>
            Display the replication manager statistical information, as
            described by <see cref="T:BerkeleyDB.RepMgrStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintRepMgrSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the replication manager statistical information, as
            described by <see cref="T:BerkeleyDB.RepMgrStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintReplicationSystemStats">
            <summary>
            Display the replication subsystem statistical information, as
            described by <see cref="T:BerkeleyDB.ReplicationStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintReplicationSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the replication subsystem statistical information, as
            described by <see cref="T:BerkeleyDB.ReplicationStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintStats">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintStats(System.Boolean,System.Boolean)">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintSubsystemStats">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintSubsystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintStats(System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Display the locking subsystem statistical information, as described
            by <see cref="T:BerkeleyDB.LockStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats">
            <summary>
            Display the transaction subsystem statistical information, as
            described by <see cref="T:BerkeleyDB.TransactionStats"/>.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats(System.Boolean,System.Boolean)">
            <summary>
            Display the transaction subsystem statistical information, as
            described by <see cref="T:BerkeleyDB.TransactionStats"/>.
            </summary>
            <param name="PrintAll">
            If true, display all available information.
            </param>
            <param name="ClearStats">
            If true, reset statistics after displaying their values.
            </param>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.AutoCommit">
            <summary>
            If true, database operations for which no explicit transaction
            handle was specified, and which modify databases in the database
            environment, will be automatically enclosed within a transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.CacheSize">
            <summary>
            The size of the shared memory buffer pool -- that is, the cache.
            </summary>
            <remarks>
            <para>
            The cache should be the size of the normal working data set of the
            application, with some small amount of additional memory for unusual
            situations. (Note: the working set is not the same as the number of
            pages accessed simultaneously, and is usually much larger.)
            </para>
            <para>
            The default cache size is 256KB, and may not be specified as less
            than 20KB. Any cache size less than 500MB is automatically increased
            by 25% to account for buffer pool overhead; cache sizes larger than
            500MB are used as specified. The maximum size of a single cache is
            4GB on 32-bit systems and 10TB on 64-bit systems. (All sizes are in
            powers-of-two, that is, 256KB is 2^18 not 256,000.) For information
            on tuning the Berkeley DB cache size, see Selecting a cache size in
            the Programmer's Reference Guide.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.CDB_ALLDB">
            <summary>
            If true, Berkeley DB Concurrent Data Store applications will perform
            locking on an environment-wide basis rather than on a per-database
            basis. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Create">
            <summary>
            If true, Berkeley DB subsystems will create any underlying files, as
            necessary.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.DataDirs">
            <summary>
            The array of directories where database files are stored.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.DeadlockResolution">
            <summary>
            The deadlock detector configuration, specifying what lock request(s)
            should be rejected. As transactions acquire locks on behalf of a
            single locker ID, rejecting a lock request associated with a
            transaction normally requires the transaction be aborted.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.EncryptAlgorithm">
            <summary>
            The algorithm used by the Berkeley DB library to perform encryption
            and decryption. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.ErrorFeedback">
            <summary>
            The mechanism for reporting detailed error messages to the
            application.
            </summary>
            <remarks>
            <para>
            When an error occurs in the Berkeley DB library, a
            <see cref="T:BerkeleyDB.DatabaseException"/>, or subclass of DatabaseException,
            is thrown. In some cases, however, the exception may be insufficient
            to completely describe the cause of the error, especially during
            initial application debugging.
            </para>
            <para>
            In some cases, when an error occurs, Berkeley DB will call the given
            delegate with additional error information. It is up to the delegate
            to display the error message in an appropriate manner.
            </para>
            <para>
            Setting ErrorFeedback to NULL unconfigures the callback interface.
            </para>
            <para>
            This error-logging enhancement does not slow performance or
            significantly increase application size, and may be run during
            normal operation as well as during application debugging.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.ErrorPrefix">
            <summary>
            The prefix string that appears before error messages issued by
            Berkeley DB.
            </summary>
            <remarks>
            <para>
            For databases opened inside of a DatabaseEnvironment, setting
            ErrorPrefix affects the entire environment and is equivalent to
            setting <see cref="P:BerkeleyDB.DatabaseEnvironment.ErrorPrefix"/>.
            </para>
            <para>
            Setting ErrorPrefix configures operations performed using the
            specified object, not all operations performed on the underlying
            database. 
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.EventNotify">
            <summary>
            A delegate which is called to notify the process of specific
            Berkeley DB events. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Feedback">
            <summary>
            Monitor progress within long running operations.
            </summary>
            <remarks>
            <para>
            Some operations performed by the Berkeley DB library can take
            non-trivial amounts of time. The Feedback delegate can be used by
            applications to monitor progress within these operations. When an
            operation is likely to take a long time, Berkeley DB will call the
            specified delegate with progress information.
            </para>
            <para>
            It is up to the delegate to display this information in an
            appropriate manner. 
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.ForceFlush">
            <summary>
            If true, flush database writes to the backing disk before returning
            from the write system call, rather than flushing database writes
            explicitly in a separate system call, as necessary.
            </summary>
            <remarks>
            This flag may result in inaccurate file modification times and other
            file-level information for Berkeley DB database files. This flag
            will almost certainly result in a performance decrease on most
            systems.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.FreeThreaded">
            <summary>
            If true, the object is free-threaded; that is, concurrently usable
            by multiple threads in the address space.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Home">
            <summary>
            The database environment home directory.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.InitRegions">
            <summary>
            If true, Berkeley DB will page-fault shared regions into memory when
            initially creating or joining a Berkeley DB environment.
            </summary>
            <remarks>
            <para>
            In some applications, the expense of page-faulting the underlying
            shared memory regions can affect performance. (For example, if the
            page-fault occurs while holding a lock, other lock requests can
            convoy, and overall throughput may decrease.)
            </para>
            <para>
            In addition to page-faulting, Berkeley DB will write the shared
            regions when creating an environment, forcing the underlying virtual
            memory and filesystems to instantiate both the necessary memory and
            the necessary disk space. This can also avoid out-of-disk space
            failures later on.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.IntermediateDirMode">
            <summary>
            The intermediate directory permissions. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LockConflictMatrix">
            <summary>
            The current lock conflicts array.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Lockdown">
            <summary>
            If true, lock shared Berkeley DB environment files and memory-mapped
            databases into memory.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LockPartitions">
            <summary>
            The number of lock table partitions used in the Berkeley DB
            environment.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LockTimeout">
            <summary>
            A value, in microseconds, representing lock timeouts.
            </summary>
            <remarks>
            <para>
            All timeouts are checked whenever a thread of control blocks on a
            lock or when deadlock detection is performed. As timeouts are only
            checked when the lock request first blocks or when deadlock
            detection is performed, the accuracy of the timeout depends on how
            often deadlock detection is performed.
            </para>
            <para>
            Timeout values specified for the database environment may be
            overridden on a per-transaction basis, see
            <see cref="M:BerkeleyDB.Transaction.SetLockTimeout(System.UInt32)"/>.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogBufferSize">
            <summary>
            The size of the in-memory log buffer, in bytes
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogDir">
            <summary>
            The path of a directory to be used as the location of logging files.
            Log files created by the Log Manager subsystem will be created in
            this directory. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogFileMode">
            <summary>
            The absolute file mode for created log files. This property is only
            useful for the rare Berkeley DB application that does not control
            its umask value.
            </summary>
            <remarks>
            Normally, if Berkeley DB applications set their umask appropriately,
            all processes in the application suite will have read permission on
            the log files created by any process in the application suite.
            However, if the Berkeley DB application is a library, a process
            using the library might set its umask to a value preventing other
            processes in the application suite from reading the log files it
            creates. In this rare case, this property can be used to set the
            mode of created log files to an absolute value.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogNoBuffer">
            <summary>
            If true, system buffering is turned off for Berkeley DB log files to
            avoid double caching. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogForceSync">
            <summary>
            If true, Berkeley DB will flush log writes to the backing disk
            before returning from the write system call, rather than flushing
            log writes explicitly in a separate system call, as necessary.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogAutoRemove">
            <summary>
            If true, Berkeley DB will automatically remove log files that are no
            longer needed.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogInMemory">
            <summary>
            If true, transaction logs are maintained in memory rather than on
            disk. This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability).
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogZeroOnCreate">
            <summary>
            If true, all pages of a log file are zeroed when that log file is
            created.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.LogRegionSize">
            <summary>
            The size of the underlying logging area of the Berkeley DB
            environment, in bytes.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxCacheSize">
            <summary>
            The maximum cache size
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxLogFileSize">
            <summary>
            The maximum size of a single file in the log, in bytes. Because
            <see cref="F:BerkeleyDB.LSN.Offset">LSN Offsets</see> are unsigned four-byte
            values, the size may not be larger than the maximum unsigned
            four-byte value.
            </summary>
            <remarks>
            <para>
            When the logging subsystem is configured for on-disk logging, the
            default size of a log file is 10MB.
            </para>
            <para>
            When the logging subsystem is configured for in-memory logging, the
            default size of a log file is 256KB. In addition, the configured log
            buffer size must be larger than the log file size. (The logging
            subsystem divides memory configured for in-memory log records into
            "files", as database environments configured for in-memory log
            records may exchange log records with other members of a replication
            group, and those members may be configured to store log records
            on-disk.) When choosing log buffer and file sizes for in-memory
            logs, applications should ensure the in-memory log buffer size is
            large enough that no transaction will ever span the entire buffer,
            and avoid a state where the in-memory buffer is full and no space
            can be freed because a transaction that started in the first log
            "file" is still active.
            </para>
            <para>
            See Log File Limits in the Programmer's Reference Guide for more
            information.
            </para>
            <para>
            If no size is specified by the application, the size last specified
            for the database region will be used, or if no database region
            previously existed, the default will be used.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxLockers">
            <summary>
            The maximum number of locking entities supported by the Berkeley DB
            environment.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxLocks">
            <summary>
            The maximum number of locks supported by the Berkeley DB
            environment.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxMutexes">
            <summary>
            The total number of mutexes allocated
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxObjects">
            <summary>
            The maximum number of locked objects
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxOpenFiles">
            <summary>
            The number of file descriptors the library will open concurrently
            when flushing dirty pages from the cache.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxSequentialWrites">
            <summary>
            The number of sequential write operations scheduled by the library
            when flushing dirty pages from the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MaxTransactions">
            <summary>
            The number of active transactions supported by the environment. This
            value bounds the size of the memory allocated for transactions.
            Child transactions are counted as active until they either commit or
            abort.
            </summary>
            <remarks>
            <para>
            Transactions that update multiversion databases are not freed until
            the last page version that the transaction created is flushed from
            cache. This means that applications using multi-version concurrency
            control may need a transaction for each page in cache, in the
            extreme case.
            </para>
            <para>
            When all of the memory available in the database environment for
            transactions is in use, calls to <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/> will
            fail (until some active transactions complete). If MaxTransactions
            is never set, the database environment is configured to support at
            least 100 active transactions.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MMapSize">
            <summary>
            The maximum file size, in bytes, for a file to be mapped into the
            process address space. If no value is specified, it defaults to
            10MB. 
            </summary>
            <remarks>
            Files that are opened read-only in the cache (and that satisfy a few
            other criteria) are, by default, mapped into the process address
            space instead of being copied into the local cache. This can result
            in better-than-usual performance because available virtual memory is
            normally much larger than the local cache, and page faults are
            faster than page copying on many systems. However, it can cause
            resource starvation in the presence of limited virtual memory, and
            it can result in immense process sizes in the presence of large
            databases.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MutexAlignment">
            <summary>
            The mutex alignment, in bytes.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.MutexIncrement">
            <summary>
            The number of additional mutexes allocated.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.NoBuffer">
            <summary>
            If true, turn off system buffering of Berkeley DB database files to
            avoid double caching. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.NoLocking">
            <summary>
            If true, Berkeley DB will grant all requested mutual exclusion
            mutexes and database locks without regard for their actual
            availability. This functionality should never be used for purposes
            other than debugging. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.NoMMap">
            <summary>
            If true, Berkeley DB will copy read-only database files into the
            local cache instead of potentially mapping them into process memory.
            </summary>
            <seealso cref="P:BerkeleyDB.DatabaseEnvironment.MMapSize"/>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.NoPanic">
            <summary>
            If true, Berkeley DB will ignore any panic state in the database
            environment. (Database environments in a panic state normally refuse
            all attempts to call Berkeley DB functions, throwing 
            <see cref="T:BerkeleyDB.RunRecoveryException"/>.) This functionality should never
            be used for purposes other than debugging.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.NumTestAndSetSpins">
            <summary>
            The number of times that test-and-set mutexes should spin without
            blocking. The value defaults to 1 on uniprocessor systems and to 50
            times the number of processors on multiprocessor systems. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Overwrite">
            <summary>
            If true, overwrite files stored in encrypted formats before deleting
            them.
            </summary>
            <remarks>
            Berkeley DB overwrites files using alternating 0xff, 0x00 and 0xff
            byte patterns. For file overwriting to be effective, the underlying
            file must be stored on a fixed-block filesystem. Systems with
            journaling or logging filesystems will require operating system
            support and probably modification of the Berkeley DB sources.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Private">
            <summary>
            If true, allocate region memory from the heap instead of from memory
            backed by the filesystem or system shared memory. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Register">
            <summary>
            If true, Berkeley DB will have checked to see if recovery needed to
            be performed before opening the database environment.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepAckTimeout">
            <summary>
            The amount of time the replication manager's transport function
            waits to collect enough acknowledgments from replication group
            clients, before giving up and returning a failure indication. The
            default wait time is 1 second.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepBulkTransfer">
            <summary>
            If true, the replication master sends groups of records to the
            clients in a single network transfer
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepCheckpointDelay">
            <summary>
            The amount of time a master site will delay between completing a
            checkpoint and writing a checkpoint record into the log.
            </summary>
            <remarks>
            This delay allows clients to complete their own checkpoints before
            the master requires completion of them. The default is 30 seconds.
            If all databases in the environment, and the environment's
            transaction log, are configured to reside in memory (never preserved
            to disk), then, although checkpoints are still necessary, the delay
            is not useful and should be set to 0.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepClockskewFast">
            <summary>
            The value, relative to <see cref="P:BerkeleyDB.DatabaseEnvironment.RepClockskewSlow"/>, of the
            fastest clock in the group of sites.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepClockskewSlow">
            <summary>
            The value of the slowest clock in the group of sites.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepConnectionRetry">
            <summary>
            The amount of time the replication manager will wait before trying
            to re-establish a connection to another site after a communication
            failure. The default wait time is 30 seconds.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepDelayClientSync">
            <summary>
            If true, the client should delay synchronizing to a newly declared
            master (defaults to false). Clients configured in this way will remain
            unsynchronized until the application calls <see cref="M:BerkeleyDB.DatabaseEnvironment.RepSync"/>. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepElectionRetry">
            <summary>
            Configure the amount of time the replication manager will wait
            before retrying a failed election. The default wait time is 10
            seconds. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepElectionTimeout">
            <summary>
            The timeout period for an election. The default timeout is 2
            seconds.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepFullElectionTimeout">
            <summary>
            An optional configuration timeout period to wait for full election
            participation the first time the replication group finds a master.
            By default this option is turned off and normal election timeouts
            are used. (See the Elections section in the Berkeley DB Reference
            Guide for more information.) 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepHeartbeatMonitor">
            <summary>
            The amount of time the replication manager, running at a client
            site, waits for some message activity on the connection from the
            master (heartbeats or other messages) before concluding that the
            connection has been lost. When 0 (the default), no monitoring is
            performed.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepHeartbeatSend">
            <summary>
            The frequency at which the replication manager, running at a master
            site, broadcasts a heartbeat message in an otherwise idle system.
            When 0 (the default), no heartbeat messages will be sent. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepLeaseTimeout">
            <summary>
            The amount of time a client grants its master lease to a master.
            When using master leases all sites in a replication group must use
            the same lease timeout value. There is no default value. If leases
            are desired, this method must be called prior to calling
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/> or <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepMgrAckPolicy">
            <summary>
            Specify how master and client sites will handle acknowledgment of
            replication messages which are necessary for "permanent" records.
            The current implementation requires all sites in a replication group
            configure the same acknowledgement policy. 
            </summary>
            <seealso cref="P:BerkeleyDB.DatabaseEnvironment.RepAckTimeout"/>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepMgrLocalSite">
            <summary>
            The host information for the local system. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepMgrRemoteSites">
            <summary>
            The status of the sites currently known by the replication manager. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepNoAutoInit">
            <summary>
            If true, the replication master will not automatically re-initialize
            outdated clients (defaults to false). 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepNoBlocking">
            <summary>
            If true, Berkeley DB method calls that would normally block while
            clients are in recovery will return errors immediately (defaults to
            false).
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepNSites">
            <summary>
            The total number of sites in the replication group.
            </summary>
            <remarks>
            <para>
            This setting is typically used by applications which use the
            Berkeley DB library "replication manager" support. (However, see
            also <see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>, the description of the nsites
            parameter.)
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepPriority">
            <summary>
            The database environment's priority in replication group elections.
            A special value of 0 indicates that this environment cannot be a
            replication group master. If not configured, then a default value
            of 100 is used.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepRetransmissionRequestMin">
            <summary>
            The minimum number of microseconds a client waits before requesting
            retransmission.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepRetransmissionRequestMax">
            <summary>
            The maximum number of microseconds a client waits before requesting
            retransmission.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepStrict2Site">
            <summary>
            Replication Manager observes the strict "majority" rule in managing
            elections, even in a group with only 2 sites. This means the client
            in a 2-site group will be unable to take over as master if the
            original master fails or becomes disconnected. (See the Elections
            section in the Berkeley DB Reference Guide for more information.)
            Both sites in the replication group should have the same value for
            this parameter.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepTransmitLimitGBytes">
            <summary>
            The gigabytes component of the byte-count limit on the amount of
            data that will be transmitted from a site in response to a single
            message processed by <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepTransmitLimitBytes">
            <summary>
            The bytes component of the byte-count limit on the amount of data
            that will be transmitted from a site in response to a single
            message processed by <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepTransport">
            <summary>
            The delegate used to transmit data using the replication
            application's communication infrastructure.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RepUseMasterLeases">
            <summary>
            If true, master leases will be used for this site (defaults to
            false). 
            </summary>
            <remarks>
            Configuring this option may result in a 
            <see cref="T:BerkeleyDB.LeaseExpiredException"/> when attempting to read entries
            from a database after the site's master lease has expired.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RunFatalRecovery">
            <summary>
            If true, catastrophic recovery was run on this environment before
            opening it for normal use.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.RunRecovery">
            <summary>
            If true, normal recovery was run on this environment before opening
            it for normal use.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.SequentialWritePause">
            <summary>
            The number of microseconds the thread of control will pause before
            scheduling further write operations.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.SetThreadID">
            <summary>
            A delegate that returns a unique identifier pair for the current 
            thread of control.
            </summary>
            <remarks>
            This delegate supports <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>. For more
            information, see Architecting Data Store and Concurrent Data Store
            applications, and Architecting Transactional Data Store
            applications, both in the Berkeley DB Programmer's Reference Guide.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.SetThreadName">
            <summary>
            A delegate that formats a process ID and thread ID identifier pair. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.SystemMemory">
            <summary>
            If true, allocate region memory from system shared memory instead of
            from heap memory or memory backed by the filesystem. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TempDir">
            <summary>
            The path of a directory to be used as the location of temporary
            files.
            </summary>
            <remarks>
            <para>
            The files created to back in-memory access method databases will be
            created relative to this path. These temporary files can be quite
            large, depending on the size of the database.
            </para>
            <para>
            If no directories are specified, the following alternatives are
            checked in the specified order. The first existing directory path is
            used for all temporary files.
            </para>
            <list type="number">
            <item>The value of the environment variable TMPDIR.</item>
            <item>The value of the environment variable TEMP.</item>
            <item>The value of the environment variable TMP.</item>
            <item>The value of the environment variable TempFolder.</item>
            <item>The value returned by the GetTempPath interface.</item>
            <item>The directory /var/tmp.</item>
            <item>The directory /usr/tmp.</item>
            <item>The directory /temp.</item>
            <item>The directory /tmp.</item>
            <item>The directory C:/temp.</item>
            <item>The directory C:/tmp.</item>
            </list>
            <para>
            Environment variables are only checked if
            <see cref="P:BerkeleyDB.DatabaseEnvironment.UseEnvironmentVars"/> is true.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.ThreadCount">
            <summary>
            An approximate number of threads in the database environment.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.ThreadIsAlive">
            <summary>
            A delegate that returns if a thread of control (either a true thread
            or a process) is still running.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TimeNotGranted">
            <summary>
            If true, database calls timing out based on lock or transaction
            timeout values will throw <see cref="T:BerkeleyDB.LockNotGrantedException"/>
            instead of <see cref="T:BerkeleyDB.DeadlockException"/>.
            </summary>
            <remarks>
            If true, this allows applications to distinguish between operations
            which have deadlocked and operations which have exceeded their time
            limits.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TxnNoSync">
            <summary>
            If true, Berkeley DB will not write or synchronously flush the log
            on transaction commit.
            </summary>
            <remarks>
            This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability); that
            is, database integrity will be maintained, but if the application or
            system fails, it is possible some number of the most recently
            committed transactions may be undone during recovery. The number of
            transactions at risk is governed by how many log updates can fit
            into the log buffer, how often the operating system flushes dirty
            buffers to disk, and how often the log is checkpointed.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TxnNoWait">
            <summary>
            If true and a lock is unavailable for any Berkeley DB operation
            performed in the context of a transaction, cause the operation to 
            throw <see cref="T:BerkeleyDB.DeadlockException"/> (or
            <see cref="T:BerkeleyDB.LockNotGrantedException"/> if configured with
            <see cref="P:BerkeleyDB.DatabaseEnvironment.TimeNotGranted"/>).
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TxnSnapshot">
            <summary>
            If true, all transactions in the environment will be started as if
            <see cref="F:BerkeleyDB.TransactionConfig.Snapshot"/> was passed to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>, and all non-transactional cursors
            will be opened as if <see cref="F:BerkeleyDB.CursorConfig.SnapshotIsolation"/>
            was passed to <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TxnTimeout">
            <summary>
            A value, in microseconds, representing transaction timeouts.
            </summary>
            <remarks>
            <para>
            All timeouts are checked whenever a thread of control blocks on a
            lock or when deadlock detection is performed. As timeouts are only
            checked when the lock request first blocks or when deadlock
            detection is performed, the accuracy of the timeout depends on how
            often deadlock detection is performed.
            </para>
            <para>
            Timeout values specified for the database environment may be
            overridden on a per-transaction basis, see
            <see cref="M:BerkeleyDB.Transaction.SetTxnTimeout(System.UInt32)"/>.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TxnTimestamp">
            <summary>
            The recovery timestamp
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.TxnWriteNoSync">
            <summary>
            If true, Berkeley DB will write, but will not synchronously flush,
            the log on transaction commit. 
            </summary>
            <remarks>
            This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability); that
            is, database integrity will be maintained, but if the system fails, 
            it is possible some number of the most recently committed
            transactions may be undone during recovery. The number of
            transactions at risk is governed by how often the system flushes
            dirty buffers to disk and how often the log is checkpointed.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UseMVCC">
            <summary>
            If true, all databases in the environment will be opened as if
            <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> was set.
            </summary>
            <remarks>
            This flag will be ignored for queue databases for which MVCC is not
            supported.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UsingCDB">
            <summary>
            If true, locking for the Berkeley DB Concurrent Data Store product
            was initialized.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UsingLocking">
            <summary>
            If true, the locking subsystem was initialized.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UsingLogging">
            <summary>
            If true, the logging subsystem was initialized.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UsingMPool">
            <summary>
            If true, the shared memory buffer pool subsystem was initialized.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UsingReplication">
            <summary>
            If true, the replication subsystem was initialized.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UsingTxns">
            <summary>
            If true, the transaction subsystem was initialized.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.Verbosity">
            <summary>
            Specific additional informational and debugging messages in the
            Berkeley DB message output.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.YieldCPU">
            <summary>
            If true, Berkeley DB will yield the processor immediately after each
            page or mutex acquisition.
            </summary>
            <remarks>
            This functionality should never be used for purposes other than
            stress testing.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironment.UseEnvironmentVars">
            <summary>
            The Berkeley DB process' environment may be permitted to specify
            information to be used when naming files; see Berkeley DB File
            Naming in the Programmer's Reference Guide for more information.
            </summary>
        </member>
        <member name="T:BerkeleyDB.ReplicationStats">
            <summary>
            Statistical information about the replication subsystem
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.CurrentQueuedLogRecords">
            <summary>
            Log records currently queued. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ClientStartupComplete">
            <summary>
            Site completed client sync-up. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.Status">
            <summary>
            Current replication status. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.NextLSN">
            <summary>
            Next LSN to use or expect. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.AwaitedLSN">
            <summary>
            LSN we're awaiting, if any. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MaxPermanentLSN">
            <summary>
            Maximum permanent LSN. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.NextPage">
            <summary>
            Next pg we expect. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.AwaitedPage">
            <summary>
            pg we're awaiting, if any. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.DupMasters">
            <summary>
            # of times a duplicate master condition was detected.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.EnvID">
            <summary>
            Current environment ID. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.EnvPriority">
            <summary>
            Current environment priority. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.BulkBufferFills">
            <summary>
            Bulk buffer fills. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.BulkBufferOverflows">
            <summary>
            Bulk buffer overflows. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.BulkRecordsStored">
            <summary>
            Bulk records stored. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.BulkBufferTransfers">
            <summary>
            Transfers of bulk buffers. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ForcedRerequests">
            <summary>
            Number of forced rerequests. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ClientServiceRequests">
            <summary>
            Number of client service requests received by this client.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ClientServiceRequestsMissing">
            <summary>
            Number of client service requests missing on this client.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.CurrentGenerationNumber">
            <summary>
            Current generation number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.CurrentElectionGenerationNumber">
            <summary>
            Current election gen number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.DuplicateLogRecords">
            <summary>
            Log records received multiply. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MaxQueuedLogRecords">
            <summary>
            Max. log records queued at once. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.QueuedLogRecords">
            <summary>
            Total # of log recs. ever queued. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ReceivedLogRecords">
            <summary>
            Log records received and put. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MissedLogRecords">
            <summary>
            Log recs. missed and requested. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MasterEnvID">
            <summary>
            Env. ID of the current master. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MasterChanges">
            <summary>
            # of times we've switched masters. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.BadGenerationMessages">
            <summary>
            Messages with a bad generation #. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ReceivedMessages">
            <summary>
            Messages received and processed. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.IgnoredMessages">
            <summary>
            Messages ignored because this site was a client in recovery.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.FailedMessageSends">
            <summary>
            # of failed message sends. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MessagesSent">
            <summary>
            # of successful message sends. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.NewSiteMessages">
            <summary>
            # of NEWSITE msgs. received. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.Sites">
            <summary>
            Current number of sites we will assume during elections.
            </summary>        
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.Throttled">
            <summary>
            # of times we were throttled. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.Outdated">
            <summary>
            # of times we detected and returned an OUTDATED condition.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.DuplicatePages">
            <summary>
            Pages received multiply. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ReceivedPages">
            <summary>
            Pages received and stored. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MissedPages">
            <summary>
            Pages missed and requested. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.AppliedTransactions">
            <summary>
            # of transactions applied. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.StartSyncMessagesDelayed">
            <summary>
            # of STARTSYNC msgs delayed. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.Elections">
            <summary>
            # of elections held. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionsWon">
            <summary>
            # of elections won by this site. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.CurrentWinner">
            <summary>
            Current front-runner. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionGenerationNumber">
            <summary>
            Election generation number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.CurrentWinnerMaxLSN">
            <summary>
            Max. LSN of current winner. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.RegisteredSites">
            <summary>
            # of "registered voters". 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.RegisteredSitesNeeded">
            <summary>
            # of "registered voters" needed. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionPriority">
            <summary>
            Current election priority. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionStatus">
            <summary>
            Current election status. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionTiebreaker">
            <summary>
            Election tiebreaker value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.Votes">
            <summary>
            Votes received in this round. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionTimeSec">
            <summary>
            Last election time seconds. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.ElectionTimeUSec">
            <summary>
            Last election time useconds. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MaxLeaseSec">
            <summary>
            Maximum lease timestamp seconds. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationStats.MaxLeaseUSec">
            <summary>
            Maximum lease timestamp useconds. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.ErrorCodes">
            <summary>
            Constants representing error codes returned by the Berkeley DB library.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_BUFFER_SMALL">
            <summary>
             User memory too small for return. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_DONOTINDEX">
            <summary>
             "Null" return from 2ndary callbk. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_FOREIGN_CONFLICT">
            <summary>
             A foreign db constraint triggered. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_KEYEMPTY">
            <summary>
             Key/data deleted or never created. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_KEYEXIST">
            <summary>
             The key/data pair already exists. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_LOCK_DEADLOCK">
            <summary>
             Deadlock. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_LOCK_NOTGRANTED">
            <summary>
             Lock unavailable. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_LOG_BUFFER_FULL">
            <summary>
             In-memory log buffer full. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_NOSERVER">
            <summary>
             Server panic return. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_NOSERVER_HOME">
            <summary>
             Bad home sent to server. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_NOSERVER_ID">
            <summary>
             Bad ID sent to server. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_NOTFOUND">
            <summary>
             Key/data pair not found (EOF). 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_OLD_VERSION">
            <summary>
             Out-of-date version. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_PAGE_NOTFOUND">
            <summary>
             Requested page not found. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_DUPMASTER">
            <summary>
             There are two masters. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_HANDLE_DEAD">
            <summary>
             Rolled back a commit. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_HOLDELECTION">
            <summary>
             Time to hold an election. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_IGNORE">
            <summary>
             This msg should be ignored.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_ISPERM">
            <summary>
             Cached not written perm written.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_JOIN_FAILURE">
            <summary>
             Unable to join replication group. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_LEASE_EXPIRED">
            <summary>
             Master lease has expired. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_LOCKOUT">
            <summary>
             API/Replication lockout now. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_NEWSITE">
            <summary>
             New site entered system. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_NOTPERM">
            <summary>
             Permanent log record not written. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_REP_UNAVAIL">
            <summary>
             Site cannot currently be reached. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_RUNRECOVERY">
            <summary>
             Panic return. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_SECONDARY_BAD">
            <summary>
             Secondary index corrupt. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_VERIFY_BAD">
            <summary>
             Verify failed; bad format. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ErrorCodes.DB_VERSION_MISMATCH">
            <summary>
             Environment version mismatch. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.ActiveTransaction">
            <summary>
            The ActiveTransaction class describes a currently active transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.ID">
            <summary>
            The transaction ID of the transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.ParentID">
            <summary>
            The transaction ID of the parent transaction (or 0, if no parent). 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.ProcessID">
            <summary>
            The process ID of the originator of the transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.ThreadID">
            <summary>
            The thread of control ID of the originator of the transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.Begun">
            <summary>
            The current log sequence number when the transaction was begun.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.SnapshotReads">
            <summary>
            The log sequence number of reads for snapshot transactions. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.BufferCopiesInCache">
            <summary>
            The number of MVCC buffer copies created by this transaction that
            remain in cache.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.Status">
            <summary>
            Status of the transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.GlobalID">
            <summary>
            If the transaction is a prepare transaction, the transaction's
            Global ID. Otherwise, the GlobalID contents are undefined. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ActiveTransaction.Name">
            <summary>
            If a name was specified for the transaction, up to the first 50
            bytes of that name. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.ActiveTransaction.TransactionStatus">
            <summary>
            The status of an active transaction.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.ABORTED">
            <summary>
            The transaction has been aborted
            </summary>
        </member>
        <member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.COMMITTED">
            <summary>
            The transaction has been committed
            </summary>
        </member>
        <member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.PREPARED">
            <summary>
            The transaction has been prepared
            </summary>
        </member>
        <member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.RUNNING">
            <summary>
            The transaction is running
            </summary>
        </member>
        <member name="T:BerkeleyDB.SecondaryRecnoDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.RecnoDatabase"/>
            </summary>
        </member>
        <member name="T:BerkeleyDB.SecondaryDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.SecondaryDatabase"/>
            </summary>
        </member>
        <member name="T:BerkeleyDB.DatabaseConfig">
            <summary>
            A class representing configuration parameters for <see cref="T:BerkeleyDB.Database"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.Env">
            <summary>
            The Berkeley DB environment within which to create a database.  If 
            null, the database will be created stand-alone; that is, it is not
            part of any Berkeley DB environment. 
            </summary>
            <remarks>
            The database access methods automatically make calls to the other
            subsystems in Berkeley DB, based on the enclosing environment. For
            example, if the environment has been configured to use locking, the
            access methods will automatically acquire the correct locks when
            reading and writing pages of the database.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.Priority">
            <summary>
            The cache priority for pages referenced by the database.
            </summary>
            <remarks>
            The priority of a page biases the replacement algorithm to be more
            or less likely to discard a page when space is needed in the buffer
            pool. The bias is temporary, and pages will eventually be discarded
            if they are not referenced again. This priority is only advisory,
            and does not guarantee pages will be treated in a specific way.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.CacheSize">
            <summary>
            The size of the shared memory buffer pool -- that is, the cache.
            </summary>
            <remarks>
            <para>
            The cache should be the size of the normal working data set of the
            application, with some small amount of additional memory for unusual
            situations. (Note: the working set is not the same as the number of
            pages accessed simultaneously, and is usually much larger.)
            </para>
            <para>
            The default cache size is 256KB, and may not be specified as less
            than 20KB. Any cache size less than 500MB is automatically increased
            by 25% to account for buffer pool overhead; cache sizes larger than
            500MB are used as specified. The maximum size of a single cache is
            4GB on 32-bit systems and 10TB on 64-bit systems. (All sizes are in
            powers-of-two, that is, 256KB is 2^18 not 256,000.) For information
            on tuning the Berkeley DB cache size, see Selecting a cache size in
            the Programmer's Reference Guide.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.ByteOrder">
            <summary>
            The byte order for integers in the stored database metadata.  The
            host byte order of the machine where the Berkeley DB library was
            compiled is the default value.
            </summary>
            <remarks>
            <para>
            The access methods provide no guarantees about the byte ordering of
            the application data stored in the database, and applications are
            responsible for maintaining any necessary ordering.
            </para>
            <para>
            If creating additional databases in a single physical file, this
            parameter will be ignored and the byte order of the existing
            databases will be used.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseConfig.SetEncryption(System.String,BerkeleyDB.EncryptionAlgorithm)">
            <summary>
            Set the password and algorithm used by the Berkeley DB library to
            perform encryption and decryption. 
            </summary>
            <param name="password">
            The password used to perform encryption and decryption.
            </param>
            <param name="alg">
            The algorithm used to perform encryption and decryption.
            </param>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.ErrorPrefix">
            <summary>
            The prefix string that appears before error messages issued by
            Berkeley DB.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.ErrorFeedback">
            <summary>
            The mechanism for reporting error messages to the application.
            </summary>
            <remarks>
            <para>
            In some cases, when an error occurs, Berkeley DB will call
            ErrorFeedback with additional error information. It is up to the
            delegate function to display the error message in an appropriate
            manner.
            </para>
            <para>
            This error-logging enhancement does not slow performance or
            significantly increase application size, and may be run during
            normal operation as well as during application debugging.
            </para>
            <para>
            For databases opened inside of Berkeley DB environments, setting
            ErrorFeedback affects the entire environment and is equivalent to 
            setting <see cref="P:BerkeleyDB.DatabaseEnvironment.ErrorFeedback"/>.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.Feedback">
            <summary>
            
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.DoChecksum">
            <summary>
            If true, do checksum verification of pages read into the cache from
            the backing filestore.
            </summary>
            <remarks>
            <para>
            Berkeley DB uses the SHA1 Secure Hash Algorithm if encryption is
            configured and a general hash algorithm if it is not.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.NonDurableTxns">
            <summary>
            If true, Berkeley DB will not write log records for this database.
            </summary>
            <remarks>
            If Berkeley DB does not write log records, updates of this database
            will exhibit the ACI (atomicity, consistency, and isolation)
            properties, but not D (durability); that is, database integrity will
            be maintained, but if the application or system fails, integrity
            will not persist. The database file must be verified and/or restored
            from backup after a failure. In order to ensure integrity after
            application shut down, the database must be synced when closed, or
            all database changes must be flushed from the database environment
            cache using either
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Checkpoint"/> or
            <see cref="M:BerkeleyDB.DatabaseEnvironment.SyncMemPool"/>. All database objects
            for a single physical file must set NonDurableTxns, including
            database objects for different databases in a physical file.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.AutoCommit">
            <summary>
            Enclose the open call within a transaction. If the call succeeds,
            the open operation will be recoverable and all subsequent database
            modification operations based on this handle will be transactionally
            protected. If the call fails, no database will have been created. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.FreeThreaded">
            <summary>
            Cause the database object to be free-threaded; that is, concurrently
            usable by multiple threads in the address space.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.NoMMap">
            <summary>
            Do not map this database into process memory.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.ReadOnly">
            <summary>
            Open the database for reading only. Any attempt to modify items in
            the database will fail, regardless of the actual permissions of any
            underlying files. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.ReadUncommitted">
            <summary>
            Support transactional read operations with degree 1 isolation.
            </summary>
            <remarks>
            Read operations on the database may request the return of modified
            but not yet committed data. This flag must be specified on all
            database objects used to perform dirty reads or database updates,
            otherwise requests for dirty reads may not be honored and the read
            may block.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.Truncate">
            <summary>
            Physically truncate the underlying file, discarding all previous databases it might have held.
            </summary>
            <remarks>
            <para>
            Underlying filesystem primitives are used to implement this flag.
            For this reason, it is applicable only to the file and cannot be
            used to discard databases within a file.
            </para>
            <para>
            This setting cannot be lock or transaction-protected, and it is an
            error to specify it in a locking or transaction-protected
            environment.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseConfig.UseMVCC">
            <summary>
            Open the database with support for multiversion concurrency control.
            </summary>
            <remarks>
            This will cause updates to the database to follow a copy-on-write
            protocol, which is required to support snapshot isolation. This
            settting requires that the database be transactionally protected
            during its open and is not supported by the queue format.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseConfig.#ctor">
            <summary>
            Instantiate a new DatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseConfig.PageSize">
            <summary>
            The size of the pages used to hold items in the database, in bytes.
            </summary>
            <remarks>
            <para>
            The minimum page size is 512 bytes, the maximum page size is 64K
            bytes, and the page size must be a power-of-two. If the page size is
            not explicitly set, one is selected based on the underlying
            filesystem I/O block size. The automatically selected size has a
            lower limit of 512 bytes and an upper limit of 16K bytes.
            </para>
            <para>
            For information on tuning the Berkeley DB page size, see Selecting a
            page size in the Programmer's Reference Guide.
            </para>
            <para>
            If creating additional databases in a single physical file, this
            parameter will be ignored and the page size of the existing
            databases will be used.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseConfig.EncryptionPassword">
            <summary>
            The password used to perform encryption and decryption.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseConfig.EncryptAlgorithm">
            <summary>
            The algorithm used to perform encryption and decryption.
            </summary>
        </member>
        <member name="F:BerkeleyDB.SecondaryDatabaseConfig.Populate">
            <summary>
            If true and the secondary database is empty, walk through Primary
            and create an index to it in the empty secondary. This operation is
            potentially very expensive.
            </summary>
            <remarks>
            <para>
            If the secondary database has been opened in an environment
            configured with transactions, the entire secondary index creation is
            performed in the context of a single transaction.
            </para>
            <para>
            Care should be taken not to use a newly-populated secondary database
            in another thread of control until
            <see cref="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig)"/> has returned successfully in
            the first thread.
            </para>
            <para>
            If transactions are not being used, care should be taken not to
            modify a primary database being used to populate a secondary
            database, in another thread of control, until
            <see cref="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig)"/> has returned successfully in
            the first thread. If transactions are being used, Berkeley DB will
            perform appropriate locking and the application need not do any
            special operation ordering.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryDatabaseConfig.ImmutableKey">
            <summary>
            If true, the secondary key is immutable.
            </summary>
            <remarks>
            <para>
            This setting can be used to optimize updates when the secondary key
            in a primary record will never be changed after the primary record
            is inserted. For immutable secondary keys, a best effort is made to
            avoid calling the secondary callback function when primary records
            are updated. This optimization may reduce the overhead of update
            operations significantly if the callback function is expensive.
            </para>
            <para>
            Be sure to specify this setting only if the secondary key in the
            primary record is never changed. If this rule is violated, the
            secondary index will become corrupted, that is, it will become out
            of sync with the primary.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
            <summary>
            Instantiate a new SecondaryDatabaseConfig object, with the default
            configuration settings.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
            <summary>
            All updates to Primary will be automatically reflected in the
            secondary and all reads from the secondary will return corresponding
            data from Primary.
            </summary>
            <remarks>
            Note that as primary keys must be unique for secondary indices to
            work, Primary must have been configured with
            <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.SecondaryDatabaseConfig.KeyGen">
            <summary>
            The delegate that creates the set of secondary keys corresponding to
            a given primary key and data pair. 
            </summary>
            <remarks>
            KeyGen may be null if both
            <see cref="P:BerkeleyDB.BaseDatabase.ReadOnly">Primary.ReadOnly</see> and
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadOnly"/> are true.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Renumber">
            <summary>
            Cause the logical record numbers to be mutable, and change as
            records are added to and deleted from the database.
            </summary>
            <remarks>
            <para>
            For example, the deletion of record number 4 causes records numbered
            5 and greater to be renumbered downward by one. If a cursor was
            positioned to record number 4 before the deletion, it will refer to
            the new record number 4, if any such record exists, after the
            deletion. If a cursor was positioned after record number 4 before
            the deletion, it will be shifted downward one logical record,
            continuing to refer to the same record as it did before.
            </para>
            <para>
            Using <see cref="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> or <see cref="M:BerkeleyDB.Cursor.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32)"/> to
            create new records will cause the creation of multiple records if
            the record number is more than one greater than the largest record
            currently in the database. For example, creating record 28, when
            record 25 was previously the last record in the database, will
            create records 26 and 27 as well as 28. Attempts to retrieve records
            that were created in this manner will throw a
            <see cref="T:BerkeleyDB.KeyEmptyException"/>.
            </para>
            <para>
            If a created record is not at the end of the database, all records
            following the new record will be automatically renumbered upward by
            one. For example, the creation of a new record numbered 8 causes
            records numbered 8 and greater to be renumbered upward by one. If a
            cursor was positioned to record number 8 or greater before the
            insertion, it will be shifted upward one logical record, continuing
            to refer to the same record as it did before.
            </para>
            <para>
            For these reasons, concurrent access to a
            <see cref="T:BerkeleyDB.SecondaryRecnoDatabase"/> with this setting specified may
            be largely meaningless, although it is supported.
            </para>
            <para>
            If the database already exists, this setting must be the same as the
            existing database or an exception will be thrown.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Snapshot">
            <summary>
            If true, any <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> file will be read in its
            entirety when <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> is called.
            If false, <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> may be read lazily. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile">
            <summary>
            The underlying source file for the Recno access method.
            </summary>
            <remarks>
            <para>
            The purpose of the source file is to provide fast access and
            modification to databases that are normally stored as flat text
            files.
            </para>
            <para>
            The source parameter specifies an underlying flat text database file
            that is read to initialize a transient record number index. In the
            case of variable length records, the records are separated, as
            specified by <see cref="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.Delimiter"/>. For example, standard UNIX
            byte stream files can be interpreted as a sequence of variable
            length records separated by newline characters.
            </para>
            <para>
            In addition, when cached data would normally be written back to the
            underlying database file (for example,
            <see cref="M:BerkeleyDB.BaseDatabase.Close"/> or
            <see cref="M:BerkeleyDB.BaseDatabase.Sync"/>), the in-memory copy of the
            database will be written back to the source file.
            </para>
            <para>
            By default, the backing source file is read lazily; that is, records
            are not read from the file until they are requested by the
            application. If multiple processes (not threads) are accessing a
            Recno database concurrently, and are either inserting or deleting
            records, the backing source file must be read in its entirety before
            more than a single process accesses the database, and only that
            process should specify the backing source file as part of the
            <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> call. See
            <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Snapshot"/> for more information.
            </para>
            <para>
            Reading and writing the backing source file specified by source
            cannot be transaction-protected because it involves filesystem
            operations that are not part of the Db transaction methodology. For
            this reason, if a temporary database is used to hold the records, it
            is possible to lose the contents of the source file, for example, if
            the system crashes at the right instant. If a file is used to hold
            the database, normal database recovery on that file can be used to
            prevent information loss, although it is still possible that the
            contents of source will be lost if the system crashes.
            </para>
            <para>
            The source file must already exist (but may be zero-length) when 
            <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> is called.
            </para>
            <para>
            It is not an error to specify a read-only source file when creating
            a database, nor is it an error to modify the resulting database.
            However, any attempt to write the changes to the backing source file
            using either the <see cref="M:BerkeleyDB.BaseDatabase.Sync"/> or
            <see cref="M:BerkeleyDB.BaseDatabase.Close"/> methods will fail, of course.
            Use <see cref="M:BerkeleyDB.BaseDatabase.Close(System.Boolean)"/> to stop it from
            attempting to write the changes to the backing file; instead, they
            will be silently discarded.
            </para>
            <para>
            For all of the previous reasons, the source file is generally used
            to specify databases that are read-only for Berkeley DB
            applications; and that are either generated on the fly by software
            tools or modified using a different mechanism — for example, a text
            editor.
            </para>
            <para>
            If the database already exists, BackingFile must be the same as that
            historically used to create the database or corruption can occur.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.SecondaryRecnoDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
            <summary>
            Instantiate a new SecondaryRecnoDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.Delimiter">
            <summary>
            The delimiting byte used to mark the end of a record in
            <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/>.
            </summary>
            <remarks>
            <para>
            This byte is used for variable length records if
            <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> is set. If <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> is
            specified and no delimiting byte was specified, newline characters
            (that is, ASCII 0x0a) are interpreted as end-of-record markers.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.Length">
            <summary>
            Specify that the records are fixed-length, not byte-delimited, and
            are of length Length. 
            </summary>
            <remarks>
            <para>
            Any records added to the database that are less than Length bytes
            long are automatically padded (see <see cref="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.PadByte"/> for more
            information).
            </para>
            <para>
            Any attempt to insert records into the database that are greater
            than Length bytes long will cause the call to fail immediately and
            return an error. 
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
            <remarks>
            <para>
            If no pad character is specified, space characters (that is, ASCII
            0x20) are used for padding.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.MultipleDatabaseEntry">
            <summary>
            A class providing access to multiple <see cref="T:BerkeleyDB.DatabaseEntry"/>
            objects.
            </summary>
        </member>
        <member name="M:BerkeleyDB.MultipleDatabaseEntry.GetEnumerator">
            <summary>
            Return an enumerator which iterates over all
            <see cref="T:BerkeleyDB.DatabaseEntry"/> objects represented by the 
            <see cref="T:BerkeleyDB.MultipleDatabaseEntry"/>.
            </summary>
            <returns>
            An enumerator for the <see cref="T:BerkeleyDB.MultipleDatabaseEntry"/>
            </returns>
        </member>
        <member name="T:BerkeleyDB.CachePriority">
            <summary>
            A class to represent cache priority for database pages
            </summary>
        </member>
        <member name="F:BerkeleyDB.CachePriority.VERY_LOW">
            <summary>
            The lowest priority: pages are the most likely to be discarded. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.CachePriority.LOW">
            <summary>
            The next lowest priority.
            </summary>
        </member>
        <member name="F:BerkeleyDB.CachePriority.DEFAULT">
            <summary>
            The default priority.
            </summary>
        </member>
        <member name="F:BerkeleyDB.CachePriority.HIGH">
            <summary>
            The next highest priority. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.CachePriority.VERY_HIGH">
            <summary>
            The highest priority: pages are the least likely to be discarded.
            </summary>
        </member>
        <member name="T:BerkeleyDB.SequenceStats">
            <summary>
            Statistical information about a Sequence
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.CacheSize">
            <summary>
            Cache size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.CachedValue">
            <summary>
            Current cached value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.Flags">
            <summary>
            Flag value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.LastCachedValue">
            <summary>
            Last cached value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.LockWait">
            <summary>
            Sequence lock granted w/o wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.LockNoWait">
            <summary>
            Sequence lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.Max">
            <summary>
            Maximum value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.Min">
            <summary>
            Minimum value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceStats.StoredValue">
            <summary>
            Current value in db. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.QueueDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.QueueDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.QueueDatabaseConfig.ConsumeInOrder">
            <summary>
            If true, modify the operation of <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/>
            to return key/data pairs in order. That is, they will always return
            the key/data item from the head of the queue. 
            </summary>
            <remarks>
            <para>
            The default behavior of queue databases is optimized for multiple
            readers, and does not guarantee that record will be retrieved in the
            order they are added to the queue. Specifically, if a writing thread
            adds multiple records to an empty queue, reading threads may skip
            some of the initial records when the next
            <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/> call returns.
            </para>
            <para>
            This setting modifies <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/> to verify
            that the record being returned is in fact the head of the queue.
            This will increase contention and reduce concurrency when there are
            many reading threads.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.QueueDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.QueueDatabaseConfig.Append">
            <summary>
            A function to call after the record number has been selected but
            before the data has been stored into the database.
            </summary>
            <remarks>
            <para>
            When using <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>, it may be useful to
            modify the stored data based on the generated key. If a delegate is
            specified, it will be called after the record number has been
            selected, but before the data has been stored.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.QueueDatabaseConfig.#ctor">
            <summary>
            Instantiate a new QueueDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueDatabaseConfig.Length">
            <summary>
            Specify the length of records in the database.
            </summary>
            <remarks>
            <para>
            The record length must be enough smaller than
            <see cref="P:BerkeleyDB.DatabaseConfig.PageSize"/> that at least one record plus
            the database page's metadata information can fit on each database
            page.
            </para>
            <para>
            Any records added to the database that are less than Length bytes
            long are automatically padded (see <see cref="P:BerkeleyDB.QueueDatabaseConfig.PadByte"/> for more
            information).
            </para>
            <para>
            Any attempt to insert records into the database that are greater
            than Length bytes long will cause the call to fail immediately and
            return an error. 
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.QueueDatabaseConfig.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
            <remarks>
            <para>
            If no pad character is specified, space characters (that is, ASCII
            0x20) are used for padding.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.QueueDatabaseConfig.ExtentSize">
            <summary>
            The size of the extents used to hold pages in a
            <see cref="T:BerkeleyDB.QueueDatabase"/>, specified as a number of pages. 
            </summary>
            <remarks>
            <para>
            Each extent is created as a separate physical file. If no extent
            size is set, the default behavior is to create only a single
            underlying database file.
            </para>
            <para>
            For information on tuning the extent size, see Selecting a extent
            size in the Programmer's Reference Guide.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.HashDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.HashDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.HashDatabaseConfig.Duplicates">
            <summary>
            Policy for duplicate data items in the database; that is, insertion
            when the key of the key/data pair being inserted already exists in
            the database will be successful.
            </summary>
            <remarks>
            <para>
            The ordering of duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
            of insertion, unless the ordering is otherwise specified by use of a
            cursor operation or a duplicate sort function. The ordering of
            duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
            duplicate comparison function. If the application does not specify a
            comparison function using 
            <see cref="F:BerkeleyDB.HashDatabaseConfig.DuplicateCompare"/>, a default lexical
            comparison will be used.
            </para>
            <para>
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to 
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
            applications wanting to order duplicate data items manually.
            </para>
            <para>
            If the database already exists, the value of Duplicates must be the
            same as the existing database or an error will be returned.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.HashDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.HashDatabaseConfig.HashComparison">
            <summary>
            The Hash key comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a key specified by the application with a key currently
            stored in the tree.
            </para>
            <para>
            If no comparison function is specified, the keys are compared
            lexically, with shorter keys collating before longer keys.
            </para>
            <para>
            If the database already exists, the comparison function must be the
            same as that historically used to create the database or corruption
            can occur. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.HashDatabaseConfig.HashFunction">
            <summary>
            A user-defined hash function; if no hash function is specified, a
            default hash function is used. 
            </summary>
            <remarks>
            <para>
            Because no hash function performs equally well on all possible data,
            the user may find that the built-in hash function performs poorly
            with a particular data set.
            </para>
            <para>
            If the database already exists, HashFunction must be the same as
            that historically used to create the database or corruption can
            occur.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.HashDatabaseConfig.DuplicateCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a data item specified by the application with a data item
            currently stored in the database. Setting DuplicateCompare implies 
            setting <see cref="F:BerkeleyDB.HashDatabaseConfig.Duplicates"/> to
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
            </para>
            <para>
            If no comparison function is specified, the data items are compared
            lexically, with shorter data items collating before longer data
            items.
            </para>
            <para>
            If the database already exists when <see cref="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)"/>
            is called, the delegate must be the same as that historically used
            to create the database or corruption can occur.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.HashDatabaseConfig.#ctor">
            <summary>
            Instantiate a new HashDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashDatabaseConfig.FillFactor">
            <summary>
            The desired density within the hash table. If no value is specified,
            the fill factor will be selected dynamically as pages are filled. 
            </summary>
            <remarks>
            <para>
            The density is an approximation of the number of keys allowed to
            accumulate in any one bucket, determining when the hash table grows
            or shrinks. If you know the average sizes of the keys and data in
            your data set, setting the fill factor can enhance performance. A
            reasonable rule computing fill factor is to set it to the following:
            </para>
            <para>
            (pagesize - 32) / (average_key_size + average_data_size + 8)
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.HashDatabaseConfig.TableSize">
            <summary>
            An estimate of the final size of the hash table.
            </summary>
            <remarks>
            <para>
            In order for the estimate to be used when creating the database,
            <see cref="P:BerkeleyDB.HashDatabaseConfig.FillFactor"/> must also be set. If the estimate or fill
            factor are not set or are set too low, hash tables will still expand
            gracefully as keys are entered, although a slight performance
            degradation may be noticed.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.SecondaryRecnoDatabase">
            <summary>
            A class representing a RecnoDatabase. The Recno format supports fixed-
            or variable-length records, accessed sequentially or by logical record
            number, and optionally backed by a flat text file. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.SecondaryDatabase">
            <summary>
            A class representing a secondary Berkeley DB database, a base class for
            access method specific classes.
            </summary>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.#ctor(BerkeleyDB.DatabaseEnvironment,System.UInt32)">
            <summary>
            Protected construtor
            </summary>
            <param name="env">The environment in which to open the DB</param>
            <param name="flags">Flags to pass to DB->create</param>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.Config(BerkeleyDB.SecondaryDatabaseConfig)">
            <summary>
            Protected method to configure the DB.  Only valid before DB->open.
            </summary>
            <param name="cfg">Configuration parameters.</param>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryDatabase object, open the database
            represented by <paramref name="Filename"/> and associate the
            database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
            primary index</see>. The file specified by
            <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryDatabase object, open the database
            represented by <paramref name="Filename"/> and associate the
            database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
            primary index</see>. The file specified by
            <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null and 
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryDatabase object, open the database
            represented by <paramref name="Filename"/> and associate the
            database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
            primary index</see>. The file specified by
            <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryDatabase object, open the database
            represented by <paramref name="Filename"/> and associate the
            database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
            primary index</see>. The file specified by
            <paramref name="Filename"/> must exist.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null and 
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.doAssociate(System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr)">
            <summary>
            Protected method to call the key generation function.
            </summary>
            <param name="dbp">Secondary DB Handle</param>
            <param name="keyp">Primary Key</param>
            <param name="datap">Primary Data</param>
            <param name="skeyp">Scondary Key</param>
            <returns>0 on success, !0 on failure</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.doNullify(System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.Int32@)">
            <summary>
            Protected method to nullify a foreign key
            </summary>
            <param name="dbp">Secondary DB Handle</param>
            <param name="keyp">Primary Key</param>
            <param name="datap">Primary Data</param>
            <param name="fkeyp">Foreign Key</param>
            <param name="changed">Whether the foreign key has changed</param>
            <returns>0 on success, !0 on failure</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.SecondaryCursor">
            <summary>
            Create a secondary database cursor.
            </summary>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.SecondaryCursor(BerkeleyDB.CursorConfig)">
            <summary>
            Create a secondary database cursor with the given configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.SecondaryCursor(BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected secondary database cursor.
            </summary>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryDatabase.SecondaryCursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected secondary database cursor with
            the given configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="P:BerkeleyDB.SecondaryDatabase.KeyGen">
            <summary>
            The delegate that creates the set of secondary keys corresponding to
            a given primary key and data pair. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryRecnoDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryRecnoDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryRecnoDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryRecnoDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabase.Renumber">
            <summary>
            If true, the logical record numbers are mutable, and change as
            records are added to and deleted from the database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabase.Snapshot">
            <summary>
            If true, any <see cref="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile"/> file will be read in its
            entirety when <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> is called. If false,
            <see cref="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile"/> may be read lazily. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabase.Delimiter">
            <summary>
            The delimiting byte used to mark the end of a record in
            <see cref="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabase.Length">
            <summary>
            If using fixed-length, not byte-delimited records, the length of the
            records. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabase.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile">
            <summary>
            The underlying source file for the Recno access method.
            </summary>
        </member>
        <member name="T:BerkeleyDB.TransactionStats">
            <summary>
            Statistical information about the transaction subsystem
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Aborted">
            <summary>
            Number of aborted transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Active">
            <summary>
            Number of active transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Begun">
            <summary>
            Number of begun transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Committed">
            <summary>
            Number of committed transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.LastCheckpoint">
            <summary>
            LSN of the last checkpoint 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.LastCheckpointTime">
            <summary>
            Time of last checkpoint 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.LastID">
            <summary>
            Last transaction id given out 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.MaxActive">
            <summary>
            Maximum active transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.MaxSnapshot">
            <summary>
            Maximum snapshot transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.MaxTransactions">
            <summary>
            Maximum txns possible 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.RegionLockNoWait">
            <summary>
            Region lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.RegionSize">
            <summary>
            Region size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.RegionLockWait">
            <summary>
            Region lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Restored">
            <summary>
            Number of restored transactions after recovery.
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Snapshot">
            <summary>
            Number of snapshot transactions 
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionStats.Transactions">
            <summary>
            List of active transactions
            </summary>
        </member>
        <member name="T:BerkeleyDB.HashCursor">
            <summary>
            A class for traversing the records of a <see cref="T:BerkeleyDB.HashDatabase"/>
            </summary>
        </member>
        <member name="T:BerkeleyDB.Cursor">
            <summary>
            A class representing database cursors, which allow for traversal of 
            database records.
            </summary>
        </member>
        <member name="T:BerkeleyDB.BaseCursor">
            <summary>
            <para>
            The abstract base class from which all cursor classes inherit.
            </para>
            <para>
            Cursors may span threads, but only serially, that is, the application
            must serialize access to the cursor handle.
            </para>
            </summary>
        </member>
        <member name="F:BerkeleyDB.BaseCursor.dbc">
            <summary>
            The underlying DBC handle
            </summary>
        </member>
        <member name="M:BerkeleyDB.BaseCursor.Compare(BerkeleyDB.Cursor)">
            <summary>
            Compare this cursor's position to another's.
            </summary>
            <param name="compareTo">The cursor with which to compare.</param>
            <returns>
            True if both cursors point to the same item, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseCursor.Count">
            <summary>
            Returns a count of the number of data items for the key to which the
            cursor refers. 
            </summary>
            <returns>
            A count of the number of data items for the key to which the cursor
            refers.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BaseCursor.Close">
            <summary>
            <para>
            Discard the cursor.
            </para>
            <para>
            It is possible for the Close() method to throw a
            <see cref="T:BerkeleyDB.DeadlockException"/>, signaling that any enclosing
            transaction should be aborted. If the application is already
            intending to abort the transaction, this error should be ignored,
            and the application should proceed.
            </para>
            <para>
            After Close has been called, regardless of its result, the object
            may not be used again. 
            </para>
            </summary>
            <exception cref="T:BerkeleyDB.DeadlockException"></exception>
        </member>
        <member name="M:BerkeleyDB.BaseCursor.Dispose">
            <summary>
            Release the resources held by this object, and close the cursor if
            it's still open.
            </summary>
        </member>
        <member name="M:BerkeleyDB.BaseCursor.Delete">
            <summary>
            <para>
            Delete the key/data pair to which the cursor refers.
            </para>
            <para>
            When called on a SecondaryCursor, delete the key/data pair from the
            primary database and all secondary indices.
            </para>
            <para>
            The cursor position is unchanged after a delete, and subsequent
            calls to cursor functions expecting the cursor to refer to an
            existing key will fail.
            </para>
            </summary>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            Thrown if the element has already been deleted.
            </exception>
        </member>
        <member name="M:BerkeleyDB.BaseCursor.GetEnumerator">
            <summary>
            Returns an enumerator that iterates through the cursor.
            </summary>
            <returns>An enumerator for the cursor.</returns>
        </member>
        <member name="F:BerkeleyDB.Cursor.pgsz">
            <summary>
            Protected member, storing the pagesize of the underlying database.
            Used during bulk get (i.e. Move*Multiple).
            </summary>
        </member>
        <member name="M:BerkeleyDB.Cursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Protected method for BTree and Hash to insert with KEYFIRST and
            KEYLAST.
            </summary>
            <param name="pair">The key/data pair to add</param>
            <param name="loc">Where to add, if adding duplicate data</param>
        </member>
        <member name="M:BerkeleyDB.Cursor.AddUnique(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
            <summary>
            Protected method for BTree and Hash to insert with NODUPDATA.
            </summary>
            <param name="pair">The key/data pair to add</param>
        </member>
        <member name="M:BerkeleyDB.Cursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Protected method for BTree, Hash and Recno to insert with AFTER and
            BEFORE.
            </summary>
            <param name="data">The duplicate data item to add</param>
            <param name="loc">
            Whether to add the dup data before or after the current cursor
            position
            </param>
        </member>
        <member name="M:BerkeleyDB.Cursor.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32,BerkeleyDB.LockingInfo)">
            <summary>
            Protected method wrapping DBC->get.
            </summary>
            <param name="key">The key to retrieve</param>
            <param name="data">The data to retrieve</param>
            <param name="flags">Modify the behavior of get</param>
            <param name="info">The locking configuration to use</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.GetMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32,System.UInt32,BerkeleyDB.LockingInfo,System.Boolean)">
            <summary>
            Protected method wrapping DBC->get for bulk get.
            </summary>
            <param name="key">The key to retrieve</param>
            <param name="data">The data to retrieve</param>
            <param name="BufferSize">Size of the bulk buffer</param>
            <param name="flags">Modify the behavior of get</param>
            <param name="info">The locking configuration to use</param>
            <param name="isMultKey">
            If true, use DB_MULTIPLE_KEY instead of DB_MULTIPLE
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32)">
            <summary>
            Protected method wrapping DBC->put.
            </summary>
            <param name="key">The key to store</param>
            <param name="data">The data to store</param>
            <param name="flags">Modify the behavior of put</param>
        </member>
        <member name="M:BerkeleyDB.Cursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
            <summary>
            Stores the key/data pair in the database.  
            </summary>
            <remarks>
            If the underlying database supports duplicate data items, and if the
            key already exists in the database and a duplicate sort function has
            been specified, the inserted data item is added in its sorted
            location. If the key already exists in the database and no duplicate
            sort function has been specified, the inserted data item is added as
            the first of the data items for that key. 
            </remarks>
            <param name="pair">
            The key/data pair to be stored in the database.
            </param>
        </member>
        <member name="M:BerkeleyDB.Cursor.Delete">
            <summary>
            Delete the key/data pair to which the cursor refers.
            </summary>
            <remarks>
            <para>
            The cursor position is unchanged after a delete, and subsequent
            calls to cursor functions expecting the cursor to refer to an
            existing key will fail.
            </para>
            </remarks>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            The element has already been deleted.
            </exception>
        </member>
        <member name="M:BerkeleyDB.Cursor.Duplicate(System.Boolean)">
            <summary>
            Create a new cursor that uses the same transaction and locker ID as
            the original cursor.
            </summary>
            <remarks>
            This is useful when an application is using locking and requires two
            or more cursors in the same thread of control.
            </remarks>
            <param name="keepPosition">
            If true, the newly created cursor is initialized to refer to the
            same position in the database as the original cursor (if any) and
            hold the same locks (if any). If false, or the original cursor does
            not hold a database position and locks, the created cursor is
            uninitialized and will behave like a cursor newly created by
            <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.</param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.GetEnumerator">
            <summary>
            Returns an enumerator that iterates through the
            <see cref="T:BerkeleyDB.Cursor"/>.
            </summary>
            <remarks>
            The enumerator will begin at the cursor's current position (or the
            first record if the cursor has not yet been positioned) and iterate 
            forwards (i.e. in the direction of <see cref="M:BerkeleyDB.Cursor.MoveNext"/>) over the
            remaining records.
            </remarks>
            <returns>An enumerator for the Cursor.</returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirst">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the first key has
            duplicate values, the first data item in the set of duplicates is
            stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirst(BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the first key has
            duplicate values, the first data item in the set of duplicates is
            stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultiple">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that key and as many duplicate data items that can fit in
            a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <overloads>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> will
            contain an empty
            <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </overloads>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that key and as many duplicate data items that can fit in
            a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultiple(BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that key and as many duplicate data items that can fit in
            a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that key and as many duplicate data items that can fit in
            a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that pair and as many ensuing key/data pairs that can fit
            in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that pair and as many ensuing key/data pairs that can fit
            in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that pair and as many ensuing key/data pairs that can fit
            in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store that pair and as many ensuing key/data pairs that can fit
            in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store the
            datum associated with the given key in <see cref="P:BerkeleyDB.Cursor.Current"/>. In the
            presence of duplicate key values, the first data item in the set of
            duplicates is stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store the
            datum associated with the given key in <see cref="P:BerkeleyDB.Cursor.Current"/>. In the
            presence of duplicate key values, the first data item in the set of
            duplicates is stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean)">
            <summary>
            Move the cursor to the specified key/data pair of the database. The
            cursor is positioned to a key/data pair if both the key and data
            match the values provided on the key and data parameters. 
            </summary>
            <remarks>
            <para>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </para>
            <para>
            If this flag is specified on a database configured without sorted
            duplicate support, the value of <paramref name="exact"/> is ignored.
            </para>
            </remarks>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Move the cursor to the specified key/data pair of the database. The
            cursor is positioned to a key/data pair if both the key and data
            match the values provided on the key and data parameters. 
            </summary>
            <remarks>
            <para>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </para>
            <para>
            If this flag is specified on a database configured without sorted
            duplicate support, the value of <paramref name="exact"/> is ignored.
            </para>
            </remarks>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveLast">
            <summary>
            Set the cursor to refer to the last key/data pair of the database, 
            and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the last key has
            duplicate values, the last data item in the set of duplicates is
            stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveLast(BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the last key/data pair of the database, 
            and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the last key has
            duplicate values, the last data item in the set of duplicates is
            stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many duplicate data items associated with the given key that
            can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many duplicate data items associated with the given key that
            can fit in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many duplicate data items associated with the given key that
            can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many duplicate data items associated with the given key that
            can fit in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many duplicate data items associated
            with the given key that can fit in a buffer the size of one database
            page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The cursor is positioned to a
            key/data pair if both the key and data match the values provided on
            the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many duplicate data items associated
            with the given key that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The
            cursor is positioned to a key/data pair if both the key and data
            match the values provided on the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many duplicate data items associated
            with the given key that can fit in a buffer the size of one database
            page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The cursor is positioned to a
            key/data pair if both the key and data match the values provided on
            the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many duplicate data items associated
            with the given key that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The
            cursor is positioned to a key/data pair if both the key and data
            match the values provided on the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many ensuing key/data pairs that can fit in a buffer the
            size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many ensuing key/data pairs that can fit in a buffer the
            size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many ensuing key/data pairs that can fit in a buffer the
            size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store that 
            key and as many ensuing key/data pairs that can fit in a buffer the
            size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
            key/data pair if both the key and data match the values provided on
            the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
            key/data pair if both the key and data match the values provided on
            the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
            key/data pair if both the key and data match the values provided on
            the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Move the cursor to the specified key/data pair of the database, and
            store that key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
            key/data pair if both the key and data match the values provided on
            the key and data parameters. 
            </summary>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNext">
            <summary>
            If the cursor is not yet initialized, MoveNext is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveFirst"/>. Otherwise, move the cursor to the next
            key/data pair of the database, and store that pair in
            <see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
            value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNext(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNext is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveFirst(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
            the next key/data pair of the database, and store that pair in
            <see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
            value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultiple">
            <summary>
            If the cursor is not yet initialized, MoveNextMultiple is identical
            to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple"/>. Otherwise, move the cursor to
            the next key/data pair of the database, and store that pair and as
            many duplicate data items that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In the presence of
            duplicate key values, the value of
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
            change. 
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultiple(System.Int32)">
            <summary>
            If the cursor is not yet initialized, MoveNextMultiple is identical
            to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32)"/>. Otherwise, move the cursor
            to the next key/data pair of the database, and store that pair and
            as many duplicate data items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In
            the presence of duplicate key values, the value of
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
            change. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultiple(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextMultiple is identical
            to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(BerkeleyDB.LockingInfo)"/>. Otherwise, move the
            cursor to the next key/data pair of the database, and store that
            pair and as many duplicate data items that can fit in a buffer the
            size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In the
            presence of duplicate key values, the value of
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
            change. 
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultiple(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextMultiple is identical
            to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32,BerkeleyDB.LockingInfo)"/>. Otherwise,
            move the cursor to the next key/data pair of the database, and store
            that pair and as many duplicate data items that can fit in a buffer
            the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In the presence of duplicate key
            values, the value of
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
            change. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey">
            <summary>
            If the cursor is not yet initialized, MoveNextMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey"/>. Otherwise, move
            the cursor to the next key/data pair of the database, and store that
            pair and as many ensuing key/data pairs that can fit in a buffer the
            size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In
            the presence of duplicate key values, the keys of
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not change. 
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey(System.Int32)">
            <summary>
            If the cursor is not yet initialized, MoveNextMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32)"/>. Otherwise,
            move the cursor to the next key/data pair of the database, and store
            that pair and as many ensuing key/data pairs that can fit in a
            buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In the presence of duplicate key
            values, the keys of <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not change. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(BerkeleyDB.LockingInfo)"/>.
            Otherwise, move the cursor to the next key/data pair of the
            database, and store that pair and as many ensuing key/data pairs
            that can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In the presence of duplicate key
            values, the keys of <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not change. 
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32,BerkeleyDB.LockingInfo)"/>.
            Otherwise, move the cursor to the next key/data pair of the
            database, and store that pair and as many ensuing key/data pairs
            that can fit in a buffer the size of <paramref name="BufferSize"/>
            in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In the presence of duplicate
            key values, the keys of <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not
            change. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicate">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            MoveNextDuplicate will return false if the next key/data pair of the
            database is not a duplicate data record for the current key/data
            pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicate(BerkeleyDB.LockingInfo)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            MoveNextDuplicate will return false if the next key/data pair of the
            database is not a duplicate data record for the current key/data
            pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextDuplicateMultiple will return
            false if the next key/data pair of the database is not a duplicate
            data record for the current key/data pair.
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple(System.Int32)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, then move cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            MoveNextDuplicateMultiple will return false if the next key/data
            pair of the database is not a duplicate data record for the current
            key/data pair.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple(BerkeleyDB.LockingInfo)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextDuplicateMultiple will return
            false if the next key/data pair of the database is not a duplicate
            data record for the current key/data pair.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            MoveNextDuplicateMultiple will return false if the next key/data
            pair of the database is not a duplicate data record for the current
            key/data pair.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. MoveNextDuplicateMultipleKey will
            return false if the next key/data pair of the database is not a
            duplicate data record for the current key/data pair.
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey(System.Int32)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            MoveNextDuplicateMultipleKey will return false if the next key/data
            pair of the database is not a duplicate data record for the current
            key/data pair.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey(BerkeleyDB.LockingInfo)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. MoveNextDuplicateMultipleKey will
            return false if the next key/data pair of the database is not a
            duplicate data record for the current key/data pair.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store that pair and as many duplicate data
            items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            MoveNextDuplicateMultipleKey will return false if the next key/data
            pair of the database is not a duplicate data record for the current
            key/data pair.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUnique">
            <summary>
            If the cursor is not yet initialized, MoveNextUnique is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveFirst"/>. Otherwise, move the cursor to the next
            non-duplicate key in the database, and store that key and associated
            datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MoveNextUnique will return false if
            no non-duplicate key/data pairs exist after the cursor position in
            the database. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUnique(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextUnique is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveFirst(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
            the next non-duplicate key in the database, and store that key and 
            associated datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MoveNextUnique will
            return false if no non-duplicate key/data pairs exist after the
            cursor position in the database. 
            </summary>
            <remarks>
            <para>
            If the database is a Queue or Recno database, MoveNextUnique will
            ignore any keys that exist but were never explicitly created by the
            application, or those that were created and later deleted.
            </para>
            <para>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </para>
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultiple is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple"/>. Otherwise, move the
            cursor to the next non-duplicate key in the database, and store that
            key and associated datum and as many duplicate data items that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextUniqueMultiple will return
            false if no non-duplicate key/data pairs exist after the cursor
            position in the database. 
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple(System.Int32)">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultiple is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32)"/>. Otherwise, move
            the cursor to the next non-duplicate key in the database, and store
            that key and associated datum and as many duplicate data items that
            can fit in a buffer the size of <paramref name="BufferSize"/> in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextUniqueMultiple will return
            false if no non-duplicate key/data pairs exist after the cursor
            position in the database. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultiple is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(BerkeleyDB.LockingInfo)"/>.
            Otherwise, move the cursor to the next non-duplicate key in the
            database, and store that key and associated datum and as many
            duplicate data items that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            MoveNextUniqueMultiple will return false if no non-duplicate
            key/data pairs exist after the cursor position in the database. 
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultiple is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32,BerkeleyDB.LockingInfo)"/>.
            Otherwise, move the cursor to the next non-duplicate key in the
            database, and store that key and associated datum and as many
            duplicate data items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            MoveNextUniqueMultiple will return false if no non-duplicate
            key/data pairs exist after the cursor position in the database. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey"/>. Otherwise, move
            the cursor to the next non-duplicate key in the database, and store
            that key and associated datum and as many ensuing key/data pairs
            that can fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. MoveNextUniqueMultipleKey will
            return false if no non-duplicate key/data pairs exist after the
            cursor position in the database. 
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey(System.Int32)">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32)"/>. Otherwise,
            move the cursor to the next non-duplicate key in the database, and
            store that key and associated datum and as many ensuing key/data
            pairs that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            MoveNextUniqueMultipleKey will return false if no non-duplicate
            key/data pairs exist after the cursor position in the database. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(BerkeleyDB.LockingInfo)"/>.
            Otherwise, move the cursor to the next non-duplicate key in the
            database, and store that key and associated datum and as many
            ensuing key/data pairs that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            MoveNextUniqueMultipleKey will return false if no non-duplicate
            key/data pairs exist after the cursor position in the database. 
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
            identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32,BerkeleyDB.LockingInfo)"/>.
            Otherwise, move the cursor to the next non-duplicate key in the
            database, and store that key and associated datum and as many
            ensuing key/data pairs that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            MoveNextUniqueMultipleKey will return false if no non-duplicate
            key/data pairs exist after the cursor position in the database. 
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MovePrev">
            <summary>
            If the cursor is not yet initialized, MovePrev is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveLast"/>. Otherwise, move the cursor to the previous
            key/data pair of the database, and store that pair in
            <see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
            value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MovePrev(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MovePrev is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
            the previous key/data pair of the database, and store that pair in
            <see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
            value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MovePrevDuplicate">
            <summary>
            If the previous key/data pair of the database is a duplicate data
            record for the current key/data pair, the cursor is moved to the
            previous key/data pair of the database, and that pair is stored in
            <see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevDuplicate will return false if the
            previous key/data pair of the database is not a duplicate data
            record for the current key/data pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MovePrevDuplicate(BerkeleyDB.LockingInfo)">
            <summary>
            If the previous key/data pair of the database is a duplicate data
            record for the current key/data pair, the cursor is moved to the
            previous key/data pair of the database, and that pair is stored in
            <see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevDuplicate will return false if the
            previous key/data pair of the database is not a duplicate data
            record for the current key/data pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MovePrevUnique">
            <summary>
            If the cursor is not yet initialized, MovePrevUnique is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveLast"/>. Otherwise, move the cursor to the previous
            non-duplicate key in the database, and store that key and associated
            datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevUnique will return false if
            no non-duplicate key/data pairs exist after the cursor position in
            the database. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.MovePrevUnique(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MovePrevUnique is identical to 
            <see cref="M:BerkeleyDB.Cursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
            the previous non-duplicate key in the database, and store that key
            and associated datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevUnique will
            return false if no non-duplicate key/data pairs exist after the
            cursor position in the database. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Overwrite(BerkeleyDB.DatabaseEntry)">
            <summary>
            Overwrite the data of the key/data pair to which the cursor refers
            with the specified data item.
            </summary>
            <param name="data"></param>
        </member>
        <member name="M:BerkeleyDB.Cursor.Refresh">
            <summary>
            Store the key/data pair to which the cursor refers in
            <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.Refresh(BerkeleyDB.LockingInfo)">
            <summary>
            Store the key/data pair to which the cursor refers in
            <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultiple">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            duplicate data items that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultiple(System.Int32)">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            duplicate data items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultiple(BerkeleyDB.LockingInfo)">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            duplicate data items that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultiple(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            duplicate data items that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultipleKey">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            ensuing key/data pairs that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultipleKey(System.Int32)">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            ensuing key/data pairs that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultipleKey(BerkeleyDB.LockingInfo)">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            ensuing key/data pairs that can fit in a buffer the size of one
            database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.Cursor.RefreshMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Store the key/data pair to which the cursor refers and as many
            ensuing key/data pairs that can fit in a buffer the size of
            <paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="P:BerkeleyDB.Cursor.Current">
            <summary>
            The key/data pair at which the cursor currently points.
            </summary>
            <remarks>
            Only one of <see cref="P:BerkeleyDB.Cursor.Current"/>, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> and
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> will ever be non-empty.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.Cursor.CurrentMultiple">
            <summary>
            The key and multiple data items at which the cursor currently
            points.
            </summary>
            <remarks>
            Only one of <see cref="P:BerkeleyDB.Cursor.Current"/>, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> and
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> will ever be non-empty.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.Cursor.CurrentMultipleKey">
            <summary>
            The multiple key and data items at which the cursor currently
            points.
            </summary>
            <remarks>
            Only one of <see cref="P:BerkeleyDB.Cursor.Current"/>, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> and
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> will ever be non-empty.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.Cursor.Priority">
            <summary>
            The cache priority for pages referenced by the cursor.
            </summary>
            <remarks>
            The priority of a page biases the replacement algorithm to be more
            or less likely to discard a page when space is needed in the buffer
            pool. The bias is temporary, and pages will eventually be discarded
            if they are not referenced again. The setting is only advisory, and
            does not guarantee pages will be treated in a specific way.
            </remarks>
        </member>
        <member name="T:BerkeleyDB.Cursor.InsertLocation">
            <summary>
            Specifies where to place duplicate data elements of the key to which
            the cursor refers.
            </summary>
        </member>
        <member name="F:BerkeleyDB.Cursor.InsertLocation.AFTER">
            <summary>
            The new element appears immediately after the current cursor
            position.
            </summary>
        </member>
        <member name="F:BerkeleyDB.Cursor.InsertLocation.BEFORE">
            <summary>
            The new element appears immediately before the current cursor
            position.
            </summary>
        </member>
        <member name="F:BerkeleyDB.Cursor.InsertLocation.FIRST">
            <summary>
            The new element appears as the first of the data items for the 
            given key
            </summary>
        </member>
        <member name="F:BerkeleyDB.Cursor.InsertLocation.LAST">
            <summary>
            The new element appears as the last of the data items for the 
            given key
            </summary>
        </member>
        <member name="M:BerkeleyDB.HashCursor.Duplicate(System.Boolean)">
            <summary>
            Create a new cursor that uses the same transaction and locker ID as
            the original cursor.
            </summary>
            <remarks>
            This is useful when an application is using locking and requires two
            or more cursors in the same thread of control.
            </remarks>
            <param name="keepPosition">
            If true, the newly created cursor is initialized to refer to the
            same position in the database as the original cursor (if any) and
            hold the same locks (if any). If false, or the original cursor does
            not hold a database position and locks, the created cursor is
            uninitialized and will behave like a cursor newly created by
            <see cref="M:BerkeleyDB.HashDatabase.Cursor"/>.</param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.HashCursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Insert the data element as a duplicate element of the key to which
            the cursor refers.
            </summary>
            <param name="data">The data element to insert</param>
            <param name="loc">
            Specify whether to insert the data item immediately before or
            immediately after the cursor's current position.
            </param>
        </member>
        <member name="M:BerkeleyDB.HashCursor.AddUnique(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
            <summary>
            Insert the specified key/data pair into the database, unless a
            key/data pair comparing equally to it already exists in the
            database.
            </summary>
            <param name="pair">The key/data pair to be inserted</param>
            <exception cref="T:BerkeleyDB.KeyExistException">
            Thrown if a matching key/data pair already exists in the database.
            </exception>
        </member>
        <member name="M:BerkeleyDB.HashCursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Insert the specified key/data pair into the database.
            </summary>
            <param name="pair">The key/data pair to be inserted</param>
            <param name="loc">
            If the key already exists in the database and no duplicate sort
            function has been specified, specify whether the inserted data item
            is added as the first or the last of the data items for that key. 
            </param>
        </member>
        <member name="T:BerkeleyDB.Transaction">
            <summary>
            A class representing Berkeley DB transactions
            </summary>
            <remarks>
            <para>
            Calling <see cref="M:BerkeleyDB.Transaction.Abort"/>,
            <see cref="M:BerkeleyDB.Transaction.Commit"/> or
            <see cref="M:BerkeleyDB.Transaction.Discard"/> will release the resources held by
            the created object.
            </para>
            <para>
            Transactions may only span threads if they do so serially; that is,
            each transaction must be active in only a single thread of control
            at a time. This restriction holds for parents of nested transactions
            as well; no two children may be concurrently active in more than one
            thread of control at any one time.
            </para>
            <para>
            Cursors may not span transactions; that is, each cursor must be
            opened and closed within a single transaction.
            </para>
            <para>
            A parent transaction may not issue any Berkeley DB operations —
            except for <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>, 
            <see cref="M:BerkeleyDB.Transaction.Abort"/>and <see cref="M:BerkeleyDB.Transaction.Commit"/>
            — while it has active child transactions (child transactions that
            have not yet been committed or aborted).
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.Transaction.GlobalIdLength">
            <summary>
            The size of the global transaction ID
            </summary>
        </member>
        <member name="M:BerkeleyDB.Transaction.Abort">
            <summary>
            Cause an abnormal termination of the transaction.
            </summary>
            <remarks>
            <para>
            Before Abort returns, any locks held by the transaction will have
            been released.
            </para>
            <para>
            In the case of nested transactions, aborting a parent transaction
            causes all children (unresolved or not) of the parent transaction to
            be aborted.
            </para>
            <para>
            All cursors opened within the transaction must be closed before the
            transaction is aborted.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.Transaction.Commit">
            <summary>
            End the transaction.
            </summary>
            <overloads>
            <para>
            In the case of nested transactions, if the transaction is a parent
            transaction, committing the parent transaction causes all unresolved
            children of the parent to be committed. In the case of nested
            transactions, if the transaction is a child transaction, its locks
            are not released, but are acquired by its parent. Although the
            commit of the child transaction will succeed, the actual resolution
            of the child transaction is postponed until the parent transaction
            is committed or aborted; that is, if its parent transaction commits,
            it will be committed; and if its parent transaction aborts, it will
            be aborted.
            </para>
            <para>
            All cursors opened within the transaction must be closed before the
            transaction is committed.
            </para>
            </overloads>
        </member>
        <member name="M:BerkeleyDB.Transaction.Commit(System.Boolean)">
            <summary>
            End the transaction.
            </summary>
            <remarks>
            Synchronously flushing the log is the default for Berkeley DB
            environments unless
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoSync"/> was specified.
            Synchronous log flushing may also be set or unset for a single
            transaction using
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>. The
            value of <paramref name="syncLog"/> overrides both of those
            settings.
            </remarks>
            <param name="syncLog">If true, synchronously flush the log.</param>
        </member>
        <member name="M:BerkeleyDB.Transaction.Discard">
            <summary>
            Free up all the per-process resources associated with the specified
            Transaction instance, neither committing nor aborting the
            transaction.
            </summary>
            <remarks>
            This call may be used only after calls to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/> when there are multiple
            global transaction managers recovering transactions in a single
            Berkeley DB environment. Any transactions returned by 
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/> that are not handled by
            the current global transaction manager should be discarded using 
            Discard.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.Transaction.Prepare(System.Byte[])">
            <summary>
            Initiate the beginning of a two-phase commit.
            </summary>
            <remarks>
            <para>
            In a distributed transaction environment, Berkeley DB can be used as
            a local transaction manager. In this case, the distributed
            transaction manager must send prepare messages to each local
            manager. The local manager must then call Prepare and await its
            successful return before responding to the distributed transaction
            manager. Only after the distributed transaction manager receives
            successful responses from all of its prepare messages should it
            issue any commit messages.
            </para>
            <para>
            In the case of nested transactions, preparing the parent causes all
            unresolved children of the parent transaction to be committed. Child
            transactions should never be explicitly prepared. Their fate will be
            resolved along with their parent's during global recovery.
            </para>
            </remarks>
            <param name="globalId">
            The global transaction ID by which this transaction will be known.
            This global transaction ID will be returned in calls to 
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/> telling the
            application which global transactions must be resolved.
            </param>
        </member>
        <member name="M:BerkeleyDB.Transaction.SetLockTimeout(System.UInt32)">
            <summary>
            Set the timeout value for locks for this transaction. 
            </summary>
            <remarks>
            <para>
            Timeouts are checked whenever a thread of control blocks on a lock
            or when deadlock detection is performed. This timeout is for any
            single lock request. As timeouts are only checked when the lock
            request first blocks or when deadlock detection is performed, the
            accuracy of the timeout depends on how often deadlock detection is
            performed.
            </para>
            <para>
            Timeout values may be specified for the database environment as a
            whole. See <see cref="P:BerkeleyDB.DatabaseEnvironment.LockTimeout"/> for more
            information. 
            </para>
            </remarks>
            <param name="timeout">
            An unsigned 32-bit number of microseconds, limiting the maximum
            timeout to roughly 71 minutes. A value of 0 disables timeouts for
            the transaction.
            </param>
        </member>
        <member name="M:BerkeleyDB.Transaction.SetTxnTimeout(System.UInt32)">
            <summary>
            Set the timeout value for transactions for this transaction. 
            </summary>
            <remarks>
            <para>
            Timeouts are checked whenever a thread of control blocks on a lock
            or when deadlock detection is performed. This timeout is for the
            life of the transaction. As timeouts are only checked when the lock
            request first blocks or when deadlock detection is performed, the
            accuracy of the timeout depends on how often deadlock detection is
            performed. 
            </para>
            <para>
            Timeout values may be specified for the database environment as a
            whole. See <see cref="P:BerkeleyDB.DatabaseEnvironment.TxnTimeout"/> for more
            information. 
            </para>
            </remarks>
            <param name="timeout">
            An unsigned 32-bit number of microseconds, limiting the maximum
            timeout to roughly 71 minutes. A value of 0 disables timeouts for
            the transaction.
            </param>
        </member>
        <member name="P:BerkeleyDB.Transaction.Id">
            <summary>
            The unique transaction id associated with this transaction.
            </summary>
        </member>
        <member name="P:BerkeleyDB.Transaction.Name">
            <summary>
            The transaction's name. The name is returned by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats"/>
            and displayed by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats"/>.
            </summary>
            <remarks>
            If the database environment has been configured for logging and the
            Berkeley DB library was built in Debug mode (or with DIAGNOSTIC
            defined), a debugging log record is written including the
            transaction ID and the name.
            </remarks>
        </member>
        <member name="T:BerkeleyDB.QueueDatabase">
            <summary>
            A class representing a QueueDatabase. The Queue format supports fast
            access to fixed-length records accessed sequentially or by logical
            record number.
            </summary>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig)">
            <summary>
            Instantiate a new QueueDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new QueueDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)">
            <summary>
            Append the data item to the end of the database.
            </summary>
            <param name="data">The data item to store in the database</param>
            <returns>The record number allocated to the record</returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Append the data item to the end of the database.
            </summary>
            <remarks>
            There is a minor behavioral difference between
            <see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> and
            <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>. If a transaction enclosing an
            Append operation aborts, the record number may be reallocated in a
            subsequent <see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation, but it will
            not be reallocated in a subsequent
            <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation.
            </remarks>
            <param name="data">The data item to store in the database</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>The record number allocated to the record</returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)">
            <summary>
            Return the record number and data from the available record closest
            to the head of the queue, and delete the record.
            </summary>
            <param name="wait">
            If true and the Queue database is empty, the thread of control will
            wait until there is data in the queue before returning.
            </param>
            <exception cref="T:BerkeleyDB.LockNotGrantedException">
            If lock or transaction timeouts have been specified, a
            <see cref="T:BerkeleyDB.LockNotGrantedException"/> may be thrown. This failure,
            by itself, does not require the enclosing transaction be aborted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is the record number and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean,BerkeleyDB.Transaction)">
            <summary>
            Return the record number and data from the available record closest
            to the head of the queue, and delete the record.
            </summary>
            <param name="wait">
            If true and the Queue database is empty, the thread of control will
            wait until there is data in the queue before returning.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <exception cref="T:BerkeleyDB.LockNotGrantedException">
            If lock or transaction timeouts have been specified, a
            <see cref="T:BerkeleyDB.LockNotGrantedException"/> may be thrown. This failure,
            by itself, does not require the enclosing transaction be aborted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is the record number and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            Return the record number and data from the available record closest
            to the head of the queue, and delete the record.
            </summary>
            <param name="wait">
            If true and the Queue database is empty, the thread of control will
            wait until there is data in the queue before returning.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <exception cref="T:BerkeleyDB.LockNotGrantedException">
            If lock or transaction timeouts have been specified, a
            <see cref="T:BerkeleyDB.LockNotGrantedException"/> may be thrown. This failure,
            by itself, does not require the enclosing transaction be aborted.
            </exception>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is the record number and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.FastStats">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.FastStats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.FastStats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <overloads>
            <para>
            Among other things, this method makes it possible for applications
            to request key and record counts without incurring the performance
            penalty of traversing the entire database. 
            </para>
            <para>
            The statistical information is described by the
            <see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
            <see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes. 
            </para>
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Stats">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Stats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.QueueDatabase.Stats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <overloads>
            The statistical information is described by
            <see cref="T:BerkeleyDB.BTreeStats"/>. 
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="P:BerkeleyDB.QueueDatabase.ExtentSize">
            <summary>
            The size of the extents used to hold pages in a
            <see cref="T:BerkeleyDB.QueueDatabase"/>, specified as a number of pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueDatabase.InOrder">
            <summary>
            If true, modify the operation of <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/>
            to return key/data pairs in order. That is, they will always return
            the key/data item from the head of the queue. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueDatabase.Length">
            <summary>
            The length of records in the database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueDatabase.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
        </member>
        <member name="T:BerkeleyDB.PreparedTransaction">
            <summary>
            A class representing a transaction that must be resolved by the
            application following <see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.PreparedTransaction.Txn">
            <summary>
            The transaction which must be committed, aborted or discarded.
            </summary>
        </member>
        <member name="P:BerkeleyDB.PreparedTransaction.GlobalID">
            <summary>
            The global transaction ID for the transaction. The global
            transaction ID is the one specified when the transaction was
            prepared. The application is responsible for ensuring uniqueness
            among global transaction IDs.
            </summary>
        </member>
        <member name="T:BerkeleyDB.MPoolFileStats">
            <summary>
            Statistical information about a file in the memory pool
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.FileName">
            <summary>
            File name.
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.MappedPages">
            <summary>
            Pages from mapped files. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.PagesCreatedInCache">
            <summary>
            Pages created in the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.PagesInCache">
            <summary>
            Pages found in the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.PagesNotInCache">
            <summary>
            Pages not found in the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.PagesRead">
            <summary>
            Pages read in. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.PageSize">
            <summary>
            Page size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolFileStats.PagesWritten">
            <summary>
            Pages written out. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.LockingConfig">
            <summary>
            A class representing configuration parameters for a
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s locking subsystem.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LockingConfig.DeadlockResolution">
            <summary>
            If non-null, the deadlock detector is to be run whenever a lock
            conflict occurs, lock request(s) should be rejected according to the
            specified policy.
            </summary>
            <remarks>
            <para>
            As transactions acquire locks on behalf of a single locker ID,
            rejecting a lock request associated with a transaction normally
            requires the transaction be aborted.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LockingConfig.Conflicts">
            <summary>
            The locking conflicts matrix. 
            </summary>
            <remarks>
            <para>
            If Conflicts is never set, a standard conflicts array is used; see
            Standard Lock Modes in the Programmer's Reference Guide for more
            information.
            </para>
            <para>
            Conflicts parameter is an nmodes by nmodes array. A non-0 value for
            the array element indicates that requested_mode and held_mode
            conflict:
            <code>
            conflicts[requested_mode][held_mode] 
            </code>
            </para>
            <para>The not-granted mode must be represented by 0.</para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            Conflicts will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LockingConfig.MaxLockers">
            <summary>
            The maximum number of simultaneous locking entities supported by the
            Berkeley DB environment
            </summary>
            <remarks>
            <para>
            This value is used by <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> to
            estimate how much space to allocate for various lock-table data
            structures. The default value is 1000 lockers. For specific
            information on configuring the size of the lock subsystem, see
            Configuring locking: sizing the system in the Programmer's Reference
            Guide.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            MaxLockers will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LockingConfig.MaxLocks">
            <summary>
            The maximum number of locks supported by the Berkeley DB
            environment.
            </summary>
            <remarks>
            <para>
            This value is used by <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> to
            estimate how much space to allocate for various lock-table data
            structures. The default value is 1000 lockers. For specific
            information on configuring the size of the lock subsystem, see
            Configuring locking: sizing the system in the Programmer's Reference
            Guide.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            MaxLocks will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LockingConfig.MaxObjects">
            <summary>
            The maximum number of locked objects supported by the Berkeley DB
            environment.
            </summary>
            <remarks>
            <para>
            This value is used by <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> to
            estimate how much space to allocate for various lock-table data
            structures. The default value is 1000 lockers. For specific
            information on configuring the size of the lock subsystem, see
            Configuring locking: sizing the system in the Programmer's Reference
            Guide.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            MaxObjects will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LockingConfig.Partitions">
            <summary>
            The number of lock table partitions in the Berkeley DB environment.
            </summary>
            <remarks>
            <para>
            The default value is 10 times the number of CPUs on the system if
            there is more than one CPU. Increasing the number of partitions can
            provide for greater throughput on a system with multiple CPUs and
            more than one thread contending for the lock manager. On single
            processor systems more than one partition may increase the overhead
            of the lock manager. Systems often report threading contexts as
            CPUs. If your system does this, set the number of partitions to 1 to
            get optimal performance.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            Partitions will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.BTreeDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.BTreeDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.Duplicates">
            <summary>
            Policy for duplicate data items in the database; that is, insertion
            when the key of the key/data pair being inserted already exists in
            the database will be successful.
            </summary>
            <remarks>
            <para>The ordering of duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
            of insertion, unless the ordering is otherwise specified by use of a
            cursor operation or a duplicate sort function. The ordering of
            duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
            duplicate comparison function. If the application does not specify a
            comparison function using 
            <see cref="F:BerkeleyDB.BTreeDatabaseConfig.DuplicateCompare"/>, a default lexical
            comparison will be used.
            </para>
            <para>
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to 
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
            applications wanting to order duplicate data items manually.
            </para>
            <para>
            If the database already exists, the value of Duplicates must be the
            same as the existing database or an error will be returned.
            </para>
            <para>
            It is an error to specify <see cref="F:BerkeleyDB.BTreeDatabaseConfig.UseRecordNumbers"/> and
            anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.NoReverseSplitting">
            <summary>
            Turn reverse splitting in the Btree on or off.
            </summary>
            <remarks>
            As pages are emptied in a database, the Berkeley DB Btree
            implementation attempts to coalesce empty pages into higher-level
            pages in order to keep the database as small as possible and
            minimize search time. This can hurt performance in applications with
            cyclical data demands; that is, applications where the database
            grows and shrinks repeatedly. For example, because Berkeley DB does
            page-level locking, the maximum level of concurrency in a database
            of two pages is far smaller than that in a database of 100 pages, so
            a database that has shrunk to a minimal size can cause severe
            deadlocking when a new cycle of data insertion begins. 
            </remarks>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.UseRecordNumbers">
            <summary>
            If true, support retrieval from the Btree using record numbers.
            </summary>
            <remarks>
            <para>
            Logical record numbers in Btree databases are mutable in the face of
            record insertion or deletion. See
            <see cref="F:BerkeleyDB.RecnoDatabaseConfig.Renumber"/> for further discussion.
            </para>
            <para>
            Maintaining record counts within a Btree introduces a serious point
            of contention, namely the page locations where the record counts are
            stored. In addition, the entire database must be locked during both
            insertions and deletions, effectively single-threading the database
            for those operations. Specifying UseRecordNumbers can result in
            serious performance degradation for some applications and data sets.
            </para>
            <para>
            It is an error to specify <see cref="F:BerkeleyDB.BTreeDatabaseConfig.UseRecordNumbers"/> and
            anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
            </para>
            <para>
            If the database already exists, the value of UseRecordNumbers must
            be the same as the existing database or an error will be returned. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.BTreeCompare">
            <summary>
            The Btree key comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a key specified by the application with a key currently
            stored in the tree.
            </para>
            <para>
            If no comparison function is specified, the keys are compared
            lexically, with shorter keys collating before longer keys.
            </para>
            <para>
            If the database already exists, the comparison function must be the
            same as that historically used to create the database or corruption
            can occur. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.BTreePrefixCompare">
            <summary>
            The Btree prefix function.
            </summary>
            <remarks>
            <para>
            The prefix function is used to determine the amount by which keys
            stored on the Btree internal pages can be safely truncated without
            losing their uniqueness. See the Btree prefix comparison section of
            the Berkeley DB Reference Guide for more details about how this
            works. The usefulness of this is data-dependent, but can produce
            significantly reduced tree sizes and search times in some data sets.
            </para>
            <para>
            If no prefix function or key comparison function is specified by the
            application, a default lexical comparison function is used as the
            prefix function. If no prefix function is specified and
            <see cref="F:BerkeleyDB.BTreeDatabaseConfig.BTreeCompare"/> is specified, no prefix function is
            used. It is an error to specify a prefix function without also
            specifying <see cref="F:BerkeleyDB.BTreeDatabaseConfig.BTreeCompare"/>. 
            </para>
            <para>
            If the database already exists, the prefix function must be the
            same as that historically used to create the database or corruption
            can occur. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.BTreeDatabaseConfig.DuplicateCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a data item specified by the application with a data item
            currently stored in the database. Setting DuplicateCompare implies 
            setting <see cref="F:BerkeleyDB.BTreeDatabaseConfig.Duplicates"/> to
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
            </para>
            <para>
            If no comparison function is specified, the data items are compared
            lexically, with shorter data items collating before longer data
            items.
            </para>
            <para>
            If the database already exists when
            <see cref="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)"/> is called, the
            delegate must be the same as that historically used to create the
            database or corruption can occur.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabaseConfig.SetCompression">
            <summary>
            Enable compression of the key/data pairs stored in the database,
            using the default compression and decompression functions.
            </summary>
            <remarks>
            The default functions perform prefix compression on keys, and prefix
            compression on data items for duplicate keys.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabaseConfig.SetCompression(BerkeleyDB.BTreeCompressDelegate,BerkeleyDB.BTreeDecompressDelegate)">
            <summary>
            Enable compression of the key/data pairs stored in the database,
            using the specified compression and decompression functions.
            </summary>
            <param name="compression">The compression function</param>
            <param name="decompression">The decompression function</param>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabaseConfig.#ctor">
            <summary>
            Create a new BTreeDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabaseConfig.Compress">
            <summary>
            The compression function used to store key/data pairs in the
            database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabaseConfig.Decompress">
            <summary>
            The decompression function used to retrieve key/data pairs from the
            database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabaseConfig.MinKeysPerPage">
            <summary>
            The minimum number of key/data pairs intended to be stored on any
            single Btree leaf page.
            </summary>
            <remarks>
            <para>
            This value is used to determine if key or data items will be stored
            on overflow pages instead of Btree leaf pages. For more information
            on the specific algorithm used, see the Berkeley DB Reference Guide.
            The value specified must be at least 2; if not explicitly set, a
            value of 2 is used. 
            </para>
            <para>
            If the database already exists, MinKeysPerPage will be ignored. 
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.SequenceConfig">
            <summary>
            Configuration properties for a Sequence
            </summary>
        </member>
        <member name="F:BerkeleyDB.SequenceConfig.Creation">
            <summary>
            The policy for how to handle sequence creation.
            </summary>
            <remarks>
            If the sequence does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set, the Sequence constructor
            will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SequenceConfig.FreeThreaded">
            <summary>
            If true, the object returned by the Sequence constructor will be
            free-threaded; that is, usable by multiple threads within a single
            address space. Note that if multiple threads create multiple
            sequences using the same <see cref="F:BerkeleyDB.SequenceConfig.BackingDatabase"/>, that
            database must have also been opened free-threaded.
            </summary>
        </member>
        <member name="F:BerkeleyDB.SequenceConfig.BackingDatabase">
            <summary>
            An open database which holds the persistent data for the sequence.
            </summary>
            <remarks>
            <para>
            The database may be of any type, but must not have been configured
            to support duplicate data items.
            </para>
            <para>
            If <paramref name="P:BackingDatabase"/> was opened in a transaction,
            calling Get may result in changes to the sequence object; these
            changes will be automatically committed in a transaction internal to
            the Berkeley DB library. If the thread of control calling Get has an
            active transaction, which holds locks on the same database as the
            one in which the sequence object is stored, it is possible for a
            thread of control calling Get to self-deadlock because the active
            transaction's locks conflict with the internal transaction's locks.
            For this reason, it is often preferable for sequence objects to be
            stored in their own database. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SequenceConfig.key">
            <summary>
            The record in the database that stores the persistent sequence data. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.SequenceConfig.Wrap">
            <summary>
            If true, the sequence should wrap around when it is incremented
            (decremented) past the specified maximum (minimum) value. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.SequenceConfig.SetRange(System.Int64,System.Int64)">
            <summary>
            Set the minimum and maximum values in the sequence.
            </summary>
            <param name="Max">The maximum value in the sequence.</param>
            <param name="Min">The minimum value in the sequence.</param>
        </member>
        <member name="P:BerkeleyDB.SequenceConfig.InitialValue">
            <summary>
            The initial value for a sequence.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceConfig.Decrement">
            <summary>
            If true, the sequence will be decremented.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceConfig.Increment">
            <summary>
            If true, the sequence will be incremented. This is the default. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceConfig.CacheSize">
            <summary>
            The number of elements cached by a sequence handle.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceConfig.Min">
            <summary>
            The minimum value in the sequence.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SequenceConfig.Max">
            <summary>
            The maximum value in the sequence.
            </summary>
        </member>
        <member name="T:BerkeleyDB.SecondaryHashDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.SecondaryHashDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.Duplicates">
            <summary>
            Policy for duplicate data items in the database; that is, insertion
            when the key of the key/data pair being inserted already exists in
            the database will be successful.
            </summary>
            <remarks>
            <para>
            The ordering of duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
            of insertion, unless the ordering is otherwise specified by use of a
            cursor operation or a duplicate sort function. The ordering of
            duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
            duplicate comparison function. If the application does not specify a
            comparison function using 
            <see cref="F:BerkeleyDB.SecondaryHashDatabaseConfig.DuplicateCompare"/>, a default lexical
            comparison will be used.
            </para>
            <para>
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to 
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
            applications wanting to order duplicate data items manually.
            </para>
            <para>
            If the database already exists, the value of Duplicates must be the
            same as the existing database or an error will be returned.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.Compare">
            <summary>
            The Secondary Hash key comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a key specified by the application with a key currently
            stored in the tree.
            </para>
            <para>
            If no comparison function is specified, the keys are compared
            lexically, with shorter keys collating before longer keys.
            </para>
            <para>
            If the database already exists, the comparison function must be the
            same as that historically used to create the database or corruption
            can occur. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.HashFunction">
            <summary>
            A user-defined hash function; if no hash function is specified, a
            default hash function is used. 
            </summary>
            <remarks>
            <para>
            Because no hash function performs equally well on all possible data,
            the user may find that the built-in hash function performs poorly
            with a particular data set.
            </para>
            <para>
            If the database already exists, HashFunction must be the same as
            that historically used to create the database or corruption can
            occur.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.DuplicateCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a data item specified by the application with a data item
            currently stored in the database. Setting DuplicateCompare implies 
            setting <see cref="F:BerkeleyDB.SecondaryHashDatabaseConfig.Duplicates"/> to
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
            </para>
            <para>
            If no comparison function is specified, the data items are compared
            lexically, with shorter data items collating before longer data
            items.
            </para>
            <para>
            If the database already exists when
            <see cref="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig)"/> is called, the delegate
            must be the same as that historically used to create the database or
            corruption can occur.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.SecondaryHashDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
            <summary>
            Instantiate a new SecondaryHashDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabaseConfig.FillFactor">
            <summary>
            The desired density within the hash table. If no value is specified,
            the fill factor will be selected dynamically as pages are filled. 
            </summary>
            <remarks>
            <para>
            The density is an approximation of the number of keys allowed to
            accumulate in any one bucket, determining when the hash table grows
            or shrinks. If you know the average sizes of the keys and data in
            your data set, setting the fill factor can enhance performance. A
            reasonable rule computing fill factor is to set it to the following:
            </para>
            <para>
            (pagesize - 32) / (average_key_size + average_data_size + 8)
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabaseConfig.TableSize">
            <summary>
            An estimate of the final size of the hash table.
            </summary>
            <remarks>
            <para>
            In order for the estimate to be used when creating the database,
            <see cref="P:BerkeleyDB.SecondaryHashDatabaseConfig.FillFactor"/> must also be set. If the estimate or fill
            factor are not set or are set too low, hash tables will still expand
            gracefully as keys are entered, although a slight performance
            degradation may be noticed.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.MPoolStats">
            <summary>
            Statistical information about the memory pool subsystem
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.CacheSettings">
            <summary>
            Total cache size and number of regions
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.CacheRegions">
            <summary>
            Maximum number of regions. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxMMapSize">
            <summary>
            Maximum file size for mmap. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxOpenFileDescriptors">
            <summary>
            Maximum number of open fd's. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxBufferWrites">
            <summary>
            Maximum buffers to write. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxBufferWritesSleep">
            <summary>
            Sleep after writing max buffers. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.Pages">
            <summary>
            Total number of pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MappedPages">
            <summary>
            Pages from mapped files. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesInCache">
            <summary>
            Pages found in the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesNotInCache">
            <summary>
            Pages not found in the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesCreatedInCache">
            <summary>
            Pages created in the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesRead">
            <summary>
            Pages read in. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesWritten">
            <summary>
            Pages written out. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.CleanPagesEvicted">
            <summary>
            Clean pages forced from the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.DirtyPagesEvicted">
            <summary>
            Dirty pages forced from the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesTrickled">
            <summary>
            Pages written by memp_trickle. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.CleanPages">
            <summary>
            Clean pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.DirtyPages">
            <summary>
            Dirty pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.HashBuckets">
            <summary>
            Number of hash buckets. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PageSize">
            <summary>
            Assumed page size.
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.HashChainSearches">
            <summary>
            Total hash chain searches. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.LongestHashChainSearch">
            <summary>
            Longest hash chain searched. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.HashEntriesSearched">
            <summary>
            Total hash entries searched. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.HashLockNoWait">
            <summary>
            Hash lock granted with nowait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.HashLockWait">
            <summary>
            Hash lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxHashLockNoWait">
            <summary>
            Max hash lock granted with nowait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxHashLockWait">
            <summary>
            Max hash lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.RegionLockNoWait">
            <summary>
            Region lock granted with nowait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.RegionLockWait">
            <summary>
            Region lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.FrozenBuffers">
            <summary>
            Buffers frozen. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.ThawedBuffers">
            <summary>
            Buffers thawed. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.FrozenBuffersFreed">
            <summary>
            Frozen buffers freed. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PageAllocations">
            <summary>
            Number of page allocations. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.BucketsCheckedDuringAlloc">
            <summary>
            Buckets checked during allocation. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxBucketsCheckedDuringAlloc">
            <summary>
            Max checked during allocation. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.PagesCheckedDuringAlloc">
            <summary>
            Pages checked during allocation. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.MaxPagesCheckedDuringAlloc">
            <summary>
            Max checked during allocation. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.BlockedOperations">
            <summary>
            Thread waited on buffer I/O. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.SyncInterrupted">
            <summary>
            Number of times sync interrupted.
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.RegionSize">
            <summary>
            Region size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolStats.Files">
            <summary>
            Stats for files open in the memory pool
            </summary>
        </member>
        <member name="T:BerkeleyDB.BTreeStats">
            <summary>
            Statistical information about a BTreeDatabase
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.DuplicatePages">
            <summary>
            Duplicate pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.DuplicatePagesFreeBytes">
            <summary>
            Bytes free in duplicate pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.EmptyPages">
            <summary>
            Empty pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.FreePages">
            <summary>
            Pages on the free list. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.InternalPages">
            <summary>
            Internal pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.InternalPagesFreeBytes">
            <summary>
            Bytes free in internal pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.LeafPages">
            <summary>
            Leaf pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.LeafPagesFreeBytes">
            <summary>
            Bytes free in leaf pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.Levels">
            <summary>
            Tree levels. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.MagicNumber">
            <summary>
            Magic number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.MetadataFlags">
            <summary>
            Metadata flags. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.MinKey">
            <summary>
            Minkey value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.nData">
            <summary>
            Number of data items. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.nKeys">
            <summary>
            Number of unique keys. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.nPages">
            <summary>
            Page count. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.OverflowPages">
            <summary>
            Overflow pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.OverflowPagesFreeBytes">
            <summary>
            Bytes free in overflow pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.PageSize">
            <summary>
            Page size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeStats.Version">
            <summary>
            Version number. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.RecnoCursor">
            <summary>
            A class for traversing the records of a <see cref="T:BerkeleyDB.RecnoDatabase"/>
            </summary>
        </member>
        <member name="M:BerkeleyDB.RecnoCursor.Duplicate(System.Boolean)">
            <summary>
            Create a new cursor that uses the same transaction and locker ID as
            the original cursor.
            </summary>
            <remarks>
            This is useful when an application is using locking and requires two
            or more cursors in the same thread of control.
            </remarks>
            <param name="keepPosition">
            If true, the newly created cursor is initialized to refer to the
            same position in the database as the original cursor (if any) and
            hold the same locks (if any). If false, or the original cursor does
            not hold a database position and locks, the created cursor is
            uninitialized and will behave like a cursor newly created by
            <see cref="M:BerkeleyDB.RecnoDatabase.Cursor"/>.</param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoCursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Insert the data element as a duplicate element of the key to which
            the cursor refers.
            </summary>
            <param name="data">The data element to insert</param>
            <param name="loc">
            Specify whether to insert the data item immediately before or
            immediately after the cursor's current position.
            </param>
        </member>
        <member name="T:BerkeleyDB.SecondaryQueueDatabase">
            <summary>
            A class representing a SecondaryQueueDatabase. The Queue format supports
            fast access to fixed-length records accessed sequentially or by logical
            record number.
            </summary>
        </member>
        <member name="M:BerkeleyDB.SecondaryQueueDatabase.Open(System.String,BerkeleyDB.SecondaryQueueDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryQueueDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryQueueDatabase.Open(System.String,BerkeleyDB.SecondaryQueueDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryQueueDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="P:BerkeleyDB.SecondaryQueueDatabase.ExtentSize">
            <summary>
            The size of the extents used to hold pages in a
            <see cref="T:BerkeleyDB.QueueDatabase"/>, specified as a number of pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryQueueDatabase.Length">
            <summary>
            The length of records in the database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryQueueDatabase.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
        </member>
        <member name="T:BerkeleyDB.DatabaseEntry">
            <summary>
            A class representing a key or data item in a Berkeley DB database
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEntry.#ctor">
            <summary>
            Create a new, empty DatabaseEntry object.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEntry.#ctor(System.Byte[])">
            <summary>
            Create a new DatabaseEntry object, with the specified data 
            </summary>
            <param name="data">The new object's <see cref="P:BerkeleyDB.DatabaseEntry.Data"/></param>
        </member>
        <member name="M:BerkeleyDB.DatabaseEntry.Dispose">
            <summary>
            Release the resources held by the underlying C library.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEntry.Data">
            <summary>
            The byte string stored in or retrieved from a database
            </summary>
        </member>
        <member name="T:BerkeleyDB.AckPolicy">
            <summary>
            The AckPolicy class specifies how master and client sites will handle
            acknowledgment of replication messages which are necessary for
            "permanent" records. The current implementation requires all sites in a
            replication group configure the same acknowledgement policy. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.AckPolicy.ALL">
            <summary>
            The master should wait until all replication clients have
            acknowledged each permanent replication message.
            </summary>
        </member>
        <member name="F:BerkeleyDB.AckPolicy.ALL_PEERS">
            <summary>
            The master should wait until all electable peers have acknowledged
            each permanent replication message (where "electable peer" means a
            client capable of being subsequently elected master of the
            replication group).
            </summary>
        </member>
        <member name="F:BerkeleyDB.AckPolicy.NONE">
            <summary>
            The master should not wait for any client replication message
            acknowledgments.
            </summary>
        </member>
        <member name="F:BerkeleyDB.AckPolicy.ONE">
            <summary>
            The master should wait until at least one client site has
            acknowledged each permanent replication message. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.AckPolicy.ONE_PEER">
            <summary>
            The master should wait until at least one electable peer has
            acknowledged each permanent replication message (where "electable
            peer" means a client capable of being subsequently elected master of
            the replication group).
            </summary>
        </member>
        <member name="F:BerkeleyDB.AckPolicy.QUORUM">
            <summary>
            The master should wait until it has received acknowledgements from
            the minimum number of electable peers sufficient to ensure that the
            effect of the permanent record remains durable if an election is
            held (where "electable peer" means a client capable of being
            subsequently elected master of the replication group). This is the
            default acknowledgement policy.
            </summary>
        </member>
        <member name="T:BerkeleyDB.TransactionConfig">
            <summary>
            A class representing configuration parameters for a
            <see cref="T:BerkeleyDB.Transaction"/>.
            </summary>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.IsolationDegree">
            <summary>
            The degree of isolation for this transaction
            </summary>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.NoWait">
            <summary>
            If true and a lock is unavailable for any Berkeley DB operation
            performed in the context of a transaction, cause the operation to
            throw a <see cref="T:BerkeleyDB.DeadlockException"/>
            (or <see cref="T:BerkeleyDB.LockNotGrantedException"/> if configured with
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted"/>).
            </summary>
            <remarks>
            <para>
            This setting overrides the behavior specified by
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoWait"/>.
            </para>
            </remarks>    
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.Snapshot">
            <summary>
            If true, this transaction will execute with snapshot isolation.
            </summary>
            <remarks>
            <para>
            For databases with <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> set, data
            values will be read as they are when the transaction begins, without
            taking read locks. Silently ignored for operations on databases with
            <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> not set on the underlying
            database (read locks are acquired).
            </para>
            <para>
            A <see cref="T:BerkeleyDB.DeadlockException"/> will be thrown from update
            operations if a snapshot transaction attempts to update data which
            was modified after the snapshot transaction read it.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.SyncAction">
            <summary>
            Log sync behavior on transaction commit or prepare.
            </summary>
            <remarks>
            <para>
            This setting overrides the behavior specified by
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoSync"/> and
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnWriteNoSync"/>.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.TransactionConfig.#ctor">
            <summary>
            Instantiate a new TransactionConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.TransactionConfig.LockTimeout">
            <summary>
            The timeout value for locks for the transaction. 
            </summary>
            <remarks>
            <para>
            Timeouts are checked whenever a thread of control blocks on a lock
            or when deadlock detection is performed. This timeout is for any
            single lock request. As timeouts are only checked when the lock
            request first blocks or when deadlock detection is performed, the
            accuracy of the timeout depends on how often deadlock detection is
            performed.
            </para>
            <para>
            Timeout values may be specified for the database environment as a
            whole. See <see cref="P:BerkeleyDB.DatabaseEnvironmentConfig.LockTimeout"/> for
            more information.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.TransactionConfig.Name">
            <summary>
            The transaction's name. The name is returned by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats"/>
            and displayed by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats"/>.
            </summary>
            <remarks>
            If the database environment has been configured for logging and the
            Berkeley DB library was built in Debug mode (or with DIAGNOSTIC
            defined), a debugging log record is written including the
            transaction ID and the name.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.TransactionConfig.TxnTimeout">
            <summary>
            The timeout value for locks for the transaction. 
            </summary>
            <remarks>
            <para>
            Timeouts are checked whenever a thread of control blocks on a lock
            or when deadlock detection is performed. This timeout is for the
            life of the transaction. As timeouts are only checked when the lock
            request first blocks or when deadlock detection is performed, the
            accuracy of the timeout depends on how often deadlock detection is
            performed.
            </para>
            <para>
            Timeout values may be specified for the database environment as a
            whole. See <see cref="P:BerkeleyDB.DatabaseEnvironmentConfig.TxnTimeout"/> for
            more information.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.TransactionConfig.LogFlush">
            <summary>
            Specifies the log flushing behavior on transaction commit
            </summary>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.LogFlush.DEFAULT">
            <summary>
            Use Berkeley DB's default behavior of syncing the log on commit.
            </summary>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.LogFlush.NOSYNC">
            <summary>
            Berkeley DB will not write or synchronously flush the log on
            transaction commit or prepare.
            </summary>
            <remarks>
            <para>
            This means the transaction will exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability);
            that is, database integrity will be maintained but it is
            possible that this transaction may be undone during recovery. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.LogFlush.WRITE_NOSYNC">
            <summary>
            Berkeley DB will write, but will not synchronously flush, the
            log on transaction commit or prepare. 
            </summary>
            <remarks>
            <para>
            This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability);
            that is, database integrity will be maintained, but if the
            system fails, it is possible some number of the most recently
            committed transactions may be undone during recovery. The number
            of transactions at risk is governed by how often the system
            flushes dirty buffers to disk and how often the log is
            checkpointed.
            </para>
            <para>
            For consistent behavior across the environment, all 
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/> objects opened in the
            environment must either set WRITE_NOSYNC, or the
            DB_TXN_WRITE_NOSYNC flag should be specified in the DB_CONFIG
            configuration file.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.TransactionConfig.LogFlush.SYNC">
            <summary>
            Berkeley DB will synchronously flush the log on transaction
            commit or prepare. 
            </summary>
            <remarks>
            This means the transaction will exhibit all of the ACID
            (atomicity, consistency, isolation, and durability) properties.
            </remarks>
        </member>
        <member name="T:BerkeleyDB.RepProcMsgResult">
            <summary>
            A class representing the return value of
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.Result">
            <summary>
            The result of processing an incoming replication message.
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.RetLsn">
            <summary>
            The log sequence number of the permanent log message that could not
            be written to disk if <see cref="F:BerkeleyDB.RepProcMsgResult.Result"/> is
            <see cref="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.NOT_PERMANENT"/>. The largest log
            sequence number of the permanent records that are now written to
            disk as a result of processing the message, if
            <see cref="F:BerkeleyDB.RepProcMsgResult.Result"/> is
            <see cref="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.IS_PERMANENT"/>. In all other cases the
            value is undefined. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.RepProcMsgResult.ProcMsgResult">
            <summary>
            The result of processing an incoming replication message.
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.DUPLICATE_MASTER">
            <summary>
            The replication group has more than one master.
            </summary>
            <remarks>
            The application should reconfigure itself as a client by calling
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/>,
            and then call for an election using
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.ERROR">
            <summary>
            An unspecified error occurred.
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.HOLD_ELECTION">
            <summary>
            An election is needed.
            </summary>
            <remarks>
            The application should call for an election using
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>. 
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.IGNORED">
            <summary>
            A message cannot be processed.
            </summary>
            <remarks>
            This is an indication that a message is irrelevant to the
            current replication state (for example, an old message from a
            previous generation arrives and is processed late).
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.IS_PERMANENT">
            <summary>
            Processing a message resulted in the processing of records that
            are permanent.
            </summary>
            <remarks>
            <see cref="F:BerkeleyDB.RepProcMsgResult.RetLsn"/> is the maximum LSN of the permanent
            records stored.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.JOIN_FAILURE">
            <summary>
            A new master has been chosen but the client is unable to
            synchronize with the new master.
            </summary>
            <remarks>
            Possibly because the client has been configured with
            <see cref="F:BerkeleyDB.ReplicationConfig.NoAutoInit"/> to turn off
            automatic internal initialization.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.NEW_SITE">
            <summary>
            The system received contact information from a new environment.
            </summary>
            <remarks>
            The rec parameter to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/> contains the
            opaque data specified in the cdata parameter to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/>. The
            application should take whatever action is needed to establish a
            communication channel with this new environment.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.NOT_PERMANENT">
            <summary>
            A message carrying a DB_REP_PERMANENT flag was processed
            successfully, but was not written to disk.
            </summary>
            <remarks>
            <see cref="F:BerkeleyDB.RepProcMsgResult.RetLsn"/> is the LSN of this record. The application
            should take whatever action is deemed necessary to retain its
            recoverability characteristics. 
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.SUCCESS">
            <summary>
            Processing a message succeded.
            </summary>
        </member>
        <member name="T:BerkeleyDB.CompactConfig">
            <summary>
            A class to represent configuration settings for
            <see cref="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig)"/> and
            <see cref="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig)"/>.
            </summary>
        </member>
        <member name="F:BerkeleyDB.CompactConfig.returnEnd">
            <summary>
            Return the database key marking the end of the compaction operation
            in a Btree or Recno database. This is generally the first key of the
            page where the operation stopped. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.CompactConfig.start">
            <summary>
            If non-null, the starting point for compaction. Compaction will
            start at the smallest key greater than or equal to
            <paramref name="start"/>. If null, compaction will start at the
            beginning of the database. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.CompactConfig.stop">
            <summary>
            If non-null, the stopping point for compaction. Compaction will stop
            at the page with the smallest key greater than
            <paramref name="stop"/>. If null, compaction will stop at the end of
            the database. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.CompactConfig.TruncatePages">
            <summary>
            If true, return pages to the filesystem when possible. If false,
            pages emptied as a result of compaction will be placed on the free
            list for re-use, but never returned to the filesystem.
            </summary>
            <remarks>
            Note that only pages at the end of a file can be returned to the
            filesystem. Because of the one-pass nature of the compaction
            algorithm, any unemptied page near the end of the file inhibits
            returning pages to the file system. A repeated call to
            <see cref="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig)"/> or 
            <see cref="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig)"/> with a low
            <see cref="P:BerkeleyDB.CompactConfig.FillPercentage"/> may be used to return pages in this
            case. 
            </remarks>
        </member>
        <member name="M:BerkeleyDB.CompactConfig.#ctor">
            <summary>
            Create a new CompactConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactConfig.FillPercentage">
            <summary>
            If non-zero, this provides the goal for filling pages, specified as
            a percentage between 1 and 100. Any page not at or above this
            percentage full will be considered for compaction. The default
            behavior is to consider every page for compaction, regardless of its
            page fill percentage. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactConfig.Pages">
            <summary>
            If non-zero, compaction will complete after the specified number of
            pages have been freed.
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactConfig.Timeout">
            <summary>
            If non-zero, and no <see cref="T:BerkeleyDB.Transaction"/> is specified, this
            parameter identifies the lock timeout used for implicit
            transactions, in microseconds. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.ReplicationHostAddress">
            <summary>
            A class representing the address of a replication site used by Berkeley
            DB HA.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationHostAddress.Host">
            <summary>
            The site's host identification string, generally a TCP/IP host name. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationHostAddress.Port">
            <summary>
            The port number on which the site is receiving. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.ReplicationHostAddress.#ctor">
            <summary>
            Instantiate a new, empty address
            </summary>
        </member>
        <member name="M:BerkeleyDB.ReplicationHostAddress.#ctor(System.String)">
            <summary>
            Instantiate a new address, parsing the host and port from the given
            string
            </summary>
            <param name="HostAndPort">A string in host:port format</param>
        </member>
        <member name="M:BerkeleyDB.ReplicationHostAddress.#ctor(System.String,System.UInt32)">
            <summary>
            Instantiate a new address
            </summary>
            <param name="Host">The site's host identification string</param>
            <param name="Port">
            The port number on which the site is receiving.
            </param>
        </member>
        <member name="T:BerkeleyDB.QueueStats">
            <summary>
            Statistical information about a QueueDatabase
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.DataPages">
            <summary>
            Data pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.DataPagesBytesFree">
            <summary>
            Bytes free in data pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.FirstRecordNumber">
            <summary>
            First not deleted record. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.MagicNumber">
            <summary>
            Magic number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.MetadataFlags">
            <summary>
            Metadata flags. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.NextRecordNumber">
            <summary>
            Next available record number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.nData">
            <summary>
            Number of data items. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.nKeys">
            <summary>
            Number of unique keys. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.PageSize">
            <summary>
            Page size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.PagesPerExtent">
            <summary>
            Pages per extent. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.RecordLength">
            <summary>
            Fixed-length record length. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.RecordPadByte">
            <summary>
            Fixed-length record pad. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.QueueStats.Version">
            <summary>
            Version number. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.CompactData">
            <summary>
            A class for representing compact operation statistics
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactData.Deadlocks">
            <summary>
            If no <see cref="T:BerkeleyDB.Transaction"/> parameter was specified, the
            number of deadlocks which occurred. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactData.Levels">
            <summary>
            The number of levels removed from the Btree or Recno database during
            the compaction phase. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactData.PagesExamined">
            <summary>
            The number of database pages reviewed during the compaction phase. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactData.PagesFreed">
            <summary>
            The number of database pages freed during the compaction phase. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactData.PagesTruncated">
            <summary>
            The number of database pages returned to the filesystem.
            </summary>
        </member>
        <member name="P:BerkeleyDB.CompactData.End">
            <summary>
            The database key marking the end of the compaction operation.  This
            is generally the first key of the page where the operation stopped
            and is only non-null if <see cref="F:BerkeleyDB.CompactConfig.returnEnd"/> was
            true.
            </summary>
        </member>
        <member name="T:BerkeleyDB.ByteOrder">
            <summary>
            A class to represent the database byte order.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ByteOrder.MACHINE">
            <summary>
            The host byte order of the machine where the Berkeley DB library was
            compiled.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ByteOrder.LITTLE_ENDIAN">
            <summary>
            Little endian byte order
            </summary>
        </member>
        <member name="F:BerkeleyDB.ByteOrder.BIG_ENDIAN">
            <summary>
            Big endian byte order
            </summary>
        </member>
        <member name="M:BerkeleyDB.ByteOrder.FromConst(System.Int32)">
            <summary>
            Convert from the integer constant used to represent byte order in 
            the C library to its corresponding ByteOrder object.
            </summary>
            <param name="order">The C library constant</param>
            <returns>
            The ByteOrder object corresponding to the given constant
            </returns>
        </member>
        <member name="T:BerkeleyDB.BTreeDatabase">
            <summary>
            A class representing a BTreeDatabase.  The Btree format is a
            representation of a sorted, balanced tree structure. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)">
            <summary>
            Instantiate a new BTreeDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Open(System.String,System.String,BerkeleyDB.BTreeDatabaseConfig)">
            <summary>
            Instantiate a new BTreeDatabase object and open the database
            represented by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new BTreeDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Open(System.String,System.String,BerkeleyDB.BTreeDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new BTreeDatabase object and open the database
            represented by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig)">
            <summary>
            Compact the database, and optionally return unused database pages to
            the underlying filesystem. 
            </summary>
            <remarks>
            If the operation occurs in a transactional database, the operation
            will be implicitly transaction protected using multiple
            transactions. These transactions will be periodically committed to
            avoid locking large sections of the tree. Any deadlocks encountered
            cause the compaction operation to be retried from the point of the
            last transaction commit.
            </remarks>
            <param name="cdata">Compact configuration parameters</param>
            <returns>Compact operation statistics</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig,BerkeleyDB.Transaction)">
            <summary>
            Compact the database, and optionally return unused database pages to
            the underlying filesystem. 
            </summary>
            <remarks>
            <para>
            If <paramref name="txn"/> is non-null, then the operation is
            performed using that transaction. In this event, large sections of
            the tree may be locked during the course of the transaction.
            </para>
            <para>
            If <paramref name="txn"/> is null, but the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected using multiple transactions. These transactions will be
            periodically committed to avoid locking large sections of the tree.
            Any deadlocks encountered cause the compaction operation to be
            retried from the point of the last transaction commit.
            </para>
            </remarks>
            <param name="cdata">Compact configuration parameters</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>Compact operation statistics</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Cursor">
            <summary>
            Create a database cursor.
            </summary>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Cursor(BerkeleyDB.CursorConfig)">
            <summary>
            Create a database cursor with the given configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Cursor(BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor.
            </summary>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Cursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor with the given
            configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.FastStats">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.FastStats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.FastStats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <overloads>
            <para>
            Among other things, this method makes it possible for applications
            to request key and record counts without incurring the performance
            penalty of traversing the entire database. 
            </para>
            <para>
            The statistical information is described by the
            <see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
            <see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes. 
            </para>
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Get(System.UInt32)">
            <summary>
            Retrieve a specific numbered key/data pair from the database.
            </summary>
            <param name="recno">
            The record number of the record to be retrieved.
            </param>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Get(System.UInt32,BerkeleyDB.Transaction)">
            <summary>
            Retrieve a specific numbered key/data pair from the database.
            </summary>
            <param name="recno">
            The record number of the record to be retrieved.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Get(System.UInt32,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
            <summary>
            Retrieve a specific numbered key/data pair from the database.
            </summary>
            <param name="recno">
            The record number of the record to be retrieved.
            </param>
            <param name="txn">
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
            parameter is <paramref name="key"/> and whose Value parameter is the
            retrieved data.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.KeyRange(BerkeleyDB.DatabaseEntry)">
            <summary>
            Return an estimate of the proportion of keys that are less than,
            equal to, and greater than the specified key.
            </summary>
            <param name="key">The key to search for</param>
            <returns>
            An estimate of the proportion of keys that are less than, equal to,
            and greater than the specified key.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.KeyRange(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Return an estimate of the proportion of keys that are less than,
            equal to, and greater than the specified key.
            </summary>
            <param name="key">The key to search for</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            An estimate of the proportion of keys that are less than, equal to,
            and greater than the specified key.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
            <summary>
            Store the key/data pair in the database only if it does not already
            appear in the database. 
            </summary>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Store the key/data pair in the database only if it does not already
            appear in the database. 
            </summary>
            <param name="key">The key to store in the database</param>
            <param name="data">The data item to store in the database</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Stats">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Stats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.Stats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <overloads>
            The statistical information is described by
            <see cref="T:BerkeleyDB.BTreeStats"/>. 
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.TruncateUnusedPages">
            <summary>
            Return pages to the filesystem that are already free and at the end
            of the file.
            </summary>
            <returns>
            The number of database pages returned to the filesystem
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeDatabase.TruncateUnusedPages(BerkeleyDB.Transaction)">
            <summary>
            Return pages to the filesystem that are already free and at the end
            of the file.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The number of database pages returned to the filesystem
            </returns>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.Compare">
            <summary>
            The Btree key comparison function. The comparison function is called
            whenever it is necessary to compare a key specified by the
            application with a key currently stored in the tree. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.Compress">
            <summary>
            The compression function used to store key/data pairs in the
            database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.Decompress">
            <summary>
            The decompression function used to retrieve key/data pairs from the
            database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.DupCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.Duplicates">
            <summary>
            Whether the insertion of duplicate data items in the database is
            permitted, and whether duplicates items are sorted.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.MinKeysPerPage">
            <summary>
            The minimum number of key/data pairs intended to be stored on any
            single Btree leaf page.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.PrefixCompare">
            <summary>
            The Btree prefix function. The prefix function is used to determine
            the amount by which keys stored on the Btree internal pages can be
            safely truncated without losing their uniqueness.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.RecordNumbers">
            <summary>
            If true, this object supports retrieval from the Btree using record
            numbers.
            </summary>
        </member>
        <member name="P:BerkeleyDB.BTreeDatabase.ReverseSplit">
            <summary>
            If false, empty pages will not be coalesced into higher-level pages.
            </summary>
        </member>
        <member name="T:BerkeleyDB.RecnoDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.RecnoDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.RecnoDatabaseConfig.Renumber">
            <summary>
            Cause the logical record numbers to be mutable, and change as
            records are added to and deleted from the database.
            </summary>
            <remarks>
            <para>
            Using <see cref="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> or <see cref="M:BerkeleyDB.Cursor.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32)"/> to
            create new records will cause the creation of multiple records if
            the record number is more than one greater than the largest record
            currently in the database. For example, creating record 28, when
            record 25 was previously the last record in the database, will
            create records 26 and 27 as well as 28. Attempts to retrieve records
            that were created in this manner will throw a
            <see cref="T:BerkeleyDB.KeyEmptyException"/>.
            </para>
            <para>
            If a created record is not at the end of the database, all records
            following the new record will be automatically renumbered upward by
            one. For example, the creation of a new record numbered 8 causes
            records numbered 8 and greater to be renumbered upward by one. If a
            cursor was positioned to record number 8 or greater before the
            insertion, it will be shifted upward one logical record, continuing
            to refer to the same record as it did before.
            </para>
            <para>
            If a deleted record is not at the end of the database, all records
            following the removed record will be automatically renumbered
            downward by one. For example, deleting the record numbered 8 causes
            records numbered 9 and greater to be renumbered downward by one.  If
            a cursor was positioned to record number 9 or greater before the
            removal, it will be shifted downward one logical record, continuing
            to refer to the same record as it did before.
            </para>
            <para>
            If a record is deleted, all cursors that were positioned on that
            record prior to the removal will no longer be positioned on a valid
            entry. This includes cursors used to delete an item. For example, if
            a cursor was positioned to record number 8 before the removal of
            that record, subsequent calls to <see cref="M:BerkeleyDB.Cursor.Refresh"/>
            will return false until the cursor is moved to another record. A
            call to <see cref="M:BerkeleyDB.Cursor.MoveNext"/> will return the new record
            numbered 8 - which is the record that was numbered 9 prior to the
            delete (if such a record existed).
            </para>
            <para>
            For these reasons, concurrent access to a
            <see cref="T:BerkeleyDB.RecnoDatabase"/> with this setting specified may be
            largely meaningless, although it is supported.
            </para>
            <para>
            If the database already exists, this setting must be the same as the
            existing database or an exception will be thrown.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RecnoDatabaseConfig.Snapshot">
            <summary>
            If true, any <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> file will be read in its
            entirety when <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is called. If false,
            <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> may be read lazily. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.RecnoDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RecnoDatabaseConfig.Append">
            <summary>
            A function to call after the record number has been selected but
            before the data has been stored into the database.
            </summary>
            <remarks>
            <para>
            When using <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>, it may be useful to
            modify the stored data based on the generated key. If a delegate is
            specified, it will be called after the record number has been
            selected, but before the data has been stored.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile">
            <summary>
            The underlying source file for the Recno access method.
            </summary>
            <remarks>
            <para>
            The purpose of the source file is to provide fast access and
            modification to databases that are normally stored as flat text
            files.
            </para>
            <para>
            The source parameter specifies an underlying flat text database file
            that is read to initialize a transient record number index. In the
            case of variable length records, the records are separated, as
            specified by <see cref="P:BerkeleyDB.RecnoDatabaseConfig.Delimiter"/>. For example, standard UNIX
            byte stream files can be interpreted as a sequence of variable
            length records separated by newline characters.
            </para>
            <para>
            In addition, when cached data would normally be written back to the
            underlying database file (for example,
            <see cref="M:BerkeleyDB.BaseDatabase.Close"/> or
            <see cref="M:BerkeleyDB.BaseDatabase.Sync"/>), the in-memory copy of the
            database will be written back to the source file.
            </para>
            <para>
            By default, the backing source file is read lazily; that is, records
            are not read from the file until they are requested by the
            application. If multiple processes (not threads) are accessing a
            Recno database concurrently, and are either inserting or deleting
            records, the backing source file must be read in its entirety before
            more than a single process accesses the database, and only that
            process should specify the backing source file as part of the
            <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> call. See <see cref="F:BerkeleyDB.RecnoDatabaseConfig.Snapshot"/>
            for more information.
            </para>
            <para>
            Reading and writing the backing source file specified by source
            cannot be transaction-protected because it involves filesystem
            operations that are not part of the Db transaction methodology. For
            this reason, if a temporary database is used to hold the records, it
            is possible to lose the contents of the source file, for example, if
            the system crashes at the right instant. If a file is used to hold
            the database, normal database recovery on that file can be used to
            prevent information loss, although it is still possible that the
            contents of source will be lost if the system crashes.
            </para>
            <para>
            The source file must already exist (but may be zero-length) when 
            <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is called.
            </para>
            <para>
            It is not an error to specify a read-only source file when creating
            a database, nor is it an error to modify the resulting database.
            However, any attempt to write the changes to the backing source file
            using either the <see cref="M:BerkeleyDB.BaseDatabase.Sync"/> or
            <see cref="M:BerkeleyDB.BaseDatabase.Close"/> methods will fail, of course.
            Use <see cref="M:BerkeleyDB.BaseDatabase.Close(System.Boolean)"/> to stop it from
            attempting to write the changes to the backing file; instead, they
            will be silently discarded.
            </para>
            <para>
            For all of the previous reasons, the source file is generally used
            to specify databases that are read-only for Berkeley DB
            applications; and that are either generated on the fly by software
            tools or modified using a different mechanism — for example, a text
            editor.
            </para>
            <para>
            If the database already exists, BackingFile must be the same as that
            historically used to create the database or corruption can occur.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabaseConfig.#ctor">
            <summary>
            Instantiate a new RecnoDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabaseConfig.Delimiter">
            <summary>
            The delimiting byte used to mark the end of a record in
            <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/>.
            </summary>
            <remarks>
            <para>
            This byte is used for variable length records if
            <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> is set. If <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> is
            specified and no delimiting byte was specified, newline characters
            (that is, ASCII 0x0a) are interpreted as end-of-record markers.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabaseConfig.Length">
            <summary>
            Specify that the records are fixed-length, not byte-delimited, and
            are of length Length. 
            </summary>
            <remarks>
            <para>
            Any records added to the database that are less than Length bytes
            long are automatically padded (see <see cref="P:BerkeleyDB.RecnoDatabaseConfig.PadByte"/> for more
            information).
            </para>
            <para>
            Any attempt to insert records into the database that are greater
            than Length bytes long will cause the call to fail immediately and
            return an error. 
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabaseConfig.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
            <remarks>
            <para>
            If no pad character is specified, space characters (that is, ASCII
            0x20) are used for padding.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.HashStats">
            <summary>
            Statistical information about a HashDatabase
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.BigPages">
            <summary>
            Number of big key/data pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.BigPagesFreeBytes">
            <summary>
            Bytes free on big item pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.BucketPagesFreeBytes">
            <summary>
            Bytes free on bucket pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.DuplicatePages">
            <summary>
            Number of dup pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.DuplicatePagesFreeBytes">
            <summary>
            Bytes free on duplicate pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.FillFactor">
            <summary>
            Fill factor specified at create. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.FreePages">
            <summary>
            Pages on the free list. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.MetadataFlags">
            <summary>
            Metadata flags. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.MagicNumber">
            <summary>
            Magic number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.nData">
            <summary>
            Number of data items. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.nHashBuckets">
            <summary>
            Number of hash buckets. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.nKeys">
            <summary>
            Number of unique keys. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.OverflowPages">
            <summary>
            Number of overflow pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.OverflowPagesFreeBytes">
            <summary>
            Bytes free on ovfl pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.nPages">
            <summary>
            Page count. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.PageSize">
            <summary>
            Page size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.HashStats.Version">
            <summary>
            Version number. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.CursorConfig">
            <summary>
            A class representing configuration parameters for <see cref="T:BerkeleyDB.Cursor"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.CursorConfig.IsolationDegree">
            <summary>
            The isolation degree the cursor should use.
            </summary>
            <remarks>
            <para>
            <see cref="F:BerkeleyDB.Isolation.DEGREE_TWO"/> ensures the stability of the
            current data item read by this cursor but permits data read by this
            cursor to be modified or deleted prior to the commit of the
            transaction for this cursor. 
            </para>
            <para>
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> allows read operations performed
            by the cursor to return modified but not yet committed data.
            Silently ignored if the <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>
            was not specified when the underlying database was opened. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.CursorConfig.WriteCursor">
            <summary>
            If true, specify that the cursor will be used to update the
            database. The underlying database environment must have been opened
            with <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseCDB"/> set. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.CursorConfig.SnapshotIsolation">
            <summary>
            <para>
            Configure a transactional cursor to operate with read-only snapshot
            isolation. For databases with <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/>
            set, data values will be read as they are when the cursor is opened,
            without taking read locks.
            </para>
            <para>
            This setting implicitly begins a transaction that is committed when
            the cursor is closed.
            </para>
            <para>
            This setting is silently ignored if
            <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> is not set on the underlying
            database or if a transaction is supplied to
            <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>
            </para>
            </summary>
        </member>
        <member name="F:BerkeleyDB.CursorConfig.Priority">
            <summary>
            The cache priority for pages referenced by the cursor.
            </summary>
            <remarks>
            The priority of a page biases the replacement algorithm to be more
            or less likely to discard a page when space is needed in the buffer
            pool. The bias is temporary, and pages will eventually be discarded
            if they are not referenced again. The setting is only advisory, and
            does not guarantee pages will be treated in a specific way.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.CursorConfig.#ctor">
            <summary>
            Instantiate a new CursorConfig object
            </summary>
        </member>
        <member name="T:BerkeleyDB.SecondaryQueueDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.SecondaryQueueDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.SecondaryQueueDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.SecondaryQueueDatabase.Open(System.String,BerkeleyDB.SecondaryQueueDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.SecondaryQueueDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
            <summary>
            Instantiate a new SecondaryQueueDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryQueueDatabaseConfig.Length">
            <summary>
            Specify the length of records in the database.
            </summary>
            <remarks>
            <para>
            The record length must be enough smaller than
            <see cref="P:BerkeleyDB.DatabaseConfig.PageSize"/> that at least one record plus
            the database page's metadata information can fit on each database
            page.
            </para>
            <para>
            Any records added to the database that are less than Length bytes
            long are automatically padded (see <see cref="P:BerkeleyDB.SecondaryQueueDatabaseConfig.PadByte"/> for more
            information).
            </para>
            <para>
            Any attempt to insert records into the database that are greater
            than Length bytes long will cause the call to fail immediately and
            return an error. 
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.SecondaryQueueDatabaseConfig.PadByte">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
            <remarks>
            <para>
            If no pad character is specified, space characters (that is, ASCII
            0x20) are used for padding.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.SecondaryQueueDatabaseConfig.ExtentSize">
            <summary>
            The size of the extents used to hold pages in a
            <see cref="T:BerkeleyDB.SecondaryQueueDatabase"/>, specified as a number of
            pages. 
            </summary>
            <remarks>
            <para>
            Each extent is created as a separate physical file. If no extent
            size is set, the default behavior is to create only a single
            underlying database file.
            </para>
            <para>
            For information on tuning the extent size, see Selecting a extent
            size in the Programmer's Reference Guide.
            </para>
            <para>
            If the database already exists, this setting will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.SecondaryHashDatabase">
            <summary>
            A class representing a SecondaryHashDatabase. The Hash format is an
            extensible, dynamic hashing scheme.
            </summary>
        </member>
        <member name="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryHashDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryHashDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryHashDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryHashDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryHashDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryHashDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabase.Compare">
            <summary>
            The secondary Hash key comparison function. The comparison function
            is called whenever it is necessary to compare a key specified by the
            application with a key currently stored in the tree. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabase.DupCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabase.Duplicates">
            <summary>
            Whether the insertion of duplicate data items in the database is
            permitted, and whether duplicates items are sorted.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabase.FillFactor">
            <summary>
            The desired density within the hash table.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabase.HashFunction">
            <summary>
            A user-defined hash function; if no hash function is specified, a
            default hash function is used. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryHashDatabase.TableSize">
            <summary>
            An estimate of the final size of the hash table.
            </summary>
        </member>
        <member name="T:BerkeleyDB.RepMgrStats">
            <summary>
            Statistical information about the Replication Manager
            </summary>
        </member>
        <member name="P:BerkeleyDB.RepMgrStats.DroppedConnections">
            <summary>
            Existing connections dropped. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RepMgrStats.DroppedMessages">
            <summary>
            # msgs discarded due to excessive queue length.
            </summary>
        </member>
        <member name="P:BerkeleyDB.RepMgrStats.FailedConnections">
            <summary>
            Failed new connection attempts. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RepMgrStats.FailedMessages">
            <summary>
            # of insufficiently ack'ed msgs. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RepMgrStats.QueuedMessages">
            <summary>
            # msgs queued for network delay. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.ReplicationConfig">
            <summary>
            A class representing configuration parameters for a
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s replication subsystem.
            </summary>
        </member>
        <member name="M:BerkeleyDB.ReplicationConfig.#ctor">
            <summary>
            Instantiate a new ReplicationConfig object with default
            configuration values.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.BulkTransfer">
            <summary>
            If true, the replication master will send groups of records to the
            clients in a single network transfer
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.DelayClientSync">
            <summary>
            If true, the client will delay synchronizing to a newly declared
            master (defaults to false). Clients configured in this way will
            remain unsynchronized until the application calls
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepSync"/>. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.UseMasterLeases">
            <summary>
            If true, master leases will be used for this site (defaults to
            false). 
            </summary>
            <remarks>
            Configuring this option may result in a 
            <see cref="T:BerkeleyDB.LeaseExpiredException"/> when attempting to read entries
            from a database after the site's master lease has expired.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.NoAutoInit">
            <summary>
            If true, the replication master will not automatically re-initialize
            outdated clients (defaults to false). 
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.NoBlocking">
            <summary>
            If true, Berkeley DB method calls that would normally block while
            clients are in recovery will return errors immediately (defaults to
            false).
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.Strict2Site">
            <summary>
            If true, the Replication Manager will observe the strict "majority"
            rule in managing elections, even in a group with only 2 sites. This
            means the client in a 2-site group will be unable to take over as
            master if the original master fails or becomes disconnected. (See
            the Elections section in the Berkeley DB Reference Guide for more
            information.) Both sites in the replication group should have the
            same value for this parameter.
            </summary>
        </member>
        <member name="M:BerkeleyDB.ReplicationConfig.Clockskew(System.UInt32,System.UInt32)">
            <summary>
            Set the clock skew ratio among replication group members based on
            the fastest and slowest measurements among the group for use with
            master leases.
            </summary>
            <remarks>
            <para>
            Calling this method is optional, the default values for clock skew
            assume no skew. The user must also configure leases via
            <see cref="F:BerkeleyDB.ReplicationConfig.UseMasterLeases"/>. Additionally, the user must also
            set the master lease timeout via <see cref="P:BerkeleyDB.ReplicationConfig.LeaseTimeout"/> and
            the number of sites in the replication group via
            <see cref="P:BerkeleyDB.ReplicationConfig.NSites"/>. These settings may be configured in any
            order. For a description of the clock skew values, see Clock skew 
            in the Berkeley DB Programmer's Reference Guide. For a description
            of master leases, see Master leases in the Berkeley DB Programmer's
            Reference Guide.
            </para>
            <para>
            These arguments can be used to express either raw measurements of a
            clock timing experiment or a percentage across machines. For
            instance a group of sites have a 2% variance, then
            <paramref name="fast"/> should be set to 102, and
            <paramref name="slow"/> should be set to 100. Or, for a 0.03%
            difference, you can use 10003 and 10000 respectively.
            </para>
            </remarks>
            <param name="fast">
            The value, relative to <paramref name="slow"/>, of the fastest clock
            in the group of sites.
            </param>
            <param name="slow">
            The value of the slowest clock in the group of sites.
            </param>
        </member>
        <member name="M:BerkeleyDB.ReplicationConfig.RetransmissionRequest(System.UInt32,System.UInt32)">
            <summary>
            Set a threshold for the minimum and maximum time that a client waits
            before requesting retransmission of a missing message.
            </summary>
            <remarks>
            <para>
            If the client detects a gap in the sequence of incoming log records
            or database pages, Berkeley DB will wait for at least
            <paramref name="min"/> microseconds before requesting retransmission
            of the missing record. Berkeley DB will double that amount before
            requesting the same missing record again, and so on, up to a
            maximum threshold of <paramref name="max"/> microseconds.
            </para>
            <para>
            These values are thresholds only. Since Berkeley DB has no thread
            available in the library as a timer, the threshold is only checked
            when a thread enters the Berkeley DB library to process an incoming
            replication message. Any amount of time may have passed since the
            last message arrived and Berkeley DB only checks whether the amount
            of time since a request was made is beyond the threshold value or
            not.
            </para>
            <para>
            By default the minimum is 40000 and the maximum is 1280000 (1.28
            seconds). These defaults are fairly arbitrary and the application
            likely needs to adjust these. The values should be based on expected
            load and performance characteristics of the master and client host
            platforms and transport infrastructure as well as round-trip message
            time.
            </para></remarks>
            <param name="min">
            The minimum number of microseconds a client waits before requesting
            retransmission.
            </param>
            <param name="max">
            The maximum number of microseconds a client waits before requesting
            retransmission.
            </param>
        </member>
        <member name="M:BerkeleyDB.ReplicationConfig.TransmitLimit(System.UInt32,System.UInt32)">
            <summary>
            Set a byte-count limit on the amount of data that will be
            transmitted from a site in response to a single message processed by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>. The limit is
            not a hard limit, and the record that exceeds the limit is the last
            record to be sent. 
            </summary>
            <remarks>
            <para>
            Record transmission throttling is turned on by default with a limit
            of 10MB.
            </para>
            <para>
            If both <paramref name="GBytes"/> and <paramref name="Bytes"/> are
            zero, then the transmission limit is turned off.
            </para>
            </remarks>
            <param name="GBytes">
            The number of gigabytes which, when added to
            <paramref name="Bytes"/>, specifies the maximum number of bytes that
            will be sent in a single call to 
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </param>
            <param name="Bytes">
            The number of bytes which, when added to 
            <paramref name="GBytes"/>, specifies the maximum number of bytes
            that will be sent in a single call to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </param>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.Transport">
            <summary>
            The delegate used to transmit data using the replication
            application's communication infrastructure.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.RepMgrAckPolicy">
            <summary>
            Specify how master and client sites will handle acknowledgment of
            replication messages which are necessary for "permanent" records.
            The current implementation requires all sites in a replication group
            configure the same acknowledgement policy. 
            </summary>
            <seealso cref="P:BerkeleyDB.ReplicationConfig.AckTimeout"/>
        </member>
        <member name="F:BerkeleyDB.ReplicationConfig.RepMgrLocalSite">
            <summary>
            The host information for the local system. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.ReplicationConfig.AddRemoteSite(BerkeleyDB.ReplicationHostAddress,System.Boolean)">
            <summary>
            Add a new replication site to the replication manager's list of
            known sites. It is not necessary for all sites in a replication
            group to know about all other sites in the group. 
            </summary>
            <remarks>
            Currently, the replication manager framework only supports a single
            client peer, and the last specified peer is used.
            </remarks>
            <param name="host">The remote site's address</param>
            <param name="isPeer">
            If true, configure client-to-client synchronization with the
            specified remote site.
            </param>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.AckTimeout">
            <summary>
            The amount of time the replication manager's transport function
            waits to collect enough acknowledgments from replication group
            clients, before giving up and returning a failure indication. The
            default wait time is 1 second.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.CheckpointDelay">
            <summary>
            The amount of time a master site will delay between completing a
            checkpoint and writing a checkpoint record into the log.
            </summary>
            <remarks>
            This delay allows clients to complete their own checkpoints before
            the master requires completion of them. The default is 30 seconds.
            If all databases in the environment, and the environment's
            transaction log, are configured to reside in memory (never preserved
            to disk), then, although checkpoints are still necessary, the delay
            is not useful and should be set to 0.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.ConnectionRetry">
            <summary>
            The amount of time the replication manager will wait before trying
            to re-establish a connection to another site after a communication
            failure. The default wait time is 30 seconds.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.ElectionTimeout">
            <summary>
            The timeout period for an election. The default timeout is 2
            seconds.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.ElectionRetry">
            <summary>
            Configure the amount of time the replication manager will wait
            before retrying a failed election. The default wait time is 10
            seconds. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.FullElectionTimeout">
            <summary>
            An optional configuration timeout period to wait for full election
            participation the first time the replication group finds a master.
            By default this option is turned off and normal election timeouts
            are used. (See the Elections section in the Berkeley DB Reference
            Guide for more information.) 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.HeartbeatMonitor">
            <summary>
            The amount of time the replication manager, running at a client
            site, waits for some message activity on the connection from the
            master (heartbeats or other messages) before concluding that the
            connection has been lost. When 0 (the default), no monitoring is
            performed.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.HeartbeatSend">
            <summary>
            The frequency at which the replication manager, running at a master
            site, broadcasts a heartbeat message in an otherwise idle system.
            When 0 (the default), no heartbeat messages will be sent. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.LeaseTimeout">
            <summary>
            The amount of time a client grants its master lease to a master.
            When using master leases all sites in a replication group must use
            the same lease timeout value. There is no default value. If leases
            are desired, this method must be called prior to calling
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/> or
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.ClockskewFast">
            <summary>
            The value, relative to <see cref="P:BerkeleyDB.ReplicationConfig.ClockskewSlow"/>, of the fastest
            clock in the group of sites.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.ClockskewSlow">
            <summary>
            The value of the slowest clock in the group of sites.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.NSites">
            <summary>
            The total number of sites in the replication group.
            </summary>
            <remarks>
            <para>
            This setting is typically used by applications which use the
            Berkeley DB library "replication manager" support. (However, see
            also <see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>, the
            description of the nsites parameter.)
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.Priority">
            <summary>
            The database environment's priority in replication group elections.
            A special value of 0 indicates that this environment cannot be a
            replication group master. If not configured, then a default value
            of 100 is used.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.RetransmissionRequestMin">
            <summary>
            The minimum number of microseconds a client waits before requesting
            retransmission.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.RetransmissionRequestMax">
            <summary>
            The maximum number of microseconds a client waits before requesting
            retransmission.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.TransmitLimitGBytes">
            <summary>
            The gigabytes component of the byte-count limit on the amount of
            data that will be transmitted from a site in response to a single
            message processed by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.ReplicationConfig.TransmitLimitBytes">
            <summary>
            The bytes component of the byte-count limit on the amount of data
            that will be transmitted from a site in response to a single
            message processed by
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
            </summary>
        </member>
        <member name="T:BerkeleyDB.MutexConfig">
            <summary>
            A class representing configuration parameters for a
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s mutex subsystem.
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexConfig.Alignment">
            <summary>
            The mutex alignment, in bytes.
            </summary>
            <remarks>
            <para>
            It is sometimes advantageous to align mutexes on specific byte
            boundaries in order to minimize cache line collisions. Alignment
            specifies an alignment for mutexes allocated by Berkeley DB.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            Alignment will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.MutexConfig.Increment">
            <summary>
            Configure the number of additional mutexes to allocate.
            </summary>
            <remarks>
            <para>
            If both Increment and <see cref="P:BerkeleyDB.MutexConfig.MaxMutexes"/> are set, the value of
            Increment will be silently ignored.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            Increment will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.MutexConfig.MaxMutexes">
            <summary>
            The total number of mutexes to allocate.
            </summary>
            <remarks>
            <para>
            Berkeley DB allocates a default number of mutexes based on the
            initial configuration of the database environment. That default
            calculation may be too small if the application has an unusual need
            for mutexes (for example, if the application opens an unexpectedly
            large number of databases) or too large (if the application is
            trying to minimize its memory footprint). MaxMutexes is used to
            specify an absolute number of mutexes to allocate.
            </para>
            <para>
            If both <see cref="P:BerkeleyDB.MutexConfig.Increment"/> and MaxMutexes are set, the value of
            Increment will be silently ignored.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            MaxMutexes will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.MutexConfig.NumTestAndSetSpins">
            <summary>
            The number of spins test-and-set mutexes should execute before
            blocking. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.AppendRecordDelegate">
            <summary>
            A function to call after the record number has been selected but before
            the data has been stored into the database.
            </summary>
            <param name="data">The data to be stored.</param>
            <param name="recno">The generated record number.</param>
        </member>
        <member name="T:BerkeleyDB.BTreeCompressDelegate">
            <summary>
            A function to store a compressed key/data pair into a supplied buffer.
            </summary>
            <param name="prevKey">The key immediately preceding the application supplied key.</param>
            <param name="prevData">The data associated with prevKey.</param>
            <param name="key">The application supplied key.</param>
            <param name="data">The application supplied data. </param>
            <param name="dest">The compressed data to be stored in the
            database.</param>
            <param name="size">The number of compressed bytes written to
            <paramref name="dest"/>, or the required size of
            <paramref name="dest"/>, if too small.</param>
            <returns>True on success, false if dest is too small to contain the
            compressed data.  All other errors should throw an exception.</returns>
        </member>
        <member name="T:BerkeleyDB.BTreeDecompressDelegate">
            <summary>
            A function to decompress a key/data pair from a supplied buffer.
            </summary>
            <param name="prevKey">The key immediately preceding the key being decompressed.</param>
            <param name="prevData">The data associated with prevKey.</param>
            <param name="compressed">The data stored in the tree, that is, the compressed data.</param>
            <param name="bytesRead">The number of bytes read from <paramref name="compressed"/>.</param>
            <returns>Two new DatabaseEntry objects representing the decompressed
            key/data pair.</returns>
        </member>
        <member name="T:BerkeleyDB.DatabaseFeedbackDelegate">
            <summary>
            The application-specified feedback function called to report Berkeley DB
            operation progress.
            </summary>
            <param name="opcode">
            An operation code specifying the Berkley DB operation
            </param>
            <param name="percent">
            The percent of the operation that has been completed, specified as an
            integer value between 0 and 100.
            </param>
        </member>
        <member name="T:BerkeleyDB.EntryComparisonDelegate">
            <summary>
            An application-specified comparison function.
            </summary>
            <param name="dbt1">The application supplied key.</param>
            <param name="dbt2">The current tree's key.</param>
            <returns>
            An integer value less than, equal to, or greater than zero if the first
            key parameter is considered to be respectively less than, equal to, or
            greater than the second key parameter.
            </returns>
        </member>
        <member name="T:BerkeleyDB.EnvironmentFeedbackDelegate">
            <summary>
            The application-specified feedback function called to report Berkeley DB
            operation progress.
            </summary>
            <param name="opcode">
            An operation code specifying the Berkley DB operation
            </param>
            <param name="percent">
            The percent of the operation that has been completed, specified as an
            integer value between 0 and 100.
            </param>
        </member>
        <member name="T:BerkeleyDB.ErrorFeedbackDelegate">
            <summary>
            The application-specified error reporting function.
            </summary>
            <param name="errPrefix">The prefix string</param>
            <param name="errMessage">The error message string</param>
        </member>
        <member name="T:BerkeleyDB.EventNotifyDelegate">
            <summary>
            The application's event notification function.
            </summary>
            <param name="eventcode">
            An even code specifying the Berkeley DB event
            </param>
            <param name="event_info">
            Additional information describing an event. By default, event_info is
            null; specific events may pass non-null values, in which case the event
            will also describe the information's structure.
            </param>
        </member>
        <member name="T:BerkeleyDB.ForeignKeyNullifyDelegate">
            <summary>
            
            </summary>
            <param name="key"></param>
            <param name="data"></param>
            <param name="foreignkey"></param>
            <returns></returns>
        </member>
        <member name="T:BerkeleyDB.HashFunctionDelegate">
            <summary>
            The application-specified hash function.
            </summary>
            <param name="data">
            A byte string representing a key in the database
            </param>
            <returns>The hashed value of <paramref name="data"/></returns>
        </member>
        <member name="T:BerkeleyDB.ReplicationTransportDelegate">
            <summary>
            The function used to transmit data using the replication application's
            communication infrastructure.
            </summary>
            <param name="control">
            The first of the two data elements to be transmitted by the send
            function.
            </param>
            <param name="rec">
            The second of the two data elements to be transmitted by the send
            function.
            </param>
            <param name="lsn">
            If the type of message to be sent has an LSN associated with it, then
            this is the LSN of the record being sent. This LSN can be used to
            determine that certain records have been processed successfully by
            clients.
            </param>
            <param name="envid">
            <para>
            A positive integer identifier that specifies the replication environment
            to which the message should be sent.
            </para>
            <para>
            The special identifier DB_EID_BROADCAST indicates that a message should
            be broadcast to every environment in the replication group. The
            application may use a true broadcast protocol or may send the message
            in sequence to each machine with which it is in communication. In both
            cases, the sending site should not be asked to process the message.
            </para>
            <para>
            The special identifier DB_EID_INVALID indicates an invalid environment
            ID. This may be used to initialize values that are subsequently checked
            for validity. 
            </para>
            </param>
            <param name="flags">XXX: TBD</param>
            <returns>0 on success and non-zero on failure</returns>
        </member>
        <member name="T:BerkeleyDB.SecondaryKeyGenDelegate">
            <summary>
            The function that creates the set of secondary keys corresponding to a
            given primary key and data pair. 
            </summary>
            <param name="key">The primary key</param>
            <param name="data">The primary data item</param>
            <returns>The secondary key(s)</returns>
        </member>
        <member name="T:BerkeleyDB.SetThreadIDDelegate">
            <summary>
            A function which returns a unique identifier pair for a thread of
            control in a Berkeley DB application.
            </summary>
            <returns>
            A DbThreadID object describing the current thread of control
            </returns>
        </member>
        <member name="T:BerkeleyDB.SetThreadNameDelegate">
            <summary>
            A function which returns an identifier pair for a thread of control
            formatted for display.
            </summary>
            <param name="info">The thread of control to format</param>
            <returns>The formatted identifier pair</returns>
        </member>
        <member name="T:BerkeleyDB.ThreadIsAliveDelegate">
            <summary>
            A function which returns whether the thread of control, identified by
            <paramref name="info"/>, is still running.
            </summary>
            <param name="info">The thread of control to check</param>
            <param name="procOnly">
            If true, return only if the process is alive, and the
            <see cref="F:BerkeleyDB.DbThreadID.threadID"/> portion of <paramref name="info"/>
            should be ignored.
            </param>
            <returns>True if the tread is alive, false otherwise.</returns>
        </member>
        <member name="T:BerkeleyDB.DatabaseEnvironmentConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/>
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironmentConfig.#ctor">
            <summary>
            Create a new object, with default settings
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.LockSystemCfg">
            <summary>
            Configuration for the locking subsystem
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.LogSystemCfg">
            <summary>
            Configuration for the logging subsystem
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.MPoolSystemCfg">
            <summary>
            Configuration for the memory pool subsystem
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.MutexSystemCfg">
            <summary>
            Configuration for the mutex subsystem
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.RepSystemCfg">
            <summary>
            Configuration for the replication subsystem
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ErrorFeedback">
            <summary>
            The mechanism for reporting detailed error messages to the
            application.
            </summary>
            <remarks>
            <para>
            When an error occurs in the Berkeley DB library, a
            <see cref="T:BerkeleyDB.DatabaseException"/>, or subclass of DatabaseException,
            is thrown. In some cases, however, the exception may be insufficient
            to completely describe the cause of the error, especially during
            initial application debugging.
            </para>
            <para>
            In some cases, when an error occurs, Berkeley DB will call the given
            delegate with additional error information. It is up to the delegate
            to display the error message in an appropriate manner.
            </para>
            <para>
            Setting ErrorFeedback to NULL unconfigures the callback interface.
            </para>
            <para>
            This error-logging enhancement does not slow performance or
            significantly increase application size, and may be run during
            normal operation as well as during application debugging.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Feedback">
            <summary>
            Monitor progress within long running operations.
            </summary>
            <remarks>
            <para>
            Some operations performed by the Berkeley DB library can take
            non-trivial amounts of time. The Feedback delegate can be used by
            applications to monitor progress within these operations. When an
            operation is likely to take a long time, Berkeley DB will call the
            specified delegate with progress information.
            </para>
            <para>
            It is up to the delegate to display this information in an
            appropriate manner. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.EventNotify">
            <summary>
            A delegate which is called to notify the process of specific
            Berkeley DB events. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.SetThreadID">
            <summary>
            A delegate that returns a unique identifier pair for the current 
            thread of control.
            </summary>
            <remarks>
            This delegate supports <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>.
            For more information, see Architecting Data Store and Concurrent
            Data Store applications, and Architecting Transactional Data Store
            applications, both in the Berkeley DB Programmer's Reference Guide.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadName">
            <summary>
            A delegate that formats a process ID and thread ID identifier pair. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadIsAlive">
            <summary>
            A delegate that returns if a thread of control (either a true thread
            or a process) is still running.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.DataDirs">
            <summary>
            Paths of directories to be used as the location of the access method
            database files.
            </summary>
            <remarks>
            <para>
            Paths specified to <see cref="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)"/> will be searched
            relative to this path. Paths set using this method are additive, and
            specifying more than one will result in each specified directory
            being searched for database files.
            </para>
            <para>
            If no database directories are specified, database files must be
            named either by absolute paths or relative to the environment home
            directory. See Berkeley DB File Naming in the Programmer's Reference
            Guide for more information.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.CreationDir">
            <summary>
            The path of a directory to be used as the location to create the
            access method database files. When <see cref="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)"/>,
            <see cref="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)"/>, <see cref="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig)"/> or
            <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is used to create a file it will be
            created relative to this path.
            </summary>
            <remarks>
            <para>
            This path must also exist in <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.DataDirs"/>.
            </para>
            <para>
            If no database directory is specified, database files must be named
            either by absolute paths or relative to the environment home 
            directory. See Berkeley DB File Naming in the Programmer's Reference
            Guide for more information.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.DatabaseEnvironmentConfig.SetEncryption(System.String,BerkeleyDB.EncryptionAlgorithm)">
            <summary>
            Set the password and algorithm used by the Berkeley DB library to
            perform encryption and decryption. 
            </summary>
            <param name="password">
            The password used to perform encryption and decryption.
            </param>
            <param name="alg">
            The algorithm used to perform encryption and decryption.
            </param>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ErrorPrefix">
            <summary>
            The prefix string that appears before error messages issued by
            Berkeley DB.
            </summary>
            <remarks>
            <para>
            For databases opened inside of a DatabaseEnvironment, setting
            ErrorPrefix affects the entire environment and is equivalent to
            setting <see cref="P:BerkeleyDB.DatabaseEnvironment.ErrorPrefix"/>.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.IntermediateDirMode">
            <summary>
            The permissions for any intermediate directories created by Berkeley
            DB.
            </summary>
            <remarks>
            <para>
            By default, Berkeley DB does not create intermediate directories
            needed for recovery, that is, if the file /a/b/c/mydatabase is being
            recovered, and the directory path b/c does not exist, recovery will
            fail. This default behavior is because Berkeley DB does not know
            what permissions are appropriate for intermediate directory
            creation, and creating the directory might result in a security
            problem.
            </para>
            <para>
            Directory permissions are interpreted as a string of nine
            characters, using the character set r (read), w (write), x (execute
            or search), and - (none). The first character is the read
            permissions for the directory owner (set to either r or -). The
            second character is the write permissions for the directory owner
            (set to either w or -). The third character is the execute
            permissions for the directory owner (set to either x or -).
            </para>
            <para>
            Similarly, the second set of three characters are the read, write
            and execute/search permissions for the directory group, and the
            third set of three characters are the read, write and execute/search
            permissions for all others. For example, the string rwx------ would
            configure read, write and execute/search access for the owner only.
            The string rwxrwx--- would configure read, write and execute/search
            access for both the owner and the group. The string rwxr----- would
            configure read, write and execute/search access for the directory
            owner and read-only access for the directory group.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TempDir">
            <summary>
            The path of a directory to be used as the location of temporary
            files.
            </summary>
            <remarks>
            <para>
            The files created to back in-memory access method databases will be
            created relative to this path. These temporary files can be quite
            large, depending on the size of the database.
            </para>
            <para>
            If no directories are specified, the following alternatives are
            checked in the specified order. The first existing directory path is
            used for all temporary files.
            </para>
            <list type="number">
            <item>The value of the environment variable TMPDIR.</item>
            <item>The value of the environment variable TEMP.</item>
            <item>The value of the environment variable TMP.</item>
            <item>The value of the environment variable TempFolder.</item>
            <item>The value returned by the GetTempPath interface.</item>
            <item>The directory /var/tmp.</item>
            <item>The directory /usr/tmp.</item>
            <item>The directory /temp.</item>
            <item>The directory /tmp.</item>
            <item>The directory C:/temp.</item>
            <item>The directory C:/tmp.</item>
            </list>
            <para>
            Environment variables are only checked if
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseEnvironmentVars"/> is true.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Verbosity">
            <summary>
            Specific additional informational and debugging messages in the
            Berkeley DB message output.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.AutoCommit">
            <summary>
            If true, database operations for which no explicit transaction
            handle was specified, and which modify databases in the database
            environment, will be automatically enclosed within a transaction.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.CDB_ALLDB">
            <summary>
            If true, Berkeley DB Concurrent Data Store applications will perform
            locking on an environment-wide basis rather than on a per-database
            basis. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ForceFlush">
            <summary>
            If true, Berkeley DB will flush database writes to the backing disk
            before returning from the write system call, rather than flushing
            database writes explicitly in a separate system call, as necessary.
            </summary>
            <remarks>
            This is only available on some systems (for example, systems
            supporting the IEEE/ANSI Std 1003.1 (POSIX) standard O_DSYNC flag,
            or systems supporting the Windows FILE_FLAG_WRITE_THROUGH flag).
            This flag may result in inaccurate file modification times and other
            file-level information for Berkeley DB database files. This flag
            will almost certainly result in a performance decrease on most
            systems. This flag is only applicable to certain filesysystems (for
            example, the Veritas VxFS filesystem), where the filesystem's
            support for trickling writes back to stable storage behaves badly
            (or more likely, has been misconfigured).
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.InitRegions">
            <summary>
            If true, Berkeley DB will page-fault shared regions into memory when
            initially creating or joining a Berkeley DB environment. In
            addition, Berkeley DB will write the shared regions when creating an
            environment, forcing the underlying virtual memory and filesystems
            to instantiate both the necessary memory and the necessary disk
            space. This can also avoid out-of-disk space failures later on.
            </summary>
            <remarks>
            <para>
            In some applications, the expense of page-faulting the underlying
            shared memory regions can affect performance. (For example, if the
            page-fault occurs while holding a lock, other lock requests can
            convoy, and overall throughput may decrease.)
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoBuffer">
            <summary>
            If true, turn off system buffering of Berkeley DB database files to
            avoid double caching. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoLocking">
            <summary>
            If true, Berkeley DB will grant all requested mutual exclusion
            mutexes and database locks without regard for their actual
            availability. This functionality should never be used for purposes
            other than debugging. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoMMap">
            <summary>
            If true, Berkeley DB will copy read-only database files into the
            local cache instead of potentially mapping them into process memory
            (see <see cref="P:BerkeleyDB.MPoolConfig.MMapSize"/> for further information).
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoPanic">
            <summary>
            If true, Berkeley DB will ignore any panic state in the database
            environment. (Database environments in a panic state normally refuse
            all attempts to call Berkeley DB functions, throwing
            <see cref="T:BerkeleyDB.RunRecoveryException"/>. This functionality should never
            be used for purposes other than debugging.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Overwrite">
            <summary>
            If true, overwrite files stored in encrypted formats before deleting
            them.
            </summary>
            <remarks>
            Berkeley DB overwrites files using alternating 0xff, 0x00 and 0xff
            byte patterns. For file overwriting to be effective, the underlying
            file must be stored on a fixed-block filesystem. Systems with
            journaling or logging filesystems will require operating system
            support and probably modification of the Berkeley DB sources.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted">
            <summary>
            If true, database calls timing out based on lock or transaction
            timeout values will throw <see cref="T:BerkeleyDB.LockNotGrantedException"/>
            instead of <see cref="T:BerkeleyDB.DeadlockException"/>. This allows applications
            to distinguish between operations which have deadlocked and
            operations which have exceeded their time limits.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoSync">
            <summary>
            If true, Berkeley DB will not write or synchronously flush the log
            on transaction commit.
            </summary>
            <remarks>
            This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability); that
            is, database integrity will be maintained, but if the application or
            system fails, it is possible some number of the most recently
            committed transactions may be undone during recovery. The number of
            transactions at risk is governed by how many log updates can fit
            into the log buffer, how often the operating system flushes dirty
            buffers to disk, and how often the log is checkpointed.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoWait">
            <summary>
            If true and a lock is unavailable for any Berkeley DB operation
            performed in the context of a transaction, cause the operation to
            throw <see cref="T:BerkeleyDB.DeadlockException"/> (or
            <see cref="T:BerkeleyDB.LockNotGrantedException"/> if
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted"/> is set.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnSnapshot">
            <summary>
            If true, all transactions in the environment will be started as if
            <see cref="F:BerkeleyDB.TransactionConfig.Snapshot"/> were passed to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>, and all
            non-transactional cursors will be opened as if
            <see cref="F:BerkeleyDB.CursorConfig.SnapshotIsolation"/> were passed to
            <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnWriteNoSync">
            <summary>
            If true, Berkeley DB will write, but will not synchronously flush,
            the log on transaction commit.
            </summary>
            <remarks>
            This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability); that
            is, database integrity will be maintained, but if the system fails,
            it is possible some number of the most recently committed
            transactions may be undone during recovery. The number of
            transactions at risk is governed by how often the system flushes
            dirty buffers to disk and how often the log is checkpointed.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseMVCC">
            <summary>
            If true, all databases in the environment will be opened as if
            <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> is passed to
            <see cref="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)"/>. This flag will be ignored for queue
            databases for which MVCC is not supported. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.YieldCPU">
            <summary>
            If true, Berkeley DB will yield the processor immediately after each
            page or mutex acquisition. This functionality should never be used
            for purposes other than stress testing. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Create">
            <summary>
            If true, Berkeley DB subsystems will create any underlying files, as
            necessary.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.FreeThreaded">
            <summary>
            If true, the created <see cref="T:BerkeleyDB.DatabaseEnvironment"/> object will
            be free-threaded; that is, concurrently usable by multiple threads
            in the address space.
            </summary>
            <remarks>
            <para>
            Required to be true if the created <see cref="T:BerkeleyDB.DatabaseEnvironment"/>
            object will be concurrently used by more than one thread in the
            process, or if any <see cref="T:BerkeleyDB.Database"/> objects opened in the
            scope of the <see cref="T:BerkeleyDB.DatabaseEnvironment"/> object will be
            concurrently used by more than one thread in the process.
            </para>
            <para>Required to be true when using the Replication Manager.</para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Lockdown">
            <summary>
            If true, lock shared Berkeley DB environment files and memory-mapped
            databases into memory.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Private">
            <summary>
            If true, allocate region memory from the heap instead of from memory
            backed by the filesystem or system shared memory. 
            </summary>
            <remarks>
            <para>
            This setting implies the environment will only be accessed by a
            single process (although that process may be multithreaded). This
            flag has two effects on the Berkeley DB environment. First, all
            underlying data structures are allocated from per-process memory
            instead of from shared memory that is accessible to more than a
            single process. Second, mutexes are only configured to work between
            threads.
            </para>
            <para>
            This setting should be false if more than a single process is
            accessing the environment because it is likely to cause database
            corruption and unpredictable behavior. For example, if both a server
            application and Berkeley DB utilities (for example, db_archive,
            db_checkpoint or db_stat) are expected to access the environment,
            this setting should be false.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Register">
            <summary>
            If true, check to see if recovery needs to be performed before
            opening the database environment. (For this check to be accurate,
            all processes using the environment must specify it when opening the
            environment.)
            </summary>
            <remarks>
            If recovery needs to be performed for any reason (including the
            initial use of this setting), and <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery"/>is also
            specified, recovery will be performed and the open will proceed
            normally. If recovery needs to be performed and
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery"/> is not specified,
            <see cref="T:BerkeleyDB.RunRecoveryException"/> will be thrown. If recovery does
            not need to be performed, <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery"/> will be ignored.
            See Architecting Transactional Data Store applications in the 
            Programmer's Reference Guide for more information.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.RunFatalRecovery">
            <summary>
            If true, catastrophic recovery will be run on this environment
            before opening it for normal use.
            </summary>
            <remarks>
            If true, the <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.Create"/> and <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/> must
            also be set, because the regions will be removed and re-created,
            and transactions are required for application recovery.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery">
            <summary>
            If true, normal recovery will be run on this environment before
            opening it for normal use.
            </summary>
            <remarks>
            If true, the <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.Create"/> and <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/> must
            also be set, because the regions will be removed and re-created,
            and transactions are required for application recovery.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.SystemMemory">
            <summary>
            If true, allocate region memory from system shared memory instead of
            from heap memory or memory backed by the filesystem. 
            </summary>
            <remarks>
            See Shared Memory Regions in the Programmer's Reference Guide for
            more information.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseEnvironmentVars">
            <summary>
            If true, the Berkeley DB process' environment may be permitted to
            specify information to be used when naming files.
            </summary>
            <remarks>
            <para>
            See Berkeley DB File Naming in the Programmer's Reference Guide for 
            more information.
            </para>
            <para>
            Because permitting users to specify which files are used can create
            security problems, environment information will be used in file 
            naming for all users only if UseEnvironmentVars is true.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseCDB">
            <summary>
            If true, initialize locking for the Berkeley DB Concurrent Data
            Store product.
            </summary>
            <remarks>
            In this mode, Berkeley DB provides multiple reader/single writer
            access. The only other subsystem that should be specified with
            UseCDB flag is <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseMPool"/>.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLocking">
            <summary>
            If true, initialize the locking subsystem.
            </summary>
            <remarks>
            This subsystem should be used when multiple processes or threads are
            going to be reading and writing a Berkeley DB database, so that they
            do not interfere with each other. If all threads are accessing the
            database(s) read-only, locking is unnecessary. When UseLocking is
            specified, it is usually necessary to run a deadlock detector, as
            well. See <see cref="M:BerkeleyDB.DatabaseEnvironment.DetectDeadlocks(BerkeleyDB.DeadlockPolicy)"/> for more
            information.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLogging">
            <summary>
            If true, initialize the logging subsystem.
            </summary>
            <remarks>
            This subsystem should be used when recovery from application or
            system failure is necessary. If the log region is being created and
            log files are already present, the log files are reviewed;
            subsequent log writes are appended to the end of the log, rather
            than overwriting current log entries.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseMPool">
            <summary>
            If true, initialize the shared memory buffer pool subsystem.
            </summary>
            <remarks>
            This subsystem should be used whenever an application is using any
            Berkeley DB access method.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseReplication">
            <summary>
            If true, initialize the replication subsystem.
            </summary>
            <remarks>
            This subsystem should be used whenever an application plans on using
            replication. UseReplication requires <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/> and
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLocking"/> also be set.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns">
            <summary>
            If true, initialize the transaction subsystem.
            </summary>
            <remarks>
            This subsystem should be used when recovery and atomicity of
            multiple operations are important. UseTxns implies
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLogging"/>.
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.EncryptionPassword">
            <summary>
            The password used to perform encryption and decryption.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.EncryptAlgorithm">
            <summary>
            The algorithm used to perform encryption and decryption.
            </summary>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.LockTimeout">
            <summary>
            A value, in microseconds, representing lock timeouts.
            </summary>
            <remarks>
            <para>
            All timeouts are checked whenever a thread of control blocks on a
            lock or when deadlock detection is performed. As timeouts are only
            checked when the lock request first blocks or when deadlock
            detection is performed, the accuracy of the timeout depends on how
            often deadlock detection is performed.
            </para>
            <para>
            Timeout values specified for the database environment may be
            overridden on a per-transaction basis, see
            <see cref="M:BerkeleyDB.Transaction.SetLockTimeout(System.UInt32)"/>.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.MaxTransactions">
            <summary>
            The number of active transactions supported by the environment. This
            value bounds the size of the memory allocated for transactions.
            Child transactions are counted as active until they either commit or
            abort.
            </summary>
            <remarks>
            <para>
            Transactions that update multiversion databases are not freed until
            the last page version that the transaction created is flushed from
            cache. This means that applications using multi-version concurrency
            control may need a transaction for each page in cache, in the
            extreme case.
            </para>
            <para>
            When all of the memory available in the database environment for
            transactions is in use, calls to 
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/> will fail (until
            some active transactions complete). If MaxTransactions is never set,
            the database environment is configured to support at least 100
            active transactions.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.ThreadCount">
            <summary>
            An approximate number of threads in the database environment.
            </summary>
            <remarks>
            <para>
            ThreadCount must set if <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>
            will be used. ThreadCount does not set the maximum number of threads
            but is used to determine memory sizing and the thread control block
            reclamation policy.
            </para>
            <para>
            If a process has not configured <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadIsAlive"/>, and
            then attempts to join a database environment configured for failure
            checking with <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>,
            <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.SetThreadID"/>, <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadIsAlive"/> and
            ThreadCount, the program may be unable to allocate a thread control
            block and fail to join the environment. This is true of the
            standalone Berkeley DB utility programs. To avoid problems when
            using the standalone Berkeley DB utility programs with environments
            configured for failure checking, incorporate the utility's
            functionality directly in the application, or call 
            <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/> before running the
            utility.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.TxnTimeout">
            <summary>
            A value, in microseconds, representing transaction timeouts.
            </summary>
            <remarks>
            <para>
            All timeouts are checked whenever a thread of control blocks on a
            lock or when deadlock detection is performed. As timeouts are only
            checked when the lock request first blocks or when deadlock
            detection is performed, the accuracy of the timeout depends on how
            often deadlock detection is performed.
            </para>
            <para>
            Timeout values specified for the database environment may be
            overridden on a per-transaction basis, see
            <see cref="M:BerkeleyDB.Transaction.SetTxnTimeout(System.UInt32)"/>.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.DatabaseEnvironmentConfig.TxnTimestamp">
            <summary>
            Recover to the time specified by timestamp rather than to the most
            current possible date.
            </summary>
            <remarks>
            <para>
            Once a database environment has been upgraded to a new version of
            Berkeley DB involving a log format change (see Upgrading Berkeley DB
            installations in the Programmer's Reference Guide), it is no longer
            possible to recover to a specific time before that upgrade.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.SecondaryBTreeDatabase">
            <summary>
            A class representing a SecondaryBTreeDatabase.  The Btree format is a
            representation of a sorted, balanced tree structure. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryBTreeDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)">
            <summary>
            Instantiate a new SecondaryBTreeDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryBTreeDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new SecondaryBTreeDatabase object, open the
            database represented by <paramref name="Filename"/> and associate 
            the database with the
            <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.Compare">
            <summary>
            The Btree key comparison function. The comparison function is called
            whenever it is necessary to compare a key specified by the
            application with a key currently stored in the tree. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.DupCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.Duplicates">
            <summary>
            Whether the insertion of duplicate data items in the database is
            permitted, and whether duplicates items are sorted.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.MinKeysPerPage">
            <summary>
            The minimum number of key/data pairs intended to be stored on any
            single Btree leaf page.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.ReverseSplit">
            <summary>
            If false, empty pages will not be coalesced into higher-level pages.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.PrefixCompare">
            <summary>
            The Btree prefix function. The prefix function is used to determine
            the amount by which keys stored on the Btree internal pages can be
            safely truncated without losing their uniqueness.
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabase.RecordNumbers">
            <summary>
            If true, this object supports retrieval from the Btree using record
            numbers.
            </summary>
        </member>
        <member name="T:BerkeleyDB.CreatePolicy">
            <summary>
            The policy for how to handle database creation.
            </summary>
        </member>
        <member name="F:BerkeleyDB.CreatePolicy.NEVER">
            <summary>
            Never create the database.
            </summary>
        </member>
        <member name="F:BerkeleyDB.CreatePolicy.IF_NEEDED">
            <summary>
            Create the database if it does not already exist.
            </summary>
        </member>
        <member name="F:BerkeleyDB.CreatePolicy.ALWAYS">
            <summary>
            Do not open the database and return an error if it already exists.
            </summary>
        </member>
        <member name="T:BerkeleyDB.DatabaseFeedbackEvent">
            <summary>
            Specifies the database operation whose progress is being reported
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseFeedbackEvent.UPGRADE">
            <summary>
            The underlying database is being upgraded.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseFeedbackEvent.VERIFY">
            <summary>
            The underlying database is being verified.
            </summary>
        </member>
        <member name="T:BerkeleyDB.DuplicatesPolicy">
            <summary>
            Policy for duplicate data items in the database; that is, whether insertion
            when the key of the key/data pair being inserted already exists in the
            database will be successful. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.DuplicatesPolicy.NONE">
            <summary>
            Insertion when the key of the key/data pair being inserted already
            exists in the database will fail.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DuplicatesPolicy.SORTED">
            <summary>
            Duplicates are allowed and mainted in sorted order, as determined by the
            duplicate comparison function.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DuplicatesPolicy.UNSORTED">
            <summary>
            Duplicates are allowed and ordered in the database by the order of
            insertion, unless the ordering is otherwise specified by use of a cursor
            operation or a duplicate sort function. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.EncryptionAlgorithm">
            <summary>
            Specifies an algorithm used for encryption and decryption
            </summary>
        </member>
        <member name="F:BerkeleyDB.EncryptionAlgorithm.DEFAULT">
            <summary>
            The default algorithm, or the algorithm previously used in an
            existing environment
            </summary>
        </member>
        <member name="F:BerkeleyDB.EncryptionAlgorithm.AES">
            <summary>
            The Rijndael/AES algorithm
            </summary>
            <remarks>
            Also known as the Advanced Encryption Standard and Federal
            Information Processing Standard (FIPS) 197
            </remarks>
        </member>
        <member name="T:BerkeleyDB.EnvironmentFeedbackEvent">
            <summary>
            Specifies the environment operation whose progress is being reported
            </summary>
        </member>
        <member name="F:BerkeleyDB.EnvironmentFeedbackEvent.RECOVERY">
            <summary>
            The environment is being recovered.
            </summary>
        </member>
        <member name="T:BerkeleyDB.ForeignKeyDeleteAction">
            <summary>
            Specifies the action to take when deleting a foreign key
            </summary>
        </member>
        <member name="F:BerkeleyDB.ForeignKeyDeleteAction.ABORT">
            <summary>
            Abort the deletion.
            </summary>
        </member>
        <member name="F:BerkeleyDB.ForeignKeyDeleteAction.CASCADE">
            <summary>
            Delete records that refer to the foreign key
            </summary>
        </member>
        <member name="F:BerkeleyDB.ForeignKeyDeleteAction.NULLIFY">
            <summary>
            Nullify records that refer to the foreign key
            </summary>
        </member>
        <member name="T:BerkeleyDB.Isolation">
            <summary>
            Specify the degree of isolation for transactional operations
            </summary>
        </member>
        <member name="F:BerkeleyDB.Isolation.DEGREE_ONE">
            <summary>
            Read operations on the database may request the return of modified
            but not yet committed data.
            </summary>
        </member>
        <member name="F:BerkeleyDB.Isolation.DEGREE_TWO">
            <summary>
            Provide for cursor stability but not repeatable reads. Data items
            which have been previously read by a transaction may be deleted or
            modified by other transactions before the original transaction
            completes.
            </summary>
        </member>
        <member name="F:BerkeleyDB.Isolation.DEGREE_THREE">
            <summary>
            For the life of the transaction, every time a thread of control
            reads a data item, it will be unchanged from its previous value
            (assuming, of course, the thread of control does not itself modify
            the item).  This is Berkeley DB's default degree of isolation.
            </summary>
        </member>
        <member name="T:BerkeleyDB.NotificationEvent">
            <summary>
            Specify a Berkeley DB event
            </summary>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.PANIC">
            <summary>
            The database environment has failed.
            </summary>
            <remarks>
            All threads of control in the database environment should exit the
            environment, and recovery should be run.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.REP_CLIENT">
            <summary>
            The local site is now a replication client.
            </summary>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.REP_ELECTED">
            <summary>
            The local replication site has just won an election.
            </summary>
            <remarks>
            <para>
            An application using the Base replication API should arrange for a
            call to
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/> after
            receiving this event, to reconfigure the local environment as a
            replication master.
            </para>
            <para>
            Replication Manager applications may safely ignore this event. The
            Replication Manager calls
            <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/>
            automatically on behalf of the application when appropriate
            (resulting in firing of the <see cref="F:BerkeleyDB.NotificationEvent.REP_MASTER"/> event).
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.REP_MASTER">
            <summary>
            The local site is now the master site of its replication group. It
            is the application's responsibility to begin acting as the master
            environment.
            </summary>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER">
            <summary>
            The replication group of which this site is a member has just
            established a new master; the local site is not the new master. The
            event_info parameter to the <see cref="T:BerkeleyDB.EventNotifyDelegate"/>
            stores an integer containing the environment ID of the new master. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.REP_PERM_FAILED">
            <summary>
            The replication manager did not receive enough acknowledgements
            (based on the acknowledgement policy configured with
            <see cref="F:BerkeleyDB.ReplicationConfig.RepMgrAckPolicy"/>) to ensure a
            transaction's durability within the replication group. The
            transaction will be flushed to the master's local disk storage for
            durability.
            </summary>
            <remarks>
            This event is provided only to applications configured for the
            replication manager. 
            </remarks>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.REP_STARTUPDONE">
            <summary>
            The client has completed startup synchronization and is now
            processing live log records received from the master. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.NotificationEvent.WRITE_FAILED">
            <summary>
            A Berkeley DB write to stable storage failed. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.DeadlockPolicy">
            <summary>
            A class to represent what lock request(s) should be rejected during
            deadlock resolution.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.DEFAULT">
            <summary>
            If no DeadlockPolicy has yet been specified, use
            <see cref="F:BerkeleyDB.DeadlockPolicy.RANDOM"/>.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.EXPIRE">
            <summary>
            Reject lock requests which have timed out. No other deadlock
            detection is performed.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.MAX_LOCKS">
            <summary>
            Reject the lock request for the locker ID with the most locks.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.MAX_WRITE">
            <summary>
            Reject the lock request for the locker ID with the most write locks.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.MIN_LOCKS">
            <summary>
            Reject the lock request for the locker ID with the fewest locks.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.MIN_WRITE">
            <summary>
            Reject the lock request for the locker ID with the fewest write
            locks.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.OLDEST">
            <summary>
            Reject the lock request for the locker ID with the oldest lock.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.RANDOM">
            <summary>
            Reject the lock request for a random locker ID.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DeadlockPolicy.YOUNGEST">
            <summary>
            Reject the lock request for the locker ID with the youngest lock.
            </summary>
        </member>
        <member name="T:BerkeleyDB.CacheInfo">
            <summary>
            A class to represent information about the Berkeley DB cache
            </summary>
        </member>
        <member name="F:BerkeleyDB.CacheInfo.Gigabytes">
            <summary>
            The number of gigabytes in the cache
            </summary>
        </member>
        <member name="F:BerkeleyDB.CacheInfo.Bytes">
            <summary>
            The number of bytes in the cache
            </summary>
        </member>
        <member name="F:BerkeleyDB.CacheInfo.NCaches">
            <summary>
            The number of caches
            </summary>
        </member>
        <member name="M:BerkeleyDB.CacheInfo.#ctor(System.UInt32,System.UInt32,System.Int32)">
            <summary>
            Create a new CacheInfo object.  The size of the cache is set to 
            gbytes gigabytes plus bytes and spread over numCaches separate
            caches.
            </summary>
            <param name="gbytes">The number of gigabytes in the cache</param>
            <param name="bytes">The number of bytes in the cache</param>
            <param name="numCaches">The number of caches</param>
        </member>
        <member name="T:BerkeleyDB.Sequence">
            <summary>
            A class that provides an arbitrary number of persistent objects that
            return an increasing or decreasing sequence of integers.
            </summary>
        </member>
        <member name="M:BerkeleyDB.Sequence.#ctor(BerkeleyDB.SequenceConfig)">
            <summary>
            Instantiate a new Sequence object.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="cfg">Configuration parameters for the Sequence</param>
        </member>
        <member name="M:BerkeleyDB.Sequence.#ctor(BerkeleyDB.SequenceConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new Sequence object.
            </summary>
            <remarks>
            If <paramref name="txn"/> is null and the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected.
            </remarks>
            <param name="cfg">Configuration parameters for the Sequence</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.Sequence.Close">
            <summary>
            Close the sequence handle. Any unused cached values are lost. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.Sequence.Get(System.Int32)">
            <summary>
            Return the next available element in the sequence and change the
            sequence value by <paramref name="Delta"/>.
            </summary>
            <overloads>
            <para>
            If there are enough cached values in the sequence handle then they
            will be returned. Otherwise the next value will be fetched from the
            database and incremented (decremented) by enough to cover the delta
            and the next batch of cached values. 
            </para>
            <para>
            For maximum concurrency a non-zero cache size should be specified
            prior to opening the sequence handle and <paramref name="NoSync"/>
            should be specified for each Get method call.
            </para>
            <para>
            By default, sequence ranges do not wrap; to cause the sequence to
            wrap around the beginning or end of its range, set
            <paramref name="SequenceConfig.Wrap"/> to true.
            </para>
            <para>
            If <paramref name="P:BackingDatabase"/> was opened in a transaction,
            calling Get may result in changes to the sequence object; these
            changes will be automatically committed in a transaction internal to
            the Berkeley DB library. If the thread of control calling Get has an
            active transaction, which holds locks on the same database as the
            one in which the sequence object is stored, it is possible for a
            thread of control calling Get to self-deadlock because the active
            transaction's locks conflict with the internal transaction's locks.
            For this reason, it is often preferable for sequence objects to be
            stored in their own database. 
            </para>
            </overloads>
            <param name="Delta">
            The amount by which to increment the sequence value.  Must be
            greater than 0.
            </param>
            <returns>The next available element in the sequence.</returns>
        </member>
        <member name="M:BerkeleyDB.Sequence.Get(System.Int32,System.Boolean)">
            <summary>
            Return the next available element in the sequence and change the
            sequence value by <paramref name="Delta"/>.
            </summary>
            <param name="Delta">
            The amount by which to increment the sequence value.  Must be
            greater than 0.
            </param>
            <param name="NoSync">
            If true, and if the operation is implicitly transaction protected,
            do not synchronously flush the log when the transaction commits.
            </param>
            <returns>The next available element in the sequence.</returns>
        </member>
        <member name="M:BerkeleyDB.Sequence.Get(System.Int32,BerkeleyDB.Transaction)">
            <summary>
            Return the next available element in the sequence and change the
            sequence value by <paramref name="Delta"/>.
            </summary>
            <param name="Delta">
            The amount by which to increment the sequence value.  Must be
            greater than 0.
            </param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.  
            Must be null if the sequence was opened with a non-zero cache size. 
            </param>
            <returns>The next available element in the sequence.</returns>
        </member>
        <member name="M:BerkeleyDB.Sequence.PrintStats">
            <summary>
            Print diagnostic information.
            </summary>
        </member>
        <member name="M:BerkeleyDB.Sequence.PrintStats(System.Boolean)">
            <summary>
            Print diagnostic information.
            </summary>
            <overloads>
            The diagnostic information is described by
            <see cref="T:BerkeleyDB.SequenceStats"/>. 
            </overloads>
            <param name="ClearStats">
            If true, reset statistics after printing.
            </param>
        </member>
        <member name="M:BerkeleyDB.Sequence.Remove">
            <summary>
            Remove the sequence from the database.
            </summary>
        </member>
        <member name="M:BerkeleyDB.Sequence.Remove(System.Boolean)">
            <summary>
            Remove the sequence from the database.
            </summary>
            <param name="NoSync">
            If true, and if the operation is implicitly transaction protected,
            do not synchronously flush the log when the transaction commits.
            </param>
        </member>
        <member name="M:BerkeleyDB.Sequence.Remove(BerkeleyDB.Transaction)">
            <summary>
            Remove the sequence from the database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
        </member>
        <member name="M:BerkeleyDB.Sequence.Stats">
            <summary>
            Return statistical information for this sequence.
            </summary>
            <returns>Statistical information for this sequence.</returns>
        </member>
        <member name="M:BerkeleyDB.Sequence.Stats(System.Boolean)">
            <summary>
            Return statistical information for this sequence.
            </summary>
            <overloads>
            <para>
            In the presence of multiple threads or processes accessing an active
            sequence, the information returned by DB_SEQUENCE->stat() may be
            out-of-date.
            </para>
            <para>
            The DB_SEQUENCE->stat() method cannot be transaction-protected. For
            this reason, it should be called in a thread of control that has no
            open cursors or active transactions. 
            </para>
            </overloads>
            <param name="clear">If true, reset statistics.</param>
            <returns>Statistical information for this sequence.</returns>
        </member>
        <member name="M:BerkeleyDB.Sequence.Dispose">
            <summary>
            Release the resources held by this object, and close the sequence if
            it's still open.
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.BackingDatabase">
            <summary>
            The database used by the sequence.
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Key">
            <summary>
            The key for the sequence.
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Cachesize">
            <summary>
            The current cache size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Min">
            <summary>
            The minimum value in the sequence.
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Max">
            <summary>
            The maximum value in the sequence.
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Wrap">
            <summary>
            If true, the sequence should wrap around when it is incremented
            (decremented) past the specified maximum (minimum) value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Increment">
            <summary>
            If true, the sequence will be incremented. This is the default. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.Sequence.Decrement">
            <summary>
            If true, the sequence will be decremented.
            </summary>
        </member>
        <member name="T:BerkeleyDB.KeyRange">
            <summary>
            <para>
            A class representing an estimate of the proportion of keys that are less
            than, equal to, and greater than a given key.
            </para>
            <para>
            Values are in the range of 0 to 1; for example, if the field less is
            0.05, 5% of the keys in the database are less than the key parameter.
            The value for equal will be zero if there is no matching key, and will
            be non-zero otherwise. 
            </para>
            </summary>
        </member>
        <member name="P:BerkeleyDB.KeyRange.Less">
            <summary>
            A value between 0 and 1, the proportion of keys less than the
            specified key. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.KeyRange.Equal">
            <summary>
            A value between 0 and 1, the proportion of keys equal to the
            specified key. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.KeyRange.Greater">
            <summary>
            A value between 0 and 1, the proportion of keys greater than the
            specified key.
            </summary>
        </member>
        <member name="T:BerkeleyDB.MutexStats">
            <summary>
            Statistical information about the mutex subsystem
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.Alignment">
            <summary>
            Mutex alignment 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.Available">
            <summary>
            Available mutexes 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.Count">
            <summary>
            Mutex count 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.InUse">
            <summary>
            Mutexes in use 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.MaxInUse">
            <summary>
            Maximum mutexes ever in use 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.RegionNoWait">
            <summary>
            Region lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.RegionSize">
            <summary>
            Region size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.RegionWait">
            <summary>
            Region lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MutexStats.TASSpins">
            <summary>
            Mutex test-and-set spins 
            </summary>
        </member>
        <member name="T:BerkeleyDB.MPoolConfig">
            <summary>
            A class representing configuration parameters for a
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s memory pool subsystem.
            </summary>
        </member>
        <member name="F:BerkeleyDB.MPoolConfig.CacheSize">
            <summary>
            The size of the shared memory buffer pool — that is, the cache.
            </summary>
            <remarks>
            <para>
            The cache should be the size of the normal working data set of the
            application, with some small amount of additional memory for unusual
            situations. (Note: the working set is not the same as the number of
            pages accessed simultaneously, and is usually much larger.)
            </para>
            <para>
            The default cache size is 256KB, and may not be specified as less
            than 20KB. Any cache size less than 500MB is automatically increased
            by 25% to account for buffer pool overhead; cache sizes larger than
            500MB are used as specified. The maximum size of a single cache is
            4GB on 32-bit systems and 10TB on 64-bit systems. (All sizes are in
            powers-of-two, that is, 256KB is 2^18 not 256,000.) For information
            on tuning the Berkeley DB cache size, see Selecting a cache size in
            the Programmer's Reference Guide.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.MPoolConfig.MaxCacheSize">
            <summary>
            The maximum cache size.
            </summary>
            <remarks>
            <para>
            The specified size is rounded to the nearest multiple of the cache
            region size, which is the initial cache size divided by
            <see cref="F:BerkeleyDB.CacheInfo.NCaches">CacheSize.NCaches</see>. If no value
            is specified, it defaults to the initial cache size.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.MPoolConfig.SetMaxSequentialWrites(System.Int32,System.UInt32)">
            <summary>
            Limit the number of sequential write operations scheduled by the
            library when flushing dirty pages from the cache.
            </summary>
            <param name="maxWrites">
            The maximum number of sequential write operations scheduled by the
            library when flushing dirty pages from the cache, or 0 if there is
            no limitation on the number of sequential write operations.
            </param>
            <param name="pause">
            The number of microseconds the thread of control should pause before
            scheduling further write operations. It must be specified as an
            unsigned 32-bit number of microseconds, limiting the maximum pause
            to roughly 71 minutes.
            </param>
        </member>
        <member name="P:BerkeleyDB.MPoolConfig.MaxOpenFiles">
            <summary>
            The number of file descriptors the library will open concurrently
            when flushing dirty pages from the cache.
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolConfig.SequentialWritePause">
            <summary>
            The number of microseconds the thread of control should pause before
            scheduling further write operations.
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolConfig.MaxSequentialWrites">
            <summary>
            The number of sequential write operations scheduled by the library
            when flushing dirty pages from the cache. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.MPoolConfig.MMapSize">
            <summary>
            The maximum file size, in bytes, for a file to be mapped into the
            process address space. If no value is specified, it defaults to
            10MB. 
            </summary>
            <remarks>
            Files that are opened read-only in the cache (and that satisfy a few
            other criteria) are, by default, mapped into the process address
            space instead of being copied into the local cache. This can result
            in better-than-usual performance because available virtual memory is
            normally much larger than the local cache, and page faults are
            faster than page copying on many systems. However, it can cause
            resource starvation in the presence of limited virtual memory, and
            it can result in immense process sizes in the presence of large
            databases.
            </remarks>
        </member>
        <member name="T:BerkeleyDB.LogConfig">
            <summary>
            A class representing configuration parameters for a
            <see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s logging subsystem.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LogConfig.AutoRemove">
            <summary>
            If true, Berkeley DB will automatically remove log files that are no
            longer needed.
            </summary>
            <remarks>
            <para>
            Automatic log file removal is likely to make catastrophic recovery
            impossible.
            </para>
            <para>
            Replication applications will rarely want to configure automatic log
            file removal as it increases the likelihood a master will be unable
            to satisfy a client's request for a recent log record.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.LogConfig.ForceSync">
            <summary>
            If true, Berkeley DB will flush log writes to the backing disk
            before returning from the write system call, rather than flushing
            log writes explicitly in a separate system call, as necessary. 
            </summary>
            <remarks>
            <para>
            This is only available on some systems (for example, systems
            supporting the IEEE/ANSI Std 1003.1 (POSIX) standard O_DSYNC flag,
            or systems supporting the Windows FILE_FLAG_WRITE_THROUGH flag).
            This flag may result in inaccurate file modification times and other
            file-level information for Berkeley DB log files. This flag may
            offer a performance increase on some systems and a performance
            decrease on others.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.LogConfig.InMemory">
            <summary>
            If true, maintain transaction logs in memory rather than on disk.
            </summary>
            <remarks>
            <para>
            This means that transactions exhibit the ACI (atomicity,
            consistency, and isolation) properties, but not D (durability); that
            is, database integrity will be maintained, but if the application or
            system fails, integrity will not persist. All database files must be
            verified and/or restored from a replication group master or archival
            backup after application or system failure.
            </para> 
            <para>
            When in-memory logs are configured and no more log buffer space is
            available, Berkeley DB methods may throw
            <see cref="T:BerkeleyDB.FullLogBufferException"/>. When choosing log buffer and
            file sizes for in-memory logs, applications should ensure the
            in-memory log buffer size is large enough that no transaction will
            ever span the entire buffer, and avoid a state where the in-memory
            buffer is full and no space can be freed because a transaction that
            started in the first log "file" is still active.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.LogConfig.NoBuffer">
            <summary>
            If true, turn off system buffering of Berkeley DB log files to avoid
            double caching.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LogConfig.ZeroOnCreate">
            <summary>
            If true, zero all pages of a log file when that log file is created.
            </summary>
            <remarks>
            <para>
            This has shown to provide greater transaction throughput in some
            environments. The log file will be zeroed by the thread which needs
            to re-create the new log file. Other threads may not write to the
            log file while this is happening.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.LogConfig.Dir">
            <summary>
            The path of a directory to be used as the location of logging files.
            Log files created by the Log Manager subsystem will be created in
            this directory. 
            </summary>
            <remarks>
            <para>
            If no logging directory is specified, log files are created in the
            environment home directory. See Berkeley DB File Naming in the
            Programmer's Reference Guide for more information.
            </para>
            <para>
            For the greatest degree of recoverability from system or application
            failure, database files and log files should be located on separate
            physical devices.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            Dir must be consistent with the existing environment or corruption
            can occur.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LogConfig.BufferSize">
            <summary>
            The size of the in-memory log buffer, in bytes.
            </summary>
            <remarks>
            <para>
            When the logging subsystem is configured for on-disk logging, the
            default size of the in-memory log buffer is approximately 32KB. Log
            information is stored in-memory until the storage space fills up or
            transaction commit forces the information to be flushed to stable
            storage. In the presence of long-running transactions or
            transactions producing large amounts of data, larger buffer sizes
            can increase throughput.
            </para>
            <para>
            When the logging subsystem is configured for in-memory logging, the
            default size of the in-memory log buffer is 1MB. Log information is
            stored in-memory until the storage space fills up or transaction
            abort or commit frees up the memory for new transactions. In the
            presence of long-running transactions or transactions producing
            large amounts of data, the buffer size must be sufficient to hold
            all log information that can accumulate during the longest running
            transaction. When choosing log buffer and file sizes for in-memory
            logs, applications should ensure the in-memory log buffer size is
            large enough that no transaction will ever span the entire buffer,
            and avoid a state where the in-memory buffer is full and no space
            can be freed because a transaction that started in the first log
            "file" is still active.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            BufferSize will be ignored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LogConfig.FileMode">
            <summary>
            The absolute file mode for created log files.
            </summary>
            <remarks>
            <para>
            This method is only useful for the rare Berkeley DB application that
            does not control its umask value.
            </para>
            <para>
            Normally, if Berkeley DB applications set their umask appropriately,
            all processes in the application suite will have read permission on
            the log files created by any process in the application suite.
            However, if the Berkeley DB application is a library, a process
            using the library might set its umask to a value preventing other
            processes in the application suite from reading the log files it
            creates. In this rare case, the DB_ENV->set_lg_filemode() method can
            be used to set the mode of created log files to an absolute value.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.LogConfig.MaxFileSize">
            <summary>
            The maximum size of a single file in the log, in bytes. Because 
            <see cref="F:BerkeleyDB.LSN.Offset"/> is an unsigned four-byte value, MaxFileSize
            may not be larger than the maximum unsigned four-byte value.
            </summary>
            <remarks>
            <para>
            When the logging subsystem is configured for on-disk logging, the
            default size of a log file is 10MB.
            </para>
            <para>
            When the logging subsystem is configured for in-memory logging, the
            default size of a log file is 256KB. In addition, the
            <see cref="P:BerkeleyDB.LogConfig.BufferSize">configured log buffer size</see> must be
            larger than the log file size. (The logging subsystem divides memory
            configured for in-memory log records into "files", as database
            environments configured for in-memory log records may exchange log
            records with other members of a replication group, and those members
            may be configured to store log records on-disk.) When choosing log
            buffer and file sizes for in-memory logs, applications should ensure
            the in-memory log buffer size is large enough that no transaction
            will ever span the entire buffer, and avoid a state where the
            in-memory buffer is full and no space can be freed because a
            transaction that started in the first log "file" is still active.
            </para>
            <para>
            See Log File Limits in the Programmer's Reference Guide for more
            information.
            </para>
            <para>
            If no size is specified by the application, the size last specified
            for the database region will be used, or if no database region
            previously existed, the default will be used.
            </para></remarks>
        </member>
        <member name="P:BerkeleyDB.LogConfig.RegionSize">
            <summary>
            Te size of the underlying logging area of the Berkeley DB
            environment, in bytes.
            </summary>
            <remarks>
            <para>
            By default, or if the value is set to 0, the default size is
            approximately 60KB. The log region is used to store filenames, and
            so may need to be increased in size if a large number of files will
            be opened and registered with the specified Berkeley DB
            environment's log manager.
            </para>
            <para>
            If the database environment already exists when
            <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
            RegionSize will be ignored.
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.DatabaseException">
            <summary>
            Represents errors that occur during Berkley DB operations.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseException.ErrorCode">
            <summary>
            The underlying error code from the Berkeley DB C library.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseException.ThrowException(System.Int32)">
            <summary>
            Throw an exception which corresponds to the specified Berkeley DB
            error code.
            </summary>
            <param name="err">The Berkeley DB error code</param>
        </member>
        <member name="M:BerkeleyDB.DatabaseException.#ctor(System.Int32)">
            <summary>
            Create a new DatabaseException, encapsulating a specific error code.
            </summary>
            <param name="err">The error code to encapsulate.</param>
        </member>
        <member name="T:BerkeleyDB.BadSecondaryException">
            <summary>
            A secondary index has been corrupted. This is likely the result of an
            application operating on related databases without first associating
            them.
            </summary>
        </member>
        <member name="M:BerkeleyDB.BadSecondaryException.#ctor">
            <summary>
            Initialize a new instance of the BadSecondaryException
            </summary>
        </member>
        <member name="T:BerkeleyDB.ForeignConflictException">
            <summary>
            
            </summary>
        </member>
        <member name="M:BerkeleyDB.ForeignConflictException.#ctor">
            <summary>
            Initialize a new instance of the ForeignConflictException
            </summary>
        </member>
        <member name="T:BerkeleyDB.FullLogBufferException">
            <summary>
            In-memory logs are configured and no more log buffer space is available.
            </summary>
        </member>
        <member name="M:BerkeleyDB.FullLogBufferException.#ctor">
            <summary>
            Initialize a new instance of the FullLogBufferException
            </summary>
        </member>
        <member name="T:BerkeleyDB.KeyEmptyException">
            <summary>
            The requested key/data pair logically exists but was never explicitly
            created by the application, or that the requested key/data pair was
            deleted and never re-created. In addition, the Queue access method will
            throw a KeyEmptyException for records that were created as part of a
            transaction that was later aborted and never re-created.
            </summary>
            <remarks>
            The Recno and Queue access methods will automatically create key/data
            pairs under some circumstances.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.KeyEmptyException.#ctor">
            <summary>
            Initialize a new instance of the KeyEmptyException
            </summary>
        </member>
        <member name="T:BerkeleyDB.KeyExistException">
            <summary>
            A key/data pair was inserted into the database using
            <see cref="M:BerkeleyDB.Database.PutNoOverwrite(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> and the key already
            exists in the database, or using
            <see cref="M:BerkeleyDB.BTreeDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> or
            <see cref="M:BerkeleyDB.HashDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> and the key/data
            pair already exists in the database.
            </summary>
        </member>
        <member name="M:BerkeleyDB.KeyExistException.#ctor">
            <summary>
            Initialize a new instance of the KeyExistException
            </summary>
        </member>
        <member name="T:BerkeleyDB.DeadlockException">
            <summary>
            When multiple threads of control are modifying the database, there is
            normally the potential for deadlock. In Berkeley DB, deadlock is
            signified by a DeadlockException thrown from the Berkeley DB function.
            Whenever a Berkeley DB function throws a DeadlockException, the
            enclosing transaction should be aborted.
            </summary>
        </member>
        <member name="M:BerkeleyDB.DeadlockException.#ctor">
            <summary>
            Initialize a new instance of the DeadlockException
            </summary>
        </member>
        <member name="T:BerkeleyDB.LeaseExpiredException">
            <summary>
            The site's replication master lease has expired.
            </summary>
        </member>
        <member name="M:BerkeleyDB.LeaseExpiredException.#ctor">
            <summary>
            Initialize a new instance of the LeaseExpiredException
            </summary>
        </member>
        <member name="T:BerkeleyDB.LockNotGrantedException">
            <summary>
            If <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted"/> is true,
            database calls timing out based on lock or transaction timeout values
            will throw a LockNotGrantedException, instead of a DeadlockException.
            </summary>
        </member>
        <member name="M:BerkeleyDB.LockNotGrantedException.#ctor">
            <summary>
            Initialize a new instance of the LockNotGrantedException
            </summary>
        </member>
        <member name="M:BerkeleyDB.MemoryException.#ctor">
            <summary>
            Initialize a new instance of the MemoryException
            </summary>
        </member>
        <member name="T:BerkeleyDB.NotFoundException">
            <summary>
            The requested key/data pair did not exist in the database or that
            start-of- or end-of-file has been reached by a cursor.
            </summary>
        </member>
        <member name="M:BerkeleyDB.NotFoundException.#ctor">
            <summary>
            Initialize a new instance of the NotFoundException
            </summary>
        </member>
        <member name="T:BerkeleyDB.OldVersionException">
            <summary>
            This version of Berkeley DB is unable to upgrade a given database.
            </summary>
        </member>
        <member name="M:BerkeleyDB.OldVersionException.#ctor">
            <summary>
            Initialize a new instance of the OldVersionException
            </summary>
        </member>
        <member name="T:BerkeleyDB.PageNotFoundException">
            <summary>
            
            </summary>
        </member>
        <member name="M:BerkeleyDB.PageNotFoundException.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="T:BerkeleyDB.RunRecoveryException">
            <summary>
            Berkeley DB has encountered an error it considers fatal to an entire
            environment. Once a RunRecoveryException has been thrown by any
            interface, it will be returned from all subsequent Berkeley DB calls
            made by any threads of control participating in the environment.
            </summary>
            <remarks>
            An example of this type of fatal error is a corrupted database page. The
            only way to recover from this type of error is to have all threads of
            control exit the Berkeley DB environment, run recovery of the
            environment, and re-enter Berkeley DB. (It is not strictly necessary
            that the processes exit, although that is the only way to recover system
            resources, such as file descriptors and memory, allocated by
            Berkeley DB.)
            </remarks>
        </member>
        <member name="M:BerkeleyDB.RunRecoveryException.#ctor">
            <summary>
            Initialize a new instance of the RunRecoveryException
            </summary>
        </member>
        <member name="T:BerkeleyDB.VerificationException">
            <summary>
            Thrown by <see cref="M:BerkeleyDB.Database.Verify(System.String,BerkeleyDB.DatabaseConfig)"/> if a database is
            corrupted, and by <see cref="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig)"/> if all
            key/data pairs in the file may not have been successfully output.
            </summary>
        </member>
        <member name="M:BerkeleyDB.VerificationException.#ctor">
            <summary>
            Initialize a new instance of the VerificationException
            </summary>
        </member>
        <member name="T:BerkeleyDB.VersionMismatchException">
            <summary>
            The version of the Berkeley DB library doesn't match the version that
            created the database environment.
            </summary>
        </member>
        <member name="M:BerkeleyDB.VersionMismatchException.#ctor">
            <summary>
            Initialize a new instance of the VersionMismatchException
            </summary>
        </member>
        <member name="T:BerkeleyDB.DbThreadID">
            <summary>
            A class representing a unique identifier for a thread of control in a
            Berkeley DB application.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DbThreadID.processID">
            <summary>
            The Process ID of the thread of control
            </summary>
        </member>
        <member name="F:BerkeleyDB.DbThreadID.threadID">
            <summary>
            The Thread ID of the thread of control
            </summary>
        </member>
        <member name="M:BerkeleyDB.DbThreadID.#ctor(System.Int32,System.UInt32)">
            <summary>
            Instantiate a new DbThreadID object
            </summary>
            <param name="pid">The Process ID of the thread of control</param>
            <param name="tid">The Thread ID of the thread of control</param>
        </member>
        <member name="T:BerkeleyDB.MultipleKeyDatabaseEntry">
            <summary>
            A class providing access to multiple key/data pairs.
            </summary>
        </member>
        <member name="M:BerkeleyDB.MultipleKeyDatabaseEntry.GetEnumerator">
            <summary>
            Return an enumerator which iterates over all
            <see cref="T:BerkeleyDB.DatabaseEntry"/> pairs represented by the 
            <see cref="T:BerkeleyDB.MultipleKeyDatabaseEntry"/>.
            </summary>
            <returns>
            An enumerator for the <see cref="T:BerkeleyDB.MultipleDatabaseEntry"/>
            </returns>
        </member>
        <member name="T:BerkeleyDB.SecondaryBTreeDatabaseConfig">
            <summary>
            A class representing configuration parameters for
            <see cref="T:BerkeleyDB.SecondaryBTreeDatabase"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Duplicates">
            <summary>
            Policy for duplicate data items in the database; that is, insertion
            when the key of the key/data pair being inserted already exists in
            the database will be successful.
            </summary>
            <remarks>
            <para>The ordering of duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
            of insertion, unless the ordering is otherwise specified by use of a
            cursor operation or a duplicate sort function. The ordering of
            duplicates in the database for
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
            duplicate comparison function. If the application does not specify a
            comparison function using 
            <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.DuplicateCompare"/>, a default lexical
            comparison will be used.
            </para>
            <para>
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to 
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
            <see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
            applications wanting to order duplicate data items manually.
            </para>
            <para>
            If the database already exists, the value of Duplicates must be the
            same as the existing database or an error will be returned.
            </para>
            <para>
            It is an error to specify <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.UseRecordNumbers"/> and
            anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.NoReverseSplitting">
            <summary>
            Turn reverse splitting in the Btree on or off.
            </summary>
            <remarks>
            As pages are emptied in a database, the Berkeley DB Btree
            implementation attempts to coalesce empty pages into higher-level
            pages in order to keep the database as small as possible and
            minimize search time. This can hurt performance in applications with
            cyclical data demands; that is, applications where the database
            grows and shrinks repeatedly. For example, because Berkeley DB does
            page-level locking, the maximum level of concurrency in a database
            of two pages is far smaller than that in a database of 100 pages, so
            a database that has shrunk to a minimal size can cause severe
            deadlocking when a new cycle of data insertion begins. 
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.UseRecordNumbers">
            <summary>
            If true, support retrieval from the Btree using record numbers.
            </summary>
            <remarks>
            <para>
            Logical record numbers in Btree databases are mutable in the face of
            record insertion or deletion. See
            <see cref="F:BerkeleyDB.RecnoDatabaseConfig.Renumber"/> for further discussion.
            </para>
            <para>
            Maintaining record counts within a Btree introduces a serious point
            of contention, namely the page locations where the record counts are
            stored. In addition, the entire database must be locked during both
            insertions and deletions, effectively single-threading the database
            for those operations. Specifying UseRecordNumbers can result in
            serious performance degradation for some applications and data sets.
            </para>
            <para>
            It is an error to specify <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.UseRecordNumbers"/> and
            anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
            </para>
            <para>
            If the database already exists, the value of UseRecordNumbers must
            be the same as the existing database or an error will be returned. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Creation">
            <summary>
            The policy for how to handle database creation.
            </summary>
            <remarks>
            If the database does not already exist and
            <see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
            <see cref="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)"/> will fail.
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Compare">
            <summary>
            The Btree key comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a key specified by the application with a key currently
            stored in the tree.
            </para>
            <para>
            If no comparison function is specified, the keys are compared
            lexically, with shorter keys collating before longer keys.
            </para>
            <para>
            If the database already exists, the comparison function must be the
            same as that historically used to create the database or corruption
            can occur. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.PrefixCompare">
            <summary>
            The Btree prefix function.
            </summary>
            <remarks>
            <para>
            The prefix function is used to determine the amount by which keys
            stored on the Btree internal pages can be safely truncated without
            losing their uniqueness. See the Btree prefix comparison section of
            the Berkeley DB Reference Guide for more details about how this
            works. The usefulness of this is data-dependent, but can produce
            significantly reduced tree sizes and search times in some data sets.
            </para>
            <para>
            If no prefix function or key comparison function is specified by the
            application, a default lexical comparison function is used as the
            prefix function. If no prefix function is specified and
            <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Compare"/> is specified, no prefix function is
            used. It is an error to specify a prefix function without also
            specifying <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Compare"/>. 
            </para>
            <para>
            If the database already exists, the prefix function must be the
            same as that historically used to create the database or corruption
            can occur. 
            </para>
            </remarks>
        </member>
        <member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.DuplicateCompare">
            <summary>
            The duplicate data item comparison function.
            </summary>
            <remarks>
            <para>
            The comparison function is called whenever it is necessary to
            compare a data item specified by the application with a data item
            currently stored in the database. Setting DuplicateCompare implies 
            setting <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Duplicates"/> to
            <see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
            </para>
            <para>
            If no comparison function is specified, the data items are compared
            lexically, with shorter data items collating before longer data
            items.
            </para>
            <para>
            If the database already exists when
            <see cref="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)"/> is called, the delegate
            must be the same as that historically used to create the database or
            corruption can occur.
            </para>
            </remarks>
        </member>
        <member name="M:BerkeleyDB.SecondaryBTreeDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
            <summary>
            Create a new SecondaryBTreeDatabaseConfig object
            </summary>
        </member>
        <member name="P:BerkeleyDB.SecondaryBTreeDatabaseConfig.MinKeysPerPage">
            <summary>
            The minimum number of key/data pairs intended to be stored on any
            single Btree leaf page.
            </summary>
            <remarks>
            <para>
            This value is used to determine if key or data items will be stored
            on overflow pages instead of Btree leaf pages. For more information
            on the specific algorithm used, see the Berkeley DB Reference Guide.
            The value specified must be at least 2; if not explicitly set, a
            value of 2 is used. 
            </para>
            <para>
            If the database already exists, MinKeysPerPage will be ignored. 
            </para>
            </remarks>
        </member>
        <member name="T:BerkeleyDB.LogStats">
            <summary>
            Statistical information about the logging subsystem
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.BufferSize">
            <summary>
            Log buffer size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.Bytes">
            <summary>
            Bytes to log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.BytesSinceCheckpoint">
            <summary>
            Bytes to log since checkpoint. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.CurrentFile">
            <summary>
            Current log file number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.CurrentOffset">
            <summary>
            Current log file offset. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.DiskFileNumber">
            <summary>
            Known on disk log file number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.DiskOffset">
            <summary>
            Known on disk log file offset. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.FileSize">
            <summary>
            Log file size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.MBytes">
            <summary>
            Megabytes to log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.MBytesSinceCheckpoint">
            <summary>
            Megabytes to log since checkpoint. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.MagicNumber">
            <summary>
            Log file magic number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.MaxCommitsPerFlush">
            <summary>
            Max number of commits in a flush. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.MinCommitsPerFlush">
            <summary>
            Min number of commits in a flush. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.OverflowWrites">
            <summary>
            Overflow writes to the log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.PermissionsMode">
            <summary>
            Log file permissions mode. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.Reads">
            <summary>
            Total I/O reads from the log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.Records">
            <summary>
            Records entered into the log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.RegionLockNoWait">
            <summary>
            Region lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.RegionLockWait">
            <summary>
            Region lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.RegionSize">
            <summary>
            Region size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.Syncs">
            <summary>
            Total syncs to the log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.Writes">
            <summary>
            Total I/O writes to the log. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LogStats.Version">
            <summary>
            Log file version number. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.JoinCursor">
            <summary>
            A class representing a join cursor, for use in performing equality or
            natural joins on secondary indices.  For information on how to organize
            your data to use this functionality, see Equality join in the
            Programmer's Reference Guide. 
            </summary>
            <remarks>
            JoinCursor does not support many of the operations offered by
            <see cref="T:BerkeleyDB.Cursor"/> and is not a subclass of <see cref="T:BerkeleyDB.Cursor"/>.
            </remarks>
            <seealso cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.Close">
            <summary>
            <para>
            Discard the cursor.
            </para>
            <para>
            It is possible for the Close() method to throw a
            <see cref="T:BerkeleyDB.DeadlockException"/>, signaling that any enclosing
            transaction should be aborted. If the application is already
            intending to abort the transaction, this error should be ignored,
            and the application should proceed.
            </para>
            <para>
            After Close has been called, regardless of its result, the object
            may not be used again. 
            </para>
            </summary>
            <exception cref="T:BerkeleyDB.DeadlockException"></exception>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.Dispose">
            <summary>
            Release the resources held by this object, and close the cursor if
            it's still open.
            </summary>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.GetEnumerator">
            <summary>
            Returns an enumerator that iterates through the
            <see cref="T:BerkeleyDB.JoinCursor"/>.
            </summary>
            <remarks>
            The enumerator will begin at the cursor's current position (or the
            first record if the cursor has not yet been positioned) and iterate 
            forwards (i.e. in the direction of <see cref="M:BerkeleyDB.JoinCursor.MoveNext"/>) over the
            remaining records.
            </remarks>
            <returns>An enumerator for the Cursor.</returns>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.MoveNext">
            <summary>
            Iterate over the values associated with the keys to which each 
            <see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
            was initialized. Any data value that appears in all
            <see cref="T:BerkeleyDB.SecondaryCursor"/>s is then used as a key into the
            primary, and the key/data pair found in the primary is stored in 
            <see cref="P:BerkeleyDB.JoinCursor.Current"/>.
            </summary>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.MoveNext(BerkeleyDB.LockingInfo)">
            <summary>
            Iterate over the values associated with the keys to which each 
            <see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
            was initialized. Any data value that appears in all
            <see cref="T:BerkeleyDB.SecondaryCursor"/>s is then used as a key into the
            primary, and the key/data pair found in the primary is stored in 
            <see cref="P:BerkeleyDB.JoinCursor.Current"/>.
            </summary>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.MoveNextItem">
            <summary>
            Iterate over the values associated with the keys to which each 
            <see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
            was initialized. Any data value that appears in all
            <see cref="T:BerkeleyDB.SecondaryCursor"/>s is then stored in 
            <see cref="P:BerkeleyDB.JoinCursor.Current">Current.Key</see>.
            </summary>
            <remarks>
            <see cref="P:BerkeleyDB.JoinCursor.Current">Current.Value</see> will contain an empty
            <see cref="T:BerkeleyDB.DatabaseEntry"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.JoinCursor.MoveNextItem(BerkeleyDB.LockingInfo)">
            <summary>
            Iterate over the values associated with the keys to which each 
            <see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
            was initialized. Any data value that appears in all
            <see cref="T:BerkeleyDB.SecondaryCursor"/>s is then stored in 
            <see cref="P:BerkeleyDB.JoinCursor.Current">Current.Key</see>.
            </summary>
            <remarks>
            <see cref="P:BerkeleyDB.JoinCursor.Current">Current.Value</see> will contain an empty
            <see cref="T:BerkeleyDB.DatabaseEntry"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="P:BerkeleyDB.JoinCursor.Current">
            <summary>
            The key/data pair at which the cursor currently points.
            </summary>
        </member>
        <member name="T:BerkeleyDB.DatabaseType">
            <summary>
            A class representing the supported Berkeley DB access methods.
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseType.BTREE">
            <summary>
            BTree access method
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseType.HASH">
            <summary>
            Hash access method
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseType.RECNO">
            <summary>
            Recno access method
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseType.QUEUE">
            <summary>
            Queue access method
            </summary>
        </member>
        <member name="F:BerkeleyDB.DatabaseType.UNKNOWN">
            <summary>
            Unknown access method
            </summary>
        </member>
        <member name="M:BerkeleyDB.DatabaseType.ToString">
            <summary>
            Convert this instance of DatabaseType to its string representation.
            </summary>
            <returns>A string representation of this instance.</returns>
        </member>
        <member name="T:BerkeleyDB.LockStats">
            <summary>
            Statistical information about the locking subsystem
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LastAllocatedLockerID">
            <summary>
            Last allocated locker ID. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockConflictsWait">
            <summary>
            Lock conflicts w/ subsequent wait 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockConflictsNoWait">
            <summary>
            Lock conflicts w/o subsequent wait 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockDeadlocks">
            <summary>
            Number of lock deadlocks. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockDowngrades">
            <summary>
            Number of lock downgrades. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockModes">
            <summary>
            Number of lock modes. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockPuts">
            <summary>
            Number of lock puts. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockRequests">
            <summary>
            Number of lock gets. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockSteals">
            <summary>
            Number of lock steals so far. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockTimeoutLength">
            <summary>
            Lock timeout. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockTimeouts">
            <summary>
            Number of lock timeouts. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockUpgrades">
            <summary>
            Number of lock upgrades. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockerNoWait">
            <summary>
            Locker lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.LockerWait">
            <summary>
            Locker lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.Lockers">
            <summary>
            Current number of lockers. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.Locks">
            <summary>
            Current number of locks. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxBucketLength">
            <summary>
            Max length of bucket. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxLockSteals">
            <summary>
            Maximum number steals in any partition. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxLockers">
            <summary>
            Maximum number of lockers so far. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxLockersInTable">
            <summary>
            Maximum num of lockers in table. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxLocks">
            <summary>
            Maximum number of locks so far. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxLocksInBucket">
            <summary>
            Maximum number of locks in any bucket. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxLocksInTable">
            <summary>
            Maximum number of locks in table. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxObjectSteals">
            <summary>
            Maximum number of steals in any partition. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxObjects">
            <summary>
            Maximum number of objects so far. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxObjectsInBucket">
            <summary>
            Maximum number of objectsin any bucket. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxPartitionLockNoWait">
            <summary>
            Max partition lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxPartitionLockWait">
            <summary>
            Max partition lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxUnusedID">
            <summary>
            Current maximum unused ID. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.MaxObjectsInTable">
            <summary>
            Maximum num of objects in table. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.nPartitions">
            <summary>
            number of partitions. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.ObjectNoWait">
            <summary>
            Object lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.ObjectSteals">
            <summary>
            Number of objects steals so far. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.ObjectWait">
            <summary>
            Object lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.Objects">
            <summary>
            Current number of objects. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.PartitionLockNoWait">
            <summary>
            Partition lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.PartitionLockWait">
            <summary>
            Partition lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.RegionNoWait">
            <summary>
            Region lock granted without wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.RegionSize">
            <summary>
            Region size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.RegionWait">
            <summary>
            Region lock granted after wait. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.TxnTimeoutLength">
            <summary>
            Transaction timeout. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.LockStats.TxnTimeouts">
            <summary>
            Number of transaction timeouts. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.VerboseMessages">
            <summary>
            Enable specific additional informational and debugging messages.
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.Deadlock">
            <summary>
            Display additional information when doing deadlock detection.
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.FileOps">
            <summary>
            Display additional information when performing filesystem operations
            such as open, close or rename. May not be available on all
            platforms. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.AllFileOps">
            <summary>
            Display additional information when performing all filesystem
            operations, including read and write. May not be available on all
            platforms. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.Recovery">
            <summary>
            Display additional information when performing recovery.
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.Register">
            <summary>
            Display additional information concerning support for
            <see cref="P:BerkeleyDB.DatabaseEnvironment.Register"/>
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.Replication">
            <summary>
            Display all detailed information about replication. This includes
            the information displayed by all of the other Replication* and
            RepMgr* values. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.RepMgrConnectionFailure">
            <summary>
            Display detailed information about Replication Manager connection
            failures. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.RepMgrMisc">
            <summary>
            Display detailed information about general Replication Manager
            processing. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.ReplicationElection">
            <summary>
            Display detailed information about replication elections.
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.ReplicationLease">
            <summary>
            Display detailed information about replication master leases. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.ReplicationMisc">
            <summary>
            Display detailed information about general replication processing
            not covered by the other Replication* values. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.ReplicationMessages">
            <summary>
            Display detailed information about replication message processing. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.ReplicationSync">
            <summary>
            Display detailed information about replication client
            synchronization. 
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.ReplicationTest">
            <summary>
            
            </summary>
        </member>
        <member name="F:BerkeleyDB.VerboseMessages.WaitsForTable">
            <summary>
            Display the waits-for table when doing deadlock detection.
            </summary>
        </member>
        <member name="T:BerkeleyDB.SecondaryCursor">
            <summary>
            A class representing database cursors over secondary indexes, which
            allow for traversal of database records.
            </summary>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.PGet(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32,BerkeleyDB.LockingInfo)">
            <summary>
            Protected method wrapping DBC->pget()
            </summary>
            <param name="key">The secondary key</param>
            <param name="pkey">The primary key</param>
            <param name="data">The primary data</param>
            <param name="flags">Flags to pass to DBC->pget</param>
            <param name="info">Locking parameters</param>
            <returns></returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Delete">
            <summary>
            Delete the key/data pair to which the cursor refers from the primary
            database and all secondary indices.
            </summary>
            <remarks>
            <para>
            The cursor position is unchanged after a delete, and subsequent
            calls to cursor functions expecting the cursor to refer to an
            existing key will fail.
            </para>
            </remarks>
            <exception cref="T:BerkeleyDB.KeyEmptyException">
            The element has already been deleted.
            </exception>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Duplicate(System.Boolean)">
            <summary>
            Create a new cursor that uses the same transaction and locker ID as
            the original cursor.
            </summary>
            <remarks>
            This is useful when an application is using locking and requires two
            or more cursors in the same thread of control.
            </remarks>
            <param name="keepPosition">
            If true, the newly created cursor is initialized to refer to the
            same position in the database as the original cursor (if any) and
            hold the same locks (if any). If false, or the original cursor does
            not hold a database position and locks, the created cursor is
            uninitialized and will behave like a cursor newly created by
            <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.</param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.GetEnumerator">
            <summary>
            Returns an enumerator that iterates through the
            <see cref="T:BerkeleyDB.SecondaryCursor"/>.
            </summary>
            <remarks>
            The enumerator will begin at the cursor's current position (or the
            first record if the cursor has not yet been positioned) and iterate 
            forwards (i.e. in the direction of <see cref="M:BerkeleyDB.SecondaryCursor.MoveNext"/>) over the
            remaining records.
            </remarks>
            <returns>An enumerator for the SecondaryCursor.</returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveFirst">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store the secondary key along with the corresponding primary
            key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the first key has
            duplicate values, the first data item in the set of duplicates is
            stored in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveFirst(BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the first key/data pair of the database, 
            and store the secondary key along with the corresponding primary
            key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the first key has
            duplicate values, the first data item in the set of duplicates is
            stored in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store the
            primary key/data pair associated with the given secondary key in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of duplicate key values, the
            first data item in the set of duplicates is stored in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to <paramref name="key"/>, and store the
            primary key/data pair associated with the given secondary key in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of duplicate key values, the
            first data item in the set of duplicates is stored in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="key">The key at which to position the cursor</param>
            <param name="exact">
            If true, require the given key to match the key in the database
            exactly.  If false, position the cursor at the smallest key greater
            than or equal to the specified key, permitting partial key matches
            and range searches.
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry}},System.Boolean)">
            <summary>
            Move the cursor to the specified key/data pair of the database. The
            cursor is positioned to a key/data pair if both the key and data
            match the values provided on the key and data parameters. 
            </summary>
            <remarks>
            <para>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </para>
            <para>
            If this flag is specified on a database configured without sorted
            duplicate support, the value of <paramref name="exact"/> is ignored.
            </para>
            </remarks>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry}},System.Boolean,BerkeleyDB.LockingInfo)">
            <summary>
            Move the cursor to the specified key/data pair of the database. The
            cursor is positioned to a key/data pair if both the key and data
            match the values provided on the key and data parameters. 
            </summary>
            <remarks>
            <para>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </para>
            <para>
            If this flag is specified on a database configured without sorted
            duplicate support, the value of <paramref name="exact"/> is ignored.
            </para>
            </remarks>
            <param name="pair">
            The key/data pair at which to position the cursor.
            </param>
            <param name="exact">
            If true, require the given key and data to match the key and data
            in the database exactly.  If false, position the cursor at the
            smallest data value which is greater than or equal to the value
            provided by <paramref name="pair.Value"/> (as determined by the
            comparison function).
            </param>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveLast">
            <summary>
            Set the cursor to refer to the last key/data pair of the database, 
            and store the secondary key and primary key/data pair in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the last key has duplicate values, the
            last data item in the set of duplicates is stored in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveLast(BerkeleyDB.LockingInfo)">
            <summary>
            Set the cursor to refer to the last key/data pair of the database, 
            and store the secondary key and primary key/data pair in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the last key has duplicate values, the
            last data item in the set of duplicates is stored in
            <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveNext">
            <summary>
            If the cursor is not yet initialized, MoveNext is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
            key/data pair of the database, and store the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of
            duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">Current.Key
            </see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveNext(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNext is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
            key/data pair of the database, and store the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of
            duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">Current.Key
            </see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveNextDuplicate">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store the secondary key and primary
            key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextDuplicate will
            return false if the next key/data pair of the database is not a
            duplicate data record for the current key/data pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveNextDuplicate(BerkeleyDB.LockingInfo)">
            <summary>
            If the next key/data pair of the database is a duplicate data record
            for the current key/data pair, move the cursor to the next key/data
            pair in the database, and store the secondary key and primary
            key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextDuplicate will
            return false if the next key/data pair of the database is not a
            duplicate data record for the current key/data pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveNextUnique">
            <summary>
            If the cursor is not yet initialized, MoveNextUnique is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
            non-duplicate key in the database, and store the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextUnique will
            return false if no non-duplicate key/data pairs exist after the
            cursor position in the database. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MoveNextUnique(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MoveNextUnique is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
            non-duplicate key in the database, and store the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextUnique will
            return false if no non-duplicate key/data pairs exist after the
            cursor position in the database. 
            </summary>
            <remarks>
            <para>
            If the database is a Queue or Recno database, MoveNextUnique will
            ignore any keys that exist but were never explicitly created by the
            application, or those that were created and later deleted.
            </para>
            <para>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </para>
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MovePrev">
            <summary>
            If the cursor is not yet initialized, MovePrev is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveLast"/>. Otherwise, move the cursor to the previous
            key/data pair of the database, and store the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of
            duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">Current.Key
            </see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MovePrev(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MovePrev is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
            the previous key/data pair of the database, and store the secondary
            key and primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the
            presence of duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">
            Current.Key</see> may not change. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MovePrevDuplicate">
            <summary>
            If the previous key/data pair of the database is a duplicate data
            record for the current key/data pair, the cursor is moved to the
            previous key/data pair of the database, and the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MovePrevDuplicate
            will return false if the previous key/data pair of the database is
            not a duplicate data record for the current key/data pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MovePrevDuplicate(BerkeleyDB.LockingInfo)">
            <summary>
            If the previous key/data pair of the database is a duplicate data
            record for the current key/data pair, the cursor is moved to the
            previous key/data pair of the database, and the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MovePrevDuplicate
            will return false if the previous key/data pair of the database is
            not a duplicate data record for the current key/data pair.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MovePrevUnique">
            <summary>
            If the cursor is not yet initialized, MovePrevUnique is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveLast"/>. Otherwise, move the cursor to the previous
            non-duplicate key in the database, and store the secondary key and
            primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MovePrevUnique will
            return false if no non-duplicate key/data pairs exist after the 
            cursor position in the database. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.MovePrevUnique(BerkeleyDB.LockingInfo)">
            <summary>
            If the cursor is not yet initialized, MovePrevUnique is identical to 
            <see cref="M:BerkeleyDB.SecondaryCursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
            the previous non-duplicate key in the database, and store the
            secondary key and primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            MovePrevUnique will return false if no non-duplicate key/data pairs
            exist after the cursor position in the database. 
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Refresh">
            <summary>
            Store the secondary key and primary key/data pair to which the
            cursor refers in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.SecondaryCursor.Refresh(BerkeleyDB.LockingInfo)">
            <summary>
            Store the secondary key and primary key/data pair to which the
            cursor refers in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
            </summary>
            <remarks>
            If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
            an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
            </remarks>
            <param name="info">The locking behavior to use.</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="P:BerkeleyDB.SecondaryCursor.Current">
            <summary>
            The secondary key and primary key/data pair at which the cursor
            currently points.
            </summary>
        </member>
        <member name="T:BerkeleyDB.RecnoStats">
            <summary>
            Statistical information about a RecnoDatabase
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.MagicNumber">
            <summary>
            Magic number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.Version">
            <summary>
            Version number. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.MetadataFlags">
            <summary>
            Metadata flags. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.nKeys">
            <summary>
            Number of unique keys. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.nData">
            <summary>
            Number of data items. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.nPages">
            <summary>
            Page count. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.PageSize">
            <summary>
            Page size. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.MinKey">
            <summary>
            Minkey value. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.RecordLength">
            <summary>
            Fixed-length record length. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.RecordPadByte">
            <summary>
            Fixed-length record pad. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.Levels">
            <summary>
            Tree levels. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.InternalPages">
            <summary>
            Internal pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.LeafPages">
            <summary>
            Leaf pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.DuplicatePages">
            <summary>
            Duplicate pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.OverflowPages">
            <summary>
            Overflow pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.EmptyPages">
            <summary>
            Empty pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.FreePages">
            <summary>
            Pages on the free list. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.InternalPagesFreeBytes">
            <summary>
            Bytes free in internal pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.LeafPagesFreeBytes">
            <summary>
            Bytes free in leaf pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.DuplicatePagesFreeBytes">
            <summary>
            Bytes free in duplicate pages. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoStats.OverflowPagesFreeBytes">
            <summary>
            Bytes free in overflow pages. 
            </summary>
        </member>
        <member name="T:BerkeleyDB.BTreeCursor">
            <summary>
            A class for traversing the records of a <see cref="T:BerkeleyDB.BTreeDatabase"/>
            </summary>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Duplicate(System.Boolean)">
            <summary>
            Create a new cursor that uses the same transaction and locker ID as
            the original cursor.
            </summary>
            <remarks>
            This is useful when an application is using locking and requires two
            or more cursors in the same thread of control.
            </remarks>
            <param name="keepPosition">
            If true, the newly created cursor is initialized to refer to the
            same position in the database as the original cursor (if any) and
            hold the same locks (if any). If false, or the original cursor does
            not hold a database position and locks, the created cursor is
            uninitialized and will behave like a cursor newly created by
            <see cref="M:BerkeleyDB.BTreeDatabase.Cursor"/>.</param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Move(System.UInt32)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Move(System.UInt32,BerkeleyDB.LockingInfo)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="info">The locking behavior to use</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many duplicate data items that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32,System.Int32)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many duplicate data items that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32,BerkeleyDB.LockingInfo)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many duplicate data items that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="info">The locking behavior to use</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32,System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many duplicate data items that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with duplicate data items.  Must be at
            least the page size of the underlying database and be a multiple of
            1024.
            </param>
            <param name="info">The locking behavior to use</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32,System.Int32)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32,BerkeleyDB.LockingInfo)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="info">The locking behavior to use</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32,System.Int32,BerkeleyDB.LockingInfo)">
            <summary>
            Position the cursor at a specific key/data pair in the database, and
            store the key/data pair and as many ensuing key/data pairs that can
            fit in a buffer the size of one database page in
            <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
            </summary>
            <param name="recno">
            The specific numbered record of the database at which to position
            the cursor.
            </param>
            <param name="BufferSize">
            The size of a buffer to fill with key/data pairs.  Must be at least
            the page size of the underlying database and be a multiple of 1024.
            </param>
            <param name="info">The locking behavior to use</param>
            <returns>
            True if the cursor was positioned successfully, false otherwise.
            </returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Recno">
            <summary>
            Return the record number associated with the cursor's current
            position.
            </summary>
            <returns>The record number associated with the cursor.</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Recno(BerkeleyDB.LockingInfo)">
            <summary>
            Return the record number associated with the cursor's current
            position.
            </summary>
            <param name="info">The locking behavior to use</param>
            <returns>The record number associated with the cursor.</returns>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Insert the data element as a duplicate element of the key to which
            the cursor refers.
            </summary>
            <param name="data">The data element to insert</param>
            <param name="loc">
            Specify whether to insert the data item immediately before or
            immediately after the cursor's current position.
            </param>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.AddUnique(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
            <summary>
            Insert the specified key/data pair into the database, unless a
            key/data pair comparing equally to it already exists in the
            database.
            </summary>
            <param name="pair">The key/data pair to be inserted</param>
            <exception cref="T:BerkeleyDB.KeyExistException">
            Thrown if a matching key/data pair already exists in the database.
            </exception>
        </member>
        <member name="M:BerkeleyDB.BTreeCursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},BerkeleyDB.Cursor.InsertLocation)">
            <summary>
            Insert the specified key/data pair into the database.
            </summary>
            <param name="pair">The key/data pair to be inserted</param>
            <param name="loc">
            If the key already exists in the database and no duplicate sort
            function has been specified, specify whether the inserted data item
            is added as the first or the last of the data items for that key. 
            </param>
        </member>
        <member name="T:BerkeleyDB.RecnoDatabase">
            <summary>
            A class representing a RecnoDatabase. The Recno format supports fixed-
            or variable-length records, accessed sequentially or by logical record
            number, and optionally backed by a flat text file. 
            </summary>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)">
            <summary>
            Instantiate a new RecnoDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Open(System.String,System.String,BerkeleyDB.RecnoDatabaseConfig)">
            <summary>
            Instantiate a new RecnoDatabase object and open the database
            represented by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
            will be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new RecnoDatabase object and open the database
            represented by <paramref name="Filename"/>.
            </summary>
            <remarks>
            <para>
            If <paramref name="Filename"/> is null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database
            object that created it, in circumstances where doing so is safe.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Open(System.String,System.String,BerkeleyDB.RecnoDatabaseConfig,BerkeleyDB.Transaction)">
            <summary>
            Instantiate a new RecnoDatabase object and open the database
            represented by <paramref name="Filename"/> and
            <paramref name="DatabaseName"/>.
            </summary>
            <remarks>
            <para>
            If both <paramref name="Filename"/> and
            <paramref name="DatabaseName"/> are null, the database is strictly
            temporary and cannot be opened by any other thread of control, thus
            the database can only be accessed by sharing the single database 
            object that created it, in circumstances where doing so is safe. If
            <paramref name="Filename"/> is null and
            <paramref name="DatabaseName"/> is non-null, the database can be
            opened by other threads of control and will be replicated to client
            sites in any replication group.
            </para>
            <para>
            If <paramref name="txn"/> is null, but
            <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
            be implicitly transaction protected. Note that transactionally
            protected operations on a datbase object requires the object itself
            be transactionally protected during its open. Also note that the
            transaction must be committed before the object is closed.
            </para>
            </remarks>
            <param name="Filename">
            The name of an underlying file that will be used to back the
            database. In-memory databases never intended to be preserved on disk
            may be created by setting this parameter to null.
            </param>
            <param name="DatabaseName">
            This parameter allows applications to have multiple databases in a
            single file. Although no DatabaseName needs to be specified, it is
            an error to attempt to open a second database in a file that was not
            initially created using a database name.
            </param>
            <param name="cfg">The database's configuration</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>A new, open database object</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)">
            <summary>
            Append the data item to the end of the database.
            </summary>
            <param name="data">The data item to store in the database</param>
            <returns>The record number allocated to the record</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
            <summary>
            Append the data item to the end of the database.
            </summary>
            <remarks>
            There is a minor behavioral difference between
            <see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> and
            <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>. If a transaction enclosing an
            Append operation aborts, the record number may be reallocated in a
            subsequent <see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation, but it will
            not be reallocated in a subsequent
            <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation.
            </remarks>
            <param name="data">The data item to store in the database</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>The record number allocated to the record</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig)">
            <summary>
            Compact the database, and optionally return unused database pages to
            the underlying filesystem. 
            </summary>
            <remarks>
            If the operation occurs in a transactional database, the operation
            will be implicitly transaction protected using multiple
            transactions. These transactions will be periodically committed to
            avoid locking large sections of the tree. Any deadlocks encountered
            cause the compaction operation to be retried from the point of the
            last transaction commit.
            </remarks>
            <param name="cdata">Compact configuration parameters</param>
            <returns>Compact operation statistics</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig,BerkeleyDB.Transaction)">
            <summary>
            Compact the database, and optionally return unused database pages to
            the underlying filesystem. 
            </summary>
            <remarks>
            <para>
            If <paramref name="txn"/> is non-null, then the operation is
            performed using that transaction. In this event, large sections of
            the tree may be locked during the course of the transaction.
            </para>
            <para>
            If <paramref name="txn"/> is null, but the operation occurs in a
            transactional database, the operation will be implicitly transaction
            protected using multiple transactions. These transactions will be
            periodically committed to avoid locking large sections of the tree.
            Any deadlocks encountered cause the compaction operation to be
            retried from the point of the last transaction commit.
            </para>
            </remarks>
            <param name="cdata">Compact configuration parameters</param>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>Compact operation statistics</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Cursor">
            <summary>
            Create a database cursor.
            </summary>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Cursor(BerkeleyDB.CursorConfig)">
            <summary>
            Create a database cursor with the given configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Cursor(BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor.
            </summary>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Cursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
            <summary>
            Create a transactionally protected database cursor with the given
            configuration.
            </summary>
            <param name="cfg">
            The configuration properties for the cursor.
            </param>
            <param name="txn">
            The transaction context in which the cursor may be used.
            </param>
            <returns>A newly created cursor</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.FastStats">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.FastStats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.FastStats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information which does not require
            traversal of the database.
            </summary>
            <overloads>
            <para>
            Among other things, this method makes it possible for applications
            to request key and record counts without incurring the performance
            penalty of traversing the entire database. 
            </para>
            <para>
            The statistical information is described by the
            <see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
            <see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes. 
            </para>
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>
            The database statistical information which does not require
            traversal of the database.
            </returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Stats">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Stats(BerkeleyDB.Transaction)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.Stats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
            <summary>
            Return the database statistical information for this database.
            </summary>
            <overloads>
            The statistical information is described by
            <see cref="T:BerkeleyDB.BTreeStats"/>. 
            </overloads>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <param name="isoDegree">
            The level of isolation for database reads.
            <see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for 
            databases which did not specify
            <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
            </param>
            <returns>Database statistical information.</returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.TruncateUnusedPages">
            <summary>
            Return pages to the filesystem that are already free and at the end
            of the file.
            </summary>
            <returns>
            The number of database pages returned to the filesystem
            </returns>
        </member>
        <member name="M:BerkeleyDB.RecnoDatabase.TruncateUnusedPages(BerkeleyDB.Transaction)">
            <summary>
            Return pages to the filesystem that are already free and at the end
            of the file.
            </summary>
            <param name="txn">
            If the operation is part of an application-specified transaction,
            <paramref name="txn"/> is a Transaction object returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
            the operation is part of a Berkeley DB Concurrent Data Store group,
            <paramref name="txn"/> is a handle returned from
            <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
            </param>
            <returns>
            The number of database pages returned to the filesystem
            </returns>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.AppendCallback">
            <summary>
            A function to call after the record number has been selected but
            before the data has been stored into the database.
            </summary>
            <remarks>
            <para>
            When using <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>, it may be useful to
            modify the stored data based on the generated key. If a delegate is
            specified, it will be called after the record number has been
            selected, but before the data has been stored.
            </para>
            </remarks>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.RecordDelimiter">
            <summary>
            The delimiting byte used to mark the end of a record in
            <see cref="P:BerkeleyDB.RecnoDatabase.SourceFile"/>.
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.RecordLength">
            <summary>
            If using fixed-length, not byte-delimited records, the length of the
            records. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.RecordPad">
            <summary>
            The padding character for short, fixed-length records.
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.Renumber">
            <summary>
            If true, the logical record numbers are mutable, and change as
            records are added to and deleted from the database.
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.Snapshot">
            <summary>
            If true, any <see cref="P:BerkeleyDB.RecnoDatabase.SourceFile"/> file will be read in its
            entirety when <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is called. If false,
            <see cref="P:BerkeleyDB.RecnoDatabase.SourceFile"/> may be read lazily. 
            </summary>
        </member>
        <member name="P:BerkeleyDB.RecnoDatabase.SourceFile">
            <summary>
            The underlying source file for the Recno access method.
            </summary>
        </member>
        <member name="T:BerkeleyDB.LockingInfo">
            <summary>
            A class representing the locking options for Berkeley DB operations.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LockingInfo.IsolationDegree">
            <summary>
            The isolation degree of the operation.
            </summary>
        </member>
        <member name="F:BerkeleyDB.LockingInfo.ReadModifyWrite">
            <summary>
            If true, acquire write locks instead of read locks when doing a
            read, if locking is configured.
            </summary>
            <remarks>
            Setting ReadModifyWrite can eliminate deadlock during a
            read-modify-write cycle by acquiring the write lock during the read
            part of the cycle so that another thread of control acquiring a read
            lock for the same item, in its own read-modify-write cycle, will not
            result in deadlock.
            </remarks>
        </member>
        <member name="M:BerkeleyDB.LockingInfo.#ctor">
            <summary>
            Instantiate a new LockingInfo object
            </summary>
        </member>
        <member name="T:BerkeleyDB.RepMgrSite">
            <summary>
            A class representing a replication site used by Replication Manager
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepMgrSite.EId">
            <summary>
            Environment ID assigned by the replication manager. This is the same
            value that is passed to
            <see cref="P:BerkeleyDB.DatabaseEnvironment.EventNotify"/> for the
            <see cref="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER"/> event.
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepMgrSite.Address">
            <summary>
            The address of the site
            </summary>
        </member>
        <member name="F:BerkeleyDB.RepMgrSite.isConnected">
            <summary>
            If true, the site is connected.
            </summary>
        </member>
    </members>
</doc>
