Exercício - Criar novos itens

10 minutos

Lembre-se de que você pode criar itens em seu contêiner usando o SDK do Azure Cosmos DB para .NET. Para este projeto, o contêiner de produtos contém os itens de produto individuais e itens de categoria especial para cada categoria. Há dois casos que você deseja tratar neste aplicativo:

Se uma categoria estiver vazia, não há problema em criar o item dessa categoria individualmente. Não há itens de produto relacionados para criar.
No entanto, se uma categoria incluir produtos relacionados, você deseja criar o item de categoria e os itens de produto relacionados simultaneamente.

Neste momento, você tem dois requisitos principais:

Criar um item individualmente como uma única operação
Usar um lote transacional para criar vários itens relacionados

Illustration of icons indicating data being uploaded to the cloud.

Depois de concluir este exercício, seu projeto terá a lógica para criar itens em seu contêiner individualmente ou como um lote.

Adicionar um item individual a um contêiner

No Azure Cosmos DB, você pode criar, substituir ou atualizar itens para um contêiner. Criar um item requer que o item tenha um identificador exclusivo. A substituição de um item requer que o item já exista. Upsert é o melhor dos dois mundos, onde verifica o identificador único e, em seguida, substitui ou cria o item. Para este projeto, você quer ser capaz de executar o aplicativo várias vezes sem erros, tornando upsert uma escolha clara. Para o nosso primeiro item, criamos uma categoria que não tem nenhum produto associado. Aqui, você implementa uma única operação de upsert com uma categoria criada manualmente.

Abra o arquivo .cs programa mais uma vez.
Crie uma nova instância de Category nomeada goggles com os seguintes valores:

Property valor

id ef7fa0f1-0e9d-4435-aaaf-a778179a94ad

categoryId gear-snow-goggles
```
Category goggles = new(
    Id: "ef7fa0f1-0e9d-4435-aaaf-a778179a94ad",
    CategoryId: "gear-snow-goggles"
);
```
Crie uma nova PartitionKey instância usando o mesmo valor da categoryId propriedade para a instância Category que você criou anteriormente.
```
PartitionKey gogglesKey = new("gear-snow-goggles");
```
Use o método para criar ou substituir o item que passa em um objeto para o UpsertItemAsync item a ser criado e um valor de chave de partição.
```
Category result = await container.UpsertItemAsync(goggles, gogglesKey);
```
Imprima várias propriedades do no console, incluindo: O identificador exclusivo do item e o tipo do result item.
```
Console.WriteLine($"[New item created]:\t{result.Id}\t(Type: {result.Type})");
```
Crie uma nova instância de Category nomeada helmets com os seguintes valores:

Property valor

id 91f79374-8611-4505-9c28-3bbbf1aa7df7

categoryId gear-climb-helmets
```
Category helmets = new(
    Id: "91f79374-8611-4505-9c28-3bbbf1aa7df7",
    CategoryId: "gear-climb-helmets"
);
```
Crie uma nova PartitionKey instância usando o mesmo valor da categoryId propriedade para a instância Category que você criou anteriormente.
```
PartitionKey helmetsKey = new("gear-climb-helmets");
```
Use o método para criar ou substituir o UpsertItemAsync item. Passe um objeto para o item a ser criado e um valor de chave de partição. Retornar um objeto do tipo ItemResponse<T>.
```
ItemResponse<Category> response = await container.UpsertItemAsync(helmets, helmetsKey);
```
Imprima várias propriedades do no console, incluindo: O identificador exclusivo do item subjacente, o tipo do response item subjacente e a taxa de solicitação em RUs.
```
Console.WriteLine($"[New item created]:\t{response.Resource.Id}\t(Type: {response.Resource.Type})\t(RUs: {response.RequestCharge})");
```
Salve o arquivo .cs programa.

Property	valor
id	`ef7fa0f1-0e9d-4435-aaaf-a778179a94ad`
categoryId	`gear-snow-goggles`

Property	valor
id	`91f79374-8611-4505-9c28-3bbbf1aa7df7`
categoryId	`gear-climb-helmets`

Implementar várias operações como um lote transacional

Agora, considere um cenário em que você deseja criar vários produtos junto com uma categoria. Se os produtos são criados, mas a categoria não existe, esses produtos não são tão úteis. Criar vários itens é uma situação em que você pode usar uma transação para agrupar várias operações de "ponto" juntas para que todas tenham sucesso ou falhem como uma única unidade coesa. Voltando ao nosso cenário, precisamos criar uma categoria para tendas ao ar livre com alguns produtos de tenda. Nós já temos um único item de categoria sem nenhum item de produto. Aqui está o que devemos acabar:

Nesta seção, criamos um lote transacional para criar a categoria e os tents produtos relacionados juntos.

Em Program.cs, crie uma nova instância Category nomeada tents com os seguintes valores:

Property valor

id 5df21ec5-813c-423e-9ee9-1a2aaead0be4

categoryId gear-camp-tents
```
Category tents = new(
    Id: "5df21ec5-813c-423e-9ee9-1a2aaead0be4",
    CategoryId: "gear-camp-tents"
);
```

Property	valor
id	`5df21ec5-813c-423e-9ee9-1a2aaead0be4`
categoryId	`gear-camp-tents`

Crie quatro instâncias do tipo de produto usando esses valores.

Property	`cirroa`	`kuloar`	`mammatin`	`nimbolo`
ID	`e8dddee4-9f43-4d15-9b08-0d7f36adcac8`	`e6f87b8d-8cd7-4ade-a005-14d3e2fbd1aa`	`f7653468-c4b8-47c9-97ff-451ee55f4fd5`	`6e3b7275-57d4-4418-914d-14d1baca0979`
CategoriaId	`gear-camp-tents`	`gear-camp-tents`	`gear-camp-tents`	`gear-camp-tents`
Nome	`Cirroa Tent`	`Kuloar Tent`	`Mammatin Tent`	`Nimbolo Tent`
Preço	`490.00`	`530.00`	`0.00`	`330.00`
Arquivado	`false`	`false`	`true`	`false`
Quantidade	`15`	`8`	`0`	`35`

Product cirroa = new(
    Id: "e8dddee4-9f43-4d15-9b08-0d7f36adcac8",
    CategoryId: "gear-camp-tents"
){
    Name = "Cirroa Tent",
    Price = 490.00m,
    Archived = false,
    Quantity = 15
};

Product kuloar = new(
    Id: "e6f87b8d-8cd7-4ade-a005-14d3e2fbd1aa",
    CategoryId: "gear-camp-tents"
){
    Name = "Kuloar Tent",
    Price = 530.00m,
    Archived = false,
    Quantity = 8
};

Product mammatin = new(
    Id: "f7653468-c4b8-47c9-97ff-451ee55f4fd5",
    CategoryId: "gear-camp-tents"
){
    Name = "Mammatin Tent",
    Price = 0.00m,
    Archived = true,
    Quantity = 0
};

Product nimbolo = new(
    Id: "6e3b7275-57d4-4418-914d-14d1baca0979",
    CategoryId: "gear-camp-tents"
){
    Name = "Nimbolo Tent",
    Price = 330.00m,
    Archived = false,
    Quantity = 35
};

Agora, crie uma nova PartitionKey instância usando o gear-camp-tents valor.
```
PartitionKey tentsKey = new("gear-camp-tents");
```
Crie um novo lote transacional com escopo para o valor da chave de partição usando o gear-camp-tentsCreateTransactionalBatch(PartitionKey) método. Usando a sintaxe fluente, adicione cinco operações de upsert para criar os itens que precisamos em nosso contêiner para a categoria e todos os produtos relacionados.
```
TransactionalBatch batch = container.CreateTransactionalBatch(tentsKey)
    .UpsertItem<Category>(tents)
    .UpsertItem<Product>(cirroa)
    .UpsertItem<Product>(kuloar)
    .UpsertItem<Product>(mammatin)
    .UpsertItem<Product>(nimbolo);
```
Envie uma mensagem para o console indicando que estamos iniciando uma operação em lote.
```
Console.WriteLine("[Batch started]");
```
Use o método para executar o TransactionalBatch.ExecuteAsync lote e retornar um tipo de resposta especial.
```
using TransactionalBatchResponse batchResponse = await batch.ExecuteAsync();
```

Usando um loop for, itere todos os itens na resposta. Primeiro, converta cada item para o tipo TransactionalBatchOperationResult usando sua Item classe base como o genérico. Em seguida, imprima o identificador exclusivo e o tipo do objeto de resposta.

for (int i = 0; i < batchResponse.Count; i++)
{
    TransactionalBatchOperationResult<Item> batchResult = batchResponse.GetOperationResultAtIndex<Item>(i);
    Console.WriteLine($"[New item created]:\t{batchResult.Resource.Id}\t(Type: {batchResult.Resource.Type})");
}

Envie outra mensagem para o console indicando que o lote está concluído. Inclua a taxa de solicitação para todo o lote nesta mensagem.
```
Console.WriteLine($"[Batch completed]:\t(RUs: {batchResponse.RequestCharge})");
```
Salve o arquivo .cs programa.

Verifique o seu trabalho

Seu aplicativo agora cria vários itens e foi projetado para ser resiliente o suficiente para ser executado várias vezes sem causar uma exceção. Aqui, você executa o aplicativo e verifica a saída para os identificadores exclusivos de cada um dos seis itens recém-criados.

Executar aplicação
Código de revisão

Execute o aplicativo .NET no terminal:
```
dotnet run
```

Observe a saída da execução do aplicativo. A saída deve corresponder ao exemplo aqui:

...
[New item created]:     ef7fa0f1-0e9d-4435-aaaf-a778179a94ad    (Type: Category)
[New item created]:     91f79374-8611-4505-9c28-3bbbf1aa7df7    (Type: Category)        (RUs: 10.29)
[Batch started]
[New item created]:     5df21ec5-813c-423e-9ee9-1a2aaead0be4    (Type: Category)
[New item created]:     e8dddee4-9f43-4d15-9b08-0d7f36adcac8    (Type: Product)
[New item created]:     e6f87b8d-8cd7-4ade-a005-14d3e2fbd1aa    (Type: Product)
[New item created]:     f7653468-c4b8-47c9-97ff-451ee55f4fd5    (Type: Product)
[New item created]:     6e3b7275-57d4-4418-914d-14d1baca0979    (Type: Product)
[Batch completed]:      (RUs: 36.76)

Gorjeta

As RUs mostradas neste exemplo de saída podem variar da sua saída.

Reveja o ficheiro de código Program.cs para se certificar de que o seu código corresponde a este exemplo.

using Microsoft.Azure.Cosmos;
using Microsoft.Azure.Cosmos.Fluent;
using Microsoft.Azure.Cosmos.Linq;

// Code to create client omitted for brevity

// Code to create resources omitted for brevity

Category goggles = new(
    Id: "ef7fa0f1-0e9d-4435-aaaf-a778179a94ad",
    CategoryId: "gear-snow-goggles"
);

PartitionKey gogglesKey = new("gear-snow-goggles");

Category result = await container.UpsertItemAsync(goggles, gogglesKey);

Console.WriteLine($"[New item created]:\t{result.Id}\t(Type: {result.Type})");

Category helmets = new(
    Id: "91f79374-8611-4505-9c28-3bbbf1aa7df7",
    CategoryId: "gear-climb-helmets"
);

PartitionKey helmetsKey = new("gear-climb-helmets");

ItemResponse<Category> response = await container.UpsertItemAsync(helmets, helmetsKey);

Console.WriteLine($"[New item created]:\t{response.Resource.Id}\t(Type: {response.Resource.Type})\t(RUs: {response.RequestCharge})");

Category tents = new(
    Id: "5df21ec5-813c-423e-9ee9-1a2aaead0be4",
    CategoryId: "gear-camp-tents"
);

Product cirroa = new(
    Id: "e8dddee4-9f43-4d15-9b08-0d7f36adcac8",
    CategoryId: "gear-camp-tents"
){
    Name = "Cirroa Tent",
    Price = 490.00m,
    Archived = false,
    Quantity = 15
};

Product kuloar = new(
    Id: "e6f87b8d-8cd7-4ade-a005-14d3e2fbd1aa",
    CategoryId: "gear-camp-tents"
){
    Name = "Kuloar Tent",
    Price = 530.00m,
    Archived = false,
    Quantity = 8
};

Product mammatin = new(
    Id: "f7653468-c4b8-47c9-97ff-451ee55f4fd5",
    CategoryId: "gear-camp-tents"
){
    Name = "Mammatin Tent",
    Price = 0.00m,
    Archived = true,
    Quantity = 0
};

Product nimbolo = new(
    Id: "6e3b7275-57d4-4418-914d-14d1baca0979",
    CategoryId: "gear-camp-tents"
){
    Name = "Nimbolo Tent",
    Price = 330.00m,
    Archived = false,
    Quantity = 35
};

PartitionKey tentsKey = new("gear-camp-tents");

TransactionalBatch batch = container.CreateTransactionalBatch(tentsKey)
    .UpsertItem<Category>(tents)
    .UpsertItem<Product>(cirroa)
    .UpsertItem<Product>(kuloar)
    .UpsertItem<Product>(mammatin)
    .UpsertItem<Product>(nimbolo);

Console.WriteLine("[Batch started]");

using TransactionalBatchResponse batchResponse = await batch.ExecuteAsync();
for (int i = 0; i < batchResponse.Count; i++)
{
    TransactionalBatchOperationResult<Item> batchResult = batchResponse.GetOperationResultAtIndex<Item>(i);
    Console.WriteLine($"[New item created]:\t{batchResult.Resource.Id}\t(Type: {batchResult.Resource.Type})");
}

Console.WriteLine($"[Batch completed]:\t(RUs: {batchResponse.RequestCharge})");

Continuar

Exercício - Criar novos itens

Adicionar um item individual a um contêiner

Implementar várias operações como um lote transacional

Verifique o seu trabalho

Comentários