componentlerin anotomisi hakkında.

[meron06]

arkdaşlar iyi çalışmalar.benim uzun süredir merak edip öğrenmek istediğim bi konu var.bu konu programlama dillerine yüklenen componentlerin nasıl tasarlandığı.bu işin temelinde neler var.örneğin sıfırdan yeni bir component nasıl yazılır.bu konuda döküman kaynak site ve örnek ler varsa paylaşırmısınız.ben özellikle visualstudio c# a component nasıl geliştirilir bununla ilgili bilgiler toplamak istiyorum.cevaplarınız için şimdiden tşk.ler iyi çalışmalar arkadaşlar.

[aslangeri]

bunu öğrenmek için en güzel yol bileşenin helpine bakmatır.
delphide bileşenlerin helpine baktığın zaman hieyerarşi linkini göreceksin. ordan en üstteki sınıf temel sınıfdır. bileşen ordan başlar sonra geliştirile geliştirile kullanıdığın hale gelir. onlara biraz gözgezdir.
OOP (NYP) u biraz araştır.
kolay gelsin.

[ibrahimcoban]

Şimdi bu soruyu sorduğuna göre artık programcı olmaya karar vermişsin.
Cehennem ve Cennetin aynı olduğu yere hoşgeldin.
Component veya bileşenler genelde pek sıfırdan yazılmaz, yazılsa bile bu bayağı uzun bir
kod olacaktır. Bunun için genelde OOP destekli dillerin nimetlerinden faydalanarak
türetme yapılır.
Örneğin aşağıda bir bileşen seti için yazdığım karet bileşeni bulunmaktadır.

Kod: Tümünü seç

unit GraphicControl1;

interface

uses
  SysUtils, Classes, Controls, ExtCtrls, graphics, windows, messages;
type
  TCizim = (tcElips, tdDiktortgen, tdKoseli); // karetin çizim şekli ; Enumerated tip 

type
  TCaretD = class(TGraphicControl) // burada sınıf tanımlaması ve üretilen sınıfı belirtiyoruz.
  private // kendi değişkenlerin taımlanan yeri
    { Private declarations }
    Ftimmer: TTimer; // durumu yani yanık mı sönükmü olduğunu ayarlamak  için
    Fdurum: boolean; // yanık mı sönük mü durumu takip etmek için
    FCizim: TCizim; // çizim şeklinin tutulacağı enumerated  değişken
    FDolguRenk: TColor;
    FCizgiRenk: Tcolor;
    FInterval: Cardinal; // yanıp sönme hızı
    procedure Soyle(sender: TObject); // TTimer nesnesinin belirtilen interval sürüsi bittiğinde yapılacak işler. Yani TTimer nesnesinin OnTimer olayının yapacağı işlemler.
    procedure SetCizim(const Value: TCizim);
    procedure SetCizgiRenk(const Value: Tcolor);
    procedure SetDolguRenk(const Value: TColor);
    procedure SetInterval(const Value: Cardinal);
  protected
    procedure Paint; override; // Görsel bileşenlerinin vazgeçilmez komutu ekrana çizimi yapan yer veya yapmaya başlanan yer
  public  // dışardan erişebilinin fonksiyon veya procedure ler
    constructor Create(AOwner: TComponent); override; // Yapılandırıcı standart şekliyle devralıyoruz.
    constructor CreateB(x, y, w, h: integer; AOwner: TComponent); overload; // bu da komut olarak ayrı bir yapılandırıcı. Parametrelere dikkat.
    destructor Destroy; override; // yok edici bu da standar olarak TGraphicControl ata sınıfından devralıp eziyoruz. Ezmek yani içine kendi komutlarımızı da ekleyiyoruz
    procedure SetPoS(x, y: integer); // Nesnemizin sol ve üst koordinatlarını ayarlıyoruz.
    { Public declarations }
  published // puplicten farkı kısaca ; object inspector da gördüğümüz propertiesler yani özellikler. 
    property Cizim: TCizim read FCizim write SetCizim default tdDiktortgen; // cizim özelliği nesne.cizim dediğimizde FCizim değişkeni okur. yani read dan sonraki değişkeni write genelde proceduredir ve FCizim değişkenine değer atar bu atama sırasında başka işlerde yapabiliriz.
    property CizgiRenk: Tcolor read FCizgiRenk write SetCizgiRenk default clBlack;
    property DolguRenk: TColor read FDolguRenk write SetDolguRenk default clBlack;
    property Interval: Cardinal read FInterval write SetInterval default 300;


    { Published declarations }
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Samples', [TCaretD]);
end;

{ TCaretD }
// burda nesneyi oluşturuyoruz. Standart oluşturma şeklimiz.
constructor TCaretD.Create(AOwner: TComponent);
begin
  inherited Create(AOwner); //ata  sınıfın oluşturulmasını yapıyoruz yani TGraphicControl sınıfı
  Parent := TWinControl(AOwner); // parent ; yani sahipliği atıyoruz. neyin üzerine çizileceğini.
  FCizim := tdDiktortgen; // çizim şekli diktörtgen olarak atıyoruz
  FDurum := false; // hemen çizmesin diye false
  Ftimmer := TTimer.Create(Self); // TTimer ı oluşturuyoruz.
  Ftimmer.Interval := 300; // yanıp sönme hızı 300 mlsn 
  Ftimmer.OnTimer := soyle; // her 300 mlsnde yapılacak işi söyleyen procedure yi atıyoruz.
  Ftimmer.Enabled := true; // timeri çalıştırıyoruz.


end;

// 2. oluşturma şekli burada x ve y değeri ve w ve h yükseklik genişlik değerleri ile oluşturuyoruz.
// Geri si aynı
constructor TCaretD.CreateB(x, y, w, h: integer; AOwner: TComponent);
begin
  inherited Create(AOwner);
  FCizim := tdDiktortgen;
  Width := w;
  Height := h;
  Left := x;
  Top := y;
  FDurum := true;
  Ftimmer := TTimer.Create(Self);
  Ftimmer.Interval := 300;
  Ftimmer.OnTimer := soyle;
  Ftimmer.Enabled := true;
  Parent := TWinControl(AOwner);

end;

// bu rası OOP nin olmazsa olmazlarından yokedim veya yıkım yeri her nesneyi yok etmeliyiz, Yoksa hafıza şişer.
// Gerçi 1 tane kullanacaksak ana form veya bileşen yok edildiğinde bu da yok edilir ama bir sürü 
// kullandığımızda hafızayı boşa kullanmış oluruz.

destructor TCaretD.Destroy;
begin
  Ftimmer.Enabled := false; // oluşturduğumuz TTimer durdurulup 
  Ftimmer.Free; //yok ediliyorz
  inherited; // ata TGraphicControl  yok ediliyor.
end;

// çizim yeri
procedure TCaretD.Paint;
begin

  if FDurum then //Fdurum true ise yani çiz ise
  begin
    Canvas.Pen.Color := FCizgiRenk; // tuval çizgi rengi  yani dış çizgisi
    Canvas.Brush.Color := FDolguRenk;  // tuval dolgu rengi 
    case FCizim of
      tcElips: Canvas.Ellipse(1, 1, Width - 1, Height - 1); //elipsse
      tdDiktortgen: Canvas.Rectangle(1, 1, Width - 1, Height - 1); //
      tdKoseli: Canvas.RoundRect(1, 1, Width - 1, Height - 1, 3, 3); //
    end;

  end;

end;


procedure TCaretD.SetCizgiRenk(const Value: Tcolor);
begin
  FCizgiRenk := Value;
end;

procedure TCaretD.SetCizim(const Value: TCizim);
begin
  FCizim := Value;
end;

procedure TCaretD.SetDolguRenk(const Value: TColor);
begin
  FDolguRenk := Value;
end;



procedure TCaretD.SetInterval(const Value: Cardinal);
begin
  FInterval := Value;
  Ftimmer.Interval := Value;
end;

procedure TCaretD.SetPoS(x, y: integer);
begin
  Left := x;
  Top := y;
end;

// burası Fdurumu Finterval süresi bitiminde tersine çeviriyor ; true ise false gibi
procedure TCaretD.Soyle(sender: TObject);
begin
  Fdurum := not Fdurum;
  Refresh; // burada Invalidate da kullanılabilirdi fakat bu konut hemen çizmesini ister ve diğer kanalların çok önüne geçebilir.
   // bunun yerine daha yüksek sebiyeli Refresh komutunu kullanarak işlemin windowsa sıraya almasını söylüyoruz. 
  // Zaten yapacağı fazla bir şey yok  :D 
end;



end.

İnşallah bir nebze fikir vermişimdir.
c# da da hemen hemen aynı şekilde yapılır bir ata sınıf devralırsınız bu genelde control sınıfıdır .

public class Benimsınıf : Control
{
private byte A;

//public değiken ve fonksiyonlar;
public int deneme;
puplic void SunuYap;
puplic int BunudaYap;
//özellik tanımlamada
public Color Renk { get; set; }

}
gibi iki dildede bilişen mantık olarak aynı söz dizilimi farklı olduğundan biraz farklar var.
Ayrıca Delphi Windows tabanlı ve native dir. c# ise .Net tabanlı yorum dilidir. Arada teknik farklar var.
c# en son OOP dildir ve en kapsamlısı bu gözüküyor.

Ama kim Merhaba Dünya demek için arkada 20 mb dan fazla bir şey çalışmasını isterki.
Ben c# web programlama ve mobile cihazlar için kullanıyorum oda web service lerine erişmek için.