コード例 #1
0
        public async Task RemovesSqlComposite()
        {
            var toDelete = SqlCompositeIds.Take(5).ToList();

            using (var db = new woodmanContext())
            {
                var entities = await db.EfCoreTestChild
                               .Join(toDelete)
                               .ToListAsync();

                Assert.NotEmpty(entities);
            }

            using (var db = new woodmanContext())
            {
                var result = await db.EfCoreTestChild
                             .Where(e => e.Name.Contains(nameof(BulkRemoveTests)))
                             .BulkRemoveAsync(toDelete);

                Assert.Equal(5, result);
            }

            using (var db = new woodmanContext())
            {
                var entities = await db.EfCoreTestChild
                               .Join(toDelete)
                               .ToListAsync();

                Assert.Empty(entities);
            }
        }
コード例 #2
0
        public async Task JoinsByCompositeKeySql()
        {
            var expectedIds = SqlCompositeIds.Take(5).ToList();

            List <object[]> actualIds;

            using (var db = new woodmanContext())
            {
                actualIds = await db.EfCoreTestChild
                            .Join(expectedIds)
                            .Select(e => new object[] { e.Id, e.EfCoreTestId })
                            .ToListAsync();
            }

            Assert.Equal(expectedIds.Count, actualIds.Count);

            foreach (var expected in expectedIds)
            {
                Assert.Contains(expected, actualIds);
            }
        }
コード例 #3
0
        public async Task UpdatesSqlComposite()
        {
            var toUpdate = SqlCompositeIds.Take(2)
                           .ToDictionary(key => key, value => DateTime.UtcNow.AddDays(3));

            using (var db = new woodmanContext())
            {
                var result = await db.EfCoreTestChild.BulkUpdateAsync(toUpdate.Select(x => x.Key), id => new EfCoreTestChild
                {
                    ModifiedDate = toUpdate[id]
                });

                Assert.Equal(toUpdate.Count, result);
            }

            using (var db = new woodmanContext())
            {
                var updated = await db.EfCoreTestChild
                              .Join(toUpdate.Select(y => y.Key))
                              .ToListAsync();

                Assert.Equal(toUpdate.Count, updated.Count);

                foreach (var u in updated)
                {
                    var keyExists = toUpdate.Keys.Any(k => Enumerable.SequenceEqual(new object[] { u.Id, u.EfCoreTestId }, k));

                    Assert.True(keyExists);

                    var expected = toUpdate.First(x => Enumerable.SequenceEqual(new object[] { u.Id, u.EfCoreTestId }, x.Key)).Value;
                    var actual   = u.ModifiedDate;

                    Assert.Equal(expected.ToString("G"), actual.ToString("G"));
                }
            }
        }