C# et PostgreSQL : Guide complet d'intégration et de gestion de base de données

Pourquoi C# et PostgreSQL forment un duo incontournable

Dans le monde du développement, chaque choix compte. Choisir un langage, un framework et une base de données, c'est poser les fondations de votre projet. Si vous êtes ici, c'est que vous vous intéressez à l'une des combinaisons les plus puissantes et modernes du développement d'entreprise : C# et PostgreSQL.

Pourquoi ce duo ? C# est un langage mature, fortement typé, avec un écosystème immense et des performances exceptionnelles. PostgreSQL est un SGBD objet-relationnel qui surpasse nombre de ses concurrents en termes de fonctionnalités, de stabilité et de prise en charge de types de données avancés (JSONB, tableaux, recherche plein texte). Ensemble, ils vous offrent bien plus qu'un simple "langage et base de données" : un outil flexible et scalable pour créer des applications web, des microservices et des systèmes analytiques.

Dans ce guide, nous n'allons pas nous contenter de la théorie. Nous allons plonger directement dans la pratique : de l'installation du pilote à l'écriture de transactions complexes. Vous apprendrez à configurer correctement la connexion, à effectuer des opérations CRUD, à utiliser les ORM modernes (Entity Framework Core et Dapper) et à éviter les pièges courants. C'est parti !

Étape 1. Préparation : ce qu'il faut installer

Avant d'écrire du code, assurons-nous que vous avez tout le nécessaire.

\n
• PostgreSQL — téléchargez la dernière version depuis le site officiel. Pendant l'installation, notez le port (5432 par défaut) et le mot de passe du superutilisateur postgres.
\n
• Visual Studio / Rider / VS Code — n'importe quel IDE prenant en charge .NET.
\n
• .NET SDK (6.0, 7.0 ou 8.0) — plus c'est récent, mieux c'est. Nous utiliserons .NET 8.
\n

Créez maintenant un nouveau projet. Pour une application console, c'est simple :

dotnet new console -n CsharpPostgresDemo\ncd CsharpPostgresDemo

L'étape la plus importante est d'installer le pilote pour PostgreSQL. Dans le monde .NET, il s'agit du package Npgsql (prononcez "En-pi-es-quel"). C'est la base de toutes les autres bibliothèques.

dotnet add package Npgsql

Étape 2. Première connexion : vérifions la liaison

Créons un script très simple qui se connecte à la base de données et affiche la version du serveur. C'est le meilleur moyen de vérifier que tout fonctionne.

using Npgsql;\n\n// Chaîne de connexion : indiquez vos informations\nstring connectionString = "Host=localhost;Port=5432;Database=postgres;Username=postgres;Password=your_password";\n\nusing var connection = new NpgsqlConnection(connectionString);\nconnection.Open();\n\n// Exécution de la requête\nusing var command = new NpgsqlCommand("SELECT version();", connection);\nstring version = (string)await command.ExecuteScalarAsync();\n\nConsole.WriteLine($"Connexion réussie ! Version de PostgreSQL : {version}");

Exécutez le code. Si vous voyez quelque chose comme "PostgreSQL 16.1 on x86_64-pc-linux-gnu..." dans la console, c'est gagné ! Sinon, vérifiez le mot de passe, le nom d'hôte et assurez-vous que le service PostgreSQL est démarré.

Étape 3. Opérations CRUD en C# avec PostgreSQL

Maintenant que la connexion fonctionne, créons une table et effectuons un cycle complet : Create, Read, Update, Delete.

Création de la table

string createTableSql = @"\n    CREATE TABLE IF NOT EXISTS users (\n        id SERIAL PRIMARY KEY,\n        name VARCHAR(100) NOT NULL,\n        email VARCHAR(255) UNIQUE NOT NULL,\n        created_at TIMESTAMP DEFAULT NOW()\n    );";\n\nusing var cmdCreate = new NpgsqlCommand(createTableSql, connection);\nawait cmdCreate.ExecuteNonQueryAsync();\nConsole.WriteLine("Table users créée.");

Insertion de données (INSERT)

// Utilisation d'une requête paramétrée — protection contre les injections SQL !\nstring insertSql = "INSERT INTO users (name, email) VALUES (@name, @email) RETURNING id;";\n\nusing var cmdInsert = new NpgsqlCommand(insertSql, connection);\ncmdInsert.Parameters.AddWithValue("@name", "Alex");\ncmdInsert.Parameters.AddWithValue("@email", "alex@example.com");\n\nint newId = (int)await cmdInsert.ExecuteScalarAsync();\nConsole.WriteLine($"Nouvel utilisateur inséré avec l'ID : {newId}");

Lecture des données (SELECT)

string selectSql = "SELECT id, name, email, created_at FROM users;";\n\nusing var cmdSelect = new NpgsqlCommand(selectSql, connection);\nusing var reader = await cmdSelect.ExecuteReaderAsync();\n\nwhile (await reader.ReadAsync())\n{\n    Console.WriteLine($"ID : {reader.GetInt32(0)}, Nom : {reader.GetString(1)}, Email : {reader.GetString(2)}, Créé le : {reader.GetDateTime(3)}");\n}

Mise à jour des données (UPDATE)

string updateSql = "UPDATE users SET name = @newName WHERE id = @id;";\n\nusing var cmdUpdate = new NpgsqlCommand(updateSql, connection);\ncmdUpdate.Parameters.AddWithValue("@newName", "Alexandre");\ncmdUpdate.Parameters.AddWithValue("@id", 1);\n\nint rowsAffected = await cmdUpdate.ExecuteNonQueryAsync();\nConsole.WriteLine($"{rowsAffected} ligne(s) mise(s) à jour.");

Suppression de données (DELETE)

string deleteSql = "DELETE FROM users WHERE id = @id;";\n\nusing var cmdDelete = new NpgsqlCommand(deleteSql, connection);\ncmdDelete.Parameters.AddWithValue("@id", 1);\n\nint rowsDeleted = await cmdDelete.ExecuteNonQueryAsync();\nConsole.WriteLine($"{rowsDeleted} ligne(s) supprimée(s).");

Étape 4. Utilisation d'Entity Framework Core avec PostgreSQL

Entity Framework Core (EF Core) est l'ORM (Object-Relational Mapper) le plus populaire dans l'écosystème .NET. Il vous permet de travailler avec la base de données en utilisant des objets C#, sans écrire de SQL manuel.

Commencez par installer les packages nécessaires :

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL\ndotnet add package Microsoft.EntityFrameworkCore.Tools

Créez ensuite votre modèle et votre contexte de base de données :

using Microsoft.EntityFrameworkCore;\n\n// Modèle\npublic class User\n{\n    public int Id { get; set; }\n    public string Name { get; set; }\n    public string Email { get; set; }\n    public DateTime CreatedAt { get; set; }\n}\n\n// Contexte\npublic class AppDbContext : DbContext\n{\n    public DbSet<User> Users { get; set; }\n\n    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)\n    {\n        optionsBuilder.UseNpgsql("Host=localhost;Port=5432;Database=monapp;Username=postgres;Password=your_password");\n    }\n}

Exemple d'utilisation avec EF Core :

using var context = new AppDbContext();\n\n// Création\nvar newUser = new User { Name = "Marie", Email = "marie@example.com" };\ncontext.Users.Add(newUser);\nawait context.SaveChangesAsync();\nConsole.WriteLine($"Utilisateur créé avec l'ID : {newUser.Id}");\n\n// Lecture\nvar users = await context.Users.ToListAsync();\nforeach (var user in users)\n{\n    Console.WriteLine($"{user.Id} - {user.Name} - {user.Email}");\n}

Étape 5. Dapper : l'alternative légère et performante

Dapper est un micro-ORM développé par l'équipe Stack Overflow. Il est extrêmement rapide et vous donne un contrôle total sur vos requêtes SQL.

Installez Dapper :

dotnet add package Dapper

Exemple d'utilisation :

using Dapper;\nusing Npgsql;\n\nstring connectionString = "Host=localhost;Port=5432;Database=monapp;Username=postgres;Password=your_password";\nusing var connection = new NpgsqlConnection(connectionString);\n\n// Requête simple\nvar users = await connection.QueryAsync<User>("SELECT * FROM users");\n\nforeach (var user in users)\n{\n    Console.WriteLine($"{user.Id} - {user.Name}");\n}\n\n// Requête paramétrée\nvar userById = await connection.QueryFirstOrDefaultAsync<User>(\n    "SELECT * FROM users WHERE id = @Id", new { Id = 1 });\n\nConsole.WriteLine($"Utilisateur trouvé : {userById?.Name}");

Étape 6. Gestion des transactions

Les transactions garantissent l'intégrité de vos données. Si une opération échoue, toutes les modifications sont annulées.

using var transaction = await connection.BeginTransactionAsync();\n\ntry\n{\n    string sql1 = "UPDATE comptes SET solde = solde - 100 WHERE id = 1";\n    string sql2 = "UPDATE comptes SET solde = solde + 100 WHERE id = 2";\n\n    await connection.ExecuteAsync(sql1, transaction: transaction);\n    await connection.ExecuteAsync(sql2, transaction: transaction);\n\n    await transaction.CommitAsync();\n    Console.WriteLine("Transaction réussie !");\n}\ncatch\n{\n    await transaction.RollbackAsync();\n    Console.WriteLine("Transaction annulée.");\n}

Bonnes pratiques et astuces

\n
• Utilisez toujours des requêtes paramétrées pour éviter les injections SQL.
\n
• Gérez les connexions avec using pour libérer les ressources automatiquement.
\n
• Pour les applications à fort trafic, utilisez un pool de connexions (intégré par défaut dans Npgsql).
\n
• Indexez vos colonnes fréquemment utilisées dans les clauses WHERE pour améliorer les performances.
\n
• Pour les opérations par lots, privilégiez les commandes en une seule requête plutôt que plusieurs appels.
\n

Conclusion

Vous avez maintenant toutes les clés en main pour intégrer PostgreSQL dans vos projets C#. Que vous choisissiez Entity Framework Core pour sa productivité ou Dapper pour ses performances brutes, l'important est de comprendre les fondamentaux : connexion, CRUD, transactions et bonnes pratiques.

N'hésitez pas à expérimenter avec des fonctionnalités avancées de PostgreSQL comme les index partiels, les vues matérialisées ou les fonctions window. Combinées à la puissance de C#, ces techniques vous permettront de construire des applications robustes et performantes.

Bon code !