4. Yaygın olarak kullanılan .NET sınıfları

Burada, yeni başlayanlar için bile ilgi çekici olan .NET platformundaki bazı sınıfları tanıtıyoruz. Öncelikle, mevcut yüzlerce sınıf hakkında nasıl bilgi edinebileceğinizi göstereceğiz.

4.1. SDK.NET ile yardım arama

4.1.1. wincv

Yalnızca SDK kurulmuşsa ve Visual Studio.NET kurulmamışsa, normalde SDK dizin yapısında bulunan (örneğin C:\Program Files\Microsoft Visual Studio) wincv.exe programını kullanabilirsiniz.NET 2003\SDK\v1.1. Bu yardımcı programı çalıştırdığınızda, aşağıdaki arayüz karşınıza çıkar:

(1)'e istenen sınıfın adını yazıyoruz. Bu, (2)'de çeşitli olası temaları gösterir. Uygun olanı seçtiğimizde sonucu (3)'te görürüz; burada HashTable sınıfı. Bu yöntem, aradığımız sınıfın adını biliyorsak uygundur. .NET veya HTML StartHere.htm dosyalarını da kullanabilirsiniz; bu dosyalar da doğrudan SSK.Net kurulum klasöründe bulunur, örneğin C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.

.NET Framework SDK Belgeleri bağlantısı, .NET sınıflarına genel bir bakış elde etmek için izlenmesi gereken bağlantıdır:

Burada [Bibliothèque de classes] bağlantısını takip edeceğiz. Burada .NET sınıflarının tam listesi bulunur:

Örneğin, System.Collections bağlantısını takip edelim. Bu ad alanı, HashTable sınıfı da dahil olmak üzere koleksiyonları uygulayan çeşitli sınıfları bir araya getirir:

Aşağıdaki HashTable bağlantısını takip edelim:

Aşağıdaki sayfaya ulaşırız:

Aşağıda elin konumuna dikkat edin. El, istenen dili (burada Visual Basic) belirlemeye yarayan bir bağlantıyı işaret ediyor.

Burada sınıfın prototipi ve kullanım örnekleri yer almaktadır. Aşağıdaki [Hashtable, membres] bağlantısını takip edelim:

Sınıfın tam açıklaması karşımıza çıkar:

Bu yöntem, SDK ve sınıflarını keşfetmek için en iyi yoldur. WinCV aracı, sınıf hakkında zaten biraz bilgi sahibi olduğumuzda ve bazı üyelerini unuttuğumuzda kullanışlıdır. WinCV, bu durumda sınıfı ve üyelerini hızlı bir şekilde bulmamızı sağlar.

4.2. VS.NET ile sınıflar hakkında yardım arama

Burada, Visual Studio.NET ile yardım bulmak için bazı ipuçları veriyoruz

4.2.1. Yardım Seçeneği

Menüden [?] seçeneğini seçelim.

Aşağıdaki pencere açılır:

Açılır listeden bir yardım filtresi seçebiliriz. Burada [Visual Basic] filtresini seçeceğiz.

İki yardım bölümü faydalıdır:

VB.NET diline ilişkin yardım (sözdizimi)
VB.NET dili tarafından kullanılabilen classes.NET öğeleriyle ilgili yardım

VB.NET diline ilişkin yardım, [Visual Studio.NET/Visual Basic et Visual C#/Reference/Visual Basic] aracılığıyla erişilebilir:

Aşağıdaki yardım sayfası görüntülenir:

Buradan itibaren, çeşitli alt başlıklar sayesinde VB.NET ile ilgili farklı konularda yardım alabiliriz. VB.NET'teki öğreticilere özellikle dikkat etmeliyiz:

.NET platformundaki çeşitli sınıflara erişmek için [Visual Studio.NET/.NET Framework] yardımını seçeceğiz.

Özellikle [Référence/Bibliothèque de classes] başlığına dikkat edilmelidir:

[ArrayList] sınıfıyla ilgilendiğimizi varsayalım. Bu sınıf, [System.Collections] ad alanında yer almaktadır. Bunu bilmek gerekir; aksi takdirde aşağıda açıklanan arama yöntemini tercih etmek daha uygun olacaktır. Şu yardım metni görüntülenir:

[ArrayList, classe] bağlantısı, sınıfın genel bir görünümünü sunar:

Bu tür sayfalar tüm sınıflar için mevcuttur. Sayfa, örneklerle birlikte sınıfın bir özetini sunar. Sınıfın elemanlarının açıklaması için [ArrayList, membres] bağlantısını takip edelim:

4.2.2. Yardım/Dizin

[Aide/index] seçeneği, önceki yardımdan daha hedefli bir yardım araması yapmanızı sağlar. Aradığınız anahtar kelimeyi yazmanız yeterlidir:

Bu yöntemin bir önceki yönteme göre avantajı, yardım sisteminde aradığınız bilginin nerede olduğunu bilmenize gerek olmamasıdır. Hedefli bir arama yaparken muhtemelen bu yöntem tercih edilmelidir; diğer yöntem ise yardımın sunduğu tüm içeriği keşfetmek için daha uygundur.

4.3. String sınıfı

String sınıfı birçok özellik ve yöntem içerir. Bunlardan bazıları şunlardır:

`Public ReadOnly Property Length As Integer`	dizenin karakter sayısı
`Public Default ReadOnly Property Chars(ByVal index As Integer) As Char`	varsayılan olarak indeksli özellik. [String].Chars(i), dizgenin i numaralı karakteridir
`Public Function EndsWith(ByVal value As String) As Boolean`	dize value ile bitiyorsa true değerini döndürür
`Public Function StartsWith(ByVal value As String) As Boolean`	dize "value" ile başlıyorsa true değerini döndürür
`Overloads Public Function Equals(ByVal value As String) As Boolean`	dize value değerine eşitse true değerini döndürür
`Overloads Public Function IndexOf(ByVal value As String) As Integer`	value dizesinin ilk konumunu döndürür - arama 0 numaralı karakterden başlar
`Overloads Public Function IndexOf(ByVal value As String,ByVal startIndex As Integer) As Integer`	value dizgesindeki ilk konumu döndürür - arama, startIndex karakterinden itibaren başlar
`Overloads Public Shared Function Join(ByVal separator As String,ByVal value() As String) As String`	sınıf yöntemi - value dizisindeki değerlerin separator ayırıcısıyla birleştirilmesiyle elde edilen dizeyi döndürür
`Overloads Public Function Replace(ByVal oldChar As Char,ByVal newChar As Char) As String`	oldChar karakterinin newChar karakteriyle değiştirildiği, geçerli dizenin bir kopyasını döndürür
`Overloads Public Function Split(ByVal ParamArray separator() As Char) As String()`	dize, separator dizisinde bulunan karakterlerle ayrılmış bir dizi alan olarak görülür. Sonuç, bu alanların dizisidir
`Overloads Public Function Substring( ByVal startIndex As Integer,ByVal length As Integer) As String`	startIndex konumundan başlayan ve length karakter uzunluğuna sahip mevcut dizgenin alt dizgesidir
`Overloads Public Function ToLower() As String`	geçerli dizgiyi küçük harflerle yazdırır
`Overloads Public Function ToUpper() As String`	geçerli dizeyi büyük harfe dönüştürür
`Overloads Public Function Trim() As String`	geçerli dizeyi baştaki ve sondaki boşluklardan arındırır

Bir C dizesi, bir karakter dizisi olarak düşünülebilir. Dolayısıyla

C.Chars(i), C dizisinin i'nci karakteridir
C.Length, C dizisinin karakter sayısıdır

Aşağıdaki örneği ele alalım:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System

Module test
    Sub Main()
        Dim uneChaine As String = "l'oiseau vole au-dessus des nuages"
        affiche("uneChaine=" + uneChaine)
        affiche("uneChaine.Length=" & uneChaine.Length)
        affiche("chaine[10]=" + uneChaine.Chars(10))
        affiche("uneChaine.IndexOf(""vole"")=" & uneChaine.IndexOf("vole"))
        affiche("uneChaine.IndexOf(""x"")=" & uneChaine.IndexOf("x"))
        affiche("uneChaine.LastIndexOf('a')=" & uneChaine.LastIndexOf("a"c))
        affiche("uneChaine.LastIndexOf('x')=" & uneChaine.LastIndexOf("x"c))
        affiche("uneChaine.Substring(4,7)=" + uneChaine.Substring(4, 7))
        affiche("uneChaine.ToUpper()=" + uneChaine.ToUpper())
        affiche("uneChaine.ToLower()=" + uneChaine.ToLower())
        affiche("uneChaine.Replace('a','A')=" + uneChaine.Replace("a"c, "A"c))
        Dim champs As String() = uneChaine.Split(Nothing)
        Dim i As Integer
        For i = 0 To champs.Length - 1
            affiche("champs[" & i & "]=[" & champs(i) & "]")
        Next i
        affiche("Join("":"",champs)=" + System.String.Join(":", champs))
        affiche("(""  abc  "").Trim()=[" + "  abc  ".Trim() + "]")
    End Sub

    ' görüntüler
    Sub affiche(ByVal msg As [String])
        ' mesajı göster
        Console.Out.WriteLine(msg)
    End Sub
End Module

Çalıştırıldığında şu sonuçlar elde edilir:

dos>vbc string1.vb

dos>string1
uneChaine=l'oiseau vole au-dessus des nuages
uneChaine.Length=34
chaine[10]=o
uneChaine.IndexOf("vole")=9
uneChaine.IndexOf("x")=-1
uneChaine.LastIndexOf('a')=30
uneChaine.LastIndexOf('x')=-1
uneChaine.Substring(4,7)=seau vo
uneChaine.ToUpper()=L'OISEAU VOLE AU-DESSUS DES NUAGES
uneChaine.ToLower()=l'oiseau vole au-dessus des nuages
uneChaine.Replace('a','A')=l'oiseAu vole Au-dessus des nuAges
champs[0]=[l'oiseau]
champs[1]=[vole]
champs[2]=[au-dessus]
champs[3]=[des]
champs[4]=[nuages]
Join(":",champs)=l'oiseau:vole:au-dessus:des:nuages
("  abc  ").Trim()=[abc]

Yeni bir örnek ele alalım:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System

Module string2
    Sub Main()
        ' analiz edilecek satır
        Dim ligne As String = "un:deux::trois:"
        ' alan ayırıcıları
        Dim séparateurs() As Char = {":"c}
        ' bölme
        Dim champs As String() = ligne.Split(séparateurs)
        Dim i As Integer
        For i = 0 To champs.Length - 1
            Console.Out.WriteLine(("Champs[" & i & "]=" & champs(i)))
        Next i
        ' birleştirme
        Console.Out.WriteLine(("join=[" + System.String.Join(":", champs) + "]"))
    End Sub
End Module

ve çalıştırma sonuçları:

Champs[0]=un
Champs[1]=deux
Champs[2]=
Champs[3]=trois
Champs[4]=
join=[un:deux::trois:]

String sınıfının Split yöntemi, bir karakter dizisindeki alanları bir diziye yerleştirmeye olanak tanır. Burada kullanılan yöntemin tanımı şöyledir:

Overloads Public Function Split(ByVal ParamArray separator() As Char) As String()

`separator`	karakter dizisi. Bu karakterler, karakter dizisindeki alanları ayırmak için kullanılan karakterleri temsil eder. Dolayısıyla, karakter dizisi [champ1, champ2, champ3] ise separator=new char() {","c} kullanılabilir. Ayırıcı bir dizi boşluktan oluşuyorsa separator=nothing kullanılır.
`résultat`	Her bir elemanı dizenin bir alanı olan dize dizisi.

Join yöntemi, String sınıfının statik bir yöntemidir:

Overloads Public Shared Function Join(ByVal separator As String,ByVal value() As String) As String

`value`	dize dizisi
`separator`	alan ayırıcısı olarak kullanılacak bir karakter dizesi
`résultat`	value dizisinin elemanlarının, separator dizisiyle ayrılmış olarak birleştirilmesiyle oluşturulan bir karakter dizisi.

4.4. Array sınıfı

Array sınıfı bir diziyi hayata geçirir. Örneğimizde aşağıdaki özellikleri ve yöntemleri kullanacağız:

`Public ReadOnly Property Length As Integer`	özellik - dizideki eleman sayısı
`Overloads Public Shared Function BinarySearch (ByVal array As Array,ByVal index As Integer, ByVal length As Integer,ByVal value As Object) As Integer`	sınıf yöntemi - value'in sıralı array dizisindeki konumunu döndürür - index konumundan başlayarak ve length elemanla arama yapar
`Overloads Public Shared Sub Copy(ByVal sourceArray As Array,ByVal destinationArray As Array, ByVal length As Integer)`	sınıf yöntemi - length öğelerini sourceArray'ten destinationArray'e kopyalar - bu işlem sırasında destinationArray oluşturulur
`Overloads Public Shared Sub Sort(ByVal array As Array)`	sınıf yöntemi - array dizisini sıralar - bu dizi, varsayılan sıralama işlevine sahip bir veri türü (dizgiler, sayılar) içermelidir.

Aşağıdaki program, Array sınıfının kullanımını göstermektedir:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System

Module test
    Sub Main()
        ' klavyeyle girilen bir dizinin elemanlarını okuma
        Dim terminé As [Boolean] = False
        Dim i As Integer = 0
        Dim éléments1 As Double() = Nothing
        Dim éléments2 As Double() = Nothing
        Dim élément As Double = 0
        Dim réponse As String = Nothing
        Dim erreur As [Boolean] = False

        While Not terminé
            ' soru
            Console.Out.Write(("Elément (réel) " & i & " du tableau (rien pour terminer) : "))
            ' cevabın okunması
            réponse = Console.ReadLine().Trim()
            ' dize boşsa girişin sonlandırılması
            If réponse.Equals("") Then
                Exit While
            End If
            ' girişin doğrulanması
            Try
                élément = [Double].Parse(réponse)
                erreur = False
            Catch
                Console.Error.WriteLine("Saisie incorrecte, recommencez")
                erreur = True
            End Try
            ' hata yoksa
            If Not erreur Then
                ' yeni öğeyi barındıracak yeni tablo
                éléments2 = New Double(i) {}
                ' eski diziyi yeni diziye kopyala
                If i <> 0 Then
                    Array.Copy(éléments1, éléments2, i)
                End If
                ' yeni tablo eski tablo haline gelir
                éléments1 = éléments2
                ' yeni tabloya artık gerek yok
                éléments2 = Nothing
                ' yeni öğenin eklenmesi
                éléments1(i) = élément
                ' tabloda bir öğe daha
                i += 1
            End If
        End While
        ' tablo sıralanmamış olarak görüntüleniyor
        System.Console.Out.WriteLine("Tableau non trié")
        For i = 0 To éléments1.Length - 1
            Console.Out.WriteLine(("éléments[" & i & "]=" & éléments1(i)))
        Next i
        ' tablonun sıralanması
        System.Array.Sort(éléments1)
        ' sıralanmış tablonun görüntülenmesi
        System.Console.Out.WriteLine("Tableau trié")
        For i = 0 To éléments1.Length - 1
            Console.Out.WriteLine(("éléments[" & i & "]=" & éléments1(i)))
        Next i
        ' Arama
        While Not terminé
            ' soru
            Console.Out.Write("Elément cherché (rien pour arrêter) : ")
            ' cevabın okunması ve doğrulanması
            réponse = Console.ReadLine().Trim()
            ' bitti mi?
            If réponse.Equals("") Then
                Exit While
            End If
            ' doğrulama
            Try
                élément = [Double].Parse(réponse)
                erreur = False
            Catch
                Console.Error.WriteLine("Saisie incorrecte, recommencez")
                erreur = True
            End Try
            ' hata yoksa
            If Not erreur Then
                ' sıralı dizide öğeyi arıyoruz
                i = System.Array.BinarySearch(éléments1, 0, éléments1.Length, élément)
                ' Yanıtın görüntülenmesi
                If i >= 0 Then
                    Console.Out.WriteLine(("Trouvé en position " & i))
                Else
                    Console.Out.WriteLine("Pas dans le tableau")
                End If
            End If
        End While
    End Sub
End Module

Ekran çıktısı şu şekildedir:

Elément (réel) 0 du tableau (rien pour terminer) : 10,4
Elément (réel) 1 du tableau (rien pour terminer) : 5,2
Elément (réel) 2 du tableau (rien pour terminer) : 8,7
Elément (réel) 3 du tableau (rien pour terminer) : 3,6
Elément (réel) 4 du tableau (rien pour terminer) :
Tableau non trié
éléments[0]=10,4
éléments[1]=5,2
éléments[2]=8,7
éléments[3]=3,6
Tableau trié
éléments[0]=3,6
éléments[1]=5,2
éléments[2]=8,7
éléments[3]=10,4
Elément cherché (rien pour arrêter) : 8,7
Trouvé en position 2
Elément cherché (rien pour arrêter) : 11
Pas dans le tableau
Elément cherché (rien pour arrêter) : a
Saisie incorrecte, recommencez
Elément cherché (rien pour arrêter) :

Programın ilk bölümü, klavyeden girilen sayısal verilerden bir dizi oluşturur. Kullanıcının gireceği eleman sayısının önceden bilinmediği için dizinin boyutu önceden belirlenemez. Bu nedenle, éléments1 ve éléments2 adlı iki dizi ile çalışılır.


                ' yeni öğeyi barındıracak yeni dizi
                éléments2 = New Double(i) {}
                ' eski tabloyu yeni tabloya kopyalama
                If i <> 0 Then
                    Array.Copy(éléments1, éléments2, i)
                End If
                ' Yeni tablo eski tablo haline geliyor
                éléments1 = éléments2
                ' yeni tabloya artık gerek yok
                éléments2 = Nothing
                ' yeni öğenin eklenmesi
                éléments1(i) = élément
                ' tabloya bir öğe daha eklenir
                i += 1

éléments1 dizisi, o anda girilmiş olan değerleri içerir. Kullanıcı yeni bir değer eklediğinde, éléments1 dizisinden bir eleman daha fazla eleman içeren éléments2 dizisi oluşturulur, éléments1'in içeriği éléments2'e (Array.Copy) kopyalanır, éléments1'in éléments2'e "işaret etmesini" sağlıyoruz ve son olarak yeni elemanı éléments1'e ekliyoruz. Bu karmaşık bir süreçtir; ancak sabit boyutlu bir dizi (Array) yerine değişken boyutlu bir dizi (ArrayList) kullanılırsa basitleştirilebilir.

Dizi, Array.Sort yöntemi ile sıralanır. Bu yöntem, sıralama kurallarını belirleyen farklı parametrelerle çağrılabilir. Parametre verilmezse, varsayılan olarak artan sırada sıralama yapılır. Son olarak, Array.BinarySearch yöntemi, sıralanmış bir dizide bir öğeyi aramaya olanak tanır.

4.5. ArrayList sınıfı

ArrayList sınıfı, programın çalışması sırasında değişken boyutlu diziler oluşturmaya olanak tanır; bu, önceki Array sınıfında mümkün değildir. İşte bu sınıfın yaygın olarak kullanılan bazı özellikleri ve yöntemleri:

`Public Sub New()`	boş bir liste oluşturur
`Public Overridable ReadOnly Property Count As Integer Implements ICollection.Count`	koleksiyondaki öğe sayısı
`Public Overridable Function Add(ByVal value As Object) As Integer Implements IList.Add`	value nesnesini koleksiyonun sonuna ekler
`Public Overridable Sub Clear() Implements IList.Clear`	listeyi siler
`Overloads Public Overridable Function IndexOf(ByVal value As Object) As Integer Implements IList.IndexOf`	listedeki value nesnesinin dizini veya mevcut değilse -1
`Overloads Public Overridable Function IndexOf(ByVal value As Object, ByVal startIndex As Integer) As Integer`	Aynı, ancak startIndex numaralı öğeden başlayarak arama yapılır
`Overloads Public Overridable Function LastIndexOf(ByVal value As Object) As Integer`	aynı, ancak listedeki value değerinin son geçtiği yerin indeksini verir
`Overloads Public Overridable Function LastIndexOf(ByVal value As Object, ByVal startIndex As Integer) As Integer`	Aynı, ancak startIndex numaralı öğeden başlayarak arama yapar
`Public Overridable Sub Remove( ByVal obj As Object) Implements IList.Remove`	Listede varsa obj nesnesini kaldır
`Public Overridable Sub RemoveAt(ByVal index As Integer) Implements IList.RemoveAt`	index öğesini listeden kaldır
`Overloads Public Overridable Function BinarySearch(ByVal value As Object) As Integer`	value nesnesinin listedeki konumunu döndürür; listede yoksa -1 değerini döndürür. Liste sıralanmış olmalıdır
`Overloads Public Overridable Sub Sort()`	Listeyi sıralar. Liste, önceden tanımlanmış bir sıralama ilişkisine sahip nesneler (dizgiler, sayılar) içermelidir
`Overloads Public Overridable Sub Sort(ByVal comparer As IComparer)`	listeyi, karşılaştırma işlevi tarafından belirlenen sıralama ilişkisine göre sıralar

Array türündeki nesnelerle işlenen örneği tekrar ele alalım ve bu kez ArrayList türündeki nesnelerle işleyelim:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections

Module test
    Sub Main()
        ' klavyeyle girilen tablo öğelerini okuma
        Dim terminé As [Boolean] = False
        Dim i As Integer = 0
        Dim éléments As New ArrayList
        Dim élément As Double = 0
        Dim réponse As String = Nothing
        Dim erreur As [Boolean] = False

        While Not terminé
            ' soru
            Console.Out.Write(("Elément (réel) " & i & " du tableau (rien pour terminer) : "))
            ' cevabın okunması
            réponse = Console.ReadLine().Trim()
            ' dize boşsa girişin sonlandırılması
            If réponse.Equals("") Then
                Exit While
            End If
            ' girişin doğrulanması
            Try
                élément = Double.Parse(réponse)
                erreur = False
            Catch
                Console.Error.WriteLine("Saisie incorrecte, recommencez")
                erreur = True
            End Try
            ' hata yoksa
            If Not erreur Then
                ' diziye bir öğe daha eklenir
                éléments.Add(élément)
            End If
        End While
        ' sıralanmamış tablonun görüntülenmesi
        System.Console.Out.WriteLine("Tableau non trié")
        For i = 0 To éléments.Count - 1
            Console.Out.WriteLine(("éléments[" & i & "]=" & éléments(i).ToString))
        Next i        ' tri du tableau
        éléments.Sort()
        ' sıralanmış tablo görüntüleme
        System.Console.Out.WriteLine("Tableau trié")
        For i = 0 To éléments.Count - 1
            Console.Out.WriteLine(("éléments[" & i & "]=" & éléments(i).ToString))
        Next i
        ' Arama
        While Not terminé
            ' soru
            Console.Out.Write("Elément cherché (rien pour arrêter) : ")
            ' cevabı okuma-doğrulama
            réponse = Console.ReadLine().Trim()
            ' bitti mi?
            If réponse.Equals("") Then
                Exit While
            End If
            ' doğrulama
            Try
                élément = [Double].Parse(réponse)
                erreur = False
            Catch
                Console.Error.WriteLine("Saisie incorrecte, recommencez")
                erreur = True
            End Try
            ' hata yoksa
            If Not erreur Then
                ' sıralı dizide öğeyi arıyoruz
                i = éléments.BinarySearch(élément)
                ' Yanıtın görüntülenmesi
                If i >= 0 Then
                    Console.Out.WriteLine(("Trouvé en position " & i))
                Else
                    Console.Out.WriteLine("Pas dans le tableau")
                End If
            End If
        End While
    End Sub
End Module

Çalıştırma sonuçları şöyledir:

Elément (réel) 0 du tableau (rien pour terminer) : 10,4
Elément (réel) 0 du tableau (rien pour terminer) : 5,2
Elément (réel) 0 du tableau (rien pour terminer) : a
Saisie incorrecte, recommencez
Elément (réel) 0 du tableau (rien pour terminer) : 3,7
Elément (réel) 0 du tableau (rien pour terminer) : 15
Elément (réel) 0 du tableau (rien pour terminer) :
Tableau non trié
éléments[0]=10,4
éléments[1]=5,2
éléments[2]=3,7
éléments[3]=15
Tableau trié
éléments[0]=3,7
éléments[1]=5,2
éléments[2]=10,4
éléments[3]=15
Elément cherché (rien pour arrêter) : a
Saisie incorrecte, recommencez
Elément cherché (rien pour arrêter) : 15
Trouvé en position 3
Elément cherché (rien pour arrêter) : 1
Pas dans le tableau
Elément cherché (rien pour arrêter) :

4.6. Hashtable sınıfı

Hashtable sınıfı, bir sözlükün uygulanmasına olanak tanır. Bir sözlük, iki sütunlu bir tablo olarak düşünülebilir:

Anahtarlar benzersizdir, c.a.d. Yani iki anahtarın aynı olması mümkün değildir. Hashtable sınıfının başlıca yöntemleri ve özellikleri şunlardır:

`Public Sub New()`	boş bir sözlük oluşturur
`Public Overridable Sub Add(ByVal key As Object,ByVal value As Object) Implements IDictionary.Add`	sözlüğe bir (anahtar, değer) satırı ekler; burada anahtar ve değer, nesne referanslarıdır.
`Public Overridable Sub Remove (ByVal key As Object) Implements IDictionary.Remove`	sözlükten key=key satırını siler
`Public Overridable Sub Clear() Implements IDictionary.Clear`	sözlüğü boşaltır
`Public Overridable Function ContainsKey (ByVal key As Object) As Boolean`	key anahtarı sözlüğe aitse true değerini döndürür.
`Public Overridable Function ContainsValue(ByVal value As Object) As Boolean`	value değeri sözlüğe aitse true değerini döndürür.
`Public Overridable ReadOnly Property Count As Integer Implements ICollection.Count`	özellik: sözlükteki öğe sayısı (anahtar, değer)
`Public Overridable ReadOnly Property Keys As ICollection Implements IDictionary.Keys`	özellik: sözlüğün anahtarlarının koleksiyonu
`Public Overridable ReadOnly Property Values As ICollection Implements IDictionary.Values`	özellik: sözlüğün değerleri koleksiyonu
`Public Overridable Default Property Item(ByVal key As Object) As Object Implements IDictionary.Item`	indeksli özellik: bir anahtara (key) atanan değeri öğrenmeye veya belirlemeye olanak tanır

Aşağıdaki örnek programı ele alalım:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections

Module test
    Sub Main()
        Dim liste() As [String] = {"jean:20", "paul:18", "mélanie:10", "violette:15"}
        Dim i As Integer
        Dim champs As [String]() = Nothing
        Dim séparateurs() As Char = {":"c}
        ' sözlüğün doldurulması
        Dim dico As New Hashtable
        For i = 0 To liste.Length - 1
            champs = liste(i).Split(séparateurs)
            dico.Add(champs(0), champs(1))
        Next i
        ' sözlükteki öğe sayısı
        Console.Out.WriteLine(("Le dictionnaire a " & dico.Count & " éléments"))
        ' anahtar listesi
        Console.Out.WriteLine("[Liste des clés]")
        Dim clés As IEnumerator = dico.Keys.GetEnumerator()
        While clés.MoveNext()
            Console.Out.WriteLine(clés.Current)
        End While
        ' değerler listesi
        Console.Out.WriteLine("[Liste des valeurs]")
        Dim valeurs As IEnumerator = dico.Values.GetEnumerator()
        While valeurs.MoveNext()
            Console.Out.WriteLine(valeurs.Current)
        End While
        ' anahtar ve değer listesi
        Console.Out.WriteLine("[Liste des clés & valeurs]")
        clés.Reset()
        While clés.MoveNext()
            Console.Out.WriteLine(("clé=" & clés.Current.ToString & " valeur=" & dico(clés.Current).ToString))
        End While
        ' "paul" anahtarı siliniyor
        Console.Out.WriteLine("[Suppression d'une clé]")
        dico.Remove("paul")
        ' anahtar ve değer listesi
        Console.Out.WriteLine("[Liste des clés & valeurs]")
        clés = dico.Keys.GetEnumerator()
        While clés.MoveNext()
            Console.Out.WriteLine(("clé=" & clés.Current.ToString & " valeur=" & dico(clés.Current).ToString))
        End While

        ' sözlükte arama
        Dim nomCherché As [String] = Nothing
        Console.Out.Write("Nom recherché (rien pour arrêter) : ")
        nomCherché = Console.ReadLine().Trim()
        Dim value As [Object] = Nothing
        While Not nomCherché.Equals("")
            If dico.ContainsKey(nomCherché) Then
                value = dico(nomCherché)
                Console.Out.WriteLine((nomCherché + "," + CType(value, [String])))
            Else
                Console.Out.WriteLine(("Nom " + nomCherché + " inconnu"))
            End If
            ' sonraki arama
            Console.Out.Write("Nom recherché (rien pour arrêter) : ")
            nomCherché = Console.ReadLine().Trim()
        End While
    End Sub
End Module

Çalıştırma sonuçları şöyledir:

Le dictionnaire a 4 éléments
[Liste des clés]
mélanie
paul
violette
jean
[Liste des valeurs]
10
18
15
20
[Liste des clés & valeurs]
clé=mélanie valeur=10
clé=paul valeur=18
clé=violette valeur=15
clé=jean valeur=20
[Suppression d'une clé]
[Liste des clés & valeurs]
clé=mélanie valeur=10
clé=violette valeur=15
clé=jean valeur=20
Nom recherché (rien pour arrêter) : paul
Nom paul inconnu
Nom recherché (rien pour arrêter) : mélanie
mélanie,10
Nom recherché (rien pour arrêter) :

Program ayrıca, IEnumerator nesnesini kullanarak ICollection türündeki sözlüğün anahtar ve değer koleksiyonlarını tarar (yukarıdaki Keys ve Values özelliklerine bakınız). Koleksiyon, içinden gezinebileceğimiz nesnelerden oluşan bir kümedir. ICollection arayüzü şu şekilde tanımlanmıştır:

Count özelliği, koleksiyondaki öğe sayısını öğrenmemizi sağlar. ICollection arayüzü, IEnumerable arayüzünden türetilmiştir:

Bu arayüzde, GetEnumerator adlı tek bir yöntem bulunur ve bu yöntem sayesinde IEnumerator türünde bir nesne elde edebiliriz:

Bir ICollection koleksiyonundaki GetEnumerator() yöntemi, aşağıdaki yöntemlerle koleksiyonu taramamıza olanak tanır:

`MoveNext`	koleksiyonun bir sonraki öğesine geçer. Bu öğe varsa true, yoksa false değerini döndürür. İlk MoveNext yöntemi, ilk öğeye geçer. Koleksiyonun "geçerli" öğesi, bu durumda sayıcının Current özelliğinde bulunur
`Current`	özelliği: koleksiyonun geçerli öğesi
`Reset`	, sayıcıyı koleksiyonun başına, c.a.d'e, 1. öğeden önce yeniden konumlandırır.

Bir koleksiyondaki öğeler üzerinde yineleme yapmanın (ICollection) C dilindeki yapısı şu şekildedir:

' koleksiyonu tanımla
dim C as ICollection C=...
' bu koleksiyonun bir sayacını al
dim itérateur as IEnumerator=C.GetEnumerator();
' bu sayıcıyla koleksiyonu tarama
while(itérateur.MoveNext())
    ' geçerli bir öğe var
     ' itérateur.Current'i işleme
end while

4.7. StreamReader sınıfı

StreamReader sınıfı, bir dosyanın içeriğini okumaya olanak tanır. İşte bu sınıfın bazı özellikleri ve yöntemleri:

`Public Sub New(ByVal path As String)`	path dosyasından bir akış açar. Dosya mevcut değilse bir istisna atılır
`Overrides Public Sub Close()`	akışı kapatır
`Overrides Public Function ReadLine() As String`	açık akıştan bir satır okur
`Overrides Public Function ReadToEnd() As String`	akışın geri kalanını mevcut konumdan okur

İşte bir örnek:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections
Imports System.IO

Module test
    Sub Main()
        Dim ligne As String = Nothing
        Dim fluxInfos As StreamReader = Nothing
        ' dosya içeriğini okuma
        Try
            fluxInfos = New StreamReader("infos.txt")
            ligne = fluxInfos.ReadLine()
            While Not (ligne Is Nothing)
                System.Console.Out.WriteLine(ligne)
                ligne = fluxInfos.ReadLine()
            End While
        Catch e As Exception
            System.Console.Error.WriteLine("L'erreur suivante s'est produite : " & e.ToString)
        Finally
            Try
                fluxInfos.Close()
            Catch
            End Try
        End Try
    End Sub
End Module

ve yürütme sonuçları:

dos>more infos.txt
12620:0:0
13190:0,05:631
15640:0,1:1290,5
24740:0,15:2072,5
31810:0,2:3309,5
39970:0,25:4900
48360:0,3:6898,5
55790:0,35:9316,5
92970:0,4:12106
127860:0,45:16754,5
151250:0,5:23147,5
172040:0,55:30710
195000:0,6:39312
0:0,65:49062

dos>file1
12620:0:0
13190:0,05:631
15640:0,1:1290,5
24740:0,15:2072,5
31810:0,2:3309,5
39970:0,25:4900
48360:0,3:6898,5
55790:0,35:9316,5
92970:0,4:12106
127860:0,45:16754,5
151250:0,5:23147,5
172040:0,55:30710
195000:0,6:39312
0:0,65:49062

4.8. StreamWriter sınıfı

StreamWriter sınıfı, dosyaya yazma işlemi gerçekleştirir. İşte bu sınıfın bazı özellikleri ve yöntemleri:

`Public Sub New(ByVal path As String)`	path dosyasından bir yazma akışı açar. Dosya oluşturulamazsa bir istisna atılır
`Public Overridable Property AutoFlush As Boolean`	değer bu işlevin döndürdüğü değerle eşitse, akışa yazma işlemi bir tampon üzerinden gerçekleşmez; aksi takdirde akışa yazma işlemi anında gerçekleşmez: önce bir tampona yazılır, tampon dolduğunda ise akışa yazılır. Varsayılan olarak tamponlu mod kullanılır. Bu mod, dosya akışları için uygundur ancak genellikle ağ akışları için uygun değildir.
`Public Overridable Property NewLine As String`	WriteLine yöntemi tarafından kullanılacak satır sonu işaretini belirlemek veya öğrenmek için
`Overrides Public Sub Close()`	akışı kapatır
`Overloads Public Overridable Sub WriteLine(ByVal value As String)`	yazma akışına bir satır yazar
`Overrides Public Sub Flush()`	tampon içeriğini akışa yazar

Aşağıdaki örneği ele alalım:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections
Imports System.IO

Module test
    Sub Main()
        Dim ligne As String = Nothing        ' une ligne de texte
        Dim fluxInfos As StreamWriter = Nothing        ' le fichier texte
        Try
            ' metin dosyası oluşturma
            fluxInfos = New StreamWriter("infos.txt")
            ' klavyeden girilen satırı okuma
            Console.Out.Write("ligne (rien pour arrêter) : ")
            ligne = Console.In.ReadLine().Trim()
            ' girilen satır boş olmadığı sürece döngü
            While ligne <> ""
                ' satırı metin dosyasına yazma
                fluxInfos.WriteLine(ligne)
                ' klavyeden yeni satırı okuma
                Console.Out.Write("ligne (rien pour arrêter) : ")
                ligne = Console.In.ReadLine().Trim()
            End While
        Catch e As Exception
            System.Console.Error.WriteLine("L'erreur suivante s'est produite : " & e.ToString)
        Finally
            ' dosyayı kapat
            Try
                fluxInfos.Close()
            Catch
            End Try
        End Try
    End Sub
End Module

ve yürütme sonuçları:

dos>file2
ligne (rien pour arrêter) : ligne1
ligne (rien pour arrêter) : ligne2
ligne (rien pour arrêter) : ligne3
ligne (rien pour arrêter) :

dos>more infos.txt
ligne1
ligne2
ligne3

4.9. Regex sınıfı

Regex sınıfı, düzenli ifadelerin kullanılmasını sağlar. Düzenli ifadeler, bir karakter dizisinin biçimini test etmeye yarar. Böylece, bir tarihi temsil eden karakter dizisinin gerçekten gg/aa/yy biçiminde olup olmadığını kontrol edebiliriz. Bunun için bir şablon kullanılır ve karakter dizisi bu şablonla karşılaştırılır. Dolayısıyla bu örnekte, j, m ve a rakamlar olmalıdır. Geçerli bir tarih biçiminin şablonu "\d\d/\d\d/\d\d" şeklindedir; burada \d sembolü bir rakamı ifade eder. Şablonda kullanılabilecek semboller şunlardır (Microsoft belgeleri):

	Açıklama
`\`	Bir sonraki karakteri özel karakter veya değişmez karakter olarak işaretler. Örneğin, "n" karakteri "n" karakterine karşılık gelir. "\n" karakteri yeni satır karakterine karşılık gelir. "\\" dizisi "\" karakterine karşılık gelirken, "\(" karakteri "(" karakterine karşılık gelir.
`^`	Girişin başlangıcına karşılık gelir.
`$`	Girişin sonuna karşılık gelir.
`*`	Önceki karakterin sıfır kez veya birden fazla kez tekrarına karşılık gelir. Dolayısıyla, "zo*" "z" veya "zoo" karakterlerine karşılık gelir.
`+`	Önceki karakteri bir veya daha fazla kez eşleştirir. Dolayısıyla, "zo+" "zoo" ile eşleşir, ancak "z" ile eşleşmez.
`?`	Önceki karakterle sıfır veya bir kez eşleşir. Örneğin, "a?ve?" "lever" kelimesindeki "ve" ile eşleşir.
`.`	Satır sonu karakteri hariç, herhangi bir tekil karakterle eşleşir.
`(modèle)`	modèle'i arar ve eşleşmeyi kaydeder. Eşleşen alt dize, elde edilen Matches koleksiyonundan Item [0]...[n] kullanılarak çıkarılabilir. Parantez ( ) içindeki karakterlerle eşleşmeleri bulmak için "$" veya "$" kullanın.
`x\|y`	x veya y ile eşleşir. Örneğin, "z\|foot" correspond à "z" ou à "foot". "(z\|f)oo" "zoo" veya "foo" ile eşleşir.
`{n}`	n, negatif olmayan bir tam sayıdır. Tam olarak n çarpı karakter sayısına karşılık gelir. Örneğin, "o{2}", "Bob," içindeki "o" harfine değil, "fooooot" içindeki ilk iki "o" harfine karşılık gelir.
`{n,}`	n, negatif olmayan bir tamsayıdır. Karakterin en az n katına karşılık gelir. Örneğin, "o{2,}", "Bob" kelimesindeki "o" harfine değil, "fooooot" kelimesindeki tüm "o" harflerine karşılık gelir. "o{1,}", "o+" ile eşdeğerdir ve "o{0,}", "o*" ile eşdeğerdir.
`{n,m}`	m ve n, negatif olmayan tamsayılardır. Karakterin en az n ve en fazla m kez tekrarlanmasına karşılık gelir. Örneğin, "o{1,3}", "foooooot" kelimesindeki ilk üç "o" harfine karşılık gelir ve "o{0,1}", "o?" ile eşdeğerdir.
`[xyz]`	Karakter kümesi. Belirtilen karakterlerden birine karşılık gelir. Örneğin, "[abc]", "plat" kelimesindeki "a" harfine karşılık gelir.
`[^xyz]`	Negatif karakter kümesi. Belirtilmeyen tüm karakterlere karşılık gelir. Örneğin, "[^abc]", "plat" kelimesindeki "p" harfine karşılık gelir.
`[a-z]`	Karakter aralığı. Belirtilen dizideki tüm karakterlere karşılık gelir. Örneğin, "[a-z]", "a" ile "z" arasındaki tüm küçük harflere karşılık gelir.
`[^m-z]`	Negatif karakter aralığı. Belirtilen dizide bulunmayan tüm karakterlere karşılık gelir. Örneğin, "[^m-z]", "m" ile "z" arasında bulunmayan tüm karakterlere karşılık gelir.
`\b`	Bir kelimeyi temsil eden sınırla, başka bir deyişle bir kelime ile boşluk arasındaki konuma karşılık gelir. Örneğin, "er\b", "lever" kelimesindeki "er" ile eşleşir, ancak "verbe" kelimesindeki "er" ile eşleşmez.
`\B`	Bir kelimeyi temsil etmeyen bir sınıra karşılık gelir. "en*t\B", "bien entendu" kelimesindeki "ent" kısmına karşılık gelir.
`\d`	Bir rakamı temsil eden bir karaktere karşılık gelir. [0-9] ile eşdeğerdir.
`\D`	Rakam olmayan bir karaktere karşılık gelir. [^0-9] ile eşdeğerdir.
`\f`	Sayfa sonu karakterine karşılık gelir.
`\n`	Yeni satır karakterine karşılık gelir.
`\r`	Satır başı karakterine karşılık gelir.
`\s`	Boşluk, sekme, sayfa sonu vb. dahil olmak üzere tüm boşluklara karşılık gelir. "[ \f\n\r\t\v]" ile eşdeğerdir.
`\S`	Beyaz olmayan tüm boşluk karakterlerine karşılık gelir. "[^ \f\n\r\t\v]" ile eşdeğerdir.
`\t`	Bir sekme karakterine karşılık gelir.
`\v`	Dikey sekme karakterine karşılık gelir.
`\w`	Bir kelimeyi temsil eden ve alt çizgi içeren herhangi bir karaktere karşılık gelir. "[A-Za-z0-9_]" ile eşdeğerdir.
`\W`	Bir kelimeyi temsil etmeyen herhangi bir karaktere karşılık gelir. "[^A-Za-z0-9_]" ile eşdeğerdir.
`\num`	num'e karşılık gelir; burada num pozitif bir tamsayıdır. Kaydedilmiş eşleşmelere atıfta bulunur. Örneğin, "(.)\1" iki ardışık aynı karaktere karşılık gelir.
`\n`	n'e karşılık gelir; burada n bir sekizlik kaçış değeridir. Sekizlik kaçış değerleri 1, 2 veya 3 basamaklı olmalıdır. Örneğin, "\11" ve "\011" her ikisi de bir sekme karakterine karşılık gelir. "\0011", "\001" ve "1"e eşittir. Sekizlik kaçış değerleri 256'yı aşmamalıdır. Aşılması durumunda, ifadede yalnızca ilk iki rakam dikkate alınır. ASCII kodlarının düzenli ifadelerde kullanılmasına olanak tanır.
`\xn`	n'e karşılık gelir; burada n onaltılık bir kaçış değeridir. Onaltılık kaçış değerleri mutlaka iki basamaklı olmalıdır. Örneğin, "\x41" "A" harfine karşılık gelir. "\x041" ise "\x04" ve "1" değerlerinin birleşimine eşittir. ASCII kodlarının düzenli ifadelerde kullanılmasına izin verir.

Bir şablondaki öğe, 1 veya daha fazla kopya halinde bulunabilir. 1 rakamı temsil eden \d sembolüyle ilgili birkaç örneği inceleyelim:

şablon	anlam
`\d`	bir rakam
`\d?`	0 veya 1 rakam
`\d*`	0 veya daha fazla rakam
`\d+`	1 veya daha fazla rakam
`\d{2}`	2 rakam
`\d{3,}`	en az 3 rakam
`\d{5,7}`	5 ile 7 rakam arası

Şimdi, bir karakter dizisi için beklenen biçimi tanımlayabilen modeli düşünelim:

aranan dize	model
`une date au format jj/mm/aa`	\d{2}/\d{2}/\d{2}
`une heure au format hh:mm:ss`	\d{2}:\d{2}:\d{2}
`un nombre entier non signé`	\d+
`un suite d'espaces éventuellement vide`	\s*
`un nombre entier non signé qui peut être précédé ou suivi d'espaces`	\s\d+\s
`un nombre entier qui peut être signé et précédé ou suivi d'espaces`	\s[+\|-]?\s\d+\s*
`un nombre réel non signé qui peut être précédé ou suivi d'espaces`	\s\d+(.\d)?\s*
`un nombre réel qui peut être signé et précédé ou suivi d'espaces`	\s[+\|]?\s\d+(.\d)?\s
`une chaîne contenant le mot juste`	\bjuste\b

Dizgide kalıbın nerede aranacağını belirtebiliriz:

desen	anlam
`^modèle`	şablon, dizgenin başında yer alır
`modèle$`	şablon dizgisini sonlandırır
`^modèle$`	şablon dizgiyi başlatır ve bitirir
`modèle`	şablon, dizgenin başından başlayarak dizgenin her yerinde aranır.

aranan dize	desen
`une chaîne se terminant par un point d'exclamation`	!$
`une chaîne se terminant par un point`	\.$
`une chaîne commençant par la séquence //`	^//
`une chaîne ne comportant qu'un mot éventuellement suivi ou précédé d'espaces`	^\s\w+\s$
`une chaîne ne comportant deux mot éventuellement suivis ou précédés d'espaces`	^\s\w+\s\w+\s*$
`une chaîne contenant le mot secret`	\bsecret\b

Bir şablonun alt kümeleri "alınabilir". Böylece, bir dizgenin belirli bir şablona uyup uymadığını kontrol etmekle kalmaz, aynı zamanda bu dizgede parantezlerle çevrilen şablonun alt kümelerine karşılık gelen öğeleri de alabiliriz. Örneğin, gg/aa/yyyy tarihini içeren bir dizgiyi analiz ediyorsak ve bu tarihin gg, aa, yyyy öğelerini de ayıklamak istiyorsak, (\d\d)/(\d\d)/(\d\d) şablonunu kullanırız.

4.9.1. Bir dizgenin belirli bir modele uyup uymadığını kontrol etme

Regex türü bir nesne şu şekilde oluşturulur:

Public Sub New(ByVal pattern As String)

Oluşturucu, parametre olarak verilen bir şablondan ("pattern") bir "düzenli ifade" nesnesi oluşturur. Düzenli ifade şablonu oluşturulduktan sonra, IsMatch yöntemi kullanılarak karakter dizileriyle karşılaştırılabilir:

Overloads Public Function IsMatch(ByVal input As String) As Boolean

IsMatch, girdi dizesi düzenli ifade şablonuna uyuyorsa true değerini döndürür. İşte bir örnek:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections
Imports System.Text.RegularExpressions

Module regex1

    Sub Main()
        ' bir düzenli ifade şablonu
        Dim modèle1 As String = "^\s*\d+\s*$"
        Dim regex1 As New Regex(modèle1)
        ' bir örneği şablonla karşılaştırma
        Dim exemplaire1 As String = "  123  "
        If regex1.IsMatch(exemplaire1) Then
            affiche(("[" + exemplaire1 + "] correspond au modèle [" + modèle1 + "]"))
        Else
            affiche(("[" + exemplaire1 + "] ne correspond pas au modèle [" + modèle1 + "]"))
        End If
        Dim exemplaire2 As String = "  123a  "
        If regex1.IsMatch(exemplaire2) Then
            affiche(("[" + exemplaire2 + "] correspond au modèle [" + modèle1 + "]"))
        Else
            affiche(("[" + exemplaire2 + "] ne correspond pas au modèle [" + modèle1 + "]"))
        End If
    End Sub

    ' görüntüle 
    Sub affiche(ByVal msg As String)
        Console.Out.WriteLine(msg)
    End Sub
End Module

ve yürütme sonuçları:

dos>vbc /r:system.dll regex1.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4 pour Microsoft (R) .NET Framework version 1.1.4322.573

dos>regex1
[  123  ] correspond au modèle [^\s*\d+\s*$]
[  123a  ] ne correspond pas au modèle [^\s*\d+\s*$]

4.9.2. Bir desene uyan bir dizgedeki tüm öğeleri bulma

Matches yöntemi

Overloads Public Function Matches(ByVal input As String) As MatchCollection

yöntemi, aşağıdaki örnekte gösterildiği gibi, input dizesindeki desene uyan öğelerin bir koleksiyonunu döndürür:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections
Imports System.Text.RegularExpressions

Module regex2
    Sub Main()
        ' örnekteki şablonun birden fazla geçmesi
        Dim modèle2 As String = "\d+"
        Dim regex2 As New Regex(modèle2)        '
        Dim exemplaire3 As String = "  123  456  789 "
        Dim résultats As MatchCollection = regex2.Matches(exemplaire3)
        affiche(("Modèle=[" + modèle2 + "],exemplaire=[" + exemplaire3 + "]"))
        affiche(("Il y a " & résultats.Count & " occurrences du modèle dans l'exemplaire "))
        Dim i As Integer
        For i = 0 To résultats.Count - 1
            affiche((résultats(i).Value & " en position " & résultats(i).Index))
        Next i
    End Sub

    'göster
    Sub affiche(ByVal msg As String)
        Console.Out.WriteLine(msg)
    End Sub
End Module

MatchCollection sınıfının, koleksiyondaki öğe sayısını gösteren Count adlı bir özelliği vardır. résultats, MatchCollection nesnesiyse, résultats(i) bu koleksiyonun i'inci elemanıdır ve türü Match'tir. Örneğimizde, résultats, exemplaire3 dizisindeki modèle2 şablonuna uyan öğelerin kümesidir ve résultats(i) bu öğelerden biridir. Match sınıfında burada ilgilendiğimiz iki özellik vardır:

Value: Match nesnesinin değeri, yani modele karşılık gelen öğe
Index: Elemanın taranan dizede bulunduğu konum

Önceki programın çalıştırılma sonuçları:

dos>vbc /r:system.dll regex2.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4p our Microsoft (R) .NET Framework version 1.1.4322.573

dos>regex2
Modèle=[\d+],exemplaire=[  123  456  789 ]
Il y a 3 occurrences du modèle dans l'exemplaire
123 en position 2
456 en position 7
789 en position 12

4.9.3. Bir şablonun parçalarını alma

Bir şablonun alt kümeleri "çıkarılabilir". Böylece, bir dizgenin belirli bir şablona uyup uymadığını kontrol etmekle kalmaz, aynı zamanda bu dizgede parantez içine alınmış şablonun alt kümelerine karşılık gelen öğeleri de çıkarabiliriz. Örneğin, gg/aa/yyyy tarihini içeren bir dizgiyi analiz ediyorsak ve bu tarihin gg, aa, yyyy öğelerini de ayıklamak istiyorsak, (\d\d)/(\d\d)/(\d\d) modelini kullanırız. Aşağıdaki örneği inceleyelim:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections
Imports System.Text.RegularExpressions

Module regex2
    Sub Main()
        ' şablondaki öğelerin yakalanması
        Dim modèle3 As String = "(\d\d):(\d\d):(\d\d)"
        Dim regex3 As New Regex(modèle3)
        Dim exemplaire4 As String = "Il est 18:05:49"
        ' şablon doğrulama
        Dim résultat As Match = regex3.Match(exemplaire4)
        If résultat.Success Then
            ' örnek, modele uyuyor
            affiche(("L'exemplaire [" + exemplaire4 + "] correspond au modèle [" + modèle3 + "]"))
            ' gruplar görüntüleniyor
            Dim i As Integer
            For i = 0 To résultat.Groups.Count - 1
                affiche(("groupes[" & i & "]=[" & résultat.Groups(i).Value & "] en position " & résultat.Groups(i).Index))
            Next i
        Else
            ' örnek, şablona uymuyor
            affiche(("L'exemplaire[" + exemplaire4 + " ne correspond pas au modèle [" + modèle3 + "]"))
        End If
    End Sub

    'görüntüleniyor
    Sub affiche(ByVal msg As String)
        Console.Out.WriteLine(msg)
    End Sub
End Module

Bu programın çalıştırılması sonucunda aşağıdaki sonuçlar elde edilir:

dos>vbc /r:system.dll regex3.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4

dos>regex3
L'exemplaire [Il est 18:05:49] correspond au modèle [(\d\d):(\d\d):(\d\d)]
groupes[0]=[18:05:49] en position 7
groupes[1]=[18] en position 7
groupes[2]=[05] en position 10
groupes[3]=[49] en position 13

Yenilik, aşağıdaki kod bölümünde yer almaktadır:


        ' şablon kontrolü
        Dim résultat As Match = regex3.Match(exemplaire4)
        If résultat.Success Then
            ' örnek, şablona uyuyor
            affiche(("L'exemplaire [" + exemplaire4 + "] correspond au modèle [" + modèle3 + "]"))
            ' gruplar görüntüleniyor
            Dim i As Integer
            For i = 0 To résultat.Groups.Count - 1
                affiche(("groupes[" & i & "]=[" & résultat.Groups(i).Value & "] en position " & résultat.Groups(i).Index))
            Next i
        Else

exemplaire4 dizesi, regex3 şablonuyla Match yöntemi aracılığıyla karşılaştırılır. Bu yöntem, daha önce tanıtılmış olan Match nesnesini döndürür. Burada bu sınıfın iki yeni özelliğini kullanıyoruz:

Success: eşleşme olup olmadığını gösterir
Groups: aşağıdakileri içeren koleksiyon
- Groups[0], şablona karşılık gelen dize kısmına karşılık gelir
- Groups[i] (i>=1), i numaralı parantez grubuna karşılık gelir

Sonuç Match türündeyse, résultats.Groups, GroupCollection türündedir ve résultats.Groups[i], Group türündedir. Group sınıfında burada kullandığımız iki özellik vardır:

Value: Group nesnesinin değeri; bu, parantez içindeki içeriğe karşılık gelen öğedir
Index: Elemanın taranan dizede bulunduğu konum

4.9.4. Bir alıştırma programı

Bir dizgenin belirli bir modele uyup uymadığını kontrol etmemizi sağlayan düzenli ifadeyi bulmak bazen gerçek bir zorluktur. Aşağıdaki program bu konuda alıştırma yapmanıza olanak tanır. Program, bir model ve bir dizge ister ve ardından dizgenin modele uyup uymadığını belirtir.


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Collections
Imports System.Text.RegularExpressions
Imports Microsoft.visualbasic

Module regex4
    Sub Main()
        ' bir şablon düzenli ifadesi
        Dim modèle, chaine As String
        Dim regex As Regex = Nothing
        Dim résultats As MatchCollection
        ' kullanıcıdan, bu örnekle karşılaştırılacak şablonlar ve örnekler istenir
        Dim terminé1 As Boolean = False
        Do While Not terminé1
            Dim erreur As Boolean = True
            Do While Not terminé1 And erreur
                ' şablon sorulur
                Console.Out.Write("Tapez le modèle à tester ou fin pour arrêter :")
                modèle = Console.In.ReadLine()
                ' bitti mi?
                If modèle.Trim().ToLower() = "fin" Then
                    terminé1 = True
                Else
                    ' düzenli ifade oluşturulur
                    Try
                        regex = New Regex(modèle)
                        erreur = False
                    Catch ex As Exception
                        Console.Error.WriteLine(("Erreur : " + ex.Message))
                    End Try
                End If
            Loop
            ' bitti mi?
            If terminé1 Then Exit Sub
            ' kullanıcıdan modelle karşılaştırılacak örnekler isteniyor
            Dim terminé2 As Boolean = False
            Do While Not terminé2
                Console.Out.Write(("Tapez la chaîne à comparer au modèle [" + modèle + "] ou fin pour arrêter :"))
                chaine = Console.In.ReadLine()
                ' bitti mi?
                If chaine.Trim().ToLower() = "fin" Then
                    terminé2 = True
                Else
                    ' karşılaştırma yapılıyor
                    résultats = regex.Matches(chaine)
                    ' başarılı mı?
                    If résultats.Count = 0 Then
                        Console.Out.WriteLine("Je n'ai pas trouvé de correspondances")
                    Else
                        ' modele uyan öğeler görüntülenir
                        Dim i As Integer
                        For i = 0 To résultats.Count - 1
                            Console.Out.WriteLine(("J'ai trouvé la correspondance [" & résultats(i).Value & "] en position " & résultats(i).Index))
                            ' alt öğeler
                            If résultats(i).Groups.Count <> 1 Then
                                Dim j As Integer
                                For j = 1 To (résultats(i).Groups.Count) - 1
                                    Console.Out.WriteLine((ControlChars.Tab & "sous-élément [" & résultats(i).Groups(j).Value & "] en position " & résultats(i).Groups(j).Index))
                                Next j
                            End If
                        Next i
                    End If
                End If
            Loop
        Loop
    End Sub

    'görüntüleniyor
    Sub affiche(ByVal msg As String)
        Console.Out.WriteLine(msg)
    End Sub
End Module

İşte bir çalıştırma örneği:

Tapez le modèle à tester ou fin pour arrêter :\d+
Tapez la chaîne à comparer au modèle [\d+] ou fin pour arrêter :123 456 789
J'ai trouvé la correspondance [123] en position 0
J'ai trouvé la correspondance [456] en position 4
J'ai trouvé la correspondance [789] en position 8
Tapez la chaîne à comparer au modèle [\d+] ou fin pour arrêter :fin

Tapez le modèle à tester ou fin pour arrêter :(\d\d):(\d\d)
Tapez la chaîne à comparer au modèle [(\d\d):(\d\d)] ou fin pour arrêter :14:15 abcd 17:18 xyzt
J'ai trouvé la correspondance [14:15] en position 0
        sous-élément [14] en position 0
        sous-élément [15] en position 3
J'ai trouvé la correspondance [17:18] en position 11
        sous-élément [17] en position 11
        sous-élément [18] en position 14
Tapez la chaîne à comparer au modèle [(\d\d):(\d\d)] ou fin pour arrêter :fin

Tapez le modèle à tester ou fin pour arrêter :^\s*\d+\s*$
Tapez la chaîne à comparer au modèle [^\s*\d+\s*$] ou fin pour arrêter :  1456
J'ai trouvé la correspondance [  1456] en position 0
Tapez la chaîne à comparer au modèle [^\s*\d+\s*$] ou fin pour arrêter :fin

Tapez le modèle à tester ou fin pour arrêter :^\s*(\d+)\s*$
Tapez la chaîne à comparer au modèle [^\s*(\d+)\s*$] ou fin pour arrêter :1456
J'ai trouvé la correspondance [1456] en position 0
        sous-élément [1456] en position 0
Tapez la chaîne à comparer au modèle [^\s*(\d+)\s*$] ou fin pour arrêter :abcd 1
456
Je n'ai pas trouvé de correspondances
Tapez la chaîne à comparer au modèle [^\s*(\d+)\s*$] ou fin pour arrêter :fin

Tapez le modèle à tester ou fin pour arrêter :fin

4.9.5. Split yöntemi

Bu yöntemi daha önce String sınıfında görmüştük:

Overloads Public Function Split(ByVal ParamArray separator() As Char) As String()

Dize, [separator] tablosunda bulunan karakterlerle ayrılmış bir dizi alan olarak görülür. Sonuç, bu alanların oluşturduğu tablodur.

Dizgedeki alan ayırıcısı, burada separator tablosundaki karakterlerden biridir. Regex sınıfındaki Split yöntemi, ayırıcıyı bir şablona göre ifade etmemizi sağlar:

Overloads Public Function Split(ByVal input As String) As String()

[input] dizesi alanlara ayrılır; bu alanlar, geçerli Regex nesnesinin şablonuna karşılık gelen bir ayırıcıyla birbirinden ayrılır. Örneğin, bir metin dosyasında alan1, alan2, .., alann biçiminde satırlar olduğunu varsayalım. Alanlar virgülle ayrılır, ancak virgülün önünde veya arkasında boşluklar olabilir. Bu durumda, string sınıfındaki Split yöntemi uygun değildir. Çözümü ise RegEx yönteminde bulabiliriz. line okunan satır ise, alanlar şu şekilde elde edilebilir:

dim champs() as string=new Regex("s*,\s*").Split(ligne)

kullanılarak elde edilebilir; aşağıdaki örnekte gösterildiği gibi:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Text.RegularExpressions

Module regex5
    Sub Main()
        ' bir satır
        Dim ligne As String = "abc  , def  , ghi"
        ' bir şablon
        Dim modèle As New Regex("\s*,\s*")
        ' satırı alanlara ayırma
        Dim champs As String() = modèle.Split(ligne)
        ' görüntüleme
        Dim i As Integer
        For i = 0 To champs.Length - 1
            Console.Out.WriteLine(("champs[" & i & "]=[" & champs(i) & "]"))
        Next i
    End Sub
End Module

Çalıştırma sonuçları:

dos>vbc /r:system.dll regex5.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4

dos>regex5
champs[0]=[abc]
champs[1]=[def]
champs[2]=[ghi]

4.10. BinaryReader ve BinaryWriter sınıfları

BinaryReader ve BinaryWriter sınıfları, ikili dosyaları okumak ve yazmak için kullanılır. Aşağıdaki uygulamayı ele alalım. Şu şekilde çağrılacak bir program yazmak istiyoruz:

// pg metin bin sözdizimi
// bir metin dosyası (metin) okunur ve içeriği bir
// ikili dosyaya kaydedilir
// metin dosyası, "ad: yaş" biçiminde satırlardan oluşur
// bu satırları string ve int türlerinde bir yapıya kaydedeceğiz

Metin dosyasının içeriği şöyledir:

paul : 10
helene : 15
jacques : 11
sylvain : 12

Program şu şekildedir:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Text.RegularExpressions
Imports System.IO

' BinaryWriter()

Module bw1
    ' pg metin bin sözdizimi
    ' bir metin dosyası (text) okunur ve içeriği bir
    ' ikili dosyaya kaydedilir
    ' metin dosyası, "ad: yaş" biçiminde satırlardan oluşur
    ' bu satırları string ve int türlerinde bir yapıya kaydedeceğiz

    Sub Main(ByVal arguments() As String)
        ' 2 argüman gereklidir
        Dim nbArgs As Integer = arguments.Length
        If nbArgs <> 2 Then
            Console.Error.WriteLine("syntaxe : pg texte binaire")
            Environment.Exit(1)
        End If
        ' metin dosyasının okuma modunda açılması
        Dim input As StreamReader = Nothing
        Try
            input = New StreamReader(arguments(0))
        Catch ex As Exception
            Console.Error.WriteLine("Erreur d'ouverture du fichier " & arguments(0) & "(" & ex.Message & ")")
            Environment.Exit(2)
        End Try
        ' ikili dosyanın yazma modunda açılması
        Dim output As BinaryWriter = Nothing
        Try
            output = New BinaryWriter(New FileStream(arguments(1), FileMode.Create, FileAccess.Write))
        Catch ex As Exception
            Console.Error.WriteLine("Erreur d'ouverture du fichier " & arguments(1) & "(" & ex.Message & ")")
            Environment.Exit(3)
        End Try
        ' metin dosyasını okuma - ikili dosyayı yazma
        ' metin dosyasının satırı
        Dim ligne As String
        ' satırdaki alan ayırıcısı
        Dim séparateur As New Regex("\s*:\s*")
        ' yaş şablonu
        Dim modAge As New Regex("\s*\d+\s*")
        Dim numLigne As Integer = 0
        Dim traitementFini As Boolean
        Dim champs As String()
        ligne = input.ReadLine()
        While Not (ligne Is Nothing)
            traitementFini = False
            ' boş satır mı?
            If ligne.Trim() = "" Then
                traitementFini = True
            End If
            ' bir satır daha
            If Not traitementFini Then
                numLigne += 1
                ' ad: yaş satırı
                champs = séparateur.Split(ligne)
                ' 2 alana ihtiyacımız var
                If champs.Length <> 2 Then
                    Console.Error.WriteLine(("La ligne n° " & numLigne & " du fichier " & arguments(0) & " a un nombre de champs incorrect"))
                    ' sonraki satır
                    traitementFini = True
                End If
            End If
            If Not traitementFini Then
                ' ikinci alan >=0 olan bir tamsayı olmalı
                If Not modAge.IsMatch(champs(1)) Then
                    Console.Error.WriteLine(("La ligne n° " & numLigne & " du fichier " & arguments(0) & " a un âge incorrect"))
                    ' sonraki satır
                    traitementFini = True
                End If
                ' verileri ikili dosyaya yazıyoruz
                output.Write(champs(0))
                output.Write(Integer.Parse(champs(1)))
            End If
            'bir sonraki satır
            ligne = input.ReadLine()
        End While
        ' dosyalar kapatılır
        input.Close()
        output.Close()
    End Sub
End Module

BinaryWriter sınıfıyla ilgili işlemler üzerinde biraz duralım:

BinaryWriter nesnesi,


            output = New BinaryWriter(New FileStream(arguments(1), FileMode.Create, FileAccess.Write))

Oluşturucunun argümanı bir akış (Stream) olmalıdır. Burada, aşağıda verilen bir dosyadan (FileStream) oluşturulan bir akış söz konusudur:

(devamı)
- adı
- yapılacak işlem, burada dosyayı oluşturmak için FileMode.Create
- erişim türü; burada dosyaya yazma erişimi için FileAccess.Write

yazma işlemi


                 ' veriler ikili dosyaya yazılır
                output.Write(champs(0))
                output.Write(Integer.Parse(champs(1)))

BinaryWriter sınıfı, farklı basit veri türlerini yazmak için üstü yazılmış çeşitli Write yöntemlerine sahiptir

akışın kapatılması işlemi

        output.Close()

Önceki çalıştırmanın sonuçları, aşağıdaki program tarafından bize verilecektir. Bu program da iki argüman kabul eder:

     ' pg bin metin sözdizimi
     ' bin ikili dosyası okunur ve içeriği bir metin dosyasına (text) kaydedilir
     ' ikili dosyanın yapısı string, int şeklindedir
     ' metin dosyası, "ad: yaş" biçiminde satırlara sahiptir

Dolayısıyla ters işlemi yapıyoruz. Bir ikili dosyayı okuyarak bir metin dosyası oluşturuyoruz. Oluşturulan metin dosyası orijinal dosyayla aynıysa, metin --> ikili --> metin dönüşümünün başarılı olduğunu anlarız. Kod şu şekildedir:


' seçenekler
Option Strict On
Option Explicit On 

' ad alanları
Imports System
Imports System.Text.RegularExpressions
Imports System.IO

Module br1
    ' pg bin metin sözdizimi
    ' bin adlı bir ikili dosya okunur ve içeriği bir metin dosyasına (text) kaydedilir
    ' ikili dosyanın yapısı string, int şeklindedir
    ' metin dosyası, "ad: yaş" biçiminde satırlara sahiptir

    Sub Main(ByVal arguments() As String)
        ' 2 argüman gereklidir
        Dim nbArgs As Integer = arguments.Length
        If nbArgs <> 2 Then
            Console.Error.WriteLine("syntaxe : pg binaire texte")
            Environment.Exit(1)
        End If
        ' ikili dosyanın okuma modunda açılması
        Dim dataIn As BinaryReader = Nothing
        Try
            dataIn = New BinaryReader(New FileStream(arguments(0), FileMode.Open, FileAccess.Read))
        Catch ex As Exception
            Console.Error.WriteLine("Erreur d'ouverture du fichier " & arguments(0) & "(" & ex.Message & ")")
            Environment.Exit(2)
        End Try
        ' metin dosyasının yazma modunda açılması
        Dim dataOut As StreamWriter = Nothing
        Try
            dataOut = New StreamWriter(arguments(1))
            dataOut.AutoFlush = True
        Catch ex As Exception
            Console.Error.WriteLine("Erreur d'ouverture du fichier " & arguments(1) & "(" & ex.Message & ")")
            Environment.Exit(3)
        End Try
        ' ikili dosyanın okunması - metin dosyasının yazılması
        Dim nom As String        ' nom d'une personne
        Dim age As Integer        ' son âge
        ' ikili dosyanın işleme döngüsü
        While True
            ' ad okuma
            Try
                nom = dataIn.ReadString()
            Catch
                ' dosyanın sonu
                Exit Sub
            End Try
            ' yaş okuma
            Try
                age = dataIn.ReadInt32()
            Catch
                Console.Error.WriteLine("Le fichier " & arguments(0) + " ne semble pas avoir un format correct")
                Exit Sub
            End Try
            ' metin dosyasına yazma
            dataOut.WriteLine(nom & ":" & age)
            System.Console.WriteLine(nom & ":" & age)
        End While
        ' her şeyi kapatıyoruz
        dataIn.Close()
        dataOut.Close()
    End Sub
End Module

BinaryReader sınıfıyla ilgili işlemler üzerinde biraz duralım:

BinaryReader nesnesi şu işlemle açılır:


            dataIn = New BinaryReader(New FileStream(arguments(0), FileMode.Open, FileAccess.Read))

Oluşturucunun argümanı bir akış (Stream) olmalıdır. Burada, bir dosyadan (FileStream) oluşturulan bir akış söz konusudur ve bu akış için şunlar verilmiştir:

(devamı)
- adı
- yapılacak işlem, burada mevcut bir dosyayı açmak için FileMode.Open
- erişim türü; burada dosyaya okuma erişimi için FileAccess.Read

okuma işlemi

                nom = dataIn.ReadString()
                age = dataIn.ReadInt32()

BinaryReader sınıfı, çeşitli basit veri türlerini okumak için farklı yöntemlere sahiptir: ReadXX

akışın kapatılması işlemi

        dataIn.Close()

personnes.txt'i personnes.bin'e, ardından personnes.bin'i personnes.txt2'e dönüştüren iki programı arka arkaya çalıştırırsak şu sonuç elde edilir:

dos>more personnes.txt
paul : 10
helene : 15
jacques : 11
sylvain : 12

dos>more personnes.txt2
paul:10
helene:15
jacques:11
sylvain:12

dos>dir
29/04/2002  18:19                   54 personnes.txt
29/04/2002  18:19                   44 personnes.bin
29/04/2002  18:20                   44 personnes.txt2