abstract class WorkerTask extends DefaultTask {
                @Inject
                abstract WorkerExecutor getWorkerExecutor()

                @Internal
                abstract DirectoryProperty getGradleUserHome()

                @TaskAction
                void doWork() {
                    (1..8).each {
                        workerExecutor.processIsolation().submit(ToolSetupWorkAction) {

    MyObjectFactoryTask(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory
    }

    @TaskAction
    void doTaskAction() {
        var outputDirectory = objectFactory.directoryProperty()
        outputDirectory.convention(project.layout.projectDirectory)
        println(outputDirectory.get())
    }
}

tasks.register("myInjectedObjectFactoryTask",MyObjectFactoryTask) {}

    @get:OutputDirectory
    abstract val metadataOutputDir: DirectoryProperty

    @get:InputDirectory
    @get:IgnoreEmptyDirectories
    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val compiledPluginsBlocksDir: DirectoryProperty

    @get:Internal
    internal
    lateinit var plugins: List<PrecompiledScriptPlugin>

    @get:InputFiles

        "RegularFileProperty"         | "File"           | "self.getProperty().getAsFile().getOrNull()"     | ".fileValue(arg0)" | [File]
        "DirectoryProperty"           | "File"           | "self.getProperty().getAsFile().getOrNull()"     | ".fileValue(arg0)" | [File]

In this context, properties in Gradle act as references to the actual values behind them, allowing Gradle to track inputs and outputs between tasks.

For the input of our task, we use a `DirectoryProperty` from Gradle.
We annotate it with `@InputDirectory` to indicate that it is an input to the task:

====
[.multi-language-sample]
=====
.buildSrc/src/main/kotlin/GenerateReportTask.kt
[source,kotlin]

abstract class MyObjectFactoryTask
@Inject constructor(private var objectFactory: ObjectFactory) : DefaultTask() {

    @TaskAction
    fun doTaskAction() {
        val outputDirectory = objectFactory.directoryProperty()
        outputDirectory.convention(project.layout.projectDirectory)
        println(outputDirectory.get())
    }
}

tasks.register("myInjectedObjectFactoryTask", MyObjectFactoryTask::class) {}

    def "convention mapping can be used with FileSystemLocation properties and a #valueType value"() {
        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract DirectoryProperty getFoo()
                @Internal abstract RegularFileProperty getBar()

                @TaskAction
                void useIt() {
                    assert foo.asFile.get().name == "foo"

            abstract class ZipSrc extends DefaultTask {
                @Internal
                int countResolved

                @Internal
                abstract DirectoryProperty getSources()

                @InputFiles
                abstract ConfigurableFileCollection getSourceFiles()

                @OutputFile
                abstract RegularFileProperty getZipFile()

                destinationDir = file('build/extract')
            }
            interface ExtracterParameters extends WorkParameters {
                RegularFileProperty getArchiveFile()
                DirectoryProperty getDestinationDir()
                Property<Integer> getIndex()
            }
            abstract class Extracter implements WorkAction<ExtracterParameters> {
                @Inject

                @Internal
                final Property<Directory> propValue

                @Inject
                SomeTask(ObjectFactory objects) {
                    propValue = objects.directoryProperty()
                }

                @TaskAction
                void run() {
                    println "value = " + value
                    println "value.child = " + value.dir("child")