*
 * @since 6.6
 */
@ServiceScope({Scope.Build.class, Scope.Project.class})
public interface ArchiveOperations {

    /**
     * Creates resource that points to a gzip compressed file at the given path.
     * The path is evaluated as per {@link Project#file(Object)}.
     *

        this.archiveOperations = archiveOperations
    }

    @TaskAction
    void doTaskAction() {
        archiveOperations.zipTree("${projectDir}/sources.jar")
    }
}

tasks.register("myInjectedArchiveOperationsTask", MyArchiveOperationsTask) {}
// end::archive-op-inject[]

// tag::exec-op[]
tasks.register('runCommand') {
    doLast {
        exec { // short for project.exec

// tag::archive-op[]
tasks.register("ArchiveOperations") {
    doLast {
        zipTree() { "${project.projectDir}/sources.jar" } // short for project.zipTree
    }
}
// end::archive-op[]

// tag::archive-op-inject[]
abstract class MyArchiveOperationsTask
@Inject constructor(
    private val archiveOperations: ArchiveOperations,
    private val project: Project
) : DefaultTask() {

        val scriptClassPath = scriptHandler.scriptClassPath.asFiles
        classpath = project.files(scriptClassPath)

        val archiveOperations = findArchiveOperations(project)
        val pluginClassesOf = pluginJars.stream()
            .map { zipPath: File? -> archiveOperations.zipTree(zipPath!!) }
            .collect(Collectors.toList())
        classes = project.files(pluginClassesOf)
    }
}

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

package org.gradle.internal.flow.services

import org.gradle.api.file.ArchiveOperations
import org.gradle.api.file.FileSystemOperations
import org.gradle.api.flow.FlowParameters
import org.gradle.internal.instantiation.InstantiatorFactory
import org.gradle.internal.service.DefaultServiceRegistry

 * limitations under the License.
 */

package org.gradle.api.internal.file;

import org.gradle.api.file.ArchiveOperations;
import org.gradle.api.file.FileTree;
import org.gradle.api.resources.ReadableResource;
import org.gradle.api.resources.ResourceHandler;

public class DefaultArchiveOperations implements ArchiveOperations {

    private final FileOperations fileOperations;

====

The `FileSystemOperations` service is injected into the `MyFileSystemOperationsTask` task's constructor using the `@Inject` annotation.

[[archiveoperations]]
== 7. `ArchiveOperations`

link:{javadocPath}/org/gradle/api/file/ArchiveOperations.html[`ArchiveOperations`] is a service that provides methods for creating archives, such as ZIP and TAR files.

                @InputFile abstract RegularFileProperty getInputFile()
                @OutputFile abstract RegularFileProperty getOutputFile()
                @Inject abstract ArchiveOperations getArchives()
                @TaskAction def action() {
                    def outFile = outputFile.get().asFile
                    outFile.parentFile.mkdirs()

                @Inject
                abstract ArchiveOperations getArchiveOperations()

                @Override
                void execute() {
                    // This synchronizes all extracters so they try to start at the same time
                    ${server.callFromBuild("wait")}
                    archiveOperations.tarTree(parameters.archiveFile).visit { fcd ->

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

import org.gradle.api.file.ArchiveOperations
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.DirectoryProperty
import org.gradle.api.file.FileSystemOperations
import org.gradle.api.file.FileTree