CleanArchitecture/CleanArchitecture/CleanArchitecture.Data/Repositories/UnitOfWork.cs

using CleanArchitecture.Application.Contracts.Persistence;
using CleanArchitecture.Domain.Common;
using CleanArchitecture.Infrastructure.Persistence;
using System.Collections;

namespace CleanArchitecture.Infrastructure.Repositories
{
    public class UnitOfWork : IUnitOfWork
    {
        private Hashtable repositories;
        private readonly StreamerDbContext context;

        private IVideoRepository videoRepository;
        private IStreamerRepository streamerRepository;


        public IVideoRepository VideoRepository => videoRepository ?? new VideoRepository(context);
        public IStreamerRepository StreamerRepository => streamerRepository ?? new StreamerRepository(context);

        public UnitOfWork(StreamerDbContext _context)
        {
            context = _context;
        }

        public  StreamerDbContext StreamerDbContext => context;

        public async Task<int> Complete()
        {
            return await context.SaveChangesAsync();
        }

        public void Dispose()
        {
            context.Dispose();
        }

        public IAsyncRepository<T> Repository<T>() where T : BaseDomainModel
        {
            if (repositories == null)
            {
                repositories = new Hashtable();
            }
            var type = typeof(T).Name;
            if (!repositories.ContainsKey(type))
            {
                var repositoryType = typeof(RepositoryBase<>);
                var repositoryInstance = Activator.CreateInstance(repositoryType.MakeGenericType(typeof(T)), context);
                repositories.Add(type, repositoryInstance);
            }

            return (IAsyncRepository<T>)repositories[type];

        }
    }
}