0Pricing
C# Academy · Lezione

Fondamenti di Span/ReadOnlySpan (emulazione in C# 6)

Emulate Span/ReadOnlySpan con ArraySegment : create viste sugli array, eseguite suddivisioni con offset/lunghezza ed elaborate i dati senza copiarli.

Fondamenti di Span/ReadOnlySpan (emulazione in C# 6) è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.

Perché le slice sono importanti

Obiettivo: lavorare con le slice senza allocazioni aggiuntive.

  • Utilizzi ArraySegment<T> come vista
  • Crei slice tramite offset e count
  • Scriva metodi che accettano ArraySegment<T>
  • Mantenga le operazioni semplici e sicure

Vista senza copia

ArraySegment<T> è una vista senza copia su una parte di un array. Lo passi ai metodi per evitare copie durante lo slicing.

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
  }
}

Slice annidate

È possibile creare un helper Slice per ottenere un sottointervallo da un segmento esistente. Anche in questo caso non viene effettuata alcuna copia.

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
  }
}

Operare sul posto tramite una vista

Operi tramite offset/count per evitare di creare sottostringhe; è un approccio simile al trimming basato su 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();
  }
}

Materializzazione su richiesta

A volte è necessaria una copia reale. Materializzi il segmento in un nuovo array solo al confine.

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));
  }
}

Suggerimenti e limiti

Suggerimenti:

  • Progetti API che accettino ArraySegment<T> quando lavora con gli array.
  • Tenga traccia di offset e count.
  • Copi solo ai confini (I/O, interoperabilità).
  • Span, nelle versioni moderne, offre sicurezza e viste sullo stack; qui utilizziamo i segmenti per imparare il principio dello slicing.

Simulare le slice in C# 6

Verifica rapida: quale tipo di C# 6 simula meglio una slice (vista) senza copia su una parte di un array?

Riepilogo

Riepilogo: utilizzi ArraySegment<T> per visualizzare sottointervalli, scriva API che accettino segmenti, operi tramite offset/count e copi solo quando necessario.

Domande Frequenti

La lezione «Fondamenti di Span/ReadOnlySpan (emulazione in C# 6)» è gratuita?

Sì — il testo completo di «Fondamenti di Span/ReadOnlySpan (emulazione in C# 6)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.

Cosa imparerò in «Fondamenti di Span/ReadOnlySpan (emulazione in C# 6)»?

Emulate Span/ReadOnlySpan con ArraySegment : create viste sugli array, eseguite suddivisioni con offset/lunghezza ed elaborate i dati senza copiarli. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.

Quanto tempo richiede la lezione «Fondamenti di Span/ReadOnlySpan (emulazione in C# 6)»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Fondamenti di Span/ReadOnlySpan (emulazione in C# 6)
  2. Emulazione di Memory/ReadOnlyMemory: finestre senza copia
  3. API string-as-Span (emulazione in C# 6)
← Torna a C# Academy