コード例 #1
0
        private static async Task EnsureDeleted_will_delete_database_test(bool async)
        {
            using (var testDatabase = await SqlServerTestDatabase.Scratch(createDatabase: true))
            {
                testDatabase.Connection.Close();

                using (var context = new BloggingContext(testDatabase))
                {
                    Assert.True(async ? await context.Database.AsRelational().ExistsAsync() : context.Database.AsRelational().Exists());

                    if (async)
                    {
                        Assert.True(await context.Database.EnsureDeletedAsync());
                    }
                    else
                    {
                        Assert.True(context.Database.EnsureDeleted());
                    }

                    Assert.Equal(ConnectionState.Closed, context.Database.AsRelational().Connection.DbConnection.State);

                    Assert.False(async ? await context.Database.AsRelational().ExistsAsync() : context.Database.AsRelational().Exists());

                    Assert.Equal(ConnectionState.Closed, context.Database.AsRelational().Connection.DbConnection.State);
                }
            }
        }
コード例 #2
0
        public async Task SaveChanges_logs_DataStoreErrorLogState(bool async)
        {
            var loggerFactory = new TestLoggerFactory();
            var serviceProvider = new ServiceCollection()
                .AddEntityFramework()
                .AddInMemoryStore()
                .ServiceCollection()
                .AddInstance<ILoggerFactory>(loggerFactory)
                .BuildServiceProvider();

            using (var context = new BloggingContext(serviceProvider))
            {
                context.Blogs.Add(new BloggingContext.Blog(jimSaysThrow: false) { Url = "http://sample.com" });
                context.SaveChanges();
                context.ChangeTracker.Entries().Single().State = EntityState.Added;

                Exception ex;
                if (async)
                {
                    ex = await Assert.ThrowsAsync<ArgumentException>(() => context.SaveChangesAsync());
                }
                else
                {
                    ex = Assert.Throws<ArgumentException>(() => context.SaveChanges());
                }

                Assert.Same(ex, loggerFactory.Logger.LastDataStoreErrorException);
                Assert.Same(typeof(BloggingContext), loggerFactory.Logger.LastDataStoreErrorState.ContextType);
                Assert.EndsWith(ex.ToString(), loggerFactory.Logger.LastDataStoreErrorFormatter(loggerFactory.Logger.LastDataStoreErrorState, ex));
            }
        }
コード例 #3
0
ファイル: DefaultModel.cs プロジェクト: TOByrne/TGOByrne
        protected DefaultModel(string blogusername = null)
        {
            _IUser = HttpContext.Current.User;

            //	The user that we're looking at.
            string viewUser;

            if (_IUser.Identity.IsAuthenticated)
            {
                viewUser = _IUser.Identity.Name;
            }
            else if (blogusername != null)
            {
                viewUser = blogusername;
            }
            else
            {
                viewUser = "******";
            }

            using (var db = new BloggingContext())
            {
                User = (from u in db.Users
                        where u.Username == viewUser || u.FirstName == viewUser
                        select u).FirstOrDefault();

                Sections = (from p in User.Posts
                            select p.Section)
                            .Distinct()
                            .ToList();
            }

            HttpContext.Current.Items["User"] = User;
        }
コード例 #4
0
ファイル: SiteAdminModel.cs プロジェクト: TOByrne/TGOByrne
        public bool AddSiteUpdate(string headline, string importance)
        {
            using (var db = new BloggingContext())
            {
                try
                {
                    var user = (from u in db.Users
                        where u.Username == this.User.Identity.Name
                        select u)
                        .FirstOrDefault();
                    ;

                    var update = new SiteUpdate()
                    {
                        User = user,
                        Headline = headline,
                        Importance = importance,
                        Timestamp = DateTime.Now
                    };

                    db.SiteUpdates.Add(update);
                    db.SaveChanges();
                }
                catch
                {
                    return false;
                }
            }

            return true;
        }
コード例 #5
0
 public void TestGetAllowedEntityTypes()
 {
     var ctx = new BloggingContext("Blogging");
     var allowedTypes = DbContextExtensions.DbContextExtensions.GetAllowedEntityTypes<BloggingContext>(ctx);
     Assert.IsNotNull(allowedTypes);
     Assert.IsTrue(allowedTypes.Count > 0);
 }
コード例 #6
0
ファイル: SqlController.cs プロジェクト: rnmisrahi/JB
 // GET: Sql
 public ActionResult Index()
 {
     using (var context = new BloggingContext())
     {
         var blogs = context.Blogs.SqlQuery("SELECT * FROM dbo.Blogs").ToList();
     }
     return View();
 }
コード例 #7
0
 protected override void SetUp()
 {
     base.SetUp();
     using (var context = new BloggingContext(ConnectionStringEF))
     {
         context.Blogs.RemoveRange(context.Blogs);
         context.Posts.RemoveRange(context.Posts);
         context.SaveChanges();
     }
 }
コード例 #8
0
        public static void Run()
        {
            using (var context = new BloggingContext())
            {
                var blogs = context.Blogs
                    .FromSql("SELECT * FROM dbo.Blogs")
                    .ToList();
            }

            using (var context = new BloggingContext())
            {
                var blogs = context.Blogs
                    .FromSql("EXECUTE dbo.GetMostPopularBlogs")
                    .ToList();
            }

            using (var context = new BloggingContext())
            {
                var user = "******";

                var blogs = context.Blogs
                    .FromSql("EXECUTE dbo.GetMostPopularBlogsForUser {0}", user)
                    .ToList();
            }

            using (var context = new BloggingContext())
            {
                var user = new SqlParameter("user", "johndoe");

                var blogs = context.Blogs
                    .FromSql("EXECUTE dbo.GetMostPopularBlogsForUser @user", user)
                    .ToList();
            }

            using (var context = new BloggingContext())
            {
                var searchTerm = ".NET";

                var blogs = context.Blogs
                    .FromSql("SELECT * FROM dbo.SearchBlogs {0}", searchTerm)
                    .Where(b => b.Rating > 3)
                    .OrderByDescending(b => b.Rating)
                    .ToList();
            }

            using (var context = new BloggingContext())
            {
                var searchTerm = ".NET";

                var blogs = context.Blogs
                    .FromSql("SELECT * FROM dbo.SearchBlogs {0}", searchTerm)
                    .Include(b => b.Posts)
                    .ToList();
            }
        }
コード例 #9
0
        public void Inserts_and_updates_are_batched_correctly()
        {
            var optionsBuilder = new DbContextOptionsBuilder();
            optionsBuilder.UseSqlServer(_testStore.Connection);

            var expectedBlogs = new List<Blog>();
            using (var context = new BloggingContext(_serviceProvider, optionsBuilder.Options))
            {
                context.Database.EnsureCreated();
                var owner1 = new Owner {Name = "0"};
                var owner2 = new Owner {Name = "1" };
                context.Owners.Add(owner1);
                context.Owners.Add(owner2);

                var blog1 = new Blog
                {
                    Id = Guid.NewGuid(),
                    Owner = owner1,
                    Order = 1
                };

                context.Blogs.Add(blog1);
                expectedBlogs.Add(blog1);

                context.SaveChanges();

                owner2.Name = "2";

                blog1.Order = 0;
                var blog2 = new Blog
                {
                    Id = Guid.NewGuid(),
                    Owner = owner1,
                    Order = 1
                };

                context.Blogs.Add(blog2);
                expectedBlogs.Add(blog2);

                var blog3 = new Blog
                {
                    Id = Guid.NewGuid(),
                    Owner = owner2,
                    Order = 2
                };

                context.Blogs.Add(blog3);
                expectedBlogs.Add(blog3);

                context.SaveChanges();
            }

            AssertDatabaseState(true, expectedBlogs, optionsBuilder);
        }
コード例 #10
0
ファイル: AdminCenterModel.cs プロジェクト: TOByrne/TGOByrne
 //public List<Tags> Tags { get; protected set; }
 //public List<Blog> Blogs { get; protected set; }
 //public List<Album> Albums { get; protected set; }
 //public List<Comment> Comments { get; protected set; }
 //public List<Picture> Pictures { get; protected set; }
 //public List<Post> Posts { get; protected set; }
 public AdminCenterModel(BloggingContext context = null)
     : base("tgobyrne")
 {
     if (context != null)
     {
         Context = context;
     }
     else
     {
         Context = new BloggingContext();
     }
 }
コード例 #11
0
        private static async Task Exists_returns_true_when_database_exists_test(bool async)
        {
            using (var testDatabase = await SqlServerTestStore.CreateScratchAsync(createDatabase: true))
            {
                using (var context = new BloggingContext(testDatabase))
                {
                    Assert.True(async ? await context.Database.AsRelational().ExistsAsync() : context.Database.AsRelational().Exists());

                    Assert.Equal(ConnectionState.Closed, context.Database.AsRelational().Connection.DbConnection.State);
                }
            }
        }
コード例 #12
0
        private static async Task Exists_returns_false_when_database_doesnt_exist_test(bool async)
        {
            using (var testDatabase = await SqlServerTestStore.CreateScratchAsync(createDatabase: false))
            {
                using (var context = new BloggingContext(testDatabase))
                {
                    var creator = context.GetService<IRelationalDatabaseCreator>();

                    Assert.False(async ? await creator.ExistsAsync() : creator.Exists());

                    Assert.Equal(ConnectionState.Closed, context.Database.GetDbConnection().State);
                }
            }
        }
コード例 #13
0
ファイル: User.cs プロジェクト: TOByrne/TGOByrne
        /// <summary>
        /// Checks if user with given password exists in the database
        /// </summary>
        /// <param name="_username">User name</param>
        /// <param name="_password">User password</param>
        /// <returns>True if user exist and password is correct</returns>
        public bool IsValid(string _username, string _password)
        {
            using (var db = new BloggingContext())
            {
                var username = _username;
                var password = Helpers.SHA1.Encode(_password);

                var user = (from u in db.Users
                            where u.Username == username && u.Password == password
                            select u).FirstOrDefault();

                return user != null;
            }
        }
コード例 #14
0
        public static void Run()
        {
            var connectionString = @"Server=(localdb)\mssqllocaldb;Database=EFSaving.Transactions;Trusted_Connection=True;";

            using (var context = new BloggingContext(
                new DbContextOptionsBuilder<BloggingContext>()
                    .UseSqlServer(connectionString)
                    .Options))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();
            }

            var connection = new SqlConnection(connectionString);
            connection.Open();

            using (var transaction = connection.BeginTransaction())
            {
                try
                {
                    // Run raw ADO.NET command in the transaction
                    var command = connection.CreateCommand();
                    command.Transaction = transaction;
                    command.CommandText = "DELETE FROM dbo.Blogs";
                    command.ExecuteNonQuery();

                    // Run an EF Core command in the transaction
                    var options = new DbContextOptionsBuilder<BloggingContext>()
                        .UseSqlServer(connection)
                        .Options;

                    using (var context = new BloggingContext(options))
                    {
                        context.Database.UseTransaction(transaction);
                        context.Blogs.Add(new Blog { Url = "http://blogs.msdn.com/dotnet" });
                        context.SaveChanges();
                    }

                    // Commit transaction if all commands succeed, transaction will auto-rollback
                    // when disposed if either commands fails
                    transaction.Commit();
                }
                catch (System.Exception)
                {
                    // TODO: Handle failure
                }
            }
        }
コード例 #15
0
        public static void Run()
        {
            using (var context = new BloggingContext())
            {
                var blogs = context.Blogs.ToList();
            }

            using (var context = new BloggingContext())
            {
                var blog = context.Blogs
                    .Single(b => b.BlogId == 1);
            }

            using (var context = new BloggingContext())
            {
                var blogs = context.Blogs
                    .Where(b => b.Url.Contains("dotnet"))
                    .ToList();
            }
        }
コード例 #16
0
        public void Inserts_are_batched_correctly(bool clientPk, bool clientFk, bool clientOrder)
        {
            var optionsBuilder = new DbContextOptionsBuilder();
            optionsBuilder.UseSqlServer(_testStore.Connection);

            var expectedBlogs = new List<Blog>();
            using (var context = new BloggingContext(_serviceProvider, optionsBuilder.Options))
            {
                context.Database.EnsureCreated();
                var owner1 = new Owner();
                var owner2 = new Owner();
                context.Owners.Add(owner1);
                context.Owners.Add(owner2);

                for (var i = 1; i < 500; i++)
                {
                    var blog = new Blog();
                    if (clientPk)
                    {
                        blog.Id = Guid.NewGuid();
                    }

                    if (clientFk)
                    {
                        blog.Owner = i % 2 == 0 ? owner1 : owner2;
                    }

                    if (clientOrder)
                    {
                        blog.Order = i;
                    }

                    context.Blogs.Add(blog);
                    expectedBlogs.Add(blog);
                }

                context.SaveChanges();
            }

            AssertDatabaseState(clientOrder, expectedBlogs, optionsBuilder);
        }
コード例 #17
0
        public override void TestFixtureSetup()
        {
            base.TestFixtureSetup();
            using (var context = new BloggingContext(ConnectionStringEF))
            {
                if (context.Database.Exists())
                    context.Database.Delete();//We delete to be 100% schema is synced
                context.Database.Create();
            }

            // Create sequence for the IntComputedValue property.
            using (var createSequenceConn = new NpgsqlConnection(ConnectionStringEF))
            {
                createSequenceConn.Open();
                ExecuteNonQuery("create sequence blog_int_computed_value_seq", createSequenceConn);
                ExecuteNonQuery("alter table \"dbo\".\"Blogs\" alter column \"IntComputedValue\" set default nextval('blog_int_computed_value_seq');", createSequenceConn);

            }


        }
コード例 #18
0
        public static void Run()
        {
            using (var context = new BloggingContext())
            {
                var blogs = context.Blogs
                    .OrderByDescending(blog => blog.Rating)
                    .Select(blog => new
                    {
                        Id = blog.BlogId,
                        Url = StandardizeUrl(blog.Url)
                    })
                    .ToList();
            }

            using (var context = new BloggingContext())
            {
                var blogs = context.Blogs
                    .Where(blog => StandardizeUrl(blog.Url).Contains("dotnet"))
                    .ToList();
            }
        }
コード例 #19
0
ファイル: UserModel.cs プロジェクト: TOByrne/TGOByrne
        public static IResponse AddDefaultUser(BloggingContext db)
        {
            var user = new User
            {
                FirstName = "Tony",
                LastName = "O'Byrne",
                Email = "*****@*****.**",
                Username = "******",
                Password = "",
                CreateDate = DateTime.Now,
                LastUpdateDate = DateTime.Now
            };

            user.Blog.Add(new Blog
            {
                Name = "Personal"
            });

            IResponse userResult = AddUser(db, user);
            return userResult;
        }
コード例 #20
0
ファイル: AdminController.cs プロジェクト: TOByrne/TGOByrne
        public AdminController()
        {
            //	Get all the User stuff
            using (var db = new BloggingContext())
            {
                var users = from user in db.Users
                            orderby user.LastName
                            select user;

                if (!users.Any())
                {
                    IResponse addUserRespose = UserModel.AddDefaultUser(db);
                    Messages = addUserRespose.messages;
                }

                Users = new List<User>();
                foreach (var user in users)
                {
                    Users.Add(user);
                }
            }
        }
コード例 #21
0
        public override void TestFixtureSetup()
        {
            base.TestFixtureSetup();
            using (var context = new BloggingContext(ConnectionStringEF))
            {
                if (context.Database.Exists())
                    context.Database.Delete();//We delete to be 100% schema is synced
                context.Database.Create();
            }

            // Create sequence for the IntComputedValue property.
            using (var createSequenceConn = new NpgsqlConnection(ConnectionStringEF))
            {
                createSequenceConn.Open();
                ExecuteNonQuery("create sequence blog_int_computed_value_seq", createSequenceConn);
                ExecuteNonQuery("alter table \"dbo\".\"Blogs\" alter column \"IntComputedValue\" set default nextval('blog_int_computed_value_seq');", createSequenceConn);
                ExecuteNonQuery("alter table \"dbo\".\"Posts\" alter column \"VarbitColumn\" type varbit using null", createSequenceConn);
                ExecuteNonQuery("CREATE OR REPLACE FUNCTION \"dbo\".\"StoredAddFunction\"(integer, integer) RETURNS integer AS $$ SELECT $1 + $2; $$ LANGUAGE SQL;", createSequenceConn);
            }


        }
コード例 #22
0
        public void Batches_are_divided_correctly_with_two_inserted_columns()
        {
            var optionsBuilder = new EntityOptionsBuilder();
            optionsBuilder.UseSqlServer(_testStore.Connection);

            using (var context = new BloggingContext(_serviceProvider, optionsBuilder.Options))
            {
                context.Database.EnsureCreated();

                for (var i = 1; i < 1101; i++)
                {
                    var blog = new Blog { Id = i, Name = "Foo" + i };
                    context.Blogs.Add(blog);
                }

                context.SaveChanges();
            }

            using (var context = new BloggingContext(_serviceProvider, optionsBuilder.Options))
            {
                Assert.Equal(1100, context.Blogs.Count());
            }
        }
コード例 #23
0
ファイル: HomeModel.cs プロジェクト: TOByrne/TGOByrne
        public void GetUpdates()
        {
            using (var db = new BloggingContext())
            {
                try
                {
                    //var tags = (from t in db.Tags
                    //	select t)
                    //	.Distinct()
                    //	.ToList();

                    Updates = (from t in db.SiteUpdates
                        where t.User.UserId == User.UserId
                        select t)
                        .OrderByDescending(p => p.Timestamp)
                        .ToList();
                }
                catch (Exception)
                {
                    //	There are either no tags, or no updates.
                }

                Posts = (from p in db.Posts
                         where (from t in p.Tags
                                select t.Tag.ToUpper()).Contains("UPDATE") == false
                             && p.User.UserId == User.UserId
                         select p)
                    .OrderByDescending(p => p.Time)
                    .ToList()
                    //.Take(2)
                    ;

                //	Enumerate the tags; we'll need them.
                EnumerateTags(Updates);
                EnumerateTags(Posts);
            }
        }
コード例 #24
0
ファイル: CalendarModel.cs プロジェクト: TOByrne/TGOByrne
        public CalendarModel(BloggingContext db, DefaultModel pageModel)
            : base(pageModel)
        {
            if (db.Posts.Count() != 0)
            {
                LastPostDate = (from posts in db.Posts
                                orderby posts.Time descending
                                where (from t in posts.Tags
                                       select t.Tag.ToUpper()).Contains("UPDATE") == false
                                    && posts.Time != null
                                select posts.Time.Value).First();
                Now = LastPostDate;
            }
            else
            {
                Now = DateTime.Now;
            }

            FirstOfThisMonth = new DateTime(Now.Year, Now.Month, 1);
            DaysInThisMonth = DateTime.DaysInMonth(Now.Year, Now.Month);

            var FirstDayOfMonth = FirstOfThisMonth.DayOfWeek;

            GetDatesWithPostsThisMonth(db);

            Dictionary<int, DateInfo> firstRow = StartFirstRow(FirstDayOfMonth);
            CompleteFirstRow(firstRow);

            Dates = new List<Dictionary<int, DateInfo>>();
            Dates.Add(firstRow);

            while (DateCounter <= DaysInThisMonth)
            {
                Dates.Add(FullRow());
            }
            AddExtraNextMonthRow(Dates);
        }
コード例 #25
0
ファイル: PostModel.cs プロジェクト: TOByrne/TGOByrne
        public Post AddPost(string title, string content, List<string> tags, string section = "Personal")
        {
            using (var db = new BloggingContext())
            {
                title = Sanitize(title);
                content = Sanitize(content);
                Sanitize(tags);
                section = Sanitize(section);

                var postTags = VerifyTagsInDB(tags, db);

                GetBlog(section, db);
                GetUser(db);
                GetSection(section, db);

                var time = DateTime.Now;

                var post = new Post
                {
                    Blog = _Blog,
                    BlogBlogId = _Blog.BlogId,
                    Content = content,
                    Title = title,
                    User = _User,
                    UserUserId = _User.UserId,
                    Time = time,
                    Tags = postTags,
                    Section = _Section
                };

                var newPost = db.Posts.Add(post);
                db.SaveChanges();

                return newPost;
            }
        }
コード例 #26
0
        static void Main(string[] args)
        {
            using (var db = new BloggingContext())
            {
                var serviceProvider = db.GetInfrastructure<IServiceProvider>();
                var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
                loggerFactory.AddProvider(new MyLoggerProvider());
            }

            using (var db = new BloggingContext())
            {
                db.Database.EnsureCreated();
                db.Blogs.Add(new Blog { Url = "http://sample.com" });
                db.SaveChanges();
            }

            using (var db = new BloggingContext())
            {
                foreach (var blog in db.Blogs)
                {
                    Console.WriteLine(blog.Url);
                }
            }
        }
コード例 #27
0
ファイル: AdminController.cs プロジェクト: TOByrne/TGOByrne
        public JsonResult AddUser(User newUser)
        {
            using (var db = new BloggingContext())
            {
                if (string.IsNullOrEmpty(newUser.Password))
                {
                    newUser.Password = "";
                }

                newUser.CreateDate = DateTime.Now;
                newUser.LastUpdateDate = DateTime.Now;

                newUser.Blog.Add(new Blog
                {
                    Name = "Personal"
                });
                var userAdded = UserModel.AddUser(db, newUser);

                return new JsonResult
                {
                    Data = userAdded
                };
            }
        }
コード例 #28
0
 public PostService(BloggingContext context)
 {
     _context = context;
 }
コード例 #29
0
        public async Task Can_save_changes()
        {
            using (var testDatabase = await SqlServerTestStore.CreateScratchAsync())
            {
                var loggingFactory  = new TestSqlLoggerFactory();
                var serviceProvider = new ServiceCollection()
                                      .AddEntityFrameworkSqlServer()
                                      .AddSingleton <ILoggerFactory>(loggingFactory)
                                      .BuildServiceProvider();

                var optionsBuilder = new DbContextOptionsBuilder()
                                     .EnableSensitiveDataLogging()
                                     .UseSqlServer(testDatabase.ConnectionString)
                                     .UseInternalServiceProvider(serviceProvider);

                using (var db = new BloggingContext(optionsBuilder.Options))
                {
                    await CreateBlogDatabaseAsync <Blog>(db);
                }

                using (var db = new BloggingContext(optionsBuilder.Options))
                {
                    var toUpdate = db.Blogs.Single(b => b.Name == "Blog1");
                    toUpdate.Name = "Blog is Updated";
                    var updatedId = toUpdate.Id;
                    var toDelete  = db.Blogs.Single(b => b.Name == "Blog2");
                    toDelete.Name = "Blog to delete";
                    var deletedId = toDelete.Id;

                    db.Entry(toUpdate).State = EntityState.Modified;
                    db.Entry(toDelete).State = EntityState.Deleted;

                    var toAdd = db.Add(new Blog
                    {
                        Name       = "Blog to Insert",
                        George     = true,
                        TheGu      = new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BF"),
                        NotFigTime = new DateTime(1973, 9, 3, 0, 10, 33, 777),
                        ToEat      = 64,
                        OrNothing  = 0.123456789,
                        Fuse       = 777,
                        WayRound   = 9876543210,
                        Away       = 0.12345f,
                        AndChew    = new byte[16]
                    }).Entity;

                    await db.SaveChangesAsync();

                    var addedId = toAdd.Id;
                    Assert.NotEqual(0, addedId);

                    Assert.Equal(EntityState.Unchanged, db.Entry(toUpdate).State);
                    Assert.Equal(EntityState.Unchanged, db.Entry(toAdd).State);
                    Assert.DoesNotContain(toDelete, db.ChangeTracker.Entries().Select(e => e.Entity));

                    Assert.Equal(3, TestSqlLoggerFactory.SqlStatements.Count);
                    Assert.Contains("SELECT", TestSqlLoggerFactory.SqlStatements[0]);
                    Assert.Contains("SELECT", TestSqlLoggerFactory.SqlStatements[1]);
                    Assert.Contains("@p0: " + deletedId, TestSqlLoggerFactory.SqlStatements[2]);
                    Assert.Contains("DELETE", TestSqlLoggerFactory.SqlStatements[2]);
                    Assert.Contains("UPDATE", TestSqlLoggerFactory.SqlStatements[2]);
                    Assert.Contains("INSERT", TestSqlLoggerFactory.SqlStatements[2]);

                    var rows = await testDatabase.ExecuteScalarAsync <int>(
                        $@"SELECT Count(*) FROM [dbo].[Blog] WHERE Id = {updatedId} AND Name = 'Blog is Updated'",
                        CancellationToken.None);

                    Assert.Equal(1, rows);

                    rows = await testDatabase.ExecuteScalarAsync <int>(
                        $@"SELECT Count(*) FROM [dbo].[Blog] WHERE Id = {deletedId}",
                        CancellationToken.None);

                    Assert.Equal(0, rows);

                    rows = await testDatabase.ExecuteScalarAsync <int>(
                        $@"SELECT Count(*) FROM [dbo].[Blog] WHERE Id = {addedId} AND Name = 'Blog to Insert'",
                        CancellationToken.None);

                    Assert.Equal(1, rows);
                }
            }
        }
コード例 #30
0
ファイル: PostsController.cs プロジェクト: rukfash/Blogging
 public PostsController(IPostService postSvc, BloggingContext context)
 {
     _context = context;
     _postSvc = postSvc;
 }
コード例 #31
0
ファイル: Seeder.cs プロジェクト: viktortat/ef-experiments
        public static void Seed()
        {
            var dbContext = new BloggingContext();

            if (dbContext.Authors.Any())
            {
                return;
            }

            var tags = new[]
            {
                new Tag
                {
                    Id          = "csharp",
                    Description = "C#"
                },
                new Tag
                {
                    Id          = "javascript",
                    Description = "JavaScript"
                },
                new Tag
                {
                    Id          = "cooking",
                    Description = "Cooking"
                },
                new Tag
                {
                    Id          = "egg",
                    Description = "Egg"
                },
                new Tag
                {
                    Id          = "forbeginners",
                    Description = "For Beginners"
                },
                new Tag
                {
                    Id          = "db",
                    Description = "Databases"
                },
                new Tag
                {
                    Id          = "ef",
                    Description = "Entity Framework"
                },
                new Tag
                {
                    Id          = "advanced",
                    Description = "Advanced"
                },
                new Tag
                {
                    Id          = "oriental",
                    Description = "Oriental Cooking"
                }
            };

            var blogs = new[]
            {
                new Blog
                {
                    Created = DateTime.Now.AddDays(-100),
                    Title   = "Programmer's Spot"
                },
                new Blog
                {
                    Created = DateTime.Now.AddDays(-1000),
                    Title   = "Cooking at home"
                }
            };

            var authors = new[]
            {
                new Author
                {
                    Name     = "Eduard",
                    LastName = "Lepner",
                    Posts    = new List <Post>
                    {
                        new Post
                        {
                            Title   = "How to start with EF and don't shoot your head",
                            Content = "Some interesting post content",
                            Blog    = blogs[0],
                            Rating  = 5,
                            Created = DateTime.Now.AddDays(-1)
                        },
                        new Post
                        {
                            Title   = "Functional Programming For Body Builders",
                            Content = "Some content",
                            Rating  = 4,
                            Blog    = blogs[0],
                            Created = DateTime.Today
                        },
                        new Post
                        {
                            Title   = "How to cook an Egg",
                            Content = "Put an egg into tea pot and turn it on.",
                            Blog    = blogs[1],
                            Created = DateTime.Now
                        }
                    }
                },
                new Author
                {
                    Name     = "John",
                    LastName = "Doe",
                    Posts    = new List <Post>
                    {
                        new Post
                        {
                            Title   = "John First Post Title",
                            Content = "Some content for John's first post.",
                            Blog    = blogs[0]
                        },
                        new Post
                        {
                            Title   = "John Second Post Title",
                            Content = "Some content for John's second post.",
                            Blog    = blogs[1]
                        }
                    }
                },
                new Author
                {
                    Name     = "Jan",
                    LastName = "Kovalski",
                    Posts    = new List <Post>
                    {
                        new Post
                        {
                            Title   = "Jan's first post",
                            Content = "Some content for Jan's first post.",
                            Blog    = blogs[1],
                            Rating  = 3
                        }
                    }
                }
            };

            var posts = authors.SelectMany(x => x.Posts).ToArray();

            posts[0].AssignTags("csharp", "db", "ef");
            posts[1].AssignTags("csharp", "forbeginners");
            posts[2].AssignTags("forbeginners");
            posts[3].AssignTags("javascript", "db", "advanced", "csharp");
            posts[4].AssignTags("oriental", "db", "advanced", "csharp");

            dbContext.Blogs.AddRange(blogs);
            dbContext.Authors.AddRange(authors);
            dbContext.Tags.AddRange(tags);
            dbContext.SaveChanges();
        }
コード例 #32
0
 public ArticlesController(BloggingContext context)
 {
     _db = context;
 }
コード例 #33
0
 public UnitTestBase(ITestOutputHelper output)
 {
     Effort.Provider.EffortProviderConfiguration.RegisterProvider();
     this._context = PrepareContext();
     DTORepositoryContainer.InitializeDtoMapper <BloggingContext>();
 }
コード例 #34
0
        public async System.Threading.Tasks.Task Stream_Generate_Insert_For_Multiple_Entities()
        {
            using (var testDatabase = SqlServerTestStore.Create(DatabaseName))
            {
                var loggingFactory  = new TestSqlLoggerFactory();
                var serviceProvider = new ServiceCollection()
                                      .AddEntityFrameworkSqlServer()
                                      .AddSingleton <ILoggerFactory>(loggingFactory)
                                      .BuildServiceProvider();

                var optionsBuilder = new DbContextOptionsBuilder()
                                     .EnableSensitiveDataLogging()
                                     .UseSqlServer(testDatabase.ConnectionString, b => b.ApplyConfiguration())
                                     .UseInternalServiceProvider(serviceProvider);

                using (var db = new BloggingContext(optionsBuilder.Options))
                {
                    await CreateBlogDatabaseAsync <Blog>(db);
                }

                loggingFactory.Clear();

                using (var db = new BloggingContext(optionsBuilder.Options))
                {
                    var toAdd = db.Add(new Blog
                    {
                        Name       = "Blog to Insert",
                        George     = true,
                        TheGu      = new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BF"),
                        NotFigTime = new DateTime(1973, 9, 3, 0, 10, 33, 777),
                        ToEat      = 64,
                        OrNothing  = 0.123456789,
                        Fuse       = 777,
                        WayRound   = 9876543210,
                        Away       = 0.12345f,
                        AndChew    = new byte[16]
                    }).Entity;

                    var recordTwo = db.Add(new Blog
                    {
                        Name       = "Another Blog to Insert",
                        George     = true,
                        TheGu      = new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BE"),
                        NotFigTime = new DateTime(1974, 9, 3, 0, 10, 33, 777),
                        ToEat      = 65,
                        OrNothing  = 0.123456789,
                        Fuse       = 777,
                        WayRound   = 9876543210,
                        Away       = 0.12345f,
                        AndChew    = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
                    }).Entity;

                    var statement = "";

                    using (var stream = new MemoryStream())
                    {
                        db.Generate(stream);
                        stream.Seek(0, SeekOrigin.Begin);
                        var streamReader = new StreamReader(stream);
                        statement = await streamReader.ReadToEndAsync();

                        Assert.IsTrue(!string.IsNullOrEmpty(statement));
                    }

                    var reader = new StringReader(statement);
                    IList <ParseError> errors;
                    var parser = new TSql140Parser(false);

                    var parseResult = parser.Parse(reader, out errors);

                    Assert.IsFalse(errors.Any());
                }
            }
        }
コード例 #35
0
        public void PerformanceTest()
        {
            MemoryCacheProvider.ClearCache();

            decimal loopCount = 1000;

            var loggerProvider = new DebugLoggerProvider();
            var loggerFactory  = new LoggerFactory(new[] { loggerProvider });

            var options = new DbContextOptionsBuilder <BloggingContext>()
                          .UseLoggerFactory(loggerFactory)
                          .UseInMemoryDatabase(databaseName: "PerformanceTest")
                          .Options;

            // create test entries
            using (var initContext = new BloggingContext(options))
            {
                initContext.ChangeTracker.AutoDetectChangesEnabled = false;

                for (int i = 0; i < 100000; i++)
                {
                    initContext.Blogs.Add(new Blog
                    {
                        Url = $"http://sample.com/cat{i}",

                        Posts = new List <Post>
                        {
                            { new Post {
                                  Title = $"Post{1}"
                              } }
                        }
                    });
                }
                initContext.SaveChanges();
            }

            var rawOptions = new DbContextOptionsBuilder <BloggingContext>()
                             .UseLoggerFactory(loggerFactory)
                             .UseInMemoryDatabase(databaseName: "PerformanceTest")
                             .Options;

            using (var performanceContext = new BloggingContext(rawOptions))
            {
                Stopwatch watch = new Stopwatch();
                watch.Start();

                // raw queries
                for (int i = 0; i < loopCount; i++)
                {
                    var result = performanceContext.Blogs
                                 .Where(d => d.BlogId >= 0)
                                 .Take(100)
                                 .ToList();
                }

                var rawTimeSpan = watch.Elapsed;

                Debug.WriteLine($"Average default context database query duration [+{TimeSpan.FromTicks((long)(rawTimeSpan.Ticks / loopCount))}].");
            }

            using (var performanceContext = new BloggingContext(options))
            {
                Stopwatch watch = new Stopwatch();
                watch.Start();

                // uncached queries
                for (int i = 0; i < loopCount; i++)
                {
                    var result = performanceContext.Blogs
                                 .Where(d => d.BlogId >= 0)
                                 .Take(100)
                                 .ToList();
                }

                var uncachedTimeSpan = watch.Elapsed;

                // caching query result
                performanceContext.Blogs
                .Where(d => d.BlogId >= 0)
                .Cacheable(TimeSpan.FromMinutes(10))
                .Take(100)
                .ToList();

                watch.Restart();

                // cached queries
                for (int i = 0; i < loopCount; i++)
                {
                    var result = performanceContext.Blogs
                                 .Where(d => d.BlogId >= 0)
                                 .Cacheable(TimeSpan.FromMinutes(10))
                                 .Take(100)
                                 .ToList();
                }

                var cachedTimeSpan = watch.Elapsed;


                // find log entries
                var queryResultsCachedCount = loggerProvider.Entries.Where(e => e.EventId == CacheableEventId.QueryResultCached).Count();
                var cacheHitsCount          = loggerProvider.Entries.Where(e => e.EventId == CacheableEventId.CacheHit).Count();

                // check cache event counts
                Assert.IsTrue(queryResultsCachedCount == 1);
                Assert.IsTrue(cacheHitsCount == loopCount);

                Debug.WriteLine($"Average database query duration [+{TimeSpan.FromTicks((long)(uncachedTimeSpan.Ticks / loopCount))}].");
                Debug.WriteLine($"Average cache query duration [+{TimeSpan.FromTicks((long)(cachedTimeSpan.Ticks / loopCount))}].");
                Debug.WriteLine($"Cached queries are x{((Decimal)uncachedTimeSpan.Ticks / (Decimal)cachedTimeSpan.Ticks)-1:N2} times faster.");

                Assert.IsTrue(cachedTimeSpan < uncachedTimeSpan);
            }
        }
コード例 #36
0
        public async Task Paging_lots_of_elements(int itemsCount)
        {
            try
            {
                // Run the test against one instance of the context
                using (var context = new BloggingContext(Setup.DbOpts))
                {
                    var repository = new AspNetCore.ExistingDb.Repositories.HashesRepository(context, Setup.Conf, Setup.Cache, Setup.Logger, Setup.ServerTiming);
                    var tasks      = new List <Task>(itemsCount + 1);
                    for (int i = 0; i < itemsCount; i++)
                    {
                        tasks.Add(repository.AddRangeAsync(new[] {
                            new ThinHashes
                            {
                                Key        = $"alamakota_{i}",
                                HashMD5    = $"dc246bcdd6cb3548579770a034d2e678_{i}",
                                HashSHA256 = $"63b347973bb99fed9277b33cb4646b205e9a31331acfa574add3d2351f445e43_{i}"
                            },
                            new ThinHashes
                            {
                                Key        = $"fakefakef_{i}",
                                HashMD5    = $"fakefakefakefakefakefakefakefake_{i}",
                                HashSHA256 = $"fakefakefakefakefakefakefakefakefakefakefakefakefakefakefakefake_{i}"
                            }
                        }));
                    }
                    Task.WaitAll(tasks.ToArray());
                    await repository.SaveAsync();
                }

                using (var context = new BloggingContext(Setup.DbOpts))
                {
                    var repository = new AspNetCore.ExistingDb.Repositories.HashesRepository(context, Setup.Conf, Setup.Cache, Setup.Logger, Setup.ServerTiming);
                    var found      = await repository.PagedSearchAsync("Key", "asc", "fake", 2, 10, CancellationToken);

                    Assert.True(found.Count > 0);
                    Assert.NotEmpty(found.Itemz);
                    Assert.Equal(found.Count, itemsCount);
                    Assert.Equal(10, found.Itemz.Count());
                    Assert.Equal("fakefakef_10", found.Itemz.First()[0]);
                    Assert.Equal("fakefakefakefakefakefakefakefakefakefakefakefakefakefakefakefake_10", found.Itemz.First()[2]);
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                Setup.Conn.Dispose();
            }

            //2nd run
            var db = SetupInMemoryDB();

            db.Wait();
            Setup = db.Result;
            try
            {
                // Run the test against one instance of the context
                using (var context = new BloggingContext(Setup.DbOpts))
                {
                    var repository = new AspNetCore.ExistingDb.Repositories.HashesRepository(context, Setup.Conf, Setup.Cache, Setup.Logger, Setup.ServerTiming);
                    var tasks      = new List <Task>(itemsCount + 1);
                    for (int i = 0; i < itemsCount; i++)
                    {
                        tasks.Add(repository.AddRangeAsync(new[] {
                            new ThinHashes
                            {
                                Key        = $"alamakota_{i}",
                                HashMD5    = $"dc246bcdd6cb3548579770a034d2e678_{i}",
                                HashSHA256 = $"63b347973bb99fed9277b33cb4646b205e9a31331acfa574add3d2351f445e43_{i}"
                            },
                            new ThinHashes
                            {
                                Key        = $"fakefakef_{i}",
                                HashMD5    = $"fakefakefakefakefakefakefakefake_{i}",
                                HashSHA256 = $"fakefakefakefakefakefakefakefakefakefakefakefakefakefakefakefake_{i}"
                            }
                        }));
                    }
                    Task.WaitAll(tasks.ToArray());
                    await repository.SaveAsync();
                }

                using (var context = new BloggingContext(Setup.DbOpts))
                {
                    var repository = new AspNetCore.ExistingDb.Repositories.HashesRepository(context, Setup.Conf, Setup.Cache, Setup.Logger, Setup.ServerTiming);
                    var found      = await repository.PagedSearchAsync("Key", "asc", "63b347973bb99f", 2, 10, CancellationToken);

                    Assert.True(found.Count > 0);
                    Assert.NotEmpty(found.Itemz);
                    Assert.Equal(found.Count, itemsCount);
                    Assert.Equal(10, found.Itemz.Count());
                    Assert.Equal("alamakota_10", found.Itemz.First()[0]);
                    Assert.Equal("63b347973bb99fed9277b33cb4646b205e9a31331acfa574add3d2351f445e43_10", found.Itemz.First()[2]);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
コード例 #37
0
ファイル: PostsController.cs プロジェクト: uzzyka/ASP
 public PostsController(BloggingContext context)
 {
     _context = context;
 }
コード例 #38
0
 public BlogService(BloggingContext context)
 {
     _context = context;
 }
コード例 #39
0
        public async Task CalculateHashesInfo()
        {
            try
            {
                // Run the test against one instance of the context
                using (var context = new BloggingContext(Setup.DbOpts))
                {
                    var repository = new AspNetCore.ExistingDb.Repositories.HashesRepository(context, Setup.Conf, Setup.Cache, Setup.Logger, Setup.ServerTiming);
                    int count      = 100;
                    var tasks      = new List <Task>(count + 1);
                    for (int i = 0; i < count; i++)
                    {
                        tasks.Add(repository.AddRangeAsync(new[] {
                            new ThinHashes
                            {
                                Key        = $"alamakota_{i}",
                                HashMD5    = $"dc246bcdd6cb3548579770a034d2e678_{i}",
                                HashSHA256 = $"63b347973bb99fed9277b33cb4646b205e9a31331acfa574add3d2351f445e43_{i}"
                            },
                            new ThinHashes
                            {
                                Key        = $"bakebakeb_{i}",
                                HashMD5    = $"bakebakebakebakebakebakebakebake_{i}",
                                HashSHA256 = $"bakebakebakebakebakebakebakebakebakebakebakebakebakebakebakebake_{i}"
                            },
                            new ThinHashes
                            {
                                Key        = $"cakecakec_{i}",
                                HashMD5    = $"cakecakecakecakecakecakecakecake_{i}",
                                HashSHA256 = $"cakecakecakecakecakecakecakecakecakecakecakecakecakecakecakecake_{i}"
                            },
                        }));
                    }
                    Task.WaitAll(tasks.ToArray());
                    await repository.SaveAsync();
                }

                using (var context = new BloggingContext(Setup.DbOpts))
                {
                    var repository = new AspNetCore.ExistingDb.Repositories.HashesRepository(context, Setup.Conf, Setup.Cache, Setup.Logger, Setup.ServerTiming);
                    var factory    = new LoggerFactory();
                    var logger     = factory.CreateLogger <HashesRepository>();

                    var expected = await repository.CurrentHashesInfo;
                    Assert.Null(expected);

                    var res0 = await repository.CalculateHashesInfo(logger, Setup.DbOpts);

                    Assert.NotNull(res0);

                    var res1 = await repository.CalculateHashesInfo(logger, Setup.DbOpts);

                    Assert.NotNull(res1);

                    Assert.Same(res0, res1);
                    Assert.Equal("abc", res0.Alphabet);
                    Assert.Equal(300, res0.Count);
                    Assert.False(res0.IsCalculating);
                    Assert.Equal(12, res0.KeyLength);

                    expected = await repository.CurrentHashesInfo;

                    Assert.NotNull(expected);
                    Assert.Equal(res1.ID, expected.ID);
                    Assert.Equal(res1.Alphabet, expected.Alphabet);
                    Assert.Equal(res1.Count, expected.Count);
                    Assert.Equal(res1.IsCalculating, expected.IsCalculating);
                    Assert.Equal(res1.KeyLength, expected.KeyLength);
                    Assert.Equal(res1.ToString(), expected.ToString());
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
コード例 #40
0
 public static TestDatabaseCreator GetDatabaseCreator(BloggingContext context)
 => (TestDatabaseCreator)context.GetService <IRelationalDatabaseCreator>();
コード例 #41
0
 public CommentCollectionsController(BloggingContext context)
 {
     _context = context;
 }
コード例 #42
0
        /// <summary>
        /// Testing cache expiration functionality.
        /// </summary>
        //[TestMethod]
        public void ExpirationTest()
        {
            MemoryCacheProvider.ClearCache();

            var loggerProvider = new DebugLoggerProvider();
            var loggerFactory  = new LoggerFactory(new[] { loggerProvider });

            var options = new DbContextOptionsBuilder <BloggingContext>()
                          .UseLoggerFactory(loggerFactory)
                          .UseInMemoryDatabase(databaseName: "ExpirationTest")
                          .Options;

            // create test entries
            using (var initContext = new BloggingContext(options))
            {
                initContext.Blogs.Add(new Blog {
                    BlogId = 1, Url = "http://sample.com/cats"
                });
                initContext.Blogs.Add(new Blog {
                    BlogId = 2, Url = "http://sample.com/catfish"
                });
                initContext.Blogs.Add(new Blog {
                    BlogId = 3, Url = "http://sample.com/dogs"
                });
                initContext.SaveChanges();
            }

            using (var expirationContext = new BloggingContext(options))
            {
                // shoud not hit cache, because first execution
                var result = expirationContext.Blogs
                             .Where(d => d.BlogId == 1)
                             .Cacheable(TimeSpan.FromSeconds(5))
                             .ToList();

                // shoud hit cache, because second execution
                result = expirationContext.Blogs
                         .Where(d => d.BlogId == 1)
                         .Cacheable(TimeSpan.FromSeconds(5))
                         .ToList();

                // shoud not hit cache, because different parameter
                result = expirationContext.Blogs
                         .Where(d => d.BlogId == 2)
                         .Cacheable(TimeSpan.FromSeconds(5))
                         .ToList();

                Thread.Sleep(TimeSpan.FromSeconds(10));

                // shoud not hit cache, because expiration
                result = expirationContext.Blogs
                         .Where(d => d.BlogId == 1)
                         .Cacheable(TimeSpan.FromSeconds(5))
                         .ToList();
            }

            // find "cache hit" log entries
            var logs = loggerProvider.Entries.Where(e => e.EventId == CacheableEventId.CacheHit);

            // cache should hit one time
            Assert.IsTrue(logs.Count() == 1);
        }
コード例 #43
0
        public void TestCacheReaderRaw()
        {
            var test = GetTestEntity();

            using (var ctx = new BloggingContext(ConnectionString))
            {
                ctx.Tests.Add(test);
                ctx.SaveChanges();

                test = ctx.Tests.Single();
            }

            using (var ctx = new BloggingContext(ConnectionString))
            {
                var cmd = GetEntityCommand(ctx, "SELECT VALUE Test FROM BloggingContext.Tests AS Test");

                using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                {
                    // Check schema.
                    Assert.Throws <NotSupportedException>(() => reader.GetSchemaTable());
                    Assert.AreEqual(0, reader.Depth);
                    Assert.AreEqual(-1, reader.RecordsAffected);
                    Assert.IsTrue(reader.HasRows);
                    Assert.IsFalse(reader.IsClosed);
                    Assert.AreEqual(11, reader.FieldCount);
                    Assert.AreEqual(11, reader.VisibleFieldCount);

                    // Check field names.
                    Assert.AreEqual("Edm.Int32", reader.GetDataTypeName(0));
                    Assert.AreEqual("Edm.Byte", reader.GetDataTypeName(1));
                    Assert.AreEqual("Edm.Int16", reader.GetDataTypeName(2));
                    Assert.AreEqual("Edm.Int64", reader.GetDataTypeName(3));
                    Assert.AreEqual("Edm.Single", reader.GetDataTypeName(4));
                    Assert.AreEqual("Edm.Double", reader.GetDataTypeName(5));
                    Assert.AreEqual("Edm.Decimal", reader.GetDataTypeName(6));
                    Assert.AreEqual("Edm.Boolean", reader.GetDataTypeName(7));
                    Assert.AreEqual("Edm.String", reader.GetDataTypeName(8));
                    Assert.AreEqual("Edm.Guid", reader.GetDataTypeName(9));
                    Assert.AreEqual("Edm.DateTime", reader.GetDataTypeName(10));

                    // Check field types.
                    Assert.AreEqual(typeof(int), reader.GetFieldType(0));
                    Assert.AreEqual(typeof(byte), reader.GetFieldType(1));
                    Assert.AreEqual(typeof(short), reader.GetFieldType(2));
                    Assert.AreEqual(typeof(long), reader.GetFieldType(3));
                    Assert.AreEqual(typeof(float), reader.GetFieldType(4));
                    Assert.AreEqual(typeof(double), reader.GetFieldType(5));
                    Assert.AreEqual(typeof(decimal), reader.GetFieldType(6));
                    Assert.AreEqual(typeof(bool), reader.GetFieldType(7));
                    Assert.AreEqual(typeof(string), reader.GetFieldType(8));
                    Assert.AreEqual(typeof(Guid), reader.GetFieldType(9));
                    Assert.AreEqual(typeof(DateTime), reader.GetFieldType(10));

                    // Read.
                    Assert.IsTrue(reader.Read());

                    // Test values array.
                    var vals = new object[reader.FieldCount];
                    reader.GetValues(vals);

                    Assert.AreEqual(test.Byte, vals[reader.GetOrdinal("Byte")]);
                    Assert.AreEqual(test.Short, vals[reader.GetOrdinal("Short")]);
                    Assert.AreEqual(test.ArrayReaderTestId, vals[reader.GetOrdinal("ArrayReaderTestId")]);
                    Assert.AreEqual(test.Long, vals[reader.GetOrdinal("Long")]);
                    Assert.AreEqual(test.Float, vals[reader.GetOrdinal("Float")]);
                    Assert.AreEqual(test.Double, vals[reader.GetOrdinal("Double")]);
                    Assert.AreEqual(test.Decimal, vals[reader.GetOrdinal("Decimal")]);
                    Assert.AreEqual(test.Bool, vals[reader.GetOrdinal("Bool")]);
                    Assert.AreEqual(test.String, vals[reader.GetOrdinal("String")]);
                    Assert.AreEqual(test.Guid, vals[reader.GetOrdinal("Guid")]);
                    Assert.AreEqual(test.DateTime, vals[reader.GetOrdinal("DateTime")]);
                }

                using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                {
                    // Read.
                    Assert.IsTrue(reader.Read());

                    // Test separate values.
                    Assert.AreEqual(test.ArrayReaderTestId, reader.GetInt32(0));
                    Assert.AreEqual(test.Byte, reader.GetByte(1));
                    Assert.AreEqual(test.Short, reader.GetInt16(2));
                    Assert.AreEqual(test.Long, reader.GetInt64(3));
                    Assert.AreEqual(test.Float, reader.GetFloat(4));
                    Assert.AreEqual(test.Double, reader.GetDouble(5));
                    Assert.AreEqual(test.Decimal, reader.GetDecimal(6));
                    Assert.AreEqual(test.Bool, reader.GetBoolean(7));
                    Assert.AreEqual(test.String, reader.GetString(8));
                    Assert.AreEqual(test.Guid, reader.GetGuid(9));
                    Assert.AreEqual(test.DateTime, reader.GetDateTime(10));
                }
            }
        }
コード例 #44
0
ファイル: BlogManager.cs プロジェクト: SwedishConnection/Five
 public BlogManager(BloggingContext ctx)
 {
     this.ctx = ctx;
 }
コード例 #45
0
        public async System.Threading.Tasks.Task Stream_Generate_For_DML()
        {
            using (var testDatabase = SqlServerTestStore.Create(DatabaseName))
            {
                var loggingFactory  = new TestSqlLoggerFactory();
                var serviceProvider = new ServiceCollection()
                                      .AddEntityFrameworkSqlServer()
                                      .AddSingleton <ILoggerFactory>(loggingFactory)
                                      .BuildServiceProvider();

                var optionsBuilder = new DbContextOptionsBuilder()
                                     .EnableSensitiveDataLogging()
                                     .UseSqlServer(testDatabase.ConnectionString, b => b.ApplyConfiguration())
                                     .UseInternalServiceProvider(serviceProvider);

                using (var db = new BloggingContext(optionsBuilder.Options))
                {
                    await CreateBlogDatabaseAsync <Blog>(db);
                }

                loggingFactory.Clear();

                using (var db = new BloggingContext(optionsBuilder.Options))
                {
                    var toUpdate = db.Blogs.Single(b => b.Name == "Blog1");
                    toUpdate.Name = "Blog is Updated";
                    var updatedId = toUpdate.Id;
                    var toDelete  = db.Blogs.Single(b => b.Name == "Blog2");
                    toDelete.Name = "Blog to delete";
                    var deletedId = toDelete.Id;

                    db.Entry(toUpdate).State = EntityState.Modified;
                    db.Entry(toDelete).State = EntityState.Deleted;

                    var toAdd = db.Add(new Blog
                    {
                        Name       = "Blog to Insert",
                        George     = true,
                        TheGu      = new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BF"),
                        NotFigTime = new DateTime(1973, 9, 3, 0, 10, 33, 777),
                        ToEat      = 64,
                        OrNothing  = 0.123456789,
                        Fuse       = 777,
                        WayRound   = 9876543210,
                        Away       = 0.12345f,
                        AndChew    = new byte[16]
                    }).Entity;

                    var statement = "";

                    using (var stream = new MemoryStream())
                    {
                        db.Generate(stream);
                        stream.Seek(0, SeekOrigin.Begin);
                        var streamReader = new StreamReader(stream);
                        statement = await streamReader.ReadToEndAsync();

                        Assert.IsTrue(!string.IsNullOrEmpty(statement));
                    }

                    var reader = new StringReader(statement);
                    IList <ParseError> errors;
                    var parser = new TSql140Parser(false);

                    var parseResult = parser.Parse(reader, out errors);

                    Assert.IsFalse(errors.Any());

                    //var expectedStatement = "EXECUTE sp_executesql N'INSERT INTO Blog ([AndChew], [Away], [Fuse], [George], [Name], [NotFigTime], [OrNothing], [TheGu], [ToEat], [WayRound]) VALUES (@p0,@p1,@p2,@p3,@p4,@p5,@p6,@p7,@p8,@p9)', N'@p0 varbinary(max),@p1 real,@p2 smallint,@p3 bit,@p4 nvarchar(max),@p5 datetime2,@p6 float,@p7 uniqueidentifier,@p8 tinyint,@p9 bigint', @p0 = 0x00000000000000000000000000000000,@p1 = 0.12345,@p2 = 777,@p3 = True,@p4 = 'Blog to Insert',@p5 = '9/3/1973 12:10:33 AM',@p6 = 0.123456789,@p7 = '0456aef1-b7fc-47aa-8102-975d6ba3a9bf',@p8 = 64,@p9 = 9876543210";

                    //Assert.AreEqual(expectedStatement, statement);
                }
            }
        }
コード例 #46
0
        public void TestComplicatedQueriesWithApply()
        {
            if ((BackendVersion.Major > 9) || (BackendVersion.Major == 9 && BackendVersion.Minor >= 3))
            {
                using (var context = new BloggingContext(ConnectionStringEF))
                {
                    context.Database.Log = Console.Out.WriteLine;

                    // Test Apply
                    (from t1 in context.Blogs
                     from t2 in context.Posts.Where(p => p.BlogId == t1.BlogId).Take(1)
                     select new { t1, t2 }).ToArray();

                    Action<string> elinq = (string query) => {
                        new System.Data.Entity.Core.Objects.ObjectQuery<System.Data.Common.DbDataRecord>(query, ((System.Data.Entity.Infrastructure.IObjectContextAdapter)context).ObjectContext).ToArray();
                    };

                    // Joins, apply
                    elinq("Select value Blogs.BlogId From Blogs outer apply (Select p1.BlogId as bid, p1.PostId as bid2 from Posts as p1 left outer join (Select value p.PostId from Posts as p where p.PostId < Blogs.BlogId)) as b outer apply (Select p.PostId from Posts as p where p.PostId < b.bid)");

                    // Just some really crazy query that results in an apply as well
                    context.Blogs.Select(b => new { b, b.BlogId, n = b.Posts.Select(p => new { t = p.Title + b.Name, n = p.Blog.Posts.Count(p2 => p2.BlogId < 4) }).Take(2) }).ToArray();
                }
            }
        }
コード例 #47
0
 public CustomBlogRepository(BloggingContext dbContext) : base(dbContext)
 {
 }
コード例 #48
0
        private async Task RoundTripChanges <TBlog>() where TBlog : class, IBlog, new()
        {
            using (var testDatabase = await SqlServerTestStore.CreateScratchAsync())
            {
                var optionsBuilder = new DbContextOptionsBuilder()
                                     .UseSqlServer(testDatabase.ConnectionString)
                                     .UseInternalServiceProvider(_fixture.ServiceProvider);

                int blog1Id;
                int blog2Id;
                int blog3Id;

                using (var context = new BloggingContext <TBlog>(optionsBuilder.Options))
                {
                    var blogs = await CreateBlogDatabaseAsync <TBlog>(context);

                    blog1Id = blogs[0].Id;
                    blog2Id = blogs[1].Id;

                    Assert.NotEqual(0, blog1Id);
                    Assert.NotEqual(0, blog2Id);
                    Assert.NotEqual(blog1Id, blog2Id);
                }

                using (var context = new BloggingContext <TBlog>(optionsBuilder.Options))
                {
                    var blogs = context.Blogs.ToList();
                    Assert.Equal(2, blogs.Count);

                    var blog1 = blogs.Single(b => b.Name == "Blog1");
                    Assert.Equal(blog1Id, blog1.Id);

                    Assert.Equal("Blog1", blog1.Name);
                    Assert.True(blog1.George);
                    Assert.Equal(new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BF"), blog1.TheGu);
                    Assert.Equal(new DateTime(1973, 9, 3, 0, 10, 33, 777), blog1.NotFigTime);
                    Assert.Equal(64, blog1.ToEat);
                    Assert.Equal(0.123456789, blog1.OrNothing);
                    Assert.Equal(777, blog1.Fuse);
                    Assert.Equal(9876543210, blog1.WayRound);
                    Assert.Equal(0.12345f, blog1.Away);
                    Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, blog1.AndChew);

                    blog1.Name = "New Name";

                    var blog2 = blogs.Single(b => b.Name == "Blog2");
                    Assert.Equal(blog2Id, blog2.Id);

                    blog2.Name       = null;
                    blog2.NotFigTime = new DateTime();
                    blog2.AndChew    = null;

                    var blog3 = context.Add(new TBlog()).Entity;

                    await context.SaveChangesAsync();

                    blog3Id = blog3.Id;
                    Assert.NotEqual(0, blog3Id);
                }

                using (var context = new BloggingContext <TBlog>(optionsBuilder.Options))
                {
                    var blogs = context.Blogs.ToList();
                    Assert.Equal(3, blogs.Count);

                    Assert.Equal("New Name", blogs.Single(b => b.Id == blog1Id).Name);

                    var blog2 = blogs.Single(b => b.Id == blog2Id);
                    Assert.Null(blog2.Name);
                    Assert.Equal(blog2.NotFigTime, new DateTime());
                    Assert.Null(blog2.AndChew);

                    var blog3 = blogs.Single(b => b.Id == blog3Id);
                    Assert.Null(blog3.Name);
                    Assert.Equal(blog3.NotFigTime, new DateTime());
                    Assert.Null(blog3.AndChew);
                }
            }
        }
コード例 #49
0
 public IndexModel(BloggingContext db)
 {
     _db = db;
 }
コード例 #50
0
 public APIController(BloggingContext context)
 {
     _context = context;
 }
コード例 #51
0
        public void SingleProjectionExpressionTest()
        {
            MemoryCacheProvider.ClearCache();

            var loggerProvider = new DebugLoggerProvider();
            var loggerFactory  = new LoggerFactory(new[] { loggerProvider });

            var options = new DbContextOptionsBuilder <BloggingContext>()
                          .UseLoggerFactory(loggerFactory)
                          .UseInMemoryDatabase(databaseName: "ProjectionExpressionTest")
                          .Options;

            // create test entries
            using (var initContext = new BloggingContext(options))
            {
                initContext.Blogs.Add(new Blog {
                    BlogId = 1, Url = "http://sample.com/cats"
                });
                initContext.Blogs.Add(new Blog {
                    BlogId = 2, Url = "http://sample.com/catfish"
                });
                initContext.Blogs.Add(new Blog {
                    BlogId = 3, Url = "http://sample.com/dogs"
                });
                initContext.SaveChanges();
            }

            using (var projectionContext = new BloggingContext(options))
            {
                // shoud not hit cache, because first execution
                var result = projectionContext.Blogs
                             .Where(d => d.BlogId == 1)
                             .Select(d => new
                {
                    d.BlogId,
                    d.Rating
                })
                             .Cacheable(TimeSpan.FromMinutes(5))
                             .SingleOrDefault();

                Thread.Sleep(TimeSpan.FromSeconds(1));

                // shoud hit cache, because second execution
                var cachedResult = projectionContext.Blogs
                                   .Where(d => d.BlogId == 1)
                                   .Select(d => new
                {
                    d.BlogId,
                    d.Rating
                })
                                   .Cacheable(TimeSpan.FromMinutes(5))
                                   .SingleOrDefault();

                Assert.IsNotNull(result);
                Assert.AreSame(result, cachedResult);
            }

            // find "cache hit" log entries
            var logs = loggerProvider.Entries.Where(e => e.EventId == CacheableEventId.CacheHit);

            // cache should hit one time
            Assert.IsTrue(logs.Count() == 1);
        }
コード例 #52
0
 public UserRepository(BloggingContext databaseContext)
 {
     _databaseContext = databaseContext;
 }
コード例 #53
0
 public static void Seed(this BloggingContext context)
 {
     context
     .Blogs
     .AddRange(
         new Blog
     {
         Url    = "http://blog1.com",
         Rating = 5,
         Posts  =
         {
             new Post()
             {
                 Content = "Post 1 content",
                 Title   = "Post 1"
             },
             new Post()
             {
                 Content = "Post 2 content",
                 Title   = "Post 2"
             },
             new Post()
             {
                 Content = "Post 3 content",
                 Title   = "Post 3"
             }
         }
     },
         new Blog
     {
         Url    = "http://blog2.com",
         Rating = 7,
         Posts  =
         {
             new Post()
             {
                 Content = "Post 4 content",
                 Title   = "Post 4"
             },
             new Post()
             {
                 Content = "Post 5 content",
                 Title   = "Post 5"
             },
             new Post()
             {
                 Content = "Post 6 content",
                 Title   = "Post 6"
             }
         }
     },
         new Blog
     {
         Url    = "http://blog3.com",
         Rating = 4,
         Posts  =
         {
             new Post()
             {
                 Content = "Post 7 content",
                 Title   = "Post 7"
             },
             new Post()
             {
                 Content = "Post 8 content",
                 Title   = "Post 8"
             },
             new Post()
             {
                 Content = "Post 9 content",
                 Title   = "Post 9"
             }
         }
     }
         );
     context.SaveChanges();
 }
コード例 #54
0
 public CommentsController(BloggingContext bloggingContext)
 {
     _bloggingContext = bloggingContext;
 }
コード例 #55
0
        public void InsertAndSelect()
        {
            using (var context = new BloggingContext(ConnectionStringEF))
            {
                var blog = new Blog()
                {
                    Name = "Some blog name"
                };
                blog.Posts = new List<Post>();
                for (int i = 0; i < 5; i++)
                    blog.Posts.Add(new Post()
                    {
                        Content = "Some post content " + i,
                        Rating = (byte)i,
                        Title = "Some post Title " + i
                    });
                context.Blogs.Add(blog);
                context.NoColumnsEntities.Add(new NoColumnsEntity());
                context.SaveChanges();
            }

            using (var context = new BloggingContext(ConnectionStringEF))
            {
                var posts = from p in context.Posts
                            select p;
                Assert.AreEqual(5, posts.Count());
                foreach (var post in posts)
                {
                    StringAssert.StartsWith("Some post Title ", post.Title);
                }
                Assert.AreEqual(1, context.NoColumnsEntities.Count());
            }
        }
コード例 #56
0
 public BloggingController(BloggingContext bloggingContext)
 {
     _bloggingContext = bloggingContext;
 }
コード例 #57
0
 public CitiesController(BloggingContext context)
 {
     _context = context;
 }
コード例 #58
0
 public WeatherForecastController(ILogger <WeatherForecastController> logger, BloggingContext dbContext)
 {
     _logger    = logger;
     _dbContext = dbContext;
 }
コード例 #59
0
ファイル: AdminController.cs プロジェクト: TOByrne/TGOByrne
        public JsonResult RemoveUser(string username, string userid)
        {
            using (var db = new BloggingContext())
            {
                var user = (from u in db.Users
                            where u.Username.ToLower() == username.ToLower()
                            select u).First();

                //	Sanity check to make sure that the inputs haven't been
                //	fiddled with...
                var hashCheck = new Hash(username, user.UserId, user.Email).GetHash();
                if (userid != hashCheck)
                {
                    return new JsonResult
                    {
                        Data = new
                        {
                            success = false,
                            message = "It looks like the request has been tampered with."
                        }
                    };
                }

                var blogModel = new Blogs.IndexModel();
                if (blogModel.BlogExists(user.Username))
                {
                    blogModel.RemoveBlog(db, user.Username);
                }
                var userRemoved = UserModel.RemoveUser(db, user);

                return new JsonResult
                {
                    Data = userRemoved
                };
            }
        }
コード例 #60
0
 public BlogRepository(BloggingContext context)
 {
     _context = context;
 }