DEV Community: Gabriel Batista

Como Resolver o Erro DbUpdateConcurrencyException no Entity Framework

Gabriel Batista — Fri, 03 Jan 2025 05:38:52 +0000

Se você estiver gerando seus próprios IDs ao usar Entity Framework e se deparar com um erro de concorrência, essa dica pode te ajudar!

Recentemente, enfrentei um problema interessante ao trabalhar com Entity Framework: um DbUpdateConcurrencyException aparentemente inexplicável ao tentar salvar novas entidades.

A funcionalidade era simples:

Recuperar um Grupo do banco
Adicionar um Membro ao Grupo
Salvar tudo

O código parecia correto, mas sempre recebia:

DbUpdateConcurrencyException: The database operation was expected to affect 1 row(s), but actually affected 0 row(s)

O que acontece?

Esse erro ocorre porque, por padrão, o Entity Framework assume a responsabilidade de gerar e gerenciar os valores das chaves primárias das entidades. Quando você define manualmente um valor para uma chave que normalmente seria gerada, a entidade será rastreada como "Modified" em vez de "Added" e quando uma entidade é marcada como "Modified" em vez de "Added", o EF tenta fazer um UPDATE no banco em vez de um INSERT mas não existe registro para atualizar (é uma nova entidade)

Esse erro ocorre porque, por padrão, o Entity Framework assume a responsabilidade de gerar e gerenciar os valores das chaves primárias das entidades. Quando você define manualmente um valor para uma chave que normalmente seria gerada, a entidade é rastreada como "Modified" em vez de "Added". Como resultado, o EF tenta realizar um UPDATE no banco de dados em vez de um INSERT, mas não existe nenhum registro para atualizar (é uma nova entidade).

A solução? Configure explicitamente que a chave primária não deve ser gerada automaticamente. Isso pode ser feito no Fluent API:

builder.Property(t => t.Id).ValueGeneratedNever();

Ou com data annotations:

[DatabaseGenerated(DatabaseGeneratedOption.None)]
public string Id { get; set; }

Espero que essa dica ajude você a evitar horas de debugging! 😉

Seu Primeiro Pacote NuGet: Um Passo a Passo Prático

Gabriel Batista — Fri, 03 Jan 2025 05:33:35 +0000

Quando você trabalha em diferentes aplicações, é comum se deparar com os mesmos problemas e as mesmas soluções aparecendo de novo e de novo. Isso faz parte do dia a dia de um desenvolvedor, mas pode ser meio cansativo. Agora, imagine se você pudesse pegar esse código repetido, organizar direitinho e usar facilmente em outros projetos. Legal, né? Neste artigo, vamos explorar como fazer isso com o NuGet.

Visão geral:

O NuGet é o gerenciador de pacotes oficial do .NET e ajuda você a empacotar, compartilhar e usar funcionalidades reutilizáveis de forma simples. Com ele, dá para organizar seu código em pacotes, reaproveitá-los em outros projetos e até colaborar de maneira mais prática com outros desenvolvedores.

"Um pacote NuGet é um arquivo ZIP com a extensão .nupkg que contém código compilado (DLLs), arquivos relacionados e um manifesto descritivo com informações como o número da versão. Desenvolvedores criam e publicam pacotes, enquanto consumidores obtêm e utilizam suas funcionalidades. O NuGet gerencia os detalhes intermediários."

Criando um projeto

Antes de começar, crie uma conta no NuGet.org. Isso será necessário para publicar seu pacote.

Crie um projeto do tipo Class Library. No terminal, execute:

dotnet new classlib --name ExamplePackage

Em seguida, abra o projeto em seu editor de preferência. Vamos criar um exemplo simples que converte um objeto em uma string JSON.

Definindo os Metadados

Para criar um pacote, é necessário configurar informações importantes diretamente no arquivo .csproj do projeto. Esse arquivo define os metadados essenciais que identificarão seu pacote no NuGet.

Metadados Obrigatórios:

TargetFramework: Define a versão do .NET que seu projeto utilizará.
PackageId: Um identificador único para seu pacote.
Version: Versão do pacote no formato Major.Minor.Patch (SemVer).
- Major: Alterações que quebram compatibilidade.
- Minor: Novas funcionalidades.
- Patch: Correções de bugs.

Metadados opcionais (não obrigatórios mas fortemente recomendados):

Authors Nome do autor ou autores do pacote.
Description: Uma breve descrição do propósito do pacote.
PackageLicenseExpression: Especifica a licença sob a qual o pacote é distribuído.

Atualize o arquivo .csproj para incluir essas informações:

Compilando o pacote

Com os metadados configurados, é hora de compilar o pacote. No terminal, execute:

dotnet pack --configuration Release

Esse comando criará um arquivo .nupkg na pasta bin/Release.

Testando localmente

Configurando a Fonte Local:

Dentro do projeto, crie uma pasta para os pacotes locais:

mkdir NuGetLocal

Copie o arquivo .nupkg gerado para essa pasta:

cp bin/Release/examplePackage.Convert.1.0.0.nupkg NuGetLocal

Adicione a pasta como uma fonte NuGet:

dotnet nuget add source /caminho/completo/para/NuGetLocal --name NuGetLocal

Consumindo o Pacote no Projeto:

Você pode criar um projeto console para testes:

dotnet new console --name ExamplePackageTest
cd ExamplePackageTest

Use o comando dotnet add package para instalar o pacote:

dotnet add package examplePackage.Convert --version 1.0.0

Testando o Pacote

Abra o arquivo Program.cs do projeto de teste e use o pacote:

Publicação

Após validar seu pacote, é hora de publicá-lo. Acesse sua conta em NuGet.org, vá até o seu perfil e crie uma nova chave.

No terminal, use o comando abaixo para publicar seu pacote no NuGet:

dotnet nuget push bin\Release\examplePackage.Convert.1.0.0.nupkg --api-key SuaAPIkEY --source https://api.nuget.org/v3/index.json

Pronto, se tudo estiver correto após alguns minutos, o pacote estará disponível no NuGet.org.

Conclusão

Agora que você aprendeu a criar, testar e publicar pacotes NuGet, pode começar a criar os seus próprios pacotes para facilitar o seu trabalho e, quem sabe, ajudar outras pessoas com as suas soluções.

Materiais Relacionados e Referências

Como Definir o Contexto Adequado ao Construir um Dockerfile

Gabriel Batista — Thu, 05 Oct 2023 05:15:30 +0000

Quantas vezes você já se deparou com a situação em que tentou criar um Dockerfile e, de repente, ele não conseguia copiar os arquivos para o container? A razão por trás disso pode estar relacionada à escolha do contexto adequado.

Quando trabalhamos com Dockerfiles, é fundamental entender que o Docker utiliza um diretório como ponto de partida inicial para a construção da imagem. Isso significa que apenas os arquivos presentes nesse diretório e seus subdiretórios são acessíveis durante o processo de build.

Por exemplo, considere a seguinte estrutura de diretórios:

├ exemplo dockerfile
│   ├── docker
│   │   ├── Dockerfile
│   │   └── .dockerignore
│   └── package.json
│   └── server.js

Dockerfile:

FROM node:18

# Create app directory

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 8080

CMD [ "node", "server.js" ]

Se tentarmos executar o comando de build a partir do diretório docker, como o exemplo a seguir:

docker build -t image/teste .

Nos deparamos com o seguinte erro:

Esse erro ocorre devido a incapacidade do Docker de localizar os arquivos desejados, uma vez que o contexto atual, ou seja, o diretório docker, não inclui o diretório pai que contém os arquivos relevantes.

Então, qual é a solução?

Para garantir que a compilação seja bem-sucedida, é crucial ampliar o contexto de construção. Em vez de executar o comando de build a partir do diretório docker, você deve retornar à raiz do projeto e, em seguida, utilizar o seguinte comando:

docker build -f docker/Dockerfile -t image/teste .

Vamos analisar cada componente desse comando:

docker build: Este é o comando que dá início ao processo de construção da imagem Docker.

-f docker/Dockerfile: Especifica o arquivo Dockerfile a ser usado para construir a imagem.

-t image/teste: Essa opção define um nome (ou uma "tag") para a imagem que será criada.

".": O ponto no final do comando indica o contexto de construção, ou seja, o diretório no qual o Docker procurará o Dockerfile e quaisquer outros arquivos necessários para a construção da imagem. O ponto representa o diretório atual.

Após a execução bem-sucedida dessa instrução, você pode esperar o seguinte resultado:

Com essa abordagem, você consegue especificar qual Dockerfile deseja utilizar e também indicar qual é o contexto. O ponto "." representa a raiz do projeto e instrui o Docker a considerar esse ponto como o contexto inicial para a construção da imagem.