Optional task dependencies

[ap0llo]

Hi,

I would like to use optional task dependencies as described here in the release notes for Cake 0.23.

As far as I can tell the functionality is still there in e.g. CakeGraphBuilder but it is (no longer?) made available through IsDependentOn()/IsDependeeOf() and is not mentioned in the documentation.
It is also not usable in Cake.Frosting at the moment.

Was there a reason to remove this functionality?

My use case is the following:

• I want to provide some assemblies of reusable Cake.Frosting tasks that can be reused across multiple projects.
• Not all of the projects need all the tasks and can choose to include one or more of the task assemblies.
• If multiple assemblies are included, I still want to ensure the right execution order.

This is exactly what the optional dependency feature does (as far as I understand it): Respect the dependency if both tasks are in the current build but ignore the dependency otherwise.

I'd be happy to provide a PR that adds support for this to Cake.Frosting.

[jasells]

@ap0llo Did you ever find a solution/answer?

My current plan to address this is to define my resuable tasks and a base-BuildContext that defines common arguments in a library project, like so:

public class ResuableTask1 : FrostingTask<CustomBuildContextBaseDef>
{
      public override void Run(CustomBuildContextBaseDef context)
     {
            // custom, but re-usable task logic
     }
}

and in each specific build project's Program.cs:

[TaskName("CiBuildTask1")]
[IsDependentOn(typeof(AnotherCiTask))]
public sealed class CiBuildTask1: ResuableTask1
{  }

and 

[TaskName("UnitTestBuildTask1")]
[IsDependentOn(typeof(AnotherUnitTestTask))]
public sealed class UnitTestBuildTask1: ResuableTask1
{  }

[ap0llo]

I did something similar in my build and did not use the optional dependencies.

I did not however have the need to define any tasks in the build project that derive from the reusable task.
I instead choose to add new "implementation-less" tasks in the build that just wire up the dependencies, something like this:

Library:

[TaskName("Task1")]
public class LibraryTask1  : FrostingTask<IBuildContect>
{
    // ...
}

[TaskName("Task2")]
public class LibraryTask2  : FrostingTask<IBuildContect>
{
    // ...
}

Build:

[TaskName("Build")]
[IsDependentOn(typeof(LibraryTask1))]
[IsDependentOn(typeof(LibraryTask2))]
public class BuildTask : FrostingTask<IBuildContect>
{
    // ...
}

The execution order is the order in which the attributes are defined on BuildTask.

Assuming there there is a dependency between LibraryTask1 and LibraryTask2 (that only exist is both tasks are used), I need to make sure they are added in the right order (not ideal, since I don't even know if the execution order is guaranteed this way), but it works for now.

So in summary, optional dependencies would still be useful to properly model the dependencies but I managed to define a build without it.