C# Academy · Lektion

Utforma bra extension methods

Tillämpa god praxis och undvik fallgropar.

Lektion 4 av 413 steg

Utforma bra extension methods är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Utforma utökningar som andra uppskattar

Utökningsmetoder är kraftfulla, men kraft bjuder in till missbruk. Bra utökningar känns som en naturlig del av typen, är lätta att upptäcka och överraskar aldrig den som anropar dem. I den här lektionen går vi igenom praktiska riktlinjer.

Utöka funktionalitet, inte identitet

Föredra utökningar för nyttofunktioner som blir lättlästa i en pipeline. Om en metod verkligen hör till en typ som Du äger bör Du i stället göra den till en riktig medlem.

using System;

public static class TimeExtensions
{
    // A pleasant, focused helper
    public static bool IsWeekend(this DayOfWeek day)
        => day == DayOfWeek.Saturday || day == DayOfWeek.Sunday;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(DayOfWeek.Sunday.IsWeekend());
        Console.WriteLine(DayOfWeek.Monday.IsWeekend());
    }
}

Håll metoderna rena när det är möjligt

Utökningar som returnerar ett nytt värde och undviker sidoeffekter är enklast att förstå och kedja. Sikta på data in, värde ut.

using System;

public static class StringExtensions
{
    // Pure: depends only on input, returns a new string
    public static string Truncate(this string s, int max)
        => s.Length <= max ? s : s.Substring(0, max) + "...";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Extension methods are great".Truncate(10));
    }
}

Hantera null-indata

Eftersom anropare kan anropa en utökning på en null-mottagare bör Du medvetet bestämma vad som ska hända. Antingen hanterar Du null på ett smidigt sätt eller kastar Du ett tydligt ArgumentNullException.

using System;

public static class StringExtensions
{
    public static string SafeUpper(this string s)
    {
        if (s is null) throw new ArgumentNullException(nameof(s));
        return s.ToUpper();
    }
}

public class Program
{
    public static void Main()
    {
        try { ((string)null).SafeUpper(); }
        catch (ArgumentNullException ex) { Console.WriteLine("Caught: " + ex.ParamName); }
        Console.WriteLine("ok".SafeUpper());
    }
}

Namnge för att underlätta upptäckt

Utvecklare hittar utökningar genom att skriva punkt och söka igenom IntelliSense. Tydliga, verbbaserade namn som beskriver resultatet gör Dina hjälpmetoder lätta att upptäcka och självförklarande.

using System;
using System.Collections.Generic;

public static class CollectionExtensions
{
    public static bool HasItems<T>(this ICollection<T> c)
        => c != null && c.Count > 0;
}

public class Program
{
    public static void Main()
    {
        var list = new List<int> { 1 };
        Console.WriteLine(list.HasItems());
    }
}

Samla relaterade utökningar på ett enhetligt sätt

Placera utökningar för ett och samma koncept i en väl namngiven statisk klass och ett väl namngivet namespace. Då blir importer meningsfulla och användare kan ta in exakt de hjälpmetoder de vill ha.

using System;
using System.Collections.Generic;

public static class EnumerableExtensions
{
    public static IEnumerable<T> TakeFirst<T>(this IEnumerable<T> source, int n)
    {
        int taken = 0;
        foreach (var item in source)
        {
            if (taken++ >= n) yield break;
            yield return item;
        }
    }
}

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4 };
        Console.WriteLine(string.Join(",", nums.TakeFirst(2)));
    }
}

Dölj inte överraskande beteenden

En utökning som verkar enkel men utför dyrt eller tillståndsberoende arbete bryter mot förväntningarna. Gör kostnaden tydlig; om metoden frågar en databas eller ändrar tillstånd bör namnet ange det.

using System;

public static class MathExtensions
{
    // Cheap and obvious: no hidden cost
    public static int ClampMin(this int value, int min)
        => value < min ? min : value;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine((-3).ClampMin(0));
        Console.WriteLine(5.ClampMin(0));
    }
}

Undvik att utöka object

Att utöka object förorenar varje typ i programmet med Din metod och belamrar IntelliSense överallt. Rikta i stället in Dig på den mest specifika typ eller det mest specifika gränssnitt som är relevant.

using System;

public static class IntExtensions
{
    // Specific to int, not object - far less noisy
    public static string ToOrdinal(this int n)
    {
        if (n % 10 == 1 && n % 100 != 11) return n + "st";
        if (n % 10 == 2 && n % 100 != 12) return n + "nd";
        if (n % 10 == 3 && n % 100 != 13) return n + "rd";
        return n + "th";
    }
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(1.ToOrdinal());
        Console.WriteLine(22.ToOrdinal());
    }
}

Föredra IEnumerable för sekvenser

För sekvensoperatorer bör Du returnera IEnumerable<T> och använda fördröjd körning. Det går bra att komponera och undviker att tvinga anropare att materialisera data som de kanske inte behöver.

using System;
using System.Collections.Generic;

public static class SeqExtensions
{
    public static IEnumerable<int> Doubled(this IEnumerable<int> source)
    {
        foreach (var n in source) yield return n * 2;
    }
}

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3 };
        foreach (var n in nums.Doubled()) Console.WriteLine(n);
    }
}

En checklista för bra utökningar

Innan Du levererar en utökning bör Du fråga: Är namnet tydligt? Är metoden ren, eller är sidoeffekterna uppenbara? Hanteras null? Är måltypen specifik? Är utökningen grupperad på ett vettigt sätt? Om svaret är ja på allt har Du en hjälpmetod som andra gärna använder.

using System;

public static class StringExtensions
{
    public static string OrDefault(this string s, string fallback)
        => string.IsNullOrEmpty(s) ? fallback : s;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("".OrDefault("N/A"));
        Console.WriteLine("value".OrDefault("N/A"));
    }
}

Prova själv

Tillämpa checklistan: en specifik måltyp, ett tydligt namn, null-tolerans och ett rent resultat. Den här lilla utökningen följer alla riktlinjer.

using System;
using System.Collections.Generic;

public static class DictionaryExtensions
{
    // Clear name, specific type, null-safe, pure
    public static TValue GetOrDefault<TKey, TValue>(
        this IReadOnlyDictionary<TKey, TValue> dict, TKey key, TValue fallback)
    {
        if (dict == null) return fallback;
        return dict.TryGetValue(key, out var value) ? value : fallback;
    }
}

public class Program
{
    public static void Main()
    {
        var ages = new Dictionary<string, int> { ["Ann"] = 30 };
        Console.WriteLine(ages.GetOrDefault("Ann", -1));
        Console.WriteLine(ages.GetOrDefault("Bob", -1));
    }
}

Snabbkontroll

Tillämpa riktlinjerna för utformning.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Väl utformade utökningar känns inbyggda och förutsägbara.

Föredra rena hjälpmetoder som returnerar värden och kan kedjas väl.
Bestäm och dokumentera hur null hanteras.
Använd tydliga, verbbaserade namn som underlättar upptäckt.
Rikta in Dig på specifika typer eller gränssnitt, inte object.
Samla relaterade hjälpmetoder och returnera IEnumerable<T> för sekvenser.

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Utforma bra extension methods” gratis?

Ja – hela texten till ”Utforma bra extension methods” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Utforma bra extension methods”?

Tillämpa god praxis och undvik fallgropar. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Utforma bra extension methods”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C# Academy