Profiler votre application avec l’agent GitHub Copilot Profiler

L’agent GitHub Copilot Profiler fonctionne avec GitHub Copilot et vous guide tout au long des tests de performances et de l’amélioration.

Ce tutoriel montre comment profiler des applications et améliorer les performances à l’aide de l’agent Copilot Profiler.

L’agent profileur peut effectuer toutes les tâches suivantes.

Analysez l’utilisation du processeur, les allocations de mémoire et le comportement du runtime.
Goulots d’étranglement des performances de surface.
Générez des benchmarks BenchmarkDotNet ou optimisez les benchmarks BenchmarkDotNet existants.
Appliquez des optimisations suggérées.
Valider les améliorations apportées à une boucle guidée.

L’agent profileur est particulièrement utile quand :

Vous ne connaissez pas le profilage.
Vous ne savez pas où commencer par le réglage des performances.
Vous souhaitez valider les optimisations avec des benchmarks réels.
Vous travaillez sur des applications hautes performances telles que des jeux, des services ou des outils clients.

Pour plus d’informations sur les autres fonctionnalités de profilage dans Copilot, consultez les scénarios améliorés par l’IA. Pour obtenir des informations générales sur les agents Copilot et le mode agent, consultez Utiliser le mode d’agent Copilot.

Prerequisites

Pour commencer, vous avez besoin des éléments suivants :

Visual Studio version 18.0.0 Preview 1 ou ultérieure
Se connecter à Visual Studio en utilisant un compte GitHub avec accès à Copilot
^** Vous pouvez utiliser GitHub Copilot gratuitement. Inscrivez-vous et tirez parti de l’IA pour coder plus rapidement et plus efficacement.

Démarrer une session de profilage

Dans Visual Studio, créez une application console C#.

Dans la fenêtre de démarrage, choisissez Créer un projet. Tapez la console dans la zone de recherche, sélectionnez C# comme langue, puis choisissez Application console pour .NET. Choisissez Suivant. Tapez un nom de projet tel que ConsoleApp_CopilotProfile , puis sélectionnez Suivant. Choisissez une infrastructure cible (par exemple, .NET 8) et choisissez Créer.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud Dépendances dans le projet, choisissez Gérer les packages NuGet, recherchez EntityFramework, puis ajoutez les packages suivants au projet :
- Microsoft.EntityFramework.Core
- Microsoft.EntityFramework.Core.InMemory
L’application utilise une base de données en mémoire pour simplifier la configuration du projet.

Remplacez le code dans Program.cs par le code suivant :

using System.Diagnostics;
using Microsoft.EntityFrameworkCore;

// Configure EF Core to use the InMemory provider
var options = new DbContextOptionsBuilder<AppDbContext>()
    .UseInMemoryDatabase("PerfDemoDb")
    .Options;

using var db = new AppDbContext(options);

// Seed 100,000 records once
if (!db.People.Any())
{
    var rand = new Random(42);
    var cities = new[]
    {
        "Chicago", "Seattle", "Cairo", "London", "Paris",
        "Cleveland", "Calgary", "Dallas", "Berlin", "Copenhagen"
    };

    var people = Enumerable.Range(1, 100_000).Select(i => new Person
    {
        Name = $"Person {i}",
        Age = rand.Next(18, 80),
        City = cities[rand.Next(cities.Length)]
    });

    db.People.AddRange(people);
    db.SaveChanges();
}

Console.WriteLine($"Seeded records: {db.People.Count():N0}");

// Inefficient LINQ pattern: materialize everything and repeatedly re-materialize + chain ToList
// This simulates client-heavy work that doesn't scale, even with in-memory provider
var sw = Stopwatch.StartNew();

// Full materialization of all rows
var all = db.People.ToList();

// Extra ToList calls create multiple large intermediate lists
var inefficient = all
    .Where(p => p.Age > 50)
    .ToList()
    .Where(p => p.City.StartsWith("C"))
    .ToList()
    .Select(p => p.Name)
    .Distinct()
    .OrderBy(n => n)
    .Take(10)
    .ToList();

sw.Stop();
Console.WriteLine($"Inefficient query returned {inefficient.Count} rows in {sw.ElapsedMilliseconds} ms");

// EF Core entity
public class Person
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public int Age { get; set; }
    public string City { get; set; } = string.Empty;
}

// EF Core DbContext
public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
    public DbSet<Person> People => Set<Person>();
}

Sélectionnez Générer la > solution pour vous assurer que l’application génère sans erreur.

Demander à Copilot d’obtenir des insights sur le profilage

Ouvrez la fenêtre Copilot Chat et utilisez l’invite suivante.

@Profiler Please evaluate the performance of this code
Sélectionnez Envoyer.

La @Profiler commande appelle l’agent Copilot Profiler.

Vous pouvez également démarrer l’agent du profileur en choisissant manuellement Sélectionner des outils et en activant manuellement l’agent profileur, puis en basculant vers le mode agent. À l’aide de cette méthode, vous n’avez pas besoin d’utiliser la @Profiler commande.

Copilot vous demande si vous souhaitez exécuter le profileur.
Choisissez Confirmer.

L’agent s’exécute par une série d’étapes indépendamment. Il examine le code, ajoute la prise en charge au projet pour BenchmarkDotNet, y compris les références de projet et les packages, ajoute des benchmarks à un nouveau fichier et exécute un test de comparaison par rapport au nouveau code qu’il génère.

Les résultats du benchmark s’affichent dans la fenêtre Sortie, avec la sortie définie sur Diagnostics Hub.

Les résultats de la session de diagnostics s’affichent dans un rapport de fichier .diagsession . Si vous souhaitez examiner manuellement l’utilisation du processeur, consultez Analyser les performances à l’aide du profilage du processeur. Toutefois, dans ce scénario, nous utilisons l’agent Profiler à la place.

Une fois le test terminé, l’agent récapitule ses résultats.

L’agent signale un potentiel de 33% gagner en efficacité, principalement en supprimant la matérialisation complète de table et un appel de méthode inutile ToList() .

L’agent fournit également quelques suggestions pour les étapes suivantes, notamment une option permettant d’optimiser la requête LINQ.

Pour cet exemple, vous vous concentrez sur l’optimisation de la requête LINQ.
Sélectionnez la deuxième suggestion Copilot et sélectionnez Envoyer pour indiquer à l’agent d’optimiser la chaîne de requêtes LINQ.

L’agent met à jour Program.cs et fournit des suggestions supplémentaires pour optimiser le code. Nous allons ignorer ces suggestions pour l’instant.
Examinez les modifications apportées au code dans Program.cs.

Dans le coin inférieur droit de l’éditeur de code, examinez les modifications du code et sélectionnez Conserver pour les conserver.

La requête optimisée s’affiche ici.

 var optimized = db.People
     .AsNoTracking()
     .Where(p => p.Age > 50 && p.City.StartsWith("C"))
     .Select(p => p.Name)
     .Distinct()
     .OrderBy(n => n)
     .Take(10)
     .ToList();

Si vous souhaitez que l’agent effectue des optimisations supplémentaires, sélectionnez les suggestions fournies par l’agent ou posez des questions supplémentaires.

Continuer la conversation après avoir atteint la limite de jetons

L'agent Profiler fournit une synthèse intelligente ainsi que la poursuite des discussions, conçue pour maintenir le flux de travail sans être bloqué par les limites de jetons.

Si une conversation avec Copilot approche de sa limite de jeton, vous êtes invité à utiliser l’option pour résumer et continuer dans un nouveau thread.

Capture d’écran de la synthèse des threads.

Si vous sélectionnez cette option, l’agent génère automatiquement un résumé concis et riche en contexte du thread de conversation actuel et le transmet dans une nouvelle conversation. Cela vous permet d’éviter de retracer les étapes.

Rétroaction

Cette page a-t-elle été utile ?

Last updated on 2025-11-12