}
            }

            abstract class MyTask extends DefaultTask {
                @Input
                abstract Property<String> getGreeting()

                @TaskAction void run() { println greeting.get() }
            }

            def greetValueSource = providers.of(GreetValueSource) {}
            tasks.register("greet", MyTask) {
                greeting = greetValueSource
            }

            }
        """
        file('build-logic/src/main/groovy/MyTask.groovy') << """
            import org.gradle.api.*
            import org.gradle.api.file.*
            import org.gradle.api.tasks.*
            import org.gradle.workers.*
            import javax.inject.Inject

            abstract class MyTask extends DefaultTask {

            import org.gradle.api.*

            class ${className} implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.create("myTask${className}") {
                        doLast {
                            def closure = {
                                println "From ${className}"
                            }
                            closure()

General::
 * `<<` for task definitions no longer works. In other words, you can not use the syntax `task myTask << { ... }`.
+
Use the link:{groovyDslPath}/org.gradle.api.Task.html#org.gradle.api.Task:doLast(org.gradle.api.Action)[Task.doLast()] method instead, like this:
+
----
task myTask {
    doLast {
        ...
    }
}
----

        given:
        buildFile << """
            class Param<T> {
                T display
                String toString() { display.toString() }
            }

            abstract class MyTask extends DefaultTask {
                @Input
                abstract MapProperty<$keyType, $valueType> getProp()

                @TaskAction
                void go() {

| Returns `void`, so it cannot be chained.

|===

== Eager APIs to avoid

[cols="a,a", options="header"]
|===
| API
| Note

| `task myTask(type: MyTask) {}`
| Do not use the shorthand notation. Use `register()` instead.

| link:{javadocPath}/org/gradle/api/tasks/TaskContainer.html#create-java.util.Map-[TaskContainer.create()]
| Use `register()` instead.

    }

    def "buildSrc is loaded from cache"() {
        configureCacheForBuildSrc()
        file("buildSrc/src/main/groovy/MyTask.groovy") << """
            import org.gradle.api.*

            class MyTask extends DefaultTask {}
        """

        when:
        withBuildCache().run "help"
        then:
        result.assertTaskNotSkipped(":buildSrc:compileGroovy")

This style of property definition is legacy in Gradle and is discouraged:

[source,java]
----
public class MyTask extends DefaultTask {
    private String someProperty;

    public String getSomeProperty() {
        return someProperty;
    }

    public void setSomeProperty(String someProperty) {

                    task.$code
                }
            }

            tasks.register("a", MyTask)
            tasks.register("b", MyTask) {
                doLast(new MyAction())
            }
            tasks.register("c") {
                doFirst(new MyAction())
            }
            tasks.register("d") {
                doFirst { $code }
            }
        """

====
include::sample[dir="snippets/tutorial/stopExecutionException/kotlin",files="build.gradle.kts[]"]
include::sample[dir="snippets/tutorial/stopExecutionException/groovy",files="build.gradle[]"]

----
$ gradle -q myTask
include::{snippetsPath}/tutorial/stopExecutionException/tests/stopExecutionException.out[]
----
====

This feature is helpful if you work with tasks provided by Gradle.