Configurazione del container DI
*******************************

.[perex]
Panoramica delle opzioni di configurazione del container DI di Nette.


File di configurazione
======================

Il container DI di Nette si governa facilmente con i file di configurazione. Di norma si scrivono nel [formato NEON|neon:format]. Consigliamo di usare [editor con supporto |tools:ide] per questo formato.

<pre>
"decorator .[prism-token prism-atrule]":[#Decorator]: 	"Decorator .[prism-token prism-comment]"<br>
"di .[prism-token prism-atrule]":[#DI]: 			"Container DI .[prism-token prism-comment]"<br>
"extensions .[prism-token prism-atrule]":[#Estensioni]: 	"Installazione di altre estensioni DI .[prism-token prism-comment]"<br>
"includes .[prism-token prism-atrule]":[#Inclusione di file]: 	"Inclusione di file .[prism-token prism-comment]"<br>
"parameters .[prism-token prism-atrule]":[#Parametri]: 	"Parametri .[prism-token prism-comment]"<br>
"search .[prism-token prism-atrule]":[#Search]: 		"Registrazione automatica dei servizi .[prism-token prism-comment]"<br>
"services .[prism-token prism-atrule]":[services]: 		"Servizi .[prism-token prism-comment]"
</pre>

.[note]
Per scrivere una stringa che contiene il carattere `%`, dovete effettuare l'escape raddoppiandolo in `%%`.


Parametri
=========

Nella configurazione potete definire parametri, che si possono poi usare all'interno delle definizioni dei servizi. Questo vi permette di rendere più chiara la configurazione o di centralizzare i valori che potrebbero cambiare.

```neon
parameters:
	dsn: 'mysql:host=127.0.0.1;dbname=test'
	user: root
	password: secret
```

Facciamo riferimento al parametro `dsn` in qualsiasi punto della configurazione con la notazione `%dsn%`. I parametri si possono usare anche dentro le stringhe, come `'%wwwDir%/images'`.

I parametri non devono essere per forza solo stringhe o numeri: possono contenere anche array:

```neon
parameters:
	mailer:
		host: smtp.example.com
		secure: ssl
		user: franta@gmail.com
	languages: [cs, en, de]
```

Facciamo riferimento a una chiave specifica come `%mailer.user%`.

Se il vostro codice (per esempio una classe) ha bisogno del valore di un parametro, passatelo alla classe. Per esempio nel costruttore. Non esiste un oggetto di configurazione globale a cui le classi possano chiedere i valori dei parametri. Sarebbe una violazione del principio della dependency injection.


Servizi
=======

Vedi il [capitolo dedicato|services].


Decorator
=========

Come modificare in un colpo solo più servizi di un certo tipo? Per esempio, come chiamare un determinato metodo su tutti i presenter che ereditano da una certa classe base? A questo serve il decorator.

```neon
decorator:
	# per tutti i servizi che sono istanze di questa classe o interfaccia
	App\Presentation\BasePresenter:
		setup:
			- setProjectId(10)       # chiama questo metodo
			- $absoluteUrls = true   # e imposta la variabile
```

I decorator si possono usare anche per impostare i [tag |services#Tag] o per attivare la [modalità inject |services#Modalità inject].

```neon
decorator:
	InjectableInterface:
		tags: [mytag: 1]
		inject: true
```


DI
===

Impostazioni tecniche del container DI.

```neon
di:
	# mostrare il DIC nella Tracy Bar?
	debugger: ...        # (bool) di norma per rilevamento automatico (attivo quando Tracy è presente)

	# tipi di parametro a cui non applicare mai l'autowiring
	excluded: ...        # (string[])

	# attivare la creazione pigra dei servizi?
	lazy: ...            # (bool) di norma false

	# la classe da cui eredita il container DI
	parentClass: ...     # (string) di norma Nette\DI\Container
```


Servizi pigri .{data-version:3.2.4}
-----------------------------------

Impostare `lazy: true` attiva la creazione pigra (differita) dei servizi. Significa che i servizi non vengono creati davvero nel momento in cui li si chiede al container DI, ma solo al momento del loro primo uso. Questo può accelerare l'avvio dell'applicazione e ridurre l'uso della memoria, perché vengono creati solo i servizi effettivamente necessari a una determinata richiesta.

Per un servizio specifico la creazione pigra si può [regolare |services#Servizi pigri].

.[note]
Gli oggetti pigri si possono usare solo per le classi definite dall'utente, non per le classi interne di PHP. Richiede PHP 8.4 o successivo.


Esportazione dei metadati
-------------------------

La classe del container DI contiene anche molti metadati. Potete ridurne la dimensione riducendo l'esportazione dei metadati.

```neon
di:
	export:
		# esportare i parametri?
		parameters: false   # (bool) di norma true

		# esportare i tag e quali?
		tags:               # (string[]|bool) di norma tutti
			- event.subscriber

		# esportare i dati per l'autowiring e quali?
		types:              # (string[]|bool) di norma tutti
			- Nette\Database\Connection
			- Symfony\Component\Console\Application
```

Se non usate `$container->getParameters()`, potete disattivare l'esportazione dei parametri. Potete inoltre esportare solo i tag che usate davvero per ottenere i servizi con `$container->findByTag(...)`. Se non chiamate affatto questo metodo, potete disattivare completamente l'esportazione dei tag con `false`.

Potete ridurre notevolmente i metadati per l'[autowiring|autowiring] elencando solo le classi che chiedete davvero con `$container->getByType()`. Anche qui, se non chiamate questo metodo (o lo chiamate solo nel file di [bootstrap|application:bootstrapping], per esempio per ottenere `Nette\Application\Application`), potete disattivare completamente l'esportazione dei tipi con `false`.


Estensioni
==========

Registrazione di ulteriori estensioni DI. Ecco come aggiungete, per esempio, l'estensione DI `Dibi\Bridges\Nette\DibiExtension3` con il nome `dibi`:

```neon
extensions:
	dibi: Dibi\Bridges\Nette\DibiExtension3
```

La configurate poi nella sezione `dibi`:

```neon
dibi:
	host: localhost
```

Come estensione potete aggiungere anche una classe con parametri:

```neon
extensions:
	application: Nette\Bridges\ApplicationDI\ApplicationExtension(%debugMode%, [%appDir%], %tempDir%/cache)
```


Inclusione di file
==================

Ulteriori file di configurazione si possono includere nella sezione `includes`:

```neon
includes:
	- parameters.php
	- services.neon
	- presenters.neon
```

Il nome `parameters.php` non è un errore di battitura: la configurazione si può scrivere anche in un file PHP che la restituisce come array:

```php
<?php
return [
	'database' => [
		'main' => [
			'dsn' => 'sqlite::memory:',
		],
	],
];
```

Se in più file di configurazione compaiono elementi con le stesse chiavi, essi verranno sovrascritti oppure, nel caso degli array, [uniti |#Unione]. Un file incluso più tardi ha priorità maggiore rispetto al precedente. Il file in cui è indicata la sezione `includes` ha priorità maggiore rispetto ai file inclusi al suo interno.


Search
======

La registrazione automatica dei servizi nel container DI semplifica notevolmente lo sviluppo. Nette aggiunge automaticamente al container i presenter, ma potete aggiungervi facilmente anche qualsiasi altra classe.

Basta indicare in quali directory (e sottodirectory) cercare le classi:

```neon
search:
	-	in: %appDir%/Forms
	-	in: %appDir%/Model
```

Se vi serve una sola regola di ricerca, potete omettere l'elenco e scriverne le chiavi direttamente sotto `search`:

```neon
search:
	in: %appDir%
```

Di norma, però, non vogliamo aggiungere assolutamente tutte le classi e le interfacce, quindi possiamo filtrarle:

```neon
search:
	-	in: %appDir%/Forms

		# filtraggio per nome di file (string|string[])
		files:
			- *Factory.php

		# filtraggio per nome di classe (string|string[])
		classes:
			- *Factory
```

Oppure possiamo selezionare le classi che ereditano o implementano almeno una delle classi elencate:


```neon
search:
	-	in: %appDir%
		extends:
			- App\*Form
		implements:
			- App\*FormInterface
```

Potete definire anche regole di esclusione, con maschere di nomi di classe o di antenati. Se una classe corrisponde a una regola di esclusione, non verrà aggiunta al container DI:

```neon
search:
	-	in: %appDir%
		exclude:
			files: ...
			classes: ...
			extends: ...
			implements: ...
```

A tutti i servizi registrati automaticamente si possono assegnare dei tag:

```neon
search:
	-	in: %appDir%
		tags: ...
```

Oltre alle classi, la ricerca registra anche le interfacce che hanno un unico metodo `create()` o `get()`, come [factory o accessor generati |factory]. Le classi per cui nel container è già registrato un servizio dello stesso tipo vengono saltate, così non si creano duplicati.


Unione
======

Se in più file di configurazione compaiono elementi con le stesse chiavi, essi verranno sovrascritti oppure, nel caso degli array, uniti. Il file incluso più tardi ha priorità maggiore rispetto al precedente.

<table class=table>
<tr>
	<th width=33%>config1.neon</th>
	<th width=33%>config2.neon</th>
	<th>risultato</th>
</tr>
<tr>
	<td>
```neon
items:
	- 1
	- 2
```
	</td>
	<td>
```neon
items:
	- 3
```
	</td>
	<td>
```neon
items:
	- 1
	- 2
	- 3
```
	</td>
</tr>
</table>

Per gli array l'unione si può impedire aggiungendo un punto esclamativo dopo il nome della chiave:

<table class=table>
<tr>
	<th width=33%>config1.neon</th>
	<th width=33%>config2.neon</th>
	<th>risultato</th>
</tr>
<tr>
	<td>
```neon
items:
	- 1
	- 2
```
	</td>
	<td>
```neon
items!:
	- 3
```
	</td>
	<td>
```neon
items:
	- 3
```
	</td>
</tr>
</table>

{{maintitle: Configurazione della dependency injection}}