diff --git a/src/Build.UnitTests/BackEnd/AssemblyTaskFactory_Tests.cs b/src/Build.UnitTests/BackEnd/AssemblyTaskFactory_Tests.cs
index ffd6ed0068e..fa6883c1c34 100644
--- a/src/Build.UnitTests/BackEnd/AssemblyTaskFactory_Tests.cs
+++ b/src/Build.UnitTests/BackEnd/AssemblyTaskFactory_Tests.cs
@@ -32,10 +32,7 @@ public class AssemblyTaskFactory_Tests
         /// </summary>
         private AssemblyLoadInfo _loadInfo;
 
-        /// <summary>
-        /// The loaded type from the initialized task factory.
-        /// </summary>
-        private LoadedType _loadedType;
+        private Dictionary<string, string> _taskFactoryIdentityParameters = null;
 
         /// <summary>
         /// Initialize a task factory
@@ -55,8 +52,8 @@ public void NullLoadInfo()
         {
             Assert.Throws<ArgumentNullException>(() =>
             {
-                AssemblyTaskFactory taskFactory = new AssemblyTaskFactory();
-                taskFactory.InitializeFactory(null, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, null, false, null, ElementLocation.Create("NONE"), String.Empty);
+                AssemblyTaskFactory taskFactory = new();
+                taskFactory.InitializeFactory(null, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, ref _taskFactoryIdentityParameters, false, null, ElementLocation.Create("NONE"), String.Empty);
             }
            );
         }
@@ -69,7 +66,7 @@ public void NullTaskName()
             Assert.Throws<InvalidProjectFileException>(() =>
             {
                 AssemblyTaskFactory taskFactory = new AssemblyTaskFactory();
-                taskFactory.InitializeFactory(_loadInfo, null, new Dictionary<string, TaskPropertyInfo>(), string.Empty, null, false, null, ElementLocation.Create("NONE"), String.Empty);
+                taskFactory.InitializeFactory(_loadInfo, null, new Dictionary<string, TaskPropertyInfo>(), string.Empty, ref _taskFactoryIdentityParameters, false, null, ElementLocation.Create("NONE"), String.Empty);
             }
            );
         }
@@ -82,7 +79,7 @@ public void EmptyTaskName()
             Assert.Throws<InvalidProjectFileException>(() =>
             {
                 AssemblyTaskFactory taskFactory = new AssemblyTaskFactory();
-                taskFactory.InitializeFactory(_loadInfo, String.Empty, new Dictionary<string, TaskPropertyInfo>(), string.Empty, null, false, null, ElementLocation.Create("NONE"), String.Empty);
+                taskFactory.InitializeFactory(_loadInfo, String.Empty, new Dictionary<string, TaskPropertyInfo>(), string.Empty, ref _taskFactoryIdentityParameters, false, null, ElementLocation.Create("NONE"), String.Empty);
             }
            );
         }
@@ -95,7 +92,7 @@ public void GoodTaskNameButNotInInfo()
             Assert.Throws<InvalidProjectFileException>(() =>
             {
                 AssemblyTaskFactory taskFactory = new AssemblyTaskFactory();
-                taskFactory.InitializeFactory(_loadInfo, "RandomTask", new Dictionary<string, TaskPropertyInfo>(), string.Empty, null, false, null, ElementLocation.Create("NONE"), String.Empty);
+                taskFactory.InitializeFactory(_loadInfo, "RandomTask", new Dictionary<string, TaskPropertyInfo>(), string.Empty, ref _taskFactoryIdentityParameters, false, null, ElementLocation.Create("NONE"), String.Empty);
             }
            );
         }
@@ -180,7 +177,7 @@ public void CreatableByTaskFactoryNullTaskName()
         [Fact]
         public void CreatableByTaskFactoryMatchingIdentity()
         {
-            IDictionary<string, string> factoryIdentityParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            Dictionary<string, string> factoryIdentityParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
             factoryIdentityParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.currentRuntime);
             factoryIdentityParameters.Add(XMakeAttributes.architecture, XMakeAttributes.MSBuildArchitectureValues.currentArchitecture);
 
@@ -200,7 +197,7 @@ public void CreatableByTaskFactoryMatchingIdentity()
         [Fact]
         public void CreatableByTaskFactoryMismatchedIdentity()
         {
-            IDictionary<string, string> factoryIdentityParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            Dictionary<string, string> factoryIdentityParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
             factoryIdentityParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.clr2);
             factoryIdentityParameters.Add(XMakeAttributes.architecture, XMakeAttributes.MSBuildArchitectureValues.currentArchitecture);
 
@@ -342,7 +339,7 @@ public void VerifyMatchingUsingTaskParametersDontLaunchTaskHost1()
             ITask createdTask = null;
             try
             {
-                IDictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                 taskParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.any);
                 taskParameters.Add(XMakeAttributes.architecture, XMakeAttributes.MSBuildArchitectureValues.any);
 
@@ -375,7 +372,7 @@ public void VerifyMatchingUsingTaskParametersDontLaunchTaskHost2()
             ITask createdTask = null;
             try
             {
-                IDictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                 taskParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.any);
                 taskParameters.Add(XMakeAttributes.architecture, XMakeAttributes.GetCurrentMSBuildArchitecture());
 
@@ -408,7 +405,7 @@ public void VerifyMatchingParametersDontLaunchTaskHost()
             ITask createdTask = null;
             try
             {
-                IDictionary<string, string> factoryParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> factoryParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                 factoryParameters.Add(XMakeAttributes.runtime, XMakeAttributes.GetCurrentMSBuildRuntime());
 
                 SetupTaskFactory(factoryParameters, false /* don't want task host */);
@@ -444,7 +441,7 @@ public void VerifyNonmatchingUsingTaskParametersLaunchTaskHost()
             ITask createdTask = null;
             try
             {
-                IDictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                 taskParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.clr2);
                 taskParameters.Add(XMakeAttributes.architecture, XMakeAttributes.MSBuildArchitectureValues.any);
 
@@ -510,7 +507,7 @@ public void VerifyNonmatchingParametersLaunchTaskHost()
             ITask createdTask = null;
             try
             {
-                IDictionary<string, string> factoryParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> factoryParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                 factoryParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.clr2);
 
                 SetupTaskFactory(factoryParameters, false /* don't want task host */);
@@ -575,7 +572,7 @@ public void VerifyExplicitlyLaunchTaskHostEvenIfParametersMatch1()
             ITask createdTask = null;
             try
             {
-                IDictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                 taskParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.any);
                 taskParameters.Add(XMakeAttributes.architecture, XMakeAttributes.MSBuildArchitectureValues.any);
 
@@ -641,7 +638,7 @@ public void VerifyExplicitlyLaunchTaskHostEvenIfParametersMatch2()
         public void VerifySameFactoryCanGenerateDifferentTaskInstances()
         {
             ITask createdTask = null;
-            IDictionary<string, string> factoryParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            Dictionary<string, string> factoryParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
             factoryParameters.Add(XMakeAttributes.runtime, XMakeAttributes.MSBuildRuntimeValues.any);
             factoryParameters.Add(XMakeAttributes.architecture, XMakeAttributes.MSBuildArchitectureValues.any);
 
@@ -694,7 +691,7 @@ public void VerifySameFactoryCanGenerateDifferentTaskInstances()
         /// Abstract out the creation of the new AssemblyTaskFactory with default task, and 
         /// with some basic validation.
         /// </summary>
-        private void SetupTaskFactory(IDictionary<string, string> factoryParameters, bool explicitlyLaunchTaskHost)
+        private void SetupTaskFactory(Dictionary<string, string> factoryParameters, bool explicitlyLaunchTaskHost)
         {
             _taskFactory = new AssemblyTaskFactory();
 #if FEATURE_ASSEMBLY_LOCATION
@@ -702,8 +699,8 @@ private void SetupTaskFactory(IDictionary<string, string> factoryParameters, boo
 #else
             _loadInfo = AssemblyLoadInfo.Create(typeof(TaskToTestFactories).GetTypeInfo().Assembly.FullName, null);
 #endif
-            _loadedType = _taskFactory.InitializeFactory(_loadInfo, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, factoryParameters, explicitlyLaunchTaskHost, null, ElementLocation.Create("NONE"), String.Empty);
-            Assert.True(_loadedType.Assembly.Equals(_loadInfo)); // "Expected the AssemblyLoadInfo to be equal"
+            TypeInformation typeInfo = _taskFactory.InitializeFactory(_loadInfo, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, ref factoryParameters, explicitlyLaunchTaskHost, null, ElementLocation.Create("NONE"), String.Empty);
+            typeInfo.LoadInfo.ShouldBe(_loadInfo, "Expected the AssemblyLoadInfo to be equal");
         }
 
         #endregion
diff --git a/src/Build.UnitTests/BackEnd/TaskExecutionHost_Tests.cs b/src/Build.UnitTests/BackEnd/TaskExecutionHost_Tests.cs
index 4482dda9bfa..1567868e60e 100644
--- a/src/Build.UnitTests/BackEnd/TaskExecutionHost_Tests.cs
+++ b/src/Build.UnitTests/BackEnd/TaskExecutionHost_Tests.cs
@@ -1170,7 +1170,7 @@ private void InitializeHost(bool throwOnExecute)
             TaskBuilderTestTask.TaskBuilderTestTaskFactory taskFactory = new TaskBuilderTestTask.TaskBuilderTestTaskFactory();
             taskFactory.ThrowOnExecute = throwOnExecute;
             string taskName = "TaskBuilderTestTask";
-            (_host as TaskExecutionHost)._UNITTESTONLY_TaskFactoryWrapper = new TaskFactoryWrapper(taskFactory, loadedType, taskName, null);
+            (_host as TaskExecutionHost)._UNITTESTONLY_TaskFactoryWrapper = new TaskFactoryWrapper(taskFactory, new TypeInformation(loadedType), taskName, null);
             _host.InitializeForTask
                 (
                 this,
diff --git a/src/Build/BackEnd/TaskExecutionHost/TaskExecutionHost.cs b/src/Build/BackEnd/TaskExecutionHost/TaskExecutionHost.cs
index fd733207795..600eb2a81c5 100644
--- a/src/Build/BackEnd/TaskExecutionHost/TaskExecutionHost.cs
+++ b/src/Build/BackEnd/TaskExecutionHost/TaskExecutionHost.cs
@@ -257,12 +257,12 @@ void ITaskExecutionHost.InitializeForTask(IBuildEngine2 buildEngine, TargetLoggi
 
             TaskRequirements requirements = TaskRequirements.None;
 
-            if (_taskFactoryWrapper.TaskFactoryLoadedType.HasSTAThreadAttribute())
+            if (_taskFactoryWrapper.TaskFactoryTypeInformation.HasSTAThreadAttribute)
             {
                 requirements |= TaskRequirements.RequireSTAThread;
             }
 
-            if (_taskFactoryWrapper.TaskFactoryLoadedType.HasLoadInSeparateAppDomainAttribute())
+            if (_taskFactoryWrapper.TaskFactoryTypeInformation.HasLoadInSeparateAppDomainAttribute)
             {
                 requirements |= TaskRequirements.RequireSeparateAppDomain;
 
@@ -299,7 +299,7 @@ bool ITaskExecutionHost.InitializeForBatch(TaskLoggingContext loggingContext, It
             if (_resolver == null)
             {
                 _resolver = new TaskEngineAssemblyResolver();
-                _resolver.Initialize(_taskFactoryWrapper.TaskFactoryLoadedType.Assembly.AssemblyFile);
+                _resolver.Initialize(_taskFactoryWrapper.TaskFactoryTypeInformation.LoadInfo.AssemblyFile);
                 _resolver.InstallHandler();
             }
 #endif
@@ -899,15 +899,18 @@ private TaskFactoryWrapper FindTaskInRegistry(IDictionary<string, string> taskId
                     }
                 }
 
+                string taskFactoryFullName = returnClass.TaskFactory is AssemblyTaskFactory atf ? atf.TaskName : returnClass.TaskFactory.TaskType.FullName;
                 // Map to an intrinsic task, if necessary.
-                if (String.Equals(returnClass.TaskFactory.TaskType.FullName, "Microsoft.Build.Tasks.MSBuild", StringComparison.OrdinalIgnoreCase))
+                if (String.Equals(taskFactoryFullName, "Microsoft.Build.Tasks.MSBuild", StringComparison.OrdinalIgnoreCase))
                 {
-                    returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(MSBuild)), new LoadedType(typeof(MSBuild), AssemblyLoadInfo.Create(typeof(TaskExecutionHost).GetTypeInfo().Assembly.FullName, null)), _taskName, null);
+                    AssemblyLoadInfo loadInfo = AssemblyLoadInfo.Create(typeof(TaskExecutionHost).GetTypeInfo().Assembly.FullName, null);
+                    returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(MSBuild)), new TypeInformation(new LoadedType(typeof(MSBuild), loadInfo)), _taskName, null);
                     _intrinsicTasks[_taskName] = returnClass;
                 }
-                else if (String.Equals(returnClass.TaskFactory.TaskType.FullName, "Microsoft.Build.Tasks.CallTarget", StringComparison.OrdinalIgnoreCase))
+                else if (String.Equals(taskFactoryFullName, "Microsoft.Build.Tasks.CallTarget", StringComparison.OrdinalIgnoreCase))
                 {
-                    returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(CallTarget)), new LoadedType(typeof(CallTarget), AssemblyLoadInfo.Create(typeof(TaskExecutionHost).GetTypeInfo().Assembly.FullName, null)), _taskName, null);
+                    AssemblyLoadInfo loadInfo = AssemblyLoadInfo.Create(typeof(TaskExecutionHost).GetTypeInfo().Assembly.FullName, null);
+                    returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(CallTarget)), new TypeInformation(new LoadedType(typeof(CallTarget), loadInfo)), _taskName, null);
                     _intrinsicTasks[_taskName] = returnClass;
                 }
             }
@@ -1073,30 +1076,15 @@ out parameterSet
                 else
                 {
                     // flag an error if we find a parameter that has no .NET property equivalent
-                    if (_taskFactoryWrapper.TaskFactoryLoadedType.LoadedAssembly is null)
-                    {
-                        _taskLoggingContext.LogError
-                            (
-                            new BuildEventFileInfo( parameterLocation ),
-                            "UnexpectedTaskAttribute",
-                            parameterName,
-                            _taskName,
-                            _taskFactoryWrapper.TaskFactoryLoadedType.Type.Assembly.FullName,
-                            _taskFactoryWrapper.TaskFactoryLoadedType.Type.Assembly.Location
-                            );
-                    }
-                    else
-                    {
-                        _taskLoggingContext.LogError
-                            (
-                            new BuildEventFileInfo( parameterLocation ),
-                            "UnexpectedTaskAttribute",
-                            parameterName,
-                            _taskName,
-                            _taskFactoryWrapper.TaskFactoryLoadedType.LoadedAssembly.FullName,
-                            _taskFactoryWrapper.TaskFactoryLoadedType.LoadedAssembly.Location
-                            );
-                    }
+                    _taskLoggingContext.LogError
+                        (
+                        new BuildEventFileInfo( parameterLocation ),
+                        "UnexpectedTaskAttribute",
+                        parameterName,
+                        _taskName,
+                        _taskFactoryWrapper.TaskFactoryTypeInformation.LoadInfo.AssemblyName,
+                        _taskFactoryWrapper.TaskFactoryTypeInformation.LoadInfo.AssemblyLocation
+                        );
                 }
             }
             catch (AmbiguousMatchException)
diff --git a/src/Build/Instance/ReflectableTaskPropertyInfo.cs b/src/Build/Instance/ReflectableTaskPropertyInfo.cs
index 571ba866933..6518e901fdd 100644
--- a/src/Build/Instance/ReflectableTaskPropertyInfo.cs
+++ b/src/Build/Instance/ReflectableTaskPropertyInfo.cs
@@ -17,14 +17,19 @@ namespace Microsoft.Build.Execution
     internal class ReflectableTaskPropertyInfo : TaskPropertyInfo
     {
         /// <summary>
-        /// The reflection-produced PropertyInfo.
+        /// The name of the generated tasks.
         /// </summary>
-        private PropertyInfo _propertyInfo;
+        private readonly string taskName;
 
         /// <summary>
-        /// The type of the generated tasks.
+        /// Function for accessing information about a property on a task via its name.
         /// </summary>
-        private Type _taskType;
+        private readonly Func<string, BindingFlags, PropertyInfo> getProperty;
+
+        /// <summary>
+        /// The reflection-produced PropertyInfo.
+        /// </summary>
+        private PropertyInfo _propertyInfo;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ReflectableTaskPropertyInfo"/> class.
@@ -35,7 +40,16 @@ internal ReflectableTaskPropertyInfo(TaskPropertyInfo taskPropertyInfo, Type tas
             : base(taskPropertyInfo.Name, taskPropertyInfo.PropertyType, taskPropertyInfo.Output, taskPropertyInfo.Required)
         {
             ErrorUtilities.VerifyThrowArgumentNull(taskType, nameof(taskType));
-            _taskType = taskType;
+            getProperty = taskType.GetProperty;
+            taskName = taskType.FullName;
+        }
+
+        internal ReflectableTaskPropertyInfo(TaskPropertyInfo taskPropertyInfo, TypeInformation typeInformation)
+            : base(taskPropertyInfo.Name, taskPropertyInfo.PropertyType, taskPropertyInfo.Output, taskPropertyInfo.Required)
+        {
+            ErrorUtilities.VerifyThrowArgumentNull(typeInformation, nameof(typeInformation));
+            getProperty = typeInformation.GetProperty;
+            taskName = typeInformation.TypeName;
         }
 
         /// <summary>
@@ -52,6 +66,15 @@ internal ReflectableTaskPropertyInfo(PropertyInfo propertyInfo)
             _propertyInfo = propertyInfo;
         }
 
+        internal ReflectableTaskPropertyInfo(TypeInformation.PropertyInfo propertyInfo) :
+            base(
+                propertyInfo.Name,
+                propertyInfo.PropertyType,
+                propertyInfo.OutputAttribute,
+                propertyInfo.RequiredAttribute)
+        {
+        }
+
         /// <summary>
         /// Gets or sets the reflection-produced PropertyInfo.
         /// </summary>
@@ -61,8 +84,8 @@ internal PropertyInfo Reflection
             {
                 if (_propertyInfo == null)
                 {
-                    _propertyInfo = _taskType.GetProperty(Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
-                    ErrorUtilities.VerifyThrow(_propertyInfo != null, "Could not find property {0} on type {1} that the task factory indicated should exist.", Name, _taskType.FullName);
+                    _propertyInfo = getProperty(Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
+                    ErrorUtilities.VerifyThrow(_propertyInfo != null, "Could not find property {0} on type {1} that the task factory indicated should exist.", Name, taskName);
                 }
 
                 return _propertyInfo;
diff --git a/src/Build/Instance/TaskFactories/AssemblyTaskFactory.cs b/src/Build/Instance/TaskFactories/AssemblyTaskFactory.cs
index 97d721d4352..df336e05523 100644
--- a/src/Build/Instance/TaskFactories/AssemblyTaskFactory.cs
+++ b/src/Build/Instance/TaskFactories/AssemblyTaskFactory.cs
@@ -3,9 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
-
 using Microsoft.Build.Execution;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
@@ -38,7 +38,7 @@ internal class AssemblyTaskFactory : ITaskFactory2
         /// <summary>
         /// The loaded type (type, assembly name / file) of the task wrapped by the factory
         /// </summary>
-        private LoadedType _loadedType;
+        private TypeInformation _typeInformation;
 
 #if FEATURE_APPDOMAIN
         /// <summary>
@@ -84,18 +84,39 @@ public string FactoryName
         {
             get
             {
-                return _loadedType.Assembly.AssemblyLocation;
+                return _typeInformation.LoadInfo.AssemblyLocation;
             }
         }
 
         /// <summary>
         /// Gets the type of task this factory creates.
+        /// This is only actually used in finding the TaskName immediately below this if LoadedType is not null.
+        /// The extra null checks are to avoid throwing, though it will if it cannot find the type.
         /// </summary>
         public Type TaskType
         {
-            get { return _loadedType.Type; }
+            get { return _typeInformation.LoadedType?.Type ?? Type.GetType(_typeInformation.TypeName, true, true); }
         }
 
+        /// <summary>
+        /// The name of the task.
+        /// </summary>
+        public string TaskName
+        {
+            get { return _typeInformation.LoadedType is null ? $"{_typeInformation.Namespace}.{_typeInformation.TypeName}" : TaskType.FullName; }
+        }
+
+        /// <summary>
+        /// All information known about a type. If it's loaded, that information mostly comes from the LoadedType object contained within.
+        /// If not, the information was collected in TypeLoader via System.Reflection.Metadata.
+        /// </summary>
+        public TypeInformation TypeInformation { get { return _typeInformation; } }
+
+        /// <summary>
+        /// Indicates whether this task implements IGeneratedTask. IGeneratedTask has useful methods for getting and setting properties.
+        /// </summary>
+        public bool ImplementsIGeneratedTask { get { return _typeInformation?.ImplementsIGeneratedTask ?? false; } }
+
         /// <summary>
         /// Initializes this factory for instantiating tasks with a particular inline task block.
         /// </summary>
@@ -147,14 +168,9 @@ public bool Initialize(string taskName, IDictionary<string, string> factoryIdent
         /// </summary>
         public TaskPropertyInfo[] GetTaskParameters()
         {
-            PropertyInfo[] infos = _loadedType.Type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
-            var propertyInfos = new TaskPropertyInfo[infos.Length];
-            for (int i = 0; i < infos.Length; i++)
-            {
-                propertyInfos[i] = new ReflectableTaskPropertyInfo(infos[i]);
-            }
-
-            return propertyInfos;
+            return _typeInformation.LoadedType is null ?
+                _typeInformation.Properties.Select(prop => new ReflectableTaskPropertyInfo(prop)).ToArray() :
+                _typeInformation.GetProperties(BindingFlags.Instance | BindingFlags.Public).Select(prop => new ReflectableTaskPropertyInfo(prop)).ToArray();
         }
 
         /// <summary>
@@ -250,13 +266,13 @@ public void CleanupTask(ITask task)
         /// <summary>
         /// Initialize the factory from the task registry
         /// </summary>
-        internal LoadedType InitializeFactory
+        internal TypeInformation InitializeFactory
             (
                 AssemblyLoadInfo loadInfo,
                 string taskName,
                 IDictionary<string, TaskPropertyInfo> taskParameters,
                 string taskElementContents,
-                IDictionary<string, string> taskFactoryIdentityParameters,
+                ref Dictionary<string, string> taskFactoryIdentityParameters,
                 bool taskHostFactoryExplicitlyRequested,
                 TargetLoggingContext targetLoggingContext,
                 ElementLocation elementLocation,
@@ -277,8 +293,31 @@ string taskProjectFile
             {
                 ErrorUtilities.VerifyThrowArgumentLength(taskName, nameof(taskName));
                 _taskName = taskName;
-                _loadedType = _typeLoader.Load(taskName, loadInfo);
-                ProjectErrorUtilities.VerifyThrowInvalidProject(_loadedType != null, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, String.Empty);
+
+                // If the user requested a task host but provided us with an assembly name rather than an assembly file, pretend they didn't.
+                // Finding the path to the assembly file the runtime would load without actually loading the assembly would likely be a bug farm.
+                // Also, this should be a very unusual case.
+                _typeInformation = _typeLoader.Load(taskName, loadInfo, taskHostFactoryExplicitlyRequested && (loadInfo.AssemblyFile is not null || loadInfo.AssemblyName.StartsWith("Microsoft.Build")), out TaskRuntimeInformation runtimeInformation);
+                _taskHostFactoryExplicitlyRequested = runtimeInformation.TaskHostNeeded;
+                if (runtimeInformation.Architecture is not null)
+                {
+                    taskFactoryIdentityParameters ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                    taskFactoryIdentityParameters[XMakeAttributes.architecture] = runtimeInformation.Architecture;
+                    _factoryIdentityParameters = taskFactoryIdentityParameters;
+                }
+                if (runtimeInformation.Runtime is not null)
+                {
+                    taskFactoryIdentityParameters ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                    taskFactoryIdentityParameters[XMakeAttributes.runtime] = runtimeInformation.Runtime;
+                    _factoryIdentityParameters = taskFactoryIdentityParameters;
+                }
+
+                // If the user specifically requests a code task factory, and the type wasn't already loaded, we need a way to verify that it really found a matching type. Properties is an array, so it should never be null,
+                // though it could be an empty array.
+                ProjectErrorUtilities.VerifyThrowInvalidProject(_typeInformation is not null && (_typeInformation.LoadedType != null || _typeInformation.Properties != null), elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, String.Empty);
+
+                _typeInformation.LoadInfo = loadInfo;
+                _typeInformation.TypeName ??= taskName;
             }
             catch (TargetInvocationException e)
             {
@@ -309,7 +348,7 @@ string taskProjectFile
                 ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
             }
 
-            return _loadedType;
+            return _typeInformation;
         }
 
         /// <summary>
@@ -362,7 +401,7 @@ internal ITask CreateTaskInstance(ElementLocation taskLocation, TaskLoggingConte
                     mergedParameters[XMakeAttributes.architecture] = XMakeAttributes.GetCurrentMSBuildArchitecture();
                 }
 
-                TaskHostTask task = new TaskHostTask(taskLocation, taskLoggingContext, buildComponentHost, mergedParameters, _loadedType
+                TaskHostTask task = new TaskHostTask(taskLocation, taskLoggingContext, buildComponentHost, mergedParameters, _typeInformation
 #if FEATURE_APPDOMAIN
                     , appDomainSetup
 #endif
@@ -371,17 +410,13 @@ internal ITask CreateTaskInstance(ElementLocation taskLocation, TaskLoggingConte
             }
             else
             {
-#if FEATURE_APPDOMAIN
-                AppDomain taskAppDomain = null;
-#endif
-
-                ITask taskInstance = TaskLoader.CreateTask(_loadedType, _taskName, taskLocation.File, taskLocation.Line, taskLocation.Column, new TaskLoader.LogError(ErrorLoggingDelegate)
+                ITask taskInstance = TaskLoader.CreateTask(_typeInformation, _taskName, taskLocation.File, taskLocation.Line, taskLocation.Column, new TaskLoader.LogError(ErrorLoggingDelegate)
 #if FEATURE_APPDOMAIN
                     , appDomainSetup
 #endif
                     , isOutOfProc
 #if FEATURE_APPDOMAIN
-                    , out taskAppDomain
+                    , out AppDomain taskAppDomain
 #endif
                     );
 
@@ -411,13 +446,13 @@ internal bool TaskNameCreatableByFactory(string taskName, IDictionary<string, st
             {
                 ErrorUtilities.VerifyThrowArgumentLength(taskName, "TaskName");
                 // Parameters match, so now we check to see if the task exists. 
-                return _typeLoader.ReflectionOnlyLoad(taskName, _loadedType.Assembly) != null;
+                return _typeLoader.ReflectionOnlyLoad(taskName, _typeInformation.LoadInfo) != null;
             }
             catch (TargetInvocationException e)
             {
                 // Exception thrown by the called code itself
                 // Log the stack, so the task vendor can fix their code
-                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());
+                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _typeInformation.LoadInfo.AssemblyLocation ?? _typeInformation.LoadedType.Assembly.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());
             }
             catch (ReflectionTypeLoadException e)
             {
@@ -426,20 +461,20 @@ internal bool TaskNameCreatableByFactory(string taskName, IDictionary<string, st
                 {
                     if (exception != null)
                     {
-                        targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, exception.Message);
+                        targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, _typeInformation.LoadInfo.AssemblyLocation ?? _typeInformation.LoadedType.Assembly.AssemblyLocation, exception.Message);
                     }
                 }
 
-                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);
+                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _typeInformation.LoadInfo.AssemblyLocation ?? _typeInformation.LoadedType.Assembly.AssemblyLocation, e.Message);
             }
             catch (ArgumentNullException e)
             {
                 // taskName may be null
-                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);
+                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _typeInformation.LoadInfo.AssemblyLocation ?? _typeInformation.LoadedType.Assembly.AssemblyLocation, e.Message);
             }
             catch (Exception e) when (!ExceptionHandling.NotExpectedReflectionException(e))
             {
-                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);
+                ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _typeInformation.LoadInfo.AssemblyLocation ?? _typeInformation.LoadedType.Assembly.AssemblyLocation, e.Message);
             }
 
             return false;
@@ -581,7 +616,7 @@ private static IDictionary<string, string> MergeTaskFactoryParameterSets(IDictio
 
                 if (!XMakeAttributes.TryMergeArchitectureValues(taskArchitecture, usingTaskArchitecture, out mergedArchitecture))
                 {
-                    ErrorUtilities.ThrowInternalError("How did we get two runtime values that were unmergeable?");
+                    ErrorUtilities.ThrowInternalError("How did we get two architecture values that were unmergeable?");
                 }
                 else
                 {
diff --git a/src/Build/Instance/TaskFactories/TaskHostTask.cs b/src/Build/Instance/TaskFactories/TaskHostTask.cs
index ce29ccbed30..5851fe64c08 100644
--- a/src/Build/Instance/TaskFactories/TaskHostTask.cs
+++ b/src/Build/Instance/TaskFactories/TaskHostTask.cs
@@ -74,7 +74,7 @@ internal class TaskHostTask : IGeneratedTask, ICancelableTask, INodePacketFactor
         /// <summary>
         /// The type of the task that we are wrapping.  
         /// </summary>
-        private LoadedType _taskType;
+        private TypeInformation _taskType;
 
 #if FEATURE_APPDOMAIN
         /// <summary>
@@ -124,7 +124,7 @@ internal class TaskHostTask : IGeneratedTask, ICancelableTask, INodePacketFactor
         /// <summary>
         /// Constructor
         /// </summary>
-        public TaskHostTask(IElementLocation taskLocation, TaskLoggingContext taskLoggingContext, IBuildComponentHost buildComponentHost, IDictionary<string, string> taskHostParameters, LoadedType taskType
+        public TaskHostTask(IElementLocation taskLocation, TaskLoggingContext taskLoggingContext, IBuildComponentHost buildComponentHost, IDictionary<string, string> taskHostParameters, TypeInformation taskType
 #if FEATURE_APPDOMAIN
                 , AppDomainSetup appDomainSetup
 #endif
@@ -203,16 +203,28 @@ public object GetPropertyValue(TaskPropertyInfo property)
             {
                 // If we returned an exception, then we want to throw it when we 
                 // do the get.  
-                if (value is Exception)
+                if (value is Exception eVal)
                 {
-                    throw (Exception)value;
+                    throw eVal;
                 }
 
                 return value;
             }
+            else if (_taskType.LoadedType is null)
+            {
+                switch (property.Name)
+                {
+                    case "HostObject":
+                        return this.HostObject;
+                    case "BuildEngine":
+                        return this.BuildEngine;
+                    default:
+                        throw new InternalErrorException($"{property.Name} is not a property on TaskHostTask, or else it needs to be added to its registered list of properties.");
+                }
+            }
             else
             {
-                PropertyInfo parameter = _taskType.Type.GetProperty(property.Name, BindingFlags.Instance | BindingFlags.Public);
+                PropertyInfo parameter = _taskType.GetProperty(property.Name, BindingFlags.Instance | BindingFlags.Public);
                 return parameter.GetValue(this, null);
             }
         }
@@ -244,7 +256,7 @@ public bool Execute()
             // log that we are about to spawn the task host
             string runtime = _taskHostParameters[XMakeAttributes.runtime];
             string architecture = _taskHostParameters[XMakeAttributes.architecture];
-            _taskLoggingContext.LogComment(MessageImportance.Low, "ExecutingTaskInTaskHost", _taskType.Type.Name, _taskType.Assembly.AssemblyLocation, runtime, architecture);
+            _taskLoggingContext.LogComment(MessageImportance.Low, "ExecutingTaskInTaskHost", _taskType.TypeName, _taskType.LoadInfo.AssemblyLocation ?? _taskType.LoadedType.LoadedAssembly.Location, runtime, architecture);
 
             // set up the node
             lock (_taskHostLock)
@@ -253,9 +265,7 @@ public bool Execute()
                 ErrorUtilities.VerifyThrowInternalNull(_taskHostProvider, "taskHostProvider");
             }
 
-            TaskHostConfiguration hostConfiguration =
-                new TaskHostConfiguration
-                    (
+            TaskHostConfiguration hostConfiguration = new(
                         _buildComponentHost.BuildParameters.NodeId,
                         NativeMethodsShared.GetCurrentDirectory(),
                         CommunicationsUtilities.GetEnvironmentVariables(),
@@ -268,8 +278,8 @@ public bool Execute()
                         BuildEngine.ColumnNumberOfTaskNode,
                         BuildEngine.ProjectFileOfTaskNode,
                         BuildEngine.ContinueOnError,
-                        _taskType.Type.FullName,
-                        AssemblyUtilities.GetAssemblyLocation(_taskType.Type.GetTypeInfo().Assembly),
+                        _taskType.TypeName,
+                        _taskType.Path,
                         _buildComponentHost.BuildParameters.LogTaskInputs,
                         _setParameters,
                         new Dictionary<string, string>(_buildComponentHost.BuildParameters.GlobalProperties),
@@ -465,8 +475,8 @@ private void HandleTaskHostTaskComplete(TaskHostTaskComplete taskHostTaskComplet
                 }
                 else
                 {
-                    exceptionMessageArgs = new string[] { _taskType.Type.Name,
-                        AssemblyUtilities.GetAssemblyLocation(_taskType.Type.GetTypeInfo().Assembly),
+                    exceptionMessageArgs = new string[] { _taskType.TypeName,
+                        _taskType.LoadInfo.AssemblyLocation ?? _taskType.LoadedType.LoadedAssembly.Location,
                         string.Empty };
                 }
 
@@ -558,11 +568,11 @@ private void LogErrorUnableToCreateTaskHost(HandshakeOptions requiredContext, st
 
             if (e == null)
             {
-                _taskLoggingContext.LogError(new BuildEventFileInfo(_taskLocation), "TaskHostAcquireFailed", _taskType.Type.Name, runtime, architecture, msbuildLocation);
+                _taskLoggingContext.LogError(new BuildEventFileInfo(_taskLocation), "TaskHostAcquireFailed", _taskType.TypeName, runtime, architecture, msbuildLocation);
             }
             else
             {
-                _taskLoggingContext.LogError(new BuildEventFileInfo(_taskLocation), "TaskHostNodeFailedToLaunch", _taskType.Type.Name, runtime, architecture, msbuildLocation, e.ErrorCode, e.Message);
+                _taskLoggingContext.LogError(new BuildEventFileInfo(_taskLocation), "TaskHostNodeFailedToLaunch", _taskType.TypeName, runtime, architecture, msbuildLocation, e.ErrorCode, e.Message);
             }
         }
     }
diff --git a/src/Build/Instance/TaskFactoryWrapper.cs b/src/Build/Instance/TaskFactoryWrapper.cs
index 72bf3ec5624..dea1f5c7cdb 100644
--- a/src/Build/Instance/TaskFactoryWrapper.cs
+++ b/src/Build/Instance/TaskFactoryWrapper.cs
@@ -7,6 +7,8 @@
 using Microsoft.Build.Collections;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
+using Microsoft.Build.BackEnd;
+using System.Linq;
 
 #nullable disable
 
@@ -62,13 +64,13 @@ internal sealed class TaskFactoryWrapper
         /// <summary>
         /// Creates an instance of this class for the given type.
         /// </summary>
-        internal TaskFactoryWrapper(ITaskFactory taskFactory, LoadedType taskFactoryLoadInfo, string taskName, IDictionary<string, string> factoryIdentityParameters)
+        internal TaskFactoryWrapper(ITaskFactory taskFactory, TypeInformation taskFactoryLoadInfo, string taskName, IDictionary<string, string> factoryIdentityParameters)
         {
             ErrorUtilities.VerifyThrowArgumentNull(taskFactory, nameof(taskFactory));
             ErrorUtilities.VerifyThrowArgumentLength(taskName, nameof(taskName));
             _taskFactory = taskFactory;
             _taskName = taskName;
-            TaskFactoryLoadedType = taskFactoryLoadInfo;
+            TaskFactoryTypeInformation = taskFactoryLoadInfo;
             _factoryIdentityParameters = factoryIdentityParameters;
         }
 
@@ -79,11 +81,7 @@ internal TaskFactoryWrapper(ITaskFactory taskFactory, LoadedType taskFactoryLoad
         /// <summary>
         /// Load information about the task factory itself
         /// </summary>
-        public LoadedType TaskFactoryLoadedType
-        {
-            get;
-            private set;
-        }
+        public TypeInformation TaskFactoryTypeInformation { get; private set; }
 
         /// <summary>
         /// The task factory wrapped by the wrapper
@@ -187,15 +185,14 @@ internal void SetPropertyValue(ITask task, TaskPropertyInfo property, object val
             ErrorUtilities.VerifyThrowArgumentNull(task, nameof(task));
             ErrorUtilities.VerifyThrowArgumentNull(property, nameof(property));
 
-            IGeneratedTask generatedTask = task as IGeneratedTask;
-            if (generatedTask != null)
+            if (task is IGeneratedTask generatedTask)
             {
                 generatedTask.SetPropertyValue(property, value);
             }
             else
             {
-                ReflectableTaskPropertyInfo propertyInfo = (ReflectableTaskPropertyInfo)property;
-                propertyInfo.Reflection.SetValue(task, value, null);
+                PropertyInfo prop = task.GetType().GetProperty(property.Name);
+                prop.SetValue(task, value);
             }
         }
 
@@ -207,23 +204,23 @@ internal object GetPropertyValue(ITask task, TaskPropertyInfo property)
             ErrorUtilities.VerifyThrowArgumentNull(task, nameof(task));
             ErrorUtilities.VerifyThrowArgumentNull(property, nameof(property));
 
-            IGeneratedTask generatedTask = task as IGeneratedTask;
-            if (generatedTask != null)
+            if (task is IGeneratedTask generatedTask)
             {
                 return generatedTask.GetPropertyValue(property);
             }
             else
             {
-                ReflectableTaskPropertyInfo propertyInfo = property as ReflectableTaskPropertyInfo;
-                if (propertyInfo != null)
-                {
-                    return propertyInfo.Reflection.GetValue(task, null);
-                }
-                else
+                if (property is ReflectableTaskPropertyInfo propertyInfo)
                 {
-                    ErrorUtilities.ThrowInternalError("Task does not implement IGeneratedTask and we don't have {0} either.", typeof(ReflectableTaskPropertyInfo).Name);
-                    throw new InternalErrorException(); // unreachable
+                    try
+                    {
+                        return propertyInfo.Reflection.GetValue(task, null);
+                    }
+                    // If the type was not loaded, we may end up with a NotImplementedException. Ignore it.
+                    catch (NotImplementedException) { }
                 }
+
+                return task.GetType().GetTypeInfo().GetProperty(property.Name);
             }
         }
 
@@ -246,7 +243,9 @@ private void PopulatePropertyInfoCacheIfNecessary()
         {
             if (_propertyInfoCache == null)
             {
-                bool taskTypeImplementsIGeneratedTask = typeof(IGeneratedTask).IsAssignableFrom(_taskFactory.TaskType);
+                bool taskTypeImplementsIGeneratedTask = _taskFactory is AssemblyTaskFactory assemblyTaskFactory ?
+                    assemblyTaskFactory.ImplementsIGeneratedTask :
+                    typeof(IGeneratedTask).IsAssignableFrom(_taskFactory.TaskType);
                 TaskPropertyInfo[] propertyInfos = _taskFactory.GetTaskParameters();
 
                 for (int i = 0; i < propertyInfos.Length; i++)
@@ -257,7 +256,9 @@ private void PopulatePropertyInfoCacheIfNecessary()
                     TaskPropertyInfo propertyInfo = propertyInfos[i];
                     if (!taskTypeImplementsIGeneratedTask)
                     {
-                        propertyInfo = new ReflectableTaskPropertyInfo(propertyInfo, _taskFactory.TaskType);
+                        propertyInfo = _taskFactory is AssemblyTaskFactory assemblyTaskFactory2 ?
+                            new ReflectableTaskPropertyInfo(propertyInfo, assemblyTaskFactory2.TypeInformation) :
+                            new ReflectableTaskPropertyInfo(propertyInfo, _taskFactory.TaskType);
                     }
 
                     try
diff --git a/src/Build/Instance/TaskRegistry.cs b/src/Build/Instance/TaskRegistry.cs
index 390f8e29f92..53e2516bd53 100644
--- a/src/Build/Instance/TaskRegistry.cs
+++ b/src/Build/Instance/TaskRegistry.cs
@@ -436,7 +436,7 @@ ElementLocation elementLocation
                         targetLoggingContext.LogComment(MessageImportance.Low, "TaskFoundFromFactory", taskName, taskFactory.Name);
                     }
 
-                    if (taskFactory.TaskFactoryLoadedType.HasSTAThreadAttribute())
+                    if (taskFactory.TaskFactoryTypeInformation.HasSTAThreadAttribute)
                     {
                         targetLoggingContext.LogComment(MessageImportance.Low, "TaskNeedsSTA", taskName);
                     }
@@ -754,6 +754,7 @@ public string Name
             public IDictionary<string, string> TaskIdentityParameters
             {
                 get { return _taskIdentityParameters; }
+                internal set { _taskIdentityParameters = value; }
             }
 
             /// <summary>
@@ -1284,7 +1285,7 @@ private bool GetTaskFactory(TargetLoggingContext targetLoggingContext, ElementLo
                     AssemblyLoadInfo taskFactoryLoadInfo = TaskFactoryAssemblyLoadInfo;
                     ErrorUtilities.VerifyThrow(taskFactoryLoadInfo != null, "TaskFactoryLoadInfo should never be null");
                     ITaskFactory factory = null;
-                    LoadedType loadedType = null;
+                    TypeInformation typeInformation = null;
 
                     bool isAssemblyTaskFactory = String.Equals(TaskFactoryAttributeName, AssemblyTaskFactory, StringComparison.OrdinalIgnoreCase);
                     bool isTaskHostFactory = String.Equals(TaskFactoryAttributeName, TaskHostFactory, StringComparison.OrdinalIgnoreCase);
@@ -1300,8 +1301,9 @@ private bool GetTaskFactory(TargetLoggingContext targetLoggingContext, ElementLo
                             );
 
                         // Create an instance of the internal assembly task factory, it has the error handling built into its methods.
-                        AssemblyTaskFactory taskFactory = new AssemblyTaskFactory();
-                        loadedType = taskFactory.InitializeFactory(taskFactoryLoadInfo, RegisteredName, ParameterGroupAndTaskBody.UsingTaskParameters, ParameterGroupAndTaskBody.InlineTaskXmlBody, TaskFactoryParameters, explicitlyLaunchTaskHost, targetLoggingContext, elementLocation, taskProjectFile);
+                        AssemblyTaskFactory taskFactory = new();
+                        typeInformation = taskFactory.InitializeFactory(taskFactoryLoadInfo, RegisteredName, ParameterGroupAndTaskBody.UsingTaskParameters, ParameterGroupAndTaskBody.InlineTaskXmlBody, ref _taskFactoryParameters, explicitlyLaunchTaskHost, targetLoggingContext, elementLocation, taskProjectFile);
+                        _taskIdentity.TaskIdentityParameters = _taskFactoryParameters;
                         factory = taskFactory;
                     }
                     else
@@ -1327,9 +1329,9 @@ private bool GetTaskFactory(TargetLoggingContext targetLoggingContext, ElementLo
                                 }
 
                                 // Make sure we only look for task factory classes when loading based on the name
-                                loadedType = s_taskFactoryTypeLoader.Load(TaskFactoryAttributeName, taskFactoryLoadInfo);
+                                typeInformation = s_taskFactoryTypeLoader.Load(TaskFactoryAttributeName, taskFactoryLoadInfo, false, out _);
 
-                                if (loadedType == null)
+                                if (typeInformation == null)
                                 {
                                     // We could not find the type (this is what null means from the Load method) but there is no reason given so we can only log the fact that 
                                     // we could not find the name given in the task factory attribute in the class specified in the assembly File or assemblyName fields.
@@ -1367,9 +1369,9 @@ private bool GetTaskFactory(TargetLoggingContext targetLoggingContext, ElementLo
                                 // We have loaded the type, lets now try and construct it
                                 // Any exceptions from the constructor of the task factory will be caught lower down and turned into an InvalidProjectFileExceptions
 #if FEATURE_APPDOMAIN
-                                factory = (ITaskFactory)AppDomain.CurrentDomain.CreateInstanceAndUnwrap(loadedType.Type.GetTypeInfo().Assembly.FullName, loadedType.Type.FullName);
+                                factory = (ITaskFactory)AppDomain.CurrentDomain.CreateInstanceAndUnwrap(typeInformation.LoadInfo.AssemblyName ?? typeInformation.LoadedType.Type.GetTypeInfo().Assembly.FullName, typeInformation.TypeName);
 #else
-                                factory = (ITaskFactory) Activator.CreateInstance(loadedType.Type);
+                                factory = (ITaskFactory)Activator.CreateInstance(typeInformation.LoadInfo.AssemblyName ?? typeInformation.LoadedType.LoadedAssembly.FullName, typeInformation.TypeName)?.Unwrap();
 #endif
                                 TaskFactoryLoggingHost taskFactoryLoggingHost = new TaskFactoryLoggingHost(true /*I dont have the data at this point, the safest thing to do is make sure events are serializable*/, elementLocation, targetLoggingContext);
 
@@ -1388,15 +1390,14 @@ private bool GetTaskFactory(TargetLoggingContext targetLoggingContext, ElementLo
                                         // TaskFactoryParameters will always be null unless specifically created to have runtime and architecture parameters.
                                         if (TaskFactoryParameters != null)
                                         {
-                                            targetLoggingContext.LogWarning
-                                                (
+                                            targetLoggingContext.LogWarning(
                                                 null,
-                                                    new BuildEventFileInfo(elementLocation),
-                                                    "TaskFactoryWillIgnoreTaskFactoryParameters",
-                                                    factory.FactoryName,
-                                                    XMakeAttributes.runtime,
-                                                    XMakeAttributes.architecture,
-                                                RegisteredName);
+                                                new BuildEventFileInfo(elementLocation),
+                                                "TaskFactoryWillIgnoreTaskFactoryParameters",
+                                                factory.FactoryName,
+                                                XMakeAttributes.runtime,
+                                                XMakeAttributes.architecture,
+                                            RegisteredName);
                                         }
                                     }
 
@@ -1460,7 +1461,7 @@ private bool GetTaskFactory(TargetLoggingContext targetLoggingContext, ElementLo
                         }
                     }
 
-                    _taskFactoryWrapperInstance = new TaskFactoryWrapper(factory, loadedType, RegisteredName, TaskFactoryParameters);
+                    _taskFactoryWrapperInstance = new TaskFactoryWrapper(factory, typeInformation, RegisteredName, TaskFactoryParameters);
                 }
 
                 return true;
diff --git a/src/Build/Logging/LoggerDescription.cs b/src/Build/Logging/LoggerDescription.cs
index dc7950123bb..d31a93b66b7 100644
--- a/src/Build/Logging/LoggerDescription.cs
+++ b/src/Build/Logging/LoggerDescription.cs
@@ -202,7 +202,7 @@ private ILogger CreateLogger(bool forwardingLogger)
                 if (forwardingLogger)
                 {
                     // load the logger from its assembly
-                    LoadedType loggerClass = (new TypeLoader(s_forwardingLoggerClassFilter)).Load(_loggerClassName, _loggerAssembly);
+                    LoadedType loggerClass = (new TypeLoader(s_forwardingLoggerClassFilter)).Load(_loggerClassName, _loggerAssembly, false, out _).LoadedType;
 
                     if (loggerClass != null)
                     {
@@ -213,7 +213,7 @@ private ILogger CreateLogger(bool forwardingLogger)
                 else
                 {
                     // load the logger from its assembly
-                    LoadedType loggerClass = (new TypeLoader(s_loggerClassFilter)).Load(_loggerClassName, _loggerAssembly);
+                    LoadedType loggerClass = (new TypeLoader(s_loggerClassFilter)).Load(_loggerClassName, _loggerAssembly, false, out _).LoadedType;
 
                     if (loggerClass != null)
                     {
diff --git a/src/Build/Microsoft.Build.csproj b/src/Build/Microsoft.Build.csproj
index cd99bc84721..b05dc8c9617 100644
--- a/src/Build/Microsoft.Build.csproj
+++ b/src/Build/Microsoft.Build.csproj
@@ -35,7 +35,7 @@
     <PackageReference Include="System.Threading.Tasks.Dataflow" />
     <PackageReference Include="System.Text.Json" />
 
-    <PackageReference Include="System.Reflection.Metadata" Condition="'$(MonoBuild)' == 'true'" />
+    <PackageReference Include="System.Reflection.Metadata" />
 
     <PackageReference Include="Microsoft.IO.Redist" Condition="'$(FeatureMSIORedist)' == 'true'" />
   </ItemGroup>
@@ -47,7 +47,6 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETFramework'">
-    <PackageReference Include="System.Reflection.Metadata" />
     <PackageReference Include="System.Security.Principal.Windows" />
     <PackageReference Include="System.Text.Encoding.CodePages" />
     <!-- Need Win32 API on .NET Core to ping registry to determine long path support -->
@@ -717,6 +716,10 @@
       <Link>SharedUtilities\LoadedType.cs</Link>
       <ExcludeFromStyleCop>true</ExcludeFromStyleCop>
     </Compile>
+    <Compile Include="..\Shared\TypeInformation.cs">
+      <Link>SharedUtilities\TypeInformation.cs</Link>
+      <ExcludeFromStyleCop>true</ExcludeFromStyleCop>
+    </Compile>
     <Compile Include="..\Shared\InprocTrackingNativeMethods.cs">
       <Link>InprocTrackingNativeMethods.cs</Link>
       <ExcludeFromStyleCop>true</ExcludeFromStyleCop>
diff --git a/src/MSBuild/MSBuild.csproj b/src/MSBuild/MSBuild.csproj
index 803083dd1fc..82122c476ea 100644
--- a/src/MSBuild/MSBuild.csproj
+++ b/src/MSBuild/MSBuild.csproj
@@ -135,8 +135,9 @@
     <Compile Include="..\Shared\TaskLoader.cs" />
     <Compile Include="..\Shared\MSBuildLoadContext.cs" Condition="'$(TargetFrameworkIdentifier)'!='.NETFramework'" />
     <Compile Include="..\Shared\TypeLoader.cs" />
+	<Compile Include="..\Shared\TypeInformation.cs" />
     <Compile Include="..\Shared\LoadedType.cs">
-      <ExcludeFromStyleCop>true</ExcludeFromStyleCop>
+	  <ExcludeFromStyleCop>true</ExcludeFromStyleCop>
     </Compile>
     <Compile Include="..\Shared\AssemblyLoadInfo.cs">
       <ExcludeFromStyleCop>true</ExcludeFromStyleCop>
diff --git a/src/MSBuild/OutOfProcTaskAppDomainWrapperBase.cs b/src/MSBuild/OutOfProcTaskAppDomainWrapperBase.cs
index 8405d0474a0..bbc70028128 100644
--- a/src/MSBuild/OutOfProcTaskAppDomainWrapperBase.cs
+++ b/src/MSBuild/OutOfProcTaskAppDomainWrapperBase.cs
@@ -10,6 +10,7 @@
 using Microsoft.Build.BackEnd;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
+using System.IO;
 #if FEATURE_APPDOMAIN
 using System.Runtime.Remoting;
 #endif
@@ -113,11 +114,11 @@ IDictionary<string, TaskParameter> taskParams
 #endif
             wrappedTask = null;
 
-            LoadedType taskType = null;
+            TypeInformation taskType = null;
             try
             {
                 TypeLoader typeLoader = new TypeLoader(TaskLoader.IsTaskClass);
-                taskType = typeLoader.Load(taskName, AssemblyLoadInfo.Create(null, taskLocation));
+                taskType = typeLoader.Load(taskName, AssemblyLoadInfo.Create(null, taskLocation), false, out _);
             }
             catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
             {
@@ -135,10 +136,10 @@ IDictionary<string, TaskParameter> taskParams
             }
 
             OutOfProcTaskHostTaskResult taskResult;
-            if (taskType.HasSTAThreadAttribute())
+            if (taskType.HasSTAThreadAttribute)
             {
 #if FEATURE_APARTMENT_STATE
-                taskResult = InstantiateAndExecuteTaskInSTAThread(oopTaskHostNode, taskType, taskName, taskLocation, taskFile, taskLine, taskColumn,
+                taskResult = InstantiateAndExecuteTaskInSTAThread(oopTaskHostNode, taskType.LoadedType, taskName, taskLocation, taskFile, taskLine, taskColumn,
 #if FEATURE_APPDOMAIN
                     appDomainSetup,
 #endif
@@ -155,7 +156,7 @@ IDictionary<string, TaskParameter> taskParams
             }
             else
             {
-                taskResult = InstantiateAndExecuteTask(oopTaskHostNode, taskType, taskName, taskLocation, taskFile, taskLine, taskColumn,
+                taskResult = InstantiateAndExecuteTask(oopTaskHostNode, taskType.LoadedType, taskName, taskLocation, taskFile, taskLine, taskColumn,
 #if FEATURE_APPDOMAIN
                     appDomainSetup,
 #endif
@@ -296,7 +297,7 @@ IDictionary<string, TaskParameter> taskParams
 
             try
             {
-                wrappedTask = TaskLoader.CreateTask(taskType, taskName, taskFile, taskLine, taskColumn, new TaskLoader.LogError(LogErrorDelegate),
+                wrappedTask = TaskLoader.CreateTask(new TypeInformation(taskType), taskName, taskFile, taskLine, taskColumn, new TaskLoader.LogError(LogErrorDelegate),
 #if FEATURE_APPDOMAIN
                     appDomainSetup,
 #endif
diff --git a/src/MSBuild/OutOfProcTaskHostNode.cs b/src/MSBuild/OutOfProcTaskHostNode.cs
index 6b54a4ec089..a5d72babc54 100644
--- a/src/MSBuild/OutOfProcTaskHostNode.cs
+++ b/src/MSBuild/OutOfProcTaskHostNode.cs
@@ -895,7 +895,7 @@ private void RunTask(object state)
 
                 taskResult = _taskWrapper.ExecuteTask
                 (
-                    this as IBuildEngine,
+                    this,
                     taskName,
                     taskLocation,
                     taskConfiguration.ProjectFileOfTask,
diff --git a/src/MSBuildTaskHost/MSBuildTaskHost.csproj b/src/MSBuildTaskHost/MSBuildTaskHost.csproj
index f56435ec284..9a454bde581 100644
--- a/src/MSBuildTaskHost/MSBuildTaskHost.csproj
+++ b/src/MSBuildTaskHost/MSBuildTaskHost.csproj
@@ -176,7 +176,8 @@
     </Compile>
     <Compile Include="..\Shared\TaskLoader.cs" />
     <Compile Include="..\Shared\LoadedType.cs" />
-    <Compile Include="..\Shared\AssemblyLoadInfo.cs" />
+	<Compile Include="..\Shared\TypeInformation.cs" />
+	<Compile Include="..\Shared\AssemblyLoadInfo.cs" />
     <Compile Include="..\Shared\TaskHostTaskCancelled.cs" />
     <Compile Include="..\Shared\TaskParameter.cs" />
     <Compile Include="..\Shared\AssemblyNameExtension.cs" />
diff --git a/src/MSBuildTaskHost/TypeLoader.cs b/src/MSBuildTaskHost/TypeLoader.cs
index 5b4833472c4..b03e1d6c0cf 100644
--- a/src/MSBuildTaskHost/TypeLoader.cs
+++ b/src/MSBuildTaskHost/TypeLoader.cs
@@ -127,12 +127,15 @@ internal static bool IsPartialTypeNameMatch(string typeName1, string typeName2)
         /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type
         /// found will be returned.
         /// </summary>
-        internal LoadedType Load
+        internal TypeInformation Load
         (
             string typeName,
-            AssemblyLoadInfo assembly
+            AssemblyLoadInfo assembly,
+            bool taskHostFactoryExplicitlyRequested,
+            out bool taskHostFactoryNeeded
         )
         {
+            taskHostFactoryNeeded = false;
             return GetLoadedType(s_cacheOfLoadedTypesByFilter, typeName, assembly);
         }
 
@@ -148,7 +151,7 @@ internal LoadedType ReflectionOnlyLoad
             AssemblyLoadInfo assembly
         )
         {
-            return GetLoadedType(s_cacheOfReflectionOnlyLoadedTypesByFilter, typeName, assembly);
+            return GetLoadedType(s_cacheOfReflectionOnlyLoadedTypesByFilter, typeName, assembly).LoadedType;
         }
 
         /// <summary>
@@ -156,7 +159,7 @@ AssemblyLoadInfo assembly
         /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type
         /// found will be returned.
         /// </summary>
-        private LoadedType GetLoadedType(Concurrent.ConcurrentDictionary<TypeFilter, Concurrent.ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes>> cache, string typeName, AssemblyLoadInfo assembly)
+        private TypeInformation GetLoadedType(Concurrent.ConcurrentDictionary<TypeFilter, Concurrent.ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes>> cache, string typeName, AssemblyLoadInfo assembly)
         {
             // A given type filter have been used on a number of assemblies, Based on the type filter we will get another dictionary which 
             // will map a specific AssemblyLoadInfo to a AssemblyInfoToLoadedTypes class which knows how to find a typeName in a given assembly.
@@ -233,12 +236,11 @@ internal AssemblyInfoToLoadedTypes(TypeFilter typeFilter, AssemblyLoadInfo loadI
             /// <summary>
             /// Determine if a given type name is in the assembly or not. Return null if the type is not in the assembly
             /// </summary>
-            internal LoadedType GetLoadedTypeByTypeName(string typeName)
+            internal TypeInformation GetLoadedTypeByTypeName(string typeName)
             {
                 ErrorUtilities.VerifyThrowArgumentNull(typeName, nameof(typeName));
 
                 // Only one thread should be doing operations on this instance of the object at a time.
-
                 Type type = _typeNameToType.GetOrAdd(typeName, (key) =>
                 {
                     if ((_assemblyLoadInfo.AssemblyName != null) && (typeName.Length > 0))
@@ -284,7 +286,7 @@ internal LoadedType GetLoadedTypeByTypeName(string typeName)
                     return null;
                 });
 
-                return type != null ? new LoadedType(type, _assemblyLoadInfo, _loadedAssembly) : null;
+                return type != null ? new TypeInformation(new LoadedType(type, _assemblyLoadInfo, _loadedAssembly)) : null;
             }
 
             /// <summary>
diff --git a/src/Shared/AssemblyLoadInfo.cs b/src/Shared/AssemblyLoadInfo.cs
index 271a077efaa..0400d847b4e 100644
--- a/src/Shared/AssemblyLoadInfo.cs
+++ b/src/Shared/AssemblyLoadInfo.cs
@@ -176,7 +176,7 @@ private sealed class AssemblyLoadInfoWithFile : AssemblyLoadInfo
             /// </summary>
             internal AssemblyLoadInfoWithFile(string assemblyFile)
             {
-                ErrorUtilities.VerifyThrow(Path.IsPathRooted(assemblyFile), "Assembly file path should be rooted");
+                ErrorUtilities.VerifyThrow(Path.IsPathRooted(assemblyFile), $"Assembly file path should be rooted: {assemblyFile}");
 
                 _assemblyFile = assemblyFile;
             }
diff --git a/src/Shared/LoadedType.cs b/src/Shared/LoadedType.cs
index eeae7eb79ab..cd29aacc43e 100644
--- a/src/Shared/LoadedType.cs
+++ b/src/Shared/LoadedType.cs
@@ -92,7 +92,7 @@ private void CheckForHardcodedSTARequirement()
             {
                 AssemblyName assemblyName = _type.GetTypeInfo().Assembly.GetName();
                 Version lastVersionToForce = new Version(3, 5);
-                if (assemblyName.Version.CompareTo(lastVersionToForce) > 0)
+                if (assemblyName.Version > lastVersionToForce)
                 {
                     if (String.Equals(assemblyName.Name, "PresentationBuildTasks", StringComparison.OrdinalIgnoreCase))
                     {
diff --git a/src/Shared/Resources/Strings.shared.resx b/src/Shared/Resources/Strings.shared.resx
index 4a2ab0dd185..71d77481bbc 100644
--- a/src/Shared/Resources/Strings.shared.resx
+++ b/src/Shared/Resources/Strings.shared.resx
@@ -278,10 +278,18 @@
     <value>MSB5028: Solution filter file at "{0}" includes project "{1}" that is not in the solution file at "{2}".</value>
     <comment>{StrBegin="MSB5028: "}UE: The project filename is provided separately to loggers.</comment>
   </data>
+  <data name="Shared.CurrentRuntimeDoesNotMatchTask">
+    <value>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</value>
+    <comment>{StrBegin="MSB5029: "}</comment>
+  </data>
+  <data name="Shared.32BitTaskOnCore">
+    <value>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</value>
+    <comment>{StrBegin="MSB5030: "}</comment>
+  </data>
   <!--
         The shared message bucket is: MSB5001 - MSB5999
 
-        Next message code should be MSB5029
+        Next message code should be MSB5031
 
         Some unused codes which can also be reused (because their messages were deleted, and UE hasn't indexed the codes yet):
             <none>
diff --git a/src/Shared/Resources/xlf/Strings.shared.cs.xlf b/src/Shared/Resources/xlf/Strings.shared.cs.xlf
index 80de31cf354..885b89ae0e3 100644
--- a/src/Shared/Resources/xlf/Strings.shared.cs.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.cs.xlf
@@ -60,6 +60,16 @@
         <target state="translated">Nástroj MSBuild očekává platný objekt {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Cesta: {0} překračuje maximální limit pro cestu k OS. Plně kvalifikovaný název souboru musí být kratší než {1} znaků.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.de.xlf b/src/Shared/Resources/xlf/Strings.shared.de.xlf
index 28e73b49c1a..b61d8bbb241 100644
--- a/src/Shared/Resources/xlf/Strings.shared.de.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.de.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild erwartet ein gültiges {0}-Objekt.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Der Pfad "{0}" überschreitet das maximale Pfadlimit des Betriebssystems. Der vollqualifizierte Dateiname muss weniger als {1} Zeichen umfassen.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.es.xlf b/src/Shared/Resources/xlf/Strings.shared.es.xlf
index 332d51f7961..8a72bd1795e 100644
--- a/src/Shared/Resources/xlf/Strings.shared.es.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.es.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild espera un objeto "{0}" válido.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">La ruta de acceso {0} supera el límite máximo para la ruta de acceso del sistema operativo. El nombre de archivo completo debe ser inferior a {1} caracteres.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.fr.xlf b/src/Shared/Resources/xlf/Strings.shared.fr.xlf
index 98d0ecd2344..7ac8f07f5f3 100644
--- a/src/Shared/Resources/xlf/Strings.shared.fr.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.fr.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild attend un objet "{0}" valide.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Le chemin {0} dépasse la limite maximale de chemin du système d'exploitation. Le nom du fichier qualifié complet doit contenir moins de {1} caractères.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.it.xlf b/src/Shared/Resources/xlf/Strings.shared.it.xlf
index 31c10bd56ca..fd5368b449c 100644
--- a/src/Shared/Resources/xlf/Strings.shared.it.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.it.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild prevede un oggetto "{0}" valido.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Il percorso {0} supera il limite massimo dei percorsi del sistema operativo. Il nome completo del file deve essere composto da meno di {1}.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.ja.xlf b/src/Shared/Resources/xlf/Strings.shared.ja.xlf
index 762d7780a9b..fd774cde7ec 100644
--- a/src/Shared/Resources/xlf/Strings.shared.ja.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.ja.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild は有効な "{0}" オブジェクトを必要としています。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">パス: {0} は OS のパスの上限を越えています。完全修飾のファイル名は {1} 文字以下にする必要があります。</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.ko.xlf b/src/Shared/Resources/xlf/Strings.shared.ko.xlf
index 7cd5d631a66..a4e1c2b365b 100644
--- a/src/Shared/Resources/xlf/Strings.shared.ko.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.ko.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild에 올바른 "{0}" 개체가 필요합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">경로: {0}은(는) OS 최대 경로 제한을 초과합니다. 정규화된 파일 이름은 {1}자 이하여야 합니다.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.pl.xlf b/src/Shared/Resources/xlf/Strings.shared.pl.xlf
index 3755284c24a..328277ac4cf 100644
--- a/src/Shared/Resources/xlf/Strings.shared.pl.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.pl.xlf
@@ -60,6 +60,16 @@
         <target state="translated">Program MSBuild oczekuje prawidłowego obiektu „{0}”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Ścieżka: {0} przekracza limit maksymalnej długości ścieżki w systemie operacyjnym. W pełni kwalifikowana nazwa pliku musi się składać z mniej niż {1} znaków.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.pt-BR.xlf b/src/Shared/Resources/xlf/Strings.shared.pt-BR.xlf
index 6fd1b77903b..2ce21e0b3db 100644
--- a/src/Shared/Resources/xlf/Strings.shared.pt-BR.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.pt-BR.xlf
@@ -60,6 +60,16 @@
         <target state="translated">O MSBuild está esperando um objeto "{0}" válido.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Caminho: {0} excede o limite máximo do caminho do SO. O nome do arquivo totalmente qualificado deve ter menos de {1} caracteres.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.ru.xlf b/src/Shared/Resources/xlf/Strings.shared.ru.xlf
index 3570539b1f8..b2b9a2dc50d 100644
--- a/src/Shared/Resources/xlf/Strings.shared.ru.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.ru.xlf
@@ -60,6 +60,16 @@
         <target state="translated">Для MSBuild требуется допустимый объект "{0}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Длина пути {0} превышает максимально допустимую в ОС. Символов в полном имени файла должно быть не больше {1}.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.tr.xlf b/src/Shared/Resources/xlf/Strings.shared.tr.xlf
index d6831788b90..b8b3070ab8e 100644
--- a/src/Shared/Resources/xlf/Strings.shared.tr.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.tr.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild, geçerli bir "{0}" nesnesi bekliyor.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">Yol: {0}, işletim sisteminin en yüksek yol sınırını aşıyor. Tam dosya adı en fazla {1} karakter olmalıdır.</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.zh-Hans.xlf b/src/Shared/Resources/xlf/Strings.shared.zh-Hans.xlf
index b5468e75bcb..401dc34df3a 100644
--- a/src/Shared/Resources/xlf/Strings.shared.zh-Hans.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.zh-Hans.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild 需要有效的“{0}”对象。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">路径: {0} 超过 OS 最大路径限制。完全限定的文件名必须少于 {1} 个字符。</target>
diff --git a/src/Shared/Resources/xlf/Strings.shared.zh-Hant.xlf b/src/Shared/Resources/xlf/Strings.shared.zh-Hant.xlf
index 893e286184a..32c0a650160 100644
--- a/src/Shared/Resources/xlf/Strings.shared.zh-Hant.xlf
+++ b/src/Shared/Resources/xlf/Strings.shared.zh-Hant.xlf
@@ -60,6 +60,16 @@
         <target state="translated">MSBuild 需要有效的 "{0}" 物件。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Shared.32BitTaskOnCore">
+        <source>MSB5030: .NET Core MSBuild does not support 32-bit tasks.</source>
+        <target state="new">MSB5030: .NET Core MSBuild does not support 32-bit tasks.</target>
+        <note>{StrBegin="MSB5030: "}</note>
+      </trans-unit>
+      <trans-unit id="Shared.CurrentRuntimeDoesNotMatchTask">
+        <source>MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</source>
+        <target state="new">MSB5029: The '{0}' task was built for {1}, but MSBuild in use targets {2}. MSBuild does not support building tasks across frameworks.</target>
+        <note>{StrBegin="MSB5029: "}</note>
+      </trans-unit>
       <trans-unit id="Shared.PathTooLong">
         <source>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</source>
         <target state="translated">路徑: {0} 超過 OS 路徑上限。完整檔案名稱必須少於 {1} 個字元。</target>
diff --git a/src/Shared/TaskLoader.cs b/src/Shared/TaskLoader.cs
index c553d8e36ac..82e5bcb39b6 100644
--- a/src/Shared/TaskLoader.cs
+++ b/src/Shared/TaskLoader.cs
@@ -2,7 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+#if !NETFRAMEWORK
 using System.Linq;
+#endif
 using System.Reflection;
 
 using Microsoft.Build.Framework;
@@ -21,7 +23,7 @@ internal static class TaskLoader
         /// For saving the assembly that was loaded by the TypeLoader
         /// We only use this when the assembly failed to load properly into the appdomain
         /// </summary>
-        private static LoadedType s_resolverLoadedType;
+        private static TypeInformation s_resolverTypeInformation;
 #endif
 
         /// <summary>
@@ -47,7 +49,7 @@ internal static bool IsTaskClass(Type type, object unused)
         /// <summary>
         /// Creates an ITask instance and returns it.  
         /// </summary>
-        internal static ITask CreateTask(LoadedType loadedType, string taskName, string taskLocation, int taskLine, int taskColumn, LogError logError
+        internal static ITask CreateTask(TypeInformation typeInformation, string taskName, string taskLocation, int taskLine, int taskColumn, LogError logError
 #if FEATURE_APPDOMAIN
             , AppDomainSetup appDomainSetup
 #endif
@@ -58,8 +60,8 @@ internal static ITask CreateTask(LoadedType loadedType, string taskName, string
             )
         {
 #if FEATURE_APPDOMAIN
-            bool separateAppDomain = loadedType.HasLoadInSeparateAppDomainAttribute();
-            s_resolverLoadedType = null;
+            bool separateAppDomain = typeInformation.HasLoadInSeparateAppDomainAttribute;
+            s_resolverTypeInformation = null;
             taskAppDomain = null;
             ITask taskInstanceInOtherAppDomain = null;
 #endif
@@ -69,7 +71,7 @@ internal static ITask CreateTask(LoadedType loadedType, string taskName, string
 #if FEATURE_APPDOMAIN
                 if (separateAppDomain)
                 {
-                    if (!loadedType.Type.GetTypeInfo().IsMarshalByRef)
+                    if (!typeInformation.IsMarshalByRef)
                     {
                         logError
                         (
@@ -106,13 +108,13 @@ internal static ITask CreateTask(LoadedType loadedType, string taskName, string
                         }
 
                         AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolver;
-                        s_resolverLoadedType = loadedType;
+                        s_resolverTypeInformation = typeInformation;
 
                         taskAppDomain = AppDomain.CreateDomain(isOutOfProc ? "taskAppDomain (out-of-proc)" : "taskAppDomain (in-proc)", null, appDomainInfo);
 
-                        if (loadedType.LoadedAssembly != null)
+                        if (typeInformation.LoadedType?.LoadedAssembly != null)
                         {
-                            taskAppDomain.Load(loadedType.LoadedAssembly.GetName());
+                            taskAppDomain.Load(typeInformation.AssemblyName);
                         }
 
 #if FEATURE_APPDOMAIN_UNHANDLED_EXCEPTION
@@ -121,18 +123,18 @@ internal static ITask CreateTask(LoadedType loadedType, string taskName, string
 #endif
                     }
                 }
-                else
+                else if (typeInformation.LoadedType is not null)
 #endif
                 {
                     // perf improvement for the same appdomain case - we already have the type object
                     // and don't want to go through reflection to recreate it from the name.
-                    return (ITask)Activator.CreateInstance(loadedType.Type);
+                    return (ITask)Activator.CreateInstance(typeInformation.LoadedType.Type);
                 }
 
 #if FEATURE_APPDOMAIN
-                if (loadedType.Assembly.AssemblyFile != null)
+                if ((typeInformation.LoadInfo.AssemblyFile ?? typeInformation.LoadedType.Assembly.AssemblyFile) != null)
                 {
-                    taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceFromAndUnwrap(loadedType.Assembly.AssemblyFile, loadedType.Type.FullName);
+                    taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceFromAndUnwrap(typeInformation.LoadInfo.AssemblyFile ?? typeInformation.LoadedType.Assembly.AssemblyFile, typeInformation.TypeName);
 
                     // this will force evaluation of the task class type and try to load the task assembly
                     Type taskType = taskInstanceInOtherAppDomain.GetType();
@@ -140,24 +142,24 @@ internal static ITask CreateTask(LoadedType loadedType, string taskName, string
                     // If the types don't match, we have a problem. It means that our AppDomain was able to load
                     // a task assembly using Load, and loaded a different one. I don't see any other choice than
                     // to fail here.
-                    if (taskType != loadedType.Type)
+                    if (((typeInformation.LoadedType is not null) && taskType != typeInformation.LoadedType.Type) ||
+                        ((typeInformation.LoadedType is null) &&
+                        (!taskType.Assembly.Location.Equals(typeInformation.LoadInfo.AssemblyLocation) || !taskType.Name.Equals(typeInformation.TypeName))))
                     {
-                        logError
-                        (
-                        taskLocation,
-                        taskLine,
-                        taskColumn,
-                        "ConflictingTaskAssembly",
-                        loadedType.Assembly.AssemblyFile,
-                        loadedType.Type.GetTypeInfo().Assembly.Location
-                        );
+                        logError(
+                            taskLocation,
+                            taskLine,
+                            taskColumn,
+                            "ConflictingTaskAssembly",
+                            typeInformation.LoadInfo.AssemblyFile ?? typeInformation.LoadedType.Assembly.AssemblyFile,
+                            typeInformation.LoadInfo.AssemblyLocation ?? typeInformation.LoadedType.Type.GetTypeInfo().Assembly.Location);
 
                         taskInstanceInOtherAppDomain = null;
                     }
                 }
                 else
                 {
-                    taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceAndUnwrap(loadedType.Type.GetTypeInfo().Assembly.FullName, loadedType.Type.FullName);
+                    taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceAndUnwrap(typeInformation.LoadedType.Type.GetTypeInfo().Assembly.FullName, typeInformation.TypeName);
                 }
 
                 return taskInstanceInOtherAppDomain;
@@ -183,12 +185,12 @@ internal static ITask CreateTask(LoadedType loadedType, string taskName, string
         /// </summary>
         internal static Assembly AssemblyResolver(object sender, ResolveEventArgs args)
         {
-            if ((s_resolverLoadedType?.LoadedAssembly != null))
+            if ((s_resolverTypeInformation?.LoadedType?.LoadedAssembly != null))
             {
                 // Match the name being requested by the resolver with the FullName of the assembly we have loaded
-                if (args.Name.Equals(s_resolverLoadedType.LoadedAssembly.FullName, StringComparison.Ordinal))
+                if (args.Name.Equals(s_resolverTypeInformation.LoadedType.LoadedAssembly.FullName, StringComparison.Ordinal))
                 {
-                    return s_resolverLoadedType.LoadedAssembly;
+                    return s_resolverTypeInformation.LoadedType.LoadedAssembly;
                 }
             }
 
@@ -200,10 +202,10 @@ internal static Assembly AssemblyResolver(object sender, ResolveEventArgs args)
         /// </summary>
         internal static void RemoveAssemblyResolver()
         {
-            if (s_resolverLoadedType != null)
+            if (s_resolverTypeInformation != null)
             {
                 AppDomain.CurrentDomain.AssemblyResolve -= AssemblyResolver;
-                s_resolverLoadedType = null;
+                s_resolverTypeInformation = null;
             }
         }
 #endif
diff --git a/src/Shared/TypeInformation.cs b/src/Shared/TypeInformation.cs
new file mode 100644
index 00000000000..67d3d05862d
--- /dev/null
+++ b/src/Shared/TypeInformation.cs
@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Reflection;
+#if !TASKHOST
+using System.Reflection.Metadata;
+#endif
+using Microsoft.Build.Framework;
+
+#nullable disable
+
+namespace Microsoft.Build.Shared
+{
+    internal sealed class TypeInformation
+    {
+        internal string Path { get; set; }
+        internal AssemblyLoadInfo LoadInfo { get; set; }
+        internal string TypeName { get; set; }
+
+        internal LoadedType LoadedType { get; set; }
+
+        internal bool HasSTAThreadAttribute { get; set; }
+        internal bool HasLoadInSeparateAppDomainAttribute { get; set; }
+        internal bool IsMarshalByRef { get; set; }
+        internal bool ImplementsIGeneratedTask { get; set; }
+        internal AssemblyName AssemblyName { get; set; }
+        internal string Namespace { get; set; }
+#if !TASKHOST
+        internal TypeInformation.PropertyInfo[] Properties { get; set; }
+#endif
+
+        internal TypeInformation()
+        {
+        }
+
+        internal TypeInformation(LoadedType baseType)
+        {
+            LoadedType = baseType;
+            HasSTAThreadAttribute = LoadedType.HasSTAThreadAttribute();
+            HasLoadInSeparateAppDomainAttribute = LoadedType.HasLoadInSeparateAppDomainAttribute();
+            IsMarshalByRef = LoadedType.Type.GetTypeInfo().IsMarshalByRef;
+#if TASKHOST
+            ImplementsIGeneratedTask = false;
+#else
+            ImplementsIGeneratedTask = LoadedType.Type is IGeneratedTask;
+#endif
+            AssemblyName = baseType.LoadedAssembly?.GetName();
+            Namespace = LoadedType.Type.Namespace;
+            LoadInfo = LoadedType.Assembly;
+            TypeName = LoadedType.Type.FullName;
+            Path = baseType.Assembly.AssemblyFile;
+        }
+
+        public System.Reflection.PropertyInfo[] GetProperties(BindingFlags flags)
+        {
+            if (LoadedType is null)
+            {
+                throw new NotImplementedException();
+            }
+            else
+            {
+                return LoadedType.Type.GetProperties(flags);
+            }
+        }
+
+        public System.Reflection.PropertyInfo GetProperty(string name, BindingFlags flags)
+        {
+            if (LoadedType is null)
+            {
+                throw new NotImplementedException();
+            }
+            else
+            {
+                return LoadedType.Type.GetProperty(name, flags);
+            }
+        }
+
+        internal struct PropertyInfo
+        {
+            public PropertyInfo(string name, Type propertyType, bool outputAttribute, bool requiredAttribute)
+            {
+                Name = name;
+                PropertyType = propertyType;
+                OutputAttribute = outputAttribute;
+                RequiredAttribute = requiredAttribute;
+            }
+
+            public string Name { get; set; }
+            public Type PropertyType { get; set; }
+            public bool OutputAttribute { get; set; }
+            public bool RequiredAttribute { get; set; }
+        }
+    }
+}
diff --git a/src/Shared/TypeLoader.cs b/src/Shared/TypeLoader.cs
index d296c8c7547..6204b943681 100644
--- a/src/Shared/TypeLoader.cs
+++ b/src/Shared/TypeLoader.cs
@@ -4,16 +4,34 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Linq;
 using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Reflection.PortableExecutable;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+#if !NETFRAMEWORK
+using System.Runtime.Loader;
+#endif
 using System.Threading;
+using Microsoft.Build.Framework;
 
 #nullable disable
 
 namespace Microsoft.Build.Shared
 {
+    internal struct TaskRuntimeInformation
+    {
+        public bool TaskHostNeeded;
+        public string Architecture;
+        public string Runtime;
+    }
+
     /// <summary>
     /// This class is used to load types from their assemblies.
     /// </summary>
@@ -185,13 +203,15 @@ private static Assembly LoadAssembly(AssemblyLoadInfo assemblyLoadInfo)
         /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type
         /// found will be returned.
         /// </summary>
-        internal LoadedType Load
+        internal TypeInformation Load
         (
             string typeName,
-            AssemblyLoadInfo assembly
+            AssemblyLoadInfo assembly,
+            bool taskHostFactoryExplicitlyRequested,
+            out TaskRuntimeInformation runtimeInformation
         )
         {
-            return GetLoadedType(s_cacheOfLoadedTypesByFilter, typeName, assembly);
+            return GetLoadedType(s_cacheOfLoadedTypesByFilter, typeName, assembly, taskHostFactoryExplicitlyRequested, out runtimeInformation);
         }
 
         /// <summary>
@@ -206,7 +226,7 @@ internal LoadedType ReflectionOnlyLoad
             AssemblyLoadInfo assembly
         )
         {
-            return GetLoadedType(s_cacheOfReflectionOnlyLoadedTypesByFilter, typeName, assembly);
+            return GetLoadedType(s_cacheOfReflectionOnlyLoadedTypesByFilter, typeName, assembly, false, out _)?.LoadedType;
         }
 
         /// <summary>
@@ -214,7 +234,12 @@ AssemblyLoadInfo assembly
         /// any) is unambiguous; otherwise, if there are multiple types with the same name in different namespaces, the first type
         /// found will be returned.
         /// </summary>
-        private LoadedType GetLoadedType(ConcurrentDictionary<Func<Type, object, bool>, ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes>> cache, string typeName, AssemblyLoadInfo assembly)
+        private TypeInformation GetLoadedType(
+            ConcurrentDictionary<Func<Type, object, bool>, ConcurrentDictionary<AssemblyLoadInfo, AssemblyInfoToLoadedTypes>> cache,
+            string typeName,
+            AssemblyLoadInfo assembly,
+            bool taskHostFactoryExplicitlyRequested,
+            out TaskRuntimeInformation runtimeInformation)
         {
             // A given type filter have been used on a number of assemblies, Based on the type filter we will get another dictionary which 
             // will map a specific AssemblyLoadInfo to a AssemblyInfoToLoadedTypes class which knows how to find a typeName in a given assembly.
@@ -225,7 +250,7 @@ private LoadedType GetLoadedType(ConcurrentDictionary<Func<Type, object, bool>,
             AssemblyInfoToLoadedTypes typeNameToType =
                 loadInfoToType.GetOrAdd(assembly, (_) => new AssemblyInfoToLoadedTypes(_isDesiredType, _));
 
-            return typeNameToType.GetLoadedTypeByTypeName(typeName);
+            return typeNameToType.GetLoadedTypeByTypeName(typeName, taskHostFactoryExplicitlyRequested, out runtimeInformation);
         }
 
         /// <summary>
@@ -256,7 +281,12 @@ private class AssemblyInfoToLoadedTypes
             /// <summary>
             /// What is the type for the given type name, this may be null if the typeName does not map to a type.
             /// </summary>
-            private ConcurrentDictionary<string, Type> _typeNameToType;
+            private ConcurrentDictionary<string, TypeInformation> _typeNameToTypeInformation;
+
+            /// <summary>
+            /// What is the type for the given type name, this may be null if the typeName does not map to a type.
+            /// </summary>
+            private ConcurrentDictionary<string, TypeInformation> _typeNameToTypeInformationTaskHost;
 
             /// <summary>
             /// List of public types in the assembly which match the type filter and their corresponding types
@@ -285,65 +315,433 @@ internal AssemblyInfoToLoadedTypes(Func<Type, object, bool> typeFilter, Assembly
 
                 _isDesiredType = typeFilter;
                 _assemblyLoadInfo = loadInfo;
-                _typeNameToType = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
+                _typeNameToTypeInformation = new ConcurrentDictionary<string, TypeInformation>(StringComparer.OrdinalIgnoreCase);
+                _typeNameToTypeInformationTaskHost = new ConcurrentDictionary<string, TypeInformation>(StringComparer.OrdinalIgnoreCase);
                 _publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
             }
 
             /// <summary>
             /// Determine if a given type name is in the assembly or not. Return null if the type is not in the assembly
             /// </summary>
-            internal LoadedType GetLoadedTypeByTypeName(string typeName)
+            internal TypeInformation GetLoadedTypeByTypeName(string typeName, bool taskHostFactoryExplicitlyRequested, out TaskRuntimeInformation runtimeInformation)
             {
                 ErrorUtilities.VerifyThrowArgumentNull(typeName, nameof(typeName));
 
-                // Only one thread should be doing operations on this instance of the object at a time.
-
-                Type type = _typeNameToType.GetOrAdd(typeName, (key) =>
+                runtimeInformation = new() { TaskHostNeeded = taskHostFactoryExplicitlyRequested };
+                if (_assemblyLoadInfo.AssemblyFile is not null)
                 {
-                    if ((_assemblyLoadInfo.AssemblyName != null) && (typeName.Length > 0))
+                    using (FileStream stream = File.OpenRead(_assemblyLoadInfo.AssemblyFile))
+                    using (PEReader reader = new(stream))
                     {
-                        try
+                        MetadataReader metadataReader = reader.GetMetadataReader();
+                        AssemblyDefinition assemblyDef = metadataReader.GetAssemblyDefinition();
+                        string targetFramework = null;
+                        foreach (CustomAttributeHandle attrHandle in assemblyDef.GetCustomAttributes())
+                        {
+                            CustomAttribute attr = metadataReader.GetCustomAttribute(attrHandle);
+                            if (attr.Constructor.Kind == HandleKind.MemberReference && metadataReader.GetString(metadataReader.GetTypeReference((TypeReferenceHandle)metadataReader.GetMemberReference((MemberReferenceHandle)attr.Constructor).Parent).Name).Equals("TargetFrameworkAttribute"))
+                            {
+                                BlobReader blobReader = metadataReader.GetBlobReader(attr.Value);
+                                blobReader.ReadInt16();
+                                targetFramework = blobReader.ReadSerializedString();
+                                break;
+                            }
+                        }
+
+                        Attribute msbuildFramework = Assembly.GetExecutingAssembly().GetCustomAttribute(typeof(TargetFrameworkAttribute));
+                        bool netcoremsbuild = msbuildFramework is not null && msbuildFramework is TargetFrameworkAttribute tfa && !tfa.FrameworkDisplayName.Contains("Framework");
+                        if (targetFramework is not null)
                         {
-                            // try to load the type using its assembly qualified name
-                            Type t2 = Type.GetType(typeName + "," + _assemblyLoadInfo.AssemblyName, false /* don't throw on error */, true /* case-insensitive */);
-                            if (t2 != null)
+                            if (netcoremsbuild)
+                            {
+                                if (targetFramework.Contains("Framework"))
+                                {
+                                    runtimeInformation.Runtime = targetFramework.Contains("4.") ?
+                                        XMakeAttributes.MSBuildRuntimeValues.clr4 :
+                                        XMakeAttributes.MSBuildRuntimeValues.clr2;
+                                }
+                            }
+                            else
                             {
-                                return !_isDesiredType(t2, null) ? null : t2;
+                                if (!targetFramework.Contains("Framework"))
+                                {
+                                    runtimeInformation.Runtime = XMakeAttributes.MSBuildRuntimeValues.net;
+                                }
                             }
                         }
-                        catch (ArgumentException)
+
+                        if (runtimeInformation.Runtime is not null)
+                        {
+                            ErrorUtilities.ThrowArgument("Shared.CurrentRuntimeDoesNotMatchTask", typeName, netcoremsbuild ? ".NET Framework" : ".NET Core", netcoremsbuild ? ".NET Core" : ".NET Framework");
+                        }
+
+                        bool msbuildIs64Bit = RuntimeInformation.ProcessArchitecture == Architecture.X64;
+                        Machine machineArch = reader.PEHeaders.CoffHeader.Machine;
+                        if (msbuildIs64Bit && machineArch == Machine.AM33)
+                        {
+                            runtimeInformation.Architecture = XMakeAttributes.MSBuildArchitectureValues.x86;
+                        }
+                        else if (!msbuildIs64Bit && machineArch == Machine.Amd64)
+                        {
+                            runtimeInformation.Architecture = XMakeAttributes.MSBuildArchitectureValues.x64;
+                        }
+
+                        if (netcoremsbuild && runtimeInformation.Architecture == XMakeAttributes.MSBuildArchitectureValues.x86)
+                        {
+                            ErrorUtilities.ThrowArgument("Shared.32BitTaskOnCore");
+                        }
+
+                        if (runtimeInformation.Architecture is not null || runtimeInformation.Runtime is not null)
+                        {
+                            runtimeInformation.TaskHostNeeded = true;
+                        }
+                    }
+                }
+
+                // Only one thread should be doing operations on this instance of the object at a time.
+                TypeInformation typeInfo = runtimeInformation.TaskHostNeeded ?
+                    _typeNameToTypeInformationTaskHost.GetOrAdd(typeName, key => FindTypeInformationUsingSystemReflectionMetadata(typeName)) :
+                    _typeNameToTypeInformation.GetOrAdd(typeName, key => FindTypeInformationUsingLoadedType(typeName)
+                    );
+
+                return typeInfo;
+            }
+
+            private bool Required32Bit(Machine arch)
+            {
+                return arch == Machine.AM33 || arch == Machine.Arm || arch == Machine.ArmThumb2 || arch == Machine.I386 || arch == Machine.Alpha || arch == Machine.M32R;
+            }
+
+            private bool Required64Bit(Machine arch)
+            {
+                return arch == Machine.Amd64 || arch == Machine.Arm64 || arch == Machine.IA64 || arch == Machine.Alpha64;
+            }
+
+            /// <summary>
+            /// The user has not explicitly requested a TaskHost; load the type and use it to find relevant information.
+            /// </summary>
+            /// <param name="typeName">The type to find.</param>
+            /// <returns>A <c ref="TypeInformation"/> with a LoadedType indicating relevant information.</returns>
+            private TypeInformation FindTypeInformationUsingLoadedType(string typeName)
+            {
+                if ((_assemblyLoadInfo.AssemblyName != null) && (typeName.Length > 0))
+                {
+                    try
+                    {
+                        // try to load the type using its assembly qualified name
+                        Type t2 = Type.GetType(typeName + "," + _assemblyLoadInfo.AssemblyName, false /* don't throw on error */, true /* case-insensitive */);
+                        if (t2 != null)
+                        {
+                            return _isDesiredType(t2, null) ? new TypeInformation(new LoadedType(t2, _assemblyLoadInfo, _loadedAssembly)) : null;
+                        }
+                    }
+                    catch (ArgumentException)
+                    {
+                        // Type.GetType() will throw this exception if the type name is invalid -- but we have no idea if it's the
+                        // type or the assembly name that's the problem -- so just ignore the exception, because we're going to
+                        // check the existence/validity of the assembly and type respectively, below anyway
+                    }
+                }
+
+                if (Interlocked.Read(ref _haveScannedPublicTypes) == 0)
+                {
+                    lock (_lockObject)
+                    {
+                        if (Interlocked.Read(ref _haveScannedPublicTypes) == 0)
+                        {
+                            ScanAssemblyForPublicTypes();
+                            Interlocked.Exchange(ref _haveScannedPublicTypes, ~0);
+                        }
+                    }
+                }
+
+                foreach (KeyValuePair<string, Type> desiredTypeInAssembly in _publicTypeNameToType)
+                {
+                    // if type matches partially on its name
+                    if (typeName.Length == 0 || TypeLoader.IsPartialTypeNameMatch(desiredTypeInAssembly.Key, typeName))
+                    {
+                        return new TypeInformation(new LoadedType(desiredTypeInAssembly.Value, _assemblyLoadInfo, _loadedAssembly));
+                    }
+                }
+
+                return null;
+            }
+
+            /// <summary>
+            /// Find type information using System.Reflection.Metadata to avoid loading (and locking) its containing assembly.
+            /// </summary>
+            /// <param name="typeName">The type to find.</param>
+            /// <returns>A <c ref="TypeInformation"/> indicating relevant information about typeName.</returns>
+            private TypeInformation FindTypeInformationUsingSystemReflectionMetadata(string typeName)
+            {
+                string path = _assemblyLoadInfo.AssemblyFile;
+
+                // This should only be true for Microsoft.Build assemblies. We use this for testing.
+                if (path is null)
+                {
+#if NETFRAMEWORK
+                    AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
+                    setup.LoaderOptimization = LoaderOptimization.SingleDomain;
+                    AppDomain appDomain = AppDomain.CreateDomain("appDomainToFindPath", null, setup);
+                    path = appDomain.Load(new AssemblyName(_assemblyLoadInfo.AssemblyName)).Location;
+                    AppDomain.Unload(appDomain);
+#else
+                    AssemblyLoadContext alc = new("loadContextToFindPath", true);
+                    path = alc.LoadFromAssemblyName(new AssemblyName(_assemblyLoadInfo.AssemblyName)).Location;
+                    alc.Unload();
+#endif
+                }
+
+                using (FileStream stream = File.OpenRead(path))
+                using (PEReader peFile = new(stream))
+                {
+                    MetadataReader metadataReader = peFile.GetMetadataReader();
+                    AssemblyDefinition assemblyDef = metadataReader.GetAssemblyDefinition();
+                    foreach (TypeDefinitionHandle typeDefHandle in metadataReader.TypeDefinitions)
+                    {
+                        TypeDefinition typeDef = metadataReader.GetTypeDefinition(typeDefHandle);
+                        if (TryGetTypeInformationFromDefinition(metadataReader, typeDef, typeName, out TypeInformation typeInformation))
+                        {
+                            typeInformation.Path = path;
+                            return typeInformation;
+                        }
+                    }
+                }
+
+                return null;
+            }
+
+            /// <summary>
+            /// Tries to find information about the type.
+            /// </summary>
+            /// <param name="metadataReader"><c ref="MetadataReader"/> for the assembly containing the type.</param>
+            /// <param name="typeDef"><c ref="TypeDefinition"/> indicating the type currently under consideration.</param>
+            /// <param name="typeName">The name of the task type to find.</param>
+            /// <param name="typeInformation">The information, if we find it.</param>
+            /// <returns>True if this type or one of its children matches typeName. False otherwise.</returns>
+            private bool TryGetTypeInformationFromDefinition(MetadataReader metadataReader, TypeDefinition typeDef, string typeName, out TypeInformation typeInformation)
+            {
+                typeInformation = null;
+                string currentTypeName = metadataReader.GetString(typeDef.Name);
+
+                if (!(typeDef.Attributes.HasFlag(TypeAttributes.Public) || typeDef.Attributes.HasFlag(TypeAttributes.NestedPublic)) || !typeDef.Attributes.HasFlag(TypeAttributes.Class))
+                {
+                    return false;
+                }
+
+                if (currentTypeName.Length != 0 && !TypeLoader.IsPartialTypeNameMatch(currentTypeName, typeName))
+                {
+                    foreach (TypeDefinitionHandle typeDefHandle in typeDef.GetNestedTypes())
+                    {
+                        TypeDefinition childTypeDef = metadataReader.GetTypeDefinition(typeDefHandle);
+                        if (TryGetTypeInformationFromDefinition(metadataReader, childTypeDef, typeName, out typeInformation))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+                // We found the right type! Now get its information.
+                typeInformation = new();
+
+                foreach (CustomAttributeHandle customAttrHandle in typeDef.GetCustomAttributes())
+                {
+                    CustomAttribute customAttribute = metadataReader.GetCustomAttribute(customAttrHandle);
+                    MemberReference constructorReference = metadataReader.GetMemberReference((MemberReferenceHandle)customAttribute.Constructor);
+                    if (constructorReference.Parent.Kind == HandleKind.TypeReference)
+                    {
+                        TypeReference typeReference = metadataReader.GetTypeReference((TypeReferenceHandle)constructorReference.Parent);
+                        string customAttributeName = metadataReader.GetString(typeReference.Name);
+                        switch (customAttributeName)
                         {
-                            // Type.GetType() will throw this exception if the type name is invalid -- but we have no idea if it's the
-                            // type or the assembly name that's the problem -- so just ignore the exception, because we're going to
-                            // check the existence/validity of the assembly and type respectively, below anyway
+                            case "RunInSTAAttribute":
+                                typeInformation.HasSTAThreadAttribute = true;
+                                break;
+                            case "LoadInSeparateAppDomainAttribute":
+                                typeInformation.HasLoadInSeparateAppDomainAttribute = true;
+                                break;
                         }
                     }
+                }
 
-                    if (Interlocked.Read(ref _haveScannedPublicTypes) == 0)
+                IEnumerable<PropertyDefinition> propertyDefinitions = typeDef.GetProperties().Select(prop => metadataReader.GetPropertyDefinition(prop));
+                List<TypeInformation.PropertyInfo> typePropertyInfos = new();
+                foreach (PropertyDefinition propertyDefinition in propertyDefinitions)
+                {
+                    TypeInformation.PropertyInfo toAdd = new();
+                    toAdd.Name = metadataReader.GetString(propertyDefinition.Name);
+                    SignatureDecoder<string, object> decoder = new(ConstantSignatureVisualizer.Instance, metadataReader, genericContext: null);
+                    BlobReader blob = metadataReader.GetBlobReader(propertyDefinition.Signature);
+                    MethodSignature<string> signature = decoder.DecodeMethodSignature(ref blob);
+                    toAdd.PropertyType = StringToType(signature.ReturnType);
+                    toAdd.OutputAttribute = false;
+                    toAdd.RequiredAttribute = false;
+                    foreach (CustomAttributeHandle attr in propertyDefinition.GetCustomAttributes())
                     {
-                        lock (_lockObject)
+                        EntityHandle referenceHandle = metadataReader.GetMemberReference((MemberReferenceHandle)metadataReader.GetCustomAttribute(attr).Constructor).Parent;
+                        if (referenceHandle.Kind == HandleKind.TypeReference)
                         {
-                            if (Interlocked.Read(ref _haveScannedPublicTypes) == 0)
+                            string name = metadataReader.GetString(metadataReader.GetTypeReference((TypeReferenceHandle)referenceHandle).Name);
+                            if (name.Equals("OutputAttribute", StringComparison.OrdinalIgnoreCase))
+                            {
+                                toAdd.OutputAttribute = true;
+                            }
+                            else if (name.Equals("RequiredAttribute", StringComparison.OrdinalIgnoreCase))
                             {
-                                ScanAssemblyForPublicTypes();
-                                Interlocked.Exchange(ref _haveScannedPublicTypes, ~0);
+                                toAdd.RequiredAttribute = true;
                             }
                         }
                     }
+                    typePropertyInfos.Add(toAdd);
+                }
+                typeInformation.Properties = typePropertyInfos.ToArray();
 
-                    foreach (KeyValuePair<string, Type> desiredTypeInAssembly in _publicTypeNameToType)
+                TypeDefinition parentTypeDefinition = typeDef;
+                while (true)
+                {
+                    foreach (InterfaceImplementationHandle interfaceHandle in parentTypeDefinition.GetInterfaceImplementations())
                     {
-                        // if type matches partially on its name
-                        if (typeName.Length == 0 || TypeLoader.IsPartialTypeNameMatch(desiredTypeInAssembly.Key, typeName))
+                        if (metadataReader.GetString(metadataReader.GetTypeReference((TypeReferenceHandle)metadataReader.GetInterfaceImplementation(interfaceHandle).Interface).Name).Equals("IGeneratedTask"))
                         {
-                            return desiredTypeInAssembly.Value;
+                            typeInformation.ImplementsIGeneratedTask = true;
                         }
                     }
 
-                    return null;
-                });
+                    if (parentTypeDefinition.BaseType.IsNil)
+                    {
+                        break;
+                    }
 
-                return type != null ? new LoadedType(type, _assemblyLoadInfo, _loadedAssembly) : null;
+                    // If the baseType is not a TypeDefinitionHandle, we won't be able to chase it without actually loading the assembly. We would need to find the assembly containing the base type
+                    // and load it using System.Reflection.Metdata just as we're doing here, but we don't know its path without loading this assembly. Just assume it didn't implement IGeneratedTask.
+                    bool shouldBreakLoop = false;
+                    switch (parentTypeDefinition.BaseType.Kind)
+                    {
+                        case HandleKind.TypeDefinition:
+                            parentTypeDefinition = metadataReader.GetTypeDefinition((TypeDefinitionHandle)parentTypeDefinition.BaseType);
+                            break;
+                        case HandleKind.TypeReference:
+                            string parentName = metadataReader.GetString(metadataReader.GetTypeReference((TypeReferenceHandle)parentTypeDefinition.BaseType).Name);
+                            if (parentName.Equals("IGeneratedTask"))
+                            {
+                                typeInformation.ImplementsIGeneratedTask = true;
+                            }
+                            else if (parentName.Equals("MarshalByRefObject"))
+                            {
+                                typeInformation.IsMarshalByRef = true;
+                            }
+                            shouldBreakLoop = true;
+                            break;
+                        case HandleKind.TypeSpecification:
+                            shouldBreakLoop = true;
+                            break;
+                    }
+
+                    string typeDefinitionName = metadataReader.GetString(parentTypeDefinition.Name);
+                    if (typeDefinitionName.Equals("MarshalByRefObject"))
+                    {
+                        typeInformation.IsMarshalByRef = true;
+                    }
+                    if (shouldBreakLoop || typeDefinitionName.Equals("object"))
+                    {
+                        break;
+                    }
+                }
+
+                foreach (InterfaceImplementationHandle interfaceHandle in typeDef.GetInterfaceImplementations())
+                {
+                    if (metadataReader.GetString(metadataReader.GetTypeReference((TypeReferenceHandle)metadataReader.GetInterfaceImplementation(interfaceHandle).Interface).Name).Equals("IGeneratedTask"))
+                    {
+                        typeInformation.ImplementsIGeneratedTask = true;
+                    }
+                }
+
+                typeInformation.AssemblyName = _assemblyLoadInfo.AssemblyName is null ? new AssemblyName(Path.GetFileNameWithoutExtension(_assemblyLoadInfo.AssemblyFile)) : new AssemblyName(_assemblyLoadInfo.AssemblyName);
+
+                typeInformation.Namespace = metadataReader.GetString(metadataReader.GetNamespaceDefinition(metadataReader.GetNamespaceDefinitionRoot().NamespaceDefinitions.First()).Name);
+
+                return true;
+            }
+
+            private Type StringToType(string s)
+            {
+                // return Type.GetType(s, false, true) ?? typeof(object);
+                // would be a much cleaner implementation of StringToType, but it unfortunately
+                // expects not just the type name but also its namespace like "System,Int32"
+                // rather than just "Int32" as we get from decoding the TypeDefinition's signature.
+                return s switch
+                {
+                    "String" => typeof(String),
+                    "Microsoft.Build.Framework.ITaskItem" => typeof(ITaskItem),
+                    "Boolean" => typeof(Boolean),
+                    "Int32" => typeof(Int32),
+                    "Char" => typeof(Char),
+                    "Single" => typeof(Single),
+                    "Int64" => typeof(Int64),
+                    "Double" => typeof(Double),
+                    "Byte" => typeof(Byte),
+                    "SByte" => typeof(SByte),
+                    "Decimal" => typeof(Decimal),
+                    "UInt32" => typeof(UInt32),
+                    "IntPtr" => typeof(IntPtr),
+                    "UIntPtr" => typeof(UIntPtr),
+                    "UInt64" => typeof(UInt64),
+                    "Int16" => typeof(Int16),
+                    "UInt16" => typeof(UInt16),
+                    "String[]" => typeof(String[]),
+                    "Microsoft.Build.Framework.ITaskItem[]" => typeof(ITaskItem[]),
+                    "Boolean[]" => typeof(Boolean[]),
+                    "Int32[]" => typeof(Int32[]),
+                    "Char[]" => typeof(Char[]),
+                    "Single[]" => typeof(Single[]),
+                    "Int64[]" => typeof(Int64[]),
+                    "Double[]" => typeof(Double[]),
+                    "Byte[]" => typeof(Byte[]),
+                    "SByte[]" => typeof(SByte[]),
+                    "Decimal[]" => typeof(Decimal[]),
+                    "UInt32[]" => typeof(UInt32[]),
+                    "IntPtr[]" => typeof(IntPtr[]),
+                    "UIntPtr[]" => typeof(UIntPtr[]),
+                    "UInt64[]" => typeof(UInt64[]),
+                    "Int16[]" => typeof(Int16[]),
+                    "UInt16[]" => typeof(UInt16[]),
+                    "String?" => typeof(String),
+                    "Microsoft.Build.Framework.ITaskItem?" => typeof(ITaskItem),
+                    "Boolean?" => typeof(Boolean?),
+                    "Int32?" => typeof(Int32?),
+                    "Char?" => typeof(Char?),
+                    "Single?" => typeof(Single?),
+                    "Int64?" => typeof(Int64?),
+                    "Double?" => typeof(Double?),
+                    "Byte?" => typeof(Byte?),
+                    "SByte?" => typeof(SByte?),
+                    "Decimal?" => typeof(Decimal?),
+                    "UInt32?" => typeof(UInt32?),
+                    "IntPtr?" => typeof(IntPtr?),
+                    "UIntPtr?" => typeof(UIntPtr?),
+                    "UInt64?" => typeof(UInt64?),
+                    "Int16?" => typeof(Int16?),
+                    "UInt16?" => typeof(UInt16?),
+                    "String?[]" => typeof(String[]),
+                    "Microsoft.Build.Framework.ITaskItem?[]" => typeof(ITaskItem[]),
+                    "Boolean?[]" => typeof(Boolean?[]),
+                    "Int32?[]" => typeof(Int32?[]),
+                    "Char?[]" => typeof(Char?[]),
+                    "Single?[]" => typeof(Single?[]),
+                    "Int64?[]" => typeof(Int64?[]),
+                    "Double?[]" => typeof(Double?[]),
+                    "Byte?[]" => typeof(Byte?[]),
+                    "SByte?[]" => typeof(SByte?[]),
+                    "Decimal?[]" => typeof(Decimal?[]),
+                    "UInt32?[]" => typeof(UInt32?[]),
+                    "IntPtr?[]" => typeof(IntPtr?[]),
+                    "UIntPtr?[]" => typeof(UIntPtr?[]),
+                    "UInt64?[]" => typeof(UInt64?[]),
+                    "Int16?[]" => typeof(Int16?[]),
+                    "UInt16?[]" => typeof(UInt16?[]),
+                    _ => typeof(object),
+                };
             }
 
             /// <summary>
@@ -367,5 +765,64 @@ private void ScanAssemblyForPublicTypes()
                 }
             }
         }
+
+        // Copied from https://github.com/dotnet/roslyn/blob/a9027f3d3bddcd77eb3c97bf0caba61335c08426/src/Compilers/Test/Core/Metadata/MetadataReaderUtils.cs#L405
+        private sealed class ConstantSignatureVisualizer : ISignatureTypeProvider<string, object>
+        {
+            public static readonly ConstantSignatureVisualizer Instance = new();
+
+            public string GetArrayType(string elementType, ArrayShape shape)
+                => elementType + "[" + new string(',', shape.Rank) + "]";
+
+            public string GetByReferenceType(string elementType)
+                => elementType + "&";
+
+            public string GetFunctionPointerType(MethodSignature<string> signature)
+                => "method-ptr";
+
+            public string GetGenericInstantiation(string genericType, ImmutableArray<string> typeArguments)
+                => genericType + "{" + string.Join(", ", typeArguments) + "}";
+
+            public string GetGenericMethodParameter(object genericContext, int index)
+                => "!!" + index;
+
+            public string GetGenericTypeParameter(object genericContext, int index)
+                => "!" + index;
+
+            public string GetModifiedType(string modifier, string unmodifiedType, bool isRequired)
+                => (isRequired ? "modreq" : "modopt") + "(" + modifier + ") " + unmodifiedType;
+
+            public string GetPinnedType(string elementType)
+                => "pinned " + elementType;
+
+            public string GetPointerType(string elementType)
+                => elementType + "*";
+
+            public string GetPrimitiveType(PrimitiveTypeCode typeCode)
+                => typeCode.ToString();
+
+            public string GetSZArrayType(string elementType)
+                => elementType + "[]";
+
+            public string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind)
+            {
+                var typeDef = reader.GetTypeDefinition(handle);
+                var name = reader.GetString(typeDef.Name);
+                return typeDef.Namespace.IsNil ? name : reader.GetString(typeDef.Namespace) + "." + name;
+            }
+
+            public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
+            {
+                var typeRef = reader.GetTypeReference(handle);
+                var name = reader.GetString(typeRef.Name);
+                return typeRef.Namespace.IsNil ? name : reader.GetString(typeRef.Namespace) + "." + name;
+            }
+
+            public string GetTypeFromSpecification(MetadataReader reader, object genericContext, TypeSpecificationHandle handle, byte rawTypeKind)
+            {
+                var sigReader = reader.GetBlobReader(reader.GetTypeSpecification(handle).Signature);
+                return new SignatureDecoder<string, object>(Instance, reader, genericContext).DecodeType(ref sigReader);
+            }
+        }
     }
 }
diff --git a/src/Shared/UnitTests/TestEnvironment.cs b/src/Shared/UnitTests/TestEnvironment.cs
index 33ed94cc123..d4a4e38926e 100644
--- a/src/Shared/UnitTests/TestEnvironment.cs
+++ b/src/Shared/UnitTests/TestEnvironment.cs
@@ -473,7 +473,7 @@ public override void AssertInvariant(ITestOutputHelper output)
             }
 
             // Assert file count is equal minus any files that were OK
-            Assert.Equal(_originalFiles.Length, newFilesCount);
+            newFilesCount.ShouldBe(_originalFiles.Length, "Files to check: " + string.Join(" ", newFiles.Except(_originalFiles)));
         }
     }
 
diff --git a/src/Shared/UnitTests/TypeLoader_Tests.cs b/src/Shared/UnitTests/TypeLoader_Tests.cs
index 9fb112d8c03..aee9beca76c 100644
--- a/src/Shared/UnitTests/TypeLoader_Tests.cs
+++ b/src/Shared/UnitTests/TypeLoader_Tests.cs
@@ -200,13 +200,13 @@ public void Regress640476PartialName()
         {
             string forwardingLoggerLocation = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger).Assembly.Location;
             TypeLoader loader = new TypeLoader(IsForwardingLoggerClass);
-            LoadedType loadedType = loader.Load("ConfigurableForwardingLogger", AssemblyLoadInfo.Create(null, forwardingLoggerLocation));
+            LoadedType loadedType = loader.Load("ConfigurableForwardingLogger", AssemblyLoadInfo.Create(null, forwardingLoggerLocation), false, out _).LoadedType;
             Assert.NotNull(loadedType);
             Assert.Equal(forwardingLoggerLocation, loadedType.Assembly.AssemblyLocation);
 
             string fileLoggerLocation = typeof(Microsoft.Build.Logging.FileLogger).Assembly.Location;
             loader = new TypeLoader(IsLoggerClass);
-            loadedType = loader.Load("FileLogger", AssemblyLoadInfo.Create(null, fileLoggerLocation));
+            loadedType = loader.Load("FileLogger", AssemblyLoadInfo.Create(null, fileLoggerLocation), false, out _).LoadedType;
             Assert.NotNull(loadedType);
             Assert.Equal(fileLoggerLocation, loadedType.Assembly.AssemblyLocation);
         }
@@ -221,14 +221,14 @@ public void Regress640476FullyQualifiedName()
             Type forwardingLoggerType = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger);
             string forwardingLoggerLocation = forwardingLoggerType.Assembly.Location;
             TypeLoader loader = new TypeLoader(IsForwardingLoggerClass);
-            LoadedType loadedType = loader.Load(forwardingLoggerType.FullName, AssemblyLoadInfo.Create(null, forwardingLoggerLocation));
+            LoadedType loadedType = loader.Load(forwardingLoggerType.FullName, AssemblyLoadInfo.Create(null, forwardingLoggerLocation), false, out _).LoadedType;
             Assert.NotNull(loadedType);
             Assert.Equal(forwardingLoggerLocation, loadedType.Assembly.AssemblyLocation);
 
             Type fileLoggerType = typeof(Microsoft.Build.Logging.FileLogger);
             string fileLoggerLocation = fileLoggerType.Assembly.Location;
             loader = new TypeLoader(IsLoggerClass);
-            loadedType = loader.Load(fileLoggerType.FullName, AssemblyLoadInfo.Create(null, fileLoggerLocation));
+            loadedType = loader.Load(fileLoggerType.FullName, AssemblyLoadInfo.Create(null, fileLoggerLocation), false, out _).LoadedType;
             Assert.NotNull(loadedType);
             Assert.Equal(fileLoggerLocation, loadedType.Assembly.AssemblyLocation);
         }
@@ -248,7 +248,7 @@ public void NoTypeNamePicksFirstType()
             Type firstPublicType = FirstPublicDesiredType(forwardingLoggerfilter, forwardingLoggerAssemblyLocation);
 
             TypeLoader loader = new TypeLoader(forwardingLoggerfilter);
-            LoadedType loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, forwardingLoggerAssemblyLocation));
+            LoadedType loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, forwardingLoggerAssemblyLocation), false, out _).LoadedType;
             Assert.NotNull(loadedType);
             Assert.Equal(forwardingLoggerAssemblyLocation, loadedType.Assembly.AssemblyLocation);
             Assert.Equal(firstPublicType, loadedType.Type);
@@ -260,7 +260,7 @@ public void NoTypeNamePicksFirstType()
             firstPublicType = FirstPublicDesiredType(fileLoggerfilter, fileLoggerAssemblyLocation);
 
             loader = new TypeLoader(fileLoggerfilter);
-            loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, fileLoggerAssemblyLocation));
+            loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, fileLoggerAssemblyLocation), false, out _).LoadedType;
             Assert.NotNull(loadedType);
             Assert.Equal(fileLoggerAssemblyLocation, loadedType.Assembly.AssemblyLocation);
             Assert.Equal(firstPublicType, loadedType.Type);
diff --git a/src/Tasks.UnitTests/PortableTasks_Tests.cs b/src/Tasks.UnitTests/PortableTasks_Tests.cs
index 20353efc583..b8c4cc9e3a8 100644
--- a/src/Tasks.UnitTests/PortableTasks_Tests.cs
+++ b/src/Tasks.UnitTests/PortableTasks_Tests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -54,7 +55,7 @@ private void RunMSBuildOnProjectWithPortableTaskAndAssertOutput(bool useDesktopM
 
                 // "Debug", "netstandard1.3"
                 DirectoryInfo ProjectFileFolder =
-                    new DirectoryInfo(PortableTaskFolderPath).EnumerateDirectories().First().EnumerateDirectories().First();
+                    new DirectoryInfo(PortableTaskFolderPath).EnumerateDirectories().First().EnumerateDirectories().First(n => n.Name.Equals("netstandard2.0", StringComparison.OrdinalIgnoreCase));
 
                 foreach (var file in ProjectFileFolder.GetFiles())
                 {