berzahx 1
berzahx
aslan6474 1
aslan6474
Reklam vermek için turkmmo@gmail.com

C# Regex Rehberi: Örneklerle Match, Replace, Split ve Gruplar

  • Konuyu başlatan Konuyu başlatan Agora Metin2
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 0
  • Görüntüleme Görüntüleme 14
image247fbc2075bc98a7.jpg


Düzenli ifadeler (regex), metinleri belirli kurallara göre tanımlayan şablonlardır. Örneğin; "dört haneli bir sayı, ardından bir tire ve iki haneli bir sayı" veya "parantez içindeki tüm metinler" gibi tanımlamalar yapılabilir. C# programlama dilinde System.Text.RegularExpressions kütüphanesi altında yer alan Regex sınıfı; metinler içerisinde arama yapma, veri çıkarma, metin değiştirme ve parçalama işlemlerini yönetir.

IsMatch, Match ve Matches Metotları

Metin aramalarında genellikle üç temel metot kullanılır. IsMatch mantıksal bir sonuç (doğru/yanlış) döndürürken, Match bulunan ilk eşleşmeyi, Matches ise tüm eşleşmeleri liste halinde sunar:

C#:
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string note = "Order 1042 shipped on 2026-03-14, order 1043 on 2026-03-15.";

        Console.WriteLine(Regex.IsMatch(note, @"\d{4}-\d{2}-\d{2}"));   // contains a date?

        Match first = Regex.Match(note, @"\d{4}-\d{2}-\d{2}");
        Console.WriteLine($"{first.Value} at index {first.Index}");

        MatchCollection numbers = Regex.Matches(note, @"\b\d{4}\b");
        Console.WriteLine($"{numbers.Count} matches:");
        foreach (Match m in numbers)
            Console.WriteLine("  " + m.Value);

        Match none = Regex.Match(note, @"refund");
        Console.WriteLine($"Success: {none.Success}, Value: [{none.Value}]");
    }
}

Sonuç:

Kod:
True
2026-03-14 at index 22
4 matches:
  1042
  2026
  1043
  2026
Success: False, Value: []

Eşleşme bulunamadığında Match metodu null değer döndürmez; bunun yerine Success özelliği false olan ve boş bir Value içeren bir nesne döndürür. Bu nedenle, sonuçla işlem yapmadan önce Success kontrolü yapmak önemlidir.

Sadece rakam aratırken desenlerin beklediğinizden daha geniş sonuçlar verebileceğini unutmayın. Örneğin \b\d{4}\b deseni, "tam bir kelime formundaki dört rakamı" ifade eder; ancak - karakteri kelime sınırı sayıldığından tarihlerdeki yılları da yakalayabilir. Daha kesin sonuçlar için deseni daraltmalı veya gruplandırma yöntemlerini kullanmalısınız; (?<=Order |order )\d+ örneğinde olduğu gibi.

Desen Yazımında Verbatim String Kullanımı

Regex yazımında ters eğik çizgi karakteri (\d, \s, \b) çok sık kullanılır. C# string yapısında da ters eğik çizgi özel bir anlam taşıdığı için, normal string kullanımında "\d" ifadesi hata verebilir veya "\b" ifadesi "backspace" karakterine dönüşerek deseni bozabilir. Bu karmaşayı önlemek için desenleri, ters eğik çizgilerin olduğu gibi kabul edildiği @ sembolüyle başlayan verbatim string'ler olarak tanımlayın:

C#:
var a = new Regex("\\d+\\.\\d{2}");   // escaped twice: hard to read
var b = new Regex(@"\d+\.\d{2}");     // verbatim: what the regex engine sees

Bu yazım tarzında çift tırnak kullanmak isterseniz yan yana iki tane "" koymanız gerekir. C# 11 ile gelen """...""" (raw string literals) özelliği ise bu kaçış işlemlerini daha da kolaylaştırır.

Gruplar ile Metin Parçalarını Ayrıştırma

Parantez kullanımı, eşleşen metnin belirli bölümlerini gruplandırmanızı sağlar. Gruplar, açılan parantez sırasına göre 1'den başlayarak numaralandırılır; 0 numaralı grup ise eşleşen metnin tamamını temsil eder. Gruplara (?<isim>...) şeklinde ad vermek, hem kodun okunabilirliğini artırır hem de desendeki değişikliklerden etkilenmemesini sağlar:

C#:
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string line = "2026-03-14 09:41:07 ERROR [payments] Card declined for order 1042";

        var pattern = @"^(?<date>\d{4}-\d{2}-\d{2}) (?<time>[\d:]+) (?<level>\w+) \[(?<area>\w+)\] (?<message>.*)$";
        Match m = Regex.Match(line, pattern);

        if (m.Success)
        {
            Console.WriteLine(m.Groups["date"].Value);
            Console.WriteLine(m.Groups["level"].Value);
            Console.WriteLine(m.Groups["area"].Value);
            Console.WriteLine(m.Groups["message"].Value);
        }

        // Numbered groups: (\d+)x(\d+)
        Match size = Regex.Match("Poster 60x90 cm", @"(\d+)x(\d+)");
        int width = int.Parse(size.Groups[1].Value);
        int height = int.Parse(size.Groups[2].Value);
        Console.WriteLine($"{width} by {height}, area {width * height}");
    }
}

Sonuç:

Kod:
2026-03-14
ERROR
payments
Card declined for order 1042
60 by 90, area 5400

Regex sözdiziminde [ ve ] karakterleri özel bir anlam taşıdığı için, metin içerisindeki gerçek köşeli parantezleri ararken \[ ve \] şeklinde kullanmalısınız. Benzer durum . * + ? ( ) { } ^ $ | \ karakterleri için de geçerlidir. Eğer dışarıdan gelen bir metni desen içinde sabit bir metin olarak kullanacaksanız, Regex.Escape metodunu kullanarak tüm özel karakterlerin otomatik olarak etkisiz hale getirilmesini sağlayabilirsiniz.

Sadece gruplandırma yapmak isteyip veri yakalamak istemediğiniz durumlarda (?:...) yapısını kullanabilirsiniz. Bu, performans açısından daha verimlidir ve grup numaralarını karmaşıklaştırmaz.

Replace Metodu ve Lambda Kullanımı

Regex.Replace fonksiyonu, metin içindeki tüm eşleşmeleri yeni değerlerle değiştirir. Değişim metninde $1 birinci grubu, ${isim} adlandırılmış grubu, $0 ise tüm metni temsil eder. Daha karmaşık değişim mantıkları için, her eşleşmeyi girdi olarak alıp yeni metni döndüren bir lambda fonksiyonu da kullanabilirsiniz:

C#:
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        // Reorder dates from 2026-03-14 to 14/03/2026.
        string report = "Invoiced 2026-03-14, paid 2026-04-02.";
        Console.WriteLine(Regex.Replace(report, @"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})", "${d}/${m}/${y}"));

        // Collapse runs of whitespace into one space.
        Console.WriteLine(Regex.Replace("too    many \t spaces", @"\s+", " "));

        // Mask all but the last four digits of a card number.
        Console.WriteLine(Regex.Replace("Card 4111 1111 1111 1234", @"\d(?=(?:\s?\d){4})", "*"));

        // A lambda: raise every price by 10%.
        string menu = "Tea 2.50, Scone 3.20, Jam 1.00";
        string raised = Regex.Replace(menu, @"\d+\.\d{2}", m =>
            (decimal.Parse(m.Value, System.Globalization.CultureInfo.InvariantCulture) * 1.10m)
                .ToString("F2", System.Globalization.CultureInfo.InvariantCulture));
        Console.WriteLine(raised);
    }
}

Sonuç:

Kod:
Invoiced 14/03/2026, paid 02/04/2026.
too many spaces
Card **** **** **** 1234
Tea 2.75, Scone 3.52, Jam 1.10

Yukarıdaki kart maskeleme örneğinde (?=...) yani "lookahead" yapısı kullanılmıştır. Bu yapı, bir rakamın ardından dört rakam daha gelip gelmediğini kontrol eder ancak o rakamları işlem sürecine dahil etmez. Bu sayede son dört haneye dokunmadan maskeleme yapılabilir.

Eğer herhangi bir desen kullanmadan sabit bir metni değiştirecekseniz, string.Replace çok daha hızlı ve pratiktir. Regex'i sadece karmaşık desenlere ihtiyaç duyduğunuzda tercih edin.

Split ile Metni Parçalama

Regex.Split, metni bir desene göre parçalara ayırır. Bu yöntem, özellikle birden fazla farklı ayırıcının olduğu durumlarda çok kullanışlıdır:

C#:
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string tags = "csharp, dotnet;regex ,  tutorial|beginner";
        string[] parts = Regex.Split(tags.Trim(), @"\s*[,;|]\s*");
        Console.WriteLine(string.Join(" / ", parts));

        // Split camelCase or PascalCase into words.
        string[] words = Regex.Split("OrderShippedEventHandler", @"(?<!^)(?=[A-Z])");
        Console.WriteLine(string.Join(" ", words));
    }
}

Sonuç:

Kod:
csharp / dotnet / regex / tutorial / beginner
Order Shipped Event Handler

Eğer desende yakalama grubu (parantez) kullanırsanız, ayırıcı karakterler de sonuç dizisine dahil edilir. Bunu engellemek için yakalama yapmayan (?:...) gruplarını tercih edin.

RegexOptions Seçenekleri

Regex nesnesinin davranışını değiştirmek için çeşitli seçenekler sunulur. Birden fazla seçeneği | operatörüyle birleştirebilirsiniz:

C#:
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string log = "error: disk full\nINFO: started\nError: timeout";

        Console.WriteLine(Regex.Matches(log, "error").Count);
        Console.WriteLine(Regex.Matches(log, "error", RegexOptions.IgnoreCase).Count);

        // ^ and $ match at every line with Multiline.
        var firstWords = new System.Collections.Generic.List<string>();
        foreach (Match m in Regex.Matches(log, @"^\w+", RegexOptions.Multiline))
            firstWords.Add(m.Value);
        Console.WriteLine(string.Join(" ", firstWords));

        Console.WriteLine(Regex.IsMatch("TOTAL: 12", "(?i)total"));   // inline option
    }
}

Sonuç:

Kod:
1
2
error INFO Error
True

Sık kullanılan seçenekler şunlardır:

• IgnoreCase: Büyük/küçük harf ayrımını kaldırır.
• Multiline: ^ ve $ simgelerinin her satır başında/sonunda çalışmasını sağlar.
• Singleline: Nokta (.) karakterinin satır sonu karakterleri de dahil her şeyle eşleşmesini sağlar.
• IgnorePatternWhitespace: Desen içindeki boşlukları yok sayar ve # ile yorum yazılmasına izin verir; karmaşık desenleri okunaklı kılar.
• CultureInvariant: Karşılaştırmaları sistem dilinden bağımsız, genel kurallara göre yapar.
• Compiled: Deseni ara dile (IL) derleyerek sonraki kullanımlarda hız kazandırır.

Girdi Doğrulama ve E-posta Örneği

Kullanıcı girişlerini doğrularken deseni mutlaka ^ (başlangıç) ve $ (bitiş) işaretleriyle sınırlayın. Aksi takdirde, metnin sadece bir kısmının kurallara uyması geçerli sayılmasına neden olur:

C#:
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] codes = { "PT-1000", "pt-1000", "XPT-1000Y", "PT-10" };
        foreach (var c in codes)
        {
            bool loose = Regex.IsMatch(c, @"[A-Z]{2}-\d{4}");
            bool strict = Regex.IsMatch(c, @"^[A-Z]{2}-\d{4}$");
            Console.WriteLine($"{c,-10} loose={loose,-5} strict={strict}");
        }

        var email = new Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$");
        foreach (var e in new[] { "ana@example.com", "ana@example", "ana @example.com", "ana@@example.com" })
            Console.WriteLine($"{e,-17} {email.IsMatch(e)}");
    }
}

Sonuç:

Kod:
PT-1000    loose=True  strict=True
pt-1000    loose=False strict=False
XPT-1000Y  loose=True  strict=False
PT-10      loose=False strict=False
ana@example.com   True
ana@example       False
ana @example.com  False
ana@@example.com  False

E-posta doğrulaması için kullanılan genel desenler genellikle sadece temel yapıyı (nokta, @ işareti vb.) kontrol eder. Tam kapsamlı bir RFC 5322 kontrolü yapmak çok karmaşıktır ve geçerli bazı adresleri reddetme riski taşır. En mantıklı yaklaşım, temel biçimi kontrol edip kullanıcıya onay e-postası göndermektir. Alternatif olarak System.Net.Mail.MailAddress sınıfını da kullanabilirsiniz.

Performans İpuçları

Statik metotlar (Regex.IsMatch gibi), desenleri kısa süreliğine önbelleğe aldığı için seyrek kullanımlarda verimlidir. Ancak yoğun bir döngü içerisinde aynı deseni kullanacaksanız, bir Regex nesnesi oluşturup bunu static readonly olarak saklamak daha performanslıdır. Çok sık çalışan işlemlerde RegexOptions.Compiled kullanarak eşleştirme hızını artırabilirsiniz.

Zaman Aşımları ve Güvenlik

Bazı hatalı desenler, karmaşık metinlerde işlemciyi aşırı yoran "felaket düzeyinde geri izleme" (catastrophic backtracking) sorununa yol açabilir. Bu durum "ReDoS" saldırılarına zemin hazırlar. Güvenliği sağlamak için özellikle dışarıdan gelen verilerle çalışan regex işlemlerine mutlaka bir zaman aşımı süresi tanımlayın:

C#:
var pattern = new Regex(@"^(\w+\s?)*$", RegexOptions.None, TimeSpan.FromMilliseconds(100));
try
{
    bool ok = pattern.IsMatch(userInput);
}
catch (RegexMatchTimeoutException)
{
    // treat as invalid input
}

Ayrıca .NET 7 ile gelen RegexOptions.NonBacktracking seçeneği, belirli kısıtlamalar dahilinde işlem süresini garanti altına alan yeni bir motor sunar.

GeneratedRegex (.NET 7 ve Üzeri)

C# 11 ve .NET 7 ile birlikte gelen "Source Generator" özelliği, regex desenlerini derleme aşamasında doğrudan C# koduna dönüştürür. Bu sayede çalışma zamanında ek bir maliyet oluşmaz, kod daha hızlı çalışır ve Native AOT gibi modern teknolojilerle uyumlu hale gelir:

C#:
public static partial class Patterns
{
    [GeneratedRegex(@"^[A-Z]{2}-\d{4}$", RegexOptions.IgnoreCase)]
    public static partial Regex ProductCode();
}

bool ok = Patterns.ProductCode().IsMatch("pt-1000");   // True

Modern .NET projelerinde, sabit olan tüm desenler için bu yöntemin kullanılması önerilir.

Sık Yapılan Hatalar

• Doğrulama yaparken ^ ve $ kullanmamak; bu, hatalı metinlerin onaylanmasına sebep olur.
• Desen yazarken normal string kullanmak; \b gibi ifadelerin bozulmaması için @"..." tercih edilmelidir.
• Özel karakterleri kaçırmayı unutmak; örneğin . her karakteri temsil eder, sadece nokta aramak için \. yazılmalıdır.
• "Açgözlü" (greedy) operatörlerin yanlış kullanımı; <.*> yerine daha sınırlı olan .*? veya [^>]* kullanılmalıdır.
• Belirsiz girdilerde zaman aşımı belirlememek; bu, uygulamanın kilitlenmesine neden olabilir.
• HTML veya JSON gibi yapılandırılmış verileri regex ile işlemeye çalışmak; bu tür veriler için özel kütüphaneler (parser) kullanılmalıdır.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst