Startup-Anleitung für Prompt Engineering mit GitHub Copilot

Einführung

Die Erstellung von Eingabeaufforderungen ist eine wichtige Fähigkeit für Entwickler, die den Nutzen von GitHub Copilot maximieren möchten. Durch die Strukturierung effektiver Eingabeaufforderungen können Entwickler präzise, kontextbezogene Vorschläge erhalten, die Zeit sparen und die Produktivität steigern.

Dieser Artikel befasst sich mit grundlegenden und fortgeschrittenen Techniken zur Nutzung von GitHub Copilot für das Schreiben von Code, Debugging und Testen in C#, einer in der Softwareentwicklung weit verbreiteten Sprache.

Kernkonzepte in Prompt Engineering

One-Shot Prompting

Beim One-Shot Prompting wird eine einzige, prägnante Anweisung verfasst. Diese Methode eignet sich am besten für unkomplizierte Aufgaben. Sie ermöglicht es GitHub Copilot, Code auf der Grundlage minimaler Eingaben zu generieren, was es für einfache Funktionen oder allgemein bekannte Programmiermuster effizient macht.

Beispiel: Reverse a string.

Aufforderung "Erstellen Sie eine C#-Funktion zur Umkehrung einer Zeichenkette."

Ausgabe

using System;

public class StringManipulation
{
    public static string ReverseString(string input)
    {
        char[] charArray = input.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
}

Eine klare Anweisung führt zu einer einfachen und effektiven Lösung.

Single-Shot Prompting

Hier geben Sie eine Beispieleingabe und die gewünschte Ausgabe an, um Copilot zu leiten. Diese Technik hilft Copilot, die erwartete Struktur und das Format zu verstehen und ist daher besonders nützlich für Aufgaben, die präzise Ausgabemuster oder bestimmte Bedingungen erfordern.

Beispiel: Gerade Zahlen aus einer Liste filtern.

Aufforderung "Geben Sie eine Liste von ganzen Zahlen an und erstellen Sie eine neue Liste, die nur gerade Zahlen enthält. Beispiel: Eingabe: [1, 2, 3, 4] Ausgabe: [2, 4]."

Ausgabe

using System;
using System.Collections.Generic;
using System.Linq;

public class NumberFilter
{
    public static List<int> FilterEvenNumbers(List<int> numbers)
    {
        return numbers.Where(n => n % 2 == 0).ToList();
    }
}

Dieser Ansatz stellt sicher, dass Copilot Ihre Erwartungen versteht.

Gedankenkette als Anregung

Bei komplexen Aufgaben zerlegen Sie das Problem in logische Schritte und leiten Copilot schrittweise an. Diese Methode hilft Copilot, strukturiertere und genauere Antworten zu generieren, indem die Lösung schrittweise verfeinert wird. Sie ist besonders effektiv für Algorithmen, mehrstufige Arbeitsabläufe und Szenarien, die eine sequenzielle Entscheidungsfindung erfordern.

Beispiel: Verarbeiten Sie Benutzerdaten aus einer CSV-Datei.

Aufforderung "Schreiben Sie ein C#-Programm, um eine CSV-Datei zu lesen, Zeilen anhand einer Bedingung zu filtern und die Ergebnisse auszugeben."

Ausgabe

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class CSVProcessor
{
    public static List<string[]> ReadCSV(string filePath)
    {
        return File.ReadAllLines(filePath).Select(line => line.Split(',')).ToList();
    }

    public static List<string[]> FilterRows(List<string[]> data)
    {
        return data.Where(row => int.Parse(row[1]) > 50).ToList();
    }
}

Unterscheiden Sie die Eingabeaufforderung deutlich von der Ausgabe.

Zero Shot Gedankenkettenanregung

Beim Zero-Shot CoT Prompting geht es im Wesentlichen darum, die ursprüngliche Aufforderung um den Zusatz "Let's think step by step" zu ergänzen.

Beispiel: Verarbeiten Sie Benutzerdaten aus einer CSV-Datei.

Aufforderung "Bestimmen Sie, ob eine Zahl eine Primzahl ist. Lassen Sie uns Schritt für Schritt nachdenken."

Ausgabe

using System;

public class PrimeChecker
{
    public static bool IsPrime(int number)
    {
        if (number < 2) return false;
        for (int i = 2; i <= Math.Sqrt(number); i++)
        {
            if (number % i == 0) return false;
        }
        return true;
    }
}

Die Aufteilung der Lösung in Schritte verbessert die Genauigkeit.

[!HINWEIS]
Lesen Sie hier mehr über Chain-of-Thought Prompting: https://www.promptingguide.ai/techniques/cot

Effektive Prompts schreiben

Beispiele für wirksame und unwirksame Aufforderungen

Ineffektiv: "Erstellen Sie eine Funktion".

• Effektiv: "Schreiben Sie eine C#-Methode, die eine Liste von Ganzzahlen akzeptiert und die Summe der geraden Zahlen zurückgibt."

Ineffektiv: "Eine Liste sortieren".

• Effektiv: "Schreiben Sie eine C#-Methode, die eine Liste von Strings akzeptiert und die Liste in alphabetischer Reihenfolge sortiert zurückgibt."

Ineffektiv: "Erzeugen Sie einen Bericht".

• Effektiv: "Schreiben Sie eine C#-Methode, die einen Umsatzbericht für einen bestimmten Monat erstellt, der den Gesamtumsatz, den durchschnittlichen Umsatz pro Tag und den umsatzstärksten Tag enthält."

Diese Beispiele zeigen, wie die Angabe spezifischer Details in Ihrer Eingabeaufforderung zu genaueren und nützlicheren Codevorschlägen von GitHub Copilot führen kann.

Mehrstufige Prompts

Führen Sie den Copiloten mit schrittweisen Anweisungen.

Aufforderung 1 "Erstellen Sie ein C# Web-API-Projekt."

Ausgabe 1

// Create a new ASP.NET Core Web API project using the .NET CLI
// Command: dotnet new webapi -n UserManagementAPI

Aufforderung 2 "Fügen Sie einen UsersController hinzu, um Benutzer zu verwalten."

Ausgabe 2

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

[ApiController]
[Route("api/users")]
public class UsersController : ControllerBase
{
    private static List<string> users = new List<string> { "Alice", "Bob", "Charlie" };

    [HttpGet]
    public IActionResult GetUsers()
    {
        return Ok(users);
    }
}

Aufforderung 3 "Fügen Sie eine Methode hinzu, um einen neuen Benutzer in die Liste aufzunehmen."

Ausgabe 3

[HttpPost]
public IActionResult AddUser([FromBody] string user)
{
    users.Add(user);
    return Ok();
}

Aufforderung 4 "Fügen Sie eine Methode zum Löschen eines Benutzers aus der Liste hinzu."

Ausgabe 4

[HttpDelete("{name}")]
public IActionResult DeleteUser(string name)
{
    users.Remove(name);
    return Ok();
}

Fortgeschrittene Techniken

Hier finden Sie weitere fortgeschrittene Beispiele für die Verwendung von Copilot zur Leistungsoptimierung.

Aufforderung "Optimieren Sie die folgende C#-Methode, um die Speichernutzung zu reduzieren und die Leistung zu verbessern."

Ursprünglicher Code

public static List<int> GetSquareNumbers(List<int> numbers)
{
    List<int> squares = new List<int>();
    foreach (var num in numbers)
    {
        squares.Add(num * num);
    }
    return squares;
}

Optimierter Code mit LINQ

public static List<int> GetSquareNumbers(List<int> numbers) => numbers.Select(n => n * n).ToList();

Die Verwendung von LINQ verbessert die Leistung durch die Reduzierung von Iterationen.

Testen und Debuggen

Beispiel Anstelle von übermäßigen Codekommentaren verwenden Sie den Copilot-Chat für eine interaktivere Debugging-Sitzung.

Eingabeaufforderung "Warum liefert meine C#-Funktion falsche Ergebnisse?"

Ausgabe

• "Lassen Sie uns nach Randfällen suchen. Behandeln Sie leere Listen korrekt?"
• "Ziehen Sie in Betracht, vor der Verarbeitung eine Eingabeüberprüfung hinzuzufügen."

Dieser interaktive Ansatz ist praktischer als das Einbetten langer Kommentare in den Code.

Unit Tests generieren

Die Fähigkeit von Copilot, Unit-Tests zu erstellen, hilft Entwicklern, ihren Code schnell zu validieren.

Aufforderung "Schreiben Sie Unit-Tests für eine Methode, die prüft, ob eine Zahl eine Primzahl ist."

Ausgabe

using System;
using Xunit;

public class PrimeCheckerTests
{
    [Fact]
    public void Test_PrimeNumbers()
    {
        Assert.True(PrimeChecker.IsPrime(5));
        Assert.True(PrimeChecker.IsPrime(11));
    }

    [Fact]
    public void Test_NonPrimeNumbers()
    {
        Assert.False(PrimeChecker.IsPrime(4));
        Assert.False(PrimeChecker.IsPrime(10));
    }
}

Unit-Tests sorgen für Korrektheit und fangen Regressionen frühzeitig ab.

Hilfe bei der Fehlersuche

GitHub Copilot kann Sie bei der Identifizierung und Behebung von Fehlern unterstützen, indem er den vorhandenen Code analysiert und Verbesserungen vorschlägt.

Beispiel Behebung eines Gleichzeitigkeitsproblems in einer Multithreading-Anwendung.

Aufforderung "Beheben Sie die Race Condition in diesem C# Multithreading-Beispiel."

Buggy Code

using System;
using System.Threading;

class Counter
{
    private int count = 0;

    public void Increment()
    {
        count++;
    }

    public int GetCount() => count;
}

Copilot Vorgeschlagene Lösung (Verwendung einer Sicherung für das Gewinde)

using System;
using System.Threading;

class Counter
{
    private int count = 0;
    private readonly object lockObject = new object();

    public void Increment()
    {
        lock (lockObject)
        {
            count++;
        }
    }

    public int GetCount() => count;
}

Die Verwendung einer Sperre stellt sicher, dass immer nur ein Thread den Zählerstand ändern kann, wodurch Race Conditions verhindert werden.

Reale Test-Szenarien

Generieren Sie mühelos Mock-Daten für das Testen von APIs oder Datenbankoperationen. Stellen Sie sicher, dass die Eingabeaufforderung genau auf die Testdaten abgestimmt ist.

Aufforderung "Erzeugen Sie Schein-Testdaten für ein C#-Benutzerregistrierungssystem."

Ausgabe

using System;
using System.Collections.Generic;

public class MockUserData
{
    public static List<(string name, int age)> GenerateUsers(int count)
    {
        var users = new List<(string, int)>();
        var rand = new Random();

        for (int i = 0; i < count; i++)
        {
            users.Add(($"User{i}", rand.Next(18, 70)));
        }
        return users;
    }
}

Durch die Angabe des Benutzerregistrierungssystems liefert Copilot relevante Scheindaten.

Durch den Einsatz dieser Techniken wird GitHub Copilot zu einem leistungsstarken Tool, mit dem Sie nicht nur Code schreiben, sondern auch dessen Qualität und Zuverlässigkeit sicherstellen können.

Zusammenfassung

Ich hoffe, dieser Artikel hat Ihnen geholfen, das Prompt Engineering mit GitHub Copilot in Gang zu bringen. Ob Sie nun einfache Funktionen verfeinern oder komplexe Arbeitsabläufe in Angriff nehmen, die richtigen Prompts können den Unterschied ausmachen. Experimentieren Sie weiter, iterieren Sie und optimieren Sie Ihre Prompts, um die besten Ergebnisse zu erzielen. Viel Glück auf Ihrer Reise zum Programmieren!

Hier sind die wichtigsten Erkenntnisse:

• Beginnen Sie mit klaren, spezifischen, strukturierten Aufforderungen für bessere Antworten und unkomplizierte Aufgaben.
• Nutzen Sie den Kontext, einschließlich Kommentare und mehrstufige Anleitungen, für komplexe Arbeitsabläufe.
• Nutzen Sie Chain of Thought und iterative Verfeinerung zur Bewältigung komplexer Herausforderungen.
• Verwenden Sie den Copilot-Chat zur Fehlersuche anstelle von übermäßigen Inline-Kommentaren.
• Optimieren Sie die Leistung mit fortgeschrittenen Techniken und strukturiertem Refactoring.
• Integrieren Sie Tests und Refactoring in Ihren Arbeitsablauf, um den Nutzen von Copilot zu maximieren.

Dieser Artikel ist Teil des XPRT. Magazin. Die Goldene Ausgabe! Laden Sie Ihr kostenloses Exemplar hier herunter