Skip to content
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
799 lines (643 sloc) 31.7 KB


  • Interactive mode: Option to execute external processes such as dotnet, git, docker...

  • Options completion in interactive mode for tasks that run's external process

currently tab completion is available for all dotnet commands, most of git commands, coverlet, sqlcmd, gitversion. It is planned that all docker, azure, npm, octopus commands will support tab completion in near feature. FlubuCore interactive mode

  • Interactive mode: help for targets and options

FlubuCore interactive mode

  • interactive mode: reload or load another script

You can load new script with following commands in interactive mode: load -s=newscript.cs l -s=newscript cs

You can reload script with the following command: reload r

  • Override existing options or add additional options to tasks through console improvements

Let's say you have target (this is just simple dummy example)

    .AddCoreTask(x => x.Build("MySolution.sln").Configuration("Release"); 
    .AddCoreTask)x => x.Pack("ExampleProject");
You could just write in console

flubu build -c=Debug

flubu would execute

dotnet build MySolution.sln -c Debug

  • interactive mode: navigation between folders
  • fixed terminal entered command. Flubu executed sugestion instead of actually entered command
  • FetchBuildVersionFromFile: Fixed default locations output
  • Fixed additional options prefixes


  • FlubuCore interactive mode which offers target tab completition, options tab completition, toogle targets and options, executed commands history and more.

FlubuCore interactive mode

  • Targets: Execute another target within target with AddTarget.
    protected override void ConfigureTargets(ITaskContext context)
       var exampleB = context.CreateTarget("TargetB")

           .AddCoreTask(x => x.Build())
           .AddTarget(exampleB)  //Target is executed in the order it was added

    public void JustAnExample(ITaskContext context)
  • Target: Add tasks to target with a foreach loop.
  protected override void ConfigureTargets(ITaskContext context)
         var solution = context.Properties.Get<VSSolution>(BuildProps.Solution);

                .ForEach(solution.Projects, (item, target) =>
                    target.AddCoreTask(x => x.Pack().Project(item.ProjectName))
                          .Do(JustAnExample, item);

  private void JustAnExample(ITaskContext context, VSProjectInfo vsProjectInfo)
        //// Do something.
  • Override existing options or add additional options to tasks through console

      Let's say you have target

    .AddCoreTask(x => x.Build("MySolution.sln").Configuration("Release"); 

      and you wan't to build solution in debug configuration.

      You could just write in console

flubu build /o:configuration=Debug


flubu build /o:c=Debug

      flubu would execute

dotnet build MySolution.sln -c Debug

  • sequentiall logging in asynchronus executed tasks and targets.
        .AddCoreTaskAsync(x => x.Pack())
        .AddCoreTaskAsync(x => x.Pack())
        .DependsOnAsync(test2, test3);
  • New plugins are available: Chocolatey, Gitter and Slack plugin.
  • Added Get solution infromation as task context extension
  • Added support for multiple Musts on target
  • Logs have now indentation for better readability.
  • Logs have now timemark (actions that takes more than 2sec).
  • Improved build summary in logs.
  • Loged build finish time and build duration
  • Fixed GitVersionTask
  • Targets: Must now accepts optional error message parameter.
  • UpdateNetCoreTask can now write version quality(version suffix)
  • FetchBuildVersionFromFile can now fetch version quality(version suffix).
  • FetchBuildVersionFromFile improved logging.
  • Added options to set versions in dotnet tasks (dotnet build, dotnet pack, dotnet publish)
  • LoadSoluationTask returns solution information
  • Added WithArgument to IRunProgramTask interface
  • Fixed check of unknown targets.


  • Fixed build status
  • Improved message when build script is not found.


  • Added coverlet task .AddCoreTask(x => x.CoverletTask("assembly.dll")
  • Adds flubu setup where you can set location of the build script and project file. run flubu setup
  • Added When condition to all tasks.
 var compile = context
            .SetDescription("Compiles the VS solution")
            .AddCoreTask(x => x.Build().Configuration("Release").When(
            () =>
                return context.BuildSystems().IsLocalBuild;

            }, task => { task.Configuration("Debug"); }));
  • Fixed bug where nuget and assemlby references were not loaded if csproj didnt have both of them
  • Adds OnBuildFailed event.
public class BuildScript : DefaultBuildScript
    protected override void OnBuildFailed(ITaskSession session, Exception ex)
  • Adds before and after target execution events.
    protected override void BeforeTargetExecution(ITaskContext context)

    protected override void AfterTargetExecution(ITaskContext context)
  • Adds before and after build execution events.
    protected override void BeforeBuildExecution(ITaskContext context)

    protected override void AfterBuildExecution(ITaskSession session)
  • Improved nunit tasks fluent intefaces.
  • Added skipped target dependencies and tasks logging.
  • Publicly exposed task name.
  • fixed one of the default build script csproj locations.


  • Fixes Must on target fluent interface.
  • Fixes script when using partial classes. Script failed in some scenarios.
  • script allows includes of other cs files in partial classes.
  • System.Drawing.Primitives assembly reference doesn't need to be referenced exlicitly anymore in script uses collored logging (issue was only present when target .net core framework)
  • Improved some script error messages.


  • Fixes loading of nuget packages that don't have target framework specified.
  • FetchBuildVersionFromFileTask: Improves fetching of version from file by allowing version to be in any line not just first.
  • FetchBuildVersionFromFileTask: Adds default project version file locations.
  • FetchBuildVersionFromFileTask: Adds option to remove prefix from version.
  • FetchBuildVersionFromFileTask: Adds option to allow any suffix.
  • Improves error messages when cs files that are used in script are not included.
  • Improves error messages when script assembly references are not loaded.
  • Added Null and empty target name validation.


  • Added IncludeFromDirectoryAttribute: Attribute adds all .cs files from specified directory. With second optional parameter you can include subdirectories.
public class BuildScript : DefaultBuildScript
  • AssemblyFromDirectoryAttribute: When added on script class FlubuCore should add all assemblies from specified directory to script.
    public class BuildScript : DefaultBuildScript
  • Load base script class automatically. Must be in same directory as script.
  • Improved collored console logging by wrapping strings of the output in ANSI codes that instruct the terminal to color the string based on the interpreted code.
  • Allow namespaces in included cs files. Executing script does not fail anymore if included cs file contain namespace.
  • Disable collored logging with attribute or script argument.


  • Fixed attribute "directives"


  • Fixes restoring and loading of nuget packages with old csproj
  • Stylecop nuget packages are not loaded anymore
  • build status is now logged with color.
  • Target and task information is now logged with color.


  • Resolve nuget packages from build script csproj file automatically. No need for directives in build scripts anymore when executing script that is in project. For standalone scripts you still need directives.
  • Load referenced libraries from build csproj file automatically. No need for directives in build scripts anymore when executing script that is in project. For standalone scripts you still need directives.
  • All nuget dependencies are loaded automatically.
  • Added GitVersionTask: GitVersion is a tool to help you achieve Semantic Versioning on your project. Documentation
         .AddTask(x => x.GitVersionTask());
  • Automatic load of build script partial classes. Partial classes have to be in same directory as build script.
  • Automatic update of FlubuCore web api to new version. Just navigate to /UpdateCenter
  • Added small web app to FlubuCore web api for executing scripts. Navigate to /Script
  • Pass console and config arguments to targets defined with attribute
 [Target("ExampleTarget", "Default string")]     
 [Target("ExampleTarget2", "Default2 string")]
 public void Example(ITarget target, [FromArg("e")]string Example)
     target.Do(x => { x.LogInfo(boo });

dotnet flubu ExampleTarget -e=Hello


dotnet flubu ExampleTarget -Example=Hello

  • load assembly references, nuget references through script class attributes. Alternative to directives.
[NugetPackage("Newtonsoftjson", "11.0.2")]
[Reference("System.Xml.XmlDocument, System.Xml, Version=, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class BuildScript : DefaultBuildScript
  • Added Must method to target fluent interface. Condition in must will have to be meet otherwise target execution will fail before any task get executed.

  • Option to execute custom code before each target execution(target dependencies are excluded). Just override following methods:

 protected override void BeforeTargetExecution(ITaskContext context)

  protected override void AfterTargetExecution(ITaskContext context)
  • Colored console logging
  public void Example(ITaskContext context)
        context.LogInfo("Some text", ConsoleColor.DarkGray, ConsoleColor.DarkMagenta);
        context.LogInfo("Some Text2", ConsoleColor.Blue);
        context.LogError("Error", ConsoleColor.Blue);
  • FetchVersionFromExternalSourceTask now supports following build systems : Bamboo, Bitrise, ContinousCl, Jenkins, TFS, TeamCity, TravisCI.

  • CompileSolutionTask: support for VS2019

  • Restoring of nuget packages has fallback to msbuild now if dotnet core sdk is not installed

  • New Config attribute: Disable load of script references from csproj

  • New Config Attribute: Always recompile build script

  • Expose the output of ExternalProcessTaskBase

  • Fix: Specifing flubu script path in config file does not work

  • Fix: BuildScript assembly is not recompiled when included cs files are changed

  • Fix: Added interactive method to task fluent interface.

  • Fixed switched capture output and capture error output

  • Fixed GetRemoveFileTask base methods (null reference exception)

  • Fixed GitPushFileTask base methods (null reference excetpion).

  • Fixed GitAddTask base methods (null reference excetpion).

  • External process task return type is now generic

  • script key is now case insensitive in file configuration.

  • switched from Microsoft.Extensions.CommandLineUtils to McMaster.Extensions.CommadLineUtils

  • Minor visual improvements when displaying help.

  • Added Net462 Web api deploy package for x86

  • Added some more default build script locations.

FlubuCore 2.14.0

  • Add support for interactive task members.


    protected override void ConfigureTargets(ITaskContext context)
                .AddTask(x => x.CompileSolutionTask()
                    .Interactive(m => m.BuildConfiguration("default value if interactive mode disabled or value is 
                     passed as argument."), consoleText: "Enter build configuration:"));

                 "default value if interactive mode disabled or value is passed as argument", 
                  options => { options.Interactive(m => m.Param, "-test", consoleText: "Enter example value to print to console:"); });

    private static void Example2(ITaskContext context, string value)
        context.LogInfo($"Entered: {value}");

If u run target Example2 from console u will be prompted by Flubu to enter value which will be then printed to console.

  • Flubu now supports cleanup actions when hitting control + c.. If u want that cleanup actions are performed You have to explicitly set parameter in task Finally method or in group parameter.

Bellow is example in which FlubuCore performs specified cleanup actions when hitting control + c or control + break (two optional parameters with true value are added)

            target =>
                    .AddTaskAsync(task =>
                            .Run("postgres:10.5", string.Empty)
                            .Finally(innerContext => innerContext.LogInfo("Testing1"), true));
            }, innerContext => { innerContext.LogInfo("Testing2"); },
            cleanUpOnCancel: true);  
  • Improves logging on web api client tasks.
  • (Possible breaking change)Removed obsolete methods from some tasks
  • Adds option to set destination package folder in CreateZipPackageFromProjcet tasks. Currently only default destination folder could be used.


  • Added docker generated tasks
  • (Breaking changes) Old Docker task's that were previously manually implemented were overwriten with generated task.
    • Docker tasks that used property of type List<> were replaced with params.
    • Some method names in docker tasks were renamed to the same name as it is option name in the docker command.
  • Improved target fluent interface intelisense by adding methods from base interface.
  • GitBranch information can be readed for jenkins build system. context.BuildSystems().Jenkins().GitBranch;
  • WebApi increased max size limit of uploaded content

FlubuCore 2.12.0

  • Added Git tasks:Clone, Pull Add, Commit, Push, Tag, RemoveFilesTask

  • Added Docker tasks: Build, Run, Stop, RemoveContainer, RemoveImage


FlubuCore 2.11.0

  • FlubuCore cake plugin which allows you to use any cake addin in FlubuCore.
  • Added FlubuCore specific code analyzers. Added target parameter analyzers when specifing target's with Target attribute. Added FromArg attribute analyzer.
  • Greatly improved performance for .net core.
  • Improved nuget package resolving performance.

FlubuCore 2.10.0

  • Json configuration file can now be specified by machine name. FlubuSettings.{MachineName}.Json
  • Added WaitForDebugger task context extension.

FlubuCore 2.9.0

FlubuCore 2.8.2

  • FlubuCore is now available as .net core global tool. dotnet tool install --global FlubuCore.GlobalTool

  • Flubu dotnet cli tool and web api is now available for .net core 2.1.

  • Console arguments, configuration properties, enviroment variables can now be passed to script properties with FromArg attribute. Property doesn't need to have attribute. Argument key in that case is same as the property name.

    public class SimpleScript : DefaultBuildScript
      [FromArg("-sn", "If true app is deployed on second node. Otherwise not.")]
      public bool deployOnSecondNode { get; set; }
      protected override void ConfigureBuildProperties(IBuildPropertiesContext context)
      protected override void ConfigureTargets(ITaskContext context)
              .AddTask(x => x.FlubuWebApiTasks().GetTokenTask("user", "pass").SetWebApiBaseUrl("noade1Url"))
              .AddTask(x => x.FlubuWebApiTasks().UploadPackageTask("packageDir", "*.zip"))
              .AddTask(x => x.FlubuWebApiTasks().ExecuteScriptTask("Deploy", "DeployScript.cs"))
              .Group(target =>
                  target.AddTask(x => x.FlubuWebApiTasks().GetTokenTask("user", "pass").SetWebApiBaseUrl("noade2Url"))
                             .AddTask(x => x.FlubuWebApiTasks().UploadPackageTask("packageDir", "*.zip"))
                             .AddTask(x => x.FlubuWebApiTasks().ExecuteScriptTask("Deploy", "DeployScript.cs"));
                   when: c => deployOnSecondNode);

You could then pass argument to property like so:

Dotnet flubu Deploy.Example -sn=true

  • Target's can now be defined with attribute on method.

      [Target("targetName", "a", "b")]
      [Target("targetName2", "c", "d")]
      [Target("targetName3", "e", "f")]
      public void Example(ITargetFluentInterface target, string source, string destination)
              target.AddTask(x => x.CopyFileTask(source, destination, true));

Flubu 2.7.0

  • Added Xunit task - For running xunit tasks with xunit console runner.

  • WebApi: Option to include flubu web api server logs into ExecuteScript response.

  • WebApi: Option to include StackTrace to error response.

  • Added Build system providers - You can acces various build, commit... information for various build systems (such as Jenkins, TeamCity, AppVeyor, Travis...)

    protected override void ConfigureTargets(ITaskContext context)
          bool isLocalBuild = context.BuildSystems().IsLocalBuild;
          var gitCommitId = context.BuildSystems().Jenkins().GitCommitId;
  • Added conditonal task execution with when cluase on single task (see bellow for group of tasks)

         .AddTask(x => x.CompileSolutionTask())
         .AddTask(x => x.PublishNuGetPackageTask("packageId", "pathToNuspec"))
             .When(c => c.BuildSystems().Jenkins().IsRunningOnJenkins);
  • Added finally block on single task. Finally block acts just like finally in try catch (see bellow for group of tasks)

          .AddTask(x => x.CompileSolutionTask())
          .AddTask(x => x.PublishNuGetPackageTask("packageId", "pathToNuspec")
              .Finally(c => c.Tasks().DeleteFilesTask("pathtoNuspec", "*.*", true).Execute(c)));
  • Added onError block on single task. You can perform some custom action when error occures on single task(see bellow for group of tasks)

          .AddTask(x => x.CompileSolutionTask())
          .AddTask(x => x.PublishNuGetPackageTask("packageId", "pathToNuspec")
              .OnError((c, ex) => c.Tasks().DeleteFilesTask("pathtoNuspec", "*.*", true).Execute(context)));
  • Added conditonal task execution with When clause on group of tasks.

    protected override void ConfigureTargets(ITaskContext context)
         .AddCoreTask(x => x.Build())
             target =>
                 target.AddCoreTask(x => x.Pack());
                 target.AddCoreTask(x => x.NugetPush("pathToPackage"));
             when: c => !c.BuildSystems().Jenkins().IsRunningOnJenkins);
  • Finally on group of tasks: Added onFinally block on group of tasks. onFinally acts just like finally in try/catch.

              .AddCoreTask(x => x.Build())
                  target =>
                      target.AddCoreTask(x => x.Pack());
                      target.AddCoreTask(x => x.NugetPush("pathToPackage"));
                  onFinally: c =>
                      c.Tasks().DeleteFilesTask("pathToNupkg", "*.*", true).Execute(c);
  • OnError on group of tasks: You can perform some custom action when error occures in any of tasks that are in group.

          .AddCoreTask(x => x.Build())
              target =>
                  target.AddCoreTask(x => x.Pack());
                  target.AddCoreTask(x => x.NugetPush("pathToPackage"));
              onError: (c, error) =>
                 //// some custom action when error occures in any of the task in group.

Flubu 2.6.0

  • Added option to add multiple tasks, dependencies With (anonimous) method to target with Do method.

      protected override void ConfigureTargets(ITaskContext context)
              .Do(Deploy, @"C:\Web", "AppPool_Preprod", "PreProduction");
              .Do(Deploy, @"d:\Web", "AppPool_Prod", "Production");
      public void Deploy(ITargetFluentInterface target, string deployPath, string appPoolName, string enviromentName)
          target.AddTask(x => x.IisTasks().ControlAppPoolTask(appPoolName, ControlApplicationPoolAction.Stop))
              .AddTask(x => x.DeleteDirectoryTask(deployPath, false).Retry(30, 5000))
              .AddTask(x => x.CreateDirectoryTask(deployPath, false))
              .AddTask(x => x.CopyDirectoryStructureTask(@"Packages\WebApi", deployPath, true))
              .AddTask(x => x.IisTasks().ControlAppPoolTask(appPoolName, ControlApplicationPoolAction.Start));

Flubu 2.5.0

  • Added create HttpClient task.

Flubu 2.4.0

Flubu 2.3.0

  • Option to pass through arguments to tasks

          .AddTask(x => x.CompileSolutionTask()
              .ForMember(m => m.BuildConfiguration("Release"), "c"));
      //// alternatively you can get argument value like this:
      string configuraiton = context.ScriptArgs["c"];

You can execute target with -c argument:

build.exe ExampleTarget -c=Debug

You can also set value in configuration file (flubusettings.json) or through enviroment variable. See for more info.

Flubu 2.0.0

  • Added support for multiple target execution in script runner.
  • Added task for executing powershell scripts.
  • Added NunitWithDotCover task.
  • Added option to get predefined build properties - See build script fundamentals for more info.

  • add support for setting verbosity and other logging properties for msbuild (Compile Task).
  • Improved ServiceControlTask inteface.
  • Added CreateService task.
  • All Task that uses external program now implements external process tasks interface(Improved usability).

  • dotnet-flubu is now also build in .netcoreapp 1.0 target framework to support older versions.

  • added support for finding and using MSBuild 15.0 in builds.
  • All tasks that uses external programs have now fluent interface to add custom arguments.
  • Improved dotnet core task fluent interface.
  • Added GetEnviromentVariable extension method to TaskContext.

  • if not target specified and not default target, display help.

  • added SleepTask.
  • added Sc.exe task.
  • added generic interface for external process tasks.

  • Fixed script arguments pass through on flubu runner and dotnet-flubu cli tool.

  • Fixed NoLog ITask interface.

  • Option to disable task logging.

  • Updated SqlCmdTask (do not escape args).

  • merged replaceToken and replaceText tasks.

  • added standard sqlcmd params.

  • Added SqlCmd task with output capture support.
  • Added capture output support for RunProgramTask.

  • fixed compile task (correctly pass arguments to msbuild).

  • updated compile task to support workingFolder and any params for msbuild.
  • fixed il merge generation with libz container.

  • Fixed references to system assemblies in .net 462 which caused stackoverflow exception in flubu.runner in atleast package task.

  • Fixed PackageTask logging.

  • Fixed retry on tasks.

  • Fixed binding redirect for System.Security.Cryptography.Algorithms.
  • Display flubu version info.

  • Flubu is now build with .net core sdk 2.0 on build serve.

  • fixed flubuCore runner binding redirects.

  • Dotnet-flubu now targets netcoreapp1.1.

  • Added SqlCmd task for executing MS SQL scripts.
  • FlubuCore: Fixed generic parameters in Do Task.
  • FlubuCore: Removed verbose switch for default NUnit 3 task. Issues with nunit 3.7.

  • FlubuCore: Fixed web api set of base url when doing more that one request in one target.
  • FlubuCore: Added option to add generic parameters to Do task.

  • FlubCore: All tasks have now retry mechanism option.
  • FlubuCore: All tasks have now do not fail option.

  • FlubuCore, WebApi: Added option to pasthrough arguments to targets and custom tasks.
  • FlubuCore: Added upload script task.
  • FlubuCore: Added delete packages task.
  • FlubuCore: Fixed web api base url set through build propertis.
  • WebApi: Added option to upload scripts to web api through web api method.
  • WebApi: Fixed CommandArguments lifestyle.
  • WebApi: Only scripts in script directory can now be executed.

  • Fixed UploadPackageTask.
  • web api ip white list access restriction.

  • Added flubu web api GetToken task.
  • Improved flubu web api UploadPackageTask and ExecuteScriptTask.
  • Added web api documentation.

  • Added FlubuCore web api for remote script execution.
  • Added FlubuCore web api client.
  • Added Flubu web api tasks to FlubuCore.

  • Removed Client from FlubuCore.

  • Upgraded nuget packages.

  • Added generic DoNotFailOnError setting for tasks.

  • Updated nuget packages.
  • Fixed ControlAppPoolTask missing dependencie.

  • Fixed version information in GenerateCommonAssemblyInfo task extension.
  • GenerateCommonAssemblyInfo task extension has now GenerateCommonAssemblyInfo task action parameter.
  • BREAKING CHANGE: Improved core pacakge extension tasks.
  • Improved some others task extensions with task action parameter.

  • Added do not fail option to run program task.

  • Fixed dotnet core fluent interface for dotnet restore build and publish.

  • Fixed dotnet core tasks (build, restore, clean, publish,) when no project name is defined.

  • BREAKING CHANGE updated flubu.core and flubu.runner .net framework from .net4.6 to .net.462.

  • Added support for including other .cs files into buildscript with //#imp {PathToCsFile}.
  • Added dotnet nuget push task.
  • Added dotnet entity framework task.
  • CompileSolutionTask: Improved Msbuild path locator Using Microsoft tool location helper now. Registry locator is now used as fallback .
  • Solution name and configuration are now added form build props in DotNet specific tasks if not specified explicitly.
  • PackageTask: Added option to disable logging of which files were filtered and copied.
  • Updated flubu dependencies. No release candidates are referenced anymore. See for more info.

  • Updated Microsoft.Web.Administration from 10.0.0-rc1 to 10.0.0 used for iis tasks.
  • CompileSolution task now supports specifing your own paths to Msbuild. If msbuild path is not specified or not found MsBuild is still searched at default locations.
  • SSH command capture output stream directly.
  • SSH command task fixes.
  • Added SSH support for entering password.
  • Added support for executing multiple commands in one session.
  • Added support for SSH. SshCommand and SshCopy tasks.
  • CreateApplicationPool iis task: .Net clr version can now be set.
  • All iis tasks have now fluent interface.
  • Fixed iis task interfaces. They now contain Execute and ExecuteVoid methods.
  • PackageTask - fixed issue when output zip file name contains more than one dot.
  • Added support for external assembly loading by assembly relative path
  • Target names are case insensitve now
  • If target to be run does not exist help is now shown instead of default target being run.
  • Build script can now contain namespace
  • Added support for external reference based on type loading.
  • Added support for external assembly loading by assembly full path.
  • Do in Target is now a task.
  • BREAKING CHANGE: Do is now executed in the order specified in build script and not anymore before all tasks.
  • Added DoAsync to target: For asynchronus custom code execution.
  • Added AddTaskAsync to target: For asynchronus task execution.
  • Added DependsOnAsync to Target: For asynchronus target dependencies execution.
  • All tasks have now ExecuteAsync method.
  • Added explicit System.IO reference to Roslyn scripting engine.
  • Added LogInfo and LogError to TaskContext.
  • Added fluent interface to PublishNugetPackageTask.
  • Added fluent interface to CopyDirectoryStructureTask.
  • Added fluent interface to FetchBuildVersionFromFileTask.
  • Added fluent interface to UpdateXmlFileTask.
  • Added fluent interface to ReplaceTokensTask.
  • moved packaging filters to it's own namespace.
  • Added FlubuCore and dotnet-flubu nuget metadata.
  • Minor fixes.
  • Flubu.Runner now works without any manual config modifications.
  • Task fluent interface documentation.
  • Added Dotnet specific tasks and extensions.
  • BREAKING CHANGE: Splited TaskExtensions into CoreTaskExtensions and TaskExtensions.
  • Updated nuget packages to latest version.
  • Removed dotnet test -xml output parameter. It won't work under VS2017 RC.
  • BREAKING CHANGE: Removed DependsOn by TaskExtensionsFluentInterface from TargetFluentInterface. Use BackToTarget instead on TaskExtensionFluentInterface.
  • System tests.
  • CompileSolutionTask - specific platform can be set now. Default is still AnyCPU.
  • CompileSolutionTask - Custom arguments can be added now.

  • Added FlubuCore.Runner for .net 4.6. N/A
You can’t perform that action at this time.