filter { line: String -> line.reversed() }
        }
    }
}

// The WorkerExecutor will be injected by Gradle at runtime
abstract class ReverseFiles @Inject constructor(
    private val projectLayout: ProjectLayout,
    private val workerExecutor: WorkerExecutor
) : SourceTask() {

    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty

    @TaskAction
    fun reverseFiles() {

        assert workerDaemonSets[0] == workerDaemonSets[1]
    }

    String getTaskTypeUsingWorkerDaemon() {
        return """
            import org.gradle.api.file.ProjectLayout
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.internal.WorkerDaemonFactory

            abstract class TestWorkAction implements WorkAction<WorkParameters.None> {

    public DefaultVisualStudioSolution(String name, ObjectFactory objectFactory, IdeArtifactRegistry ideArtifactRegistry, ProviderFactory providers, ProjectLayout projectLayout) {
        this.name = name;
        this.solutionFile = objectFactory.newInstance(SolutionFile.class, getName() + ".sln");
        this.location = projectLayout.file(providers.provider(new Callable<File>() {
            @Override
            public File call() {

public class NativeBinaryRules extends RuleSource {
    @Defaults
    public static void assignTools(NativeBinarySpec nativeBinarySpec, NativeToolChainRegistryInternal toolChains, ProjectLayout projectLayout) {
        assignTools(nativeBinarySpec, toolChains, projectLayout.getBuildDir());
    }

    static void assignTools(NativeBinarySpec nativeBinarySpec, NativeToolChainRegistryInternal toolChains, File buildDir) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.reporting.internal;

import org.gradle.api.Task;
import org.gradle.api.file.ProjectLayout;
import org.gradle.api.internal.IConventionAware;
import org.gradle.api.internal.provider.DefaultProvider;
import org.gradle.api.reporting.DirectoryReport;

import javax.annotation.Nullable;
import javax.inject.Inject;

    private final Compiler<JavaCompileSpec> javaCompiler;
    private final ProjectLayout projectLayout;

    public ApiGroovyCompiler(Compiler<JavaCompileSpec> javaCompiler, ProjectLayout projectLayout) {
        this.javaCompiler = javaCompiler;
        this.projectLayout = projectLayout;
    }

    private static abstract class IncrementalCompilationCustomizer extends CompilationCustomizer {

                                            CachedClasspathTransformer classpathTransformer,
                                            ProjectLayout projectLayout,
                                            ProjectCacheDir projectCacheDir
                                            ) {

            abstract class MyTask extends DefaultTask {
                @Internal abstract ConfigurableFileCollection getFoo()
                @Internal abstract ConfigurableFileCollection getBar()
                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {
                    assert foo.files == layout.files("file1", "file2").files
                    assert foo.files.size() == 2
                }

====

The `MyObjectFactoryTask` task uses an `ObjectFactory` instance, which is injected into the task's constructor using the `@Inject` annotation.

[[sec:projectlayout]]
== 2. `ProjectLayout`

link:{groovyDslPath}/org.gradle.api.file.ProjectLayout.html[`ProjectLayout`] is a service that provides access to the layout of a Gradle project's directories and files.

 * from a {@link Directory} instance using the {@link Directory#file(String)} method or via various methods on {@link ProjectLayout} such as {@link ProjectLayout#getProjectDirectory()}.
 *
 * @since 4.1
 */
public interface RegularFile extends FileSystemLocation {
    /**
     * Returns the location of this file, as an absolute {@link File}.
     */