Bir metni Split ile parçalamak, Substring ile bir kısmını almak ya da bir diziyi ToArray ile kopyalamak masum görünür. Ancak her çağrı heap üzerinde yeni bir nesne üretir. Yoğun çalışan bir kod yolunda (parser, protokol işleme, log tarama) bu nesneler Garbage Collector'a (GC) ciddi yük bindirir.
Span<T> ve Memory<T>, mevcut bir belleğin üzerine kopyalamadan "pencere" açmanızı sağlar. Bu yazıda ikisinin ne olduğunu, hangi durumda hangisini seçeceğinizi, stackalloc ile birlikte nasıl kullanıldığını ve sık düşülen tuzakları örneklerle göreceksiniz.
Span<T> ve Memory<T> Nedir?
Span<T>, ardışık bir bellek bölgesine işaret eden bir görünümdür (view). Bu bölge bir dizi, bir stringin karakterleri, stack üzerinde ayrılmış bir alan ya da native bellek olabilir. Span veriyi kopyalamaz; sadece başlangıç noktasını ve uzunluğu tutar, bu yüzden dilimleme (slicing) işlemi neredeyse bedavadır.
ReadOnlySpan<T> aynı fikrin salt okunur halidir. String'ler değiştirilemez olduğu için "merhaba".AsSpan() bir ReadOnlySpan<char> döndürür. Bir metoda veri okumak için parametre alıyorsanız varsayılan tercih ReadOnlySpan<T> olmalıdır.
Memory<T> ve ReadOnlyMemory<T> ise aynı amaca hizmet eden, ama heap'te yaşayabilen karşılıklarıdır. Bunlara ihtiyaç duyulmasının nedeni bir sonraki bölümlerde netleşecek.
Allocation'ı Azaltmak: Split'ten Span'e Geçiş
Virgülle ayrılmış sayıları toplayan klasik bir yaklaşımla başlayalım:
static int ToplamHatali(string satir)
{
var toplam = 0;
foreach (var parca in satir.Split(','))
toplam += int.Parse(parca);
return toplam;
}
Burada Split bir string[] ve her parça için ayrı bir string üretir. Aynı işi span ile yaparsak hiçbir ara nesne oluşmaz:
static int Toplam(ReadOnlySpan<char> satir)
{
var toplam = 0;
while (!satir.IsEmpty)
{
var index = satir.IndexOf(',');
var parca = index >= 0 ? satir[..index] : satir;
toplam += int.Parse(parca);
satir = index >= 0 ? satir[(index + 1)..] : ReadOnlySpan<char>.Empty;
}
return toplam;
}
Dikkat edilmesi gereken noktalar:
satir[..index]yeni bir string değil, aynı belleğe bakan yeni bir span üretir.int.Parseve diğer sayısal tiplerinParse/TryParsemetotlarıReadOnlySpan<char>kabul eden aşırı yüklemelere sahiptir.- Metoda
stringverebilirsiniz; string,ReadOnlySpan<char>parametresine örtük olarak dönüşür.
Bu kod daha uzun ve biraz daha zor okunuyor. Bu bir ödünleşimdir ve neden her yere span yazmamanız gerektiğini son bölümde ele alıyoruz.
stackalloc ile Geçici Tamponlar
Küçük ve kısa ömürlü tamponlar için heap yerine stack kullanılabilir. Span<T> bu iş için doğal bir eşleşmedir; çünkü stackalloc sonucu güvenli (unsafe olmayan) bağlamda bir span olarak alınabilir.
static string Maskele(string kart)
{
if (kart.Length < 4) return kart;
Span<char> tampon = kart.Length <= 128
? stackalloc char[kart.Length]
: new char[kart.Length];
kart.AsSpan().CopyTo(tampon);
tampon[..^4].Fill('*');
return new string(tampon);
}
Eşik değeri bilinçli konur: stack sınırlıdır ve taşması yakalanamayan bir çökmeye yol açar. Bu yüzden boyutu kullanıcı girdisine bağlı bırakmak yerine küçük bir üst sınır tanımlayıp büyük durumlarda heap'e (ya da ArrayPool<T>.Shared ile havuza) düşmek doğru yaklaşımdır. stackalloc'u döngü içinde de çağırmayın; ayrılan alan metot bitene kadar geri verilmez.
Span<T> Neden Heap'e Çıkamaz? Memory<T> Devreye Giriyor
Span<T> bir ref struct'tır. Stack'e işaret edebildiği için derleyici onun stack dışına kaçmasına izin vermez. Pratikte şu kısıtlar doğar:
- Bir class'ın ya da normal struct'ın alanı olamaz.
- Boxing'e uğratılamaz,
objectya da interface'e atanamaz. - Lambda içinde yakalanamaz.
- Async metotlarda
awaitsınırını aşan şekilde kullanılamaz. C# 13'ten itibaren async metotlarda ref struct yerel değişkenler tanımlanabilir, ancak bunlaraawaitnoktaları arasında erişemezsiniz.
Asenkron I/O ya da bir nesnenin alanında tampon tutmak gerektiğinde Memory<T> kullanılır. Normal bir struct olduğu için heap'te yaşayabilir; işlem anında ise .Span özelliğiyle span'e dönüştürülür:
static async Task<int> OkuAsync(Stream akis, Memory<byte> tampon, CancellationToken ct)
{
var okunan = await akis.ReadAsync(tampon, ct);
Isle(tampon.Span[..okunan]);
return okunan;
}
static void Isle(ReadOnlySpan<byte> veri)
{
var satirSayisi = veri.Count((byte)'\n');
Console.WriteLine(satirSayisi);
}
Kalıp şudur: asenkron sınırda Memory<T> taşıyın, senkron işleme yapan metotlarda Span<T> kullanın. Asenkron akışı daha iyi kavramak isterseniz C#'ta asenkron programlama rehberine göz atabilirsiniz.
Hangisini Ne Zaman Seçmeli?
| Tip | Yazılabilir mi? | Heap'te tutulabilir mi? | Tipik kullanım |
|---|---|---|---|
Span<T> | Evet | Hayır | Senkron, yerinde veri işleme |
ReadOnlySpan<T> | Hayır | Hayır | Parse, arama, karşılaştırma parametreleri |
Memory<T> | Evet | Evet | Async I/O, alanda tampon saklama |
ReadOnlyMemory<T> | Hayır | Evet | Async okuma, salt okunur veri paylaşımı |
C# 14 (.NET 10) ile diziler, Span<T> ve ReadOnlySpan<T> arasındaki örtük dönüşümler genişledi. Bu sayede span kabul eden API'leri ve extension metotları diziler üzerinde çağırmak daha az sürtünmeyle yapılıyor. Yine de temel kural değişmedi: span'in yaşam süresi, işaret ettiği belleğin yaşam süresini aşamaz.
Tuzaklar ve Ölçüm
Span kullanırken en sık yapılan hatalar şunlardır:
- Dilimin bir kopya olduğunu sanmak:
Span<T>dilimine yazdığınızda orijinal dizi de değişir. Bu bir özelliktir, ama beklenmediğinde hataya yol açar. - Ömrü bilinmeyen belleğe referans tutmak: Havuzdan kiralanan bir diziyi geri verdikten sonra üzerindeki span ya da memory'yi kullanmak, başka birinin verisini okumaya ya da bozmaya yol açar.
- Ölçmeden optimize etmek: Seyrek çalışan kodda span'e geçmek yalnızca okunabilirliği düşürür. Önce profil çıkarın, gerekirse BenchmarkDotNet ile önce/sonra karşılaştırın.
- Büyük stackalloc: Dinamik ve sınırsız boyutlu stack ayırmak, yakalanamayan
StackOverflowriskini beraberinde getirir.
Span özellikle sık çağrılan, küçük parçalara bölünen veriyle çalışan yollarda anlam kazanır. Genel optimizasyon yaklaşımı için C# ile performans nasıl artırılır yazısı, önce nereye bakmanız gerektiğini anlatıyor.
Sık Sorulan Sorular
Span<T> ile Memory<T> arasındaki temel fark nedir?
Span<T> bir ref struct'tır ve yalnızca stack üzerinde yaşar; async metotlarda, alanlarda ve lambda'larda taşınamaz. Memory<T> heap'te saklanabilir ve .Span ile işlem anında span'e çevrilir.
Span<T> her zaman daha hızlı mıdır?
Hayır. Kazanç, ortadan kalkan kopyalama ve allocation'dan gelir; küçük ve seyrek çalışan kodda fark ihmal edilebilir. Karar vermeden önce gerçek iş yükünüzde ölçüm yapın.
String üzerinde Span<T> ile değişiklik yapabilir miyim?
String'ler immutable olduğu için AsSpan() yalnızca ReadOnlySpan<char> döndürür. Değişiklik gerekiyorsa içeriği bir Span<char> tampona kopyalayıp orada düzenleyin ve sonunda yeni bir string üretin.
Span<T> async metotta kullanılabilir mi?
await noktalarını aşacak şekilde kullanılamaz. Asenkron sınırda Memory<T> taşıyın; veriyi işleyeceğiniz senkron kısımda .Span ile span'e dönüşüp çalışın.
Sonuç
Span<T> ve Memory<T>, kopyalamadan dilimleme ve geçici tamponları stack'te tutma imkânı verir. Akılda kalacak üç nokta var:
- Okuma amaçlı parametrelerde
ReadOnlySpan<T>, asenkron sınırlarda ve alanlardaMemory<T>kullanın. stackallociçin küçük bir üst sınır koyun, aşıldığında heap ya daArrayPool'a düşün.- Önce ölçün; span'i yalnızca gerçekten sıcak olan kod yollarında tercih edin.