# ResolutionStrategy

API Documentation: | `ResolutionStrategy`

Defines the strategies around dependency resolution. For example, forcing certain dependency versions, conflict resolutions or snapshot timeouts.

Examples:

    configurations.all {
      resolutionStrategy {
        // fail eagerly on version conflict (includes transitive dependencies)
        // e.g. multiple different versions of the same dependency (group and name are equal)
        failOnVersionConflict()

        // force certain versions of dependencies (including transitive)
        //  *append new forced modules:
        force 'asm:asm-all:3.3.1', 'commons-io:commons-io:1.4'
        //  *replace existing forced modules with new ones:
        forcedModules = ['asm:asm-all:3.3.1']

        // cache dynamic versions for 10 minutes
        cacheDynamicVersionsFor 10, 'minutes'
        // don't cache changing modules at all
        cacheChangingModulesFor 0, 'seconds'
      }
    }

### Properties

Property | Description
`forcedModules` | Returns currently configured forced modules. For more information on forcing versions see `ResolutionStrategy.force()`

### Property details

#### ``Set`<`ModuleVersionSelector`>` `forcedModules`

Returns currently configured forced modules. For more information on forcing versions see `ResolutionStrategy.force()`

### Script blocks

No script blocks

### Methods

Method | Description
`cacheChangingModulesFor(value, units)` | Sets the length of time that changing modules will be cached, with units expressed as a String.
`cacheChangingModulesFor(value, units)` | Sets the length of time that changing modules will be cached.
`cacheDynamicVersionsFor(value, units)` | Sets the length of time that dynamic versions will be cached, with units expressed as a String.
`cacheDynamicVersionsFor(value, units)` | Sets the length of time that dynamic versions will be cached.
`failOnVersionConflict()` | In case of conflict, Gradle by default uses the newest of conflicting versions. However, you can change this behavior. Use this method to configure the resolution to fail eagerly on any version conflict, e.g. multiple different versions of the same dependency (group and name are equal) in the same `Configuration`. The check includes both first level and transitive dependencies. See example below:
`force(forcedModuleNotations)` | Allows forcing certain versions of dependencies, including transitive dependencies. Appends new forced modules to be considered when resolving dependencies.

### Method details

#### `void` `cacheChangingModulesFor`(`int` value, `String` units)

Sets the length of time that changing modules will be cached, with units expressed as a String.

A convenience method for `ResolutionStrategy.cacheChangingModulesFor()` with units expressed as a String. Units are resolved by calling the `valueOf(String)` method of `TimeUnit` with the upper-cased string value.

#### `void` `cacheChangingModulesFor`(`int` value, `TimeUnit` units)

Sets the length of time that changing modules will be cached.

Gradle caches the contents and artifacts of changing modules. By default, these cached values are kept for 24 hours, after which the cached entry is expired and the module is resolved again.

Use this method to provide a custom expiry time after which the cached entries for any changing module will be expired.

#### `void` `cacheDynamicVersionsFor`(`int` value, `String` units)

Sets the length of time that dynamic versions will be cached, with units expressed as a String.

A convenience method for `ResolutionStrategy.cacheDynamicVersionsFor()` with units expressed as a String. Units are resolved by calling the `valueOf(String)` method of `TimeUnit` with the upper-cased string value.

#### `void` `cacheDynamicVersionsFor`(`int` value, `TimeUnit` units)

Sets the length of time that dynamic versions will be cached.

Gradle keeps a cache of dynamic version => resolved version (ie 2.+ => 2.3). By default, these cached values are kept for 24 hours, after which the cached entry is expired and the dynamic version is resolved again.

Use this method to provide a custom expiry time after which the cached value for any dynamic version will be expired.

#### `ResolutionStrategy` `failOnVersionConflict`()

In case of conflict, Gradle by default uses the newest of conflicting versions. However, you can change this behavior. Use this method to configure the resolution to fail eagerly on any version conflict, e.g. multiple different versions of the same dependency (group and name are equal) in the same `Configuration`. The check includes both first level and transitive dependencies. See example below:

    configurations.all {
      resolutionStrategy.failOnVersionConflict()
    }

#### `ResolutionStrategy` `force`(``Object`...` forcedModuleNotations)

Allows forcing certain versions of dependencies, including transitive dependencies. Appends new forced modules to be considered when resolving dependencies.

It accepts following notations:

- String in a format of: 'group:name:version', for example: 'org.gradle:gradle-core:1.0'
- instance of `ModuleVersionSelector`
- any collection or array of above will be automatically flattened

Example:

    configurations.all {
      resolutionStrategy.force 'asm:asm-all:3.3.1', 'commons-io:commons-io:1.4'
    }