Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Sviluppo di pattern riutilizzabili
<a name="reusable-patterns-best-practices"></a>

I pattern di progettazione software sono soluzioni riutilizzabili a problemi comuni nello sviluppo di software. Fungono da guida o paradigma per aiutare gli ingegneri di software a creare prodotti che seguano le best practice. Questa sezione fornisce una panoramica di due modelli riutilizzabili che è possibile utilizzare nella propria AWS CDK codebase: il pattern Abstract Factory e il pattern Chain of Responsibility. Puoi utilizzare ciascun pattern come schema e personalizzarlo per il problema di progettazione specifico del tuo codice. Per ulteriori informazioni sui pattern di progettazione, consulta [Pattern di progettazione](https://refactoring.guru/design-patterns) nella documentazione di Refactoring.Guru.

## Abstract Factory
<a name="abstract-factory"></a>

Il pattern Abstract Factory fornisce interfacce per creare famiglie di oggetti correlati o dipendenti senza specificarne le classi concrete. Questo pattern è valido per i seguenti casi d'uso:
+ Quando il client è indipendente dal modo in cui crei e componi gli oggetti nel sistema
+ Quando il sistema è composto da più famiglie di oggetti progettate per essere utilizzate insieme
+ Quando è necessario disporre di un valore di runtime per realizzare una particolare dipendenza

Per ulteriori informazioni sul pattern Abstract Factory, vedete Abstract [Factory TypeScript nella documentazione di Refactoring.Guru](https://refactoring.guru/design-patterns/abstract-factory/typescript/example).

Il seguente esempio di codice mostra come è possibile utilizzare il pattern Abstract Factory per creare una factory di archiviazione Amazon Elastic Block Store (Amazon EBS).

```
abstract class EBSStorage {
    abstract initialize(): void; 
}

class ProductEbs extends EBSStorage{
    constructor(value: String) {
        super();
        console.log(value);
    }
    initialize(): void {}
}

abstract class AbstractFactory {
    abstract createEbs(): EBSStorage
}

class EbsFactory extends AbstractFactory {
    createEbs(): ProductEbs{
        return new ProductEbs('EBS Created.')
    }
}

const ebs = new EbsFactory();
ebs.createEbs();
```

## Chain of Responsibility
<a name="chain-responsibility"></a>

Chain of Responsibility è un pattern di progettazione comportamentale che consente di inoltrare una richiesta lungo la catena di potenziali gestori finché uno di essi non la gestirà. Il pattern Chain of Responsibility è valido per i seguenti casi d'uso:
+ Quando più oggetti, determinati durante il runtime, sono candidati alla gestione di una richiesta
+ Quando non si desidera specificare i gestori in modo esplicito nel codice
+ Quando desideri inviare una richiesta a uno di più oggetti senza specificare in modo esplicito il destinatario

Per ulteriori informazioni sul modello Chain of Responsibility, consulta Chain of [Responsibility TypeScript nella documentazione di](https://refactoring.guru/design-patterns/chain-of-responsibility/typescript/example) Refactoring.Guru.

Il codice seguente mostra un esempio di come il pattern Chain of Responsibility viene utilizzato per creare una serie di azioni necessarie per completare l'attività.

```
interface Handler {
    setNext(handler: Handler): Handler;
    handle(request: string): string;
}
abstract class AbstractHandler implements Handler
{
    private nextHandler: Handler;
    public setNext(handler: Handler): Handler {
        this.nextHandler = handler;
        return handler;
    }

    public handle(request: string): string {
        if (this.nextHandler) {
            return this.nextHandler.handle(request);
        }
        return '';
    }
}

class KMSHandler extends AbstractHandler {
    public handle(request: string): string {
        return super.handle(request);
    }
}
```