C# ImmutableDictionary.Remove方法代码示例

 public void ImmutableDictionary_RemoveTest()
 {
     Dictionary<int, string> dictionary = new Dictionary<int, string>
     {
         {1,"asaas"},
         {2,"sasas"},
         {3,"tak"}
     };
     ImmutableDictionary<int, string> test = new ImmutableDictionary<int, string>(dictionary);
     test.Remove(2);
 }

                    public DiagnosticAnalyzerMap(HostAnalyzerManager analyzerManager, string language, ImmutableDictionary<DiagnosticAnalyzer, StateSet> analyzerMap)
                    {
                        // hold directly on to compiler analyzer
                        _compilerAnalyzer = analyzerManager.GetCompilerDiagnosticAnalyzer(language);

                        // in test case, we might not have the compiler analyzer.
                        if (_compilerAnalyzer == null)
                        {
                            _map = analyzerMap;
                            return;
                        }

                        _compilerStateSet = analyzerMap[_compilerAnalyzer];

                        // hold rest of analyzers
                        _map = analyzerMap.Remove(_compilerAnalyzer);
                    }

        private static void RemoveSyntaxTreeFromDeclarationMapAndTable(
            SyntaxTree tree,
            ref ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMap,
            ref DeclarationTable declTable,
            ref bool referenceDirectivesChanged)
        {
            Lazy<RootSingleNamespaceDeclaration> lazyRoot;
            if (!declMap.TryGetValue(tree, out lazyRoot))
            {
                throw new ArgumentException(string.Format(CSharpResources.SyntaxTreeNotFoundTo, tree), "trees");
            }

            declTable = declTable.RemoveRootDeclaration(lazyRoot);
            declMap = declMap.Remove(tree);
            referenceDirectivesChanged = referenceDirectivesChanged || tree.HasReferenceDirectives();
        }

                private static ImmutableDictionary<DocumentId, SyntaxTree> RemoveOldTreeFromMap(
                    Compilation newCompilation,
                    ImmutableDictionary<DocumentId, SyntaxTree> oldMap, ImmutableDictionary<DocumentId, SyntaxTree> map,
                    CancellationToken cancellationToken)
                {
                    foreach (var oldIdAndTree in oldMap)
                    {
                        cancellationToken.ThrowIfCancellationRequested();

                        // check whether new compilation still has the tree
                        if (newCompilation.ContainsSyntaxTree(oldIdAndTree.Value))
                        {
                            continue;
                        }

                        var documentId = oldIdAndTree.Key;

                        // check whether the tree has been updated
                        SyntaxTree currentTree;
                        if (!map.TryGetValue(documentId, out currentTree) ||
                            currentTree != oldIdAndTree.Value)
                        {
                            continue;
                        }

                        // this has been removed
                        map = map.Remove(documentId);
                    }

                    return map;
                }

        private void ParseDocumentAsync(Document document)
        {
            var cancellationTokenSource = new CancellationTokenSource();

            using (_stateLock.DisposableWrite())
            {
                _workMap = _workMap.Add(document.Id, cancellationTokenSource);
            }

            var cancellationToken = cancellationTokenSource.Token;

            var task = _taskScheduler.ScheduleTask(
                () => document.GetSyntaxTreeAsync(cancellationToken),
                "BackgroundParser.ParseDocumentAsync",
                cancellationToken);

            // Always ensure that we mark this work as done from the workmap.
            task.SafeContinueWith(
                _ =>
                {
                    using (_stateLock.DisposableWrite())
                    {
                        _workMap = _workMap.Remove(document.Id);
                    }
                }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);
        }

 public void Add_Test()
 {
 	Dictionary<int, string> _dictionary = new Dictionary<int, string>
     {
         {1, "aabb"},
         {2, "bbcc"},
         {3, "ccdd"}
     };
 	ImmutableDictionary<int, string> _immutableDictionary = new ImmutableDictionary<int, string>(_dictionary);
 	_immutableDictionary.Remove(new KeyValuePair<int, string>(1, "aabb"));
 }

        private ImmutableDictionary<String, ParameterSet> RemoveCandidateIfParamDefault(
            ImmutableDictionary<String, ParameterSet> candidates,
            Parameter parameter
        )
        {
            if (parameter.IsCommonParameter)
            {
                Logger.Debug(
                    "Skipping common parameter {Parameter}",
                    parameter.Name
                );

                return candidates;
            }

            if (parameter.HasDefaultValue(Target))
            {
                Logger.Debug(
                    "Parameter {Parameter} has default value, removing {ParameterSetName} from candidates",
                    parameter.Name,
                    parameter.ParameterSetName
                );

                return candidates.Remove(
                    parameter.ParameterSetName
                );
            }

            Logger.Debug(
                "Parameter {Parameter} has a value set, keeping {ParameterSetName} as a candidate",
                parameter.Name,
                parameter.ParameterSetName
            );

            return candidates;
        }