C# Dictionary.Except方法代码示例

        public void Except()
        {
            var dict = new Dictionary<int, string>();
            dict.Add(1, "one");
            dict.Add(2, "two");
            dict.Add(3, "three");

            Assert.AreEqual("([1,one],[2,two])", dict.Except(3).Print());
            Assert.AreEqual("([2,two])", dict.Except(1, 3).Print());
            Assert.AreEqual("([1,one],[2,two],[3,three])", dict.Except(57).Print());
        }

        static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromPaths)
        {
            string[] created = importedAssets.Except (Watcher.allAssets).ToArray ();
            string[] modified = importedAssets.Except (created).ToArray ();

            Dictionary<string, string> allMoved = new Dictionary<string, string> ();
            for (int i = 0; i < movedAssets.Length; i++) {
                allMoved.Add (movedAssets [i], movedFromPaths [i]);
            }

            // Renamed to, renamed from
            Dictionary<string, string> renamed =
                (from m in allMoved
                 where (Path.GetDirectoryName (m.Key)) == (Path.GetDirectoryName (m.Value))
                 select m).ToDictionary (p => p.Key, p => p.Value);

            Dictionary<string, string> moved = allMoved.Except (renamed).ToDictionary (p => p.Key, p => p.Value);

            // Dispatch asset events to available watchers
            foreach (Watcher w in Watcher.allWatchers) {
                w.InvokeEventForPaths (created, w.onAssetCreated);
                w.InvokeEventForPaths (deletedAssets, w.onAssetDeleted);
                w.InvokeEventForPaths (modified, w.onAssetModified);
                w.InvokeMovedEventForPaths (renamed, w.onAssetRenamed);
                w.InvokeMovedEventForPaths (moved, w.onAssetMoved);
            }

            // Update asset paths cache
            Watcher.allAssets = AssetDatabase.GetAllAssetPaths ();
        }

        public void TestMethod2()
        {
            var dictionary = new Dictionary<string, int>();

            WordCounter text = new WordCounter(string.Empty);
            text.Count();
            Assert.IsTrue(!dictionary.Except(text.GetDictionary()).Any(), "Error");
        }

        public void ExceptNoEqualityComparer_SameKeyInSecondDict_RemovesDuplicateKeyValuePair()
        {
            var first = new Dictionary<int, int> { { 2, 3 }, { 3, 5 } };
            var second = new SortedList<int, int> { { 3, 2 }, { 4, 7 } };

            var expected = 1;
            var actual = first.Except(second).Count;
            Assert.AreEqual(expected, actual);
        }

        public void ExceptDefaultEqualityComparer_SameKeyDifferentValues_KeepsKeyValuePairWithMatchingKey()
        {
            var first = new Dictionary<int, int> { { 2, 3 }, { 3, 5 } };
            var second = new SortedList<int, int> { { 3, 2 }, { 4, 7 } };

            var expected = 2;
            var actual = first.Except(second, EqualityComparer<KeyValuePair<int, int>>.Default).Count;
            Assert.AreEqual(expected, actual);
        }

        public Dictionary<string, SqlColumnType> GetFieldTypes(string tablename, Dictionary<string, object> example)
        {
            if (!TableExists(tablename))
                return null;

            var types = _items.First(i => i.Name == tablename).Types;
            var extras = example.Except(types.Keys).SelectVals(v => SqlTypeConversion.GetSqlType(v));
            var res = extras.Union(types);
            return res;
        }

        public void TestMethod3()
        {
            var dictionary = new Dictionary<string, int>
                              {
                                  { "123", 2 },
                                  { "21312", 1 },
                                  { "2452", 1 }
                              };

            WordCounter text = new WordCounter("21312 2452 123 123!!$$%#$^&$%");
            text.Count();
            Assert.IsTrue(!dictionary.Except(text.GetDictionary()).Any(), "Error");
        }

        public static void CreateTable(this IDBModifier meta, string tablename, Dictionary<string, object> instance)
        {
            var taxonomyTypes = meta.Taxonomy == null ?
                new Dictionary<string, SqlColumnType>() :
                meta.Taxonomy.GetFieldTypes(tablename, instance);

            taxonomyTypes = taxonomyTypes ?? new Dictionary<string, SqlColumnType>();

            var missingTypes = instance.Except(taxonomyTypes.Keys)
                .SelectVals(v => SqlTypeConversion.GetSqlType(v));

            var fieldTypes = missingTypes.Union(taxonomyTypes);

            meta.CreateTable(tablename, fieldTypes);
        }

        public override string _getCreateTableSql(string schema, string table, Dictionary<string, SqlColumnType> fieldTypes)
        {
            // Strip off the primary key if it was supplied in fields - we'll make it ourselves
            var datafields = fieldTypes.Except(table + "Id");
            var fieldList = _fieldDefinitions(datafields);

            var sql = String.Format(@"CREATE TABLE `{1}`
            (
                {1}Id int NOT NULL AUTO_INCREMENT PRIMARY KEY,
                {2}
            )",
               schema, table, fieldList);

            return sql;
        }

        public void TestMethod1()
        {
            var dictionary = new Dictionary<string, int>
                              {
                                  { "is", 2 },
                                  { "this", 2 },
                                  { "a", 1 },
                                  { "and", 1 },
                                  { "so", 1 },
                                  { "statement", 1 }
                              };

            WordCounter text = new WordCounter("This is a statement, and so is this.");
            text.Count();
            Assert.IsTrue(!dictionary.Except(text.GetDictionary()).Any(), "Error");
        }

 private void SplitByRack(Dictionary<int, int> smpPlasmaSlices)
 {
     int totalSliceCnt = smpPlasmaSlices.Count;
     while (smpPlasmaSlices.Any())
     {
         int remaining = smpPlasmaSlices.Count;
         int splitted = totalSliceCnt - remaining;
         var tmpPlasmaSlices = smpPlasmaSlices.Take(Math.Min(remaining, 16)).ToDictionary(x => x.Key, x => x.Value);
         allRackSmpPlasmaSlices.Add(tmpPlasmaSlices);
         var tmpPackageInfos = CreatePackInfo(tmpPlasmaSlices);
         allPackageExpectedInfos.Add(new Dictionary<Point, string>(tmpPackageInfos));
         allPackageScannedInfos.Add(new Dictionary<Point, string>());
         smpPlasmaSlices = smpPlasmaSlices.Except(tmpPlasmaSlices).ToDictionary(x => x.Key, x => x.Value);
     }
     ChangeRackIndex(0);
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="schema"></param>
        /// <param name="table"></param>
        /// <param name="fieldTypes">A mapping of the fieldname to .NET type of the fields</param>
        /// <returns></returns>
        public virtual string _getCreateTableSql(string schema, string table, Dictionary<string, SqlColumnType> fieldTypes)
        {
            // Strip off the primary key if it was supplied in fields - we'll make it ourselves
            var datafields = fieldTypes.Except(table + "Id");
            var fieldList = _fieldDefinitions(datafields);

            var sql = String.Format(@"CREATE TABLE [{0}].[{1}]
            (
                {1}Id int NOT NULL IDENTITY (1,1) PRIMARY KEY,
                {2}
            ) ON [PRIMARY]",
               schema, table, fieldList);

            return sql;
        }

        public void GetInternalKeys()
        {
            downloader.Pages["http://myhost:222/api/rules/search?f=internalKey&ps=" + int.MaxValue + "&repositories=fxcop"] = "{\"total\":2,\"p\":1,\"ps\":10,\"rules\":[{\"key\":\"fxcop:My_Own_FxCop_Rule\"},{\"key\":\"fxcop:UriParametersShouldNotBeStrings\",\"internalKey\":\"CA1054\"}]}";
            var expected = new Dictionary<string, string>();
            expected["fxcop:UriParametersShouldNotBeStrings"] = "CA1054";
            var actual = ws.GetInternalKeys("fxcop");

            Assert.AreEqual(true, expected.Count == actual.Count && !expected.Except(actual).Any());
        }

        public void GetProperties()
        {
            // This test includes a regression scenario for SONARMSBRU-187:
            // Requesting properties for project:branch should return branch-specific data

            // Check that properties are correctly defaulted as well as branch-specific
            downloader.Pages["http://myhost:222/api/properties?resource=foo+bar"] = "[{\"key\": \"sonar.property1\",\"value\": \"value1\"},{\"key\": \"sonar.property2\",\"value\": \"value2\"}]";
            downloader.Pages["http://myhost:222/api/properties?resource=foo+bar%3AaBranch"] = "[{\"key\": \"sonar.property1\",\"value\": \"anotherValue1\"},{\"key\": \"sonar.property2\",\"value\": \"anotherValue2\"}]";

            // default
            var expected1 = new Dictionary<string, string>();
            expected1["sonar.property1"] = "value1";
            expected1["sonar.property2"] = "value2";
            expected1["sonar.cs.msbuild.testProjectPattern"] = SonarProperties.DefaultTestProjectPattern;
            var actual1 = ws.GetProperties("foo bar");

            Assert.AreEqual(true, expected1.Count == actual1.Count && !expected1.Except(actual1).Any());

            // branch specific
            var expected2 = new Dictionary<string, string>();
            expected2["sonar.property1"] = "anotherValue1";
            expected2["sonar.property2"] = "anotherValue2";
            expected2["sonar.cs.msbuild.testProjectPattern"] = SonarProperties.DefaultTestProjectPattern;
            var actual2 = ws.GetProperties("foo bar", "aBranch");

            Assert.AreEqual(true, expected2.Count == actual2.Count && !expected2.Except(actual2).Any());
        }

 public void TC13_VerifyDrainWashStepFunctionality()
 {
     Thread.Sleep(2000);
     if (Page.WasherGroupPage.WasherGroupTableGrid.Rows.Count > 1)
     {
         Thread.Sleep(1000);
         Page.WasherGroupPage.WasherGroupTableGrid.SelectedRows(setWasherType)[0].GetButtonControls()[4].DeskTopMouseClick();
         Page.WasherGroupPage.TabFormula.DeskTopMouseClick();
         Thread.Sleep(1000);
         Page.WasherGroupPage.WasherGroupFormulaTabelGrid.Rows[1].GetButtonControls()[4].DeskTopMouseClick();
         Thread.Sleep(1000);
         if (Page.WasherGroupPage.WashStepsTableGrid.Rows.Count > 1)
         {
             //Verifying the conditions.
             Thread.Sleep(1000);
             for (int k = 1; k <= Page.WasherGroupPage.WashStepsTableGrid.Rows.Count; k++)
             {
                 Thread.Sleep(1000);
                 if (Page.WasherGroupPage.WashStepsTableGrid.Rows[k].GetColumnValues()[2].ToString() == "Drain")
                 {
                     Dictionary<string, string> ActualDrainWashStep = new Dictionary<string, string>();
                     Dictionary<string, string> ExpectedDrainWashStep = new Dictionary<string, string>();
                     ExpectedDrainWashStep.Add("Operations", "Drain");
                     ExpectedDrainWashStep.Add("Run Time (mm:ss)", "02:00");
                     ExpectedDrainWashStep.Add("Temperature (oF)", "1");
                     ExpectedDrainWashStep.Add("Water Level (inches)", "0");
                     //Need to find the list of row values to compare and fail or pass the test case....with this finish...
                     ReadOnlyCollection<string> getValues = Page.WasherGroupPage.WashStepsTableGrid.Rows[k].GetColumnValues();
                     ActualDrainWashStep.Add("Operations", getValues[2]);
                     ActualDrainWashStep.Add("Run Time (mm:ss)", getValues[3]);
                     ActualDrainWashStep.Add("Temperature (oF)", getValues[4]);
                     ActualDrainWashStep.Add("Water Level (inches)", getValues[5]);
                     List<KeyValuePair<string,string>> diffCount = ExpectedDrainWashStep.Except(ActualDrainWashStep).ToList();
                     if(diffCount.Count > 0)
                     {
                         Assert.Fail("Drain Wash Steps are not matching with Expected.Actual - " + diffCount[0]);
                     }
                     break;
                 }
             }
         }
         else
         {
             Assert.Fail("Drain WashStep not found in the gridview: Expected- Drain WashStep to be display while adding new WashStep");
         }
     }
     else
     {
         Assert.Fail("Washer Group data not found in grid page");
     }
 }