C# List.Except方法代码示例

        public void Drivers()
        {
            var letters = new List<string>();

            for (var letter = 'D'; letter <= 'Z'; letter++)
            {
                letters.Add(letter + ":\\");
                Console.Write(letter + " ");
            }

            Console.WriteLine();

            var drives = DriveInfo.GetDrives().Select(x => x.Name);

            foreach (var drive in drives)
            {
                Console.Write(drive + " ");
            }

            Console.WriteLine();

            foreach (var l in letters.Except(drives))
            {
                Console.Write(l + " ");
            }
        }

        public void CanApplyLocalCopyOfFullMasterDataUpdate()
        {
            //Given 
            var zipStreamProcesser = new FakeZipStreamProcesser(FullMasterUpdatePath);
            var masterDataUpdater = new MasterDataUpdater(Database, zipStreamProcesser);
            
            //When
            var result = masterDataUpdater.ApplyUpdate(false, default(Stream));
            
            //Then
            CheckResult(result);
            
            var actualTableNames = new List<string>();
            var emptyTables = new List<string>();

            foreach (var entity in DatabaseConfig.GetMasteDataTypes())
            {                
                var tableName = Database.GetTableName(entity);              
                actualTableNames.Add(tableName);

                var count = Database.Count(entity);
                if (count == 0) emptyTables.Add(tableName);
            }

            var fail = CheckEmpty("Local Tables that have no rows:\n{0}", emptyTables);

            var difference = actualTableNames.Except(zipStreamProcesser.TableNames);
            fail +=  CheckEmpty("Local Tables that have no Master Data CSV File:\n{0}", difference);

            difference = zipStreamProcesser.TableNames.Except(actualTableNames);
            fail += CheckEmpty("Master Data CSV Files without Local Tables:\n {0}", difference);

            Assert.IsTrue(fail == 0, "\n\nOne or more errors occurred");
        }

        public static List<QualityProfileItem> GetDefaultQualities(params Quality[] allowed)
        {
            var qualities = new List<Quality>
            {
                Quality.SDTV,
                Quality.WEBDL480p,
                Quality.DVD,
                Quality.HDTV720p,
                Quality.HDTV1080p,
                Quality.RAWHD,
                Quality.WEBDL720p,
                Quality.Bluray720p,
                Quality.WEBDL1080p,
                Quality.Bluray1080p
            };

            if (allowed.Length == 0)
                allowed = qualities.ToArray();

            var items = qualities
                .Except(allowed)
                .Concat(allowed)
                .Select(v => new QualityProfileItem { Quality = v, Allowed = allowed.Contains(v) }).ToList();

            return items;
        }

        public void AllPropertyNames()
        {
            List<string> propertyNames = new List<string>();
            List<string> excludedNames = new List<string>();
            foreach (var file in Directory.EnumerateFiles(Path.GetFullPath(RelativePathToSchemaDir)))
            {
                if (!file.EndsWith("schema.json"))
                {
                    continue;
                }

                var contents = ReadContents(file);
                var reader = new JsonTextReader(new StringReader(contents));
                while (reader.Read())
                {
                    if (reader.TokenType != JsonToken.PropertyName) continue;
                    propertyNames.Add((string)reader.Value);
                }

                var result = JsonConvert.DeserializeObject<Schema>(contents);
                if (result.Properties != null)
                {
                    foreach (var key in result.Properties.Keys)
                    {
                        excludedNames.Add(key.ToLower());
                    }
                }
            }
            propertyNames = propertyNames.Select((p) => p.ToLower()).Distinct().ToList();
            var knownPropertyNames = typeof (Schema).GetProperties().Select((p) => p.Name.ToLower());
            propertyNames = propertyNames.Except(knownPropertyNames).Except(excludedNames)
                .Except(new[] { "$schema", "__ref__", "additionalproperties", "gltf_webgl", "gltf_detaileddescription", "gltf_enumnames", "gltf_uritype" }).ToList();
            
            CollectionAssert.AreEquivalent(new string[] {}, propertyNames);
        }

 public void given_a_string_constructs_a_correct_PackageNode(string input, string package,
     List<string> dependencies)
 {
     PackageDefinition packageDef = new PackageDefinition(input);
     Assert.AreEqual(packageDef.Package, package);
     Assert.IsFalse(dependencies.Except(packageDef.Dependencies).Any());
     Assert.IsFalse(packageDef.Dependencies.Except(dependencies).Any());
 }

 public void LogicEqualityComparerLinqExcept()
 {
     var people = new List<Person>() { _abe, _joe1, _sue, _joe2 };
     var peopleWhoAreJoe = new List<Person>() { _joe1 };
     var comparer = new LogicEqualityComparer<Person>();
     var peopleWhoAreNotJoe = people.Except(peopleWhoAreJoe, comparer);
     Assert.IsTrue(peopleWhoAreNotJoe.Count() == 2);
     Assert.IsFalse(peopleWhoAreNotJoe.Where(p => p.Name == "Joe").Any());
 }

        public void Subset()
        {
            var a = new List<int> { 1, 2, 3 };
            var b = new List<int> { 1, 2, 5, 3, 4, 3, 6 };

            var result = !a.Except(b).Any();

            Assert.IsTrue(result);
        }

 public void LogicEqualityComparerDeepLinqExcept()
 {
     var group1 = new KeyValuePair<string, List<Person>>("People", new List<Person>() { _abe });
     var group2 = new KeyValuePair<string, List<Person>>("People", new List<Person>() { _sue });
     var groups = new List<KeyValuePair<string, List<Person>>>() { group1, group2 };
     var groupsWithJoe = new List<KeyValuePair<string, List<Person>>>() { group1 };
     var groupsWithoutJoe = groups.Except(groupsWithJoe, _typedComparer);
     Assert.IsTrue(groupsWithoutJoe.Count() == 1);
     Assert.IsTrue(groupsWithoutJoe.First().Value.First().Name == "Sue");
 }

        public void ShouldNotFinishUntilAllMatchesPlayed()
        {
            var leagueSeason = A.LeagueSeason.Build();

            var fixtures = new List<Fixture>();
            leagueSeason.ScheduleFixtures(f => fixtures.Add(f));

            var allFixturesExceptLast = fixtures.Except(fixtures.Last().AsEnumerable()).ToList();
            allFixturesExceptLast.ForEach(f => leagueSeason.ApplyResult(A.MatchResult.ForFixture(f).Build()));

            Assert.That(leagueSeason.IsFinished, Is.False);
        }

        public void Difference()
        {
            var a = new List<int> { 1, 2, 3 };
            var b = new List<int> { 1, 2, 3, 4, 5, 6 };

            var results = b.Except(a).ToList();

            Assert.AreEqual(3, results.Count());
            Assert.AreEqual(4, results[0]);
            Assert.AreEqual(5, results[1]);
            Assert.AreEqual(6, results[2]);
        }

        public void Categories_That_Do_Not_Have_Certain_Products()
        {
            List<int> prod = new List<int>() { 1, 2 };

            var expected = "[{\"CategoryID\":2},{\"CategoryID\":3},{\"CategoryID\":4},{\"CategoryID\":5},{\"CategoryID\":6},{\"CategoryID\":7},{\"CategoryID\":8}]";

            ICorrectness result = this.tester.TestQuery(
                context =>
                    from
                        cat in context.Categories
                    where
                        prod.Except(cat.Products.Select(x => x.ProductID))
                            .Count() > 0
                    select
                        cat.CategoryID,
                expected);

            Assert.IsTrue(result.Check());
        }

        public void RandomShufflerShouldNotChangeReffernceTypeListContentOtherThanOrder()
        {
            const int listSize = 4;
            var list = new List<string>()
            {
                "This",
                "is",
                "a",
                "Test"
            };
            var listClone = new List<string>(list);
            ListRandomShuffler.InPlaceShuffle(list);

            var dupCount = list.Intersect(listClone).ToList().Count;
            Assert.AreEqual(dupCount, listSize);

            bool hasDifference = list.Except(listClone).ToList().Any();
            Assert.IsFalse(hasDifference);
        }

        public void CanCompareOldIdsWithNewIdsAndReturnNewIdsOnly()
        {
            // Arrange
            const int expectedNewId = 12345;

            var oldIds = new List<int> { 123, 1234, 123456, 1233 };
            var newIds = new List<int> { 123, 1234, expectedNewId };

            // Act
            var mergedIds = new List<int>();
            mergedIds.AddRange(oldIds);
            mergedIds.AddRange(newIds);

            IList<int> except = mergedIds.Except(oldIds).ToList();

            // Assert
            Assert.That(except, Is.Not.Null);
            Assert.That(except.Count(), Is.EqualTo(1));
            Assert.That(except.SingleOrDefault(), Is.EqualTo(expectedNewId));
        }

        public void StringebisShedareba()
        {
            var l1 = new List<string>(){"a", "b", "c", "d", "f"};
            var l2 = new List<string>(){"d", "c","b"};
            List<string> lNew = l1.Except(l2, StringComparer.OrdinalIgnoreCase).ToList();

            Console.WriteLine(lNew.Count);
            //Intersect saertoebi, Except - gansxvaveba
            foreach (var variable in lNew)
            {
                Console.WriteLine(variable);
            }

            Console.WriteLine(" **************************** ");
            lNew.Remove("f");
            foreach (var variable in lNew)
            {
                Console.WriteLine(variable);
            }
        }

        public void The_dependencies_should_include_referenced_complex_types_and_groups()
        {
            RelationshipsSchemaVisitor visitor = new RelationshipsSchemaVisitor(_schemaSet);
            visitor.Visit(_schema);

            List<Edge<string>> expectedList = new List<Edge<string>>
                                                  {
                                                      new Edge<string>("equity", "EquityAsset"),
                                                      new Edge<string>("EquityAsset", "ExchangeTraded"),
                                                      new Edge<string>("ExchangeTraded", "UnderlyingAsset"),
                                                      new Edge<string>("UnderlyingAsset", "IdentifiedAsset"),
                                                      new Edge<string>("IdentifiedAsset", "Asset"),
                                                      new Edge<string>("ExchangeTraded", "ExchangeIdentifier.model"),
                                                      new Edge<string>("equity", "underlyingAsset"),
                                                      new Edge<string>("underlyingAsset", "Asset"),
                                                  };

            var missingEdges = expectedList.Except(visitor.NodeEdges);
            Assert.That(visitor.NodeEdges, Is.EquivalentTo(expectedList));
        }