14. Sınıf ve Nesne Kavramı (OOP Temelleri)

C# programlama dilinin en temel ve güçlü özelliklerinden biri, Nesne Yönelimli Programlama (OOP) paradigmasıdır. OOP, yazılım geliştirme sürecini daha düzenli, modüler ve yeniden kullanılabilir hale getirmeyi amaçlar. Bu yaklaşımın merkezinde ise sınıf ve nesne kavramları yer alır. Bu yazıda, C# dilinde sınıf ve nesne kavramlarını detaylı bir şekilde inceleyeceğiz.

Sınıf (Class) Nedir?

Sınıf, bir nesnenin şablonu veya planıdır. Başka bir deyişle, bir nesnenin hangi özelliklere (alanlar veya değişkenler) ve davranışlara (metotlar) sahip olacağını tanımlar. Sınıf, gerçek dünyadaki nesnelerin veya kavramların soyut bir temsilidir.

C# dilinde bir sınıf tanımlamak için `class` anahtar kelimesi kullanılır. Sınıfın içinde, o sınıfa ait alanlar (fields) ve metotlar (methods) tanımlanır.

Sınıf Tanımlama Sözdizimi

Bir sınıfın temel yapısı aşağıdaki gibidir:

class SinifAdi
{
    // Alanlar (Fields)
    // Metotlar (Methods)
}

Örnek:

Bir `Araba` sınıfı tanımlayalım. Bu sınıfın `Marka`, `Model`, `Renk` gibi alanları ve `Hizlan`, `Yavasla` gibi metotları olsun.

class Araba
{
    public string Marka;
    public string Model;
    public string Renk;

    public void Hizlan()
    {
        Console.WriteLine("Araba hızlanıyor!");
    }

    public void Yavasla()
    {
        Console.WriteLine("Araba yavaşlıyor!");
    }
}

Bu örnekte, `Araba` sınıfının temel özelliklerini ve davranışlarını tanımladık. Ancak, bu sınıf henüz somut bir araba değildir. Somut bir araba yaratmak için, bu sınıftan bir nesne (instance) oluşturmamız gerekir.

Nesne (Object) Nedir?

Nesne, bir sınıfın somut bir örneğidir. Sınıf bir plan veya şablon iken, nesne bu planın hayata geçirilmiş halidir. Bir sınıftan birden fazla nesne oluşturulabilir. Her nesne, sınıfın tanımladığı özelliklere ve davranışlara sahiptir, ancak her nesnenin özellikleri farklı değerlere sahip olabilir.

Nesne Oluşturma

C# dilinde bir nesne oluşturmak için `new` anahtar kelimesi kullanılır. `new` anahtar kelimesi, bellekte nesne için yer ayırır ve sınıfın kurucu metodunu (constructor) çağırır.

Örnek:

`Araba` sınıfından bir nesne oluşturalım:

Araba benimArabam = new Araba();
benimArabam.Marka = "Mercedes";
benimArabam.Model = "C180";
benimArabam.Renk = "Beyaz";

Console.WriteLine("Arabanın markası: " + benimArabam.Marka);
benimArabam.Hizlan();

Bu örnekte, `benimArabam` adında bir `Araba` nesnesi oluşturduk ve bu nesnenin `Marka`, `Model` ve `Renk` özelliklerine değerler atadık. Ardından, nesnenin `Hizlan` metodunu çağırdık.

OOP’nin Temel Prensipleri

Sınıf ve nesne kavramları, Nesne Yönelimli Programlama’nın temelini oluşturur. OOP’nin diğer önemli prensipleri şunlardır:

• Kapsülleme (Encapsulation): Verileri ve metotları bir arada tutarak, verilerin dışarıdan doğrudan erişilmesini engeller. Bu, veri güvenliğini artırır ve kodun daha modüler olmasını sağlar.
• Miras (Inheritance): Bir sınıfın (alt sınıf veya türetilmiş sınıf) başka bir sınıftan (üst sınıf veya temel sınıf) özelliklerini ve davranışlarını devralmasını sağlar. Bu, kodun yeniden kullanılabilirliğini artırır ve hiyerarşik bir yapı oluşturmayı kolaylaştırır.
• Çok Biçimlilik (Polymorphism): Bir nesnenin farklı şekillerde davranabilmesini sağlar. Bu, kodun daha esnek ve genişletilebilir olmasını sağlar.
• Soyutlama (Abstraction): Karmaşık sistemlerin temel özelliklerini ortaya çıkararak, gereksiz detayları gizler. Bu, kodun daha anlaşılır ve yönetilebilir olmasını sağlar.

Sınıf ve Nesne Kullanımının Avantajları

C# dilinde sınıf ve nesne kavramlarını kullanarak program yazmanın birçok avantajı vardır:

• Modülerlik: Kodun daha küçük ve yönetilebilir parçalara ayrılmasını sağlar.
• Yeniden Kullanılabilirlik: Sınıflar ve nesneler, farklı projelerde tekrar tekrar kullanılabilir.
• Bakım Kolaylığı: Kodun daha düzenli ve anlaşılır olmasını sağlar, bu da hataları bulmayı ve düzeltmeyi kolaylaştırır.
• Genişletilebilirlik: Yeni özellikler eklemek veya mevcut özellikleri değiştirmek daha kolaydır.

Sonuç

C# programlama dilinde sınıf ve nesne kavramları, modern yazılım geliştirme için vazgeçilmezdir. Bu kavramları anlamak ve doğru bir şekilde kullanmak, daha sağlam, ölçeklenebilir ve bakımı kolay uygulamalar geliştirmemizi sağlar. Nesne Yönelimli Programlama prensiplerini özümseyerek, yazılım geliştirme sürecini daha verimli ve keyifli hale getirebiliriz.

Umarım bu makale, C# dilinde sınıf ve nesne kavramlarını anlamanıza yardımcı olmuştur. Başarılar dilerim!

14. Sınıf ve Nesne Kavramı (OOP Temelleri) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

C# Programlama Dilinde Koşullu İfadeler (if-else, switch-case)

C# programlama dilinde, programların akışını kontrol etmek ve farklı durumlara göre farklı işlemler gerçekleştirmek için koşullu ifadeler kullanılır. Bu ifadeler, programın karar verme yeteneğini artırır ve daha karmaşık ve esnek uygulamalar geliştirmeyi mümkün kılar. En sık kullanılan koşullu ifadeler if-else ve switch-case yapısıdır. Bu makalede, bu yapıları detaylı bir şekilde inceleyeceğiz.

if-else İfadeleri

if-else ifadesi, bir koşulun doğru (true) veya yanlış (false) olmasına göre farklı kod bloklarını çalıştırmak için kullanılır. Temel sözdizimi şu şekildedir:

if (koşul)
{
    // Koşul doğru ise çalışacak kod bloğu
}
else
{
    // Koşul yanlış ise çalışacak kod bloğu
}

Burada koşul, bir boolean ifade olmalıdır. Eğer koşul doğru ise, if bloğu içindeki kod çalışır; aksi takdirde, eğer varsa else bloğu içindeki kod çalışır.

if İfadesi

Sadece bir koşulun doğruluğunu kontrol etmek ve eğer doğruysa bir kod bloğunu çalıştırmak istiyorsak, sadece if ifadesini kullanabiliriz. Örneğin:

int sayi = 10;
if (sayi > 0)
{
    Console.WriteLine("Sayı pozitiftir.");
}

Bu örnekte, sayi değişkeninin değeri 0’dan büyükse, ekrana “Sayı pozitiftir.” yazdırılır.

else İfadesi

Bir koşulun yanlış olması durumunda da bir işlem yapmak istiyorsak, else ifadesini kullanırız. Örneğin:

int sayi = -5;
if (sayi > 0)
{
    Console.WriteLine("Sayı pozitiftir.");
}
else
{
    Console.WriteLine("Sayı negatif veya sıfırdır.");
}

Bu örnekte, sayi değişkeninin değeri 0’dan büyük değilse, ekrana “Sayı negatif veya sıfırdır.” yazdırılır.

else if İfadesi

Birden fazla koşulu kontrol etmek ve farklı koşullara göre farklı işlemler yapmak istiyorsak, else if ifadesini kullanırız. Örneğin:

int not = 75;

if (not >= 90)
{
    Console.WriteLine("A");
}
else if (not >= 80)
{
    Console.WriteLine("B");
}
else if (not >= 70)
{
    Console.WriteLine("C");
}
else if (not >= 60)
{
    Console.WriteLine("D");
}
else
{
    Console.WriteLine("F");
}

Bu örnekte, not değişkeninin değerine göre farklı notlar (A, B, C, D, F) ekrana yazdırılır. else if zinciri, yukarıdan aşağıya doğru koşulları kontrol eder ve ilk doğru olan koşulun bloğunu çalıştırır. Eğer hiçbir koşul doğru değilse, en sondaki else bloğu çalışır.

switch-case İfadesi

switch-case ifadesi, bir değişkenin değerine göre farklı kod bloklarını çalıştırmak için kullanılır. Özellikle, bir değişkenin birden fazla olası değeri olduğunda ve her bir değer için farklı bir işlem yapmak gerektiğinde kullanışlıdır. Temel sözdizimi şu şekildedir:

switch (değişken)
{
    case değer1:
        // değişken değeri değer1 ise çalışacak kod bloğu
        break;
    case değer2:
        // değişken değeri değer2 ise çalışacak kod bloğu
        break;
    ...
    default:
        // değişken değeri hiçbir case ile eşleşmezse çalışacak kod bloğu
        break;
}

Burada değişken, bir ifade veya değişken olabilir. case etiketleri, değişkenin olası değerlerini temsil eder. Eğer değişkenin değeri bir case etiketiyle eşleşirse, o case bloğu içindeki kod çalışır. break ifadesi, switch ifadesinden çıkılmasını sağlar. Eğer break ifadesi kullanılmazsa, eşleşen case bloğundan sonraki case blokları da çalıştırılır (fall-through). default etiketi, değişkenin değeri hiçbir case etiketiyle eşleşmezse çalışacak olan kod bloğunu belirtir.

Örneğin:

int gun = 3;
string gunAdi;

switch (gun)
{
    case 1:
        gunAdi = "Pazartesi";
        break;
    case 2:
        gunAdi = "Salı";
        break;
    case 3:
        gunAdi = "Çarşamba";
        break;
    case 4:
        gunAdi = "Perşembe";
        break;
    case 5:
        gunAdi = "Cuma";
        break;
    case 6:
        gunAdi = "Cumartesi";
        break;
    case 7:
        gunAdi = "Pazar";
        break;
    default:
        gunAdi = "Geçersiz gün numarası";
        break;
}

Console.WriteLine("Gün: " + gunAdi);

Bu örnekte, gun değişkeninin değerine göre haftanın gün adı belirlenir ve ekrana yazdırılır. Eğer gun değişkeninin değeri 1 ile 7 arasında değilse, default bloğu çalışır ve ekrana “Geçersiz gün numarası” yazdırılır.

Koşullu İfadelerin Önemi

Koşullu ifadeler, programlama dillerinin temel yapı taşlarından biridir ve programların karar verme yeteneğini sağlar. Bu sayede, programlar farklı durumlara uyum sağlayabilir, kullanıcı girdilerine göre farklı işlemler gerçekleştirebilir ve daha karmaşık algoritmalar uygulayabilir. if-else ve switch-case ifadeleri, C# programlama dilinde en sık kullanılan koşullu ifadelerdir ve programların akışını kontrol etmek için vazgeçilmez araçlardır.

Doğru ve etkili koşullu ifadeler kullanarak, daha okunabilir, bakımı kolay ve hatasız kodlar yazabilirsiniz. Bu nedenle, koşullu ifadelerin kullanımını iyi anlamak ve pratik yapmak, başarılı bir C# programcısı olmak için önemlidir.

Sonuç

Bu makalede, C# programlama dilinde kullanılan koşullu ifadelerden if-else ve switch-case yapılarını detaylı bir şekilde inceledik. Bu yapıların nasıl kullanıldığını, ne zaman tercih edildiğini ve programların akışını nasıl kontrol ettiğini öğrendik. Koşullu ifadeler, programlama becerilerinizi geliştirmenize ve daha karmaşık uygulamalar oluşturmanıza yardımcı olacaktır.

“Koşullu ifadeler, programların karar verme mekanizmalarını oluşturur ve onları daha akıllı hale getirir.” – Bilge Programcı

6. Koşullu İfadeler (if-else, switch-case) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

2. C# ile İlk Programınızı Yazmak (Hello World)

C# programlama diline hoş geldiniz! Bu makalede, C# ile ilk programınızı nasıl yazacağınızı adım adım öğreneceksiniz. Geleneksel olarak, programlamaya yeni başlayanlar için ilk program genellikle ekrana “Hello, World!” yazdırmaktır. Bu basit program, dilin temel sözdizimini anlamanıza ve geliştirme ortamınızı doğru şekilde kurmanıza yardımcı olur. Şimdi, C# ile “Hello, World!” programını yazmaya başlayalım.

Gerekli Araçlar ve Ortam Hazırlığı

C# programlama yapabilmek için öncelikle bazı araçlara ihtiyacınız olacak:

• .NET SDK (Software Development Kit): C# kodunu derlemek ve çalıştırmak için gereklidir. En güncel sürümünü Microsoft’un web sitesinden indirebilirsiniz.
• Bir Metin Editörü veya IDE (Integrated Development Environment): Kod yazmak için bir metin editörü (örn., VS Code, Sublime Text) veya bir IDE (örn., Visual Studio, JetBrains Rider) kullanabilirsiniz. IDE’ler genellikle kod tamamlama, hata ayıklama ve diğer geliştirme araçlarını içerir.

Bu makalede, Visual Studio Code’un (VS Code) yaygın olarak kullanılan ve platform bağımsız bir seçenek olması nedeniyle kullanılacağını varsayacağız. VS Code’u resmi web sitesinden indirebilirsiniz. VS Code’u kurduktan sonra, C# desteği için C# eklentisini yüklemeniz gerekecektir.

“Hello, World!” Programını Yazma

Artık geliştirme ortamınız hazır olduğuna göre, ilk C# programımızı yazabiliriz. Aşağıdaki adımları izleyin:

1. Yeni Bir Dosya Oluşturun: VS Code’u açın ve yeni bir dosya oluşturun. Dosyayı HelloWorld.cs olarak kaydedin. .cs uzantısı, bu dosyanın bir C# kaynak kodu dosyası olduğunu belirtir.
2. Kodu Yazın: Aşağıdaki C# kodunu HelloWorld.cs dosyasına yazın:

using System;

namespace HelloWorld
{
 class Program
 {
 static void Main(string[] args)
 {
 Console.WriteLine("Hello, World!");
 }
 }
}

Şimdi bu kodu satır satır inceleyelim:

using System;

Bu satır, System ad alanını (namespace) programa dahil eder. System ad alanı, temel sınıfları ve C# programlarında sıkça kullanılan işlevleri içerir. Örneğin, Console.WriteLine metodu bu ad alanı içinde tanımlanmıştır.

namespace HelloWorld

namespace anahtar kelimesi, kodunuzu mantıksal olarak gruplandırmak için kullanılır. Bu örnekte, tüm kodumuz HelloWorld ad alanı içinde yer almaktadır. Ad alanları, büyük projelerde kodun düzenlenmesine ve çakışmaların önlenmesine yardımcı olur.

class Program

C# bir nesne yönelimli (object-oriented) dildir ve her şey sınıflar (class) içinde tanımlanır. Bu satır, Program adında bir sınıf tanımlar. Programımızın ana işlevselliği bu sınıf içinde yer alacaktır.

static void Main(string[] args)

Bu, programımızın giriş noktasıdır (entry point). C# programı çalıştırıldığında, ilk olarak bu metot çalıştırılır. static anahtar kelimesi, bu metodun sınıfın bir örneği oluşturulmadan çağrılabileceğini belirtir. void anahtar kelimesi, bu metodun herhangi bir değer döndürmediğini gösterir. string[] args parametresi, komut satırından programa geçirilen argümanları temsil eder.

Console.WriteLine(“Hello, World!”);

Bu satır, Console sınıfının WriteLine metodunu kullanarak ekrana “Hello, World!” metnini yazdırır. Console sınıfı, konsol ile ilgili işlemleri gerçekleştirmek için kullanılır. WriteLine metodu, belirtilen metni konsola yazdırır ve ardından bir sonraki satıra geçer.

Programı Derleme ve Çalıştırma

Kodu yazdıktan sonra, programı derlememiz ve çalıştırmamız gerekir. VS Code’da, bir terminal açarak (View -> Terminal) aşağıdaki komutları kullanabilirsiniz:

• Derleme: dotnet build komutunu kullanarak programı derleyin. Bu komut, HelloWorld.cs dosyasını derleyerek yürütülebilir bir dosya oluşturur.

dotnet build

• Çalıştırma: dotnet run komutunu kullanarak programı çalıştırın. Bu komut, derlenmiş olan programı yürütür ve “Hello, World!” metnini konsola yazdırır.

dotnet run

Eğer her şey yolunda gittiyse, terminalde “Hello, World!” yazısını görmelisiniz. Tebrikler, ilk C# programınızı başarıyla yazdınız ve çalıştırdınız!

Özet

Bu makalede, C# ile ilk programınızı nasıl yazacağınızı öğrendiniz. “Hello, World!” programı, C# dilinin temel sözdizimini anlamanıza ve geliştirme ortamınızı doğru şekilde kurmanıza yardımcı oldu. Artık daha karmaşık programlar yazmaya başlayabilirsiniz. C# dünyasına adım attığınız için tebrikler ve başarılar dileriz!

“Programlamaya başlamak her zaman heyecan vericidir. ‘Hello, World!’ programı, sadece bir başlangıçtır. Sürekli öğrenmeye ve pratik yapmaya devam ederek, harika şeyler başarabilirsiniz.” – Bir Yazılım Geliştirici

Unutmayın, pratik yapmak ve sürekli öğrenmek, başarılı bir yazılımcı olmanın anahtarıdır. C# programlama dilinde kendinizi geliştirmek için çeşitli kaynaklardan (kitaplar, online kurslar, dokümanlar) yararlanabilirsiniz.

2. C# ile İlk Programınızı Yazmak (Hello World) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

13. Dosya İşlemleri (File I/O) – Temel Seviye

Delphi programlama dilinde dosya işlemleri (File I/O), programınızın dış dünya ile iletişim kurmasını sağlayan temel bir yetenektir. Bu, verilerin kalıcı olarak saklanması, yapılandırılmış verilerin okunması, log dosyalarının oluşturulması veya farklı uygulamalar arasında veri alışverişi gibi birçok senaryoda kullanılır. Bu makalede, Delphi’de dosya işlemlerinin temel seviyesine odaklanacağız ve dosya okuma, yazma ve yönetme konularını ele alacağız.

Dosya İşlemlerine Giriş

Dosya işlemleri, programınızın disk üzerindeki dosyalarla etkileşim kurmasını içerir. Bu etkileşim, dosyaları açma, okuma, yazma, kapatma ve silme gibi işlemleri kapsar. Delphi, dosya işlemlerini gerçekleştirmek için çeşitli fonksiyonlar ve nesneler sunar.

Dosya Türleri

Delphi’de, temelde iki tür dosya bulunur:

• Metin Dosyaları (Text Files): ASCII veya Unicode karakterler içeren dosyalardır. İnsan tarafından okunabilir formatta veri saklarlar.
• İkili Dosyalar (Binary Files): Herhangi bir türde veri (sayılar, yapılar, nesneler vb.) içerebilen dosyalardır. Genellikle insan tarafından doğrudan okunamazlar.

Metin Dosyası İşlemleri

Metin dosyaları, genellikle yapılandırılmış verileri saklamak ve işlemek için kullanılır. Delphi’de metin dosyalarıyla çalışmak için `TextFile` türünü ve ilgili fonksiyonları kullanırız.

Dosya Açma ve Kapama

Bir metin dosyasını açmak için `AssignFile`, `Reset` (okuma için) veya `Rewrite` (yazma için) fonksiyonları kullanılır. Dosya işlemleri tamamlandıktan sonra `CloseFile` fonksiyonu ile dosya kapatılmalıdır.

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'data.txt');
  Rewrite(MyFile); // Yeni bir dosya oluştur veya varsa üzerine yaz
  // Dosyaya yazma işlemleri
  CloseFile(MyFile);
end;

Okuma için ise:

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'data.txt');
  Reset(MyFile); // Dosyayı okuma modunda aç
  // Dosyadan okuma işlemleri
  CloseFile(MyFile);
end;

Dosyaya Yazma

Metin dosyasına veri yazmak için `Write` veya `WriteLn` fonksiyonları kullanılır. `Write`, veriyi olduğu gibi dosyaya yazarken, `WriteLn` veriyi yazdıktan sonra bir satır sonu karakteri ekler.

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'output.txt');
  Rewrite(MyFile);
  WriteLn(MyFile, 'Merhaba, Dünya!');
  WriteLn(MyFile, 'Bu bir Delphi örneğidir.');
  CloseFile(MyFile);
end;

Dosyadan Okuma

Metin dosyasından veri okumak için `Read` veya `ReadLn` fonksiyonları kullanılır. `Read`, belirli sayıda karakteri okurken, `ReadLn` bir satır sonuna kadar okur.

var
  MyFile: TextFile;
  Line: string;
begin
  AssignFile(MyFile, 'output.txt');
  Reset(MyFile);
  while not Eof(MyFile) do
  begin
    ReadLn(MyFile, Line);
    ShowMessage(Line); // Okunan satırı göster
  end;
  CloseFile(MyFile);
end;

`Eof(MyFile)` fonksiyonu, dosyanın sonuna gelinip gelinmediğini kontrol eder. Bu, döngü içinde dosya okurken önemlidir.

İkili Dosya İşlemleri

İkili dosyalar, yapılandırılmış verileri daha verimli bir şekilde saklamak için kullanılır. Delphi’de ikili dosyalarla çalışmak için `File` türünü ve ilgili fonksiyonları kullanırız.

Dosya Açma ve Kapama (İkili)

İkili dosyaları açmak için `AssignFile`, `Reset` (okuma için) veya `Rewrite` (yazma için) fonksiyonları kullanılır. Ancak, ikili dosyalar için `File` türü kullanılır.

var
  MyFile: File;
begin
  AssignFile(MyFile, 'data.bin');
  Rewrite(MyFile, 1); // Boyut parametresi (genellikle 1 kullanılır)
  // Dosyaya yazma işlemleri
  CloseFile(MyFile);
end;

Okuma için:

var
  MyFile: File;
begin
  AssignFile(MyFile, 'data.bin');
  Reset(MyFile, 1); // Boyut parametresi (genellikle 1 kullanılır)
  // Dosyadan okuma işlemleri
  CloseFile(MyFile);
end;

Dosyaya Yazma (İkili)

İkili dosyaya veri yazmak için `BlockWrite` fonksiyonu kullanılır. Bu fonksiyon, bir bellek bloğunu doğrudan dosyaya yazar.

var
  MyFile: File;
  Data: array[0..9] of Integer;
  i: Integer;
begin
  AssignFile(MyFile, 'data.bin');
  Rewrite(MyFile, SizeOf(Integer));

  // Veri doldur
  for i := 0 to 9 do
    Data[i] := i * 10;

  BlockWrite(MyFile, Data, SizeOf(Data));
  CloseFile(MyFile);
end;

Dosyadan Okuma (İkili)

İkili dosyadan veri okumak için `BlockRead` fonksiyonu kullanılır. Bu fonksiyon, dosyadan bir bellek bloğunu okur.

var
  MyFile: File;
  Data: array[0..9] of Integer;
  i: Integer;
  BytesRead: Integer;
begin
  AssignFile(MyFile, 'data.bin');
  Reset(MyFile, SizeOf(Integer));

  BlockRead(MyFile, Data, SizeOf(Data), BytesRead);

  // Okunan veriyi işle
  for i := 0 to 9 do
    ShowMessage(IntToStr(Data[i]));

  CloseFile(MyFile);
end;

`BlockRead` fonksiyonu, okunan byte sayısını `BytesRead` parametresinde döndürür. Bu, dosyanın sonuna ulaşıldığında veya bir hata oluştuğunda önemlidir.

Ek Fonksiyonlar ve Dikkat Edilmesi Gerekenler

• FileExists(FileName: string): Boolean: Dosyanın var olup olmadığını kontrol eder.
• DeleteFile(FileName: string): Boolean: Dosyayı siler.
• RenameFile(OldName, NewName: string): Boolean: Dosyanın adını değiştirir.
• Dosya işlemlerinde hata kontrolü önemlidir. `IOResult` değişkenini kullanarak hataları kontrol edebilirsiniz.
• Dosyaları açarken ve kapatırken dikkatli olun. Açık unutulan dosyalar, kaynak tüketimine ve veri kaybına neden olabilir.

Sonuç

Delphi’de dosya işlemleri, uygulamalarınızın dış dünya ile etkileşim kurmasını sağlayan güçlü bir araçtır. Bu makalede, temel metin ve ikili dosya işlemlerini ele aldık. Bu bilgilerle, kendi uygulamalarınızda dosya okuma, yazma ve yönetme işlemlerini gerçekleştirebilirsiniz. Unutmayın, dosya işlemlerinde dikkatli olmak ve hata kontrolünü ihmal etmemek önemlidir.

Dosya işlemleri konusunu daha derinlemesine incelemek için Delphi’nin online yardımına ve çeşitli kaynaklara başvurabilirsiniz. Başarılar!

Önemli Not: Bu makale temel seviyede dosya işlemlerini kapsamaktadır. Daha karmaşık senaryolar için, örneğin veritabanı işlemleri veya ağ üzerinden dosya transferi, daha gelişmiş teknikler ve kütüphaneler kullanmanız gerekebilir.

Umarım bu makale Delphi programlama dilinde dosya işlemleri konusunda size yardımcı olmuştur. İyi kodlamalar!

13.Dosya İşlemleri (File I/O) – Temel Seviye yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

11.Kayıt Tipleri (Records) ve Sabitler (Const)

Delphi programlama dilinde, veri yapılarını düzenlemek ve programın okunabilirliğini artırmak için çeşitli araçlar bulunur. Bu araçlardan ikisi de kayıt tipleri (records) ve sabitler (constants)‘dir. Bu makalede, kayıt tiplerinin ne olduğunu, nasıl kullanıldığını ve sabitlerin programlamadaki önemini detaylı bir şekilde inceleyeceğiz.

Kayıt Tipleri (Records) Nedir?

Kayıt tipleri, farklı veri türlerini tek bir çatı altında toplamanıza olanak tanıyan veri yapılarıdır. Başka bir deyişle, birbiriyle ilişkili farklı türdeki verileri bir araya getirerek daha anlamlı ve düzenli yapılar oluşturabilirsiniz. Örneğin, bir öğrencinin adını, soyadını, numarasını ve not ortalamasını tek bir kayıt altında tutabilirsiniz.

Kayıt Tipi Tanımlama

Kayıt tipleri, type anahtar kelimesiyle tanımlanır. İşte basit bir örnek:

type
  Ogrenci = record
    Ad: string;
    Soyad: string;
    Numara: Integer;
    NotOrtalamasi: Real;
  end;

Bu tanımlamada, Ogrenci adında bir kayıt tipi oluşturduk. Bu kayıt tipi, Ad (string), Soyad (string), Numara (Integer) ve NotOrtalamasi (Real) olmak üzere dört farklı alana sahiptir.

Kayıt Tipi Kullanımı

Kayıt tipini tanımladıktan sonra, bu tipten değişkenler oluşturabilir ve alanlarına erişebilirsiniz. İşte bir örnek:

var
  ogr1: Ogrenci;

begin
  ogr1.Ad := 'Ahmet';
  ogr1.Soyad := 'Yılmaz';
  ogr1.Numara := 12345;
  ogr1.NotOrtalamasi := 3.5;

  ShowMessage('Öğrenci Adı: ' + ogr1.Ad);
  ShowMessage('Öğrenci Soyadı: ' + ogr1.Soyad);
  ShowMessage('Öğrenci Numarası: ' + IntToStr(ogr1.Numara));
  ShowMessage('Öğrenci Not Ortalaması: ' + FloatToStr(ogr1.NotOrtalamasi));
end;

Bu örnekte, ogr1 adında bir Ogrenci tipinde değişken oluşturduk ve bu değişkenin alanlarına değerler atadık. Daha sonra, bu değerleri ekrana yazdırdık.

İç İçe Kayıtlar (Nested Records)

Kayıt tipleri, iç içe de kullanılabilir. Yani, bir kayıt tipinin içinde başka bir kayıt tipi bulunabilir. Bu, daha karmaşık veri yapıları oluşturmanıza olanak tanır. Örneğin, bir öğrencinin adres bilgilerini ayrı bir kayıt tipinde tanımlayıp, bu kayıt tipini Ogrenci kayıt tipinin içinde kullanabilirsiniz.

type
  Adres = record
    Sehir: string;
    Ilce: string;
    Mahalle: string;
  end;

  Ogrenci = record
    Ad: string;
    Soyad: string;
    Numara: Integer;
    NotOrtalamasi: Real;
    AdresBilgisi: Adres;
  end;

var
  ogr1: Ogrenci;

begin
  ogr1.Ad := 'Ahmet';
  ogr1.Soyad := 'Yılmaz';
  ogr1.Numara := 12345;
  ogr1.NotOrtalamasi := 3.5;
  ogr1.AdresBilgisi.Sehir := 'İstanbul';
  ogr1.AdresBilgisi.Ilce := 'Kadıköy';
  ogr1.AdresBilgisi.Mahalle := 'Caferağa';

  ShowMessage('Öğrenci Şehri: ' + ogr1.AdresBilgisi.Sehir);
end;

Bu örnekte, Adres adında bir kayıt tipi tanımladık ve bu kayıt tipini Ogrenci kayıt tipinin içinde AdresBilgisi adıyla kullandık.

Sabitler (Constants) Nedir?

Sabitler, programın çalışması sırasında değeri değişmeyen değerlerdir. Program içinde sabit bir değeri birden fazla yerde kullanmanız gerektiğinde, bu değeri bir sabit olarak tanımlamak, hem kodun okunabilirliğini artırır hem de değeri değiştirmek istediğinizde tek bir yerden değişiklik yapmanızı sağlar.

Sabit Tanımlama

Sabitler, const anahtar kelimesiyle tanımlanır. İşte basit bir örnek:

const
  PI = 3.14159;
  MAKSIMUM_OGRENCI_SAYISI = 100;
  UYGULAMA_ADI = 'Delphi Uygulaması';

Bu tanımlamada, PI, MAKSIMUM_OGRENCI_SAYISI ve UYGULAMA_ADI adında üç farklı sabit tanımladık. Sabitlerin değerleri programın çalışması sırasında değiştirilemez.

Sabit Kullanımı

Sabitler, değişkenler gibi kullanılabilir. İşte bir örnek:

const
  PI = 3.14159;

var
  yaricap: Real;
  alan: Real;

begin
  yaricap := 5;
  alan := PI * yaricap * yaricap;

  ShowMessage('Dairenin Alanı: ' + FloatToStr(alan));
end;

Bu örnekte, PI sabitini kullanarak bir dairenin alanını hesapladık.

Tip Belirtilmiş Sabitler (Typed Constants)

Delphi’de, sabitlere tip de belirtebilirsiniz. Bu, daha güvenli ve okunabilir kod yazmanıza yardımcı olur. İşte bir örnek:

const
  PI: Real = 3.14159;
  MAKSIMUM_OGRENCI_SAYISI: Integer = 100;
  UYGULAMA_ADI: string = 'Delphi Uygulaması';

Bu tanımlamada, sabitlerin tiplerini de belirttik. Bu, derleyicinin tip uyumsuzluğu hatalarını daha erken yakalamasına yardımcı olur.

Kayıtlar ve Sabitlerin Birlikte Kullanımı

Kayıt tipleri ve sabitler, birlikte kullanılarak daha karmaşık ve düzenli yapılar oluşturulabilir. Örneğin, bir şirketin çalışan bilgilerini tutan bir kayıt tipi tanımlayabilir ve şirketin adını bir sabit olarak tanımlayabilirsiniz.

const
  SIRKET_ADI = 'Delphi A.Ş.';

type
  Calisan = record
    Ad: string;
    Soyad: string;
    Departman: string;
    Maas: Real;
  end;

var
  calisan1: Calisan;

begin
  calisan1.Ad := 'Ayşe';
  calisan1.Soyad := 'Demir';
  calisan1.Departman := 'Yazılım Geliştirme';
  calisan1.Maas := 5000;

  ShowMessage('Şirket Adı: ' + SIRKET_ADI);
  ShowMessage('Çalışan Adı: ' + calisan1.Ad);
end;

Bu örnekte, SIRKET_ADI adında bir sabit tanımladık ve Calisan adında bir kayıt tipi oluşturduk. Daha sonra, bu sabit ve kayıt tipini birlikte kullandık.

Sonuç

Kayıt tipleri (records) ve sabitler (constants), Delphi programlama dilinde veri yapılarını düzenlemek ve programın okunabilirliğini artırmak için önemli araçlardır. Kayıt tipleri, farklı veri türlerini tek bir çatı altında toplamanıza olanak tanırken, sabitler programın çalışması sırasında değeri değişmeyen değerleri tanımlamanızı sağlar. Bu araçları doğru kullanarak, daha düzenli, okunabilir ve bakımı kolay programlar yazabilirsiniz.

Bu makalede, kayıt tiplerinin ve sabitlerin ne olduğunu, nasıl tanımlandığını ve kullanıldığını detaylı bir şekilde inceledik. Umarım bu bilgiler, Delphi programlama becerilerinizi geliştirmenize yardımcı olur.

11.Kayıt Tipleri (Records) ve Sabitler (Const) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

7. Prosedürler ve Fonksiyonlar (Metotlar)

Delphi programlama dilinde, kodun düzenlenmesi, yeniden kullanılabilirliğinin artırılması ve karmaşıklığının azaltılması için prosedürler ve fonksiyonlar (genellikle metotlar olarak da adlandırılır) önemli bir rol oynar. Bu yapılar, belirli bir görevi gerçekleştiren kod bloklarını temsil eder ve programın farklı yerlerinden çağrılarak tekrar tekrar kullanılabilir.

Prosedürler

Prosedürler, belirli bir işlemi gerçekleştiren ve herhangi bir değer döndürmeyen kod bloklarıdır. Bir prosedür, parametre alabilir veya almayabilir. Parametreler, prosedüre girdi olarak sağlanan değerlerdir ve prosedürün davranışını etkiler.

Prosedür Tanımlama

Bir prosedür aşağıdaki gibi tanımlanır:

procedure ProsedurAdi(Parametre1: VeriTipi; Parametre2: VeriTipi);
begin
  // Prosedürün gerçekleştireceği işlemler
end;

Örneğin, iki sayıyı toplayıp sonucu ekrana yazdıran bir prosedür şöyle olabilir:

procedure ToplaVeYaz(Sayi1: Integer; Sayi2: Integer);
var
  Sonuc: Integer;
begin
  Sonuc := Sayi1 + Sayi2;
  ShowMessage('Sonuç: ' + IntToStr(Sonuc));
end;

Prosedür Çağırma

Bir prosedürü çağırmak için adını ve varsa parametrelerini belirtmeniz yeterlidir:

ToplaVeYaz(5, 3); // Ekrana "Sonuç: 8" yazdırır

Fonksiyonlar

Fonksiyonlar, prosedürlere benzer, ancak bir değer döndürürler. Bu değer, fonksiyonun gerçekleştirdiği işlemin sonucudur. Fonksiyonlar da parametre alabilir veya almayabilir.

Fonksiyon Tanımlama

Bir fonksiyon aşağıdaki gibi tanımlanır:

function FonksiyonAdi(Parametre1: VeriTipi; Parametre2: VeriTipi): DonusTipi;
begin
  // Fonksiyonun gerçekleştireceği işlemler
  // DonusTipi türünde bir değer döndürmeli
  Result := DonusDegeri;
end;

Örneğin, iki sayıyı toplayıp sonucu döndüren bir fonksiyon şöyle olabilir:

function Topla(Sayi1: Integer; Sayi2: Integer): Integer;
begin
  Result := Sayi1 + Sayi2;
end;

Fonksiyon Çağırma

Bir fonksiyonu çağırmak ve döndürdüğü değeri kullanmak için şöyle bir ifade kullanabilirsiniz:

var
  Toplam: Integer;
begin
  Toplam := Topla(5, 3);
  ShowMessage('Toplam: ' + IntToStr(Toplam)); // Ekrana "Toplam: 8" yazdırır
end;

Prosedürler ve Fonksiyonlar Arasındaki Farklar

Temel fark, fonksiyonların bir değer döndürmesi, prosedürlerin ise döndürmemesidir. Fonksiyonlar genellikle bir hesaplama veya dönüşüm işleminin sonucunu elde etmek için kullanılırken, prosedürler genellikle bir eylemi gerçekleştirmek veya bir durumu değiştirmek için kullanılır.

• Değer Döndürme: Fonksiyonlar değer döndürür, prosedürler döndürmez.
• Kullanım Amacı: Fonksiyonlar genellikle hesaplama, dönüşüm gibi işlemler için, prosedürler ise eylem veya durum değişikliği için kullanılır.

Metotlar (Nesne Yönelimli Programlama Bağlamında)

Delphi, nesne yönelimli bir programlama dilidir. Bu bağlamda, metotlar, bir nesneye ait prosedür veya fonksiyonlardır. Metotlar, nesnenin davranışını tanımlar ve nesnenin verileri üzerinde işlem yapar.

Metot Tanımlama

Bir sınıf içinde metotlar aşağıdaki gibi tanımlanır:

type
  TOrnekSinif = class
  private
    FVeri: Integer;
  public
    procedure Metot1;
    function Metot2: String;
  end;

implementation

procedure TOrnekSinif.Metot1;
begin
  // Metot1'in gerçekleştireceği işlemler
end;

function TOrnekSinif.Metot2: String;
begin
  Result := 'Merhaba Dünya!';
end;

Metot Çağırma

Bir nesnenin metodunu çağırmak için nokta notasyonu kullanılır:

var
  OrnekNesne: TOrnekSinif;
begin
  OrnekNesne := TOrnekSinif.Create;
  OrnekNesne.Metot1; // Metot1 çağrılıyor
  ShowMessage(OrnekNesne.Metot2); // Metot2 çağrılıyor ve sonucu ekrana yazdırılıyor
  OrnekNesne.Free;
end;

Parametre Geçirme Yöntemleri

Delphi’de parametreler prosedürlere ve fonksiyonlara farklı şekillerde geçirilebilir. Bu yöntemler, parametrelerin nasıl kullanıldığı ve nasıl değiştirilebildiği üzerinde etkilidir.

• Değer ile Geçirme (By Value): Parametrenin bir kopyası fonksiyona veya prosedüre geçirilir. Fonksiyon veya prosedür içindeki değişiklikler orijinal parametreyi etkilemez.
• Referans ile Geçirme (By Reference): Parametrenin adresi fonksiyona veya prosedüre geçirilir. Fonksiyon veya prosedür içindeki değişiklikler orijinal parametreyi etkiler. `var` anahtar kelimesi ile belirtilir.
• Sabit Referans ile Geçirme (Const): Parametre referans ile geçirilir, ancak fonksiyon veya prosedür içinde değiştirilemez. Bu, performans açısından avantajlıdır çünkü veri kopyalanmaz, ancak güvenliği de sağlar.

Örnek Parametre Geçirme Yöntemleri

procedure DegerIleGec(Sayi: Integer);
begin
  Sayi := Sayi + 10; // Bu değişiklik ana programdaki Sayi değişkenini etkilemez
end;

procedure ReferansIleGec(var Sayi: Integer);
begin
  Sayi := Sayi + 10; // Bu değişiklik ana programdaki Sayi değişkenini etkiler
end;

procedure SabitReferansIleGec(const Sayi: Integer);
begin
  // Sayi := Sayi + 10; // Bu satır hata verir, çünkü Sayi değiştirilemez
end;

İleri Düzey Kullanım: Fonksiyon Göstericileri (Function Pointers)

Delphi, fonksiyon göstericilerini destekler. Bu, bir fonksiyonun adresini bir değişkende saklayıp, bu değişken aracılığıyla fonksiyonu çağırmanıza olanak tanır. Fonksiyon göstericileri, esnek ve dinamik programlama teknikleri için önemlidir.

type
  TToplamaFonksiyonu = function(Sayi1, Sayi2: Integer): Integer;

var
  FonksiyonGostericisi: TToplamaFonksiyonu;

function Topla(Sayi1, Sayi2: Integer): Integer;
begin
  Result := Sayi1 + Sayi2;
end;

begin
  FonksiyonGostericisi := Topla;
  ShowMessage(IntToStr(FonksiyonGostericisi(5, 3))); // Ekrana "8" yazdırır
end;

Sonuç

Prosedürler ve fonksiyonlar, Delphi programlama dilinde kodun modülerleştirilmesi, yeniden kullanılabilirliğinin artırılması ve okunabilirliğinin iyileştirilmesi için temel araçlardır. Metotlar ise, nesne yönelimli programlamanın önemli bir parçasıdır ve nesnelerin davranışlarını tanımlar. Parametre geçirme yöntemleri ve fonksiyon göstericileri gibi ileri düzey özellikler, daha esnek ve güçlü uygulamalar geliştirmenize olanak tanır. Bu yapıları etkin bir şekilde kullanarak, daha karmaşık ve yönetilebilir Delphi uygulamaları oluşturabilirsiniz.

“Prosedürler ve fonksiyonlar, yazılım mühendisliğinin temel taşlarıdır. İyi tasarlanmış prosedürler ve fonksiyonlar, kodun anlaşılmasını kolaylaştırır ve hataları azaltır.” – Yazılım Uzmanı

7. Prosedürler ve Fonksiyonlar (Metotlar) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

5. Koşullu İfadeler (if-else, case of)

Delphi programlama dilinde, program akışını kontrol etmek ve farklı durumlara göre farklı işlemler yapmak için koşullu ifadeler kullanılır. En yaygın kullanılan koşullu ifadeler if-else ve case of deyimleridir. Bu ifadeler, belirli bir koşulun doğru (True) veya yanlış (False) olmasına bağlı olarak farklı kod bloklarını çalıştırmayı sağlar.

if-else Deyimi

if-else deyimi, bir koşulun değerlendirilmesi ve sonucuna göre farklı kod bloklarının çalıştırılması için kullanılır. if anahtar kelimesi, bir koşulu belirtir. Eğer bu koşul doğruysa, then anahtar kelimesinden sonra gelen kod bloğu çalıştırılır. Eğer koşul yanlışsa, else anahtar kelimesinden sonra gelen kod bloğu çalıştırılır. else bloğu opsiyoneldir, yani sadece koşulun yanlış olduğu durumda yapılacak bir işlem yoksa kullanılmayabilir.

if Deyiminin Temel Yapısı

if deyiminin temel yapısı aşağıdaki gibidir:

if koşul then
begin
  // Koşul doğruysa yapılacak işlemler
end;

Eğer sadece tek bir işlem yapılacaksa, begin ve end blokları kullanılmayabilir. Ancak okunabilirliği artırmak ve olası hataları önlemek için blok kullanılması önerilir.

else Deyiminin Kullanımı

else deyimi, koşulun yanlış olduğu durumda yapılacak işlemleri belirtir. Yapısı aşağıdaki gibidir:

if koşul then
begin
  // Koşul doğruysa yapılacak işlemler
end
else
begin
  // Koşul yanlışsa yapılacak işlemler
end;

İç İçe if Deyimleri (Nested if)

if deyimleri iç içe kullanılabilir. Bu, daha karmaşık koşulları değerlendirmek için kullanışlıdır. Örneğin:

if koşul1 then
begin
  if koşul2 then
  begin
    // koşul1 ve koşul2 doğruysa yapılacak işlemler
  end
  else
  begin
    // koşul1 doğru, koşul2 yanlışsa yapılacak işlemler
  end;
end
else
begin
  // koşul1 yanlışsa yapılacak işlemler
end;

Örnek: if-else Kullanımı

Aşağıdaki örnekte, bir sayının pozitif, negatif veya sıfır olup olmadığını kontrol eden bir if-else yapısı gösterilmektedir:

var
  sayi: Integer;
begin
  sayi := -5;

  if sayi > 0 then
    ShowMessage('Sayı pozitif')
  else if sayi < 0 then
    ShowMessage('Sayı negatif')
  else
    ShowMessage('Sayı sıfır');
end;

case of Deyimi

case of deyimi, bir değişkenin değerine göre farklı kod bloklarını çalıştırmak için kullanılır. Özellikle, bir değişkenin birçok farklı olası değeri varsa ve her bir değer için farklı bir işlem yapılması gerekiyorsa, if-else yapısına göre daha okunabilir ve yönetilebilir bir alternatif sunar.

case of Deyiminin Temel Yapısı

case of deyiminin temel yapısı aşağıdaki gibidir:

case değişken of
  değer1: begin
    // değişken değeri değer1 ise yapılacak işlemler
  end;
  değer2: begin
    // değişken değeri değer2 ise yapılacak işlemler
  end;
  else
  begin
    // Değişken hiçbir değerle eşleşmiyorsa yapılacak işlemler (opsiyonel)
  end;
end;

Her bir değer için ayrı bir kod bloğu belirtilir. Eğer değişkenin değeri, belirtilen değerlerden biriyle eşleşirse, o değere karşılık gelen kod bloğu çalıştırılır. else bloğu, değişkenin hiçbir değerle eşleşmediği durumda çalıştırılacak olan kod bloğunu belirtir. else bloğu opsiyoneldir.

Örnek: case of Kullanımı

Aşağıdaki örnekte, bir harfin sesli veya sessiz olup olmadığını kontrol eden bir case of yapısı gösterilmektedir:

var
  harf: Char;
begin
  harf := 'a';

  case harf of
    'a', 'e', 'i', 'o', 'u': ShowMessage('Sesli harf');
    else ShowMessage('Sessiz harf');
  end;
end;

Bu örnekte, harf değişkeninin değeri ‘a’, ‘e’, ‘i’, ‘o’ veya ‘u’ ise, ekrana ‘Sesli harf’ mesajı yazdırılır. Aksi takdirde, ‘Sessiz harf’ mesajı yazdırılır.

if-else mi, case of mu?

if-else ve case of deyimleri, koşullu ifadeler için farklı yaklaşımlar sunar. Hangi deyimin kullanılacağı, duruma göre değişir. Genel olarak:

• Eğer sadece bir veya iki koşul varsa, if-else deyimi daha uygun olabilir.
• Eğer birden fazla koşul varsa ve değişkenin değeri birçok farklı olası değere sahipse, case of deyimi daha okunabilir ve yönetilebilir bir çözüm sunar.
• Eğer koşullar karmaşık mantıksal ifadeler içeriyorsa (örneğin, birden fazla değişkenin karşılaştırılması gerekiyorsa), if-else deyimi daha esnek olabilir.

Önemli olan, kodun okunabilirliğini ve anlaşılabilirliğini artırmaktır. Hangi deyimin daha uygun olduğuna karar verirken, bu faktörleri göz önünde bulundurmak önemlidir.

“Doğru koşullu ifade seçimi, kodunuzun sadece daha verimli değil, aynı zamanda daha anlaşılır olmasını sağlar. Delphi’de, her aracın avantajlarını bilerek doğru kararı vermek, iyi bir programcının işaretidir.”

Sonuç

if-else ve case of deyimleri, Delphi programlama dilinde program akışını kontrol etmek ve farklı durumlara göre farklı işlemler yapmak için kullanılan temel araçlardır. Bu ifadelerin doğru kullanımı, daha esnek, okunabilir ve yönetilebilir kodlar yazmanızı sağlar. Her iki deyimin de avantajlarını ve dezavantajlarını bilerek, projenizin gereksinimlerine en uygun olanı seçmek önemlidir.

5. Koşullu İfadeler (if-else, case of) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

3. Değişkenler ve Veri Türleri

Delphi programlama dilinde, verileri saklamak ve işlemek için değişkenler ve bu değişkenlerin alabileceği değerlerin türlerini belirleyen veri türleri temel kavramlardır. Bu kavramları anlamak, sağlam ve etkili programlar yazmak için kritik öneme sahiptir. Bu makalede, Delphi’deki değişkenler ve veri türlerini detaylı bir şekilde inceleyeceğiz.

Değişkenler

Değişken, programın çalışma zamanında değerini değiştirebileceğiniz bir bellek alanıdır. Her değişkenin bir adı, bir veri türü ve bir değeri vardır. Değişkenler, programın verileri saklamasına ve bu veriler üzerinde işlemler yapmasına olanak tanır.

Değişken Tanımlama

Delphi’de değişkenler, var anahtar kelimesi kullanılarak tanımlanır. Değişkenin adı ve veri türü belirtilir.

var
  sayi: Integer;
  isim: String;
  pi: Real;

Bu örnekte, sayi adında bir tamsayı (Integer), isim adında bir metin (String) ve pi adında bir ondalıklı sayı (Real) değişkeni tanımlanmıştır.

Değişkene Değer Atama

Değişkenlere değer atamak için := (atama operatörü) kullanılır.

sayi := 10;
isim := 'Delphi';
pi := 3.14;

Bu örnekte, sayi değişkenine 10, isim değişkenine ‘Delphi’ ve pi değişkenine 3.14 değeri atanmıştır.

Veri Türleri

Veri türleri, bir değişkenin alabileceği değerlerin türünü ve üzerinde yapılabilecek işlemleri belirler. Delphi, çeşitli veri türlerini destekler.

Temel Veri Türleri

Delphi’deki temel veri türlerinden bazıları şunlardır:

• Integer: Tamsayıları temsil eder. (Örn: -1, 0, 1, 100)
• Real: Ondalıklı sayıları temsil eder. (Örn: 3.14, -2.5, 0.0)
• Boolean: Mantıksal değerleri (True veya False) temsil eder.
• Char: Tek bir karakteri temsil eder. (Örn: ‘A’, ‘b’, ‘5’)
• String: Metinleri (karakter dizilerini) temsil eder. (Örn: ‘Merhaba Dünya’, ‘Delphi Programlama’)

Tamsayı Veri Türleri (Integer Types)

Delphi, farklı boyutlarda tamsayı veri türlerini destekler. Bu türler, saklanabilecek sayıların aralığını belirler.

• ShortInt: -128 ile 127 arasındaki tamsayıları saklar.
• SmallInt: -32768 ile 32767 arasındaki tamsayıları saklar.
• Integer: -2147483648 ile 2147483647 arasındaki tamsayıları saklar. (32-bit)
• Int64: -9223372036854775808 ile 9223372036854775807 arasındaki tamsayıları saklar. (64-bit)
• Byte: 0 ile 255 arasındaki tamsayıları saklar. (işaretsiz)
• Word: 0 ile 65535 arasındaki tamsayıları saklar. (işaretsiz)
• Cardinal: 0 ile 4294967295 arasındaki tamsayıları saklar. (işaretsiz)

Ondalıklı Sayı Veri Türleri (Real Types)

Delphi, farklı hassasiyet seviyelerinde ondalıklı sayı veri türlerini destekler.

• Real48: Daha az hassasiyetli ondalıklı sayılar için kullanılır.
• Single: Tek duyarlıklı ondalıklı sayılar için kullanılır.
• Double: Çift duyarlıklı ondalıklı sayılar için kullanılır (genellikle daha hassas sonuçlar için tercih edilir).
• Extended: Daha yüksek hassasiyetli ondalıklı sayılar için kullanılır.
• Currency: Para birimi değerlerini saklamak için kullanılır.

Karakter ve Metin Veri Türleri (Character and String Types)

Delphi, karakterleri ve metinleri saklamak için farklı veri türleri sunar.

• Char: Tek bir karakteri temsil eder. Örneğin: var karakter: Char; karakter := 'A';
• String: Değişken uzunlukta metinleri temsil eder. Örneğin: var metin: String; metin := 'Merhaba Dünya';
• ShortString: 255 karaktere kadar olan metinleri temsil eder. Artık pek kullanılmamaktadır.
• AnsiString: ANSI karakter kümesini kullanan metinleri temsil eder.
• WideString: Unicode karakter kümesini kullanan metinleri temsil eder. Uluslararası karakter desteği gerektiren uygulamalar için idealdir.

Boolean Veri Türü

Boolean veri türü, sadece iki değeri alabilir: True (Doğru) veya False (Yanlış). Mantıksal ifadelerin sonuçlarını saklamak için kullanılır.

var
  durum: Boolean;

begin
  durum := (5 > 3); // durum değişkenine True değeri atanır.
end;

Sabitler (Constants)

Sabitler, programın çalışma zamanında değeri değişmeyen verilerdir. Sabitler, const anahtar kelimesi kullanılarak tanımlanır.

const
  MAX_SAYI = 100;
  MESAJ = 'Hata oluştu!';

Sabitler, programın okunabilirliğini artırır ve tekrar eden değerlerin tek bir yerden değiştirilmesine olanak tanır.

Veri Türü Dönüşümleri

Farklı veri türleri arasında dönüşüm yapmak gerekebilir. Delphi, bu amaçla çeşitli fonksiyonlar sunar.

• IntToStr: Tamsayıyı metne dönüştürür.
• StrToInteger: Metni tamsayıya dönüştürür. (Hata kontrolü önemlidir.)
• FloatToStr: Ondalıklı sayıyı metne dönüştürür.
• StrToFloat: Metni ondalıklı sayıya dönüştürür. (Hata kontrolü önemlidir.)

Veri türü dönüşümleri sırasında veri kaybı veya hatalar oluşabileceğini unutmamak önemlidir. Bu nedenle, dönüşümler dikkatli bir şekilde yapılmalı ve hata kontrolleri eklenmelidir.

“Değişkenler ve veri türleri, programlamanın temel taşlarıdır. Doğru veri türünü seçmek ve değişkenleri doğru şekilde kullanmak, programın performansını ve güvenilirliğini önemli ölçüde etkiler.” – Bir Delphi Uzmanı

Özet

Delphi’de değişkenler ve veri türleri, programların temel yapı taşlarıdır. Değişkenler, verileri saklamak ve işlemek için kullanılırken, veri türleri bu verilerin türünü ve üzerinde yapılabilecek işlemleri belirler. Doğru veri türünü seçmek, programın performansını, belleği verimli kullanmasını ve güvenilirliğini artırır. Bu makalede ele alınan konuları iyi anlamak, Delphi programlama becerilerinizi önemli ölçüde geliştirecektir.

3. Değişkenler ve Veri Türleri yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

2. İlk Uygulamanın Yazılması (Hello World)

Delphi programlama diline hoş geldiniz! Bu makalede, Delphi ile ilk uygulamanızı nasıl oluşturacağınızı adım adım öğreneceksiniz. Geleneksel olarak, programlamaya yeni başlayanların yazdığı ilk uygulama “Hello, World!” uygulamasıdır. Bu basit uygulama, ekrana bir metin yazdırmaktan ibarettir, ancak bir programlama dilinin temel sözdizimini ve geliştirme ortamını anlamak için mükemmel bir başlangıç noktasıdır.

Delphi Ortamını Hazırlama

İlk uygulamamızı yazmadan önce, Delphi geliştirme ortamının doğru şekilde kurulduğundan ve yapılandırıldığından emin olmalıyız. Delphi IDE (Integrated Development Environment – Tümleşik Geliştirme Ortamı), kod yazmak, derlemek (compile) ve çalıştırmak için gerekli tüm araçları sunar.

Delphi IDE’yi Açma

Delphi’yi kurduktan sonra, başlat menüsünden veya masaüstü kısayolundan IDE’yi açın. IDE açıldığında, genellikle boş bir proje veya önceden ayarlanmış bir proje şablonu ile karşılaşacaksınız.

Yeni Bir VCL Projesi Oluşturma

“Hello, World!” uygulamamız için yeni bir VCL (Visual Component Library – Görsel Bileşen Kütüphanesi) projesi oluşturacağız. VCL, Delphi’nin görsel arayüz oluşturmak için kullandığı bileşen setidir. Yeni bir proje oluşturmak için şu adımları izleyin:

1. File (Dosya) -> New (Yeni) -> VCL Forms Application yolunu izleyin.
2. Bu işlem, üzerinde görsel olarak çalışabileceğiniz boş bir form (Form1) oluşturacaktır.

“Hello, World!” Uygulamasını Yazma

Şimdi, “Hello, World!” metnini ekrana yazdırmak için gerekli kodları yazmaya başlayabiliriz.

Bir Etiket (Label) Bileşeni Ekleme

Ekrana metin yazdırmak için bir etiket (Label) bileşeni kullanacağız. Etiket bileşeni, form üzerinde statik metin görüntülemek için kullanılır.

1. Delphi IDE’nin araç paletinde (Tool Palette) “Label” bileşenini bulun.
2. Label bileşenine tıklayın ve ardından form üzerine tıklayarak bir etiket yerleştirin.
3. Etiketin boyutunu ve konumunu istediğiniz gibi ayarlayabilirsiniz.

Etiket Metnini Değiştirme

Şimdi, etiketin metnini “Hello, World!” olarak değiştirelim.

1. Form üzerindeki etikete tıklayarak seçin.
2. Object Inspector (Nesne Denetleyicisi) penceresinde, “Caption” özelliğini bulun.
3. “Caption” özelliğinin değerini “Hello, World!” olarak değiştirin.

Bu adımları tamamladıktan sonra, form üzerindeki etiket “Hello, World!” metnini gösterecektir.

Alternatif Yöntem: Buton ve Olay İşleyici Kullanarak “Hello, World!” Mesajı Görüntüleme

Daha interaktif bir yaklaşım için, bir butona tıklandığında “Hello, World!” mesajını görüntüleyebiliriz. Bu yöntem, olay güdümlü programlamanın temel bir örneğidir.

1. Tool Palette’den bir Button bileşenini form üzerine sürükleyin.
2. Butona çift tıklayarak, `OnClick` olay işleyicisini otomatik olarak oluşturun. Bu, kod editöründe ilgili prosedürü açacaktır.
3. Aşağıdaki kodu `OnClick` olay işleyicisine ekleyin:

procedure TForm1.Button1Click(Sender: TObject);
begin
 ShowMessage('Hello, World!');
end;

Bu kod, butona her tıklandığında bir mesaj kutusu içinde “Hello, World!” metnini gösterecektir.

Uygulamayı Derleme ve Çalıştırma

Kodumuzu yazdığımıza göre, şimdi uygulamamızı derleyip çalıştırabiliriz.

Derleme (Compile)

Uygulamayı derlemek için şu adımları izleyin:

1. Run (Çalıştır) -> Compile (Derle) veya Project (Proje) -> Compile (Derle) yolunu izleyin.
2. Delphi, kodunuzu kontrol edecek ve yürütülebilir bir dosya oluşturacaktır.
3. Hata yoksa, derleme işlemi başarıyla tamamlanacaktır.

Çalıştırma (Run)

Uygulamayı çalıştırmak için şu adımları izleyin:

1. Run (Çalıştır) -> Run (Çalıştır) veya Debug (Hata Ayıklama) -> Run (Çalıştır) yolunu izleyin.
2. Delphi, uygulamayı çalıştıracak ve formunuz ekranda görünecektir.
3. Eğer etiket yöntemini kullandıysanız, formda “Hello, World!” metnini göreceksiniz. Eğer buton ve olay işleyici yöntemini kullandıysanız, butona tıkladığınızda bir mesaj kutusu içinde “Hello, World!” metnini göreceksiniz.

Kod Açıklaması

Oluşturduğumuz basit uygulamanın kodunu daha yakından inceleyelim.

Proje Dosyası (.dpr)

Delphi projeleri, `.dpr` uzantılı bir proje dosyası içerir. Bu dosya, projenin temel ayarlarını ve kullanılan birimleri (units) tanımlar. Örnek bir proje dosyası şuna benzer olabilir:

program HelloWorld;

uses
 Forms,  // Formları kullanmamızı sağlar
 Unit1 in 'Unit1.pas' {Form1}; // Form1'in bulunduğu birim

{$R *.res}

begin
 Application.Initialize; // Uygulamayı başlat
 Application.CreateForm(TForm1, Form1); // Form1'i oluştur
 Application.Run;  // Uygulamayı çalıştır
end.

Birim Dosyası (.pas)

Her form, `.pas` uzantılı bir birim dosyası ile ilişkilidir. Bu dosya, formun görsel bileşenlerini ve olay işleyicilerini tanımlayan kodu içerir. Örnek bir birim dosyası (Unit1.pas) şuna benzer olabilir:

unit Unit1;

interface

uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type
 TForm1 = class(TForm)
 Label1: TLabel;
 private
 { Private declarations }
 public
 { Public declarations }
 end;

var
 Form1: TForm1;

implementation

{$R *.dfm}

end.

Bu kod, `TForm1` adlı bir sınıf tanımlar. Bu sınıf, formun özelliklerini ve yöntemlerini içerir. `Label1` adlı bir etiket bileşeni de bu sınıfın bir parçasıdır.

Sonuç

Tebrikler! Delphi ile ilk uygulamanızı başarıyla oluşturdunuz. Bu basit “Hello, World!” uygulaması, Delphi programlama dilinin temel kavramlarını ve geliştirme ortamını anlamanıza yardımcı oldu. Şimdi, Delphi’nin sunduğu diğer özellikleri keşfetmeye ve daha karmaşık uygulamalar geliştirmeye hazırsınız.

Unutmayın, programlama öğrenmek sürekli pratik ve keşif gerektirir. Denemekten ve hata yapmaktan korkmayın!

İyi kodlamalar!

2. İlk Uygulamanın Yazılması (Hello World) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

1. Delphi’ye Giriş

Delphi, Borland (sonradan Embarcadero Technologies) tarafından geliştirilen, nesne yönelimli bir programlama dilidir ve IDE’dir (Entegre Geliştirme Ortamı). Özellikle Windows platformunda hızlı uygulama geliştirme (RAD – Rapid Application Development) için tasarlanmıştır. Delphi, Pascal dilinin bir lehçesi olan Object Pascal dilini kullanır. Güçlü ve esnek yapısı sayesinde, masaüstü uygulamalarından veritabanı uygulamalarına, web servislerinden mobil uygulamalara kadar geniş bir yelpazede projeler geliştirmek mümkündür.

Delphi’nin Tarihçesi

Delphi’nin ilk sürümü 1995 yılında piyasaya sürüldü. Bu sürüm, Windows 3.1 ve Windows 95 için 16-bit uygulamalar geliştirmek için tasarlanmıştı. Delphi, o dönemde Pascal programlama dilinin gücünü görsel bir geliştirme ortamıyla birleştirerek büyük bir popülerlik kazandı. İzleyen yıllarda, Delphi’nin yeni sürümleri piyasaya sürüldü ve her sürümde dilin ve IDE’nin yetenekleri geliştirildi. .Net desteği, cross-platform geliştirme yetenekleri ve mobil uygulama geliştirme gibi özellikler eklendi.

Delphi’nin Temel Özellikleri

Delphi, sunduğu birçok özellik sayesinde uygulama geliştiriciler için cazip bir seçenektir. İşte Delphi’nin temel özellikleri:

• Object Pascal Dili: Delphi, Pascal dilinin nesne yönelimli bir uzantısı olan Object Pascal’ı kullanır. Object Pascal, okunabilir ve kolay öğrenilebilir bir sözdizimine sahiptir.
• Görsel Geliştirme Ortamı (IDE): Delphi IDE, sürükle-bırak arayüzü, kod tamamlama, hata ayıklama araçları ve görsel tasarım araçları gibi özellikler sunar. Bu sayede, kullanıcı arayüzü oluşturmak ve uygulamaları geliştirmek kolaylaşır.
• Hızlı Uygulama Geliştirme (RAD): Delphi, RAD prensiplerine uygun olarak tasarlanmıştır. Bileşen tabanlı mimarisi ve görsel tasarım araçları sayesinde, uygulamaların hızlı bir şekilde prototiplenmesi ve geliştirilmesi mümkündür.
• Veritabanı Desteği: Delphi, çeşitli veritabanlarına (MySQL, Oracle, SQL Server, InterBase vb.) doğrudan erişim imkanı sunar. Veritabanı uygulamaları geliştirmek için zengin bir bileşen kütüphanesine sahiptir.
• Cross-Platform Geliştirme: Delphi, FireMonkey framework’ü sayesinde, Windows, macOS, iOS ve Android platformları için tek bir kod tabanından uygulamalar geliştirmeyi mümkün kılar.
• Geniş Bileşen Kütüphanesi: Delphi, görsel ve görsel olmayan birçok bileşeni içeren geniş bir kütüphaneye sahiptir. Bu bileşenler, kullanıcı arayüzü oluşturmak, veri işlemek, ağ işlemleri yapmak ve daha birçok görevi kolaylaştırır.
• Yerel Kod Derlemesi: Delphi, uygulamaları yerel makine koduna derler. Bu, uygulamaların hızlı ve verimli bir şekilde çalışmasını sağlar.

Delphi ile Neler Yapılabilir?

Delphi, çok yönlü bir geliştirme ortamı olduğu için birçok farklı alanda uygulama geliştirmek için kullanılabilir:

• Masaüstü Uygulamaları: Delphi, Windows platformunda çalışan masaüstü uygulamaları geliştirmek için idealdir. Ofis uygulamaları, veritabanı uygulamaları, grafik uygulamaları ve daha birçok türde uygulama Delphi ile geliştirilebilir.
• Veritabanı Uygulamaları: Delphi, güçlü veritabanı bağlantı yetenekleri sayesinde, veritabanı odaklı uygulamalar geliştirmek için çok uygundur. Müşteri ilişkileri yönetimi (CRM) sistemleri, stok takip sistemleri ve muhasebe programları gibi uygulamalar Delphi ile geliştirilebilir.
• Web Servisleri: Delphi, web servisleri geliştirmek için kullanılabilir. RESTful API’ler ve SOAP tabanlı web servisleri Delphi ile kolayca oluşturulabilir.
• Mobil Uygulamalar: Delphi, FireMonkey framework’ü sayesinde, iOS ve Android platformları için mobil uygulamalar geliştirmeyi mümkün kılar.
• IoT Uygulamaları: Delphi, nesnelerin interneti (IoT) uygulamaları geliştirmek için kullanılabilir. Sensör verilerini işlemek, cihazları kontrol etmek ve bulut tabanlı hizmetlerle iletişim kurmak gibi görevler Delphi ile gerçekleştirilebilir.

Delphi Öğrenmeye Nasıl Başlanır?

Delphi öğrenmek için aşağıdaki adımları izleyebilirsiniz:

1. Temel Programlama Bilgisi: Delphi öğrenmeye başlamadan önce, temel programlama kavramlarına (değişkenler, veri tipleri, döngüler, koşullu ifadeler vb.) hakim olmanız faydalı olacaktır.
2. Object Pascal Sözdizimi: Delphi’nin kullandığı Object Pascal dilinin sözdizimini öğrenin. Değişken tanımlama, operatörler, fonksiyonlar ve prosedürler gibi temel dil öğelerini öğrenin.
3. Delphi IDE’yi Tanıyın: Delphi IDE’nin arayüzünü ve temel özelliklerini tanıyın. Proje oluşturma, kod yazma, derleme ve hata ayıklama gibi işlemleri öğrenin.
4. Basit Uygulamalarla Başlayın: İlk olarak basit uygulamalar geliştirerek Delphi’yi öğrenmeye başlayın. Örneğin, bir hesap makinesi uygulaması veya bir not defteri uygulaması geliştirebilirsiniz.
5. Delphi Bileşenlerini Öğrenin: Delphi’nin sunduğu bileşenleri (Button, Label, Edit, Memo vb.) öğrenin ve uygulamalarınızda kullanın. Bileşenlerin özelliklerini, olaylarını ve metotlarını öğrenin.
6. Veritabanı İşlemlerini Öğrenin: Delphi ile veritabanı uygulamaları geliştirmek için, veritabanı bağlantısı kurmayı, sorgu çalıştırmayı ve veri görüntülemeyi öğrenin.
7. Kaynaklardan Yararlanın: Delphi hakkında bilgi edinmek için çeşitli kaynaklardan yararlanın. Kitaplar, online eğitimler, forumlar ve bloglar size yardımcı olabilir. Embarcadero’nun resmi web sitesi ve Delphi toplulukları da değerli kaynaklardır.
8. Pratik Yapın: Delphi’yi öğrenmenin en iyi yolu pratik yapmaktır. Farklı projeler geliştirerek ve kod yazarak Delphi becerilerinizi geliştirebilirsiniz.

Delphi’nin Avantajları ve Dezavantajları

Her programlama dili ve geliştirme ortamı gibi, Delphi’nin de avantajları ve dezavantajları bulunmaktadır.

Avantajları:

• Hızlı Uygulama Geliştirme: RAD prensiplerine uygun olarak tasarlandığı için, uygulamaların hızlı bir şekilde geliştirilmesini sağlar.
• Yerel Kod Derlemesi: Uygulamaları yerel makine koduna derlediği için, yüksek performanslı uygulamalar geliştirmek mümkündür.
• Geniş Bileşen Kütüphanesi: Zengin bir bileşen kütüphanesine sahip olduğu için, birçok görevi kolayca gerçekleştirmek mümkündür.
• Veritabanı Desteği: Çeşitli veritabanlarına doğrudan erişim imkanı sunar.
• Cross-Platform Geliştirme: FireMonkey framework’ü sayesinde, Windows, macOS, iOS ve Android platformları için tek bir kod tabanından uygulamalar geliştirmek mümkündür.

Dezavantajları:

• Maliyet: Delphi’nin ticari bir ürün olması, lisans maliyetini beraberinde getirir.
• Topluluk Büyüklüğü: Diğer popüler programlama dillerine (Java, Python vb.) göre, Delphi topluluğu daha küçüktür.
• Öğrenme Eğrisi: Bazı karmaşık özelliklerini öğrenmek zaman alabilir. Özellikle, yeni başlayanlar için FireMonkey framework’ü karmaşık gelebilir.

Delphi, güçlü ve esnek yapısı sayesinde, masaüstü, veritabanı, web ve mobil uygulamalar geliştirmek için ideal bir seçenektir. RAD prensiplerine uygun olarak tasarlanmış olması, uygulama geliştirme sürecini hızlandırır ve kolaylaştırır.

Sonuç olarak, Delphi, hızlı ve verimli uygulama geliştirme için güçlü bir araçtır. Özellikle Windows platformunda çalışan uygulamalar geliştirmek isteyenler için ideal bir seçenektir. Cross-platform geliştirme yetenekleri sayesinde, farklı platformlarda çalışan uygulamalar geliştirmek de mümkündür. Delphi öğrenmeye başlamak için birçok kaynak bulunmaktadır ve pratik yaparak Delphi becerilerinizi geliştirebilirsiniz.

1. Delphi’ye Giriş yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.