/// <summary>
/// Indicates to the TaskHost that it is no longer needed.
/// Called by TaskBuilder when the task using the EngineProxy is done.
/// </summary>
internal void MarkAsInactive()
{
lock (_callbackMonitor)
{
VerifyActiveProxy();
_activeProxy = false;
// Since the task has a pointer to this class it may store it in a static field. Null out
// internal data so the leak of this object doesn't lead to a major memory leak.
_host = null;
_requestEntry = null;
// Don't bother clearing the tiny task location
_taskLoggingContext = null;
_targetBuilderCallback = null;
// Clear out the sponsor (who is responsible for keeping the EngineProxy remoting lease alive until the task is done)
// this will be null if the engine proxy was never sent across an AppDomain boundary.
if (_sponsor != null)
{
ILease lease = (ILease)RemotingServices.GetLifetimeService(this);
if (lease != null)
{
lease.Unregister(_sponsor);
}
_sponsor.Close();
_sponsor = null;
}
}
}
/// <summary>
/// Create an instance of the wrapped ITask for a batch run of the task.
/// </summary>
internal ITask CreateTaskInstance(ElementLocation taskLocation, TaskLoggingContext taskLoggingContext, IBuildComponentHost buildComponentHost, IDictionary <string, string> taskIdentityParameters,
#if FEATURE_APPDOMAIN
AppDomainSetup appDomainSetup,
#endif
bool isOutOfProc)
{
bool useTaskFactory = false;
IDictionary <string, string> mergedParameters = null;
_taskLoggingContext = taskLoggingContext;
// Optimization for the common (vanilla AssemblyTaskFactory) case -- only calculate
// the task factory parameters if we have any to calculate; otherwise even if we
// still launch the task factory, it will be with parameters corresponding to the
// current process.
if ((_factoryIdentityParameters != null && _factoryIdentityParameters.Count > 0) || (taskIdentityParameters != null && taskIdentityParameters.Count > 0))
{
VerifyThrowIdentityParametersValid(taskIdentityParameters, taskLocation, _taskName, "MSBuildRuntime", "MSBuildArchitecture");
mergedParameters = MergeTaskFactoryParameterSets(_factoryIdentityParameters, taskIdentityParameters);
useTaskFactory = !NativeMethodsShared.IsMono &&
(_taskHostFactoryExplicitlyRequested ||
!TaskHostParametersMatchCurrentProcess(mergedParameters));
}
else
{
// if we don't have any task host parameters specified on either the using task or the
// task invocation, then we will run in-proc UNLESS "TaskHostFactory" is explicitly specified
// as the task factory.
useTaskFactory = _taskHostFactoryExplicitlyRequested;
}
if (useTaskFactory)
{
ErrorUtilities.VerifyThrowInternalNull(buildComponentHost, "buildComponentHost");
mergedParameters = mergedParameters ?? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
string runtime = null;
string architecture = null;
if (!mergedParameters.TryGetValue(XMakeAttributes.runtime, out runtime))
{
mergedParameters[XMakeAttributes.runtime] = XMakeAttributes.MSBuildRuntimeValues.clr4;
}
if (!mergedParameters.TryGetValue(XMakeAttributes.architecture, out architecture))
{
mergedParameters[XMakeAttributes.architecture] = XMakeAttributes.GetCurrentMSBuildArchitecture();
}
TaskHostTask task = new TaskHostTask(taskLocation, taskLoggingContext, buildComponentHost, mergedParameters, _loadedType
#if FEATURE_APPDOMAIN
, appDomainSetup
#endif
);
return(task);
}
else
{
#if FEATURE_APPDOMAIN
AppDomain taskAppDomain = null;
#endif
ITask taskInstance = TaskLoader.CreateTask(_loadedType, _taskName, taskLocation.File, taskLocation.Line, taskLocation.Column, new TaskLoader.LogError(ErrorLoggingDelegate)
#if FEATURE_APPDOMAIN
, appDomainSetup
#endif
, isOutOfProc
#if FEATURE_APPDOMAIN
, out taskAppDomain
#endif
);
#if FEATURE_APPDOMAIN
if (taskAppDomain != null)
{
_tasksAndAppDomains[taskInstance] = taskAppDomain;
}
#endif
return(taskInstance);
}
}
