ProviderFactory providerFactory = project.getServices().get(ProviderFactory.class);
        Credentials referenceCredentials;
        try {
            Provider<? extends Credentials> credentialsProvider;
            try {
                credentialsProvider = providerFactory.credentials(toCheck.getClass(), identity);
            } catch (IllegalArgumentException e) {

    private final ProviderFactory providerFactory;
    private final ProjectInternal project;
    private final InstanceGenerator instanceGenerator;
    private final Map<ConfigurationInternal, Set<TaskProvider<?>>> configurationToCompileTasks; // ? is really AbstractCompile & HasCompileOptions

    @Inject
    public DefaultJvmLanguageUtilities(
            ProviderFactory providerFactory,

    private final ProviderFactory providerFactory;

    private final AuthenticationSchemeRegistry authenticationSchemeRegistry;

    private boolean mutable = true;

    @Inject
    public DefaultJavaToolchainRepositoryHandler(
            Instantiator instantiator,
            ObjectFactory objectFactory,
            ProviderFactory providerFactory,

        this.providerFactory = providerFactory
    }

    @TaskAction
    void doTaskAction() {
        var outputDirectory = providerFactory.provider { "build/my-file.txt" }
        println(outputDirectory.get())
    }
}

tasks.register("myInjectedProviderFactoryTask",MyProviderFactoryTask) {}
// end::provider-factory-inject[]

// tag::worker-executor[]

tasks.register("printMessage") {
    doLast {
        val providerFactory = project.providers
        val messageProvider = providerFactory.provider { "Hello, Gradle!" }
        println(messageProvider.get())
    }
}
// end::provider-factory[]

// tag::provider-factory-inject[]
abstract class MyProviderFactoryTask
@Inject constructor(private var providerFactory: ProviderFactory) : DefaultTask() {

    @TaskAction

    private final ProviderFactory providerFactory;
    private final Provider<String> toolchainLocation;
    private final XPathFactory xPathFactory;
    private final DocumentBuilderFactory documentBuilderFactory;
    private final FileResolver fileResolver;

    @Inject
    public MavenToolchainsInstallationSupplier(ProviderFactory factory, FileResolver fileResolver) {

    }

    def "workers can inject ProviderFactory service using #isolationMode isolation"() {
        fixture.workActionThatCreatesFiles.extraFields += """
            org.gradle.api.provider.ProviderFactory providerFactory
        """
        fixture.workActionThatCreatesFiles.constructorArgs = "org.gradle.api.provider.ProviderFactory providerFactory"

        this.projectRegistry = new VisualStudioProjectRegistry(fileResolver, instantiator, ideArtifactRegistry, collectionCallbackActionDecorator, objectFactory, providerFactory);
    }

    @Override
    public NamedDomainObjectSet<? extends VisualStudioProject> getProjects() {

        super(instantiator, fileResolver, ideArtifactRegistry, collectionCallbackActionDecorator, objectFactory, providerFactory);
        this.solution = objectFactory.newInstance(DefaultVisualStudioSolution.class, projectName);
    }

    @Override

 * limitations under the License.
 */

package gradlebuild.basics

import org.gradle.api.file.DirectoryProperty
import org.gradle.api.provider.Provider
import org.gradle.api.provider.ProviderFactory
import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import org.gradle.internal.os.OperatingSystem
import javax.inject.Inject