Esercizio - Creare risorse e un account API for NoSQL

  • 9 minuti

È ora possibile creare le diverse risorse; ad esempio database, contenitori ed elementi; che si useranno nell'account Azure Cosmos DB. Per questo esercizio si creerà un database denominato cosmicworks con un singolo contenitore denominato products. È necessario assicurarsi che il codice non si arresti in modo anomalo quando si cerca di ricreare un contenitore se si esegue questa applicazione console più volte.

In questo caso ci sono alcuni requisiti chiave:

  1. Creare un database se non esiste già
  2. Creare un contenitore se non esiste già

Illustration of icons indicating Azure Cosmos DB resources are created in the cloud.

Dopo aver completato l'esercizio, il progetto creerà tutti i database o i contenitori necessari per l'esecuzione.

Creazione di un database

L'SDK contiene metodi utili che consentiranno di creare una nuova risorsa solo se non esiste già. Usando questi metodi, è possibile eseguire l'applicazione più volte senza doversi preoccupare delle eccezioni generate dai conflitti. Si creerà ora un database.

  1. Tornare al file Program.cs.

  2. Creare o ottenere un nuovo database chiamando CreateDatabaseIfNotExistsAsync(String, ThroughputProperties, RequestOptions, CancellationToken). Archiviare il risultato in una variabile denominata database. Assicurarsi di impostare i parametri seguenti:

    Parametro Valore
    id cosmicworks 
    Database database = await client.CreateDatabaseIfNotExistsAsync(
    id: "cosmicworks"
);

  3. Restituire come output l'identificatore univoco per il database.

    Console.WriteLine($"[Database created]:\t{database.Id}");

  4. Salvare il file Program.cs.

Creazione di un contenitore

Si creerà ora un contenitore con una "sezione" specifica della velocità effettiva condivisa dal database.

  1. Creare un oggetto proprietà per un nuovo contenitore usando il ContainerProperties tipo . Archiviare il risultato in una variabile denominata properties. Assicurarsi di impostare i parametri seguenti:

    Parametro Valore
    id products
    partitionKeyPath /categoryId 
    ContainerProperties properties = new(
    id: "products",
    partitionKeyPath: "/categoryId"
);

  2. Creare un oggetto velocità effettiva di scalabilità automatica usando il CreateAutoscaleThroughput(Int32) metodo statico. Archiviare il risultato in una variabile denominata throughput. Assicurarsi di impostare i parametri seguenti:

    Parametro Valore
    autoscaleMaxThroughput 1000 
    var throughput = ThroughputProperties.CreateAutoscaleThroughput(
    autoscaleMaxThroughput: 1000
);

  3. Creare o ottenere un nuovo contenitore chiamando CreateContainerIfNotExistsAsync(String, String, Nullable<Int32>, RequestOptions, CancellationToken). Archiviare il risultato in una variabile denominata container. Assicurarsi di impostare i parametri seguenti:

    Container container = await database.CreateContainerIfNotExistsAsync(
    containerProperties: properties,
    throughputProperties: throughput
);

  4. Restituire quindi come output l'identificatore univoco per il contenitore.

    Console.WriteLine($"[Container created]:\t{container.Id}");

  5. Salvare il file Program.cs.

Creare tipi di record per gli elementi

I dati C# possono essere rappresentati usando vari tipi, tra cui classi, struct e record. Per questo SDK, i record sono utili perché per impostazione predefinita non sono modificabili. È comunque possibile aggiungere codice per creare una copia modificata di un record, se necessario. I record hanno inoltre una sintassi facile da leggere e sono veloci da creare con poche righe di codice. In questa sezione verranno creati un tipo di base per tutti gli elementi e singoli tipi per ogni "tipologia" di elemento.

  1. In Visual Studio Code creare un nuovo file denominato Item.cs. Aprire quindi il file nell'editor.

  2. Creare un tipo di base denominato Item che contiene le tre proprietà da usare in tutti gli elementi per il contenitore: id, categoryId e type.

    public record Item(
    string Id,
    string CategoryId,
    string Type
);

  3. Salvare il file Item.cs. Salvare il file Item.cs.

  4. Creare un altro nuovo file denominato Category.cs. Aprire questo file nell'editor.

  5. Creare un nuovo tipo denominato Category che eredita dal tipo Item. Assicurarsi che il tipo passi i valori all'implementazione di base e impostare la variabile type per restituire come output il nome del tipo Category.

    public record Category(
    string Id,
    string CategoryId
) : Item(
    Id,
    CategoryId,
    nameof(Category)
);

  6. Salvare il file Category.cs. Salvare il file Category.cs.

  7. Creare infine un ultimo file denominato Product.cs. Aprire anche questo file nell'editor.

  8. Creare un nuovo tipo denominato Product che eredita da Item e aggiunge alcune nuove proprietà: name, price, archived e quantity.

    public record Product(
    string Id,
    string CategoryId
) : Item(
    Id,
    CategoryId,
    nameof(Product)
)
{
    public string Name { get; init; } = default!;
    public decimal Price { get; init; }
    public bool Archived { get; init; }
    public int Quantity { get; init; }
};

  9. Salvare il file Product.cs. Salvare il file Product.cs.

Controlla il tuo lavoro

L'app crea ora un database e un contenitore. I metodi usati per creare queste risorse devono essere sufficientemente resilienti da poter essere eseguiti più volte senza causare un'eccezione. Si eseguirà ora l'applicazione e si controllerà l'output per gli identificatori univoci di entrambe le risorse.

  1. Eseguire l'applicazione .NET nel terminale

    dotnet run

  2. Osservare l'output dell'esecuzione dell'applicazione. L'output sarà simile all'esempio seguente:

    ...
[Database created]:     cosmicworks
[Container created]:    products