// @nuget: Microsoft.EntityFrameworkCore

// @nuget: Microsoft.EntityFrameworkCore.SqlServer

using Microsoft.EntityFrameworkCore;

using Microsoft.EntityFrameworkCore.Metadata.Builders;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Threading.Tasks;

​

namespace EFCoreDemo

{

    public class ServiceOptions

    {

        // map this one to the corresponding 'AppSettings.json' field

        public string ConnectionString

        {

            get;

            set;

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            // var options = new DbContextOptionsBuilder<CommandDbContext>().UseSqlServer(FiddleHelper.GetConnectionStringSqlServerW3Schools()).Options;

            var options = new ServiceOptions{ConnectionString = "Let's pretend that we have one"};

            using var context = new CommandDbContext(options);

        }

    }

​

    public interface IUnitOfWork

    {

        IRepository<Customer> CustomerRepository

        {

            get;

        }

​

        int SaveChanges();

    }

​

    public class Customer : BaseEntity<Guid>

    {

        public string CustomerName

        {

            get;

            set;

        }

​

        public string City

        {

            get;

            set;

        }

    }

​

    public class CommandDbContext : DbContext

    {

        private readonly ServiceOptions _serviceOptions;

        public virtual DbSet<Customer> Customers

        {

            get;

            set;

        }

​

        public CommandDbContext(ServiceOptions serviceOptions)

        {

            _serviceOptions = serviceOptions;

        }

​

        public CommandDbContext(DbContextOptions<CommandDbContext> options, ServiceOptions serviceOptions): base(options)

        {

            _serviceOptions = serviceOptions;

        }

​

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

        {

            if (!optionsBuilder.IsConfigured)

            {

                optionsBuilder.UseSqlServer(_serviceOptions.ConnectionString);

            }

        }

​

        protected override void OnModelCreating(ModelBuilder modelBuilder)

        {

            modelBuilder.HasAnnotation("ProductVersion", "2.2.4-servicing-10062");

        // modelBuilder.ApplyConfiguration(new CustomerEntityTypeConfiguration());

        }

    }

​

    // public class CustomerEntityTypeConfiguration : IEntityTypeConfiguration<Customer>

    // {

    //   public void Configure(EntityTypeBuilder<Domain.Model.TruckBooking> builder)

    //    {

    //        builder.ToTable("Customer");

    //

    //        ConfigureProperties(builder);

    //

    //        ConfigureForeignKeys(builder);

    //    }

    //    private void ConfigureProperties(EntityTypeBuilder<Customer> builder)

    //    private void ConfigureForeignKeys(EntityTypeBuilder<Domain.Model.TruckBooking> builder)

    //  }

    public interface IRepository<TEntity, TId> : IQueryable<TEntity> where TEntity : class, IEntity<TId> where TId : IEquatable<TId>

    {

        Task<TEntity> GetByIdAsync(TId id);

        TEntity GetById(TId id);

        Task<List<TEntity>> FindAllAsync();

        Task<List<TEntity>> FindAllAsync(Expression<Func<TEntity, bool>> predicate);

        List<TEntity> FindAll();

        List<TEntity> FindAll(Expression<Func<TEntity, bool>> predicate);

        void Update(TEntity entity);

        TEntity Add(TEntity entity);

        void AddRange(IEnumerable<TEntity> entities);

        TEntity Remove(TEntity entity);

        void RemoveRange(Expression<Func<TEntity, bool>> predicate);

        void RemoveRange(IEnumerable<TEntity> entities);

        Task RemoveRangeAsync(Expression<Func<TEntity, bool>> predicate);

        Task RemoveRangeAsync(IEnumerable<TEntity> entities);

        int SaveChanges();

        Task<int> SaveChangeAsync();

        ITransaction BeginTransaction();

        void RejectChange(TEntity entity, bool reload = false);

        void RejectChanges(bool reload = false);

        Task RejectChangeAsync(TEntity entity, bool reload = false);

        Task RejectChangesAsync(bool reload = false);

    }

​

    public interface IRepository<TEntity> : IRepository<TEntity, Guid> where TEntity : class, IEntity<Guid>

    {

    }

​

    public interface IEntity

    {

    }

​

    public interface IEntity<TId> : IEntity

    {

        TId Id

        {

            get;

            set;

        }

    }

​

    public interface ITransaction : IDisposable

    {

        void Commit();

        void Rollback();

    }

​

    public abstract class BaseEntity<TId> : IEntity<TId>

    {

        public virtual TId Id

        {

            get;

            set;

        }

​

        public override bool Equals(object obj)

        {

            return obj is BaseEntity<TId> baseEntity && baseEntity.GetType() == GetType() && Equals(baseEntity.Id, Id);

        }

​

        public override int GetHashCode()

        {

            return new MultiKey(GetType(), Id).GetHashCode();

        }

    }

​

    public abstract class BaseEntity : BaseEntity<Guid>

    {

    }

​

    public class MultiKey

    {

        private readonly List<object> _parts;

        public MultiKey(params object[] parts)

        {

            _parts = new List<object>(parts);

        }

​

        public override int GetHashCode()

        {

            var hash = 0;

            if (_parts.Count > 0)

            {

                unchecked

                {

                    hash = 17;

                    _parts.Where(p => null != p).ToList().ForEach(p =>

                    {

                        hash = hash * 31 + p.GetHashCode();

                    });

                }

            }

​

            return hash;

        }

​

        public override bool Equals(object obj)

        {

            if (null != obj && obj is MultiKey key)

            {

                if (key._parts.Count != _parts.Count)

                {

                    return false;

                }

​

                for (var i = 0; i < _parts.Count; i++)

                {

                    if (!Equals(_parts[i], key._parts[i]))

                    {

                        return false;

                    }

                }

​

                return true;

            }

​

            return false;

        }

    }

}