0Pricing
C# Academy · Lekcja

Podstawy Span/ReadOnlySpan (emulacja w C# 6)

Proszę emulować Span/ReadOnlySpan za pomocą ArraySegment : tworzyć widoki tablic, wycinać fragmenty z użyciem offset/length oraz przetwarzać dane bez kopiowania.

Podstawy Span/ReadOnlySpan (emulacja w C# 6) to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.

Dlaczego wycinki mają znaczenie

Cel: Pracować z wycinkami bez dodatkowych alokacji.

  • Używać ArraySegment<T> jako widoku
  • Tworzyć wycinki za pomocą offset i count
  • Pisać metody przyjmujące ArraySegment<T>
  • Utrzymywać operacje proste i bezpieczne

Widok bez kopiowania

ArraySegment<T> to widok bez kopiowania na części tablicy. Należy przekazywać go do metod, aby uniknąć tworzenia kopii wycinków.

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

Zagnieżdżone wycinki

Można utworzyć pomocnik Slice, który pobiera podzakres istniejącego segmentu. Nadal odbywa się to bez kopiowania.

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

Operowanie w miejscu za pomocą widoku

Należy operować za pomocą offset/count, aby uniknąć tworzenia podciągów; odpowiada to przycinaniu opartemu na 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();
  }
}

Materializacja na żądanie

Czasami potrzebna jest rzeczywista kopia. Należy zmaterializować segment w nowej tablicy dopiero na granicy.

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

Wskazówki i ograniczenia

Wskazówki:

  • Należy projektować API przyjmujące ArraySegment<T> podczas pracy z tablicami.
  • Należy śledzić wartości offset i count.
  • Należy kopiować wyłącznie na granicach (I/O, interop).
  • Nowoczesny Span zapewnia bezpieczeństwo i widoki na stosie; tutaj używamy segmentów, aby poznać sposób myślenia oparty na wycinkach.

Emulowanie wycinków w C# 6

Szybkie sprawdzenie: Który typ C# 6 najlepiej emuluje wycinek bez kopiowania (widok) na części tablicy?

Podsumowanie

Podsumowanie: Należy używać ArraySegment<T> do tworzenia widoków podzakresów, pisać API przyjmujące segmenty, operować za pomocą offset/count i kopiować tylko wtedy, gdy jest to konieczne.

Często zadawane pytania

Czy lekcja „Podstawy Span/ReadOnlySpan (emulacja w C# 6)” jest bezpłatna?

Tak — pełny tekst „Podstawy Span/ReadOnlySpan (emulacja w C# 6)” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Podstawy Span/ReadOnlySpan (emulacja w C# 6)”?

Proszę emulować Span/ReadOnlySpan za pomocą ArraySegment : tworzyć widoki tablic, wycinać fragmenty z użyciem offset/length oraz przetwarzać dane bez kopiowania. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Podstawy Span/ReadOnlySpan (emulacja w C# 6)”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podstawy Span/ReadOnlySpan (emulacja w C# 6)
  2. Emulacja Memory/ReadOnlyMemory: okna bez kopiowania
  3. API string jako Span (emulacja w C# 6)
← Powrót do C# Academy