ExecuteReaderAsync和Autofac

Question

I have created an OracleUnitOfWork and Repository class like this:

public class OracleUnitOfWork : IOracleUnitOfWork
{
    // Private properties
    private readonly OracleConnection _connection;
    private readonly OracleCommand _command;
    private readonly Dictionary<Type, object> _repositories;
    private Object thisLock = new Object();

    /// <summary>
    /// Default constructor
    /// </summary>
    /// <param name="config">The Cormar config class</param>
    public OracleUnitOfWork(CormarConfig config)
    {

        // Create instances for our private properties
        this._repositories = new Dictionary<Type, object>();
        this._connection = new OracleConnection(config.ConnectionString);
        this._command = new OracleCommand
        {
            Connection = this._connection,
            CommandType = CommandType.StoredProcedure,
            BindByName = true
        };

        // Open our connection
        this._connection.Open();
    }

    /// <summary>
    /// Gets the entity repository
    /// </summary>
    /// <typeparam name="T">The entity model</typeparam>
    /// <returns></returns>
    public IRepository<T> GetRepository<T>() where T : class, new()
    {

        // Lock the thread so we can't execute at the same time
        lock (thisLock)
        {

            // If our repositories have a matching repository, return it
            if (_repositories.Keys.Contains(typeof(T)))
                return _repositories[typeof(T)] as IRepository<T>;

            // Create a new repository for our entity
            var repository = new Repository<T>(this._command);

            // Add to our list of repositories
            _repositories.Add(typeof(T), repository);

            // Return our repository
            return repository;
        }
    }

    /// <summary>
    /// Dispose
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    /// <summary>
    /// Disposes of any attached resources
    /// </summary>
    /// <param name="disposing">A boolean indicating whether the object is being disposed</param>
    protected virtual void Dispose(bool disposing)
    {

        // If we are disposing
        if (disposing)
        {

            // Close our connection
            this._connection.Close();
            this._connection.Dispose();
            this._command.Dispose();
        }
    }
}

public class Repository<T> : IRepository<T> where T : class, new()
{
    // private properties
    private readonly OracleCommand _command;
    private Object thisLock = new Object();

    /// <summary>
    /// Default constructor
    /// </summary>
    /// <param name="command"></param>
    public Repository(OracleCommand command)
    {
        this._command = command;
    }

    /// <summary>
    /// Returns the datareader for the stored procedure
    /// </summary>
    /// <param name="storedProcedureName">The name of the SPROC to execute</param>
    /// <param name="parameters">The parameters needed for the SPROC</param>
    /// <returns></returns>
    public async Task<IDataReader> ExecuteReaderAsync(string storedProcedureName, IList<OracleParameter> parameters = null)
    {

        // Set up our command
        this.InitiateCommand(storedProcedureName, parameters.ToArray());

        // Return our data reader
        return await this._command.ExecuteReaderAsync();            
    }

    /// <summary>
    /// Create, updates or deletes an entity
    /// </summary>
    /// <param name="storedProcedureName">The name of the SPROC to execute</param>
    /// <param name="parameters">The parameters needed for the SPROC</param>
    public async Task CreateUpdateOrDeleteAsync(string storedProcedureName, IList<OracleParameter> parameters = null)
    {

        // Set up our command
        this.InitiateCommand(storedProcedureName, parameters.ToArray());

        // Execute our command
        await this._command.ExecuteNonQueryAsync();
    }

    /// <summary>
    /// Intiates the command object
    /// </summary>
    /// <param name="storedProcedureName">The name of the SPROC to execute</param>
    /// <param name="parameters">An array of parameters</param>
    private void InitiateCommand(string storedProcedureName, OracleParameter[] parameters)
    {

        // Lock the thread so we can't execute at the same time
        lock (thisLock)
        {

            // Set up the command object
            this._command.CommandTimeout = 1800;
            this._command.FetchSize = 1000;
            this._command.CommandText = storedProcedureName;
            this._command.Parameters.Clear();

            // If we have any parameters
            if (parameters != null)
            {

                // Assign each parameter to the command object
                this._command.Parameters.AddRange(parameters);
            }
        }
    }
}

In my AutoFac module, I register the OracleUnitOfWork as a single instance like this:

builder.RegisterType<OracleUnitOfWork>().As<IOracleUnitOfWork>().SingleInstance();

For most queries, this is fine, but I seem to have a problem when trying to execute multiple queries simultaneously. It errors out on the ExecuteReaderAsync method in my repository and states:

Object reference not set to an instance of an object.

Sometimes I even get this error:

Index was out of range. Must be non-negative and less than the size of the collection. Parameter name: index

But I can't figure out how to fix the issue. Prior to this I was getting issues with the GetRepository method, but when I added locking that fixed the issue. I can't do that to ExecuteReaderAsync method because it will no longer be asynchronous and I need it to be.

Does anyone know how to solve this issue?

Answer 1

For most queries, this is fine, but I seem to have a problem when trying to execute multiple queries simultaneously.

You have a race condition, you're trying to access the same references across multiple threads and getting "spooky" behaviour.

You can't pass a mutable singleton across multiple threads like that, it will break. Either bite the bullet and use aa _lock or rethink your approach (ie Don't use a singleton).

Just remember, locks will kill your multi-threaded performance if not used correctly.

Answer 2

Kushan is right about OracleConnection not being thread safe. If you really need to execute multiple queries in the same time and you are not affected by the overhead, you can remove SingleInstance() and allow multiple instances to be built.

This way, each of your threads can obtain a new instance of OracleUnitOfWork and do its work independently (fetch data, perform changes, persist changes).