Refactorizați codul de performanță scăzută folosind modul Agent al GitHub Copilot

Dezvoltatorii pot folosi modul Agent al GitHub Copilot pentru a refactoriza în siguranță codul de performanță scăzută, asigurându-se în același timp că funcționalitatea este păstrată și calitatea codului este îmbunătățită.

Ce este modul Agent?

Modul Agent al GitHub Copilot funcționează autonom pentru a executa sarcini complexe de refactorizare în baza de cod. Spre deosebire de modul Întreabă, care oferă îndrumări și sugestii în panoul de chat, modul Agent implementează actualizări sugerate ca editări direct în fișierele de cod.

Modul agent poate edita fișiere, poate aplica modificări, poate rula teste și poate executa comenzi pe baza instrucțiunilor dvs. Înțelege contextul proiectului și poate menține consecvența în mai multe fișiere, asigurându-se că modificările de refactorizare nu întrerup funcționalitatea existentă.

Modul agent este ideal pentru implementarea strategiilor de optimizare în mai mulți pași care necesită o gestionare atentă a dependențelor, cazurilor limită și testării. Modul agent definește automat contextul necesar și execută pașii necesari pentru a vă atinge obiectivele de îmbunătățire a performanței.

Refactorizarea codului cu performanțe scăzute utilizând modul Agent

Puteți utiliza modul Agent pentru a implementa strategiile de optimizare identificate în timpul analizei modului Cerere. Modul agent poate executa automat mai mulți pași de refactorizare, păstrând în același timp funcționalitatea originală și îmbunătățind performanța codului.

Strategii de refactorizare a codului de performanță scăzută

Iată strategiile cheie pentru utilizarea modului Agent pentru a refactoriza codul cu performanțe scăzute:

• Optimizați structurile de date: Instruiți modul Agent să înlocuiască structurile de date ineficiente, cum ar fi căutările liniare, cu alternative optimizate, cum ar fi dicționare sau seturi hash.

• Implementați mecanisme de stocare în cache: Faceți ca modul Agent să adauge cache inteligent pentru a evita calculele redundante sau operațiunile costisitoare.

• Eliminați modelele de interogare N+1: Utilizați modul Agent pentru a consolida mai multe interogări sau operațiuni în operațiuni în lot pentru performanțe mai bune.

• Adăugați procesare asincronă: Permiteți modul agent să convertească operațiunile de blocare în modele asincrone care îmbunătățesc scalabilitatea și capacitatea de reacție.

• Reduceți complexitatea algoritmică: Faceți algoritmi de refactorizare în modul Agent pentru a utiliza abordări mai eficiente cu o complexitate mai bună a timpului.

• Asigurați securitatea: Instruiți modul Agent să valideze dacă optimizările de performanță nu introduc vulnerabilități de securitate sau ocolesc verificările de securitate existente.

• Menținerea funcționalității: Utilizați modul Agent pentru a păstra toată logica de afaceri existentă și gestionarea erorilor, îmbunătățind în același timp caracteristicile de performanță.

Modul agent solicită refactorizarea codului cu performanțe scăzute

Când utilizați modul Agent pentru a refactoriza codul cu performanță scăzută, solicitările trebuie să fie specifice, acționabile și să includă considerații de siguranță. Iată câteva exemple de text în limbaj natural pe care le puteți include în solicitare atunci când refactorizați codul cu performanțe scăzute:

Pregătire și siguranță

• "Înainte de refactorizare, creați teste unitare care verifică comportamentul curent al metodelor critice de performanță selectate."
• "Analizați codul selectat pentru implicații de securitate și asigurați-vă că refactorizarea menține toate verificările de securitate."
• "Creați o ramură de rezervă și rulați testele existente înainte de a face orice optimizare a performanței codului selectat."

Operațiuni de optimizare de bază

• "Refactorizați metoda selectată pentru a utiliza o căutare în dicționar în loc de căutare liniară pentru a îmbunătăți performanța."
• "Optimizați codul selectat prin implementarea mecanismelor de cache pentru operațiuni costisitoare."
• "Înlocuiți modelul de interogare N+1 selectat cu operațiuni în lot pentru a reduce apelurile bazei de date."
• "Convertiți operațiunile de blocare selectate în modele asincrone pentru o mai bună scalabilitate."

Modele avansate de optimizare

• "Refactorizați codul selectat folosind procesarea paralelă pentru a îmbunătăți randamentul, menținând în același timp siguranța firului."
• "Optimizați algoritmul selectat pentru a reduce complexitatea timpului de la O(n²) la O(n log n) sau mai bine."
• "Înlocuiți structura de date ineficientă selectată cu colecții optimizate pentru căutări mai rapide."
• "Refactorizați codul selectat pentru a utiliza modele de încărcare leneșă pentru a îmbunătăți performanța de inițializare."

Calitate și validare

• "După refactorizare, rulați toate testele și verificați dacă performanța s-a îmbunătățit, menținând în același timp funcționalitatea identică."
• "Asigurați-vă că codul refactorizat respectă convențiile de codare C# ale Microsoft și cele mai bune practici de performanță."
• "Validați dacă codul refactorizat menține aceleași caracteristici de securitate ca și implementarea originală."
• "Creați repere de performanță pentru a măsura îmbunătățirea obținută prin refactorizare."

Flux de lucru în modul agent pentru refactorizarea codului cu performanțe scăzute

Următorul flux de lucru demonstrează cum să utilizați modul Agent pentru a refactoriza în siguranță codul cu performanțe scăzute:

1. Pregătiți-vă spațiul de lucru

   Asigurați-vă că lucrați într-o ramură git curată și că orice lucrare existentă este angajată. Lucrul într-o ramură curată vă permite să anulați cu ușurință modificările, dacă este necesar. Navigați la fișierul care conține blocajele de performanță pe care le-ați analizat în modul Întreabă.

2. Configurați măsuri de siguranță

   Înainte de a efectua modificări, solicitați modului agent să creeze sau să ruleze teste unitare existente:

   "Creați teste unitare cuprinzătoare pentru metoda de verificare a comportamentului ProcessOrders curent înainte de refactorizare pentru performanță."

   Acest pas vă asigură că aveți o plasă de siguranță pentru a verifica dacă refactorizarea păstrează funcționalitatea.

3. Începeți cu pași simpli de optimizare

   Începeți cu modificări cu risc scăzut, cum ar fi înlocuirea căutărilor liniare:

   "Refactorizați GetProductById metoda înlocuind căutarea liniară cu o căutare în dicționar pentru performanța O(1) în loc de O(n)."

   Modul agent analizează codul și implementează abordarea bazată pe dicționar, îmbunătățind semnificativ performanța de căutare.

4. Implementați strategii de cache

   Continuați cu optimizările de stocare în cache:

   "Adăugați cache inteligent la GetExchangeRate metodă pentru a evita apelurile API redundante pentru aceeași monedă într-o perioadă scurtă de timp."

   Modul agent creează o logică adecvată de stocare în cache, reducând apelurile costisitoare de servicii externe.

5. Optimizați complexitatea algoritmică

   Rezolvați probleme de performanță mai complexe:

   "Refactorizați bucla CalculateDiscounts imbricată pentru a utiliza un algoritm mai eficient care procesează operațiunile în bloc într-o singură trecere."

   Modul agent identifică buclele imbricate ineficiente și le înlocuiește cu algoritmi optimizați.

6. Validați modificările

   După fiecare pas major de refactorizare, validați modificările:

   "Rulați toate testele unitare și benchmark-urile de performanță pentru a verifica dacă codul refactorizat produce rezultate identice cu performanțe îmbunătățite."

   Modul agent poate executa teste și poate raporta orice defecțiuni care trebuie rezolvate.

7. Revizuiți și iterați

   Dacă se găsesc probleme, oferiți instrucțiuni specifice pentru remedieri:

   "Testul de performanță arată doar o îmbunătățire marginală. Revizuiți logica de cache refactorizată și asigurați-vă că rezultatele cache sunt utilizate eficient."

   Modul agent analizează valorile de performanță și face corecțiile necesare pentru a obține îmbunătățirile așteptate.

Această abordare structurată asigură că optimizarea performanței se face în siguranță și sistematic, cu validare la fiecare pas.

Scenarii comune pentru refactorizarea codului cu performanțe scăzute

Revizuirea scenariilor comune vă poate ajuta să înțelegeți cum să utilizați eficient modul Agent pentru refactorizarea performanței.

Optimizați modelele de acces la date (eliminați interogările N+1)

Modelele de acces la date care au ca rezultat interogări N+1 pot degrada grav performanța. Refactorizarea la preluarea datelor în lot poate îmbunătăți semnificativ eficiența.

Acest scenariu poate fi ilustrat folosind următorul fragment de cod:

foreach (var order in orders)
{
    decimal price = GetProductPrice(order.ProductId); // database call
    order.TotalPrice = order.Quantity * price;
}

Analiza de profilare arată că GetProductPrice (care interogează o bază de date) este un blocaj atunci când procesează comenzi mari.

Puteți utiliza modul Agent pentru a refactoriza codul prin gruparea căutărilor de preț ale produselor. De exemplu:

Solicitare în modul agent: "Optimizați acest cod pentru a elimina modelul de interogare N+1 prin gruparea căutărilor de preț ale produselor."

Agentul refactorizează codul după cum urmează:

1. Colectați toate ID-urile unice de produse.
2. Preluați prețurile într-un singur apel la baza de date.
3. Mapați prețurile înapoi la comenzi.

Codul refactorizat ar trebui să arate similar cu următorul fragment de cod:

var productIds = orders.Select(o => o.ProductId).Distinct().ToList();
var priceCache = GetProductPrices(productIds).ToDictionary(p => p.ProductId, p => p.Price);

foreach (var order in orders)
{
    if (priceCache.TryGetValue(order.ProductId, out decimal price))
    {
        order.TotalPrice = order.Quantity * price;
    }
}

Observați următoarele îmbunătățiri:

• Codul actualizat grupează toate căutările de preț necesare într-un singur apel de bază de date.
• Gestionarea erorilor pentru produsele lipsă este menținută corespunzător.
• Codul menține aceeași logică de afaceri, îmbunătățind în același timp dramatic performanța.

Înlocuiți algoritmii ineficienți

Înlocuirea căutării liniare cu structuri de date optimizate pentru performanțe mai bune.

Acest scenariu poate fi ilustrat folosind următorul fragment de cod:

public Product FindProductByName(string name)
{
    foreach (var product in products) // O(n) linear search
    {
        if (product.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
        {
            return product;
        }
    }
    return null;
}

Puteți utiliza modul Agent pentru a refactoriza codul utilizând un dicționar pentru căutările O(1). De exemplu:

Solicitare în modul agent: "Optimizați căutările de produse utilizând o abordare bazată pe dicționar pentru performanța O(1)."

Agentul refactorizează codul după cum urmează:

1. Inițializați un dicționar care mapează numele produselor la obiectele produsului.
2. Utilizați dicționarul pentru căutări.

Codul refactorizat ar trebui să arate similar cu următorul fragment de cod:

private readonly Dictionary<string, Product> _productsByName = 
    products.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);

public Product FindProductByName(string name)
{
    _productsByName.TryGetValue(name, out Product product);
    return product;
}

Observați următoarele îmbunătățiri:

• Complexitatea timpului de căutare se îmbunătățește de la O(n) la O(1).
• Logica de comparație a șirurilor este păstrată folosind comparatorul corespunzător.
• Costul de inițializare este amortizat pe mai multe operațiuni de căutare.

Implementați procesarea asincronă

Conversia operațiunilor de blocare în modele asincrone pentru o scalabilitate mai bună. Refactorizarea codului sincron pentru a utiliza programarea asincronă poate îmbunătăți capacitatea de răspuns și scalabilitatea.

Acest scenariu poate fi ilustrat folosind următorul fragment de cod:

public void ProcessOrderNotification(Order order)
{
    var emailContent = GenerateEmailContent(order);
    Thread.Sleep(1000); // simulate email service delay
    SendEmail(order.CustomerEmail, emailContent);
}

Puteți utiliza modul Agent pentru a refactoriza codul convertindu-l într-un model asincron. De exemplu:

Solicitare în modul agent: "Convertiți această procesare sincronă a e-mailurilor în asincronă pentru a îmbunătăți scalabilitatea și capacitatea de reacție."

Agentul refactorizează codul după cum urmează:

1. Faceți metoda asincronă.
2. Utilizați await pentru operațiuni asincrone.

Codul refactorizat ar trebui să arate similar cu următorul fragment de cod:

public async Task ProcessOrderNotificationAsync(Order order)
{
    var emailContent = await GenerateEmailContentAsync(order);
    await Task.Delay(1000); // simulate async email service delay
    await SendEmailAsync(order.CustomerEmail, emailContent);
}

Observați următoarele îmbunătățiri:

• Toți apelanții sunt actualizați pentru a aștepta metoda asincronă.
• Modelul asincron este aplicat în mod constant pe tot lanțul de apeluri.
• Tokenurile de gestionare și anulare a erorilor sunt implementate corect acolo unde este necesar.

Considerente de securitate și calitate

Când utilizați modul Agent pentru refactorizarea performanței, luați întotdeauna în considerare implicațiile de securitate și calitate:

Cele mai bune practici de securitate

Luați în considerare următoarele practici de securitate atunci când refactorizați pentru performanță:

• Validați gestionarea intrărilor: asigurați-vă că optimizările de performanță nu ocolesc validarea intrărilor și nu introduc vulnerabilități de injecție.

• Păstrați verificările de autorizare: verificați dacă validările legate de securitate nu sunt eliminate sau slăbite accidental în timpul optimizării.

• Practici de stocare în cache securizate: Asigurați-vă că datele stocate în cache nu expun informații sensibile și nu creează căi de acces neautorizate.

• Menținerea pistelor de audit: Asigurați-vă că logica de înregistrare și monitorizare este păstrată în timpul îmbunătățirilor de performanță.

Standarde de calitate a codului

Companiile adoptă în general un set specific de standarde de codare. Dacă nu aveți instrucțiuni, Microsoft publică recomandări pentru convențiile de codare C# pe care le puteți urma.

Mențineți o calitate ridicată a codului urmând aceste instrucțiuni:

• Urmați modelele stabilite: asigurați-vă că codul refactorizat respectă standardele de codare și modelele arhitecturale ale echipei dvs.

• Mențineți lizibilitatea: Verificați dacă codul optimizat rămâne lizibil și întreținut, chiar și cu îmbunătățiri ale performanței.

• Păstrați gestionarea erorilor: asigurați-vă că toată logica de gestionare a erorilor este menținută în timpul optimizărilor de performanță.

• Documentați optimizări complexe: Adăugați comentarii care explică optimizări de performanță neevidente pentru viitorii întreținetori.

Instrucțiuni de siguranță pentru modul agent

Modul agent este puternic, dar necesită o supraveghere atentă:

Înainte de refactorizare

• Lucrați întotdeauna într-o ramură de caracteristici.
• Asigurați-vă că există o acoperire cuprinzătoare a testelor.
• Revizuiți planul de optimizare din analiza modului Cerere.
• Înțelegeți caracteristicile de performanță și logica afacerii.

În timpul refactorizării

• Faceți modificări incrementale, mai degrabă decât transformări mari.
• Validați fiecare pas de optimizare înainte de a trece la următorul.
• Revizuiți codul generat pentru corectitudine și îmbunătățiri ale performanței.
• Testați frecvent pentru a detecta regresiile devreme.

După refactorizare

• Rulați benchmark-uri de performanță cuprinzătoare, inclusiv comparații de referință.
• Efectuați revizuirea codului cu membrii echipei.
• Validați caracteristicile de securitate și funcționalitate.
• Actualizați documentația pentru a reflecta îmbunătățirile performanței.

Tratați modul Agent ca pe un asistent puternic

În timp ce modul Agent poate efectua optimizări complexe ale performanței, necesită supraveghere umană:

• Examinați toate modificările înainte de a le accepta.
• Validați că îmbunătățirile de performanță sunt măsurabile și semnificative.
• Asigurați-vă că cerințele de securitate și funcționalitate sunt îndeplinite.
• Testați temeinic pentru a detecta schimbările subtile de comportament.

Modul agent accelerează optimizarea performanței, dar nu înlocuiește nevoia de revizuire, testare și măsurare atentă.

Rezumat

Utilizarea modului Agent al GitHub Copilot permite dezvoltatorilor să refactorizeze eficient codul de performanță scăzută, menținând în același timp calitatea și funcționalitatea codului. Combinând informațiile analitice din modul Întreabă cu capacitățile de execuție ale modului Agent, puteți îmbunătăți sistematic performanța, scalabilitatea și eficiența aplicațiilor. Cheia succesului este furnizarea de instrucțiuni clare, menținerea practicilor de siguranță și validarea temeinică a tuturor modificărilor prin testare cuprinzătoare și măsurare a performanței.