C# Solution类代码示例

        internal async Task RemoveAllRenameAnnotationsAsync(IEnumerable<DocumentId> documentWithRenameAnnotations, AnnotationTable<RenameAnnotation> annotationSet, CancellationToken cancellationToken)
        {
            foreach (var documentId in documentWithRenameAnnotations)
            {
                if (_renamedSpansTracker.IsDocumentChanged(documentId))
                {
                    var document = _newSolution.GetDocument(documentId);
                    var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

                    // For the computeReplacementToken and computeReplacementNode functions, use 
                    // the "updated" node to maintain any annotation removals from descendants.
                    var newRoot = root.ReplaceSyntax(
                        nodes: annotationSet.GetAnnotatedNodes(root),
                        computeReplacementNode: (original, updated) => annotationSet.WithoutAnnotations(updated, annotationSet.GetAnnotations(updated).ToArray()),
                        tokens: annotationSet.GetAnnotatedTokens(root),
                        computeReplacementToken: (original, updated) => annotationSet.WithoutAnnotations(updated, annotationSet.GetAnnotations(updated).ToArray()),
                        trivia: SpecializedCollections.EmptyEnumerable<SyntaxTrivia>(),
                        computeReplacementTrivia: null);

                    _intermediateSolutionContainingOnlyModifiedDocuments = _intermediateSolutionContainingOnlyModifiedDocuments.WithDocumentSyntaxRoot(documentId, newRoot, PreservationMode.PreserveIdentity);
                }
            }

            _newSolution = _intermediateSolutionContainingOnlyModifiedDocuments;
        }

        /// <summary>
        /// this gives you SymbolTreeInfo for a metadata
        /// </summary>
        public static async Task<SymbolTreeInfo> GetInfoForMetadataReferenceAsync(
            Solution solution,
            PortableExecutableReference reference,
            bool loadOnly,
            CancellationToken cancellationToken)
        {
            var metadata = reference.GetMetadata();
            if (metadata == null)
            {
                return null;
            }

            // Find the lock associated with this piece of metadata.  This way only one thread is
            // computing a symbol tree info for a particular piece of metadata at a time.
            var gate = s_metadataIdToGate.GetValue(metadata.Id, s_metadataIdToGateCallback);
            using (await gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
            {
                cancellationToken.ThrowIfCancellationRequested();

                SymbolTreeInfo info;
                if (s_metadataIdToInfo.TryGetValue(metadata.Id, out info))
                {
                    return info;
                }

                info = await LoadOrCreateMetadataSymbolTreeInfoAsync(
                    solution, reference, loadOnly, cancellationToken: cancellationToken).ConfigureAwait(false);
                if (info == null && loadOnly)
                {
                    return null;
                }

                return s_metadataIdToInfo.GetValue(metadata.Id, _ => info);
            }
        }

        public PluginList()
        {
            InitializeComponent();

            _logger = new Logger();

            _dte = Package.GetGlobalService(typeof(DTE)) as DTE;
            if (_dte == null)
                return;

            _solution = _dte.Solution;
            if (_solution == null)
                return;

            _events = _dte.Events;
            var windowEvents = _events.WindowEvents;
            windowEvents.WindowActivated += WindowEventsOnWindowActivated;
            _solutionEvents = _events.SolutionEvents;
            _solutionEvents.BeforeClosing += BeforeSolutionClosing;
            _solutionEvents.BeforeClosing += SolutionBeforeClosing;
            _solutionEvents.ProjectAdded += SolutionProjectAdded;
            _solutionEvents.ProjectRemoved += SolutionProjectRemoved;
            _solutionEvents.ProjectRenamed += SolutionProjectRenamed;

            SelectedAssemblyItem.PropertyChanged += SelectedAssemblyItem_PropertyChanged;
        }

            public override Task NewSolutionSnapshotAsync(Solution solution, CancellationToken cancellationToken)
            {
                // check whether we are good to report total symbol numbers
                if (_symbolCountByProjectMap == null || _symbolCountByProjectMap.Count < solution.ProjectIds.Count || string.IsNullOrEmpty(solution.FilePath))
                {
                    return SpecializedTasks.EmptyTask;
                }

                if (_solutionId != null && _solutionId != solution.Id)
                {
                    ReportCount();
                    return SpecializedTasks.EmptyTask;
                }

                _solutionId = solution.Id;
                foreach (var projectId in solution.ProjectIds)
                {
                    if (!_symbolCountByProjectMap.ContainsKey(projectId))
                    {
                        return SpecializedTasks.EmptyTask;
                    }
                }

                ReportCount();
                return SpecializedTasks.EmptyTask;
            }

            public SymbolLocationNavigableItem(
                Solution solution,
                ISymbol symbol,
                Location location)
            {
                _solution = solution;
                _symbol = symbol;
                _location = location;

                _lazyDisplayName = new Lazy<string>(() =>
                {
                    var symbolDisplayService = this.Document.Project.LanguageServices.GetService<ISymbolDisplayService>();

                    switch (symbol.Kind)
                    {
                        case SymbolKind.NamedType:
                            return symbolDisplayService.ToDisplayString(_symbol, s_shortFormatWithModifiers);

                        case SymbolKind.Method:
                            return _symbol.IsStaticConstructor()
                                ? symbolDisplayService.ToDisplayString(_symbol, s_shortFormatWithModifiers)
                                : symbolDisplayService.ToDisplayString(_symbol, s_shortFormat);

                        default:
                            return symbolDisplayService.ToDisplayString(_symbol, s_shortFormat);
                    }
                });
            }

        private static async Task FindReferencesInServiceProcessAsync(
            SymbolAndProjectId symbolAndProjectId,
            Solution solution,
            IStreamingFindReferencesProgress progress,
            IImmutableSet<Document> documents,
            CancellationToken cancellationToken)
        {
            var client = await solution.Workspace.GetRemoteHostClientAsync(cancellationToken).ConfigureAwait(false);
            if (client == null)
            {
                await FindReferencesInCurrentProcessAsync(
                    symbolAndProjectId, solution, progress, documents, cancellationToken).ConfigureAwait(false);
                return;
            }

            // Create a callback that we can pass to the server process to hear about the 
            // results as it finds them.  When we hear about results we'll forward them to
            // the 'progress' parameter which will then upate the UI.
            var serverCallback = new ServerCallback(solution, progress, cancellationToken);

            using (var session = await client.CreateCodeAnalysisServiceSessionAsync(
                solution, serverCallback, cancellationToken).ConfigureAwait(false))
            {
                await session.InvokeAsync(
                    nameof(IRemoteSymbolFinder.FindReferencesAsync),
                    SerializableSymbolAndProjectId.Dehydrate(symbolAndProjectId),
                    documents?.Select(SerializableDocumentId.Dehydrate).ToArray()).ConfigureAwait(false);
            }
        }

 public void TestMethod(string ratingsString, string candyString)
 {
     var ratings = JsonConvert.DeserializeObject<int[]>(ratingsString);
     var expectedResult = JsonConvert.DeserializeObject<int[]>(candyString).Sum();
     var result = new Solution().Candy(ratings);
     Assert.AreEqual(expectedResult, result);
 }

		public SolutionPackageRepository2 (Solution solution)
			: this (
				solution,
				new SharpDevelopPackageRepositoryFactory (),
				PackageManagementServices.Options)
		{
		}

    static void Main(string[] args)
    {
        Solution s = new Solution();

        int[] TestCase = new int[6] {1,3,6,4,1,2};
        Console.WriteLine(s.solution(TestCase));
    }

 public void TestMethod(string s, string wordDictString, string expectedResultsString)
 {
     var wordDict = new HashSet<string>(wordDictString.Split());
     var expectedResults = expectedResultsString.Split('|').OrderBy(str => str).ToArray();
     var results = new Solution().WordBreak(s, wordDict).OrderBy(str => str).ToArray();
     Assert.AreEqual(string.Join("|", expectedResults), string.Join("|", results));
 }

        public void DoMutation(double probability, Solution solution)
        {
            XReal x = new XReal(solution);

            for (int var = 0; var < solution.DecisionVariables.Length; var++)
            {
                if (PseudoRandom.Instance().NextDouble() < probability)
                {
                    double rand = PseudoRandom.Instance().NextDouble();
                    double tmp = (rand - 0.5)*_perturbation;

                    tmp += x.GetValue(var);

                    if (tmp < x.GetLowerBound(var))
                    {
                        tmp = x.GetLowerBound(var);
                    }
                    else if (tmp > x.GetUpperBound(var))
                    {
                        tmp = x.GetUpperBound(var);
                    }

                    x.SetValue(var, tmp);
                }
            }
        }

        public IList<Dependency> MergeAndResolveDependencies(Solution soln, Project proj)
        {
            try {
                var wishes = new List<Wish>();
                wishes.AddRange(soln.GetAllWishes());
                wishes.AddRange(proj.GetAllWishes());

                if (Log.IsTraceEnabled()) {
                    Log.Trace("merged wishes=\n" + String.Join("\n",wishes));
                }
                ValidateAll(wishes);

                //now the fun begins. Resolve transitive deps, find closest versions
                //TODO:resolve for all but pick only what the current project needs
                //TODO:keep the calculated cache for how long? how to decide when to recalc all?
                var resolver = new WishDependencyResolver(DepsCache);
                var deps = resolver.Resolve(wishes);

                var projWishes = proj.GetAllWishes();
                //TODO:now line up with deps? to get copy to and additional info added?

                return deps;
            } catch (Exception e) {
                throw new ResolverException("Error trying to resolve dependencies for project " + proj + " and solution " + soln, e);
            }
        }

 public void TestMethod(string input, string expectedResultString)
 {
     var expectedResult = JsonConvert.DeserializeObject<List<int>>(expectedResultString);
     expectedResult.Sort();
     var result = new Solution().DiffWaysToCompute(input).OrderBy(x => x);
     Assert.AreEqual(JsonConvert.SerializeObject(expectedResult), JsonConvert.SerializeObject(result));
 }

		public RestoreAndCheckForUpdatesAction (Solution solution)
		{
			this.solution = solution;
			packageManagementEvents = PackageManagementServices.PackageManagementEvents;

			solutionManager = PackageManagementServices.Workspace.GetSolutionManager (solution);
			nugetProjects = solutionManager.GetNuGetProjects ().ToList ();

			if (AnyProjectsUsingPackagesConfig ()) {
				restoreManager = new PackageRestoreManager (
					solutionManager.CreateSourceRepositoryProvider (),
					solutionManager.Settings,
					solutionManager
				);
			}

			if (AnyProjectsUsingProjectJson ()) {
				buildIntegratedRestorer = new MonoDevelopBuildIntegratedRestorer (
					solutionManager.CreateSourceRepositoryProvider (),
					solutionManager.Settings);
			}

			if (AnyNuGetAwareProjects ()) {
				nugetAwareRestorer = new NuGetAwareProjectPackageRestoreManager (solutionManager);
			}
		}

        public TemporaryWorkspace(Solution solution)
            : base(RoslynServices.HostServices, workspaceKind: TemporaryWorkspace.WorkspaceKind_TemporaryWorkspace)
        {
            Options = Options.WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0);

            this.SetCurrentSolution(solution);
        }