public static ITaskInteraction Create(
     MSBuildFramework.IBuildEngine buildEngine,
     ITaskOutputHandler outputHandler,
     ITask task,
     IArgumentProvider arguments,
     ITypedServiceProvider services)
 {
     return new BuildTaskInteraction(task, arguments, outputHandler, buildEngine, services);
 }

 private BuildTaskInteraction(
     ITask task,
     IArgumentProvider arguments,
     ITaskOutputHandler outputHandler,
     MSBuildFramework.IBuildEngine buildEngine,
     ITypedServiceProvider services)
     : base (arguments, services)
 {
     this.outputHandler = outputHandler;
     this.loggers = new Lazy<BuildTaskLoggers>(() => new BuildTaskLoggers(buildEngine, task, arguments));
 }

        public static Expression[] VisitArguments(ExpressionVisitor visitor, IArgumentProvider nodes)
        {
            Expression[] newNodes = null;
            for (int i = 0, n = nodes.ArgumentCount; i < n; i++)
            {
                Expression curNode = nodes.GetArgument(i);
                Expression node = visitor.Visit(curNode);

                if (newNodes != null)
                {
                    newNodes[i] = node;
                }
                else if (!object.ReferenceEquals(node, curNode))
                {
                    newNodes = new Expression[n];
                    for (int j = 0; j < i; j++)
                    {
                        newNodes[j] = nodes.GetArgument(j);
                    }
                    newNodes[i] = node;
                }
            }
            return newNodes;
        }

        protected void Initialize(IArgumentProvider arguments)
        {
            string assembliesToResolve = arguments.GetOption<string>(StandardOptions.AssembliesToResolve);
            if (!String.IsNullOrEmpty(assembliesToResolve))
            {
                foreach (string assemblyToResolve in assembliesToResolve.Split(';'))
                {
                    this.AddAssemblyToResolve(assemblyToResolve);
                }
            }

            string resolutionPaths = arguments.GetOption<string>(StandardOptions.AssemblyResolutionPaths);
            if (!String.IsNullOrEmpty(resolutionPaths))
            {
                foreach (string resolutionPath in resolutionPaths.Split(';'))
                {
                    if (!String.IsNullOrWhiteSpace(resolutionPath))
                    {
                        string expandedResolutionPath = Environment.ExpandEnvironmentVariables(resolutionPath);
                        this.AddResolutionPath(expandedResolutionPath);
                    }
                }
            }
        }

            public ConsoleTaskLoggers(ITask task, IArgumentProvider arguments)
            {
                if (arguments.GetOption<bool?>(StandardOptions.Clipboard) ?? task.GetOptionDefault<bool>(StandardOptions.Clipboard[0]))
                {
                    this.richTextLogger = new RichTextLogger();
                    this.csvLogger = new CsvLogger();
                    this.textLogger = new TextLogger();
                    this.spreadsheetLogger = new XmlSpreadsheetLogger();
                    this.aggregatedLogger = new AggregatedLogger(
                        ConsoleLogger.Instance,
                        this.richTextLogger,
                        this.spreadsheetLogger,
                        this.csvLogger,
                        this.textLogger);

                    this.RegisterLogger(LoggerType.Result, this.aggregatedLogger);
                }
                else
                {
                    this.RegisterLogger(LoggerType.Result, ConsoleLogger.Instance);
                }

                this.RegisterLogger(LoggerType.Status, ConsoleLogger.Instance);
            }

 public TestArgumentSettingsProvider(string settingsSection, IArgumentProvider argumentProvider, IClientSettings clientSettings)
     : base (settingsSection, argumentProvider, clientSettings)
 {
 }

 public static AssemblyResolver Create(IArgumentProvider arguments, IFileService fileService)
 {
     AssemblyResolver resolver = new AssemblyResolver(fileService);
     resolver.Initialize(arguments);
     return resolver;
 }

 /// <summary>
 /// Execution handler for tasks running under the console.
 /// </summary>
 /// <param name="services">Override services, can be null. Used to get services before falling back on defaults.</param>
 public ConsoleTaskExecution(IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services = null)
     : base(argumentProvider, taskRegistry, services)
 {
 }

 public static AssemblyResolver Create(IArgumentProvider arguments)
 {
     AssemblyResolver resolver = new AssemblyResolver();
     resolver.Initialize(arguments);
     return resolver;
 }

 // assumes 'object' of non-static call is already on stack
 private void EmitMethodCall(MethodInfo mi, IArgumentProvider args, Type objectType)
 {
     EmitMethodCall(mi, args, objectType, CompilationFlags.EmitAsNoTail);
 }

        //CONFORMING
        private void EmitMethodCall(Expression obj, MethodInfo method, IArgumentProvider methodCallExpr) {
            // Emit instance, if calling an instance method
            Type objectType = null;
            if (!method.IsStatic) {
                EmitInstance(obj, objectType = obj.Type);
            }

            EmitMethodCall(method, methodCallExpr, objectType);
        }

 public static ITaskInteraction Create(ITask task, IArgumentProvider arguments, ITypedServiceProvider services)
 {
     return new ConsoleTaskInteraction(task, arguments, services);
 }

 private ConsoleTaskInteraction(ITask task, IArgumentProvider arguments, ITypedServiceProvider services)
     : base(arguments, services)
 {
     this.loggers = new Lazy<ConsoleTaskLoggers>(() => new ConsoleTaskLoggers(task, arguments));
 }

 internal ArgumentPrepender(Expression first, IArgumentProvider provider) {
     _first = first;
     _expression = provider;
 }

 /// <summary>
 /// Execution handler for tasks running under MSBuild.
 /// </summary>
 /// <param name="services">Override services, can be null. Used to get services before falling back on defaults.</param>
 public BuildTaskExecution(MSBuildFramework.IBuildEngine buildEngine, ITaskOutputHandler outputHandler, IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services = null)
     : base(argumentProvider, taskRegistry, services)
 {
     this.outputHandler = outputHandler;
     this.buildEngine = buildEngine;
 }

        public void DoWorkAsync(Action<Object> workAction, IArgumentProvider provider)
        {
            exitState = ExitState.NORMAL;
            CancellationToken token = tokenSource.Token;

            Task mainTask = Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    if (token.IsCancellationRequested) break;
                    try
                    {
                        Object[] args = provider.GetArguments();
                        if (args.Length == 0) break;
                        List<Task> tasks = new List<Task>();
                        foreach (Object arg in args)
                        {
                            if (token.IsCancellationRequested) break;
                            try
                            {
                                Task subtask = Task.Factory.StartNew(workAction, arg, token);
                                subtask.ContinueWith(TaskFailed, TaskContinuationOptions.OnlyOnFaulted);
                                tasks.Add(subtask);
                            }
                            catch
                            {
                                exitState = ExitState.ERROR;
                                tokenSource.Cancel();
                                break;
                            }
                        }
                        try
                        {
                            Task.WaitAll(tasks.ToArray(), tokenSource.Token);
                        }
                        catch (OperationCanceledException) { }
                    }
                    catch
                    {
                        exitState = ExitState.ERROR;
                        break;
                    }
                }
            }, TaskCreationOptions.LongRunning);
            mainTask.ContinueWith(Done, scheduler);
        }

 public abstract ITaskService GetTaskService(ref IArgumentProvider argumentProvider);

 public BuildTaskLoggers(MSBuildFramework.IBuildEngine buildEngine, ITask task, IArgumentProvider arguments)
 {
     BuildLogger logger = new BuildLogger(buildEngine, task.GetType().ToString());
     this.RegisterLogger(LoggerType.Result, logger);
     this.RegisterLogger(LoggerType.Status, logger);
 }

 /// <summary>
 /// Adds child <paramref name="expressions"/> provided through an argument
 /// provider to the rewriter, causing them to be rewritten using the parent
 /// stack spiller, and the evaluation stack state and rewrite action to be
 /// updated accordingly.
 /// </summary>
 /// <param name="expressions">
 /// The argument provider containing the child expression to add.
 /// </param>
 internal void AddArguments(IArgumentProvider expressions)
 {
     for (int i = 0, count = expressions.ArgumentCount; i < count; i++)
     {
         Add(expressions.GetArgument(i));
     }
 }

 /// <summary>
 /// Emits arguments to a call, and returns an array of write-backs that
 /// should happen after the call.
 /// </summary>
 private List<WriteBack> EmitArguments(MethodBase method, IArgumentProvider args)
 {
     return EmitArguments(method, args, 0);
 }