capypad
0 Tage Serie
Neues Quiz
Code-Bibliothek

Code, der lesenswert ist.

Sorgfältig kuratierte Snippets — TypeScript, Python, Rust, Go und mehr. Jedes mit einer Zeile-für-Zeile-Erklärung, damit du Code so liest, wie die Leute ihn geschrieben haben.

3498 Snippets · 10 Sprachen
▶ Lernen starten
Sammlung öffnen: C# · Experten →
C# · ExperteSnippet

SIMD-Vektorisierung mit Vector<T>

Single Instruction, Multiple Data (SIMD) ermöglicht es einem einzigen CPU-Befehl, mehrere Datenpunkte gleichzeitig zu verarbeiten. Vector<T> in C# ermöglicht hardwarebeschleunigte Parallelverarbeitung auf Arrays, was die Performance für mathematische und datenintensive Algorithmen erheblich steigert.

snippet.cs
csharp
1
2
3
4
5
6
7
8
public void VectorAdd(int[] a, int[] b, int[] result) {
    int vSize = Vector<int>.Count;
    for (int i = 0; i <= a.Length - vSize; i += vSize) {
        var v1 = new Vector<int>(a, i);
        var v2 = new Vector<int>(b, i);
        (v1 + v2).CopyTo(result, i);
    }
}
PerformanceArrays & ListenMemory Management
C# · ExperteSnippet

Fortgeschrittene Interop mit Unsafe-Pointern

Das Schlüsselwort 'unsafe' erlaubt C# die Durchführung von Zeigerarithmetik, ähnlich wie in C++. Die Verwendung von 'fixed' fixiert das verwaltete Objekt im Speicher und verhindert, dass der Garbage Collector es verschiebt, während Sie Speicheradressen direkt manipulieren.

snippet.cs
csharp
1
2
3
4
5
6
7
8
9
public unsafe void FastCopy(byte[] src, byte[] dest) {
    fixed (byte* pSrc = src, pDest = dest) {
        byte* ps = pSrc;
        byte* pd = pDest;
        for (int i = 0; i < src.Length; i++) {
            *pd++ = *ps++;
        }
    }
}
Memory ManagementPerformanceSyntax
C# · ExperteSnippet

Dynamische Abfrage-Kompilierung via Expression Trees

Expression Trees stellen Code in einer baumartigen Datenstruktur dar, in der jeder Knoten ein Ausdruck ist. Experten nutzen dies für Metaprogrammierung, wie den Aufbau dynamischer LINQ-Provider oder das Kompilieren hochoptimierter Logik zur Laufzeit, die sonst langsame Reflection erfordern würde.

snippet.cs
csharp
1
2
3
4
5
6
ParameterExpression param = Expression.Parameter(typeof(int), "x");
BinaryExpression body = Expression.GreaterThan(param, Expression.Constant(10));
Expression<Func<int, bool>> lambda = Expression.Lambda<Func<int, bool>>(body, param);
 
Func<int, bool> compiled = lambda.Compile();
bool result = compiled(15);
SyntaxDesign PatternsPerformance
C# · ExperteSnippet

Speichereffizienz mit Span<T> und Stackalloc

Span<T> bietet eine typsichere und speichersichere Darstellung eines zusammenhängenden Bereichs von beliebigem Speicher. Durch die Kombination mit stackalloc können Sie Hochleistungs-Pufferoperationen vollständig auf dem Stack ausführen, den Garbage Collector umgehen und den Speicherdrück reduzieren.

snippet.cs
csharp
1
2
3
4
5
public void ProcessData(ReadOnlySpan<byte> data) {
    Span<byte> buffer = stackalloc byte[128];
    data.Slice(0, 64).CopyTo(buffer);
    // Perform operations without heap allocation
}
Memory ManagementPerformanceBest Practices
C# · ExperteSnippet

Implementierung eigener Awaiter

In C# kann jeder Typ 'erwartet' (awaited) werden, wenn er das 'GetAwaiter'-Muster implementiert. Diese Technik für Experten ermöglicht es, eigene asynchrone Primitive zu erstellen, ohne auf Task oder ValueTask angewiesen zu sein, was die Allokationskosten in spezialisierten Hochleistungsszenarien senkt.

snippet.cs
csharp
1
2
3
4
5
6
7
8
9
public struct MyTaskAwaiter : INotifyCompletion {
    public bool IsCompleted => false;
    public void OnCompleted(Action continuation) => Task.Run(continuation);
    public void GetResult() { }
}
 
public struct MyCustomTask {
    public MyTaskAwaiter GetAwaiter() => new MyTaskAwaiter();
}
Async & ConcurrencyPerformanceDesign Patterns
C# · ExperteSnippet

Unsafe Accessors für Zero-Overhead-Zugriff auf private Member

Eingeführt in C# 12 ermöglichen Unsafe Accessors den Zugriff auf private Member anderer Klassen ohne die Performance-Einbußen von Reflection. Durch die Verwendung des [UnsafeAccessor]-Attributs auf einer externen statischen Methode generiert der Compiler eine direkte IL-Referenz auf das private Feld oder die Methode, was den Zugriff so schnell wie bei öffentlichen Membern macht und Sichtbarkeitsbeschränkungen umgeht.

snippet.cs
csharp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System.Runtime.CompilerServices;
 
public class DataBuffer {
    private int _secretId = 42;
}
 
public class Accessor {
    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_secretId")]
    public static extern ref int GetSecretId(DataBuffer buffer);
}
 
// Usage
var buffer = new DataBuffer();
ref int id = ref Accessor.GetSecretId(buffer);
id = 100; // Directly modifies private field
PerformanceSyntax
C# · ExperteSnippet

Generische Mathematik über statische abstrakte Member

Statische abstrakte Member in Interfaces erlauben es in C#, Operatoren und statische Eigenschaften innerhalb eines Interfaces zu definieren. Dies ist die Grundlage für 'Generic Math' und ermöglicht es Entwicklern, generische Algorithmen zu schreiben, die über alle numerischen Typen hinweg funktionieren, indem Typparameter auf das INumber<T>-Interface beschränkt werden.

snippet.cs
csharp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System.Numerics;
 
public static class MathUtils {
    public static T SumAll<T>(IEnumerable<T> values) where T : INumber<T> {
        T result = T.Zero;
        foreach (var value in values) {
            result += value;
        }
        return result;
    }
}
 
// Usage
double dSum = MathUtils.SumAll(new[] { 1.5, 2.5 });
int iSum = MathUtils.SumAll(new[] { 10, 20 });
OOPDesign Patterns
C# · ExperteSnippet

Hochleistungs-Streaming mit System.Threading.Channels

System.Threading.Channels bietet eine hochoptimierte, asynchrone Producer-Consumer-Queue. Im Gegensatz zu ConcurrentQueue unterstützt es nativ async/await beim Warten auf Platz (Writer) oder Elemente (Reader). Bounded Channels ermöglichen Backpressure-Management, sodass ein schneller Producer den Arbeitsspeicher nicht überlastet, wenn der Consumer langsam ist.

snippet.cs
csharp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using System.Threading.Channels;
 
var channel = Channel.CreateBounded<int>(new BoundedChannelOptions(100) {
    FullMode = BoundedChannelFullMode.Wait
});
 
// Producer
_ = Task.Run(async () => {
    for (int i = 0; i < 1000; i++) 
        await channel.Writer.WriteAsync(i);
    channel.Writer.Complete();
});
 
// Consumer
await foreach (var item in channel.Reader.ReadAllAsync()) {
    Process(item);
}
Async & ConcurrencyPerformance