Forem: Luiz Eduardo Dario de Araujo

Execution Time and Complexity: What Every Developer Needs to Know

Luiz Eduardo Dario de Araujo — Wed, 19 Mar 2025 16:34:58 +0000

Have you ever wondered how computers can find information so quickly among millions of data points? The answer lies in efficient algorithms, and binary search is one of the best examples!

Imagine searching for a specific word in a dictionary with 240,000 terms. With a simple search, you might need up to 240,000 attempts in the worst case. But with binary search? Only 18 attempts! 😲

This happens because binary search cuts the problem in half at each step, drastically reducing the number of operations needed. Mathematically speaking, while a simple search requires N attempts, binary search needs at most log₂(N) attempts – a game-changing difference when dealing with large amounts of data.

💡 Want to understand how this works and why Big O notation is essential for measuring algorithm efficiency? Read all article in https://www.luizdario.com.br/blog

[PT_BR]Tempo de Execução e Complexidade: O Que Todo Dev Precisa Saber

Luiz Eduardo Dario de Araujo — Wed, 19 Mar 2025 16:32:01 +0000

Você já se perguntou como os computadores conseguem encontrar informações tão rapidamente em meio a milhões de dados? A resposta está nos algoritmos eficientes, e a busca binária é um dos melhores exemplos disso!

Imagine procurar uma palavra específica em um dicionário de 240 mil termos. Com uma busca simples, você pode precisar de até 240 mil tentativas no pior caso. Mas com a busca binária? Apenas 18 tentativas! 😲

Isso acontece porque a busca binária divide o problema ao meio a cada passo, reduzindo drasticamente o número de operações necessárias. Em termos matemáticos, enquanto uma busca simples requer N tentativas, a busca binária precisa de no máximo log₂(N) tentativas – uma diferença brutal quando lidamos com grandes volumes de dados.

💡 Quer entender como isso funciona e por que a notação Big O é essencial para medir a eficiência dos algoritmos? Acesse o post completo em https://www.luizdario.com.br/blog

[PT_BR] Repositório Genérico com Dapper.Contrib

Luiz Eduardo Dario de Araujo — Wed, 09 Oct 2024 19:54:10 +0000

Um dos grandes benefícios de utilizar o Dapper é sua velocidade e versatilidade no acesso a dados. No entanto, ele ainda deixa a desejar quando pensamos em mapeamento objeto-relacional (ORM). Para resolver essa limitação, a comunidade desenvolveu o Dapper.Contrib, uma biblioteca que simplifica o mapeamento de tabelas do banco de dados para classes utilizando anotações.

Com o tempo, a criação de classes de repositório pode se tornar um processo repetitivo e mecânico. Uma solução prática é implementar uma classe de repositório base, o que facilita o desenvolvimento e reduz a duplicação de código. Neste artigo, vamos explorar como criar uma estrutura de repositório genérico utilizando o Dapper.Contrib.

Criando a Interface do Repositório Base

Começamos criando uma interface que define os métodos genéricos do repositório. Utilizamos o tipo genérico T para permitir que a interface seja reutilizada com qualquer classe que represente uma tabela do banco de dados.

internal interface IBaseRepository<T> where T : class
{
    IEnumerable<T> GetAll();

    T Get(int id);

    T Get(string id);

    long Insert(T entity);

    long Insert(IEnumerable<T> entity);

    bool Update(T entity);

    bool Update(IEnumerable<T> entity);

    bool Delete(T entity);

    bool Delete(IEnumerable<T> entity);
}

Na interface, foram criados métodos para busca por Id usando tipos de dados inteiros e strings. Dessa forma, podemos realizar consultas no banco de dados utilizando esses dois tipos de dados. Caso seu banco de dados utilize outro tipo de chave primária, como GUID, basta implementar o método correspondente na interface, e ele estará disponível para uso.

Implementando o Repositório Base

Em seguida, implementamos a interface utilizando o Dapper.Contrib. No exemplo abaixo, estamos acessando um banco de dados SQL Server e aproveitando os métodos embutidos do Dapper.Contrib, como Insert, Update, Delete e Get.

internal class BaseRepository<T> : IBaseRepository<T> where T : class
{
    public bool Delete(T entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Delete(entity);
    }

    public bool Delete(IEnumerable<T> entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Delete(entity);
    }

    public IEnumerable<T> GetAll()
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.GetAll<T>();
    }

    public T Get(int id)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Get<T>(id);
    }

    public T Get(string id)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Get<T>(id);
    }

    public long Insert(T entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Insert(entity);
    }

    public long Insert(IEnumerable<T> entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Insert(entity);
    }

    public bool Update(T entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Update(entity);
    }

    public bool Update(IEnumerable<T> entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Update(entity);
    }

    public string ConnectionString => "Minha Connection String";
}

Definindo a Entidade com Anotações

Agora, podemos criar uma entidade que representa uma tabela no banco de dados. Utilizamos as anotações fornecidas pelo Dapper.Contrib, como [Table] para mapear a tabela e [Key] para definir a chave primária.

[Table("dbo.TABLE_MYFILE")]
internal class MyFile
{
    [Key]
    public int Id { get; set; }

    public string Customer { get; set; }

    public string FileName { get; set; }

    public DateTime FileDate { get; set; }

    public string FilePath { get; set; }
}

Criando o Repositório Específico

Com o repositório base criado, construir um repositório específico para a entidade MyFile se torna extremamente simples. Apenas herdamos a classe BaseRepository e implementamos a interface correspondente.

internal class FileRepository : BaseRepository<MyFile>, IBaseRepository<MyFile>
{
    // Implementações específicas, se necessário
}

Usando o Repositório

Agora, ao instanciar o repositório, temos acesso simples a toda a funcionalidade que o Dapper.Contrib nos proporciona. Podemos, por exemplo, inserir, consultar, atualizar ou excluir registros da tabela associada à entidade MyFile de maneira fácil e eficiente.

Aqui está um exemplo de como usar o FileRepository para inserir um novo registro de arquivo no banco de dados:

class Program
{
    static void Main(string[] args)
    {
        // Instanciando o repositório
        var fileRepository = new FileRepository();

        // Criando uma nova entidade de arquivo
        var newFile = new MyFile
        {
            Customer = "João Silva",
            FileName = "relatorio.pdf",
            FileDate = DateTime.Now,
            FilePath = "/documentos/relatorios/relatorio.pdf"
        };

        // Inserindo o novo arquivo no banco de dados
        var insertedId = fileRepository.Insert(newFile);

        // Exibindo o ID do arquivo inserido
        Console.WriteLine($"Arquivo inserido com ID: {insertedId}");

        // Recuperando o arquivo pelo ID
        var retrievedFile = fileRepository.Get((int)insertedId);

        // Exibindo as informações do arquivo recuperado
        Console.WriteLine($"Arquivo Recuperado: {retrievedFile.FileName}, Cliente: {retrievedFile.Customer}");

        // Atualizando o registro do arquivo
        retrievedFile.FileName = "relatorio_atualizado.pdf";
        fileRepository.Update(retrievedFile);
        Console.WriteLine("Arquivo atualizado com sucesso.");

        // Excluindo o registro do arquivo
        fileRepository.Delete(retrievedFile);
        Console.WriteLine("Arquivo excluído com sucesso.");
    }
}

Explicação:

Instanciando o repositório: A classe FileRepository é instanciada para realizar operações no banco de dados.
Inserindo um novo arquivo: Um novo objeto da entidade MyFile é criado e inserido no banco de dados usando o método Insert.
Recuperando o arquivo: O arquivo é recuperado pelo seu ID com o método Get.
Atualizando o arquivo: O arquivo recuperado é atualizado, e as mudanças são salvas no banco de dados com o método Update.
Excluindo o arquivo: Finalmente, o arquivo é excluído do banco de dados utilizando o método Delete.

Este exemplo simples demonstra como Dapper.Contrib pode ser utilizado de forma eficiente para realizar as operações mais comuns de inserção, consulta, atualização e exclusão de registros com o padrão de repositório.

Code Structure with Dapper and Dapper.Contrib

Luiz Eduardo Dario de Araujo — Wed, 09 Oct 2024 19:53:39 +0000

One of the major benefits of using Dapper is its speed and versatility in data access. However, it falls short in object-relational mapping. To address this limitation, the community developed Dapper.Contrib, a library that simplifies the mapping of database tables to classes using annotations.

As time passes, creating repository classes can become repetitive and mechanical. A practical solution to this is to implement a base repository class, which streamlines development and reduces code duplication. In this article, we’ll explore how to build a generic repository structure using Dapper.Contrib.

Creating the Base Repository Interface

We start by defining an interface that outlines the generic repository methods. The use of the generic type T makes the interface reusable with any class representing a database table.

internal interface IBaseRepository<T> where T : class
{
    IEnumerable<T> GetAll();

    T Get(int id);

    T Get(string id);

    long Insert(T entity);

    long Insert(IEnumerable<T> entity);

    bool Update(T entity);

    bool Update(IEnumerable<T> entity);

    bool Delete(T entity);

    bool Delete(IEnumerable<T> entity);
}

In the interface, methods Get(Id) are defined for both integer and string types, allowing flexibility in database queries. If your database uses another type of primary key, such as GUID, you can simply implement the corresponding method, and it will be available for use.

Implementing the Base Repository

Next, we implement the interface using Dapper.Contrib. In the example below, we access a SQL Server database and utilize Dapper.Contrib’s built-in methods such as Insert, Update, Delete, and Get.

internal class BaseRepository<T> : IBaseRepository<T> where T : class
{
    public bool Delete(T entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Delete(entity);
    }

    public bool Delete(IEnumerable<T> entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Delete(entity);
    }

    public IEnumerable<T> GetAll()
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.GetAll<T>();
    }

    public T Get(int id)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Get<T>(id);
    }

    public T Get(string id)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Get<T>(id);
    }

    public long Insert(T entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Insert(entity);
    }

    public long Insert(IEnumerable<T> entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Insert(entity);
    }

    public bool Update(T entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Update(entity);
    }

    public bool Update(IEnumerable<T> entity)
    {
        using (var conn = new SqlConnection(ConnectionString))
            return conn.Update(entity);
    }

    public string ConnectionString => "My Connection String";
}

Defining the Entity with Annotations

Now, let’s create an entity representing a table in the database. We use annotations provided by Dapper.Contrib, such as [Table] to map the table and [Key] to define the primary key.

[Table("dbo.TABLE_MYFILE")]
internal class MyFile
{
    [Key]
    public int Id { get; set; }

    public string Customer { get; set; }

    public string FileName { get; set; }

    public DateTime FileDate { get; set; }

    public string FilePath { get; set; }
}

Creating the Specific Repository

With the base repository implemented, creating a specific repository for the MyFile entity becomes straightforward. We just need to inherit the BaseRepository class and implement the corresponding interface.

internal class FileRepository : BaseRepository<MyFile>, IBaseRepository<MyFile>
{
    // Specific implementations, if needed
}

Using the Repository

Now, when instantiating the repository, we gain easy access to all the functionality provided by Dapper.Contrib. For example, we can retrieve, insert, update, or delete records from the table associated with the MyFile entity in a simple and efficient manner.

Here is an example of how to use the FileRepository to insert a new file record into the database:

class Program
{
    static void Main(string[] args)
    {
        // Instantiate the repository
        var fileRepository = new FileRepository();

        // Create a new file entity
        var newFile = new MyFile
        {
            Customer = "John Doe",
            FileName = "report.pdf",
            FileDate = DateTime.Now,
            FilePath = "/documents/reports/report.pdf"
        };

        // Insert the new file into the database
        var insertedId = fileRepository.Insert(newFile);

        // Output the ID of the newly inserted file
        Console.WriteLine($"File inserted with ID: {insertedId}");

        // Retrieve the file by ID
        var retrievedFile = fileRepository.Get((int)insertedId);

        // Output retrieved file information
        Console.WriteLine($"Retrieved File: {retrievedFile.FileName}, Customer: {retrievedFile.Customer}");

        // Update the file record
        retrievedFile.FileName = "updated_report.pdf";
        fileRepository.Update(retrievedFile);
        Console.WriteLine("File updated successfully.");

        // Delete the file record
        fileRepository.Delete(retrievedFile);
        Console.WriteLine("File deleted successfully.");
    }
}