コード例 #1
0
        protected override int OnExecute()
        {
            var projectFile      = ProjectReader.GetProject(ProjectArgument.Value);
            var targetFrameworks = projectFile
                                   .GetTargetFrameworks()
                                   .Select(frameworkInformation => frameworkInformation.FrameworkName);

            NuGetFramework framework;

            if (!TryResolveFramework(targetFrameworks, out framework))
            {
                // Could not resolve framework for dispatch. Error was reported, exit early.
                return(0);
            }

#if NETCOREAPP1_0
            int exitCode;
            if (PackageOnlyResolveTagHelpersRunCommand.TryPackageOnlyTagHelperResolution(
                    AssemblyNamesArgument,
                    ProtocolOption,
                    BuildBasePathOption,
                    ConfigurationOption,
                    projectFile,
                    framework,
                    out exitCode))
            {
                return(exitCode);
            }
#endif

            var dispatchArgs = new List <string>
            {
                CommandName,
            };

            dispatchArgs.AddRange(AssemblyNamesArgument.Values);

            if (ProtocolOption.HasValue())
            {
                dispatchArgs.Add("--protocol");
                dispatchArgs.Add(ProtocolOption.Value());
            }

            var dispatchCommand = DotnetToolDispatcher.CreateDispatchCommand(
                dispatchArgs,
                framework,
                ConfigurationOption.Value(),
                outputPath: null,
                buildBasePath: BuildBasePathOption.Value(),
                projectDirectory: projectFile.ProjectDirectory);

            using (var errorWriter = new StringWriter())
            {
                var commandExitCode = dispatchCommand
                                      .ForwardStdErr(errorWriter)
                                      .ForwardStdOut()
                                      .Execute()
                                      .ExitCode;

                if (commandExitCode != 0)
                {
                    ReportError(
                        string.Format(
                            CultureInfo.CurrentCulture,
                            Resources.FailedToExecuteRazorTooling,
                            errorWriter.ToString()));
                }

                return(0);
            }
        }
コード例 #2
0
        public static bool TryPackageOnlyTagHelperResolution(
            CommandArgument assemblyNamesArgument,
            CommandOption protocolOption,
            CommandOption buildBasePathOption,
            CommandOption configurationOption,
            Project project,
            NuGetFramework framework,
            out int exitCode)
        {
            exitCode = 0;

            if (framework.IsDesktop())
            {
                return(false);
            }

            var runtimeIdentifiers = RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers();
            var projectContext     = new ProjectContextBuilder()
                                     .WithProject(project)
                                     .WithTargetFramework(framework)
                                     .WithRuntimeIdentifiers(runtimeIdentifiers)
                                     .Build();
            var configuration = configurationOption.Value() ?? Constants.DefaultConfiguration;

            var projectRuntimeOutputPath = projectContext.GetOutputPaths(configuration, buildBasePathOption.Value())?.RuntimeOutputPath;
            var projectAssemblyName      = project.GetCompilerOptions(framework, configuration).OutputName;
            var projectOutputAssembly    = Path.Combine(projectRuntimeOutputPath, projectAssemblyName + ".dll");

            if (File.Exists(projectOutputAssembly))
            {
                // There's already build output. Dispatch to build output; this ensures dependencies have been resolved.
                return(false);
            }

            var projectLibraries = projectContext.LibraryManager.GetLibraries();
            var libraryLookup    = projectLibraries.ToDictionary(
                library => library.Identity.Name,
                library => library,
                StringComparer.Ordinal);

            foreach (var assemblyName in assemblyNamesArgument.Values)
            {
                if (!IsPackageOnly(assemblyName, libraryLookup))
                {
                    return(false);
                }
            }

            var loadContext = projectContext.CreateLoadContext(
                projectContext.RuntimeIdentifier,
                configuration: "Debug",
                outputPath: null);
            var runner = new PackageOnlyResolveTagHelpersRunCommand(loadContext)
            {
                AssemblyNamesArgument = assemblyNamesArgument,
                ProtocolOption        = protocolOption
            };

            exitCode = runner.OnExecute();

            return(true);
        }