}
              }
              setStrings {
                create {
                    add 'b'
                }
              }
              tasks {
                create("print") {
                  doLast {
                    println "mapThings: " + ($.mapThings as List)*.keySet()
                    println "setThings: " + ($.setThings as List)

                    println "setThings: " + $.setThings.keySet()
                    println "setStrings: " + $.setStrings.keySet()
                  }
                }
              }
            }
        '''

        then:
        succeeds "print"

        and:
        output.contains "mapThings: []"
        output.contains "setThings: []"
        output.contains "setStrings: []"

        schema.getProperty('parent').schema == schema
    }

    @Managed
    interface SomeType {
        String getReadOnlyString()

        List<String> getStrings()
        void setStrings(List<String> strings)
    }

    @Managed
    interface Person {
        Person getParent()
    }

        schema.properties*.name == ['parent']
        schema.getProperty('parent').schema == schema
    }

    interface SomeType {
        String getReadOnlyString()

        List<String> getStrings()
        void setStrings(List<String> strings)
    }

    @UnmanagedStruct
    interface SomeStruct {
        String getReadOnlyString()
    }

    interface Person {
        Person getParent()
    }

        schema.properties.isEmpty()
    }

    static abstract class SomeRules extends RuleSource {
        abstract String getReadOnlyString()
        abstract List<String> getStrings()
        abstract void setStrings(List<String> strings)
    }

    def "assembles schema for RuleSource subtype"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeRules))

    public static class TestClass4 {
        @Option(option = 'stringValue', description = "string value")
        public void setStrings(String value1, String value2) {
        }
    }

    public static class TestClass5 {
        @Option(option = 'fileValue', description = "file value")
        public void setStrings(File file) {
        }
    }

    public static class TestClassWithOptionNameClashing {

	return p.prepareInput()
}

// SetString configures s for the given paragraph text. It replaces text
// previously set by SetBytes or SetString. If s contains a paragraph separator
// it will only process the first paragraph and report the number of bytes
// consumed from s including this separator. Error may be non-nil if options are
// given.
func (p *Paragraph) SetString(s string, opts ...Option) (n int, err error) {

	}
	settings := &settings{}
	if err := json.Unmarshal(data, settings); err != nil {
		return nil, fmt.Errorf("could not parse settings: %w", err)
	}
	for i := range settings.Configs {
		settings.Configs[i].resetTransient()
	}
	return settings, nil
}

// writeSettings saves settings to fname.
func writeSettings(fname string, settings *settings) error {
	data, err := json.MarshalIndent(settings, "", "  ")

```Python hl_lines="10"
{!../../../docs_src/settings/app02/config.py!}
```

Beachten Sie, dass wir jetzt keine Standardinstanz `settings = Settings()` erstellen.

### Die Haupt-Anwendungsdatei

Jetzt erstellen wir eine Abhängigkeit, die ein neues `config.Settings()` zurückgibt.

=== "Python 3.9+"

    ```Python hl_lines="6  12-13"
    {!> ../../../docs_src/settings/app02_an_py39/main.py!}
    ```

rootProject.name = 'component-metadata-rules'

// tag::rule-in-settings[]
dependencyResolutionManagement {
    components {
        withModule("com.google.guava:guava", GuavaRule)
    }
}
// end::rule-in-settings[]

// tag::prefer-settings[]
dependencyResolutionManagement {
    rulesMode = RulesMode.PREFER_SETTINGS
}
// end::prefer-settings[]

// tag::enforce-settings[]
dependencyResolutionManagement {