Öncesinde Java, sonrasında .Net’in gelmesi ve Borland-Inprise-Borland-CodeGear-Embarcadero arasında sekmesi sürecinde oldukça kötü delphi sürümleri (Delphi 8, Delphi 2005, Delphi 2006) arkası arkasına geldi ve Delphi popüleritesini kaybetti. Son 2 yıldır Delphi ile yazılım geliştirmiyorum. Ben de soğudum fakat soğumamın nedini birbiri arkasında gelen hantal ve hatalı IDE’ler değildi. Yıllardır aynı yerde sayan Object Pascal’dı. Delphi, delphi olalı kullandığımız object pascal dili nerdeyse 90′lardaki ile aynıydı.

Pascal, okunabilirlik olarak iyi bir dildir fakat iş kodlamaya geldikçe dildeki bazı yapılar gerçekten sinir bozucu oluyor. Tabi rakipleri görmeden bu eksiklikleri tümüyle göremiyorsunuz. Bir kere görünce de görmemezlikten gelemiyorsunuz.

Object Pascal’ı ayrı köklerden geldikleri için C# veya Java ile karışlaştırmak doğru olmaz. Kendi klasmanında RemObjects Oxygene (eski adıyla Chrome) ile karşılaştırabiliriz.

Tüm değişkenleri var bloğunda tanımlamak

Oysa oxygene’de buna gerek yok. Değişkeninizi kod içerisinde herhangi bir yerde tanımlayabilirsiniz. Type inference ise cabası…

Stringleri case içinde kullanamamak

case name of
  'ahmet':;
  'metin':;
else
end;

Değer döndüren metotları “function”, döndürmeyenleri ise “procedure” anahtarı ile tanımlamak

function yap(a,b:integer):integer;

procedure yap(a,b:integer):integer;

method yap(a,b:integer):integer;
method yap(a,b:integer);

Generic ya da template gibi bir yapının olmaması

Dictionary = public class
 ...
end;

foreach yapısının yetersizliği

for each u in Users index i do begin
  if i > 0 then Console.Write(';');
  Console.Write(u.Name);
end;

‘try/except/finally’ bloğunun olmayışı

return gibi bir keywordun olmayışı

method sum(a,b:integer):integer;
begin
  exit a + b;
end;

gelişmiş if

if (0 <= a) and (a < 10) then

if 0 <= a < 10 then

if not (a in [1..10]) then

if a not in [1..10] then

Oxygene’in en çok takdir ettiğim özelliklerinden birisi

result := null;
if node <> null then
  if node.parent <> null then
   if node.parent.parent <> null then
     result := node.parent.parent.caption;

result:= node:parent:parent:caption;

Oxygene’in daha sayamadığım bir çok güzel özelliği var hepsini RemObject sayfasından inceleyebilirsiniz. Eğer Delphi’ye oksijen verilirse geri dönmesi işten bile değil, merakla beklemekteyim.

Diyelimki elinizde kocaman bir bileşen kütüphanesi var. Bunu kurmak için hangi sırayla paketlerin derleneceğini ve yükleneceğini çıkarmanız lazım. Bu işlem oldukça zaman alır.

Örneğin; Developer Express’in bileşenleri (Quantum Grid+ Express Bars+SpreadSheet,vs…). Tüm seti kurmak için 30′a yakın paketi tek tek açıp derleyip yüklemeniz lazım. Delphi PI ile bu işi bir iki tıklamayla halledebilirsiniz.

Tek yapmanız gereken tüm paketlerin bulunduğu klasörü seçmek ve adımları takip etmek.

Siz bunu yaptıktan sonra DelphiPI

• paketleri tespit edecek
• paketler arasındaki bağımlıklıklara göre derleme listesi çıkaracak
• paketleri derleyecek
• paketleri delphi’ye yükleyecek
• SourcePath’leri arayıp LibraryPath’e ekleyecek
• Delphi 7 ve önceki sürümlerde; bulduğu yardım dosyalarını OpenHelp’e kaydecek.

DelphiPI’yi indirmek için tıklayın

HTML kullanarak dinamik yardım veya menüler oluşturabilir ve HTML sayfasındaki bağlantılara tıklanıldığı zamanda yapılması gereken işlemi WebBrowser nesnesinin BeforeNavigate2 olayını kullanarak değiştirebiliriz.

Bunu yapmak için HTML içinde belirtilen bağlantı yollarının http’den farklı, kendimizin belirlediği bir protokolle şekillendirilmiş olması yeterlidir. Örneğin :

Yardımı görüntüle

procedure TForm1.WebBrowserBeforeNavigate2(Sender: TObject;
  const pDisp: IDispatch; var URL, Flags, TargetFrameName, PostData,
  Headers: OleVariant; var Cancel: WordBool);
var
 ActionName : string;
 Action : TContainedAction;
begin
  ActionName := '';
  // başında app stringi olan URL'lerden action adını çıkarıyoruz.
  if pos('app:',URL)=1 then
    ActionName := copy(URL,5,length(URL)-4);
  // action adı çıkarabildiysek bu URL'yi biz işleyeceğiz
  // dolayısıyla WebBrowser nesnesinin işlem yapmasını iptal ediyoruz.
  Cancel := Length(ActionName) > 0;


// ActionList'ten action bulmaya çalışıyoruz.
  Action := FindAction(ActionList,ActionName);
  // Eğer bulduysak çalıştırıyoruz.
  if Assigned(Action) then
    Action.Execute;
end;

FindAction fonksiyonu ise şu şekilde:

function TForm1.FindAction(anActionList: TActionList;
  actionName: String): TContainedAction;
var
  i: Integer;
begin
  Result := nil;
  for I := 0 to anActionList.ActionCount - 1 do
    if UpperCase(anActionList.Actions[i].Name) = UpperCase(actionName) then begin
       Result := anActionList.Actions[i];
       exit;
    end;
end;

html_arayuz.zip (257 KB) dinamikyardim.zip (268 KB)

Recursion yöntemini kullanarak neler yapılabileceğini göstermek amacıyla

   12
-------- + 6
 13 + 1
 ------
   28

gibi ifadeleri (Expression) hesaplayan örnek bir program yazalım dedim.

Program bölme ve toplama işlemlerini tanıyabilecek. Bölme için gerekli çizgiler ‘-‘ karakteri kullanılarak çizilecek.

İfadeler ya bölme ya toplama işlemi olacak o yüzden şöyle bir class hiyerarşisi oluşturuyoruz.

İlk olarak bütün ifadelerin hesaplama yapan bir metodu olmalı ve bu metod Real bir değer döndürmeli. O yüzden TExpression diye abstract bir class tanımlıyoruz ve içine Evaluate metodunu yazıyoruz.

TExpression =  class
public
  function Evaluate:Real;virtual;abstract;
end;

Tek başına yazılmış bir sayı da bir çeşit ifade olduğu için TExpression classından TSingleExpression adında bir class türetiyoruz

TSingleExpression = class(TExpression)
private
  FValue : Real;
public
  function Evaluate: Real;override;
  constructor Create(AValue : Real);
end;

Bu classın Evaluate metodu çalışıtırıldığında Fvalue alanındaki değeri döndürecek.

Toplama işlemi için TAdditionExpression adıyla bir class daha tanımlıyoruz:

TAdditionExpression = class(TExpression)
protected
  FLeft : TExpression;
  FRight: TExpression;
public
  function Evaluate: Real;override;
  constructor Create(Left,Right:TExpression);
  destructor Destroy;override;
end;

Bu classın evaluate metoduda Fleft ve Fright alanlarındaki Expression classlarının evaluate metodlarını çalıştırıp çıkan sonucu toplayarak döndürecek

Bölme işlemi de toplama işleminden çok farklı olmadığı için

TDivisionExpression = class(TAdditionExpression)
public
  function Evaluate: Real;override;
end;

Program şöyle bir algoritma izleyecek:

function Parse(Lines: TstringList):Texpression;
basla
  // bölme işlemi için
  eger <> basla
     <<İfadeyi o satırdan Sag ve Sol olamk üzere ikiye ayır>>
     Expr1 = parse(Sag);
     Expr2 = parse(Sol);
     Result := TDivisionExpression.Create(Expr1,Expr2);
     Exit;
  bitir;
  // toplama işlemi için
  eger <> basla
     <<İfadeyi o sütundan Ust ve Alt olam üzere ikiye ayır>>
     Expr1 = parse(Ust);
     Expr2 = parse(Alt);
     Result := TAdditionExpression.Create(Expr1,Expr2);
     Exit;
  bitir;
  // sayılar için
  eger <> basla
     Result := TSingleExpression.Create(Deger)
  bitir;
  // hiçbir koşula düşmediyse
  Hata;
bitir;

Hesaplama işlemi aşağıdaki kodla yapılabilecek

var
  Exp : TExpression;
begin
Exp:=Parse(memo1.lines);
ShowMessage(FloatToStr(Exp.Evaluate));
End;

Metod çalıştırıldığında recursive olarak İfade Ağacı (Expression Tree) oluşturulacak.

Kaynak Kod: memoevaluate.rar Çalıştırılabilir Dosya : memoevaluate.exe.rar

Backtrack algoritması özyineleme (recursion) desteklenen her dilde kodlanabilir ve basit bir algoritma olmasına rağmen de bir çok ufak iş için kullanılabilir. Bu algoritmanın dezavantajı maximum adım sayısı bilinmeyen durumlarda stackoverflow hatasına neden olabilmesidir.

Algoritmanın pseudo-code’u aşağıdaki gibi :

procedure backtrack(i:integer;deger: integer);
basla
  Eger sonuclardan-biriyse
    << sonucla ilgili islemleri yap >>
  degilse
    her adaydeger icin backtrack(i+1,adaydeger);
  bitir;
bitir;

Tabi ilk bakışta bu pseudo-code’dan her şeyi anlamak kolay değil, o yüzden hemen bir örnek verelim. Bu algoritmayı kullanarak bir kümenin bütün alt kümelerini oluştururalım. Kümemiz 1’den 5’e kadar olan sayılardan oluşsun. Algoritmada bahsi geçen her adım için adaylar true ve false değerlerini alacak. Yani herhangi bir indexdeki eleman o altkümenin içindeyse true değilse false olarak işaretlenecek. Eger adım sayısı kümenin eleman sayısına eşit olduysa tüm kombinasyonlar üretildi demektir, sonucu ekrana yazıyoruz. Eger adım sayısı kümenin eleman sayısından küçükse daha üretilmesi gerek kombinasyonlar var demektir, bizde bir sonraki adım için tüm olası değerleri veriyoruz.

arr : array[1..5] of boolean;

procedure Recurse(i : integer; val:boolean);
var 
  j : integer;
begin
  arr[i]:= val;
  if (i=Length(arr)) then begin
    Write('{ ');
    for j := 0 to Length(Arr) do  if(arr[j]) then Write(j,' ');
    WriteLN(' }');
  end else begin
    recurse(i+1,true);
    recurse(i+1,false);
  end;
end;
begin
  recurse(1,true);
  recurse(1,false);
  readln;
end.

n elemanlı bir kümenin 2^n tane altkümesi vardır, dolayısıyla örneği çalıştırdığımızda 32 tane sonuç göreceğiz.

İkinci örnek olarak da bir string içindeki karakterlerin bütün permütasyonlarını oluşturalım. Yine aynı mantığı kullanıcaz ama bu sefer biraz daha fazla çalışmamız lazım.

var
  str : string = 'ABC';

 procedure backtrack(str:string;i:integer);
 var
  j: integer;
  ch : char;
 begin
   if i = length(str) then begin
     WriteLn(str);
   end else begin
     for j := i to length(str) do begin
        ch := str[i];
        str[i] := str[j];
        str[j] := ch;
        backtrack(str,i+1);
     end;
   end;
 end;

begin
  backtrack(str,1);
  Readln;
end.

Örnekteki i değeri str değişkeninin uzunluğuna denk olduğunda bunu ekrana yazıyoruz, eğer değilse i ve length(Str) arasındaki karakterleri str değişkeninin i. karakteri ile değiştirip prosedürü tekrar çağırıyoruz. Üç karakterden oluşan stringin toplam 3! = 6 tane permütasyonu olması lazım, yalnız biz bunu yaparken bütün karakterlerin birbirinden farklı olduğunu farzediyoruz. ‘AAA’ şeklinde tanımlanmış bir değişkende birbirinin aynısı olmasına rağmen 6 tane satır göreceğiz.