C# System.AsEnumerable方法代码示例

 public void ByValue_Enumerable_CanDisallowNull()
 {
     var data = new[]
     {
         new EmailAddress { Value = FakeData.Email(), },
         new EmailAddress { Value = FakeData.Email(), },
         new EmailAddress { Value = FakeData.Email(), },
     };
     data.AsEnumerable().ByValue(data[0].Value, false).ShouldNotBeNull();
     var exception = Assert.Throws<InvalidOperationException>(() =>
         data.AsEnumerable().ByValue(FakeData.Email(), false));
     Assert.NotNull(exception);
     exception.Message.IndexOf("Sequence contains no matching element", StringComparison.CurrentCulture)
         .ShouldEqual(0);
 }

        private static void Merge(System.Data.DataTable DestTable, System.Data.DataTable SrcTable)
        {
            string pk = DestTable.PrimaryKey[0].ColumnName;

            System.Data.DataRow[] pkChangedRows = DestTable.AsEnumerable().Where(p => p.RowState == DataRowState.Modified
                && !p[pk, DataRowVersion.Original].Equals(p[pk, DataRowVersion.Current])).ToArray();

            try
            {
                //When PK has changed, move row to added state
                foreach (System.Data.DataRow dr in pkChangedRows)
                {
                    dr.AcceptChanges();
                    dr.SetAdded();
                }

                DestTable.Merge(SrcTable);

            }
            finally
            {
                //And when back to modifyed
                foreach (System.Data.DataRow dr in pkChangedRows)
                {
                    dr.AcceptChanges();
                    dr.SetModified();
                }
            }

        }

        public void ToList_GivenAMultiDimensionalArray_ReturnsAnArrayWithAllItemsInIt()
        {
            var array = new[,] { { 1, 2 }, { 3, 4 } };

            var list = array.AsEnumerable();

            CollectionAssert.AreEquivalent(list, array);
        }

        static void Main(string[] args)
        {
            var a = new[] { new Program() };

            // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2014/201401/20140120/avg

            var w = a.AsEnumerable().Where(x => x.Visible);

        }

 public void ByName_Enumerable_CanAllowNull()
 {
     var data = new[]
     {
         new User { Name = FakeData.String() },
         new User { Name = FakeData.String() },
         new User { Name = FakeData.String() },
     };
     data.AsEnumerable().ByName(FakeData.String()).ShouldBeNull();
 }

 public void ByValue_Enumerable_CanAllowNull()
 {
     var data = new[]
     {
         new EmailAddress { Value = FakeData.Email(), },
         new EmailAddress { Value = FakeData.Email(), },
         new EmailAddress { Value = FakeData.Email(), },
     };
     data.AsEnumerable().ByValue(FakeData.Email()).ShouldBeNull();
 }

 public void ByTicket_Enumerable_CanAllowNull()
 {
     var data = new[]
     {
         new EmailVerification { Ticket = FakeData.String(), },
         new EmailVerification { Ticket = FakeData.String(), },
         new EmailVerification { Ticket = FakeData.String(), },
     };
     data.AsEnumerable().ByTicket(FakeData.String()).ShouldBeNull();
 }

        public void Get_All_Persons()
        {
            // Arrange
            var allPersons = new[]
            {
                new Library.Entity.Person {FirstName = "John", LastName = "McClung", MiddleName = "Paul", Notes = "Crazy as can be"},
                new Library.Entity.Person {FirstName = "Katie", LastName = "McClung", MiddleName = "Elane", Notes = "Just as crazy as John"}
            };
            var service = Mock.Of<IPersonService>(s => s.All(null, null, "LastName") == allPersons.AsEnumerable());
            var controller = new PersonController(service);

            // Act
            var result = controller.Get(null, null, "LastName") as OkNegotiatedContentResult<IEnumerable<Web.Models.Person>>;
            var personModels = allPersons.AsEnumerable().ToModel();

            // Assert
            Assert.NotNull(result);
            Assert.True(personModels.SequenceEqual(result.Content));
        }

        public void ToList_GivenAMultiDimensionalArray_ReturnsAnArrayWithAllItemsInTheCorrectOrder()
        {
            var array = new[,] { { 1, 2 }, { 3, 4 } };

            var list = array.AsEnumerable().ToList();

            Assert.AreEqual(list[0], array[0, 0]);
            Assert.AreEqual(list[1], array[1, 0]);
            Assert.AreEqual(list[2], array[0, 1]);
            Assert.AreEqual(list[3], array[1, 1]);
        }

        public void ByUserId_Enumerable_CanDisallowNull()
        {
            var userId = FakeData.Id();
            var otherUserId1 = FakeData.Id(userId);
            var otherUserId2 = FakeData.Id(userId, otherUserId1);
            var data = new[]
            {
                new LocalMembership { User = new ProxiedUser(otherUserId1), },
                new LocalMembership { User = new ProxiedUser(userId), },
                new LocalMembership { User = new ProxiedUser(otherUserId2), },
            };
            data.AsEnumerable().ByUserId(data[1].User.Id, false).ShouldNotBeNull();

            var otherUserId3 = FakeData.Id(userId, otherUserId1, otherUserId2);
            var exception = Assert.Throws<InvalidOperationException>(() =>
                data.AsEnumerable().ByUserId(otherUserId3, false));
            Assert.NotNull(exception);
            exception.Message.IndexOf("Sequence contains no matching element", StringComparison.CurrentCulture)
                .ShouldEqual(0);
        }

        public void ConstructorShouldAddFileTypeFilters()
        {
            // arrange
            var expected = new[] { "*.*", "*.txt", "*.csv" };

            // act
            var interaction = new SelectFolderInteraction( "", expected );
            var actual = interaction.FileTypeFilter;

            // assert
            Assert.Equal( expected.AsEnumerable(), actual.AsEnumerable() );
        }

        public void When_the_sequence_contains_more_than_a_single_point_the_Min_point_equals_the_element_wise_minimum_of_the_sequence()
        {
            var points = new[] {
                new Point(1, 2, 3),
                new Point(2, 3, 4),
                new Point(4, 5, 6),
                new Point(-1, 3, 7),
                new Point(0, 0, -10)
            };

            var aabb = AxisAlignedBoundingBox.FromPoints(points.AsEnumerable());

            Assert.Equal(new Point(-1, 0, -10), aabb.Min);
        }

        public void ByUserId_Enumerable_CanAllowNull()
        {
            var userId = FakeData.Id();
            var otherUserId1 = FakeData.Id(userId);
            var otherUserId2 = FakeData.Id(userId, otherUserId1);
            var data = new[]
            {
                new LocalMembership { User = new ProxiedUser(otherUserId1), },
                new LocalMembership { User = new ProxiedUser(userId), },
                new LocalMembership { User = new ProxiedUser(otherUserId2), },
            };

            var otherUserId3 = FakeData.Id(userId, otherUserId1, otherUserId2);
            data.AsEnumerable().ByUserId(otherUserId3).ShouldBeNull();
        }

        public void TestTryEnumerable()
        {
            var expected = new[] {2, 3, 4, 5, 6};
            var initital = new[] {1, 2, 3, 4, 5};
            var @try = Try.Attempt(() => initital.AsEnumerable()).ToTryEnumerable();
            var temp =
                (from num in @try
                select num + 1)
                .Out();
            var result = temp.Match(
                success: BasicFunctions.Identity,
                failure: ex => Enumerable.Empty<int>());

            Assert.IsTrue(TestUtils.AreEqual(result, expected));

        }

        public void ByUserId_Enumerable_FiltersByUserId()
        {
            var userId = FakeData.Id();
            var data = new[]
            {
                new RemoteMembership { UserId = FakeData.Id(canNotBe: userId), },
                new RemoteMembership { UserId = userId, },
                new RemoteMembership { UserId = userId, },
                new RemoteMembership { UserId = FakeData.Id(canNotBe: userId), },
                new RemoteMembership { UserId = FakeData.Id(canNotBe: userId), },
                new RemoteMembership { UserId = userId, },
            };

            var results = data.AsEnumerable().ByUserId(userId).ToArray();
            results.ShouldNotBeNull();
            results.Length.ShouldEqual(3);
        }