public async Task ExecuteAsync()

in src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs [193:352]
124 lines of code
7 McCabe index (conditional complexity)

        public async Task<RestoreResult> ExecuteAsync(CancellationToken token)
        {
            using (var telemetry = TelemetryActivity.Create(parentId: ParentId, eventName: ProjectRestoreInformation))
            {
                int httpSourcesCount = _request.DependencyProviders.RemoteProviders.Count(e => e.IsHttp);
                bool auditEnabled = AuditUtility.ParseEnableValue(
                    _request.Project.RestoreMetadata?.RestoreAuditProperties,
                    _request.Project.FilePath,
                    _logger);
                InitializeTelemetry(telemetry, httpSourcesCount, auditEnabled);

                var restoreTime = Stopwatch.StartNew();

                // Local package folders (non-sources)
                var localRepositories = new List<NuGetv3LocalRepository>
                {
                    _request.DependencyProviders.GlobalPackages
                };

                localRepositories.AddRange(_request.DependencyProviders.FallbackPackageFolders);

                var contextForProject = CreateRemoteWalkContext(_request, _logger);

                CacheFile cacheFile = null;
                bool noOpCacheFileEvaluation = false;

                using (telemetry.StartIndependentInterval(NoOpDuration))
                {
                    if (NoOpRestoreUtilities.IsNoOpSupported(_request))
                    {
                        (RestoreResult noOpResult, noOpCacheFileEvaluation, cacheFile) = await EvaluateNoOpAsync(telemetry, cacheFile, restoreTime);

                        if (noOpResult != null)
                        {
                            return noOpResult;
                        }
                    }
                }

                telemetry.TelemetryEvent[NoOpResult] = false; // Getting here means we did not no-op.

                bool success = !_request.AdditionalMessages?.Any(m => m.Level == LogLevel.Error) ?? true;
                success &= BeforeGraphResolutionValidations(httpSourcesCount);

                var packagesLockFilePath = PackagesLockFileUtilities.GetNuGetLockFilePath(_request.Project);
                PackagesLockFile packagesLockFile = null;
                (bool successfulResult, bool isLockFileValid, bool regenerateLockFile, packagesLockFilePath, packagesLockFile) = await EvaluateLockFile(
                    telemetry,
                    contextForProject,
                    packagesLockFilePath,
                    packagesLockFile,
                    success,
                    token);
                success &= successfulResult;

                AnalyzePruningResults(_request.Project, telemetry.TelemetryEvent, _logger);

                // if success == false, it generates an empty restore graph suitable to create an assets file with errors.
                // Since the graph is empty, any code that analyzes the graph (like audit) will have nothing to do.
                (successfulResult, List<RestoreTargetGraph> graphs) = await GenerateRestoreGraphsAsync(telemetry, contextForProject, success, token);
                success &= successfulResult;

                bool auditRan = false;

                if (auditEnabled)
                {
                    auditRan = await PerformAuditAsync(graphs, telemetry, token);
                }

                telemetry.StartIntervalMeasure();

                // Create assets file
                if (NuGetEventSource.IsEnabled) TraceEvents.BuildAssetsFileStart(_request.Project.FilePath);

                LockFile assetsFile = BuildAssetsFile(
                    _request.ExistingLockFile,
                    _request.Project,
                    graphs,
                    localRepositories,
                    contextForProject);

                if (NuGetEventSource.IsEnabled) TraceEvents.BuildAssetsFileStop(_request.Project.FilePath);

                telemetry.EndIntervalMeasure(GenerateAssetsFileDuration);

                telemetry.StartIntervalMeasure();

                success &= await ValidateRestoreGraphsAsync(graphs, _logger);

                // Check package compatibility
                IList<CompatibilityCheckResult> checkResults = await VerifyCompatibilityAsync(
                    _request.Project,
                    _includeFlagGraphs,
                    localRepositories,
                    assetsFile,
                    graphs,
                    _request.ValidateRuntimeAssets,
                    _logger);

                if (checkResults.Any(r => !r.Success))
                {
                    success = false;
                }

                telemetry.EndIntervalMeasure(ValidateRestoreGraphsDuration);

                // Generate Targets/Props files
                (successfulResult,
                    IEnumerable<MSBuildOutputFile> msbuildOutputFiles,
                    string assetsFilePath,
                    string cacheFilePath,
                    assetsFile,
                    graphs,
                    packagesLockFile,
                    packagesLockFilePath,
                    cacheFile) = await ProcessRestoreResultAsync(
                        telemetry,
                        localRepositories,
                        contextForProject,
                        isLockFileValid,
                        regenerateLockFile,
                        assetsFile,
                        graphs,
                        packagesLockFile,
                        packagesLockFilePath,
                        cacheFile,
                        success,
                        token);
                success &= successfulResult;

                restoreTime.Stop();

                // Create result
                var restoreResult = new RestoreResult(
                    success,
                    graphs,
                    checkResults,
                    msbuildOutputFiles,
                    assetsFile,
                    _request.ExistingLockFile,
                    assetsFilePath,
                    cacheFile,
                    cacheFilePath,
                    packagesLockFilePath,
                    packagesLockFile,
                    dependencyGraphSpecFilePath: NoOpRestoreUtilities.GetPersistedDGSpecFilePath(_request),
                    dependencyGraphSpec: _request.DependencyGraphSpec,
                    _request.ProjectStyle,
                    restoreTime.Elapsed)
                {
                    AuditRan = auditRan,
                    DidDGHashChange = !noOpCacheFileEvaluation
                };

                telemetry.TelemetryEvent[UpdatedAssetsFile] = restoreResult._isAssetsFileDirty.Value;
                telemetry.TelemetryEvent[UpdatedMSBuildFiles] = restoreResult._dirtyMSBuildFiles.Value.Count > 0;

                return restoreResult;
            }
        }