Fundamentos de Span/ReadOnlySpan (emulación de C# 6)
Emule Span/ReadOnlySpan con ArraySegment : cree vistas sobre arrays, divida con offset/length y procese datos sin copiarlos.
Fundamentos de Span/ReadOnlySpan (emulación de C# 6) es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.
Por qué son importantes los slices
Objetivo: Trabaje con slices sin asignaciones adicionales.
- Use ArraySegment<T> como una vista
- Divida mediante offset y count
- Escriba métodos que acepten ArraySegment<T>
- Mantenga las operaciones sencillas y seguras
Vista sin copias
ArraySegment<T> es una vista sin copias sobre parte de un array. Páselo a los métodos para evitar copias al crear slices.
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
}
}
Slices anidados
Puede crear un auxiliar Slice para obtener un subrango de un segmento existente. Sigue sin realizar copias.
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
}
}
Operar in situ mediante una vista
Opere mediante offset/count para evitar crear subcadenas; esto imita el recorte basado en 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();
}
}
Materializar bajo demanda
A veces necesita una copia real. Materialice el segmento en un array nuevo únicamente en el límite.
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));
}
}
Consejos y límites
Consejos:
- Diseñe las API para aceptar ArraySegment<T> cuando trabaje con arrays.
- Lleve un control de offset y count.
- Copie únicamente en los límites (E/S, interoperabilidad).
- Span, que es moderno, ofrece seguridad y vistas de la pila; aquí utilizamos segmentos para aprender el enfoque de los slices.
Emulación de slices en C# 6
Repaso
Repaso: Use ArraySegment<T> para ver subrangos, escriba API que acepten segmentos, opere mediante offset/count y copie únicamente cuando sea necesario.
Preguntas frecuentes
¿La lección «Fundamentos de Span/ReadOnlySpan (emulación de C# 6)» es gratis?
Sí — el texto completo de «Fundamentos de Span/ReadOnlySpan (emulación de C# 6)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.
¿Qué aprenderé en «Fundamentos de Span/ReadOnlySpan (emulación de C# 6)»?
Emule Span/ReadOnlySpan con ArraySegment : cree vistas sobre arrays, divida con offset/length y procese datos sin copiarlos. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 3.
¿Cuánto tiempo toma la lección «Fundamentos de Span/ReadOnlySpan (emulación de C# 6)»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Fundamentos de Span/ReadOnlySpan (emulación de C# 6)
- Emulación de Memory/ReadOnlyMemory: ventanas sin copias
- APIs de string como Span (emulación de C# 6)