2. BÖLÜM : VISUAL C# İLE PROGRAMCILIĞA GİRİŞ(*)

Visual Studio başlatıldığı zaman aşağıdaki gibi bir pencerenin ekrana geldiğini biliyorsunuz. Bu penceredeki seçeneklerden yararlanıp yeni projeler hazırlayabilir veya mevcut projeleri açabilirsiniz. Visual Studio daha önce açılan birkaç projeyi Start Page’de listelemektedir.

 

Solution Explorer penceresindeki View Form düğmesini tıklarsanız o sırada seçili durumdaki formun görsel yapısı görüntülenir. Solution Explorer penceresindeki View Code düğmesini tıklarsanız kod yazılabilinen bir pencere ekrana gelir.

Formun görsel yapısını görüntülemek demek bir bakıma çalışma anında bu form ekrana getirildiği zaman nasıl bir görünüme sahip olacağını önceden görmek demektir. Örneğin Visual Studio projedeki “Form1” adlı formu oluşturan “Form1.cs” ve “Form1.Designer.cs” dosyalarındaki kodlara bakıp çalışma anında pencere görevi yapacak formu tasarım anında karşınıza getirmektedir. Başka bir deyişe Visual Studio’dan yararlanıp formun özelliklerini değiştirdikçe geri planda formu oluşturan CS dosyasında değişiklik yapılıyor. 

İzninizle bu konuda 2 cümle daha yazmak istiyoruz: Visual Studio, söz konusu formun “FormAdı.Designer.cs” dosyasına sürekli bakıp, daha doğrusu InitializeComponent() metodunu işletip bu formun çalışma anında nasıl bir görünüme sahip olacağı konusunda programcıyı tasarım anında bilgilendirmektedir. Bu sayede programcı formun görünümünü ayarlamak üzere yazdığı satırların işlevini veya etkisini görmek için projesini çalıştırıp söz konusu formu ekrana getirmesine gerek kalmıyor. Yıllar önce Visual Studio ve Delphi gibi görsel program geliştirme araçları yokken programcılar programlarının görsel yapısı ile ilgili olarak yaptıkları değişikleri görmek için sık sık derleme çalıştırma işlemlerini yaparlardı.

Bu değişiklikleri gidip xxxDesinger.cs dosyasında kendiniz yaptığınızda ise Visual Studio bu değişiklikleri formun görsel yapısına anında yansıtıyor. Çünkü Visual Studio sürekli olarak formların görsel yapısı ile ilgili kodları gözetip formun son halini kaşınıza getirmektedir.

Visual Studio ile hazırlayıp üzerinde çalıştığımız projede “Form1” adında bir form olduğu için bu proje Visual Studio sayesinde(Debug menüsünden komut verilerek) çalıştırılıp test edildiği zaman “Form1” sınıfının örneği alınıp ekrana getirilir. Bir Form nesnesinin bir pencere olarak ekrana getirilmesi sırasında Load olayı meydana gelmektedir. Dolayısıyla örneği alınan sınıfta yani Form1’de Load olayıyla ilişkilendirilmiş bir metot varsa işletilir. 
Şimdi proje çalıştırıldığında bir diyalog kutusu içinde ekrana “Microsoft Visual C#” bilgisini mesaj olarak getirmek için hazırlık yapacağız. Sabit bilgiler diyalog kutusu içinde ekrana getirilirken MessageBox sınıfının Show() metodu kullanılmaktadır. Her ne kadar bu kısacık kod hakkında yapılması gereken başka açıklamalar olsa bile bunu sonraya bırakıyoruz.

private void Form1_Load(object sender, EventArgs e)

 {

   MessageBox.Show(this, "Microsoft Visual C#"); 

 }

Henüz yolun başında olan birisi için bu kitapta veya başka bir kaynakta incelenen C# kodunda nelerin anahtar kelime, nelerin metot, nelerin class, nelerin tip veya struct olduğunu hemen ayırt etmek zor olabilmektedir. Bu düşünce ile C#’ın sayısı fazla olmayan anahtar kelimelerinin bazılarını burada listeledik: abstract, as, base, break, byte, case, catch, checked, class, const, continue, default, delegate, do, else, enum, event, extern, false, finally, fixed, for, foreach, goto, if, implicit, in, interface, internal, is, lock, namespace, new, null, object, operator, out, override, params, private, public, readonly, ref, return, sealed, sizeof, static, switch, this, throw, try, typeof, unsafe, using, virtual, void, while. Bu anahtar kelimeler hakkında ileriki sayfalarda bilgi verilecektir. 

Açıklama Satırları

C# kodu içinde açıklama satırlarına yer vermek istiyorsanız açıklama olarak değerlendirilmesini istediğiniz satırın başına “//” koymanız yeterlidir. Başına “//” konulan satırları C# derleyicisi işleme koymaz ve bu satırlar Visual Studio tarafından yeşil renkte gösterilir.

Program.cs dosyasında en başta C# projesinde kullanılması muhtemel sınıfları içeren namespace’ler using deyimi ile koda dahil edilmektedir(.NET terminolojisinde Class’lar namespace halinde paketlenmektedir). Daha teknik bir söyleyişle; kullanılmak istenen Class’ları içeren namespace’ler using deyimi ile derleyiciye ve Visual Studio’ya en başta söylenmektedir. Kullanılması muhtemel sınıfları içeren namespace’ler using deyimi ile tek tek işaret edildikten sonra Program adında bir class hazırlanmakta ve bu class içinde Main() metoduna yer verilmektedir. Visual Studio tarafından Program.cs dosyasında hazırlanan class’a farklı bir ad verebilirsiniz.



Aslında using anahtar kelimesinden sonra adları yazılan namespaceler için “koda dahil etmek” demek yerine, bu işleme “programcının bu namespaceleri kullanma isteğini baştan belirtmesi” olarak görmek daha doğru olur. Çünkü using anahtar kelimesinden sonra ilgili namespace’in adını yazmak bir zorunluluk olmamakla birlikte programcının işi kolaylaşmaktadır. Bu sayede kod satırlarının kısa olması sağlanmaktadır. Bu konuda ayrıntılı bilgi namespace’ler aldı bölümde verilecektir. Bu cümle DOS bilenler için: “Buradaki using deyimi DOS’un Path komutu gibi bir işlev görmektedir”. 

Hazırladığınız uygulama istenilen sayıda class’tan meydana gelebilir. Bu Class’lardan birisi Main() metoduna sahip olmalıdır. Main() metodu parametrelere sahip olabilir ve geriye değer gönderebilir. Genel alışkanlıkla programcılar Program.cs dosyasına başka bir şey yazmıyor olsalar bile sizler bu kod dosyasındaki Program adlı sınıfın içinde metot hazırlayabilir veya bu kod dosyasında başka sınıfların yer almasını sağlayabilirsiniz. 

Main() metodundaki Application.Run(new Form1()); satırı ile proje başlatılmakta ve projedeki ilk formu temsil eden “Form1” adlı Class’ın örneği new anahtar kelimesi ile hazırlanmaktadır. Bu işlem yapılırken projedeki ilk forma ait CS uzantılı dosyadaki Form1 adlı sınıfın yapıcı metodundan yararlanılmaktadır. Başka bir deyişle “new Form1()” ile Form1 class’ının örneği alınmaktadır. Yani Form1 sınıfından yola çıkılıp nesne hazırlanmaktadır. 

C# uygulamalarında sınıfların yapıcı metotlarına sınıfın adı verilmektedir. Visual Studio ile Windows Forms uygulaması hazırlandığınızda bu uygulama “Form1” adında bir Class’a sahip olacağı için bu class’ta Form1() adında bir metot hazırlanmaktadır. Başka bir anlatımla Application sınıfının Run() metoduna “Form1” sınıfının yapıcı metodunun geriye gönderdiği sınıf örneği yani form nesnesi parametre olarak verilmektedir.

Örnek olması için Program.cs dosyasına aşağıdaki gibi ekleme yaptık. Yaptığımız eklemeler sayesinde projenin ilk formu new anahtar kelimesi(new anahtar kelimesine bazıları operatör demektedir) ile oluşturulup ekrana getirilmeden önce MessageBox sınıfının Show() metodu ile kullanıcıya mesaj verilmektedir. 

namespace Proje1
{
 static class Program
  {
    [STAThread]
   static void Main()
    {
      string mesaj="Proje çalıştırıldı, Form1 ekrana getirilecek";
      MessageBox.Show(mesaj);   
      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);
      Application.Run(new Form1());
    }
  }
}

using anahtar kelimesi ile System.Windows.Forms namespace’teki sınıflardan “Program.cs” dosyası dahilinde yararlanmak istediğimi belirtmemiş olsaydık MessageBox sınıfının Show() metodundan yararlanıp ekrana diyalog kutusu içinde mesaj getirebilmek için bu sınıfın adından önce sınıfın yer aldığı namespace’in adını yazmak zorunda kalırdık. 

Bu konunun netleşmesini sağlamak için Program.cs dosyasındaki using bloğundaki System.Windows.Forms adlı namespace’le ilgili satırı silip yukarıda verilen Main() metodunu aşağıdaki gibi düzenledik. Bu kod işlev bakımından yukarıdakinden farksızdır.

 static void Main()
  {
   string mesaj ="Proje başlatıldı, Form1 ekrana getirilecek";
   System.Windows.Forms.MessageBox.Show(mesaj);
   System.Windows.Forms.Application.EnableVisualStyles();
   System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
   System.Windows.Forms.Application.Run(new Form1());
  } 

using deyiminin işlevi hakkında ön bilgi vermek gerekirse şunlar söylenebilir: C#’ta önce tipler veya class’lar yazılmakta ardından ilgili değişken veya nesnenin adı belirtilmektedir. Örneğin string mesaj; şeklinde bir satır yazıldığında C# derleyicisi ilk yazılan string’in bir tip veya bir class olduğunu varsayıp bu class’ı veya tipi using bloğunda işaret edilen namespace’lerde arar. Tabii hemen uyarmak gerekir ki bazı namespace’ler using bloğunda işaret edilmeseler bile bu namespace’lerdeki sınıflar, tipler, yapılar kullanılabilmektedir. System.Core böyle bir namespace’tir.

Benzer şekilde Application.Run() yazıldığında ilk yazılanın bir Class, nokta işaretinden sonra yazılanın ise bir metot olduğunu varsayıp bu Class’ı kod dosyasının başında using deyimleri ile işaret edilen namespace’lerde arar. Söz konusu Class(yani Application) belirtilen namespace’lerde varsa sorun yoktur. Kullanılan Class using deyimi ile işaret edilen hiçbir namespace’te yoksa Visual Studio uyarıda bulunur ve derleyici hata rapor eder. 

Projenizde birden fazla form varsa “Program.cs” dosyasında değişiklik yapıp projenizi istediğiniz formdan başlatabilirsiniz. Application sınıfının Run() metoduna hangi form nesnesini parametre olarak verirseniz proje o form ile başlatılır. Farklılık olsun diye projeye 2. bir form dahil edip Program.cs dosyasındaki Main() metodunu aşağıdaki gibi düzenledik.

static void Main()
  {
    MessageBox.Show("Proje Form2 ile başlatılacak");  
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form2());
  }
 

Şimdi Visual Studio sayesinde hazırladığımız projedeki formu projeden uzaklaştıracağız. Üzerinde çalıştığınız projedeki formlardan birisini projeden uzaklaştırmak istiyorsanız Solution Explorer penceresinden yararlanabilirsiniz. Projeden hangi formu çıkarmak istiyorsanız o formun yani ilgili Class’ın hazırlandığı CS dosyasının kısayol menüsünden Exclude From Project komutunu vermelisiniz.

Exclude From Project komutu ile Form1.cs ve Form1.Designer.cs dosyalarını projeden uzaklaştırdıktan sonra proje başlatıldığı zaman ekrana getirilecek formu kod yazarak hazırlayacağız. Form nesnesi hazırlamak üzere “Program.cs“ dosyasındaki Main() metodunda yaptığımız değişiklikleri aşağıda görebilirsiniz. “Program.cs” dosyası bu şekilde düzenlenen proje çalıştırıldığında “Form1” adında bir form nesnesi hazırlanıp ekrana getirilir.

staticvoid Main()
  {
    System.Windows.Forms.Form Form1;
    Form1 = new System.Windows.Forms.Form();
    Form1.Text = "Form1"; 
    System.Windows.Forms.Application.Run(Form1);
  }

Şimdi gelelim form hazırlamak üzere yazdığımız bu satırlar hakkında biraz konuşmaya. İlk olarak System.Windows.Forms.Form tipinde bir değişken tanımladık. Sözünü ettiğimiz bu değişkenin tanımlandığı satırdaki “System.Windows.Forms” bir namespace iken en son yazılan Form ise .NET Framework ile gelen bir Class’tır. Ardından new anahtar kelimesi ile form nesnesini hazırlayıp Application sınıfının Run() metoduna parametre olarak verildi. Bu sırada using anahtar kelimesi ile System.Windows.Forms adlı namespace’teki Class’lara gerek duyacağınızı işaret ettiyseniz bu koddaki bazı satırlar kısalır. Başka bir deyişle Class adından önce namespace adını yani System.Windows.Forms yazmak zorunda kalmazsınız. 

Şimdi bu koda ekleme yapıp kod yazarak hazırlayıp ekrana getirdiğimiz forma bir TextBox yerleştireceğiz. Bu amaçla “Program.cs” dosyasındaki Main() metodunu aşağıdaki gibi düzenledik. Program.cs dosyasında bu şekilde değişiklik yaparak hazırladığımız forma TextBox nesnesi yerleştirmek için önce System.Windows.Forms’da yer alan TextBox tipinde bir değişken tanımlayıp new anahtar kelimesi ile TextBox nesnesi oluşturduk. Devamında bu nesneyi formun Controls koleksiyonuna ekledik.

static void Main()
 {
    System.Windows.Forms.Form Form1;
   Form1 = new System.Windows.Forms.Form();
   Form1.Text = "Form1";
   System.Windows.Forms.TextBox Text_kutu1;
   Text_kutu1 = new System.Windows.Forms.TextBox();
   Text_kutu1.Left = 50;
   Text_kutu1.Top = 50;
   Form1.Controls.Add(Text_kutu1);     
   Application.Run(Form1);
 }

“Program.cs” dosyasındaki Main() metodu bu şekilde düzenlenen proje çalıştırıldığında aşağıdaki gibi bir sonuç alınır. Form sınıfının Controls koleksiyonuna eklenmeyen nesneler formun üzerinde görünmezler.



Toolbox’ta TextBox kontrolünü seçip forma yerleştirdiğiniz zaman Visual Studio geri planda yukarıda TextBox’la ilgili olarak yazdığımız satırların benzerini otomatik olarak hazırlayıp formla ilgili Designer.cs dosyasına yazmaktadır.

Şimdiye kadar Program.cs dosyası ilgili olarak yazılanlardan fark edilmiş olacağı gibi bu kod dosyasının önemi Main() metodunu içermesinden dolayıdır. Bir sonraki bölümde konsol uygulamaları hakkında bilgi verilen bölümde görüleceği gibi C# derleyicisi için Main() metodunun hangi kod dosyasında ve Class’ta olduğunun önemi yoktur. Birden fazla kod dosyasında veya Class’ta Main() adında metot varsa hangisinin uygulamanın başlangıç noktası olarak kullanılmak istendiğinin işaret edilmesi gerekir. Yoksa derleyici hangi Main() metodunu kullanacağına karar veremez ve hata rapor eder.

Çok az programcı Visual Studio veya Express Edition ile geliştirdiği C# uygulaması için birden fazla Main() metodu hazırlamaya gerek duysa bile C# uygulamalarını ve Visual Studio hakkında bilgi vermek amacıyla birden fazla Main() metodu hazırlayıp bundan Visual Studio’yu nasıl haberdar edeceğinizden biraz söz edeceğiz. 

C# derleyicisi aynı Class’ta aynı parametre yapısına ve aynı ada sahip birden fazla metodun olmasına izin vermez. Bu konuda adım adım bilgi vermek için önce 2 forma sahip bir proje hazırladık. Ardından “Program.cs” dosyasında “Program1” adında 2. bir Class’a yer verip bu Class’ın da Main() metoduna sahip olmasını sağladık.

namespace Proje1
{
    static class Program   
    {      
       static void Main()
       {
         Application.Run(new Form1());
       }
    }
    static class Program1
    {
       static void Main()
        {
          Application.Run(new Form2());
        }
    }
}

“Program1” adını verdiğimiz ikinci Class’ı başka bir kod dosyasına alabilirdik. Kod uzamasın diye kullanılması zorunlu olmayan bazı satırları Main() metotlarından sildik. Bu şartlarda bu proje derlenir veya çalıştırılırsa hata meydana gelir. Çünkü C# derleyicisi hangi sınıftaki Main() metodunu kullanacağına karar veremez. Hangi sınıftaki Main() metodunun uygulamanın başlangıç noktası olması isteniyorsa Project menüsünden komut verilerek ekrana getirilen Project Properties penceresinde Startup object liste kutusunda seçim yapılmalıdır.



Bir sonraki bölümde Visual Studio veya Express Edition kullanılmadan yazılan uygulamalar konsolda derlenirken birden fazla sınıfta Main() metodu varken nasıl bir derleme yapmak gerektiği anlatılacaktır.

Başlangıçta bu liste kutusunda (Not set) seçilidir ve C# derleyicisi bulduğu tek Main() metodunu kullanır. Tabii projedeki kod dosyalarının hiç birisinde Main() metodu yoksa hata meydana gelir. Bu liste kutusunda listelenen seçeneklerdeki “Proje1” bir namespace iken “Program” ve “Program1” birer Class’tır. Bu liste kutusunda hangi Class seçilirse projenin başlangıç noktası o class’taki Main() metodu olur.

Şimdi ise “Program” adlı class’ta 2. bir Main() metoduna yer vereceğiz. Aynı Class’ta aynı ada sahip birden fazla metodun olmasını sağlamak için parametre yapılarının farklı olmasını tercih edeceğiz. Bu arada projeye 3. bir form dahil ettiğimizi belirtmek isteriz. 

namespace Proje1
{
   static class Program
   {
      static void Main()
      {
        Application.Run(new Form1());
      }
    static void Main(string[] args)
      {
        Application.Run(new Form3());
      }
   }
   static class Program1
   {
     static void Main()
      {
         Application.Run(new Form2());
      }
    }
}

Bu şartlarda yani “Program.cs” dosyası bu şekilde düzenlenen projeyi çalıştırmadan önce Visual Studio’nun Project Properties penceresinde Startup object olarak Program1 adlı class’ı seçerseniz Visual Studio projeyi hatasız derler. Ancak Project Properties penceresinde Startup object olarak 2 Main metoduna sahip “Program” adlı class’ı seçerseniz hata meydana gelir. Çünkü C# derleyicisi aynı Class’ta birden fazla Main() metodu olduğunda birisinin parametresi dizi değişken olarak seçildiğinde diğer Main() metodunun bulunmasına izin vermiyor. “Program” adlı Class’ı aşağıdaki gibi düzenleseydik C# derleyicisi kodu derlerdi ama ikinci Main() metoduna kayıtsız kalırdı. 

static class Program
  {
    static void Main()
      {
        Application.Run(new Form1());
      }
    static void Main(string args)
      {
        Application.Run(new Form3());
      }
  }

Yukarıdaki sayfalarda Main() metodundaki Application.EnableVisualStyles() satırının üzerinde durmadık. Application sınıfının bu statik metodunun proje boyunca bir kez işletilmesi yeterli olduğu için C# uygulamalarının başlangıç noktası olan Main() metodunun ilk satırında işletilmektedir. Bu kitapta verilen ekran görüntülerine bakıldığında Windows XP kurulu bilgisayarda genellikle klasik Windows temasını kullandığımız fark edilir. Bu metot klasik tema kullanılırken işlevsel olmadığı için Windows XP temasını seçtik. Application sınıfının bu metodunun işlevini göstermek için yeni bir proje hazırlayıp forma bir button ve TextBox yerleştirip çalıştırdık. Sağda verilen ekran görüntüsünü bu metodun kullanıldığı satır silindikten sonra alındı.

 

Bu kitapta renkler gösterilmese bile Windows XP teması geçerli tema iken Application sınıfının EnableVisualStyles metodunun işlevini görebilirsiniz. Benzer durum Windows Vista için de geçerlidir. Vista kurulu bilgisayarda klasik Windows teması kullanılıyorsa bu metodun bir işlevi yoktur.  

Formlar İçin Hazırlanan Kodlar

Visual Studio ile yeni bir proje hazırlandığında projeye “Form1” adında bir formun dahil edildiğini biliyorsunuz. Daha doğrusu projeye Form1.cs ve Form1.Designer.cs adında 2 kod dosyası dahil edilip bu kod dosyaları içinde .NET Framework ile gelen Form sınıfının mirasçısı Form1 adında bir sınıf hazırlanmaktadır.

Formu oluşturan kodları görüntülemek için View menüsünden Code komutu verilebilir. Aşağıda verilen ekran görüntüsünü incelediğinizde projedeki her form için hazırlanan ilk CS dosyasının en başında kullanılması muhtemel class’ların yer aldığı namespace’ler işaret edilmektedir. Ardından formla aynı ada sahip bir Class hazırlanmaktadır.



Kod dosyasının başında işaret edilen namespace’lerdeki Class’ları kullanırken Class adından önce ilgili namespace’in adını yazmak zorunda değilsiniz. Kod dosyasının başında using anahtar kelimesi ile işaret edilen namespace’in içinde yer aldığı referans veya DLL dosyasından Visual Studio’nun haberdar edilip Solution Explorer penceresinde listelenmesi sağlanmalıdır.

Bu kod dosyasındaki Form1 sınıfı System.Windows.Forms adlı namespace’teki Form adlı sınıfın mirasçısı olduğu için çok sayıda özellik ve metoda zaten sahiptir. Bu koda dikkat ederseniz önce namespace bloğu bulunmaktadır ve projenin adı aynı zamanda namespace(Proje1) adı olarak kullanılmaktadır. Devamında public ve partial olarak işaret edilen class bloğu bulunmaktadır. Hazırlanan Class’a Form1 adı verilmiş. Solution Explorer penceresinden yararlanılıp Form veya CS dosyasının adı değiştirilirse Visual Studio, başlangıçta adı Form1 olan Class’ın adını değiştirir. 

Hazırlanmak istenen Class’ın adından sonra mirasçı pozisyonundaki “Form” sınıfının adı yazılmış. Hazırlanmak istenen Class ile mirasçı(yani taban sınıf) Class’ın adını birbirinden ayırmak için “:” kullanılmaktadır. Form sınıfı System.Windows.Forms adlı namespace yer aldığı ve bu namespace using bloğunda işaret edildiği için “Form” sınıfının adının önüne namespace adının yazılmasına gerek duyulmamış. 

Devamında “Form1” sınıfının yapıcı metoduna yer verilmiş. Class ile aynı ada sahip metotlara yapıcı veya constructor metot denilmektedir. Daha sonra yapıcı metotlar hakkında ayrıntılı bilgi verileceği için şimdilik “Class ile aynı ada sahip metotlara yapıcı metot denilir” tanımını bilmeniz yeterlidir.

Form1 adı verilen Class’ın yapıcı metodunda yalnızca InitializeComponent() metodu işletilmektedir. Form1’le ilgili InitializeComponent() metodu “Form1.Designer.cs” dosyasında yer almaktadır. Konunun devamında bu metot hakkında bilgi verilecektir.

Daha önce belirtildiği gibi formların ve formların üzerine yerleştirilen nesnelerin özellikleri CS uzantılı Designer dosyasında ayarlanmaktadır. Designer dosyasında da “Form1” adında bir Class bulunmaktadır. Başka bir deyişle “Form1” adlı Class’ın bir kısmı “Form1.cs” dosyasında diğer kısmı “Form1.Designer.cs” dosyasında bulunmaktadır.



.NET Framework 2.0’dan itibaren sınıfların birden fazla parça olarak düzenlenmesine izin verilmeye başlandı. Visual Studio 2003 ile hazırlanan veya .NET 1.1 destekli projelerde yukarıda verilen “Form1.cs” ile “Form1.Designer.cs” dosyalarının içerikleri bir aradaydı. 

Class’ların birden fazla kod dosyası veya parça şeklinde düzenlenmesine Partial Class denilmektedir. Bu nedenle Form1.cs veya Form1.Designer.cs dosyalarındaki partial anahtar kelimeleri silinirse hata meydana gelir. Daha sonra Class’ların anlatıldığı bölümde Partial class’lar hakkında bilgi verilecektir. 

“Form1” adlı Class için Visual Studio tarafından hazırlanan “Form1.Designer.cs” dosyasına bakarsanız Dispose() adında bir metodun olduğunu görürsünüz. Bu metot, form ve formla ilgili olarak hazırlanan nesnelerin form kapatıldığı zaman bellekten silmesiyle ilgilidir. Bu metot hakkında daha sonra bilgi verilecektir.

Şimdi “Form1” için Visual Studio tarafından hazırlanan satırları ve bu satırlarda kullanılan metot ve anahtar kelimelerin(yani deyimlerin) bazılarından söz edeceğiz. Visual Studio her form için yukarıda verilen satırlardan daha fazlasını hazırlamaktadır. Tasarım anında Properties penceresinde yapılan değişikliklere programcı doğrudan müdahale etmeyi tercih etmeyeceği için bu satırlar Windows Form Designer generated code adlı altında gruplanıp gizlenmektedir. Bu region yani bölgeye yazılan satırları aşağıda görebilirsiniz.

namespace Proje1
{
  partial class Form1
   {
     private System.ComponentModel.IContainer components = null;
     protected override void Dispose(bool disposing)
      {
        if (disposing && (components != null))
         {
           components.Dispose();
         }
        base.Dispose(disposing);
       }
      #region Windows Form Designer generated code
      private void InitializeComponent()
      {
       this.SuspendLayout();
       this.AutoScaleDimensions =new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode =System.Windows.Forms.AutoScaleMode.Font;
       this.ClientSize = new System.Drawing.Size(292, 146);
       this.Name = "Form1";
       this.Text = "Form1";
       this.ResumeLayout(false);
      }
    #endregion
  }
}

Bu koddaki bölge başını ve sonunu işaret eden #region ve #endregion satırlarını silerseniz bu bölgedeki satırlar sürekli görüntülenir. Region’lar ‘#region’ ile başlayıp ‘#endregion” ile bitmektedir. InitializeComponent() metodundaki satırlar Toolbox’tan yararlanılarak forma yerleştirilen nesnelere göre artabilmektedir. Bu sırada Toolbox’tan yararlanıp forma herhangi bir nesneyi yerleştirir veya Properties penceresinden yararlanıp formun özelliklerini değiştirseniz “Windows Form Designer generated code” bölgesine yeni satırlar eklenir veya mevcut satırlarda değişiklik meydana gelir. 

InitializeComponent() metodunda form ve formun üzerine yerleştirilen nesneler hazırlanıp özellikleri ayarlanmaktadır. Toolbox’tan yararlanıp projenin ana formuna bir Button yerleştirince Form1 sınıfının 2. kısmının saklandığı “Form1.Designer.cs” dosyasındaki InitializeComponent metodu aşağıda verilen şekle dönüştü.

 private void InitializeComponent()
  {
    this.button1 = new System.Windows.Forms.Button();
    this.SuspendLayout();
    this.button1.Location = new System.Drawing.Point(71, 45);
    this.button1.Name = "button1";
    this.button1.Size = new System.Drawing.Size(75, 23);
    this.button1.TabIndex = 0;
    this.button1.Text = "button1";
    this.button1.UseVisualStyleBackColor = true;
    this.ClientSize = new System.Drawing.Size(294, 141);
    this.Controls.Add(this.button1);
    this.Name = "Form1";
    this.ResumeLayout(false);
  }

“Form1.cs” dosyasındaki Main() metodundaki InitializeComponent() metodunu işleten satırı silerseniz “Form1.Designer.cs” dosyasındaki bu satırlar işletilmeyeceği için tasarım anında forma yerleştirilen Button nesnesi çalışma anında formun üzerinde görünmez ve formun boyutlarını ayarlayan satırlar işletilmeyeceği için form standart özelliklere sahip olur. Örneğin bu şartlarda çalışma anında ekrana getirilen formun başlık metni olmaz. 

Form1.cs dosyasında Form1 sınıfının yapıcı metodundan InitializeComponent() metodunu işleten satırı silerseniz bundan formun tasarım anındaki görünümü etkilenmez. Konu üzerinde düşünmenizi sağlamak için Button ve TextBox yerleştirdiğimiz formun Designer.cs dosyasına müdahale edip TextBox’ın Text özelliğini değiştiren bir satır ekledik.



Bu değişiklikten sonra formun görsel yapısının görüntülendiği pencereye döndüğünüzde TextBox’ın içeriğinin değiştiğini görürsünüz. Çünkü Visual Studio tasarım anında sürekli olarak Form1.Designer.cs dosyasındaki InitializeComponent() metodunu gözetlemekte ve bu metodun içeriğine göre formun görsel yapısını oluşturmaktadır. Bu metodun adını değiştirmeniz veya tümden silmeniz halinde tasarım anında formun görünümü Form sınıfından türetildiği yani ilk hali ile karşınızda durur.

Toolbox’tan yararlanarak forma yerleştirdiğimiz Button nesnesi ile ilgili olarak Form1.Designer.cs dosyasındaki InitializeComponent() metoduna yazılan satırlara dikkat ederseniz Button nesnesinin formun Controls koleksiyonuna Add() metodu ile eklendiğini görebilirsiniz. Visual Studio tasarım anında ancak ilgili formun Controls koleksiyonuna eklenen nesneleri formun üzerinde görüntülemektedir. Button nesnesinin Controls koleksiyonuna eklendiği satırı InitializeComponent() metodundan silerseniz button nesnesi hem tasarım anında hem de çalışma anında formun üzerinde görünmez. Visual Studio tasarım sürekli olarak Form1.Designer.cs dosyasındaki InitializeComponent() metodunu gözetip ona göre formun görsel yapısını oluşturuyor. Dolayısıyla Form1.cs dosyasından bu metodu işleten satırı silerseniz formun tasarım anındaki görünümü bundan etkilenmez. 

Forma yerleştirilen bazı kontroller görsel kontroller olmadıkları, başka bir deyişle çalışma anında formun üzerinde görünmedikleri için formun altına konulan panele yeştirilmektedir. OpenFileDialog ve SaveFileDialog görsel olmayan kontrollere örnek olarak gösterilebilir.



OpenFileDialog gibi görsel olmayan nesneler formun Controls koleksiyona dahil edilmezler. InitializeComponent() metoduna ekleme yapıp OpenFileDialog nesnesini formun Controls koleksiyonuna Add() metodu eklemek isterseniz hata meydana gelir. Çünkü OpenFileDialog sınıfı Control sınıfının mirasçısı değildir.

Olaylar ve Metot Hazırlamak

Visual Studio ile hazırlanan C# projeleri başlangıçta bir forma sahiptir. Projenin çalıştırılıp ilk formun oluşturulup ekrana getirilmesi olayının Properties penceresindeki adı Load’dır. Çalışma anında form tıklandığında ise formla ilgili olarak Click olayı meydana gelir.



Formlarla ve formlara yerleştirilen nesnelerle ilgili olarak çalışma anında meydana gelmesi muhtemel çok sayıda olay vardır. Örneğin çalışma anında formu tıklamak, klavyenin herhangi bir tuşuna basmak birer olaydır. Olay kavramını anlatabilmek için Properties penceresine ait ekran görüntüsü yanda verildi. Kendi hazırlayacağınız sınıflar için nasıl olay tanımlayabileceğiniz konusunda daha sonra bilgi verilecektir. Bu bölümde sözü edilecek olaylar .NET ile gelen Button ve Form gibi sınıfların hazır olaylarıdır.

Properties penceresi 2 amaca yönelik olarak işlev görmektedir. Birincisi, form ve Toolbox’tan yararlanılarak formlara yerleştirilen nesnelerin özellikleri hakkında bilgi edinmek ve gerekirse bu özelliklerde değişiklik yapmaktır. Bu penceredeki Events düğmesi tıklandığında ise o sırada seçili durumdaki nesneye kaynaklık eden Class’ın olayları listelenmektedir. Aşağıda verilen ekran görüntüsü Form1 nesnesinin özellikleri listelenirken Events düğmesini tıkladıktan sonra alındı. Bu olayların hepsi Form sınıfının olaylarıdır.



Şimdi çalışma anında form tıklandığı zaman ekrana mesaj verirken kullanılacak bir metot hazırlayacağız. Hangi sınıfın hangi olayı için metot hazırlamak istiyorsanız o sınıfın ilgili olayının parametre yapısını bilmeniz gerekir. Tabii C# uygulamaları geliştirirken Visual Studio kullandığımız için söz konusu olayların parametre yapılarını ezbere bilmemiz gerekmiyor.

Şimdi üzerinde çalıştığımız projedeki “Form1” adlı Class’ta “Mesaj()” adında bir metot hazırlayacağız. Geriye değer göndermeyen metotların adının önüne void deyimi yazılmaktadır. Mesaj() adını verdiğimiz bu metodu aşağıda görebilirsiniz. Bu metot Visual Studio ile hazırlanan projedeki “Form1” sınıfının sınırları içinde olduğu için ister istemez Form1 sınıfına ait bir metottur. Bu metodun başına private yazıldığı için Form1sınıfına özel bir metottur.

Bu metodun object ve EventArgs tipinde 2 parametreye sahip olmasını sağladık. Çünkü Form1 sınıfının Click olayını temsil etmek üzere hazırlanacak metodun object ve EventArgs tipinde 2 parametreye sahip olması gerekmektedir. Şimdi sıra bu metodun nasıl işletileceğini belirlemeye geldi. Formun üzeri tıklandığında mesaj verilsin istediğimiz için bu metodun adını Properties penceresinde Click olayının karşısına yazmak gerekiyor.



Başlangıçta Form1 sınıfının olayları için metot hazırlanmadığı için söz konusu olaylar çalışma anında meydana gelse bile herhangi bir işlem olmaz ve C# uygulaması bir tepkide bulunmaz. Örneğin Form1 sınıfının Click olayına bir metodun adını aktarmadığınız sürece çalışma anında form istenildiği kadar tıklansın herhangi bir işlem gerçekleşmez.

Propertiespenceresinde ilgili nesnenin olayları listelenirken üzerinde bulunan olay adının hemen yanına bir liste kutusu konulmaktadır. Söz konusu olay meydana geldiği zaman işletilmesini istediğiniz metodu önceden hazırladıysanız bu liste kutusundan seçebilirsiniz. Bu liste kutusunda ancak formun Click olayını temsil edebilecek, başka bir deyişle geriye değer göndermeyip object ve EventArgs tipinde 2 parametreye sahip metotlar listelenir. Click olayının karşısına bu metodun(Mesaj) adı yazıldıktan sonra projenin çalışması sırasında formun üzerinde yapılacak her tıklamada bu metot işletilir.

Yukarıda yaptığımız gibi sıfırdan metot hazırlamak yerine forma yerleştirilmiş nesnelerin olayları için metot hazırlarken Visual Studio’dan yararlanabilirsiniz. Bu amaçla Properties penceresinde kendisi için metot hazırlanmak istenen olayın üzerine gidilir ve olaya ait kutuya hazırlanmak istenen metodun adı yazılır. Bu işlemin nasıl yapıldığını anlatmak için yeni bir proje hazırlayıp Properties penceresini ekrana getirdik. Metodun adını kendiniz belirlemek istiyorsanız metodun adını olaya ait metin kutusuna yazmalısınız.



Hazırlamak istediğiniz metodun adını bu şekilde yazıp enter tuşuna basarsanız Visual Studio metodu hazırlar ve olayla ilişkilendirir. Hazırlayıp bir olay ile ilişkilendirmek istediğiniz metodun adı konusunda özel bir nedeniniz yoksa metoda Visual Studio’nun ad vermesini sağlayabilirsiniz.

Yeni bir metot hazırlamak üzere metot adını yazmak yerine metot adı yazılabilinen kutuda çift tıklama yaparsanız söz konusu olayın ve nesnenin adının birleşiminden meydana gelen bir ada sahip bir metot Visual Studio tarafından hazırlanır. 

Properties penceresinde forma ait olaylar listelenirken FormClosed olayı çift tıklanırsa code penceresi aşağıda verilen şekle dönüşür. Formun FormClosed olayını temsil etmek üzere Visual Studio’dan yararlanarak hazırladığımız metodun parametre yapısı Click olayını temsil eden metodun parametre yapısından farklıdır. Bu şekilde hazırlanan metodun adında Form1’e yer verilerek bu metodun Form1 sınıfına ait olduğu işaret edilmektedir. 



Properties penceresinde ilgili nesnenin olayları listelenirken olayın adı üzerinde çift tıklama yapılarak metot hazırlandığında, formla ilgili “Designer.cs” dosyasındaki Windows Form Designer generated codebölgesinde bu metot ilgili olayla ilişkilendirilir. Başlangıçta bu bloktaki kodlar gizlendiği için görünmemektedir. Bu konuda bilgi vermek için yeni bir proje hazırlayıp forma ait “Form1.Designer.cs” dosyasını açtık.



Bu sırada bu kod penceresindeki “+” işareti tıklanırsa kod penceresi aşağıda verilen şekle dönüşür. Visual Studio tarafından hazırlanan InitializeComponent() metodunda formun ve formun üzerine yerleştirilen nesnelerin özellikleri ayarlanmaktadır. Bu metot “Form1.cs” adlı kod dosyasındaki Form1 sınıfının yapıcı metodunun içinden işletilmektedir.



Bu ekran görüntüsü alındığı sırada Form1.Designer.cs dosyası içinde hazırlanan tek nesne Form1(buradaki adıyla this) olduğu için Windows Forms Designer generated code bloğunda yalnızca Form1’le ilgili satırlar vardı. Bu sırada Properties penceresinde formun Click olayı çift tıklanırsa bu olay meydana geldiğinde işletilecek metodun kalıbı hazırlanır ve Click olayıyla ilişkilendirilir. Bu ilişkilendirmenin nasıl yapıldığını aşağıda görebilirsiniz.



Properties penceresinde herhangi bir olayın adı üzerinde çift tıklama yapmanız halinde 2 ayrı ayarlama yapılmaktadır. Bunlar, metodun hazırlanması ve bu metodun olayla ilişkilendirilmesidir. Daha sonra hazırladığınız metodu silmek istemeniz halinde metodun olayla ilişkilendirildiği satırı “Form1.Designer.cs” dosyasından da silmeniz gerekir. 

Tekrar etmek gerekirse; form veya forma yerleştirilen nesnelerin Properties penceresinde listelenen olaylarından birisi çift tıklandığında Visual Studio o nesne için bir metot hazırlayıp bu metodu olayla ilişkilendirmektedir. Bu söylenenlerin anlaşılmasına katkı olması için forma bir Button yerleştirip aşağıdaki gibi bir metot hazırladık. 

private void yesil_dugme(object sender, EventArgs e)
 {
   button1.BackColor = Color.SpringGreen; 
 }

Bu şekilde düzenlenen metot işletilirse forma yerleştirip “Form1” sınıfına üye yapılan “button1” nesnesinin BackColor özelliği yani zemin rengi değiştirilir. Fare işareti düğmenin üzerine götürüldüğü zaman bu metodun işletilmesini istediğimiz için Properties penceresinden yararlanıp bu metodun adını button1’in MouseHover olayına aktarabiliriz.

Bu metodu hazırlayıp ilgili olayla ilişkilendirme işlemini Visual Studio’dan yararlanarak yapmak isteseydik Properties penceresinde MouseHover olayını çift tıklayıp hazırlanan metoda yukarıda verilen satırı yazardık. Bu işlemi Visual Studio’dan yararlanmadan yapmak için formun Load olayını temsil edecek metodu aşağıdaki gibi düzenledik. 

private void Form1_Load(object sender, EventArgs e)
{
  this.button1.MouseHover +=new EventHandler(this.yesil_dugme);
}

Bu 2 hazırlıktan sonra proje çalıştırılıp fare işareti düğmenin üzerine götürüldüğünde düğmenin zemin rengi kendiliğinden yeşil olur. Bu şartlarda fare işareti düğmenin üzerinden uzaklaştırılsa düğme yeşil olarak kalmaya devam eder. Fare işareti düğmenin üzerinden uzaklaştırıldığında düğme ile ilgili olarak MouseLeave olayı meydana gelir. 

Properties penceresinde MouseLeave olayını çift tıklayıp bu olayla ilişkilendirilen bir metot hazırlayıp düğmenin renginin eskisi gibi olmasını sağlayabilirsiniz. Olay kavramanın anlaşılması için Visual Studio’dan yardım almadan aşağıdaki gibi bir metot hazırladık.

private void gri_dugme(object sender, EventArgs e) 
{
   button1.BackColor = Color.Gray; 
 }

Ardından fare işareti düğmenin üzerinden uzaklaştırıldığında meydana gelen MouseLeave olayı ile bu metot arasında ilişki kurmak için formun Load olayını temsil eden metoda 2. bir satır yazdık. Bu 2 satır ile yapılan işlemler hakkında daha sonra bilgi verilecektir. 

private void Form1_Load(object sender, EventArgs e)
{
  this.button1.MouseHover +=new EventHandler(this.yesil_dugme);
  this.button1.MouseLeave += new EventHandler(this.gri_dugme);
}

MessageBox Sınıfı

C# uygulaması dahilinde diyalog kutusu içinde kullanıcıya mesaj verip onay alınmak istendiğinde MessageBox sınıfının Show() metodu kullanılmaktadır. Show() metodu, kullanılması isteğe bağlı 4 parametreye sahiptir. İlk parametrede kullanıcıya verilecek mesaj, 2. parametrede ise diyalog kutusunun başlığı belirtilmektedir. 3. parametrede diyalog kutusunda yer alacak düğmeler seçilmektedir. MessageBox sınıfıyla ekrana diyalog kutusu getirilip kullanıcıdan nasıl onay alındığını anlatmak için aşağıda verilen metodu hazırladık. 

private void Form1_Click(object sender, System.EventArgs e)
 {
   MessageBox.Show("Formu Tıkladınız"); 
 }

Bu kodda MessageBox sınıfının Show() metodunun yalnızca ilk parametresi kullanıldı. MessageBox sınıfının Show() metodu bu hali ile işletilirse 1. parametre olarak verilen bilgi mesaj olarak ekrana getirilir ve diyalog kutusunda yalnızca Tamam düğmesi olur.



Show() metodu ile ekrana getirilen diyalog kutusunun başlık metnine sahip olmasını istiyorsanız bu metni 2. parametre olarak vermelisiniz. MessageBox sınıfı sayesinde ekrana diyalog kutusu getirmedeki amacınız kullanıcıya bilgi vermek ise ilk 2 parametre yeterlidir.

private void Form1_Click(object sender, System.EventArgs e)
 {
   MessageBox.Show("Formu Tıkladınız", "Onaylama"); 
 } 

MessageBox sınıfının Show() metodu sayesinde ekrana getirdiğiniz diyalog kutusunda kullanıcıya seçim yapma imkanı vereceksiniz 3. parametre ile diyalog kutusunda yer alacak düğmeleri belirtmeniz gerekir. MessageBox sınıfının Show() metodu aşağıdaki gibi kullanılırsa diyalog kutusunda Evet, Hayır ve İptal düğmeleri yer alır. 

MessageBox.Show("Bu Satır Silinecek", "Onaylama",
               MessageBoxButtons.YesNoCancel); 

MessageBox sınıfının Show() metodu ile ekrana getirilmek istenen diyalog kutusunda Durdur, Yeniden Dene ve Yoksay düğmelerinin olması isteniyorsa 3. parametre olarak “MessageBoxButtons.AbortRetryIgnore” sabiti kullanılmalıdır. Yukarıda verilen satır işletildiğinde aşağıdaki gibi bir sonuç alınır.



MessageBox sınıfı ile ekrana getirilen bu diyalog kutusunda tıklanan düğmeyi öğrenip ona göre işlem yapabilirsiniz. Show() metodu, tıklanan düğmeye bağlı olarak geriye DialogResult tipinde bir değer göndermektedir. Tıklanan düğmeyi öğrenmek için bir değişken tanımlayıp yukarıda verilen kodu aşağıdaki gibi değiştirdik.

DialogResult Onay= MessageBox.Show("Bu Satır Silinecek","Onaylama",
       MessageBoxButtons.YesNoCancel);
if (Onay == DialogResult.Yes)
          MessageBox.Show("Yes düğmesi tıklandı");
if (Onay == DialogResult.No)
          MessageBox.Show("No düğmesi tıklandı");

MessageBox sınıfının Show() metodu sayesinde ekrana getirilen diyalog kutusundaki mesajın önüne ünlem(!) veya soru(?) işaretinin konulmasını istiyorsanız bunu 4. parametrede belirtmeniz gerekir. Bu sınıfın Show metodunun 4. parametresinde aşağıdaki gibi MessageBoxIcon.Warning seçeneği kullanılırsa mesajın önüne ünlem(!) konulur.

DialogResult Onay;
Onay = MessageBox.Show("Bu Satır Silinecek","Onaylama",
       MessageBoxButtons.YesNoCancel,MessageBoxIcon.Warning);

Show() metodu ile kullanıcıya verilmek istenen mesaj bazen birden fazla satıra bölünüp öyle görüntülenmek istenir. Mesajı birden fazla satıra bölmek istiyorsanız “\n” karakterlerini mesaj metnine eklemeniz yeterlidir. Bu işlemin nasıl yapıldığını aşağıda görebilirsiniz.

private void Form1_Click(object sender, EventArgs e)
 {
   string Oyuncular = "Ömer Onan" + "\n";
   Oyuncular = Oyuncular + "İbrahim Kutluay";
   Oyuncular = Oyuncular + "\n" + "Mirsat Türkcan";
   Oyuncular = Oyuncular + "\n"+ "Kaya Peker";
   MessageBox.Show(Oyuncular);
 }

InputBox() İle Bilgi Girişi

C# projelerinde Visual Basic 6’dan .NET uyumlu dillere miras kalan herhangi bir metodu kullanmak istiyorsanız Add Reference diyalog kutusunu ekrana getirip Microsoft.VisualBasic referansını seçip Solution Explorer penceresinde listelemelisiniz.



.NET Framework ile gelen sınıflar namespace’ler şeklinde paketlenmektedir. Bir namespace’te istenilen sayıda Class ve/veya yapı olabilmektedir. Namespace’ler ise referans denilen DLL dosyaları içinde bulunmaktadır. Dolayısıyla kullanmak istediğiniz Class’ın yer aldığı referanstan Visual Studio’nun haberdar edilmiş olması gerekiyor.

Visual Studio veya Express Edition’da bu işlem Solution Explorer penceresinde yapılırken konsolda derleme yaparken uygulamada kullandığınız referansları reference parametresi ile belirtmeniz gerekir. Bu konuda bir sonraki bölümde bilgi verilecektir. Başka bir deyişle derleyici bu DLL dosyasının nerede olduğunu derleme sırasında bilmek ister. 

Madem Visual Basic’in InputBox() metodundan yararlanacağız; öncelikle bu metodun yer aldığı Class’ın dolayısıyla namespace’in dolayısıyla referansın projeye dahil edilmesi gerekir. Bu işlemi yukarıda gerçekleştirip Microsoft.VisualBasic adlı referansın Solution Explorer penceresinde listelenmesini sağladık. İlgili referansın Solution Explorer penceresinde listelenmesi sağlandıktan sonra Visual Basic 6 kaynaklı InputBox() metodunu C# projesinde kullanabilir. Aşağıda verilen kodda InputBox’ın en basit kullanım şekli var.

private void Form1_Click(object sender, EventArgs e)
 {
   string Takim=Microsoft.VisualBasic.Interaction.InputBox
           ("Takımınız", "Bilgi Girişi", "", 20, 20);  
 }

Bu metotta “Takim” değişkenine InputBox() metodu ile bilgi aktarılmaktadır. Bu metot işletildiği zaman aşağıda verilen diyalog kutusu ile karşılaşılır. InputBox’a 1. parametre olarak verilen bilgi diyalog kutusunun sol üst köşesine mesaj olarak yazılır.



InputBox’ı yukarıda verilen kullanım şeklinde önce namespace’in adını yazdık. Burada yararlanılan Microsoft.VisualBasic bir namespace’tir. Aslında “Microsoft” ayrı bir Namespace’tir ve bu namespace’in içinde 6 namespace vardır. Kod satırına ilgilendiğimiz namespace’in adını(burada Microsoft.VisualBasic) yazdıktan sonra sıra kullanmak istediğimiz Class’a gelir. VisualBasic adlı namespace’te çok sayıda Class bulunmaktadır. Interaction bu class’lardan birisidir. Uzun uzun yazmak gerekirse Microsoft.VisualBasic adlı referanstaki VisualBasic adlı namespace’teki Interaction Class’ı çok sayıda statik metoda sahiptir. 

Daha sonra ayrıntılı bir şekilde anlatılacağı üzere statik metotlar ilgili sınıftan yola çıkıp nesne hazırlamaya gerek kalmadan direk kullanılabilinen metotlardır. Interaction sınıfındaki InputBox veya diğer metotları üzerinde çalıştığınız kod dosyasında birden fazla kez kullanacaksanız veya kod satırlarının kısa olmasını istiyorsanız Microsoft.VisualBasic adlı namespace’i kod dosyasının en üstünde using anahtar kelimesi ile işaret etmeniz gerekir. 

Meraklılar için Microsoft.VisualBasic.dll referansı için buraya bir cümle yazalım. Bildiğiniz gibi .NET Framework ile birlikte C# derleyicisinden başka ayrıca .NET uyumlu Visual Basic derleyicisi gelmektedir. Visual Studio ile hazırlanan Visual Basic projelerinde tıpkı C# uygulamalarında olduğu .NET Framework ile gelen sınıflar istenirse kullanılmaktadır. Buna ek olarak Microsoft firması VB 6’ı kullanmış programcıların alışkanlarını sürdürebilmeleri ve geriye doğru uyumu sağlamak için eski Visual Basic 6’nın bazı sınıf ve metotlarını Microsoft.VisualBasic’te toplayıp programcıların istifadesine sundu. Madem konu Visual Basic’ten açıldı Visual Basic 6’ya özgü Left() metodunu nasıl kullanabileceğinizi görelim.

string sehir = "Adana";
string sonuc = Microsoft.VisualBasic.Strings.Left(sehir, 3);
MessageBox.Show(sonuc); // Sonuc Ada olur  

Projelerde Birden Fazla Form Kullanmak

Visual Studio’nun File menüsünden komut verilerek ekrana getirilen New Project diyalog kutusundaki Windows Forms Application şablonu ile hazırlanan projeler için bir formun otomatik olarak hazırlandığını biliyorsunuz. Üzerinde çalıştığınız projeye 2. bir form eklemek için Solution Explorer penceresinde projeye ait kısayol menüsünden Add komutu verildiği zaman açılan menüden Add Windows Form komutunu verebilirsiniz. Aşağıda verdiğim ekran görüntüsünü projeye 2. bir formu dahil ettikten sonra aldım.



Tabi daha önce başka amaçlarla hazırlamış olduğunuz mevcut bir formu üzerinde çalıştığınız projede kullanmak istiyorsanız Project menüsünden Add Existing Item komutunu verebilirsiniz. 

Projeye 2. bir form dahil etmek “Form2” adında bir class hazırlayıp projeye dahil etmek demektir. Projeye form dahil edilirken hazırlanan Class, System.Windows.Forms’deki Form adlı Class’ın mirasçısı olduğu için bu sınıfın bütün özellik ve metotlarına sahip olmaktadır. Server Explorer penceresinde bu “cs” dosyasının adını değiştirmeniz halinde class’ın adı da kendiliğinden değişir. 

Şimdi projedeki ilk formun üzerine Toolbox’tan yararlanıp bir düğme yerleştirip ve çalışma anında bu düğme tıklandığı zaman 2. formun açılmasını sağlayacağız. Bu işlem için bazı hazırlıkların yapılması ve ekrana getirilmek istenen formdan(class) yola çıkılarak nesne hazırlanması gerekiyor. Bu amaçla “Goster” adı verilen düğmeyi çift tıklayıp bu düğme çalışma anında tıklandığında işletilecek metodun Visual Studio tarafından hazırlanmasını sağladık. Ardından bu metoda aşağıda verilen satırı yazdık. 

privatevoid Goster_Click(object sender, EventArgs e) 
 { 
   Form2 Yeni_form = new Form2(); 
 } 


Projedeki ilk formun üzerindeki düğmenin Click olayını temsil eden metoda yazılan bu satır ile Form2’den yola çıkılarak “Yeni_form” adında bir nesne hazırlanmaktadır. Bir Class’ın(burada Form2) örneği hazırlanırken new anahtar kelimesi kullanılmaktadır. 

Yukarıdaki sayfalarda belirtildiği gibi sınıfların yapıcı metoduna sınıfın adı verilmektedir. Buna göre Form2 sınıfının yapıcı metodunun adı Form2() olmaktadır. C# programlama dilinde metotlar kullanılırken metot adına “()” eklenmektedir. 

Yukarıda verilen satırda gerçekte 2 işlem yapılmaktadır. İlk işlemde Form2 tipinde bir değişken tanımlanmaktadır. 2. işlemde ise new anahtar kelimesi ile Form2 sınıfının yapıcı metodu işletilip bu metodun geriye gönderdiği nesne(yani nesnenin adresi) tanımlanan değişkene aktarılmaktadır. Bu 2 işlemi tek satır yerine 2 satırda yapılmasını sağlayabilirsiniz. 

privatevoid Goster_Click(object sender, EventArgs e) 
 { 
   Form2 Yeni_form; 
   Yeni_form= new Form2(); 
 } 

Bu şekilde hazırlanan Form2 tipindeki nesne Show() metodu ile ekrana getirilebilir. “Form” sınıfının Show() metodunun nasıl kullanıldığını aşağıda görebilirsiniz. 

private void Goster_Click(object sender, EventArgs e) 
 { 
   Form2 Yeni_form = new Form2(); 
   Yeni_form.Show(); 
 } 

2 form içeren bu proje başlatıldığında projenin ilk formu Program.cs dosyasında Application sınıfının Run() metoduna parametre olarak verildiği için kendiliğinden ekrana gelir. Aşağıda verilen ekran görüntüsü Form1’deki düğme tıklanıp yukarıda verilen metodun işletilmesi sağlanıp 2. formu ekrana getirildikten sonra alındı.



Yukarıda değişken tanımlayıp nesne hazırlayan satırı düğmenin Click olayı ile ilişkilendirilen metoda yazdık. Bu nedenle çalışma anında ekranda Form2 varken Form1’deki düğme 2. kez tıklanırsa aynı nesne tekrar oluşturulur ve 2. form tekrar ekrana getirilir. Başka bir deyişle masaüstünde açık olan formların sayısı üçe çıkar. 

Ekranda 2. form varken yukarıda verilen kod işletildiğinde aynı formun 2. veya 3. kopyalarının hazırlanıp ekrana gelmesini engellemek için kullanılabilinecek değişik teknikler olmakla birlikte ilk akla geleni yazacağız. Bu amaçla “Göster” düğmesi için hazırladığımız kodu değiştirip Show() yerine ShowDialog() metodunu kullandık. 

private void Goster_Click(object sender, EventArgs e) 
 { 
    Form2 Yeni_form = new Form2(); 
    Yeni_form.ShowDialog();  
 }

ShowDialog()metodu ile ekrana getirilen form kapatılmadan projenin ana formuna geçilemez. Formları ShowDialog() metodu ile ekrana getirmenin bir diğer özelliği ise şudur: ShowDialog() metodu ile ekrana getirilen form normal bir şekilde yani Kapat düğmesi tıklanarak kapatıldığında bellekten yok edilmeyip gizlenmektedir. 

Bu sorunun önüne geçmek, başka bir deyişle hem 2. formu Show() metodu ile ekrana getirmek hem de ekranda aynı anda 2 kopyasının olmasını engellemek için değişken tanımlama satırı düğmenin Click olayını temsil eden metodun dışına alınabilinir. 

Form2Yeni_form = new Form2();
privatevoid Goster_Click(object sender, EventArgs e) 
  { 
    Yeni_form.Show();  
  } 

Bu şartlarda “Göster” düğmesini tekrar tıklasanız bile 2. form tekrar ekrana getirilmez. Ancak bu şekilde ekrana getirdiğiniz 2. formu kapattıktan sonra Show() metodu ile ekrana getirmek istemeniz halinde hata meydana gelir. Yani Form1’e 2. bir düğme yerleştirip bu formu Show() metodu ile ekrana getirmek istemeniz halinde hata meydana gelir. Çünkü bu şekilde hazırlanıp Show() metodu ile ekrana getirilen form normal bir şekilde kapatıldığında otomatik olarak yok edilir. Dolayısıyla yok edilen form tekrar ekrana getirilemez. 

Projedeki 2. formun ekrana getirilmesi sırasında yaşanan bütün sorunların önüne geçmek için formu oluşturan ve Show() metodunun kullanıldığı satırları aynı metoda yazdık ama form nesnesini new anahtar kelimesi ile tekrar oluştururken mevcut olup olmadığını araştırdık. Söz konusu form nesnesi henüz oluşturulmadıysa null olmaktadır. 

Form2 Yeni_form;
private void Goster_Click(object sender, EventArgs e) 
 { 
   if (Yeni_form == null || Yeni_form.IsDisposed) 
     { 
       Yeni_form = new Form2(); 
       Yeni_form.Show(); 
     } 
} 

Show()metodu ile ekrana getirdiğiniz formları Hide metodu ile gizleyebilir veya Close() metodu ile kapatabilirsiniz. Close() metodu ile formların nasıl kapatıldığını anlatmak için yukarıda Show() metodu ile ekrana getirdiğimiz 2. formu kapatacağız. 

Bu amaçla projedeki 2. forma “Kapat” başlıklı bir düğme yerleştirip bu düğmenin Click olayını temsil eden metoda aşağıda verilen satırı yazdık. Bu satır sayesinde 2. form kapatılır. Formu kapatmak yerine gizlemek istiyorsanız Hide() metodunu kullanabilirsiniz. Hide() metodu sayesinde gizlenen form bellekten silinmez.



Çalışma anında aktif form kapatıldığında FormClosing olayı meydana gelir. Bu olayı temsil eden metoda kod yazarak formun kapatılması işlemini kontrol altına alabilirsiniz. Söz konusu form kapatıldığında işletilecek metodun yapısını aşağıda görebilirsiniz.



Bu metodun “e” adındaki 2. parametresinin Cancel özelliğini true yaparak formun kapatılmasını önleyebilirsiniz. “e” parametresinin Cancel özelliğinin nasıl kullanıldığını anlatmak için 2. formun FormClosing olayı ile ilişkilendirdiğimiz metodu aşağıdaki gibi düzenledik. Kapatılmak istenen formun “e” parametresinin Cancel özelliği true iken form kapatılmaz. 

 privatevoid Form2_FormClosing(object sender, FormClosingEventArgs e) 
  { 
   System.Windows.Forms.DialogResult Cevap; 
   Cevap = MessageBox.Show("Form2 kapatılsın mı?", "Kapatma", MessageBoxButtons.YesNo); 
    if (Cevap == DialogResult.No) 
     { 
        e.Cancel = true; 
     } 
 }

Şimdi projedeki ilk forma ait kod dosyasında iken diğer formun yani diğer Class’ın(Form2) üzerinde nasıl işlem yapıldığını anlatacağız. Bu amaçla projedeki 2. formu ekrana getirmek amacıyla hazırlanan koda aşağıdaki gibi bir satır ekledik.

Bu satır sayesinde 2. formun başlığında değişiklik yapılır. Ancak bu şartlarda 2. forma yerleştirilen nesnelere erişilemez. Çünkü formlara yerleştirilen veya kod yazılarak hazırlanan nesneler başlangıçta private’dir yani o Class’a özeldir. Aşağıda verilen ekran görüntüsü projedeki 2. forma bir TextBox yerleştirildikten sonra alındı. Visual Studio, formlara yerleştirilen nesneleri hazırlayan satırları ilgili formun(yanisınıfın) Designer.cs dosyasına yazmaktadır.

Forma tasarım anında yerleştirilen TextBox için değişken tanımlama satırındaki private anahtar kelimesi silinip yerine public yazılırsa başka Class’lardan veya projedeki diğer formlardan bu TextBox’a erişim sağlamak mümkün olur. 2. forma ait kod dosyasında textBox1 public yapıldığı için aşağıda işaret edilen satır hataya neden olmaz.

 

Forma yerleştirdiğiniz nesneye başka bir formdan yani başka Class’tan erişilebilinsin istiyorsanız Visual Studio’nun kendi hazırladığı koda müdahale etmek yerine Properties penceresinde söz konusu nesnenin Modifiers özelliğinde ayarlama yapabilirsiniz. 

ShowDialog() Metodu 

Yukarıda işaret edildiği gibi projedeki 2. formu ekrana getirirken Show() veya ShowDialog() metotlarından birisini kullanabiliyorsunuz. ShowDialog() ile ekrana getirilen form kapatılmadan söz konusu C# uygulamasının açık olan diğer formlarına geçmenin mümkün olmadığını biliyorsunuz. Burada bu konuyu tekrar açmamın nedeni ShowDialog metodunun Show’dan farklı olarak geriye DialogResult tipinde bilgi gönderiyor olmasıdır. ShowDialog metodu hakkında ek bilgiler vermek için 2 forma sahip bir proje hazırlayıp ilk forma bir düğme yerleştirip düğmenin Click olayını temsil eden metoda aşağıda verilen kodu yazdık. 

private void Goster_Click(object sender, EventArgs e) 
  { 
    DialogResult sonuc; 
    Form2 Yeni_form = new Form2(); 
    sonuc = Yeni_form.ShowDialog();  
  } 

Bu kodda şimdiye kadarki ShowDialog() kullanımlarından farklı olarak ShowDialog metodunun geriye gönderdiği bilgi yakalanıp DialogResulttipindeki değişkene aktarılmaktadır. Ekranda ShowDialog metodu ile açılan form varken C# uygulaması ile ilgili başka bir işlemin yapılamadığını biliyorsunuz. Konu üzerinde düşünmenizi sağlamak için bu koda 4. bir satır ekledik. 

private void Goster_Click(object sender, EventArgs e) 
 { 
   DialogResult sonuc; 
   Form2 Yeni_form = new Form2(); 
   sonuc = Yeni_form.ShowDialog(); 
   Yeni_form.Visible = true;  
 } 

Bu satır ancak ShowDialog() metodu ile ekrana getirilen form kapatıldığı zaman işletilir ve kapatılan form tekrar ekrana getirilir. Ancak bu form bu kez diyalog kutusu gibi davranmayıp normal pencerelerdeki gibi başka formlara geçmenize izin verir. Bundan şu sonucu çıkarmak mümkündür: ShowDialog ile ekrana getirilen form normal yollardan kapatıldığında bellekten silinmeyip gizlendiği için Visible özelliği true yapılıp tekrar ekrana getirilebilir. 

Projedeki 2. formu ShowDialog yerine Show metodu ile ekrana getirmiş olsaydık “Goster” düğmesi için hazırlanan bu kod tekrar baştan işletilmeden 2. form ekrana getirilemezdi. Yani ilk formdaki “Göster” düğmesi için yazılan kod aşağıdaki gibi düzenlense bile 2. form kapatıldıktan sonra ekrana gelmez. Çünkü Show() metodu ile ekrana getirilen form normal yollardan kapatıldığında otomatik olarak Dispose() metodu ile bellekten silinmektedir. 

private void Goster_Click(object sender, EventArgs e) 
 { 
   Form2 Yeni_form = new Form2(); 
   Yeni_form.Show(); 
   Yeni_form.Visible = true; 
 } 

Şimdi öyle bir ayarlama yapacağız ki ShowDialog metodu ile ekrana getirilen form Kapat düğmesi tıklanarak kapatıldığında bellekten silinmesini sağlayacağız. Bu amaçla ShowDialog metodunun geriye gönderdiği DialogResult tipindeki değişkenin içeriğini kontrol edeceğiz. Aslında ShowDialog metodu ile ekrana getirilen form nasıl kapatılırsa kapatılsın ShowDialog() metodu geriye Cancel bilgisini göndermektedir. 

ShowDialog() metodunun geriye gönderdiği DialogResult tipindeki bilgi daha çok OpenFileDialog ve SaveFileDialog kontrolleri sayesinde ekrana getirilen diyalog kutuları kullanılırken işlevsel olmaktadır. Buna rağmen sanki ShowDialog metodu geriye farklı değerler gönderebilirmiş gibi aşağıda yapıldığı gibi geriye gönderilen bilgi kontrol edildi. 

private void Goster_Click(object sender, EventArgs e) 
  { 
    Form2 Yeni_form = new Form2(); 
    DialogResult sonuc = Yeni_form.ShowDialog(); 
    if (sonuc == DialogResult.Cancel) 
      MessageBox.Show("Kapattığınız form bellekte duruyor");  
} 

ShowDialog() metodu ile ekrana getirilip sonra Kapat düğmesi ile kapatılan formun bellekten yok edilmesini istiyorsanız, başka bir deyişle referansının yok edilip erişilemez olmasını istiyorsanız 2. formu ekrana getirmek için hazırladığınız kodu aşağıdaki gibi düzenleyebilirsiniz. Burada kullanılan Dispose() metodu hakkında daha sonra bilgi verilecektir. 

private void Goster_Click(object sender, EventArgs e) 
 { 
   Form2 Yeni_form = new Form2(); 
   Yeni_form.ShowDialog();
   Yeni_form.Dispose(); 
 } 

Projenin Başlangıç Formunu Seçmek

Projenizde birden fazla form varsa proje başlatıldığında ilk olarak hangi formun ekrana geleceği konusunda seçim yapmak isteyebilirsiniz. Projeler, varsayım olarak projeye ilk sırada dahil edilen formdan başlarlar. Başlangıç formu ile ilgili ayarlamalar “Program.cs” dosyasında yapılmaktadır. Program.cs dosyasından aşağıda verilen kod alındığı sırada üzerinde çalıştığımız proje 2 forma sahipti ve projenin başlangıç formu Form1’di. 

static void Main() 
  { 
    Application.EnableVisualStyles(); 
    Application.SetCompatibleTextRenderingDefault(false); 
    Application.Run(new Form1());
   } 

Projenin başlangıç formunun Form2 olmasını istiyorsanız Application.Run(new Form1()); satırındaki Form1’i silip yerine “Form2” yazmanız yeterlidir. 

Application.Run(new Form2(); 

Şimdiye kadar “Program.cs” dosyası hakkında verilen bilgilere göre projede kaç form olursa olsun bu formlardan birisinin örneği new anahtar kelimesi ile hazırlanıp Application nesnesinin Run() metoduna parametre olarak verilmektedir. Program.cs dosyasında new anahtar kelimesini birden fazla kez kullanıp birden fazla formun kopyasını oluşturup Application sınfıının Run() metodunu birden fazla kez kullanabilirsiniz. Bu konuda bilgi vermek için 2 forma sahip bir proje hazırlayıp Program.cs dosyasındaki Main() metodunu aşağıdaki gibi düzenledik. 

static void Main() 
 { 
   Application.EnableVisualStyles(); 
   Application.SetCompatibleTextRenderingDefault(false); 
   Application.Run(new Form1()); 
   Application.Run(new Form2()); 
 } 

Bu şartlarda bu proje çalıştırılırsa Run() metodunun kullanıldığı ilk satırda ilk form ekrana getirilir. İlk form kapatıldığında Run() metodunun 2. kez kullanıldığı satır işletilir ve 2. form ekrana getirilir. Application Sınıfı adlı bölümde bu konu üzerinde durulacak olsa bile arka arkaya Run() metodunu kullanmanın arka planından biraz söz etmek gerek.

Tahmin ettiğiniz gibi Visual Studio ile hazırlanan C# uygulamaları Main() metodunun sonuna gelindiğinde çalışmaları sona erer. Ancak kontrol Application sınıfının Run() metoduna parametre olarak verilen forma geçtiği için bu form kapatılana kadar uygulama çalışmaya devam eder. Tıpkı Windows’un çalışmasını sona erdirmek için Masaüstü adı verilen ana pencerenin kapatılması gerektiği gibi. 

Bu şekilde düzenlenen projedeki ilk form başlangıç formu olarak düzenlenebilir. Şimdi bu projedeki ilk formu kullanıcıdan şifre istenen başlangıç formu olarak kullanacağız. Bu amaçla projenin ilk formunu aşağıdaki gibi düzenledik.



Kullanıcı şifre girip Tamam düğmesini tıkladığında şifre kontrol edilecek. Şifre geçerli değilse projenin çalışması sona erdirilecek. Tamam düğmesi tıklandığında formun kapatılmasını sağlamak için bu düğmenin Click olayını temsil eden metodu aşağıdaki gibi düzenledik.

pririvate void Tamam_Click(object sender, EventArgs e)
 {
    this.Close();
 }

Bildiğiniz gibi Close() metodu veya başka bir teknikle form kapatıldığında FormClosing olayı meydana gelmektedir. Bu nedenle şifre kontrolü yapılan satırları ilk formun FormClosing olayını temsil eden metoduna yazdık. Projelerin çalışması genellikle Application sınıfının Exit() metodu ile sona erdirilmektedir. Bu kodu geliştirip şifre konusunda kullanıcıya haklar verebilirsiniz.

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
   if (textBox1.Text != "12345")
     Application.Exit();
}

Şimdi ise bu projedeki yani Program.cs dosyasında Main() metodunda Application sınıfının Run() metodunu 2 kez kullandığımız projenin ilk formunu başlangıç formu(Splash Screen) olarak kullanacağız. Yani proje çalıştırıldığında ilk form kısa bir süre ekranda kalıp kullanıcıya program hakkında bilgi verdikten sonra kendiliğinden kapanmasını sağlayacağız.

Bu işlemi yaparken forma bir Timer nesnesi yerleştirip Enabled özelliğini true yapıp Interval özelliğine 5000 aktarıp Tick olayını temsil eden metodu aşağıdaki gibi düzenledik. Bu satır sayesinde ilk form ekranda 5 saniye kaldıktan sonra kendiliğinden kapanır.



Kod Yazarak İle Nesnelerin Özelliklerini Değiştirmek

Forma yerleştirdiğiniz Label, TextBox ve Button gibi nesnelerin özelliklerini Properties penceresinden yararlanarak veya kod yazarak ayarlayabilirsiniz. Şimdi forma bir Label yerleştirip Text özelliğini kod yazarak değiştireceğiz. Bu değişikliğin proje çalıştırıldığında kendiliğinden olmasını saklamak için Label nesnesinin Text özelliğinde değişikliğe neden olacak satırı formun Load olayını temsil eden metoda yazdık.



Kod yazarak ilgili nesnenin hangi özelliğini değiştirmek istiyorsanız önce nesnenin, sonra özelliğin adını yazmanız gerekir. İlk formunun Load olayını temsil eden metodu bu şekilde düzenlenen proje çalıştırılırsa formun üzerine "Microsoft Visual C#" yazılır. 

Şimdi hazırlayacağız kod sayesinde çalışma anında form tıklandığı zaman formun başlığının değişmesini sağlayacağız. Bu amaçla Properties penceresinde formun özellikleri listelenirken Events sekmesine geçip Form sınıfının olaylarının listelenmesini sağladık.

Çalışma anında form tıklandığında formun başlığının değişmesini sağlamak için Click olayını seçtik. Properties penceresinde Click olayı çift tıklanırsa bu olay meydana geldiği zaman işletilecek bir metot hazırlanır.

Burada kullanılan “this” geçerli Class’ı temsil etmektedir. “this” yerine formun ActiveForm özelliğini kullanabilirsiniz. Direk “Form1.Text” şeklinde yazmanıza izin verilmez. Çünkü buradaki Form1 projedeki ilk formu temsil eden sınıfın adıdır nesnenin değil. 

Form1.ActiveForm.Text = "Pencere1"; 

Kendi hazırladığınız metotları silmek istiyorsanız Code penceresinde o metoda ait satırları silebilirsiniz. Hazırladığınız metotları kod penceresinde sildiğinizde Properties penceresinde olay adının karşısına yazılan metot adlarını Visual Studio silmektedir. 

Yukarıdaki sayfalardan hatırlayacağınız gibi Properties penceresinde herhangi bir olayın adı çift tıklanıp metot hazırlandığı zaman forma ait “Designer.cs” dosyasında Windows Form Designer generated code adlı blokta metot ile ilgili olay arasında ilişki kurulmaktadır. Bu nedenle silmiş olduğunuz metot daha önce formun herhangi bir olayı ile ilişkilendirilmişse Designer.cs dosyasındaki ilgili satırı da silmelisiniz. Yoksa hata meydana gelir.



Toolbox’tan yararlanarak forma yerleştirdiğiniz Button ve TextBox gibi kontrollerin bazı olayları için Visual Studio’dan yararlanıp metot hazırlayıp sonra da bu nesneleri formdan silerseniz bu metotlar ile ilgili nesnelerin olaylarını ilişkilendiren satırlar Designer.cs dosyasından otomatik olarak silinir. Ancak forma ait bir olay için Visual Studio’dan yararlanıp bir metot hazırlayıp sonra da bu metodu Form1.cs dosyasından silerseniz Form1.Designer.cs dosyasındaki satır olduğu gibi kalacağı için hata meydana gelir. 

TextBox Kontrolü 

Her ne kadar konunun başlığı TextBox olsa bile burada amacımız TextBox hakkında bilgi vermekten çok olay kavramının anlaşılmasını sağlamaktır. Bu amaçla projenin formunu aşağıdaki gibi düzenledik. Çalışma anında bu TextBox’a girilecek bilgileri MessageBox sınıfının Show metodu ile bir diyalog kutusu içinde ekrana getirmek için kod hazırlayacağız.



Yapılacak ayarlamaya göre çalışma anında Enter tuşuna basılınca TextBox’a o ana kadar girilen bilgiler bir diyalog kutusu içinde ekrana getirilecek. Burada yapılması gereken, basılan tuşun Enter tuşu olup olmadığını araştırmaktır. 

Çalışma anında imleç TextBox’ın içinde iken klavyenin herhangi bir tuşuna basılması halinde TextBox’la ilgili olarak KeyPress olayı meydana gelir. Bu nedenle ilk yapılması gereken, forma yerleştirilen TextBox için KeyPress olayı meydana geldiği zaman işletilecek bir metot hazırlamak ve bu metodu KeyPress olayı ile ilişkilendirmektir. Bu nedenle Properties penceresinde TextBox’ın olayları listelenirken KeyPress olayının üzerine gittik.

Properties penceresinde TextBox’a ait KeyPress olayının üzerinde çift tıklama yapılırsa Visual Studio hem KeyPress olayı için bir metot hazırlar hem de Code Editor penceresini açar. TextBox seçili iken Properties penceresinde KeyPress olayının üzerinde çift tıklama yapılırsa Visual Studio aşağıda verilen metodu hazırladı. 

Properties penceresinde KeyPress olayı çift tıklandığında hazırlanan metot geri planda Designer.cs dosyasında değişiklik yapılarak TextBox1’in KeyPress olayıyla ilişkilendirilir. Visual Studio’nun textBox1_Keypress() adını verdiği metot KeyPress olayıyla ilişkilendirilmezse tuşa basıldığında bir karşılık alınamaz ve bu metot işletilmez. 

private void textBox1_KeyPress(object sender, KeyPressEventArgs e) 
 { 
 } 

Properties penceresinde seçilen nesne ve olaya bağlı olarak Visual Studio tarafından otomatik olarak hazırlanan bu metotta, metot adından sonra parantezlerin içinde (object sender, KeyPressEventArgs e))bilgisi var. Daha açık anlatımla TextBox sınıfının KeyPress olayı için hazırlanan bu metot object ve KeyPressEventArgs tipinde 2 parametreye sahiptir. 

KeyPress olayı meydana geldikçe basılan tuşu öğrenip ona göre işlem yapmak için her seferinde basılan tuşla ilgili olarak metoda parametreler aracılığı ile bilgi gönderilir. Parametreler metot adından sonra parantez içine yazılır. Basılan tuşu temsil eden bilgi veya ASCII kodu metoda gönderileceği için KeyPressEventArgs e ile gelecek bilgi belirtiliyor. Buradaki “e”, her tuşa basma işlemi sırasında basılan tuşun Ascii kodunun ve başka bilgilerin aktarıldığı KeyPressEventArgs tipindeki parametredir. 

 private void textBox1_KeyPress(object sender, KeyPressEventArgs e) 
  { 
    if (e.KeyChar == 13) 
      MessageBox.Show(textBox1.Text);   
  } 

Bu metotta “if” deyimi ile en son basılan tuşun ASCII kodu 13 olan Enter olup olmadığı araştırılıyor. En son basılan tuşun kodu 13 ise MessageBox sınıfının Show() metodu ile “Text” özelliğinin içeriği ekrana getiriliyor. En son basılan tuşun kodu 13 değilse imleç TextBox’ın içinde beklemeye devam eder. Bu şekilde düzenlenen proje çalıştırılıp TextBox’a bilgi girilip enter tuşuna basılırsa aşağıdaki gibi bir sonuç elde edilir.

 

Şimdi yukarıda verilen metotta değişiklik yapıp TextBox’a girilen karakterlerin ASCII kodunu öğrenip Show() metodu ile ekrana getireceğiz. TextBox’a yazılan karakterin kodunu KeyPress olayından yararlanarak bulmak mümkündür ama basılan tuşun ASCII kodu KeyDown olayına ait metot ile daha kolay öğrenilmektedir. Aşağıda verilen kod dikkatle incelenirse TextBox sınıfının KeyDown olayı için hazırlanan metodun parametre yapısı KeyPress olayını temsil edebilen metottan farklıdır. 

private void textBox1_KeyDown(object sender, KeyEventArgs e) 
 {     
    int kod = e.KeyValue; 
    MessageBox.Show(Kod.ToString());   
  } 

Bu metotta ilk olarak “kod” adında integer bir değişken tanımlanmakta ve KeyDown olayının meydana gelmesine neden olan tuşun Ascii kodu KeyEventArgs tipindeki “e” parametresi aracılığıyla bu değişkene aktarılmaktadır. Aşağıda verilen ekran görüntüsü çalışma anında TextBox’a bir karakterlik bilgi girilip bu metot işletildikten sonra alındı.