Add support for net451 projects.

- Previous to this any net451 projects that Razor-tooling would attempt to load would explode.
- We now dispatch to ourselves within a users output to ensure that all dependencies are matched up correctly.
- Added framework/configuration options to enable dispatching to properly find where our counterpart exists in a projects output.
- Renamed bin directory option to build base path. With dispatching logic VisualStudio can't easily determine the users RID which is required for an output path to dotnet.
- Replaced `AssemblyLoadContext` logic with `Assembly.Load` since we now always invoke ourselves in an environment where `Assembly.Load` is accurate. This way logic in the desktop process and non-desktop processes are identical.
- Broke the `ResolveTagHelpersCommand` into 3 pieces so we can determine dispatching logic at the Program.Main level. This was required to use pieces of the `DotnetToolDispatcher`.
- We utilize DotnetToolDispatcher for dispatch logic, this also ensures that we never have mismatched references for dotnet-razor-tooling in tools/dependencies sections.
- Worked around an issue in `ProjectDependenciesCommandFactory` where configuration isn't properly flowed from constructor to `Create` method: https://github.com/dotnet/cli/issues/2512
- Worked around an issue where binding redirects were not being created for executable desktop packages. This involved upping Newtonsoft.Json to 8.0.3: https://github.com/dotnet/cli/issues/2505

#55

Author: N. Taylor Mullen

src/dotnet-razor-tooling/Internal/AssemblyLoadContextTagHelperTypeResolver.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.Runtime.Loader;
 using dotnet_razor_tooling;
 using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.Compilation.TagHelpers;
@@ -17,14 +16,9 @@ public class AssemblyTagHelperDescriptorResolver
         private readonly TagHelperDescriptorFactory _descriptorFactory = new TagHelperDescriptorFactory(designTime: true);
         private readonly TagHelperTypeResolver _tagHelperTypeResolver;
 
-        public AssemblyTagHelperDescriptorResolver(AssemblyLoadContext loadContext)
+        public AssemblyTagHelperDescriptorResolver()
         {
-            if (loadContext == null)
-            {
-                throw new ArgumentNullException(nameof(loadContext));
-            }
-
-            _tagHelperTypeResolver = new AssemblyLoadContextTagHelperTypeResolver(loadContext);
+            _tagHelperTypeResolver = new TagHelperTypeResolver();
         }
 
         public static int DefaultProtocolVersion { get; } = 1;

src/dotnet-razor-tooling/Internal/AssemblyTagHelperDescriptorResolver.cs

@@ -3,6 +3,8 @@
 
 using System;
 using System.Globalization;
+using dotnet_razor_tooling;
+using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.CommandLineUtils;
 
 namespace Microsoft.AspNetCore.Tooling.Razor.Internal
@@ -23,10 +25,20 @@ internal static void Register(CommandLineApplication app)
                 {
                     var pluginProtocol = AssemblyTagHelperDescriptorResolver.DefaultProtocolVersion;
                     var clientProtocolString = clientProtocolArgument.Value;
-                    var clientProtocol = int.Parse(clientProtocolString);
+                    int clientProtocol;
+                    if (!int.TryParse(clientProtocolString, out clientProtocol))
+                    {
+                        Reporter.Error.WriteLine(
+                            string.Format(
+                                CultureInfo.CurrentCulture,
+                                Resources.CouldNotParseProvidedProtocol,
+                                clientProtocolString));
+                        return 1;
+                    }
+
                     var resolvedProtocol = ResolveProtocol(clientProtocol, pluginProtocol);
 
-                    Console.WriteLine(resolvedProtocol.ToString(CultureInfo.InvariantCulture));
+                    Reporter.Output.WriteLine(resolvedProtocol.ToString(CultureInfo.InvariantCulture));
 
                     return 0;
                 });

src/dotnet-razor-tooling/Internal/ResolveProtocolCommand.cs

@@ -0,0 +1,83 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Razor;
+using Microsoft.AspNetCore.Razor.Compilation.TagHelpers;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.Extensions.CommandLineUtils;
+using Newtonsoft.Json;
+
+namespace Microsoft.AspNetCore.Tooling.Razor.Internal
+{
+    public abstract class ResolveTagHelpersCommandBase
+    {
+        protected const string CommandName = "resolve-taghelpers";
+
+        protected CommandOption ProtocolOption { get; set; }
+
+        protected CommandArgument AssemblyNamesArgument { get; set; }
+
+        public static void Register<TResolveTagHelpersCommand>(CommandLineApplication app) where
+            TResolveTagHelpersCommand : ResolveTagHelpersCommandBase, new()
+        {
+            var command = new TResolveTagHelpersCommand();
+            command.Register(app);
+        }
+
+        protected virtual void Configure(CommandLineApplication config)
+        {
+        }
+
+        protected abstract int OnExecute();
+
+        protected void ReportResults(IEnumerable<TagHelperDescriptor> descriptors, IEnumerable<RazorError> errors)
+        {
+            var resolvedResult = new ResolvedTagHelperDescriptorsResult
+            {
+                Descriptors = descriptors,
+                Errors = errors
+            };
+
+            var serializedResult = JsonConvert.SerializeObject(resolvedResult, Formatting.Indented);
+
+            Reporter.Output.WriteLine(serializedResult);
+        }
+
+        protected void ReportError(string message)
+        {
+            var error = new RazorError(message, SourceLocation.Zero, length: 0);
+            ReportResults(descriptors: null, errors: new[] { error });
+        }
+
+        private void Register(CommandLineApplication app)
+        {
+            app.Command(CommandName, config =>
+            {
+                config.Description = "Resolves TagHelperDescriptors in the specified assembly(s).";
+                config.HelpOption("-?|-h|--help");
+                ProtocolOption = config.Option(
+                    "-p|--protocol",
+                    "Protocol to resolve TagHelperDescriptors with.",
+                    CommandOptionType.SingleValue);
+
+                Configure(config);
+
+                AssemblyNamesArgument = config.Argument(
+                    "[assemblyName]",
+                    "Assembly name to resolve TagHelperDescriptors in.",
+                    multipleValues: true);
+
+                config.OnExecute((Func<int>)OnExecute);
+            });
+        }
+
+        private class ResolvedTagHelperDescriptorsResult
+        {
+            public IEnumerable<TagHelperDescriptor> Descriptors { get; set; }
+
+            public IEnumerable<RazorError> Errors { get; set; }
+        }
+    }
+}