C Sharp Programlama Dili/System isim alanı
Bu kısımda .Net Framework sınıf kütüphanesinin en tepesinde bulunan System isim alanındaki önemli türleri yakından inceleyeceğiz. Hatırlarsanız bu isim alanındaki rastgele sayı üretmeye yarayan Random sınıfını, matematiksel işlemler yapmamızı sağlayan Math sınıfını ve türler arasında dönüşüm sağlayan Convert sınıfını daha önce incelemiştik. Şimdi ise C#'ta tarih-saat işlemleriyle ilgili üye elemanlar barındıran DateTime ve TimeSpan yapılarını, çöp toplama mekanizmasıyla ilgili üye elemanlar barındıran GC sınıfını, verilerin baytlarıyla ilgili işlemler yapmamıza yarayan BitArray ve Buffer sınıflarını, dizilerle ilgili işlemler yapmamızı sağlayan Array sınıfını ve C#'taki temel tür yapılarını ayrıntılarıyla işleyeceğiz.
Temel tür yapıları
[değiştir]Daha önce söylemiştim, ancak yine de hatırlatmak istiyorum. C#'taki temel veri türleri aslında System isim alanındaki bazı yapılardan başka bir şey değildir. int, float, vb. System isim alanındaki Int32, Single, vb. yapılarına verilen takma isimden başka bir şey değildir. Yani C#'ın programlarımızın başına using int=System.Int32; satırını gizlice eklediğini düşünebilirsiniz. Aşağıdaki tabloyu inceleyiniz:
| C#'taki takma adı | System isim alanındaki yapı |
|---|---|
| bool | Boolean |
| byte | Byte |
| sbyte | Sbyte |
| short | Int16 |
| ushort | UInt16 |
| int | Int32 |
| uint | UInt32 |
| long | Int64 |
| ulong | UInt64 |
| float | Single |
| double | Double |
| decimal | Decimal |
| char | Char |
Tahmin edersiniz ki bu yapıların üye elemanları da vardır. Önce özellikleri inceleyelim:
MaxValue İlgili veri türünün tutabileceği maksimum değeri ilgili veri türünden tutar. string, object ve bool türü haricindekilerle kullanılabilir. Örnek:
Console.WriteLine(UInt64.MaxValue);
MinValue İlgili veri türünün tutabileceği minimum değeri ilgili veri türünden tutar. string, object ve bool türü haricindekilerle kullanılabilir. Örnek:
Console.WriteLine(UInt64.MinValue);
Epsilon Yalnızca Single ve Double ile kullanılabilir. En küçük pozitif değeri ilgili veri türünden tutar. Örnek:
Console.WriteLine(Single.Epsilon);
NaN Herhangi bir sayıyı temsil etmeyen değer (ilgili türde). Yalnızca Single ve Double ile kullanılabilir. Örnek:
Console.WriteLine(Single.NaN);
NegativeInfinity Negatif sonsuz (ilgili türde). Yalnızca Single ve Double ile kullanılabilir. Örnek:
Console.WriteLine(Single.NegativeInfinity);
PositiveInfinity Pozitif sonsuz (ilgili türde). Yalnızca Single ve Double ile kullanılabilir. Örnek:
Console.WriteLine(Single.PositiveInfinity);
Şimdi de metotlar:
Parse() String türünden veriyi ilgili türe çevirir. String ve object hariç bütün türlerle kullanılabilir. Aslında Parse() metodunun yaptığı iş stringin tırnaklarını kaldırmaktır. Stringin tırnakları kaldırılmış hâli hedef türle uyumluysa dönüşüm gerçekleşir. Örneğin string türündeki veri "true" ise Boolean türüne dönüşebilir. Ancak Int32 türüne dönüşmez. Benzer şekilde stringin içindeki karakter sayısı bir taneyse char'a dönüşebilir. Aksi bir durumda dönüşmez. Eğer dönüşüm gerçekleşmezse çalışma zamanı hatası alırsınız. Örnek:
int a=Int32.Parse("12");
CompareTo() Bu metotla, metodu çağıran veriyle parametre kıyaslanır. Metodu çağıran büyükse pozitif, parametre büyükse negatif, eşitlerse 0 değeri döndürür. Geri dönüş tipi inttir. Bütün türlerle kullanılabilir, ancak metodu çağıran object olamaz. Parametredeki verinin türü metodu çağırandan küçük ya da eşit kapasiteli olmalıdır. Bool türüyle bool türü kıyaslanabilir. true 1, false 0'mış gibi ele alınır. String türündeyse iki string aynıysa 0, diğer durumlarda 1 değeri geri döndürür. Örnek:
Console.WriteLine(12.CompareTo(100));
Equals() Bu metotla, metodu çağıran veriyle parametre kıyaslanır. Eşitlerse true, eşit değillerse false değeri geri döndürür. Bütün türlerle kullanılabilir. Hatasız sonuçlar için parametrenin tipi metodu çağırandan küçük ya da eşit kapasiteli olmalıdır. Uyumsuz türler kıyaslanırsa hata vermez, false değeri geri döndürür. Örnek:
Console.WriteLine(12.Equals(100));
ToString() Verilerin stringe dönüşmüş hâllerini tutar. Parse'ın tersidir diyebiliriz. Bütün türlerle kullanılabilir. Örnek:
string a=12.ToString();
IsInfinity() Parametredeki Single ya da Double türündeki veri sonsuz ise true, değilse false değeri üretir. Örnek:
Console.WriteLine(Single.IsInfinity(12));
IsNaN() Parametredeki Single ya da Double türündeki veri NaN (sayı olmayan) ise true, değilse false değeri üretir. Örnek:
Console.WriteLine(Single.IsNaN(12));
IsPositiveInfinity() Parametredeki Single ya da Double türündeki veri pozitif sonsuzsa true, değilse false değeri döndürür. Örnek:
Console.WriteLine(Single.IsPositiveInfinity(12));
IsNegativeInfinity() Parametredeki Single ya da Double türündeki veri negatif sonsuzsa true, değilse false değeri döndürür. Örnek:
Console.WriteLine(Single.IsNegativeInfinity(12));
GetNumericValue() Yalnızca Char yapısında bulunur. Char tipindeki parametre numerikse o sayıyı döndürür, numerik değilse negatif sayı döndürür. Geri dönüş tipi double'dır. Örnek:
Console.WriteLine(Char.GetNumericValue('5'));
Şimdi bir metot grubu inceleyelim. Aşağıdaki metotların tamamı yalnızca Char yapısında bulunur, tamamı static'tir ve tamamının iki farklı prototipi vardır. Birinci prototip:
Metot(char)
Bu metot prototipinde char türünden veri metoda sokulur.
Metot(string,int)
Bu metot prototipinde string içindeki int'te belirtilen indeks numarasındaki karakter metoda sokulur.
Bu metotların tamamının geri dönüş tipi bool'dur, belirtilen koşul sağlanmışsa true, sağlanmamışsa false değeri döndürür. Şimdi bu metotlar:
| Metot | Koşul |
|---|---|
| IsControl | Karakter kontrol karakteri ise |
| IsDigit | Karakter bir rakam ise |
| IsLetter | Karakter bir harf ise |
| IsLetterOrDigit | Karakter bir harf ya da rakam ise |
| IsLower | Karakter küçük harf ise |
| IsNumber | Karakter rakam ise |
| IsPunctuation | Karakter noktalama işareti ise |
| IsSeperator | Karakter boşluk gibi ayırıcı ise |
| IsSurroGate | Karakter Unicode yedek karakteri ise |
| IsSymbol | Karakter sembol ise |
| IsUpper | Karakter büyük harf ise |
| IsWhiteSpace | Karakter tab ya da boşluk karakteri ise |
Şimdi bunlara iki örnek verelim:
Console.WriteLine(Char.IsUpper('f'));
veya
Console.WriteLine(Char.IsUpper("deneme",3));
Şimdi iki metot inceleyelim. Bu metotların ikisi de yalnızca Char yapısında bulunur. Parametre olarak Char türünden veri alırlar. İkisi de statictir.
ToLower Parametresinden aldığı char'ı küçük harfe dönüştürüp char olarak tutar.
ToUpper Parametresinden aldığı char'ı büyük harfe dönüştürüp char olarak tutar.
Bu iki metot, parametre mantıksal olarak dönüştürülemeyecekse karakteri olduğu gibi tutar. Örneğin ToLower metodu parametre olarak 'h' veya '%' almışsa karakterde herhangi bir değişim yapmadan tutar.
Şimdi iki özellik inceleyelim. Bu iki özellik yalnızca Boolean yapısında bulunur ve False ve True stringlerini üretir. Örnekler:
string a=Boolean.FalseString;
string b=Boolean.TrueString;
Decimal türü
[değiştir]C# Decimal isminde diğer dillerden farklı bir veri türü barındırır. Değişkenler konusunu hatırlarsanız Decimal türü 16 bayt ile en fazla boyuta sahip olan türdü. Ancak işin enteresan tarafı kapasitesi çok da fazla değildi. Kapasitesi 8 byte olan double, decimaldan kat be kat fazla veri depolayabiliyordu. İşte şimdi decimal türünün sırrını göreceğiz.
Decimal türü System isim alanındaki Decimal yapısıyla temsil edilir. Decimal veri türünün bellekte saklanması diğer türlere nazaran biraz karmaşıktır. Bu yüzden bilgisayarların decimal türüyle işlem yapması biraz daha zordur. Decimal türünden bir nesne çok değişik yollarla tanımlanabilir. Örnekler:
Decimal a=new Decimal(20);
Gördüğünüz gibi Decimal yapısının bir yapıcı metodu varmış. Bu yapıcı metoda parametre olarak int, uint, long, ulong, float ve double türünden veri verilebilir. Başka bir tanımlama şekli
Decimal a=new Decimal(int alt, int orta, int ust, bool işaret, byte ondalık);
buradaki alt 128 bitlik (yani 16 baytlık) sayının ilk 32 bitini, orta sonraki 32 bitini, ust sonraki 32 bitini temsil eder. işaret true olursa sayı negatif, false olursa pozitif olur. Son olarak ondalık da sayının ondalık kısmını ayırmak için kullanılan noktanın sağdan kaçıncı basamakta olduğunu, diğer bir deyişle sayının ondalıklı kısmının kaç haneli olacağını belirtir. Şimdi bir örnek:
Decimal a=new Decimal(128755,0,0,false,2);
Bu koda göre a sayısı 1287.55'tir. Şimdi yalnızca Decimal yapısına özgü metotları inceleyelim:
ToByte(), ToSbyte, ToInt16, ToUInt16, ToInt32, ToUInt32, ToInt64, ToUInt64, ToSingle() ve ToDouble() metotlarının tamamı statictir, parametre olarak decimal türünden veri alırlar ve ilgili türdeki veriyi üretirler. Yani tür dönüşümü yaparlar. Bir örnek:
int a=Decimal.ToInt32(5m);
Şimdi decimal sayılar üzerinde çeşitli işlemler yapan metotlara geçelim:
d1 ve d2 decimal türünden iki veri olmak üzere
Decimal.Add(d1,d2); //d1 ve d2'nin toplamını decimal türünden tutar.
Decimal.Divide(d1,d2); //d1'in d2'ye bölümünü decimal türünden tutar.
Decimal.Multiply(d1,d2); //d1 ile d2'nin çarpımını decimal türünden tutar.
Decimal.Subtract(d1,d2); //d1-d2'nin sonucunu decimal türünden tutar. (çıkarma işlemi)
Decimal.Remainder(d1,d2); //d1'in d2'ye bölümünden kalanı decimal türünden tutar. (mod alma işlemi)
Decimal.Floor(d1); //d1'den büyük olmayan en büyük tam sayıyı decimal türünden tutar. (aşağı yuvarlama)
Decimal.GetBits(d1);
/*d1 için decimal sayı tanımlarken kullandığımız yapıcı işlevdeki beş parametreyi int türündeki bir dizi olarak tutar.*/
Decimal.Negate(d1); //d1'in negatifini tutar.
Decimal.Round(d1,sayi);
/*sayi int türünde olmalıdır. Bu metot ile d1'in ondalık kısmındaki hane sayısı sayi kadar kalır. Yani d1 12.53666 ve sayi
3 ise 12.537 tutulur. Son kaybedilen hane 5 ya da 5'ten büyükse son kalan hane 1 artılır. sayi 0 olursa d1 tam sayıya
yuvarlanmış olur.*/
Decimal.Truncate(d1); //d1'in tam sayı kısmını tutar. Herhangi bir yuvarlama yapılmaz.
Decimal sayıların normal sayılardan en önemli farklarından biri de şudur:
double a=2.00d;
decimal b=2.00m;
Console.WriteLine(a);
Console.WriteLine(b);
Bu program ekrana alt alta 2 ve 2,00 yazar. Yani normal sayılarda ondalık kısımdaki etkisiz sıfırlar sonuca yansımazken, decimal sayılarda yansır. Decimal sayılar daha çok ekonomi, bankacılık, para, muhasebe, vb. ile ilgili yazılım geliştirirken kullanılır.
System.Array sınıfı
[değiştir]Array sınıfındaki birçok metodu ve özelliği daha önce görmüştük. Burada yalnızca hatırlatma yapacağım ve birkaç yeni üye eleman göreceksiniz.
Özellikler
[değiştir]IsFixedSize Dizinin eleman sayısı sabitse true, değilse false değeri verir. Henüz eleman sayısı sürekli değişen dizileri görmediğimiz için sonucu daima true olacaktır. Örnek (dizi bir dizi olmak üzere):
Console.WriteLine(dizi.IsFixedSize);
IsReadOnly Dizideki elemanlar salt-okunur ise true, değilse false değeri verir. Henüz salt-okunur dizileri görmediğimiz için bunun sonucu da daima false olacaktır Örnek.
Console.WriteLine(dizi.IsReadOnly);
Length Dizideki eleman sayısını verir (int). Örnek:
Console.WriteLine(dizi.Length);
Rank Dizinin kaç boyutlu olduğunu verir (int). Örnek:
Console.WriteLine(dizi.Rank);
Metotlar
[değiştir]BinarySearch, Clear, Copy, CopyTo, GetLength, GetValue, Reverse, SetValue, Sort ve CreateInstance metotlarını diziler konusunda ayrıntılı olarak görmüştük. Burada henüz görmediğimiz bir metodu tanıtmak istiyorum. IndexOf metodu bir elemanın bir dizi içinde ilk görüldüğü indeksi verir. Örnek:
int[] dizi={1,6,9,23,5};
Console.WriteLine(Array.IndexOf(dizi,5));
Bu kod ekrana 4 yazar.
Tarih ve zaman işlemleri
[değiştir]Hatırlarsanız önceki konularımızın birinde Zaman sınıfı oluşturmuş ve iki zaman nesnesiyle çeşitli işlemler yapmıştık. Aslında şimdi göreceğimiz DateTime ve TimeSpan yapıları da benzer işleve sahip. DateTime yapısı belirli bir zamanı tutmaya yararken, TimeSpan ise zamanın miktarıyla ilgilenir. Şimdi bir örnek yapalım:
Console.WriteLine("En küçük: "+DateTime.MinValue);
Console.WriteLine("En büyük: "+DateTime.MaxValue);
Bu kod ekrana
En küçük: 01.01.0001 00:00:00 En büyük: 31.12.9999 23:59:59
çıktısını verecektir. Gördüğünüz gibi DateTime yapısına ait olan MinValue ve MaxValue özellikleri -tıpkı temel veri türlerinde olduğu gibi- DateTime yapısının tutabileceği en büyük ve en küçük verileri veriyor. Şimdi başka önemli özelliklere bakalım:
Now şimdiki saati, Today bugünü DateTime türünden verir. Örnek:
Console.WriteLine(DateTime.Now);
Console.WriteLine(DateTime.Today);
Bu kodun ekran çıktısı şuna benzer:
25.12.2008 16:52:25 25.12.2008 00:00:00
Aynı işlemler DateTime yapısı türünden nesne oluşturularak da yapılabilir. Örnek:
DateTime Tarih=new DateTime();
DateTime Zaman=new DateTime();
Tarih=DateTime.Today;
Zaman=DateTime.Now;
Console.WriteLine(Tarih);
Console.WriteLine(Zaman);
Şimdi de DateTime yapısına ait diğer güzel özellikleri inceleyelim, bunlar static değildir, yani DateTime türündeki nesnelerle erişilir
Date DateTime nesnesine ilişkin saat dışındaki bilgiyi verir. (DateTime)
Month DateTime nesnesinin ay bilgisini verir. (int)
Day DateTime nesnesinin gün bilgisini verir. (int)
Year DateTime nesnesinin yıl bilgisini verir. (int)
DayOfWeek DateTime nesnesinin haftanın kaçıncı günü olduğunu verir. (DayOfWeek enum sabiti)
DayOfYear DateTime nesnesinin yılın kaçıncı gününe denk geldiğini verir. (int)
TimeOfDay Geçerli gün için 00:00:00'dan itibaren ne kadar zaman geçtiğini TimeSpan nesnesi olarak verir. (TimeSpan)
Hour DateTime nesnesinin saat bilgisini verir. (int)
Minute DateTime nesnesinin dakika bilgisini verir. (int)
Second DateTime nesnesinin saniye bilgisini verir. (int)
Milisecond DateTime nesnesinin milisaniye bilgisini verir. (1 saniye=1000 milisaniye)(int)
Ticks DateTime nesnesindeki tarih ile 1 Ocak 0001 00:00:00 arasında kaç nanosaniye olduğunu verir. Bir nanosaniye, saniyenin 10 milyonda biridir. (long)
Bir DateTime nesnesini şu yöntemlerle oluşturabiliriz.
DateTime nesne=new DateTime(long tick_sayısı);
DateTime nesne=new DateTime(int yıl,int ay,int gün);
DateTime nesne=new DateTime(int yıl,int ay,int gün,int saat,int dakika,int saniye);
DateTime nesne=new DateTime(int yıl,int ay,int gün,int saat,int dakika,int saniye,int milisaniye);
Gördüğünüz gibi DateTime yapısının aşırı yüklenmiş birçok yapıcı metodu varmış. Şimdi bir örnek yapalım.
DateTime a=new DateTime(2008,12,25);
Console.WriteLine(a.Day);
Bu kod ekrana 25 yazar. Gelelim TimeSpan yapısına. TimeSpan yapısı belirli bir tarih tutmaktan ziyade zamanın miktarı ile ilgilenen bir yapıdır. İki DateTime nesnesini birbirinden çıkarırsak sonuçta bir TimeSpan nesnesi oluşur. Örnek:
DateTime Gun1=new DateTime(2008,5,5);
DateTime Gun2=new DateTime(2008,12,3);
TimeSpan fark=Gun2-Gun1;
Console.WriteLine(fark.Days);
Bu program ekrana 212 yazar. Evet gerçekten de iki tarih arasında 212 gün fark vardır. Ayrıca gördüğünüz gibi TimeSpan yapısının Days adında static olmayan bir özelliği varmış. Bunun gibi Hours, Minutes, Seconds ve Milliseconds özellikleri de vardır. Bu özelliklerin tamamı ilgili TimeSpan nesnesinin ilgili kısmını döndürür. Tamamının geri dönüş tipi inttir. Yine TimeSpan yapısının TotalDays, TotalHours, TotalMilliseconds, TotalMinutes ve TotalSeconds özellikleri ise ilgili TimeSpan nesnesini ilgili cins türünden döndürür. Yani cinsler arasında dönüşüm yapılır. Bunların geri dönüş tipi ise double'dır.
TimeSpan GunSayisi=new TimeSpan(45,0,0,0);
DateTime nesne=DateTime.Today+GunSayisi;
Console.WriteLine(nesne);
Bu kod bugünden 45 gün sonrasını ekrana yazar. Başka bir örnek
TimeSpan DakikaSayisi=new TimeSpan(0,0,23,0);
DateTime nesne=DateTime.Now+DakikaSayisi;
Console.WriteLine(nesne);
Bu kod ise şimdiden 23 dk. sonrasını ekrana yazar. <, >, >=, <=, ==, != operatörlerini iki DateTime nesnesini ya da iki TimeSpan nesnesini kıyaslamak için kullanabiliriz. Ayrıca DateTime yapısına ait olan AddDays() metodu DateTime türünden bir nesneye gün ekletip tutmak için kullanılır. Örnek:
DateTime a=new DateTime(2008,1,1);
Console.WriteLine(a.AddDays(65));
Bu program ekrana 06.03.2008 00:00:00 yazar. Ancak burada tabii ki a nesnesinin değeri değişmez. AddDays() metodunun geri dönüş tipi DateTime'dır.
BitConverter sınıfı
[değiştir]Alt seviye programlama yaparken genellikle verilerin kendileriyle değil, baytlarıyla ilgileniriz. İşte BitConverter sınıfı bu işlemleri yaparken işimize yarayacak üye elemanları içerir. BitConverter sınıfında bir tane özellik vardır. Bu özellik IsLittleEndian özelliğidir. Sistemimizin verileri hangi mimariye göre sakladığını kontrol eder. Bilgisayarlar verileri iki çeşit mimariye göre saklarlar.
- Düşük anlamlı byte ilk sırada
- Yüksek anlamlı byte ilk sırada
Eğer düşük anlamlı byte ilk sıradaysa bu mimariye "Little Endian", yüksek anlamlı byte ilk sıradaysa bu mimariye de "Big Endian" denir. IsLittleEndian özelliği mimari "Little Endian" ise true, "Big Endian"sa false değeri üretmektedir. Intel ve AMD'nin bütün işlemcileri Little Endian mimarisine göre çalışmaktadır. Yani bu durumda ev bilgisayarlarının %90'ının bu mimariden olduğunu söyleyebiliriz. Little Endian sistemlerde verilerin belleğe önce düşük anlamlı baytları, sonra yüksek anlamlı baytları yazılır. Bellekten okuma yapılırken de aynı sıra gözetilir. Big Endian sistemlerde ise bu durumun tam tersi söz konusudur. Aşağıdaki kodla sisteminizin hangi mimariyle çalıştığını öğrenebilirsiniz.
if(BitConverter.IsLittleEndian)
Console.WriteLine("Little Endian");
else
Console.WriteLine("Big Endian");
Gördüğünüz gibi IsLittleEndian static bir metot. Gelelim BitConverter sınıfının en önemli metoduna. GetBytes() metodu bool, char, int, long, double, short, uint, ulong, ushort türünden verilerin bytelarını byte türünden bir dizi olarak tutar. Örnek:
int a=258; //00000000 00000000 00000001 00000010
byte[] dizi=BitConverter.GetBytes(a);
foreach(byte b in dizi)
{
Console.WriteLine(b);
}
Benim bilgisayarımda bu program ekrana alt alta 2, 1, 0 ve 0 yazdı. Sizin bilgisayarınızda sonuç, bilgisayarınızın mimarisine göre benimkiyle aynı veya ters sırada olabilir. 10'un onluk sistemdeki karşılığı 2, 1'in ise 1'dir. Diğer iki 0'sa int türünün bellekte kapladığı diğer iki baytı temsil eder. int 32 bitlik (4 baytlık) bir veri tipidir. Eğer a değişkeninin türü short (16 bit-2 bayt) olsaydı ekrana sadece 2 ve 1 yazılacaktı. BitConverter sınıfına ait static bir metot grubu vardır. Bu metot grubu herhangi bir byte dizisini temel veri türlerine dönüştürür, yani GetBytes() metodunun tersini yaparlar. statictirler, iki parametre alırlar. Örnek olarak GetBytes() metodunun sonucunu kullanalım:
byte[] dizi={2,1,0,0};
Console.WriteLine(BitConverter.ToInt32(dizi,0));
Bu kod ekrana -mimariniz Little Endian ise- 258 yazar. Burada dizi dizisini 0. indeksten itibaren inte dönüştürüp ekrana yazdırdık. BitConverter sınıfının ToInt32'ye benzer ToBoolean(), ToChar(), ToInt16(), ToInt32(), ToInt64(), ToSingle(), ToDouble(), ToUInt16(), ToUInt32() ve ToString() metotları da vardır. Eğer dizi stringe dönüştürülürse bu örneğimizde ekrana 02-01-00-00 yazar. Bütün bu metotlar bilgisayarınızın mimarisine göre çalışırlar. Başka bir örnek verelim:
byte[] dizi={2,1};
Console.WriteLine(BitConverter.ToInt32(dizi,0));
Bu program çalışma zamanı hatası verir. Çünkü 32 bitlik (4 bayt) Int32 türüne eksik bir dizi verilmiştir. Bu dizi Int32 türüne dönüştürülemez. Başka bir örnek:
byte[] dizi={2,1};
Console.WriteLine(BitConverter.ToInt16(dizi,0));
Bu kod hata vermez. Çünkü Int16 türünün kapasitesi 16 bittir (2 bayt). Dolayısıyla da Int16 türüne iki elemanlı bir byte dizisi verilmesi yeterlidir. Başka bir örnek:
byte[] dizi={2,1,5,8};
Console.WriteLine(BitConverter.ToInt16(dizi,0));
Bu program hata vermez. Yalnızca ilk iki bayt (0. ve 1. indis) hesaplamaya girer ve sonuç Little Endian mimarisinde 258 çıkar.
Buffer sınıfı
[değiştir]Buffer sınıfıyla tür bilgisinden bağımsız işlemler yaparız. Buffer sınıfı verilerin değerlerine değil baytlarına bakar.
BlockCopy() metodu
[değiştir]Prototipi şöyledir:
static void BlockCopy(Array kaynak, int kaynak_indeks, Array Hedef, int Hedef_indeks, int adet)
Bu prototip kaynak dizisinin kaynak_indeks numaralı indeksinden itibaren adet kadar elemanını Hedef dizisine Hedef_indeks numaralı indeksten itibaren kopyalar. Ancak kopyalama türden bağımsız, bayt bayt yapılır. Örnek:
byte[] kaynak={1,2,3,1}; //00000001 , 00000010 , 00000011 , 00000001
short[] hedef=new short[4]; //0000000000000000 , 0000000000000000 , 0000000000000000 , 0000000000000000
Buffer.BlockCopy(kaynak,0,hedef,0,4);
/*hedef dizisinin yeni hâli: 0000001000000001 , 0000000100000011 , 0000000000000000 , 0000000000000000*/
foreach(short a in hedef)
Console.WriteLine(a);
Bu program, mimarimiz Little Endian ise ekrana alt alta 513, 259, 0 ve 0 yazacaktır. Burada derleyici her elemanı bellekte 1 bayt yer kaplayan kaynak dizisinin elemanlarını her elemanı bellekte 2 bayt kaplayan hedef dizisine olduğu gibi kopyaladı. Tahmin edersiniz ki kaynak dizisinin iki elemanı hedef dizisinin bir elemanına tekabül eder ve iki kaynak elemanı birleşip bir hedef elemanı oluşturur. Benim sistemim Little Endian olduğu için derleyici burada karşılaştığı ilk baytı düşük anlamlı bayta, ikinci baytı da yüksek anlamlı bayta kopyaladı.
ByteLength() metodu
[değiştir]Kendisine parametre olarak verilen bir dizideki toplam bayt sayısını bulur. Örneğin kendisine parametre olarak gönderilen 3 elemanlı short türünden bir dizi sonucu 6 sayısı gönderir. Geri dönüş tipi inttir. Örnek:
short[] dizi=new short[4];
Console.WriteLine(Buffer.ByteLength(dizi));
GetByte() metodu
[değiştir]Prototipi şu şekildedir:
static byte GetByte(Array dizi,int a)
dizi dizisinin a. baytını verir. Örnek:
byte[] dizi={0,3,2,1,4};
Console.WriteLine(Buffer.GetByte(dizi,3));
Bu kod 1 değerini döndürür. Eğer dizinin tipi byte değil de short olsaydı işler değişirdi. Çünkü o zaman hem sıfırla beslenen baytlar da hesaba katılırdı ve hem de bilgisayarımızın mimarisi sonucu etkilerdi. Bu durumu örneklendirelim:
short[] dizi={0,3,2,1,4};
// 0000000000000000 0000000000000011 0000000000000010 0000000000000001 0000000000000100
Console.WriteLine(Buffer.GetByte(dizi,4));
Bu kod Little Endian mimarisinde ekrana 2 yazar. Mimari Big Endian olsaydı ekrana 0 yazacaktı. Çünkü Little Endian mimarisinde verilerin önce düşük anlamlı baytı okunur/yazılır. Big Endian mimarisinde ise tam tersi söz konusudur.
SetByte() metodu
[değiştir]Prototipi şu şekildedir:
static void SetByte(Array dizi,int a,byte deger)
a. baytı deger olarak değiştirir. Örnek:
byte[] dizi={2,1,4};
Buffer.SetByte(dizi,1,5);
Console.WriteLine(dizi[1]); //Ekrana 5 yazılır.
Yine eğer dizinin türü byte değil de int olsaydı işler değişirdi.
GC (Garbage Collection) sınıfı
[değiştir]Garbage Collection mekanizmasının normalde otomatik olarak yaptığı işleri bu sınıftaki üye elemanlar sayesinde manuel olarak da yapabiliriz. Şimdi üye elemanları inceleyelim:
GC.Collect();
bu metot Garbage Collection mekanizmasının devreye girmesini, dolayısıyla da eğer bellekte gereksiz nesne varsa silinmesini sağlar. Programın herhangi bir anında toplam tahsis edilmiş bellek miktarını byte cinsinden görmek içinse GC sınıfının GetTotalMemory(bool) metodu kullanılır. Eğer parametre true olarak girilirse bellek miktarı hesaplanmadan önce GC mekanizması başlatılarak bellekteki gereksiz nesneler silinir. Eğer parametre false olarak girilirse direkt bellek miktarı hesaplanır. Örnek:
Console.WriteLine(GC.GetTotalMemory(true));