Hafıza Bölgesinde Stream Kullanımı

Takdir edersiniz ki en hızlı stream verisi hafızada bulunan stream verisidir. Yani bir hafıza stream nesnesi her halukarda okuma-yazma işlemleri dosya ve veritabanından hızlı çalışacaktır. Bu durumda eğer bir stream ile çok fazla okuma-yazma işlemleri gerçekleştiriliyorsa, ilk başta bir hafıza streami kullanılmalı ve stream ile işimiz bitip son durumu kaydetmek istediğimizde bu hafıza streaminden başka bir stream nesnesine aktarım yapılması en doğru işlem olacaktır. Aynı şekilde stream verisi üzerinde çok miktarda Seek işlemi yani stream işaretçisinin pozisyonunu değiştirme işlemi gerçekleştiriyorsanız, bu durumda yine stream verisinin tamamını bir hafıza bölgesine aktarmalısınız.

Aşağıdaki örneğe göz atalım:

procedure TForm1.Button1Click(Sender: TObject);
var
  Mem: TMemoryStream;
  writebuffer, readbuffer: AnsiString;
begin
  Mem := TMemoryStream.Create;
  try
    writebuffer := 'Diyezon';
    Mem.WriteBuffer(writebuffer[1], Length(writebuffer));
    Mem.Position := 0;
    SetLength(readbuffer, Length(writebuffer));
    Mem.ReadBuffer(readbuffer[1], Length(readbuffer));
    ShowMessage(readbuffer);
  finally
    Mem.Free;
  end;
end;

Gördüğünüz gibi TMemoryStream’in Create oluşturucusu hiç bir parametre almıyor. Burada ekstradan yazma işleminden sonra Position := 0 ile stream işaretçisini başa getiriyoruz. Çünkü yazma işleminin sonunda işaretçi pozisyonu kayacaktır. Okuma işlemini yapabilmemiz için yine işaretçiyi başa getirip okutuyoruz. Aynı işlemi Seek metodu ile de yapabiliriz. Ek bir not olarak, Seek metodu Position’dan daha hızlı çalışmaktadır.

Hafıza streami kullanmak, oluşturulması esnasında hiç bir parametre gerektirmediğinden, diğerlerine nazaran daha kolay ve pratiktir. Bu yüzden yapacağımız yüksek yoğunluktaki stream işlemlerini TMemoryStream ile yapmamız bizim yararımıza olacaktır. Özellikle Seek işlemlerinde yani pozisyon değiştirme işlemlerinde hafızadan faydalanmak önemli bir performans artışına sebep olacaktır.

Stream’lerin Aktarımı ve Kopyalanması

Stream verileri ile okuma-yazma işlemlerinden sonra yapılan en önemli işlem de bir stream’in başka bir stream verisi üzerine aktarılmasıdır. Mesela bir dosyayı hafızaya almak isteyebilirsiniz. Veya hafızadaki bir veriyi veritabanına aktarmak isteyebilirsiniz. Bu durumda her stream fonksiyonunda bulunan CopyFrom metodu kullanılır.

Aktarım işleminde basit bir metodu kullanmaktan öte, bir noktaya dikkat edilmesi şarttır. CopyFrom metodu ve bunun gibi bir çok metod, stream işaretçisinin bulunduğu pozisyondan itibaren işlemeye başlarlar. Aşağıdaki örneğe bir göz atalım:

procedure TForm1.Button1Click(Sender: TObject);
var
  Mem: TMemoryStream;
  F: TFileStream;
  //Mem, F: TStream; şeklinden de yazılabilirdi...
  buffer: AnsiString;
begin
  Mem := TMemoryStream.Create;
  F := TFileStream.Create('c:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    buffer := 'Diyezon';
    Mem.WriteBuffer(buffer[1], Length(buffer));
    //karakter katarımızı hafızaya aldık.

    Mem.Position := 0; //Önemli!!!!

    F.CopyFrom(Mem, Mem.Size);
  finally
    Mem.Free;
    F.Free;
  end;
end;

İlk yaptığımız işlem bir karakter dizisini hafızaya almak oldu. Ardında bu hafıza streamini dosya üzerine kopyaladık. Burada dikkat edilmesi gereken nokta Position := 0 kısmıdır. Hafızaya karakter dizisinin yazılmasından sonra stream işaretçisi sona kayar. Böylece sonrasında gelen CopyFrom gibi metodlar bu pozisyondan itibaren işlem yapmaya başlarlar. İşaretçi sonda olduğu için CopyFrom kopyalayamaz ve bir istisna hatası çıkarır. İşte bunu önlemek için işaretçiyi başa alıyoruz ve hafıza streaminin tamamını dosya üzerine aktarıyoruz.

Kısacası CopyFrom metodu, kopyalanacak olan streamin işaretçi pozisyonundan itibaren, sizin belirlediğiniz uzunluk kadar stream’den okur ve diğer streame aktarır. Tek dikkat etmemiz gereken nokta kopyalayacağımız kaynak stream’in mevcut işaretçi poziyonudur. Eğer işaretçi poziyonu sonda ise CopyFrom kaynak stream’den veri okuyamayacak ve hata meydana gelecektir.

Nesneler ve Bileşenleri Okuyup Yazmak

Nesneleri, stream üzerine yazmak denildiğinde ilk akla gelen record verileri gibi okuyup yazmaktır. Halbuki nesneler, her ne kadar benzese de, record verilerinden çok farklıdır ve karışıktır. Bu yüzden direk olarak bir sınıf ya da nesne stream üzerine aktarılamaz. Ancak sizin belirlediğiniz kısımları ayrı ayrı, önceden öğrendiğimiz okuma-yazma işlemleri ile halledebilirsiniz.

Fakat bileşenlerde durum biraz farklıdır. Daha doğrusu TPersistent sınıfından türeyen bütün sınıflarda durum biraz farklıdır. TStream sınıfında, bileşenlerin özelliklerini stream üzerine alabilmek için ReadComponent ve WriteComponent metodları mevcuttur. Bu metodlar sayesinde bileşenler stream verileri üzerine aktarılabilirler. Ki, Delphi IDE’si bunu bol bol kullanmaktadır. Eğer bileşen yazımı ile ilgili 3 bölümlük makaleyi okumuş iseniz bileşenlerde bir özelliğe kaydedebilme özelliği kazandırmıştık. Yani özelliğin kaydedebilme özelliği yoksa stream üzerine aktarılamazlar. Özelliklerin kaydedilebilme işlemine burada değinmeyeceğiz. Ama isterseniz, bileşen yazımı ile ilgili makaledeki kolleksiyon ve binary özellikler kısmına göz atabilirsiniz.

Bileşenlere bu özelliği kazandıran TPersistent sınıfıdır. TPersistent sınıfı ile ilgili daha fazla bilgi alabilmek için yardım dosyalarına göz atabilirsiniz.

Yeni bir form açalım ve bir button ekleyelim. Buttonun OnClick olayına aşağıdaki kodları yerleştirelim:

procedure TForm1.Button1Click(Sender: TObject);
var
  Mem: TMemoryStream;
  F: TFileStream;
begin
  Mem := TMemoryStream.Create;
  F := TFileStream.Create('c:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    Mem.WriteComponent(Button1);

    Mem.Position := 0; //Önemli!!!!

    F.CopyFrom(Mem, Mem.Size);
  finally
    Mem.Free;
    F.Free;
  end;
end;

Bu programı çalıştırıp button’a basarsanız, C: bölümde deneme.txt isimli bir dosya göreceksiniz. Bu dosyayı bir hex editor ile açıp kontrol edebilirsiniz. Ama dosyaya baktığınızda TButton’a ait tüm özelliklerin olmadığını göreceksiniz. Çünkü burada sadece bileşenin değişmiş olan özellikleri kaydedilir. Her özellik bir default değere sahiptir. Ve bu değer değişmiş ise, WriteComponent metodu bunu stream üzerine yazacaktır.

Şimdi bu dosyadaki Button1 bileşenini okutalım ve form üzerinde oluşturalım. Bunun için yeni bir uygulama açalım ve içinde Button1 isimli bir button olmamasına özen gösterelim. Çünkü birazdan bu bileşeni dosyadan biz oluşturacağız.

Form üzerine bir button ekleyelim ve ismine Button2 diyelim ve Caption olarak "bileşeni dosyadan oku" gibi bir şey yazalım. Ardından buttonun OnClick olayına aşağıdaki kodları yerleştirilem:

procedure TForm1.Button2Click(Sender: TObject);
var
  F: TFileStream;
  Button1: TButton;
begin
  F := TFileStream.Create('c:\deneme.txt', fmOpenRead or fmShareDenyNone);
  try
    Button1 := TButton.Create(Self);
    Button1.Parent := Self;
    F.ReadComponent(Button1);
  finally
    F.Free;
  end;
end;

Programı çalıştırıp Button2′ye tıklarsanız form üzerinde önceden kaydettiğimiz Button1 bileşenini göreceksiniz.

Önceden de dediğimiz gibi TPersistent olmayan nesneleri direk olarak stream olarak yazmak ve okumak mümkün değildir. Fakat kendinizin tanımlayacağı formatta, stream’den okuma ve stream’e yazma gibi fonksiyonlar ile nesnelerinize bu özelliği kazandırabilirsiniz. Zaten TPersistent sınıfının da yaptığı işlem budur. TPersistent sınıfına fazla girmek istemiyorum, fakat merakı olanlar TPersistent ile beraber TFiler, TReader gibi sınıflara yardımdan göz atabilirler.

Ek olarak bu konuda söyleyebileceğim bir tecrübem de şudur. İster VCL içinde olsun, ister başka bir yerden bulacağınız bir bileşen veya bir sınıf olsun, eğer stream ile çalışıyorlarsa şu 4 metod bunlarda bulunacaktır. LoadFromStream, LoadFromFile, SaveToStream, SaveToFile.

Buna tecrübe dedim çünkü literatürde bu metodlar aynı isim ve parametrelerle bulunacak diye bir şart yoktur. Fakat VCL’de bulunan bileşenlerde bolca kullanılan bu metodlar, diğer 3. parti bileşen ve sınıflarda da kolaylık ve alışkanlık olması açısından isimlerini ve yapılarını korumuştur. Eğer bir sınıf stream ile işlem yapıyorsa bilinki bu sınıfta, yukarıda bahsettiğimiz 4 metod bulunacaktır.

Sizler de yazacağınız sınıflarda bu metodları aynı isim ve yapıda kullanırsanız, sınıfınızı ya da bileşeninizi kullanacak olan kişiler zorlanmayacaktır. Bu metodların tanımlamasını VCL’de herhangi bir sınıf ya da bileşenin tanımlamasından kopyala yapıştır ile alabilirsiniz. Sadece burada değişecek olan kısım LoadFromStream ve SaveToStream metodlarıdır. Bu metodların içeriğini kendinize göre yeniden oluşturmalısınız.

Resource Verilerini Okuyup Yazmak

Resoruce verileri, kısaca açıklamak gerekirse, exe ya da dll dosyanız içine gömülen verilerdir. Bu veriler resim, yazı, icon, form olabileceği gibi herhangibir formatta stream verisi de olabilir.

Resource dosyaları ".RC" uzantılı bir dosyadan herhangi bir resource compiler ile derlenir. Bu derleme sonucunda ".RES" uzantılı bir dosya oluşacaktır. RES dosyalarını istediğiniz bir resource derleyicisi ile oluşturabilirsiniz. Çünkü bu res dosyaları derleyiciden bağımsızdır. Fakat RC dosyasının grameri değişiklik gösterebilmektedir. Biz bu makalede resource verilerini derlemek için delphi ile beraber gelen brcc32 derleyicisini kullanacağız. İsterseniz Visual Studio veya benzeri bir başka resource manager ile RES dosyaları oluşturabilirsiniz. Eğer Delphi 2009′a sahip iseniz, yeni "Resource Manager" ile daha rahat resource dosyaları oluşturabilirsiniz.

Delphi 2009′da menüden Project/Resources… altından ulaşabilrsiniz.

Biz elimizde Delphi’den başka bir şey olmadığını düşünerek işe koyulalım ve resource dosyamızı oluşturalım.

Notepad ile yeni bir yazı dosyası oluşturalım ve içine bir yerlerden uzun bir paragraf bulup yapıştırılım. Bunu yazi.txt ismi ile kaydelim. Aynı klasöre başka bir yazı dosyası daha oluşturalım ve içine aşağıdakileri yazalım:

yazi RCDATA yazi.txt 

Daha sonra bu dosyayı "yazi.rc" ismi ile aynı klasöre kaydedelim.

Burada ilk yazdığımız kelime resource’a verdiğmiz isimdir. İleride bu isme göre resource verimizi kullanacağız. İkinci kısımda RCDATA ile verimizin tipini belirledik. Burada RCDATA’nın dışında BITMAP, CURSOR ve ICON gibi ayrı ayrı tipler kullanılabilir. Bunların tam listesi için internette araştırma yapabilirsiniz. (http://msdn.microsoft.com/en-us/library/aa381043(VS.85).aspx). En sondaki kısım ise resource olarak kullanacağımız verimizin dosyasını giriyoruz.

Başlat/Çalıştır ile cmd yazıp entere basıp komut satırına geçelim. Buradan dosyaları kaydettiğimiz klasöre geçelim(msdos biliyorsunuzdur herhalde ). Ardından aşağıdaki komutu yazıp entere basalım.

brcc32 yazi.rc

Bir problem oluşmadı ise aynı klasörede yazi.res isimli bir dosya göreceğiz.

Bu işlemlerden sonra Delphi’ye geçip yeni bir uygulama açalım. Yeni uygulamamızı .res dosyalarını oluşturduğumuz klasöre kaydedelim. Şimdi az önce oluşturduğumuz res dosyasını programımız içine gömmek için gerekli işlemleri yapalım.

Unit1′in kodlarını açalım ve uygun bir boşluğa aşağıdaki derleyici direktifini girelim:

{$R yazi.res}

Programızı derlediğimizde bu res dosyasında buluna bütün veriler, resource verisi olarak programımıza gömülecektir. İsterseniz bunu ResHack gibi herhangi bir resource yöneticisi ile kontrol edebilirsiniz.

Şimdi bu gömülmüş olan veriyi okumamız gerekiyor diyelim. Mesela az önce programımız içine gömdüğümüz yazi.txt dosyasını bir memo içine alalım ve gösterelim.

Form üzerine bir adet memo bileşeni ve bir adet button ekleyelim. Button’unun OnClick olayına şunları yazalım:

var
  Res: TResourceStream;
begin
  Res := TResourceStream.Create(hInstance, 'yazi', RT_RCDATA);
  Memo1.Lines.LoadFromStream(Res);
end;

Programı çalıştırıp button’a basalım. Bir sorun çıkmadı ise memo bileşeninde yazi.txt dosyasındaki yazılı olan paragrafı göreceğiz.

Bu yaptığımız örnek ile görüyoruz ki; bir TResourceStream nesnesi, herhangi bir exe veya dll içindeki resource verilerine erişebiliyor. Create oluşturucusunda gördüğümüz ilk parametre resource verisini nereden çekeceğimizi belirliyor. Buna daha sonra değineceğiz. İkinci parametre olarak erişeceğimiz resource verisinin ismidir. Bunu RC dosyasını hazırlarken görmüştük. Aynı şekilde son parametre de RC dosyasında belirlenmişti. Bu son parametre ile resource verisinin tipini belirliyoruz. Tek fark olarak baş tarafına RT_ ön ekini getiriyoruz.

Sonraki işlem ise memo bileşenin Lines özelliğine streamdeki veriyi aktarıyoruz.

Bu mantığı kullanarak istediğiniz türde veriyi resource olarak gömebilir ve program çalışması anında kullanabilirsiniz. Bu yaptığımız örnek sadece mevcut programdan verileri çekebilir. Fakat başka bir dll ya da exe’den veri çekmemiz gerektiğinde ne yapacağız?

İşte bu durumda hInstance olarak girdiğimiz parametre değişecektir. Çünkü burada girdiğimiz parametre veriyi nereden çekeceğimizi daha doğrusu resource verisinini nerede olduğunu belirler.

Her program(exe, dll, ocx, ..) çalıştırıldığında windows tarafından bir handle numarası ile ilişkilendirilir. Delphi’de bu handle numarasına erişebilmek için hInstance isimli global bir değişkeni kullanıyoruz. Bu yüzden Create oluşturucusunda mevcut çalışan programımızın handle numarasını buraya birinci parametre olarak girdik.

Peki başka bir exe veya bir dll’in handle numarasını nasıl alırız?

Bunun için cevabımız LoadLibrary fonksiyonudur. Bu fonksiyon ile çağırdığımız herhangi bir program geçici olarak hafızaya yüklenir ve windows tarafından bir handle atanır. Bu handle numarası ise çıkış olarak döner. Eğer yükleme işlemi başarısız ise handle numarası 0 olarak dönecektir. Mesela yukarıda yaptığımız işlemleri bir dll içinden almaya kalkarsak nasıl yapacaktık?

var
  Res: TResourceStream;
  DLLHandle: THandle;
begin
  DLLHandle := LoadLibrary('resource.dll');
  if DLLHandle <> 0 then
  begin
    Res := TResourceStream.Create(DLLHandle, 'yazi', RT_RCDATA);
    Memo1.Lines.LoadFromStream(Res);
  end;
end;

Aynı işlemi exe, ocx gibi diğer çalıştırılabilir formatlar içinde yapabilirsiniz.

Artık herhangi bir veriyi exe içine gömüp okumayı öğrendik. Şimdi de bu işlemin bir benzerini veritabanlarında yapalım.

Veritabanında Stream Kullanımı

Artık buraya kadar öğrendiklerimizle herhangi bir stream verisini okuyup yazabiliriz. Burada yapacağımız işlem de pek farklı olmayacak. Bu yüzden hemen konuya girelim ve kısaca veritabanlarında nasıl stream kullanıldığını görelim.

Veritabanlarında bulunan tablolarda stream verilerini saklamak için alanımız BLOB tipinde olmalıdır. BLOB tipindeki alanlar binary veriler tutabilir. Fakat indeksli ve üzerinde çok arama tarama işlemleri yapılan bir tablomuz var ise bu BLOB alanlar veritabanı işlemlerini yavaşlatacaktır. Bu yüzden bu BLOB alanları başka bir tablo üzerine taşımak performansı artıracaktır.

Tabloda bulunan bir BLOB alana veri yazmak ve bu alandan veri okumak için TBlobStream nesneleri kullanılır. Kullanımı aşağıdaki gibidir:

var
  blob: TBlobStream;
begin
  blob := tblBirTablo.CreateBlobStream(tblBirTablo.FieldByName('BlobAlan'), bmReadWrite);
  try
    blob.Position := 0;
    blob.ReadBuffer(...);
    blob.WriteBuffer(...);
    ......
  finally
    blob.Free;
  end;
end;

Genel manada kullanım bu şekildedir fakat daha başka yöntemler ile de blob stream oluşturulabilir. Bu örnekte BlobAlan isimli bir alan hem okuma hem de yazma işlemleri için stream olarak bizim blob stream nesnemize atanmıştır. Burada sadece okuma işlemleri yapacaksak bmRead, sadece yazma işlemi yapacaksak bmWrite parametrelerini kullanmalıyız.

TStream’i .NET ve Delphi 2009′da Kullanmak

TStream sınıfı Delphi’nin bileşen mantığının temelini oluşturmaktadır. Delphi, .NET ortamına taşınırıken haliyle TStream sınıfı da ufak farklılıklar ile .NET ortamına taşınmıştır. Benim burada bahsedeceğim konu sadece bu küçük farklılıklar olacaktır. Geri kalan işlemlerde buraya kadar öğrendiğiniz bilgiler fazlasıyla yetecektir.

.NET ortamında Pointer işlemleri kullanılmadığından TStream sınıfı ve alt sınıfları için bir değişikliğe gidilmesi şarttı. Bu yüzden, TStream sınıfı .NET ortamına taşındığında Pointer işlemleri yerine, bu işlemlerin yerini tutan belirgin ve basit tipler için ayrı ayrı metodlar hazırlandı.

Mesela hatırlarsanız normalde TStream sınıfında bulunan ReadBuffer ile bir srting veri yazdığımızda string’i pointer olarak type cast yapıp parametre olarak giriyorduk. .NET’de pointer kullanmadığımız için ReadBuffer yerine artık aynı isimli ve sadece özel tipler için özdeşleştirilmiş bir metodumuz var. Bu metodu kullanarak rahat bir şekilde pointer kullanmadan işlemlerimizi aynı şekilde yapabiliriz. Tabi bu daha önce yaptığımız Win32 TStream sınıfına göre çok rahatlık getirmektedir. Bu da hiç şüphesiz .Net’in getiridiği rahatlıklardan birisi.

ReadBuffer ver WriteBuffer metodlarından bir kaçındaki değişlikliklere göz atalım:

    //TBytes
    procedure ReadBuffer(Buffer: TBytes; Count: Longint); overload;
    procedure WriteBuffer(const Buffer: TBytes; Count: Longint); overload;

    //Boolean
    procedure ReadBuffer(var Buffer: Boolean); overload;
    procedure WriteBuffer(const Buffer: Boolean); overload;

    //Integer
    procedure ReadBuffer(var Buffer: Integer); overload;
    procedure WriteBuffer(const Buffer: Integer); overload;
    procedure WriteBuffer(const Buffer: Integer; Count: Longint); overload; platform;

    //Char
    procedure ReadBuffer(var Buffer: Char); overload;
    procedure ReadBuffer(var Buffer: Char; Count: Longint); overload; platform;
    procedure WriteBuffer(const Buffer: Char); overload;
    procedure WriteBuffer(const Buffer: Char; Count: Longint); overload; platform;

    // AnsiChar
    procedure ReadBuffer(var Buffer: AnsiChar); overload;
    procedure ReadBuffer(var Buffer: AnsiChar; Count: Longint); overload; platform;
    procedure WriteBuffer(const Buffer: AnsiChar); overload;
    procedure WriteBuffer(const Buffer: AnsiChar; Count: Longint); overload; platform;

Tam liste için lütfen Borland.Vcl.Classes unitinde bulunan TStream sınıfına ya da yardıma göz atınız.

Gördüğünüz gibi aynı ReadBuffer metodu, overload yöntemi ile bir çok kez tanımlanmış. Biz bunlardan ihtiyacımız olanı seçip kullanacağız. Boolean ve Integer yazımı için tek bir adet parametre gerektirdiğine dikkat ediniz.

Diyelimki stream üzerine yazdıracağımız veya okuyacağımız veri çeşidine uygun bir metod bulunmamakta. Bu durumda verimizi bir byte dizisi gibi düşünüp ona göre davranacağız. Bu durumda verimizi TBytes’a yani "array of Byte" tipinieçevirmemiz gerekmektedir. Bunun için herhangi bir for döngüsü tanımlayarak bu işlememizi yapabiliriz.

Integter ile ilgili metodlara bakarsanız, en sonda fazladan Count parametresi alan bir metod yerleştirdim. Bütün metod çeşitlerinde alternatif olarak bu ikininci parametreye sahip olan metodlar mevcuttur. Bu parametreyi mesela Integer için normalde 4 byte ayrılmasına rağmen siz 10 byte yer ayırmak istediğinizde kullanablirsiniz.

Bu metodlara baktığınızda string ile ilgili bir özel metodun olmadığını farkedeceksiniz. Peki string veriyi nasıl yazacağız?

Bu durumda veriyi hangi encode’da yazacağımız veya okuyacağımız önemli. Veriyi istersek UTF8 formatında istersek UTF16 veya ANSI olarak okuyabilir ve yazabiliriz. Bu durumda string verimizi byte dizisine çeviren veya byte dizisini string verisine çeviren bir yönteme ihtiyacımız var. Aşağıdaki örneğe göz atalım:

var
  Mem: TMemoryStream;
  s: string;
  bytes: TBytes;
begin
  Mem := TMemoryStream.Create;
  try
    s := 'diyezon';
    bytes := Encoding.UTF8.GetBytes(s); //uses'a System.Text eklenmeli
    Mem.WriteBuffer(bytes, Length(bytes));
    Mem.Position := 0;
    Memo1.Lines.LoadFromStream(Mem);
  finally
    Mem.Free; //Yapmanıza gerek yok.
  end;
end;

Gördüğünüz gibi string verimizi utf-8 olarak stream üzerine attık ardından memo1 ile ekranda gösterdik. Bu işlemi yapabilmek için string verisini uygun bir byte dizisine çevirmemiz gerkiyordu. Bunun için System.Text alanında bulunan Encoding sınıfını kullanıyoruz. Bu sınıfı kullanabilmek için uses’a System.Text’i eklemelisiniz.

İsterseniz bu yazma işlemini Encoding.Unicode ile utf-16 ya da diğer adıyla unicode olarak, isterseniz Encoding.Default ile işletim sisteminin varsayılan ansi karakterleri olarak yazıp okuyabiliriz. Önemli olan string bir şekilde byte dizisine çevrilmiş olması gerekmektedir. Ayrıca yazma ve okuma işlemlerinde aynı tip encode formatını kullandığınızdan emin olun. Yani ya her ikisinde de Unicode ya da her ikisinde de UTF8 kullanın.

Eğer TBytes’dan stringe çevirim yapmamız gerekirse bu durumda aşağıdaki metodu kullanıyoruz:

s := Encoding.UTF8.GetString(bytes)

Gördüğünüz gibi .net ile bu işlemleri yapmak çok basit. Ayrıca en sonda stream’i free yapmasanız da Garbage Collector sizin için bunu yapacaktır. Fakat TFileStream kullanıyor ve dosyaya fmShareExclusive gibi kilitleyici bir parametre ile ulaşıyorsanız, stream nesnesini öldürmeden veya program kapanmadan, başka bir program dosyaya ulaşamaz, dosya kilitli kalır.

Bu bölümde bahsetmek istediğim başka bir konu da bu işlemleri Delphi 2009 ve üstünde yapmak. Burada bahsediyorum, çünkü bahsedeceğimiz bu konu .net ile de ilgili bir konu.

Aslında daha önceden gördük ki; bir stringi stream’e yazmak için stream’in kaç karakter olduğundan çok ,boyutunu bilmemiz gerekiyor. Bu yüzden ansi ya da ascii stringlerde boyut olarak her zaman Length(string) şeklinde aldık. Çünkü ansi stringlerde boyut = karakter sayısıdır. Fakat unicode olan stringlerde bu durum biraz farklıdır. Unicode olan stringler 1 byte değil, 2 byte yer kaplarlar. Bu yüzden WideString gibi unicode stringler ile uğraştığımızda artık boyutumuz Length*2 olmaktadır. Bildiğiniz gibi Delphi.Net ve Delphi 2009 ve yukarısı derleyicilerde "string" ve "Char" tipi unicode formatındadır. Bu derleyicilerde ansi olarak veri tanımlamamız gerektiğinde AnsiString, AnsiChar, PAnsiChar gibi tipleri kullanmalıyız. Aksi durumda bu derleyicilerde bir Char tipi 2 byte yer kaplar. Bu konu ile ilgili daha önceden örnek verdiğimizden bu konuyu burada bitiriyorum.

.NET Stream Nesnesinin Kullanımı

TStream’e ek olarak, .net’de aynı mekanizma bulunmaktadır. Neden bilmiyorum ama .net’de bulununa bir çok teknoloji Delphi ile benzerlik göstermektedir. Belki de c# ve .net’in fikir babası olan Anders Hejlsberg’in delphi’nin ilk temellerini atmasından kaynaklanıyor olabilir. Her neyse biz konumuza dönelim.

Aslında bu konu çok uzun anlatılabilecek bir konu ve burada bahsetmemiz makaleyi bir üçüncü bölüme bile taşıyabilir. Ki bence buna gerek yok. Ben sadece TStream ile arasındaki benzerlikleri gösterip, nasıl kullanıldığına dair bir örnek vermek istiyorum.

Bu bölümü VCL.Net kullanmak istemeyip saf .net kodu oluşturmak isteyenler veya Delphi Prism kullananlar için yazmak istedim. Aksi takdirde TStream sınıfı çoğu kez işimizi rahat bir şekilde görmektedir. Fakat bazen kullandığımız .net sınıfları .net’in stream sınıflarına ihtiyaç duyabilmektedir.

VCL’de bulunan bazı stream sınıfları yerine .net’de bulunan karşılıklarını şöyle sıralayabilriiz:

TFileStream => FileStream
TMemoryStream => MemoryStream
TIdTCPClient => NetwrokStream

vs..

Tabi bu stream sınıflarının metodları benzerlik gösterse de kullanımları farklıdır. Bu stream sınıflarını kullanabilemek için uses’a System.IO alanını eklemelisiniz. Biz buradan MemoryStream ile ilgili bir örnek verelim:

var
  Mem: MemoryStream;
  s: string;
  bytes: array of Byte;
begin
  Mem := MemoryStream.Create;
  s := 'diyezon';
  bytes := Encoding.UTF8.GetBytes(s);
  Mem.Write(bytes, 0, Length(bytes));

Gördüğünüz gibi kullanım olarak TStream’den farklı değil. Fakat Write metodunu TStream’de olduğu gibi bir çok çeşidi olduğunu zannetmeyin sakın. Çünkü MemoryStream sınıfında Write metodunun sadece iki adet varyasyonu mevcut. Bu metodda ilk parametre byte dizisi, ikinci parametre nereden itibaren yazılacağı yani ofset ve üçüncü parametre olarak yazdırılacak verinin uzunluğu giriliyor.

Bunun dışında bu string ve binary değerleri rahat bir şekilde okuyup yazabilmek için çeşitli ek sınıflar kullanılmaktadır. Mesela BinaryWriter ile binary değerleri stream üzerine yazabiliriz veya StreamReader ile streamden karakter verilerini okuyabiliriz. Aşağıdaki örneğe göz atalım:

var
  Mem: MemoryStream;
  textW: StreamWriter;
  s: string;
  bytes: array of Byte;
begin
  Mem := MemoryStream.Create;
  textW := StreamWriter.Create(Mem);
  s := 'diyezon';
  textW.Write(s);

Yukarıda yaptığımız işlemin aynısını burada StreamWriter sınıfı ile gerçekleştirdik. İşte burada StreamWriter sınıfının Write metodunda bir çok varyasyon mevcuttur. Bu varyasyonlara yardım dosyalarından ulaşabilirsiniz. Mesela bir Integer değer yazmak için yine StreamWriter’a ait Write metodunu kullanmamız kafidir.

Bunun dışında bir de kullanabileceğimiz BinaryWriter ve BinaryRead sınıfları mevcuttur. Bu sınıflar ise binary verileri okuyup yazmak için kullanılırlar. Ama kullanım aynı olduğu için bu konuya da girmeyeceğim.

Burada en son olarak BufferedStream sınıfından bahsetmek istiyorum. Bu stream ile okuma ve yazma işlemlerini başka bir stream üzerinde buffer’layarak daha hızlı işlemler yaptırabilirsiniz. Hatırlarsanız TMemoryStream sınıfından bahsederken, bu sınıfı diğer stream sınıflardaki okuma yazma işlemleri yerine kullanılabileceğinden ve bunun performansı artırdığından bahsetmiştik. İşte burada TMemoryStream bir buffer vazifesi görmektedir.

Mesela bir dosyaya bir çok veri yazılacak, ve bu veriler parça parça yazılacak. Ayrıca bu dosya stream’i üzerinde bir çok seek işlemi yani ileri geri alma işlemleri yapılacak. İşte bu durumda direk olarak TFileStream gibi bir dosya stream nesnesi ile uğraşmak yerine hafıza stream’leri ile uğraşmamız işlemlerimizin performansını önemli derecede artıracaktır. Yapacağımız stream işlemlerini bir hafıza stream’i üzerinde gerçekleştirip, en son işlemimiz bittiğinde hafıza stream’ini ilgili stream nesnesine aktarmak en akıllıca yöntemdir. İşte bu yönteme buffering ya da tamponlama tekniği denir.

İşte bu anlattığımız tekniği BufferedStream nesnesi gerçekleştirmektedir. Aynı işlemi ekstra bir memory stream tanımlayarak siz de oluşturabilirisiniz, hatta bu makalede buna benzer örnekleri çok gördük.

BufferedStream sınıfını kullanmak isteyenler, yardım dosyalarında ve msdn’de tanımlamasına bakabilirler. Artık stream mantığını kafanızda yerleştirdiğinize göre burada kullanımını vermek artık sıkacaktır.

Sonuç

Bir makalenin daha sonuna geldik. Bu makale serisinde VCL ve .net’de kullanılan stream sınıflarına değinmeye çalıştık ve bu sınıfların kullanımına dair çeşitli örnekler vermeye çalıştık.

Tabi ki burada verdiklerimiz stream için en temel konulardır. Bu makaleyi okuduktan sonra artık kafanızda stream’e ait somut düşüncelerin oluştuğunu zannediyorum. Ve bundan sonra önünüze gelecek olan bir çok stream işlemini rahat bir şekilde halledebileceğinizi umut ediyorum.

Fikir, eleştiri ve yorumlarınızı bekliyorum. Ayrıca makaledeki hataları bildirirseniz sevinirim.

Hayırlı çalışmalar.

Fatih Tolga ATA, Şubat 2009

Stream’ler hakkında bir makale yazmak, yapacaklarım arasındaydı. En son gelen bir istek üzerine stream konusuna el atalım istedim. Bu makale serimizde hem VCL’de bulunan TStream, hem de .NET’de bulunan Stream sınıfları ve kullanımlarından bahsetmeye çalışacağım.

Özellikle TStream üzerinde stringlerle uğraşmak gibi bir çok konu programcıların kafasını karıştırabilmektedir. Bu ve bunun gibi sorunların çözümlerine de çareler bulmaya çalışacağız.

Stream Nedir?

Bilgisayar ortamında yazma-okuma işlemlerinden bahsettiğimizde aklımıza bir çok şey gelir. Mesela disk üzerinde bir dosyaya erişip üzerinde yazma ve okuma işlemleri yapabiliriz. Veya bir hafıza bölgesinde yazma-okuma işlemleri yapabileceğimiz gibi bir veritabanındaki bir tablo alanında veya daha başka çeşit çeşit ortamlar üzerinde yazma-okuma işlemleri yapabiliriz. Bu bütün yazma-okuma işlemleri aslında her zaman yöntemi, işleyişi aynı olan bir fonksiyonlar dizisidir. Sadece alt planda yazma-okuma işleminin yapılacağı yüzeyde(disk, hafıza…) farklılıklar oluşmaktadır.

İşte bu işlemleri kolay bir şekilde, ortak bir sınıf üzerinden yapmak istediğimiz zaman ortaya Stream gibi bir yapı çıkıyor. Stream nesnelerini kullanarak, bir dosyayı yazıp okuyabilir, aynı fonksiyonları kullanarak bir hafıza bölgesine ulaşılabilir veya yine aynı fonksiyonlar ile bir veritabanı tablosunun alanına ulaşılabilir.

Stream, burada anlatılan basit özelliklerin yanında, stream verileri üzerinde bir çok işlemi yapabilmemize imkan sağlamaktadır. Bu makalemizde bunları ayrıntısı ile görmeye çalışacağız.

Stream Verileri

Stream nesneleri, stream verilerini kullanmamızı sağlamaktadır. Stream verileri, üzerinde çalışılan yere göre çeşitli veriler içermektedir. Bu bir resim dosyası olabileceği gibi kendimize özel çok farklı bir format da olabilir.

Buradan da anlaşılacağı gibi, stream verileri bir nevi bir byte dizisidir. Yani aynı veriyi "array of byte" şeklinde kullanarak da oluşturabilir ve üzerinde işlem yapabiliriz. Fakat bu, bize ek masraftan başka bir şeye yaramayacaktır. Üstelik yazacağımız fonksiyon ya da sınıf stream nesneleri gib esnek ve hızlı olmayacaktır.

Stream Ne Zaman Kullanılmalı?

Yapacağımız işlemerde stream mi, array mi kullanılmalı noktasında karar vermek istediğimizde bir kaç hususu göz önünde bulundurmamız gerekecektir.

İlk olarak bilmemiz gereken stream verileri array’de olduğu gibi indeksli değildir. Eğer kullanacağımız veriler, sabit veri tipi ise ve bir for döngüsüne girmek üzere oluşturulacak ise kullanacağımız nesne array olacaktır. Stream’de de istediğiniz veriye array’de olduğu gibi ulaşabilirsiniz. Fakat bu ileride de göreceğimiz gibi array indekslerinden farklı olarak çalışmaktadır.

Eğer bu veri dizimiz bir disk veya bir hafıza bölgesi üzerine yazılacaksa ve burada işlem yapılacaksa, bu durumda array yerine stream kullanılması bize bir çok kolaylık sunacaktır.

Aynı şekilde veri dizimiz sabit veri tipleri içermiyorsa yani sadece array of string veya sadece array of Integer değilse bu durumda yine stream kullanmalıyız. Mesela veri dizimizin birinci elemanı 4 karakterlik bir string, ikinci elmanı bir Integer, üçüncü elemanı bir Boolean, vs… gibi. Bu şekilde kendi dosya formatımızı oluşturabileceğimiz gibi, doc, exe, zip gibi bir çok binary dosyasının yapısını bildiğimizde bu dosyaların verilerine de ulaşabiliriz.

VCL’ de Stream Kullanımı

İlk başta VCL ile stream kullanımına değinelim. Ardında .Net üzerinde stream kullanımını göreceğiz.

VCL ile stream işlemleri yapabilmek için TStream sınıfından türeyen bir çok sınıf mevcuttur. TStream sınıfı abstract olarak tanımlanmış bir sınıftır ve direk olarak kullanılamaz. Abstract olarak oluşturulmuş olan bir sınıftan nesne oluşturulamaz. Ancak bu abstract sınıftan türemiş olan abstract olmayan sınıflardan nesne oluşturulabilir. Bu şekilde bir yapı olması, tüm stream sınıflarının aynı olan bir çok metod ve özelliğe sahip olmasını sağlar. Abstract sınıfların avantajları burada anlatılacak kadar kısa değil. Bu yüzden şimdilik bu kadar bilmemiz yeterli.

Help dosyasına göz attığımızda TStream sınıfından türemiş bir çok stream sınıfını görüyoruz.

TFileStream: Disk yani dosya sistemi üzerinde bulunan dosyalarla işlem yapmamızı sağlar.

TMemoryStream: Dosyalar üzerinde yapılan aynı işlemleri bir hafıza bölgesi üzerinde yapmamızı sağlar.

TBlobStream: Veritabanında bulunan bir tablodaki BLOB yani binary veri olarak tanımlanmış alanlar üzerinde okuma-yazma işlemleri yapmamızı sağlar.

TResourceStream: Resource dediğimiz, exe, dll gibi çalıştırılabilir dosyalar içine gömülü olan resim, yazı, dialog kutuları, versiyon bilgisi gibi çok çeşitli verileri okuyup yazmamıza imkan sağlamaktadır.

TStringStream: Aynı işlemleri bir string verisi üzerinde işlem yapabilmemizi sağlar. Böylece, sınırsız uzunlukta bir string üzerinde stream ile yapılabilecek her türlü işlemler yapılabilir.

Bunlar, temelde kullanılan stream çeşitleridir. Bunun gibi özel olarak tasarlanmış bir çok stream sınıfı da olabilir. Fakat hepsi TStream sınıfından türediği için, kullanımları da aynı olacaktır.

Dosyalar Üzerinde Stream İşlemleri

Dosyalar ile uğraşırken TFileStream kullanıldığını söylemiştik. TStream sınıflarının nasıl kullanıldığını, sonucu kolay görme açısından ilk başta dosyalar üzerinde görelim. İleride diğer stream çeşitlerine de değineceğiz.

var
  AFile: TFileStream;
  Buffer: String;
begin
  AFile := TFileStream.Create('C:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    Buffer := 'Deneme';
    AFile.WriteBuffer(Pointer(Buffer)^, Length(Buffer));
  finally
    AFile.Free;
  end;

Bu kodları bir button’nun OnClick olayına yerleştirip deneyelim. Kodlar çalıştırıldığında, C: üzerinde eğer bir erişim ihlali yoksa deneme.txt isminde bir dosya göreceğiz.

İlk bakışta bu kodlar ürkütücü gelebilir. Fakat konular ilerledikçe stream kullanmanın ne kadar rahat olduğunu göreceğiz.

AFile‘ın oluşturulduğu satıra bakalım. Bir TFileStream nesnesi oluşturabilmeniz için iki adet parametreye ihtiyacınız var. Birincisi dosyanın yolu, ki bizim örneğimizde "deneme.txt" olarak verilmiş. İkinci parametremiz ise bu dosya üzerinde yapacağımız işlem kipini ve paylaşım kipini belirler. İşlem ve paylaşım kipleri "or" kelimesi ile birleştirilerek kullanılır. Şimdi bu kiplerin ne olduğuna bakalım:

İşlem Kipleri:

fmCreate: Verilen dosya yolunda eğer dosya yoksa oluşturur. Eğer dosya var ise üzerine yazar.

fmOpenRead: Dosyayı sadece okuma amaçlı açar.

fmOpenWrite: Dosyayı sadece yazma amaçlı açar.

fmOpenReadWrite: Dosyayı hem okuma hem de yazma için açar.

Paylaşım Kipleri:

fmShareExclusive: Diğer uygulamaların, bizim üzerinde çalıştığımız dosya üzerinde hem okuma hem de yazma işlemlerini yasaklar.

fmShareDenyWrite: Diğer uygulamalar dosyayı okuyabilir fakat üzerinde yazma işlemi yapamazlar.

fmShareDenyRead: Diğer uygulamaların, dosya üzerinde okuma işlemi yapmasını yasaklar.

fmShareDenyNone: Ne okuma ne de yazma yasağı koyar. Yani diğer uygulamalar, dosya üzerinde yazma ve okuma yapabilirler.

fmShareCompat: Eskiden dos zamanlarında kullanılan FCB(File Control Block) ile uyumluluğu sağlamak için kullanılır. Windows üzerinde fmShareExclusive, Linux üzerinde ise fmShareDenyNone ile aynıdır. Bu yüzden bunu es geçebilirsiniz.

Yukarıda verdiğimiz örnekte olduğu gibi işlem kipleri ve paylaşım kipleri "or" kelimesi ile birleştirilerek kullanılır. Örneğimizde dosya fmCreate ile eğer yoksa oluşturulacak ve eğer varsa üzerine yazılacaktır. Ve dosya fmShareDenyNone kipinde olduğu için üzerinde herhangi bir okuma yazma yasağı bulumamaktadır.

Ardından try..finally buloğunda, stream üzerine yazma işlemleri yapılmaktadır. Şimdilik bu kısmı anlatmayacağız. Çünkü okuma ve yazma işlemleri için ayrı bir konu başlığımız bulunmaktadır.

finally bloğunda gördüğümüz Free metodu dosyalar üzerinde fazladan bir önem arz etmektedir. Çünkü bir kez TFileStream ile bir dosyaya erişildiğinde, bu stream nesnesi Free oluncaya yani yok edilinceye kadar, dosyanın handle’ı işletim sistemi tarafından tutulur. Dosya handle’ı aktif olduğu sürece dosyanın silinmesi taşınması işletim sistemi tarafından engellenir. Ve genelde herkesin karşılaştığı "Bu dosya bir uygulama tarafından kullanıyor." gibi bir mesaj alırız. Bunun için unlocker, process explorer gibi harici programlar ile aktif kalan bu handle’lar kapatılarak dosyalar silinebilir. Bu yüzden okuma yazma işlemlerimiz biter bitmez stream nesnemizi Free yapmalıyız.

Kısaca bir stream nesnesini oluşturmak için aşağıdaki şablonu kullanmalıyız:

var
  AStream: TBirStreamSınıfı;
begin
  AStream := TBirStreamSınıfı.Create({Stream sınıfına ait parametreler...});
  try
    //Stream üzerinde okuma yazma işlemleri
  finally
    AStream.Free;
  end;
end;

Stream Üzerinde Okuma-Yazma İşlemleri

Stream’ler üzerinde yazma işlemleri için başlıca Write ve WriteBuffer metodları ve okuma işlemleri için de Read ve ReadBuffer metodları tanımlanmıştır. Şimdi göreceğimiz işlemler Win32‘ye göre anlatılacaktır. İleride ayrı bir başlık halinde TStream sınıfının .NET üzerinde nasıl yazma okuma yapabileceğiniz de göreceğiz. Ayrıca .NET içinde bulunan Stream sınıflarına değineceğiz.

Stream üzerinde yapılan okuma yazma işlemleri bir işaretçi vasıtası ile yapılır. Bu işaretçi hangi pozisyonda ise o pozisyonda okuma ve yazma işlemi yapılır. İlk stream nesnesi oluşturulduğunda işaretçinin pozisyonu sıfırdır. Bu metodlar çağrıldığı vakit, yani her okuma ve yazma işleminin sonunda stream işaretçisi bir sonraki pozisyona kayar. Stream işaretçisi, stream verisinin sonuna gelip gelmediğini test etmek için Eof metodu kullanılır.Bu paragraf streamlerin çalışma mantığının anlaşılması için önemlidir. Bu yüzden dönüp ikinci bir defa okumanızda fayda var.

Sonunda Buffer yazan metodların yazmayanlardan farkından söz etmek istiyorum. Tek fark, "istisna" (Exception) yakalama özelliğidir. Yani mesela ReadBuffer metodu yine alt planda Read metodunu çalıştırır. Fakat Read metodu bir sorunla karşılaşır ve okuyamaz ise, ReadBuffer metodu, EReadError istisnasını yollar. Aynı şekilde WriteBuffer da sorun yaşadığında EWriteError istisnasını yollar. Böylece okuma ve yazma işlemlerinde herhangi bir hata olup olmadığının tespiti için ReadBuffer ve WriteBuffer ile beraber istisnaların yaklanması kafidir.

Okuma ve yazma metodları, işlemlerini bir buffer aracılığı ile gerçekleştirir. Bu buffer bir string olabilceği gibi bir Integer, bir record dahi olabilir. Bu yüzden her veri tipi için okuma ve yazma işlemlerinin nasıl olduğunu ayrı ayrı incelemeye çalışalım.

Sayısal Değelerin Okunması ve Yazılması

Integer, Byte, Double gibi sayısal verileri okuyup yazmak diğerlerine nazaran en basit işlemdir. Ekstra bir çevirim yapmamıza gerek kalmamaktadır.

Bunu bir örnek üzerinde görelim. İki adet button yerleştirelim. Birinin Caption özelliği "Yaz", diğerinin Caption özelliği de "Oku" olsun. "Yaz" butonuna çift tıklayalım ve şunları yazalım:

procedure TForm1.btnYazClick(Sender: TObject);
var
  BirStream: TFileStream;
  BirInteger: Integer;
  BirDouble: Double;
  BirReal: Real;
  BirByte: Byte;
begin
  BirStream := TFileStream.Create('c:\deneme.bin', fmCreate or fmShareDenyNone);
  try
    BirInteger := 15000;
    BirDouble := 1.3;
    BirReal := 123.123123123;
    BirByte := 65;
    BirStream.WriteBuffer(BirInteger, SizeOf(Integer));
    BirStream.WriteBuffer(BirDouble, SizeOf(Double));
    BirStream.WriteBuffer(BirReal, SizeOf(Real));
    BirStream.WriteBuffer(BirByte, SizeOf(Byte));
  finally
    BirStream.Free;
  end;
end;

Gördüğünüz gibi bir TFileStream nesnesi oluşturduk ve bu stream nesnesini kullanarak dosyaya bir takım sayısal değerler yazdırdık. Mesela ilk yazdırma örneğimizde buffer, Integer tipinde bir değişkendir. Bu Integer değeri yazdırırken ne kadar yazdırılması gerektiğini WriteBuffer metodunun ikinci parametresi olarak giriyoruz. Yani yazdıracağımız bu buffer kaç byte yer tutacak, onu ikinci parametre olarak giriyoruz. Örneğimizde, bu parametre olarak Integer‘ın boyutunu giriyoruz. Bunun için SizeOf fonksiyonundan faydalanıyoruz. Help dosyasına baktığımızda, Integer‘ın 4 byte yer kapladığını görürüz. Burada yaptığımız işlem dosyada 4 byte’lık bir alana Integer değeri yazdırmaktan ibarettir.

Ardından gelen yazma işlemleri de aynı mantık ile yapılmaktadır. Burada dikkat etmemiz gereken nokta ikinci parametredir. Çünkü bu parametre yanlış girilirse hem yazmada hem de okumada eksik ve yanlış verilerle karşılaşırız. Bu örnekten de anladığımız gibi sayısal veriler ile uğraşırken SizeOf(DeğişkeTipi) şeklinde ikinci parametreyi belirlememiz yeterlidir.

Şimdi bu programı çalıştırıp Yaz butonuna basalım. Diskin C: bölümünde deneme.bin isimli bir dosya oluşmuş olmalı. Herhangi bir hex editor ile (HxD) bu dosyayı açıp inceleyebilirsiniz. Eğer ayrıntısına girmek isterseniz Integer ve diğer sayısal değerlerin nasıl yazıldığını inceleyebilirsiniz. Mesela demiştik ki dosyamızın ilk 4 byte’ında bir Integer bulunmaktadır. Dosyamızı bir hex editör ile açtığımızda ilk 4 byte’ında 98 3A 00 00 yazdığını görürüz. IBM (x86) tabanlı makinelerde bu veriler tersten yazılırlar. Bu yüzden bu ifadeyi 00 00 3A 98 olarak düşüneceğiz. Hesap makinesini açıp 16′lık Hex moda geçelim. Tabi bunu yapabilmek için bilimsel moda geçmeniz gerekmektedir. Hex modu seçili iken 3A98‘i yazalım. Ardından Dec yani ondalık olarak her zaman kullandığınız sayı formatına çevirelim. Ve karşımızda 15000 sayısını göreceğiz ki bu değer örneğimizde Integer olarak dosyanın baş tarafına yazdırılmıştı. Diğer veri tiplerinin nasıl kaydedildiğini bu şekilde inceleyerek bulabilirsiniz.

Şimdi gelelim bu değerleri okumaya… Oku butonumuza çift tıklayıp şu kodları girelim:

procedure TForm1.btnOkuClick(Sender: TObject);
var
  DosyaOku: TFileStream;
  BirInteger: Integer;
  BirDouble: Double;
  BirReal: Real;
  BirByte: Byte;
begin
  DosyaOku := TFileStream.Create('c:\deneme.bin', fmOpenRead or fmShareDenyNone);
  try
    DosyaOku.ReadBuffer(BirInteger, SizeOf(Integer));
    DosyaOku.ReadBuffer(BirDouble, SizeOf(Double));
    DosyaOku.ReadBuffer(BirReal, SizeOf(Real));
    DosyaOku.ReadBuffer(BirByte, SizeOf(Byte));
    ShowMessage('Integer: ' + IntToStr(BirInteger) + #13 +
      'Double: ' + FloatToStr(BirDouble) + #13 +
      'Real: ' + FloatToStr(BirReal) + #13 +
      'Byte: ' + IntToStr(BirByte)
    );
  finally
    DosyaOku.Free;
  end;
end;

Şimdi bu programı çalıştıralım ve bu sefer oku butonuna basalım. Ve karşımızda dosyaya yazdırdığımız değerler…

Gördüğünüz gibi okuma işlemi yazma işleminden farklı değil. İhtiyacımız olan tek şey bir buffer ve bu buffer’ın tipinin boyutu. Eğer değişken tipinin boyutunu yanlış girersek veya okuma sırasını yer değiştirirsek, istediğimiz sonucu alamayız. Çünkü stream üzerine yazarken, bu sırada ve bu değişken tipleri ile yazılmıştır. Okurken de aynı sıra ve uzunlukta okunmalıdır. Bu yüzden, bu şekilde kendi dosya formatlarımızı oluştururken, bir plan üzerinde dosya formatında hangi pozisyonda hangi veri bulunacağı ve boyutu belirlenmelidir.

Gördüğünüz gibi sayısal verileri okumak ve yazmak hiç de zor değil. Şimdi dilerseniz karakter dizilerini nasıl okuyup yazacağımızı görelim.

Karakter Dizilerinin Okunup Yazılması

Karakter dizisi dediğimizde aklımıza gelen ilk değişken tipleri string ve PChar‘dır. Eğer Delphi 2009′dan önceki bir sürüm kullanıyorsanız bu değişken tipleri ANSI‘dir. Yani her bir karakter bir byte yer kaplar. D2009 ve sonrası için her bir karakter Unicode olduğu için 2 byte yer kaplarlar.

İlk önce PChar verilerini nasıl yazıyoruz ve okuyoruz onu görelim:

procedure TForm1.btnYazClick(Sender: TObject);
var
  DosyaYaz: TFileStream;
  Karakterler: PChar;
begin
  DosyaYaz := TFileStream.Create('c:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    Karakterler := 'http://www.diyezon.com';
    DosyaYaz.WriteBuffer(Karakterler^, Length(Karakterler));
  finally
    DosyaYaz.Free;
  end;
end;

Karakter verililerini yazdırırken ve okurken dikkat etmemiz gereken nokta yine verinin kapladığı alandır. Karakter dizisinin kapladığı alanı hesaplayabilmek için bir karakterin ne kadar yer kapladığını bilmemiz gereklidir. Önceden de dediğim gibi, eğer karakterleriniz ANSI ise yani Unicode değilse, her bir karakter 1 byte yer kaplar. Bu yüzden bu örneğimizde yazılacak uzunluk olarak karakter sayısını verdik. Çünkü ANSI karakter katarlarında karakter sayısı, karakter dizisinin boyutuna eşittir. Fakat PChar yerine PWideChar kullansa idik ya da bu kodları D2009 ve üzeri bir sürümde çalıştırsa idik her bir karakteri 2 byte olarak alacaktık. Bu durumda karakter sayısı karakter dizisinin boyutuna eşit değil, boyutun yarısı kadarı olacaktı. Yani Yukarıdaki kodda PChar‘ı PWideChar yaparsak WriteBuffer metodunun ikinci paramteresine Length(Karakterler) * 2 yazmamız gerekiyordu. Bu bahsettiğimizi örneğimizde değiştirip deneyin ve bir hex editör ile her bir karakterin 2 byte yer kapladığına şahid olun. Ama daha sonra tekrar PChar olarak değiştirip dosyayı tekrar yazın. Çünkü birazdan yapacağımız okuma işleminde PChar olarak okutacağız.

Okuma işlemine geçmeden önce WriteBuffer metodunda ilk parametreye bir göz atalım. Burada gördüğünüz gibi Karakterler değişkeninin sonuna ^ operatörünü ekledik. Bu operatör, işaretçilerle (pointer) birlikte kullanılan özel bir operatördür. Bir işaretçinin işaret ettiği esas değere erişmek için bu operatörü kullanıyoruz. Örneğimizde ise PChar tipindeki değişkenimizin işaret ettiği gerçek değeri buffer parametresi olarak girdik. Çünkü PChar da bir çeşit işaretçidir. Ve Karakterler^ yazmak ile bu işaretçinin hafızada işaret ettiği gerçek karakter verisini buffer olarak girdik.

Şimdi yazdırdığımız bu stream verilerini okuyalım:

procedure TForm1.btnOkuClick(Sender: TObject);
var
  DosyaOku: TFileStream;
  Karakterler: PChar;
begin
  DosyaOku := TFileStream.Create('c:\deneme.txt', fmOpenRead or fmShareDenyNone);
  try
    Karakterler := AllocMem(22);
    DosyaOku.ReadBuffer(Karakterler^, 22);
    ShowMessage(Karakterler);
  finally
    DosyaOku.Free;
  end;
end;

İlk yaptığımız işlem Karakterler değişkeni için hafızadan yer ayırmaktır. Bunun için AllocMem fonksiyonu kullanılır. Tabi bunun için okuyacağımız verinin ne kadar uzunlukta olduğunu bilmemiz gerekiyor. Eğer okuyacağımız karakter verilerinin uzunluğu belli değilse ya da duruma göre boyut değişebiliyorsa bu durumda daha başka bir şeyler yapmamız gerekecek. Bununla ilgili ayrıntılı bilgiyi ilerleyen konularda bulacağız. Ama şimdilik veri uzunluğumuzu sabit kabul ederek işlemlerimizi yapalım.

AllocMem ile hafızadan yer ayırdıktan sonra bu hafıza bölgesine stream verilerini yerleştirebiliriz. Bunun için yine ReadBuffer ile stream’den veri okuyoruz ve buffer’a atıyoruz. Yine buffer olarak işaretçinin gerçek değerini ifade eden ^ operatörünü kullanıyoruz. İkinci parametrede de ne kadar uzunlukta okuyacağımızı belirliyoruz.

PChar ile veri okuma ve yazma bu şekilde olmakta. Peki string bir değişkeni nasıl yazıp okuyacağız? Aslında PChar‘da kullandığımız yöntemden farklı değil. Çünkü string ile PChar arasında çok büyük bir fark bulunmamakta. Zaten çalışma anında bu iki tip arasında dönüşümler rahatlıkla yapılabilmektedir. Yazma için yazdığımız kodları aşağıdaki gibi değiştirelim:

procedure TForm1.btnYazClick(Sender: TObject);
var
  DosyaYaz: TFileStream;
  Karakterler: string;
begin
  DosyaYaz := TFileStream.Create('c:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    Karakterler := 'http://www.diyezon.com';
    DosyaYaz.WriteBuffer(Pointer(Karakterler)^, Length(Karakterler));
  finally
    DosyaYaz.Free;
  end;
end;

Önceki yazma işleminde çok farklı olmadığını burada görüyoruz. Tek yaptığımız işlem derleyiciye, string değişkene bir işaretçi gibi davranmasını söylüyoruz. Bu şekilde derleyici, string olan Karakterler değişkenini bir işaretçi gibi düşünecek ve ^ operatörü ile esas hafıza bölgesindeki veriyi buffer olarak kullanacak. Burada Pointer yerine PChar yazarak da type casting yapabilirsiniz.

Okuma kodları PChar‘a göre fazla ya da eksik değil. Önceki okuma fonksiyonumuzu aşağıdaki gibi değiştirelim.

procedure TForm1.btnOkuClick(Sender: TObject);
var
  DosyaOku: TFileStream;
  Karakterler: string;
begin
  DosyaOku := TFileStream.Create('c:\deneme.txt', fmOpenRead or fmShareDenyNone);
  try
    SetLength(Karakterler, 22);
    DosyaOku.ReadBuffer(Pointer(Karakterler)^, 22);
    ShowMessage(Karakterler);
  finally
    DosyaOku.Free;
  end;
end;

AllocMem yerine string için SetLength fonksiyonunu kullanıyoruz. Böylece string olan değişkenimizin boyutunu belirliyoruz. ReadBuffer‘da yapılanlar önceden anlatılmıştı.

String için yaptığımız bu işlemler biraz pointer yani işaretçi bilgisi gerektiren işlerdi. Halbuki bu pointer işlerine girmeden de string verileri yazıp okuyabiliriz. Ama ilk önce bu şekilde vermemin sebebi, esasında işin arkaplanda çalışma şeklini göstermekti.

Aslında diziler ve işaretçi olan PChar gibi karakter katarları hafızada bulunan esas verilerdeki ilk elemana işaret ederler. Derleyici bu değişken tipleri ile uğraşırken bunların uzunluğundan haberdardır ve ilk pozisyondan itibaren hafızada bu değişkenler üzerinde işlem yapabilir. Esasında PChar ve string‘de ortak olarak yapılan işlem, karakter dizisinin ilk elemanını buffer olarak girmektir. Her iki durumda da ^ operatörü dizinin hafızadaki ilk karakterine işaret eder. Geri kalanında Write ya da Read metodları verilen uzunluk kadar bu ilk karakterden itibaren okumaya ya da yazmaya başlar. Yukarıda string için yazdığımız kodları şu şekilde daha kolay ve sade bir şekilde de yazabiliriz:

procedure TForm1.btnOkuClick(Sender: TObject);
var
  DosyaOku: TFileStream;
  Karakterler: string;
begin
  DosyaOku := TFileStream.Create('c:\deneme.txt', fmOpenRead or fmShareDenyNone);
  try
    SetLength(Karakterler, 22);
    DosyaOku.ReadBuffer(Karakterler[1], 22);
    ShowMessage(Karakterler);
  finally
    DosyaOku.Free;
  end;
end;

procedure TForm1.btnYazClick(Sender: TObject);
var
  DosyaYaz: TFileStream;
  Karakterler: string;
begin
  DosyaYaz := TFileStream.Create('c:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    Karakterler := 'http://www.diyezon.com';
    DosyaYaz.WriteBuffer(Karakterler[1], Length(Karakterler));
  finally
    DosyaYaz.Free;
  end;
end;

Gördüğünüz gibi pointer’lardan kurtulup, bize yakın olan kodları kullandık ve aynı sonucu aldık. Ama arka planda derleyici bizim ilk yazdığımız ve işaretçileri kullandığımız kısımdaki gibi çalışır.

Burada tek yaptığımız işlem buffer olarak string değişkeninin ilk karakterini girmek. Tabi okuma işleminde yine SetLength‘i unutmuyoruz. Çünkü okuma işleminden önce hafızada yeterince yer ayrılması şarttır.

Önceden de dediğim gibi uzunluğu sabit uzunlukta olmayan karakter dizileri için ayrı bir konu başlığı ayırdık. O zamana kadar karakter dizimizin boyutunu sabit kabul edeceğiz.

Record’ların Stream Verileri Olarak Kullanılması

Genelde stream ile yapılmak istenen bir gurup veriyi yazmak ve okumaktır. Bu gurup verileri ise genelde record‘lar ile tutarız. Mesela aşağıda bulunan record içinde bir çok değişik değişken tipi bulunmaktadır.

TDosyaBasligi = record
  Imza: string[3];
  Versiyon: Double;
  IcerikBoyutu: Integer;
end;

Record’ları streamler ile beraber kullanırken şuna dikkat etmemiz gerekiyor. Bir record verisini stream ile okuyup yazabilmek için, record içeriğinin sabit uzunluklu verilerden oluşuyor olmasıdır. Aksi halde bu record, özel işlemler yapılmadığı taktirde, streamlerde kullanılmak için elverişli değildir. Bu yüzden yukarıda string değişkenini 3 karakter ile sınırlandırdık.

Okuma esnasında da aynı record verisini kullanarak rahat bir şekilde okuma işlemini yapabilriiz. Peki ama bu bize ne avantaj sağlayacak?

Önceki örneklerde gördüğümüz gibi, herbir string, Integer, Double gibi değişkenler için ayrı ayrı Read ve Write metodları kullandık. Halbuki bu değişkenler eğer sabit bir formda ise bunları bir paket halinde okuyup yazabilmeliyiz. İşte bu paket halinde okuyup yazma işlemi için recordları kullanıyoruz. Yani yukarıda verdiğimiz TDosyaBasligi isimli recordu yazabilmek için tek tek içinde bulunan 3 değişkeni yazdırmamız gerekmiyor. Sadece TDosyaBasligi isimli recordu yazdırmamız kafidir.

Şimdi yukarıda verdiğmiz recordu interface kısmında, TForm tanımlamasının yukarısında ama type‘ın altında yazalım. Ve Yaz butonunun OnClick olayına şunları yazalım:

procedure TForm1.btnYazClick(Sender: TObject);
var
  DosyaYaz: TFileStream;
  Paket: TDosyaBasligi;
begin
  DosyaYaz := TFileStream.Create('c:\deneme.txt', fmCreate or fmShareDenyNone);
  try
    Paket.Imza := 'DYZ';
    Paket.Versiyon := 1.2;
    Paket.IcerikBoyutu := 1500;
    DosyaYaz.WriteBuffer(Paket, SizeOf(TDosyaBasligi));
  finally
    DosyaYaz.Free;
  end;
end;

Gördüğünüz gibi herhangi bir ekstra işlem yapmadım. Sanki basit bir sayısal veriyi yazdırır gibi recordumuzu yazdırdık. Aynı şekilde okumasını da gerçekleştirelim:

procedure TForm1.btnOkuClick(Sender: TObject);
var
  DosyaOku: TFileStream;
  Paket: TDosyaBasligi;
begin
  DosyaOku := TFileStream.Create('c:\deneme.txt', fmOpenRead or fmShareDenyNone);
  try
    DosyaOku.ReadBuffer(Paket, SizeOf(TDosyaBasligi));
    ShowMessage(Paket.Imza + #13 + FloatToStr(Paket.Versiyon) + #13 +
      IntToStr(Paket.IcerikBoyutu));
  finally
    DosyaOku.Free;
  end;
end;

Bu programı çalıştıralım ve ilk önce Yaz sonra da Oku buttonlarına tıklayalım. Böylece bir recordu yazıp okuyabildik. Fakat disk üzerine yazılan dosyayı bir hex editör yardımı ile incelersek göreceğiz ki ilk kısımda bulunan 3 karakterlik stringten önce 1 byte’lık bir veri bulunmaktadır. Önceki string yazma işlemlerinden farklı olarak burada record içindeki stringlerin sadece verisi yazdırılmaz. String değişkeninin tamamı record ile beraber yazdırılır. String değişkenin tamamından kastımız stringi oluşturan parçalardır. Bir string, PChar gibi karakter dizilerinden farklı olarak ilk 0. baytında stringin veri uzunluğunu tutar. Bu örneğimizde 3 karakter uzunluğunda olduğu için hex editörde ilk göreceğimiz değer 03 değeridir. Tabi bu tek bytelık alanda en fazla 255 değeri yani FF değerini tutlabilir. Bu yüzden sınırlı bir string(literal string) kullanabilmek için en fazla 255 karakter kullanabiliriz. Aksi halde daha başka yollara başvurmalıyız. Başta bulunan 03 ifadesini kaldırıp sadece string verisini yazdırmak istersek array kullanmamız gerekmektedir. Array kullanımını bir sonraki konuda göreceğiz.

Sabit uzunluklu recordları kaydederken gördüğünüz gibi hiç zorlanmıyoruz. Eğer record içeriği burada olduğu gibi sabit uzunluklu değilse yani record içine PChar ya da limitsiz string girersek ne yapacağız. Bu durumda eğer yapabiliyorsak değişken uzunluklu olanları recorddan çıkartıp işlemlerimizi o şekilde yapmalıyız. Değişken uzunluklu verileri recorddan ayrı olarak okuyup yazmamız gerekmektedir. İleriki konularımızda değişken uzunluklu veriler ile nasıl çalışacağımızı da göreceğiz.

Dizileri Stream Verisi Olarak Kullanmak

Aslında dizileri stream üzerine yazmak için, buraya kadar öğrendiğimiz bilgiler yeterli. String’leri nasıl yazdırır ve okutuyorsak, aynı şekilde array’leri de yazdırıp okutabiliyoruz.

//Yazdırmak için
var
  FS: TFileStream;
  BirDizi: array[0..5] of Integer;
begin
  FS := TFileStream.Create('c:\deneme.bin', fmCreate or fmShareDenyNone);
  try
    BirDizi[0] := 153;
    BirDizi[1] := 1;
    BirDizi[2] := 3442;
    BirDizi[3] := 902;
    BirDizi[4] := 455;
    FS.WriteBuffer(BirDizi[0], SizeOf(BirDizi));
  finally
    FS.Free;
  end;
end;

//Okutmak için
var
  FS: TFileStream;
  BirDizi: array[0..5] of Integer;
begin
  FS := TFileStream.Create('c:\deneme.bin', fmOpenRead or fmShareDenyNone);
  try
    FS.ReadBuffer(BirDizi[0], SizeOf(BirDizi));
    ShowMessage(IntToStr(BirDizi[0]) + #13 +
      IntToStr(BirDizi[1]) + #13 +
      IntToStr(BirDizi[2]) + #13 +
      IntToStr(BirDizi[3]) + #13 +
      IntToStr(BirDizi[4]) + #13);
  finally
    FS.Free;
  end;
end;

Gördüğünüz gibi ilk elemanını buffer olarak giriyoruz ve ikinci parametre olarak da dizinin boyutunu parametre olarak giriyoruz.

Eğer dinamik array kullanıyorsak okuma işlemini gerçekleştiren ReadBuffer metodundan önce mutlaka SetLength ile dizinin boyutunu belirlemiş olmalıyız. Ayrıca dizinin kapladığı alanı bulabilmek için dinamik dizinin eleman sayısı ile elaman tipinin boyutunu çarpmalıyız. Yani yukarıdaki örnekte dinamik dizi kullanmış olsa idik Length(BirDizi) * SizeOf(Integer) kazacaktık.

İki ve daha fazla boyuttaki diziler için ise, iç içe bir for döngüsü kurularak bir okuma ve yazma algoritması geliştirilebilir.

Bu kısım diziler için kolay kısımdı. Çünkü bunlar önceki öğrendiklermizden farksızdır. Fakat eğer ActiveX ile uğraşıyorsanız, Word, Excel gibi programların otomosyonu ile uğraşıyorsanız variant array‘ler ile uğraşmışsınızdır. İşte bu durumda variant olan array’leri stream’e kaydetmek ve stream’den okutmak bu kadar kolay değildir. Ama zor da değildir. Eğer ActiveX ile uğraşmıyorsanız diğer başlığa atlayabilirsiniz, ya da nasıl yapıldığı hakkında fikir sahibi olmak için kalıp okuyabilirsiniz.

Bu örneğimizde otomosyon ya da ActiveX nesnelerine girmeyeceğim. Bir şekilde bu nesnelerden variant array verilerini aldığınızı düşünerek haraket edeceğim.

var
  VariantArray: Variant;
  VArraySize: Integer;
  PArray: Pointer;
  FS: TFileStream;
begin
  VariantArray := ActiveXNesnesi.ArrayDonderenMetod; //Bu kısım size ait...
  VArraySize := VarArrayHighBound(VariantArray, 1) - VarArrayLowBound(VariantArray, 1) + 1;
  PArray := VarArrayLock(VaraintArray);
  FS := TFileStream.Create;
  try
    FS.WriteBuffer(PArray^, VArraySize);
  finally
    FS.Free;
  free;
  VarArrayUnlock(VaraintArray);

Karışık gibi görünse de eğer ActiveX ile uğraşıyorsanız bu kısım size zor gelmeyecektir. İlk başta bir nesneden variant array değerini aldık. Bu değeri siz delphi içinde de oluşturabilirsiniz. Ardından bu array’in boyutunu hesapladık ve VArraySize isimli değişkene attık. Burada dikkat etmeniz gereken nokta, bu örneğimizde diziyi byte, char gibi her elemanı 1 byte olan bir diziye göre hesapladık. Eğer array’deki elemanların boyutu 1 byte’dan fazla ise bu durumda:

VArraySize := (VarArrayHighBound(VariantArray, 1) -
  VarArrayLowBound(VariantArray, 1) + 1) * TVarData(VariantArray).VArray^.ElementSize;

gibi bir şeyler yazmamız gerekiyordu. Yani eleman sayısı ile bir elemanın boyutunu çarpıyoruz. Daha sonraki gelen işlemlerde, variant array’in ilk elemanının işaretçisini alıyoruz. Bunun için VarArrayLock fonksiyonundan faydalanıyoruz. Bu işaretçiyi daha sonra buffer olarak WriteBuffer‘da kullanıyoruz. Bu işaretçi ile işimiz bitince VarArrayUnlock yapmayı unutmuyoruz.

Variant dizisini stream’den okurken de VarArrayCreate fonksiyonunu kullanıyoruz ve yeni bir dizi oluşturuyoruz. Ardından aynı VarArrayLock ve VarArrayUnlock işlemleri arasında dizimizi stream’den okuyoruz. Bu kısmı size bırakıyorum…

Değişken Uzunluktaki Verileri Okuyup Yazmak

Buraya kadar öğrendiğimiz işlemlerde hep varsayılan bir uzunluktan bahsettik. Fakat her zaman durum bu şekilde olmuyor.

Mesela, kullanıcının bir TMemo bileşenini doldurduğu bir form var. Biz bu TMemo‘da bulunan yazıyı ve başka verileri kendi dosya formatımızda saklamak istiyoruz. Ya da veritabanına kendi formatımızda kaydetmek istiyoruz. Bu durumda string’in ne uzunlukta olduğunu yazarken bilebiliriz fakat okurken bilemeyiz. Çünkü dosya’da ya da herhangi bir stream’de kayıtlı bulunan o string’e ait uzunluk, artık bizim bilgimizin dışına çıkmıştır. Buraya kadar yaptığımız örneklerde hep yazma ve okuma işlemlerini aynı programa koyduk ve aynı çalışma zamanında işlettirdik. Bu yüzden okuduğumuz verilerin boyutunu her zaman biliyorduk. Halbuki okuma fonksiyonu ayrı bir işlemde ise ya da programı açıp kapadığımızda da okuma işleminin çalışmasını istiyorsak bu durumda kaydedeceğimiz veriyi özel bir biçimde kaydetmeliyiz.

Bu ve bunun gibi durumlarda yapacağımız işlem çok basit ve her türlü değişken uzunluklu veri tipi için geçerlidir. Yapacağımız tek şey değişken uzunluklu olan verinin boyutunu sabit bir pozisyona yazmaktır. Ardından okuma esnasında bu sabit pozisyondaki değeri okutarak değişken olan verinin boyutu hakkında bilgi sahibi olabiliriz.

Mesela stream formatımız şu şekilde olsun:

Tabi bu çok basit bir format şekli. Normalde bir çok sabit içerikle beraber bir çok değişken içeriği iç içe kullanmamız gerekebiliyor.

Formatımıza göre ilk 3 byte’da dosya imzası bulunacak. Ardından gelen 8 byte dosyanın versiyonunu tutacak. Ve sonrasında gelen 4 byte’lık Integer değer ise bizim üzerinde uğraştığımız esas konudur. Çünkü bu Integer değer sonrasında gelen string içeriğin boyutunu tutmaktadır. Böylece okuma esnasında string verimizi ne kadar okuyacağımızı belirleyebiliyoruz.

En sonda ise 4 byte’lık bir Integer daha ekledim. Bu değer aslında bu örneğimizi için gerekli değil. Fakat burada bir noktaya dikkatinizi çekmek istediğimden bu değeri de dosya formatına ekledim.

Değişken uzunlukta olan string, array ya da herhangi bir değişkeni kaydederken normalde ilk akla gelen stream’in sonuna kadar okumak olacaktır. Ya da stream’in uzunluğundan diğer verilerin boytunu çıkarmak olacaktır. Halbuki işin içine iki veya daha fazla değişken uzunlukta veri girdiğinde ve buradaki örnekte olduğu gibi değişken uzunluktan sonra da bir başka veri geldiğinde bu mantık bizi idare etmeyecektir. Aynı şekilde dosya formatımızı sürekli olarak güncellenebilen bir format ise bu mantık yine çökecektir.

Bu durumda en mantıklı işlem, değişken verilerin başında bu verinin uzunluğunu saklamak olacaktır. Böylece sonrasında gelen değişken uzunluktaki veri rahatlıkla okunabilir.

Şimdi bu anlattıklarımızı pratiğe dökelim ve yukarıdaki stream formatımızı yine bir dosya üzerinde yazıp okuyalım. Bunun için yeni bir uygulama açın ve form üzerine bir adet button ve bir adet memo yerleştirin.

Unit’in interface kısmında TForm1 tanımlamasının hemen üstünde(type bloğu içinde) şunları yazalım:

type
  TDosyaBasligi = record
    Imza: array[0..2] of Char;
    Versiyon: Double;
    IcerikBoyutu: Integer;
  end;

Buttonnun OnClick olayına aşağıdakileri yazalım.

var
  FS: TFileStream;
  Baslik: TDosyaBasligi;
  Icerik: string;
  Rastgele: Integer;
begin
  FS := TFileStream.Create('c:\deneme.dyz', fmCreate or fmShareDenyNone);
  try
    Icerik := Memo1.Lines.Text;
    //Başlık bilgilerinin yazımı
    Baslik.Imza := 'DYZ';
    Baslik.Versiyon := 1.2;
    Baslik.IcerikBoyutu := Length(Icerik);
    FS.WriteBuffer(Baslik, SizeOf(TDosyaBasligi));

    //Değişken boyutlu içeriğin yazımı
    FS.WriteBuffer(Icerik[1], Length(Icerik)); //Unicode olduğunda Length * 2

    Randomize;
    Rastgele := Random(100);
    FS.WriteBuffer(Rastgele, SizeOf(Integer));
  finally
    FS.Free;
  end;

Burada aslında yeni bir şeyler görmedik. Sadece öğrendiklerimizi bir problemin çözümünde kullandık.

Baslik yazdırılmadan önce, değişken uzunluktaki içeriğimiz olan memo’nun Text bilgisinin uzunluğunu, Baslik record verisi içine alıyoruz. Ardından bu recordu stream’e yazdıktan sonra, değişken içeriğin uzunluğu da yazılmış oldu. Ardından normal bir stringi yazdırır gibi bütün karakterlerini stream üzerine yazdırdık. Ardından da rastgele bir sayıyı bu değişken uzunluktaki veriden sonra yazdırdık. Artık programı çalıştırıp Memo içine bir şeyler yazalım ve button’a basıp verileri stream üzerine kaydedilim.

Şimdi gelelim bu stream formatının okunmasına… Bunun için ayrı yeni bir uygulama açalım ve bir button ekleyelim. Ve bu buttonun OnClick olayına geçip şunları yazalım:

var
  FS: TFileStream;
  Baslik: TDosyaBasligi;
  Icerik: string;
  Rastgele: Integer;
begin
  FS := TFileStream.Create('c:\deneme.dyz', fmOpenRead or fmShareDenyNone);
  try
    //Başlık bilgilerinin okunması
    FS.ReadBuffer(Baslik, SizeOf(TDosyaBasligi));

    if Baslik.Imza <> 'DYZ' then
    begin
      ShowMessage('Desteklenmeyen format');
      Exit;
    end;

    if Baslik.Versiyon > 1.2 then
    begin
      ShowMessage('Bu format ancak üst versiyonlarda açılabilir.');
      Exit;
    end;

    //Değişken boyutlu içeriğin okunması
    SetLength(Icerik, Baslik.IcerikBoyutu);
    FS.ReadBuffer(Icerik[1], Baslik.IcerikBoyutu);
    FS.ReadBuffer(Rastgele, SizeOf(Integer));

    ShowMessage(Icerik + #13 + IntToStr(Rastgele));
  finally
    FS.Free;
  end;
end;

Burada yaptığımız işlem sadece verilerin okunmasından ibaret. Sadece dikkat etmemiz gereken kısım, ReadBuffer‘ dan önce SetLength ile değişken uzunlukta olan verinin uzunluğunu belirlememiz gerekiyor.

Değişken uzunluktaki stringler bu şekilde okutulabilir.

Bir küçük tüyo olarak, verileri yazdırdığımız kısımdaki şu kodlara bir daha göz atmanızı isteyeceğim:

  Icerik := Memo1.Lines.Text;
  ......
  ......
  Baslik.IcerikBoyutu := Length(Icerik);

Bu kodlar Baslik recordunun yazılmasından evvel doldurulmaktadır. Bazen öyle durumlar oluyorki, veri uzunluğunu verinin stream’e tamamen yazdırılmasına kadar bilemiyoruz. Mesela değişken uzunlukta bu stringimiz, stream’e yazdırılma esnasında belli bir algoritma ile dinamik olarak oluşturuluyor olabilir. Bu durumda string verisi tamamen stream üzerine yazdırılmadan, uzunluğunu bilemeyiz. Bu durumda TStream‘e ait Seek metodunu kullanacağız. Bu metod stream üzerinde belli bir pozisyona atlamamızı sağlamaktadır. Bu durumda kodumuz şöyle bir şey olacaktı:

  //Şimdilik yer ayırmak için 0 yazdırıyoruz.
  Baslik.IcerikBoyutu := 0;
  FS.WriteBuffer(Baslik, SizeOf(TDosyaBasligi));

  .....
  .....
  //Stream üzerine verilerin yazdırılması ve boyutunun hesaplanması...
  //Burada değişken uzunluktaki veri yazdırılmakla birlikte boyutu da hesaplanıyor.
  .....
  .....

  FS.Seek(15, soFromBeginning);
  FS.WriteBuffer(IcerikBoyutu, SizeOf(Integer));

Aynı şeyi Baslik recordunu en sonda yazdırmakla da yapabilrdik. Veya daha başka yollar ile de bu dediklerimiz yapılabilir. Burada bilmemiz gereken Seek metodunun kullanımıdır. Seek metodunda ilk parametre olarak 15 girdik. Çünkü örneğimizdeki stream format tablomuza baktığımızda 15. byte pozisyonunda içerik boyutu bulunmaktadır. Seek ile stream’in yazma işaretçisini buraya taşıdık ve bu pozisyondan sonra 4 byte’lık bir Integer değer yazdırdık. Seek metodunda kullanılan ikinci parametre için help dosyalarını gezebilirsiniz.

Değişken uzunlukta olan diziler için, yani dinamik diziler için de aynı mantığı kullanmamız gerekmektedir. Değişken olan dizinin boyutunu da stream üzerine yazdırmamız ve okuma anında bu değeri okuyup diziyi SetLength ile tekrar oluşturmamız gerekmektedir. Yapacağımız işlemler aynı olacağı için bu kısmı size bırakıyorum.

Bu bölümde bu kadar bilgi yeterli. Gelecek bölümde stream verilerinin başka streamler üzerine aktarılması ve kopyalanması, streamler ile nesne ve bileşen kullanımı, hafıza, resource, veritabanı gibi ortamlarla stream kullanımı ve son olarak .NET ortamında stream kullanımından bahsedeceğiz. İkinci bölüme geçmeden burada anlatılanları iyi bir şekilde kavrayıp, kendi denemelerinizi yapmanız gerekmektedir.

Eleştiri ve yorumlarınızı bekliyorum…

Fatih Tolga Ata – 2008