using System;

using System.Collections.Generic;

using System.ComponentModel.DataAnnotations;

using System.ComponentModel.DataAnnotations.Schema;

using System.Linq;

using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.Configuration;

using Microsoft.Extensions.DependencyInjection;

using Xunit;

​

namespace Playground

{

    public abstract class Model

    {

        [Key]

        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]

        public int Id { get; set; }

​

        [NotMapped]

        public CustomDbContext _ctx { get; set; }

    }

​

    public class Post : Model

    {

        public Post()

        {

            _map = new HashSet<PostTag>();

        }

​

        protected virtual ICollection<PostTag> _map { get; set; }

        public virtual ICollection<Foo> foos { get; set; }

​

        public void Check(bool flag)

        {

            if (flag)

            {

                Assert.NotEmpty(_map);

            }

            else

            {

                Assert.Empty(_map);

            }

        }

​

        public static Post Load(CustomDbContext ctx)

        {

            return ctx.posts.Include(p => p._map).Include(p => p.foos).First();

        }

​

        public void Add(PostTag postTag)

        {

            _map.Add(postTag);

        }

    }

​

    public class Foo : Model

    {

    }

    public class PostTag : Model

    {

        public virtual Post post { get; set; }

        public virtual Tag tag { get; set; }

    }

​

    public class Tag : Model

    {

        public Tag()

        {

            _map = new HashSet<PostTag>();

        }

​

        protected virtual ICollection<PostTag> _map { get; set; }

    }

​

    public class CustomDbContext : DbContext

    {

        public CustomDbContext(DbContextOptions options)

            : base(options)

        {

        }

​

        protected override void OnModelCreating(ModelBuilder modelBuilder)

        {

            modelBuilder.Entity<Post>().HasMany(typeof(PostTag), "_map").WithOne();

            modelBuilder.Entity<Tag>().HasMany(typeof(PostTag), "_map").WithOne();

        }

​

        public DbSet<Post> posts { get; set; }

        public DbSet<Tag> tags { get; set; }

    }

​

    public class Spec

    {

        protected IServiceProvider _serviceProvider;

​

        [Fact]

        public void test()

        {

            using (var ctx = new CustomDbContext(GetDbContextOptions()))

            {

                Assert.Equal(4, ctx.Model.GetEntityTypes().Count());

​

                ctx.posts.AddRange(new List<Post>() {new Post(), new Post(), new Post(), new Post()});

​

                ctx.tags.AddRange(new List<Tag>() {new Tag(), new Tag(), new Tag()});

                ctx.SaveChanges();

                Assert.Equal(4, ctx.posts.Count());

                Assert.Equal(3, ctx.tags.Count());

                foreach (var tag in ctx.tags)

                {

                    foreach (var post in ctx.posts)

                    {

                        PostTag p = new PostTag {post = post, tag = tag};

                        post.Add(p);

                        ctx.posts.Update(post);

                    }

                }

​

                ctx.SaveChanges();

​

                var firstPost = ctx.posts.First();

                if (firstPost.foos == null)

                {

                    firstPost.foos = new List<Foo>();

                }

                firstPost.foos.Add(new Foo());

                ctx.Update(firstPost);

                ctx.SaveChanges();

            }

​

            using (var newCtx = new CustomDbContext(GetDbContextOptions()))

            {

                var loadedPost = newCtx.posts.First();

                Assert.NotNull(loadedPost);

                //since we don't use include we check there is no navigation properties

                Assert.Empty(loadedPost.foos);

                loadedPost.Check(false);

​

                var loadedPostWithInclude = Post.Load(newCtx);

                Assert.NotNull(loadedPostWithInclude);

                Assert.NotEmpty(loadedPostWithInclude.foos);

                loadedPostWithInclude.Check(true);

            }

        }

​

        private static DbContextOptions<CustomDbContext> GetDbContextOptions()

        {

            return new DbContextOptionsBuilder<CustomDbContext>().UseInMemoryDatabase("Scratch")

                .UseInternalServiceProvider(new ServiceCollection()

                    .AddEntityFrameworkInMemoryDatabase()

                    .BuildServiceProvider()).Options;

        }

​

    }

}