0Pricing
C# Academy · Leçon

Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6)

Émulez Span/ReadOnlySpan avec ArraySegment : créez des vues sur des tableaux, découpez-les avec un décalage et une longueur et traitez les données sans les copier.

Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Pourquoi les segments sont importants

Objectif : travailler avec des segments sans allocations supplémentaires.

  • Utilisez ArraySegment<T> comme vue
  • Découpez selon un décalage et un nombre d’éléments
  • Écrivez des méthodes qui acceptent ArraySegment<T>
  • Gardez les opérations simples et sûres

Vue sans copie

ArraySegment<T> est une vue sans copie sur une partie d’un tableau. Transmettez-le aux méthodes pour éviter de copier les segments.

using System;

public class Program
{
  static int Sum(ArraySegment<int> seg)
  {
    int acc = 0;
    int end = seg.Offset + seg.Count;
    for (int i = seg.Offset; i < end; i++) acc += seg.Array[i];
    return acc;
  }

  public static void Main(string[] args)
  {
    int[] data = new int[] { 2, 4, 6, 8, 10 };
    ArraySegment<int> middle3 = new ArraySegment<int>(data, 1, 3); // 4,6,8
    Console.WriteLine("Sum = " + Sum(middle3)); // 18
  }
}

Segments imbriqués

Vous pouvez créer l’assistant Slice pour extraire une sous-plage d’un segment existant. L’opération reste sans copie.

using System;

public static class Seg
{
  public static ArraySegment<T> Slice<T>(ArraySegment<T> seg, int start, int count)
  {
    if (start < 0 || count < 0 || start + count > seg.Count) throw new ArgumentOutOfRangeException();
    return new ArraySegment<T>(seg.Array, seg.Offset + start, count);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    string[] words = new string[] { "alpha", "beta", "gamma", "delta", "epsilon" };
    ArraySegment<string> mid = new ArraySegment<string>(words, 1, 3);  // beta, gamma, delta
    ArraySegment<string> inner = Seg.Slice<string>(mid, 1, 1);         // gamma
    Console.WriteLine(inner.Array[inner.Offset]); // gamma
  }
}

Opérer en place via une vue

Opérez avec un décalage/nombre d’éléments pour éviter de créer des sous-chaînes ; cela reproduit le découpage fondé sur ReadOnlySpan.

using System;

public static class SegOps
{
  public static ArraySegment<char> Trim(ArraySegment<char> seg)
  {
    int start = seg.Offset;
    int end = seg.Offset + seg.Count - 1;

    while (start <= end && Char.IsWhiteSpace(seg.Array[start])) start++;
    while (end >= start && Char.IsWhiteSpace(seg.Array[end])) end--;

    int newCount = (end >= start) ? (end - start + 1) : 0;
    return new ArraySegment<char>(seg.Array, start, newCount);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    char[] buf = "   hello world   ".ToCharArray(); // single allocation for chars
    ArraySegment<char> all = new ArraySegment<char>(buf, 0, buf.Length);
    ArraySegment<char> trimmed = SegOps.Trim(all);

    // Print the trimmed part without new string:
    for (int i = 0; i < trimmed.Count; i++)
      Console.Write(trimmed.Array[trimmed.Offset + i]);
    Console.WriteLine();
  }
}

Matérialiser à la demande

Vous avez parfois besoin d’une copie réelle. Materialize le segment dans un nouveau tableau uniquement à la frontière.

using System;

public static class SegCopy
{
  public static T[] ToArray<T>(ArraySegment<T> seg)
  {
    T[] copy = new T[seg.Count];
    Array.Copy(seg.Array, seg.Offset, copy, 0, seg.Count);
    return copy;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    int[] data = new int[] { 1, 2, 3, 4, 5, 6 };
    ArraySegment<int> view = new ArraySegment<int>(data, 2, 3); // 3,4,5

    int[] materialized = SegCopy.ToArray<int>(view); // copy only when you must
    Console.WriteLine(string.Join(",", materialized));
  }
}

Conseils et limites

Conseils :

  • Concevez des API qui acceptent ArraySegment<T> lorsque vous travaillez sur des tableaux.
  • Suivez le décalage et le nombre d’éléments.
  • Ne copiez qu’aux frontières, notamment pour les entrées-sorties et l’interopérabilité.
  • Span moderne offre davantage de sécurité et des vues sur la pile ; ici, nous utilisons des segments pour apprendre le principe du découpage.

Simulation des segments en C# 6

Vérification rapide : quel type de C# 6 simule le mieux un segment sans copie, c’est-à-dire une vue sur une partie d’un tableau ?

Récapitulatif

Récapitulatif : utilisez ArraySegment<T> pour visualiser des sous-plages, écrivez des API qui acceptent des segments, opérez avec un décalage et un nombre d’éléments, et ne copiez que lorsque cela est nécessaire.

Questions Fréquemment Posées

La leçon « Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6) » est-elle gratuite ?

Oui — le texte complet de « Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6) » ?

Émulez Span/ReadOnlySpan avec ArraySegment : créez des vues sur des tableaux, découpez-les avec un décalage et une longueur et traitez les données sans les copier. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Principes fondamentaux de Span/ReadOnlySpan (émulation en C# 6)
  2. Émulation de Memory/ReadOnlyMemory : fenêtres sans copie
  3. API chaîne-comme-Span (émulation en C# 6)
← Retour à C# Academy