C# E-Kitap Memik Yanik

C#’a Başlangıç Kitabı
Memik Yanık
memiky@superonline.com
memikyanik@hotmail.com
www.memikyanik.com
Mart 2009
2 Memik Yanık - C#’a Başlangıç Kitabı
Önsöz
Son yazdığım C# kitabımda başlangıç düzeyi konuların ağırlığını azaltmayı

tercih ettiğim için C# konusunda henüz yolun başında olanlar zorluk
çekmesin diye birkaç makale hazırlayıp kişisel sitemde yayınladım. Sonra bu
makaleleri elden geçirip e-book haline getirdim. E-book’larda sayfa
sınırlaması olmadığı için metni az sayfaya sığdırma gibi bir kaygım olmadı.
Başka bir deyişle bu e-book’u, yakın zamanda çıkan C# 3.0 kitabıma
yardımcı veya hazırlayıcı bir kitap olarak değerlendirmek mümkündür.
Bu e-book’u inceleyenlerin fark edeceklerini sandığım bir diğer konu ise C#

gibi bir programlama dilinin nasıl kolay anlatıldığını görmeleri olacaktır.
Başka bir deyişle bu metin için rahatlıkla “dünyanın e kolay okunan C#
kitabı” denilebilir. Yıllardır Memik Yanık’ı hep başlangıç düzeyi kitaplar
yazmakla suçlayanlar bakalım bu e-book’u gördüklerinde neler
söyleyecekler?
Yıllardır kendisini bilen bilmeyen birçok kişi Memik Yanık’ı çeviri yapmakla
suçluyor. Memik Yanık’ın Đngilizcesinin çeviri yapmaya yetmediği gerçeğini
bir tarafa bırakalım ve şu soruyu sorayım: Madem Memik Yanık Türkçeye bu
kadar hakim ve yazdıkları kolay okunuyor hangi akla hizmet yabancı bir
yazarın kitabında çeviri yapar? Hem Memik Yanık Đngilizceyi anadili gibi bilse
bile hangi mantıkla kendine özel cümle kurmak yerine gidip başka bir
yazarın cümlelerini alır?
Bu e-book’ta kenar boşlukları normal basılı kitaplara göre daha azdır, fontu
ise daha büyüktür. Dolayısıyla bu metni normal kitap olarak değerlendirmek
istemiş olsaydım sayfa sayısı aşağı yukarı aynı olurdu. E-book’un sonunda
C# 3.0 kitabım hakkında yazdığım bir yazı ve C# 3.0 kitabımdan alınma bir
bölüm bulunmaktadır.
BÖLÜM 1
C# ĐLE PROGRAMCILIK
Bundan yaklaşık 1.5 yıl önce(Aralık 2007) kişisel web sitemde yayınlamak
üzere C#, Visual Basic ve Delphi hakkında başlangıç düzeyi bilgi içeren ve
ders şeklinde düzenlediğim makaleler hazırladım. Bu makaleleri ilk yazmaya
başladığımda her programlama dili için 5 yazı düşünmüştüm. C# ve Visual
Basic için hazırladığım derslerin sayısı 4’te kalırken Delphi için yazdığım
yazıların sayısı üçte kalmıştı. Dersleri tam gaz kaleme alırken değişken adı
benzerliği davası yazma hevesimi kırmıştı. Çünkü programcılık öğrenmek
isteyenlere tecrübelerimi aktarırken değişken adı çalma suçlaması ile
kendimi sanık pozisyonunda hakim karşısında bulmuştum.
2008 yılının son aylarında bir yıl önce yarım bıraktığım dersleri tamamlamak
üzere yeninden çalışmaya başladım. Dersleri ilk kaleme aldığım zaman C#,
Visual Basic ve Delphi dersleri birbirine paralel gidiyordu. Yani önce bir C#
dersi, birkaç gün sonra benzer konuları Visual Basic için kaleme alıyordum.
Ancak bu kez öyle yapmadım. Öncelikle C# derslerini bitirmeye çalıştım. C#
derslerini tamamladıktan sonra bu kez Visual Basic derslerini yeniden
hazırlayıp yayınlamaya karar vermiştim. C# ilgili dersleri kaleme alırken bir
yıl önce kaleme aldığım dersleri gözden geçirip eklemeler yapacağım.
Doğrusu geçen yıl(2007 sonu) bu programcılık derslerini okuyup sonra da az
çok programcılıkla uğraşanlara bu derslerin yeni halinin fazla bir katkısı
olmayacaktır. Çünkü bu derslerin hedef okur grubu C#, Visual Basic veya
Delphi ile programcılığına yeni başlayanlar olacaktır. Başka bir deyişle bu
dersleri, geçen yıl yayınlanan derslerin genişletilmiş baskısı olarak
değerlendirebilirsiniz. Aradan biraz zaman geçip C# derslerini tamamlayınca
tekrar gözden geçirip e-book olarak C# öğrenmek isteyenlere sunmaya
karar verdim. Böylece dersleri okumak kolaylaşmış olacaktır.
Bir makale veya kitap kaleme alınırken bir okur grubu hedeflenir ve ona
göre bir anlatım düzeyi seçilip konular ulaşılmak istenen hedef okur
grubunun "tahmini" beklentilerine göre sıralanır. Bu e-book’un hedef okur
grubu daha önce C# programlama dilliyle “uğraşmamış” olanlardır. Ya da
C#’la ilgili derslerde hocalarını izlemekte zorluk çeken öğrencilerdir, aldıkları
kitabı okuyup anlamakta zorlananlardır, her hangi bir sitede rastladıkları
makalede kullanılan kavramlara uzak olanlardır.
Öğretim üyeleri veya programcılık dersini veren hocalar öğrencilere ders

anlatırken ne fazla bilgili öğrencileri ne de o programlama diliyle daha önce
hiç yakınlığı olmayanları referans alırlar. Dersleri veren hoca sınıfın
ortalamasına göre bir anlatım düzeyi tutturmaya çalışır. Tekrar etmek
gerekirse bu e-book oluşturan dersleri C# veya sözü edilen diğer
programlama dilleri hakkında henüz bilgisi olmayanlar için kaleme aldım.
Bu dersleri kaleme alırken gerçekte klasik anlamda bir amacım yoktu:

Programcılık üzerine yazmayı seviyorum. Programcılık üzerine yazdıklarımı
önceleri(yani bundan 17 yıl kadar önce) bilgisayar dergilerinde yayınlayarak,
kitap şeklinde düzenleyerek sizlere ulaştırdım. Eskisi kadar olmasa bile kitap
yazmayı sürdürüyorum. Her ne kadar birçok insan sırf Memik Yanık
programcılık konulu kitaplar yazmasın diye seferber olmuş olsa bile yine de
yazmayı sürdürüyorum.
Yıllardır bilgisayar ve programcılık üzerine yazarken temel ilkem veya ön

şartım yazdıklarımın ilk okumada anlaşılmasını sağlamaktı. Bundan
vazgeçmiş değilim. Daha önce herhangi bir şekilde herhangi bir dilde 2 satır
kod yazdıysanız ve programcılığa merakınız varsa burada yazılanları ilk
okumada mutlaka anlarsınız. Bu nedenlerdir ki bu derslerin ayırt edici
özelliği kolay okunmasıdır. Yoksa bu derslerde verilen bilgileri başka
sitelerde ve programcılık kitaplarında bulabilirsiniz. Bu derslerin asıl işlevi
programcılık öğrenmeye karar vermiş olanların veya programcılık derslerini
zevkle izlemek isteyenlerin önünü açmaktır, öğrenme sürelerini kısaltmaktır.
Çevrenizde C#, VB, Delphi veya C++ programlama dilini bilenlere gıpta mı
ediyorsunuz veya C#’ı, Delphi'yi nasıl öğrenirim diye kara kara düşünüyor,
okulunuzda gördüğünüz C#, C++, Visual Basic derslerinden nasıl geçerim
diye kaygılanıyorsanız ilk olarak bu olumsuz düşünceleri bir tarafa bırakın
derim. Yıllarca kitaplarımın arkasında büyük puntolarla “Memik YANIK
tarafından yazılan kitaplarda ilk okumada anlaşılmayan hiçbir konu
yoktur” yazdırdım. Bu cümle birçok insanın bana saldırıp hakaretler edip
küfürler savurmasına neden olsa bile bu iddiadan vazgeçmiş değilim. Hatta
birileri hızını alamayıp “Memik Yanık kitaplarında verdiği 3–5 satırlık kısacık
kodlarda kullandığı değişkenlere ad seçerken benim kitaptan yararlanıp
değişkenlerimin adını çalmıştır” diye suçladı.
Birçok forumda her gün ismi cismi belli olmayan çok sayıda kişinin Memik
Yanık’a hakaretler düzmesinin tek nedeni yazdıklarımın ilk okumada
mutlaka anlaşılıyor olması değildir elbette. Tepki çekmemin 2. bir nedeni
değişik konularda kitaplar yazmamdır. Bir çok kişi “Bir kişi nasıl olurda
hem Visual Basic, hem Delphi hem de Clipper hakkında kitaplar
yazabilir? Olsa olsa başkasına yazdırıyordur veya çeviri yapıyordur”
şeklinde görüşler ileri sürdüler. Sanki bir gün Clipper kitabını, birkaç gün
sonra ise Visual Basic kitabını yazıp yayınlamışım gibi suçlanıyorum. Hal bu
ki bütün bu kitapları tam 17 yılda yazdım. Bazı kitaplarımın arkasına "bu
kitap telif bir kitaptır yabancı yazarların kitaplarından araklanmadı" diye
yazmış olmama rağmen inandırıcı olamadım.
Gerçekte programcılık kitaplarında kimse bilim yapmıyor, kimse yeni bir şey
üretmiyor. Yapılan tek şey; bütün özellikleri ortada olan programlama dilini
Memik Yanık - C#’a Başlangıç Kitabı 5
kendi anlayışıyla kendi cümleleri ile anlatmaktır. Örneğin yüz yıllardır aşk
üzerine yazılmış on binlerce roman vardır, aşk konulu binlerce film vardır.
Aynı şekilde C# üzerinde yazılmış yüzlerce kitap vardır. Bütün yazarlar aynı
konuları anlatıp, aynı metotlardan, aynı sınıflardan söz ediyorlar. O zaman
C# konulu kitapların arasındaki fark nedir diye soranlara verilecek cevap
şudur: Fark anlatım şeklindedir. Elinize aldığınız kitapta yazarın anlatım
şekli, cümleleri, konuları sıralayış vs size uygunsa o kitap sizin için iyidir.
Bu dersleri izleyen okurları bir konuda uyarmak istiyorum: Siz siz olun
yazdığınız kodlarda tanımlayıp kullandığınız değişkenlere ad seçerken
dikkatli olmalısınız. Olur ya boş bulunup daha önce register(!) edilmiş veya
kullanım hakları kapatılmış i, j, sayi, dosya gibi adlara sahip değişkenler
tanımlarsanız ve bu tespit edilirse başınız belaya girebilir. Bu uyarıya
rağmen şu açıklamayı yapmayı gerekli görmekteyim: Bu derslerde
kullandığım değişken adlarının mevcut Türkçe programcılık kitaplarındaki
değişken adları ile benzerlik göstermesi tesadüf eseridir.
C# Programcısı Đçin Gerekli Araçlar
Daha önce herhangi bir programlama dili ile az çok kod yazdıysanız “off
şimdi bu C#’ı kim öğrenecek, Microsoft firması bu programlama dilini keşke
hazırlamasaydı, bir sürü Class, yeni bir dil” diyorsanız bu düşüncenizden sizi
uzaklaştırmaya yüz binlerce kişiye programcılık öğretmiş Memik YANIK
olarak talibim. Daha önce Visual Basic 6 ile az çok program yazdıysanız C#
yerine Visual Basic’in .NET uyumlu sürümünü tercih edebilirsiniz. Ötesi, C#
ile Visual Basic’in .NET sürümünün yeteneklerini karşılaştırdığımızda
aralarında önemli bir fark yoktur. Kişisel görüşüme göre C#’ı öğrenmek,
.NET uyumlu Visual Basic’i öğrenmekten daha zor değildir. Daha açık bir
anlatımla Visual Basic’in NET sürümünü tercih etme nedeniniz C#’ın daha
zor öğrenilen bir dil olacağını sanma düşüncesi olmasın.
Daha önce C ile az çok uğraştıysanız C#’ın söz dizimine çabuk alışacaksınız.
Nesneye yönelik programcılık kavramları hakkında bilgi sahibiyseniz, başka
bir deyişle C++ üzerinde az çok çalıştıysanız C#’ı öğrenmek sizin için daha
kolay olacaktır. Benzer şekilde daha önce JAVA hakkında bilgi edinmiş
olanların C#’ı öğrenmeleri kolay olmaktadır.
Birileri bu dersleri 2 cümle ile anlatın derlerse söyleyeceklerim şunlardır:

“Bu dersler bir programla dili nasıl öğrenilir sorusuna cevap verme
uğraşısıdır” diyebilirim. Bu derslerin sonuna gelindiğinde C# hakkında temel
bilgilere sahip olacak ve bu derslerde sözü edilmeyen .NET sınıflarını kolayca
öğrenebileceğinizi biliyor olacaksınız, C# programcısı olma yolunda en zor
engeli aşmış olacaksınız. Başka bir anlatımla bu dersleri sonuna kadar
izleyen kişilerde programlama dili öğrenme korkusu olmayacaktır. Tabii bu
dersleri okuyan bazı arkadaşlar 200 sayfalık başlangıç düzeyi C# kitaplarına

dönüp bakma ihtiyaçları kalmayacaktır.
Her ne kadar bu başlıkta C# ile program yazmak için gereken araçları bir bir
sayıp anlatacak olsam bile mutlaka gerekli olan öğrenme isteğidir. C#’ı
öğrenmek sizin için önem arz ediyorsa ister bu dersleri izlemiş olun ister
izlememiş, bir şekilde C#’ı öğrenirsiniz. Zaten kısa sürede C#’ı öğrenmeleri
zorunluluk olanlar gidip kitap alacaklar veya programcılık eğitimi veren bir
kuruma başvuracaklardır.
Orada burada Memik YANIK ve kitapları aleyhine konuşan, yazan birilerini

görürseniz(ki görmeniz yüksek bir ihtimaldir) onlara hemen inanmayın
derim. Öncelikle bu sayfalarda yazılanları okuyun derim. Bu arada kişisel
sitemde bilgisayar kitapları hakkında yazdıklarıma biraz göz atmanızı
öneririm(www.memikyanik.com/kitaplar/kitaplarim.htm). Tabii ki yazdığım
kitaplarda hiç hata yoktur hepsi eksiksizdir diyecek değilim. Benim itirazım
kitaplarımın incelenmeden, okunmadan karalanmasıdır. Bazı arkadaşlar ise
yıllar önce yayınlanan, çoktandır satıştan kalkan kitaplarımı bugünün
şartlarına göre değerlendiriyorlar. Örneğin 2007 yılında yayınlanan Delphi
2007 kitabım dururken kalkıp 2000 yılında yayınlanan Delphi kitabım
üzerine konuşuyorlar, 2000 yılında yayınlanan programcılık kitabını 2008
yılının ihtiyaçlarına, şartlarına göre değerlendiriyorlar.
C# programlama dili ile ilgili bu dersleri izleyebilmek için başlangıçta

bilgisayarınızda .NET Framework’ün kurulu olması yeterlidir. Çünkü .NET
Framework ile birlikte C#, Visual Basic for .NET ve C++ derleyicileri zaten
geliyor. Maddeler halinde yazmak gerekirse C# programlama dili ile
program yazmak için size
• .NET Framework
• Not Defteri
gereklidir. Buna göre Not Defteri ile C# programınızı yazıp CS uzantısı ile
kaydedersiniz. Sonra DOS penceresine geçip .NET Framework ile gelen C#
derleyicisi(CSC.EXE) sayesinde derleme yapıp EXE dosyayı hazırlarsınız. Hiç
meraklanmayın bu işlemin ayrıntılarını bir sonraki C# konulu derste
anlatacağım. Hemen eklemek gerekirse; .NET Framework’ü Microsoft
ücretsiz dağıtmaktadır ve Windows Vista ile birlikte gelmektedir. Bu nedenle
işletim sistemi olarak Vista kullanıyorsanız microsoft.com’dan indirip
kurmanız gerekmez.
Kullandığınız bilgisayarda Windows XP kuruluysa .NET Framework'ü

Microsoft’un sitesinden indirip kurabilirsiniz. Birkaç yıl önce .NET Framework
1.1 vardı. Sonra 2005 yılının başında .NET Framework 2.0 hazırlanıp
dağıtıldı. Yakın bir zamanda ise .NET Framework’ün 3.0/3.5 sürümleri

piyasaya verildi. Microsoft firması önceleri .NET Framework 2.0’a bazı yeni
sınıflar ve yardımcı araçlar ekleyip buna .NET Framework 3.0 dedi.
Sonrasında ise .NET Framework 3.5 hazırlandı.
Bu dersler boyunca anlatılanları izleyip küçük örnekleri deneyebilmeniz için

size .NET Framework 2.0 yeterli olacaktır. Tabii kurmuşken en son sürüm
olsun diyenler bilgisayarlarına .NET Framework’ün 3.5 kurabilirler. .NET
Framework 1.0 ve 1.1 ile C# derleyicisinin sürüm nosu 1.0 iken .NET
Framework 2.0 ile gelenin sürümü nosu 2.0'dır. .NET Framework 3.5 ile
gelen C# derleyicisinin sürüm nosu 3.0'dır. orada burada C# 2005 veya C#
2008 adında kitaplar görürseniz bilin ki bu kitapların adları yanlıştır.
Visual Studio
Bu derslerin sizin için verimli olması için daha sonra sözü edilecek Visual
Studio 2005 veya 2008’i edinip bilgisayarınıza kurmanız veya C# için
hazırlanmış ücretsiz Express Edition’ı Microsoft’un sitesinden indirip
kurmanız gerekir. Express sürümü edinmek kolay olduğu için bu derslerde
Express sürüme ağırlık vereceğim. Tabii bilgisayarlarına Visual Studio’yu
kurmuş olanları da gözeteceğim. Bu dersleri izlerken Visual Studio’nun 2005
veya 2008 sürümü kullanılabilir.
Bu paragrafı yukarıda .NET Framework’ün sürümlerimden söz edilen

paragraf ile birlikte okuyanların bir kısmı bu Visual Studio’da ne oluyor diye
sorabilirler. Hemen açıklayayım. Gerçekte C# veya .NET Framework uyumlu
herhangi bir programlama dili ile program yazmak için .NET Framework ve
Not Defteri gibi bir editör programı yeterli olmaktadır.
Ne var ki çok sayıda dosyadan meydana gelebilen C# uygulamalarını Not

Defteri gibi kısıtlı özelliklere sahip bir editörle yazmak sonra da DOS
penceresinde derlemek imkansız olmasa bile zahmetlidir. Bu nedenle konu
.NET Framework uyumlu programlama dilleri olduğunda Microsoft ancak bu
dillerde program yazma ve derleme işlemini kolaylaştıran Visual Studio’yu
satarak para kazabilmektedir. Đleri ki konularda derleyici nedir, IDE nedir
gibi sorular sizin için bilinmez olmayacaktır.
Son 2 paragraftan kafası karışanlar için ek açıklama: Microsoft firma .NET

Framework adı verilen bir sınıf kitaplığını hazırladı. Bu sınıf kitaplığında
program yazarken gerek duyabileceğiniz çok sayıda sınıf bulunmaktadır.
Örneğin yazdığınız programda bir düğmeye gerek duyduğunuzda .NET
Framework ile gelen Button sınıfından, TextBox’a gerek duyduğunuzda
TextBox sınıfından yararlanabilirsiniz. Bu sınıf kitaplıkları C#, Visual Basic
ve C++ gibi .NET uyumlu programlama dilleri ile kullanılabildiği için
Microsoft firması bu 3 programlama dilinin derleyicilerini .NET Framework ile
birlikte ücretsiz dağıtmaktadır. Başka bir deyişle kullandığınız bilgisayara
.NET Framework’ü kurmanız halinde elinizde hem Visual Basic hem de C#
derleyicisi olmuş oluyor.
Express Edition
Visual Studio son derece gelişmiş ve program yazmayı kolaylaştırdığı gibi

yüksek fiyatla satılan bir program geliştirme aracıdır, yani bir IDE’dir.
Microsoft firması korsan kullanımı azaltmak, C# ve .NET uyumlu diğer
programlama dillerini henüz öğrenenleri düşünerek Express Edition adı
verilen Visual Studio’ya göre kısıtlı özelliklere sahip IDE’ler hazırlayıp
dağıtmaya başladı.
Visual Studio ile C#, Visual Basic, C++ ve ASP.NET uygulamaları geliştirmek
mümkün iken Express Edition’lar "dile" özeldir. Yani .NET uyumlu hangi
programlama dili kullanılacaksa o dil için hazırlanmış Express Edition adı
verilen IDE’yi yani program geliştirme aracını Microsoft’un sitesinden indirip
kurmak gerekiyor. Hemen eklemek gerekir ki C# için hazırlanmış olan
Express Edition bir programlama dili olmayıp C# uygulamalarını kolayca
hazırlayabilmeniz için Microsoft tarafından hazırlanıp ücretsiz olarak dağıtılın
bir IDE’dir, yani bir yardımcı programdır.
Karışıklık olmasın diye bir konuyu tekrarlayalım:C# derleyicisi .NET

Framework ile birlikte dağıtılmaktadır. .NET Framework 1.0 ve 1.1 ile
birlikte C# derleyicisinin 1.0 sürümü verilirken .NET Framework 2.0 ile
birlikte C# derleyicisinin 2.0 sürümü gelmektedir. Geçen yıl kullanıma
sunulan .NET Framework 3.5 ile birlikte ise C# derleyicisinin 3.0 sürümü
gelmektedir. C# derleyicisinde 1.0’dan 2.0 sürümüne gelindiğinde önemli
gelişmeler olmuştu. C# derleyicisinin 3.0 sürümünde çok sayıda yenilik
olmasına rağmen hepsi dile yapılan birer ektir. Başka bir deyişle C# 2.0 için
yazılan kodlar C# 3.0 ile sorunsuzca derlenebilmektedir.
Kısaca anlatmak gerekirse Visual C# için hazırlanmış Express Edition,

Visual Studio’yu edinemeyip ancak programlarını Not Defteri ile hazırlamak
istemeyenlere uygundur. Bana sorarsanız C#’ı öğrenirken Express Edition

size yeterli olacaktır. Visual Studio’yu edinme imkanınız varsa Express
Edition’a kayıtsız kalabilirsiniz. Bu derslerde C# 3.0 ile gelen yeniliklerden
söz edilmeyeceği için Express Edition’ın 2005 sürümü kullanılabilir. Tabi en
son sürüm olsun diyenler 2008 yılında kullanıma sunulan sürümü indirip
bilgisayarlarına kurabilirler. Daha sonra C# için hazırlanan Express Edition’ın
nasıl kurulduğu anlatılacaktır.
BÖLÜM 2
C# PROGRAMI YAZMAYA BAŞLIYORUZ
Bir önceki bölümde C# programlama diline başlama konusunda biraz sohbet
etmiştik. Bu bölümde ise kod yazmaya başlayacağız. C# konulu hangi kitabı
alırsanız alın, C# konulu hangi kursa gidiyorsanız gidin, C# programlama
diliyle ilgili dersleri hangi fakültede alıyorsanız alın C#’la çalışmaya bu
dersleri okumakla başlamanızı öneriyoruz. Bu sayede C#’a ayırmanız
gereken zaman büyük oranda azalacaktır.
Yıllardır konu programcılık üzerine yazmak olduğunda asıl olanın anlatma

şekli olduğunu savunuyorum. Yoksa söz konusu programlama diliyle ilgili
olarak hemen her şey kısa sürede söylenmekte, hemen her sorunun çözümü
bir şekilde anlatılmaktadır. Yoksa programcılık üzerine yazan birisinin
okurları ile paylaştığı bir yenilikten söz etmesi uzak bir ihtimaldir. Bu
durumda programcılık üzerine yazanlar ancak anlatma biçimleri ile
övünebilirler, ancak kurdukları cümlelerin düzgünlüğü ile fark yaratabilirler.
Yoksa bu bölümde anlattığım her şeyi C#’la az çok uğraşmış herkes
biliyordur. Yani bu makalede yeni bir şey söylemem ihtimal dışıdır. Bu
nedenle anlı şanlı bir Üniversitemizin Prof unvanlı öğretim üyesinin birisi bu
metnin çalıntı olduğunu orada burada yazarsa gülüp geçin.
.NET Framework’ü Kurmak
Herhangi bir programlama dili ile çalışılıp uygulama geliştirilmek

istendiğinde ilk yapılması gereken derleyici edinmektedir. Ancak konu .NET
Framework uyumlu programlama dilleri olduğunda derleyici aramak zorunda
kalmıyorsunuz. Çünkü C#, Visual Basic ve C++ derleyicileri .NET
Framework ile birlikte ücretsiz olarak dağıtılmaktadır. Buna göre C#
programları yazabilmek için bilgisayarımıza .NET Framework’ün kurulu
olması yeterlidir. Kullandığınız bilgisayarda Windows Vista kurulu ise ayrıca
.NET Framework kurmanız gerekmiyor. Çünkü .NET Framework Vista ile
birlikte geliyor. Kullandığınız bilgisayara Windows XP kurulu ise
microsoft.com’dan istediğiniz .NET Framework’ü indirip kurmanız gerekir.
Şu günlerde kullanıma sunulan .NET Framework’ün en son sürümünün

numarası 3.5. Daha önce işaret edildiği gibi bu derslerde örnek olması için
verilen küçük programları yazıp deneyebilmeniz için .NET Framework’ün 2.0
sürümü yeterlidir. Bilgisayarınıza .NET Framework’ün yüklü olup olmadığını
veya yüklü ise hangi sürümün yüklü olduğunu öğrenmek için Windows’un
Program Ekle veya Kaldır penceresine bakabilirsiniz.
Kullandığınız bilgisayara .NET Framework kurulu ise hemen C# programları

yazabilirsiniz. Not Defteri ile C# kodu yazıp CS uzantısı ile herhangi bir
klasöre kaydedip sonra da .NET Framework ile gelen C# derleyicisi(yani
csc.exe dosyası) sayesinde derleme yapıp EXE dosya hazırlayabilirsiniz. Bu

derste öncelikle C# programlarını Not Defteri ile yazıp derleyeceğiz.
Devamında C# için hazırlanmış Express Edition’dan yararlanacağız.
Şimdi microsoft.com’a uğrayıp .NET Framework 3.5’ı indireceğim. Bu amaçla

microsoft.com’da arama yapıp indirebileceğim linki buldum. Bulduğum linki
tıklayınca ekrana aşağıda verdiğim diyalog kutusu geldi.
Yaklaşık 3 Mb’lık bu dosyayı indirip bilgisayarıma kaydettikten sonra

çalıştırdım. .NET Framework 3.5 gerçekte 72 MB olduğu için indirdiğiniz
dosyayı çalıştırıp kurmaya başladığınızda geri kalanı Microsoft’un sitesinden
indiriliyor. Başka bir deyişle nete bağlı değilken bu 3 Mb’lık dosya ile kurma
işlemi yapılamıyor. Bu metni kaleme aldığım sırada .NET Framework 3.5 için
SP1 çıkmıştı.microsoft.com’da SP1’i indirip kurmanız önerilir.
Program Yazmaya Başlıyoruz.
Konu .NET uyumlu programlama dilleri ve özellikle C# olduğunda ilk

karşılaşmamız gereken kavram Class kavramıdır. C# programları Class
şeklinde düzenlendiği için en başından Class kavramından söz etmek
gerekmektedir. Programları Class’lar halinde düzenlemenin sayısız yararları
vardır. Ancak bunları burada anlatmayacağım. Class’lar hakkında bilgi sahibi
olmadan Visual Basic 6 ve Delphi gibi programlama dilleri ile program
geliştirmek mümkün iken C++, C# ve Java gibi diller Class’lar hakkında
bilgi sahibi olmanızı zorunlu kılmaktadır. Kaygılanmanıza gerek yok; bu
dersi sonuna kadar okuduğunuzda bir de bakarsınız ki Class'lar hakkında
temel bilgilere sahip olmuşsunuz. Yoksa diğer kitaplarda yapıldığı gibi sizlere
Class’lar hakkında teorik bilgi vermeyi düşünmüyorum.
Quick Basic, Pascal ve C gibi klasik programlama dillerinde kod dosyaları

içinde fonksiyonlar ve procedure’ler bulunuyordu. Hatta C’de fonksiyon
procedure ayrımı da yoktur. Başka bir deyişle programcılar yapmak

istedikleri işlemlere uygun fonksiyonlar yazıp gerek duydukça bunları
çağırırlardı.
Zamanla programlar büyüyüp karmaşıklaştıkça paketlenmesi ihtiyacı doğdu.

Fonksiyon ve metotların Class’lar halinde paketlenmesi ile birlikte Class
içinde bulunan fonksiyonların kullanılması, organize edilmesi ihtiyacı doğdu.
Günümüzde yaygın olarak kullanılan programlama dillerinde Class’lar
metotlardan başka Interface’leri, Olayları, Özellikleri, Delegate’leri ve Yapıcı
metotları içerebilmektedir. Lütfen olay nedir özellik nedir ki diye sormayın.
Zamanı gelince bu konular hakkında bilgi verilecektir.
Yerli yabancı ayrımı yapmadan bugüne kadar hangi kaynağa baktıysam

konu nesneye yönelik programcılık olduğunda ilk birkaç sayfada biyolojiden,
memelilerden, ütülerden arabalardan vs. söz edilmektedir. Her yazar
nesneye yönelik programcılığın 3 temel kavramını kendince anlatmaktadır.
Uzatmadan belirtmek isterim ki anlayış öğrenmeyi zorlaştırmaktadır.
Đstediğiniz ayrıntıda polimorfizm’den söz edin, istediğiniz kadar biyolojiden

memelilerden örnek verin bu kavramların kod karşılığı görülmeden verilen
bilgiler havada kalıyor. Bu nedenledir ki bu bölümde nesneye yönelik
programcılığın temel kavramlarından söz etmeden bu konuyu anlatmak
istiyorum. Esasında burada bilim yapmıyoruz, olsa olsa sizlere C#
programlama dili ile nasıl program yazabileceğinizi anlatmak istiyoruz.
Amacımız en basit şekilde programcılık tecrübesi olmayanları programcılığa
alıştırmaktır, onları C# programlama dillini öğrenebileceklerine
inandırmaktır.
Aşağıda en basit veya en kısıtlı, en az satıra sahip bir C# programı

bulunmaktadır. Bu kodu Not Defteri penceresine yazıp CS uzantısı ile
kaydedip .NET Framework ile gelen C# derleyicisi ile derleyip EXE
yapabilirsiniz. Bu işlemin nasıl yapıldığı ileriki sayfalarda anlatılacaktır. Ey
Üniversite hocaları ey programcılık üzerine yazanlar başka bir kaynakta
"Deneme" adında bir Class görürseniz bilin ki bu isim benzerliği tesadüfüdür.
Yoksa bu Class'a deneme yerine "tecrube" ya da "deneyimsiz" gibi bir ad
vermek marifete tabi değildir.
Buna göre C# kodu yazmak istiyorsanız önce mutlaka bir Class bloğu
hazırlamanız gerekmektedir. C# programlarının başlangıç noktası Main()
metodu olduğundan Main() metoduna yer vermek zorundasınız. Bu C# kodu
CS uzantılı bir dosyaya yazılıp kaydedilip derlenip hazırlanan EXE dosya
çalıştırılırsa herhangi bir hata ile karşılaşılmaz. Ancak bu program bu hali ile
herhangi bir işlem yapmaz.
En az satıra sahip bu C# programındaki Main() metodunun hem static hem

de void olduğunu işaret ettim. C# programlarının başlangıç noktası olan
Main() metodu(C programlama dilinde Main’den fonksiyon diye söz edilir)
statik olmak zorundadır ama void olması zorunlu değildir. Metot geriye bir
değer göndermeyecekse metot adından önce void yazılır. Daha sonra
metotların geriye nasıl değer gönderdikleri konusunda bilgi verilecektir.
Bu kısacak programda bile Class’tan söz ettik, metottan söz ettik. Size
önerim başlangıçta verdiğim kısacak kodlarda kullanıp ancak sözünü
etmediğim deyimlere veya metotlara kayıtsız kalmanızdır. Örneğin bu
kısacak örnekte bile sözünü etmediğim, dikkatinizden kaçırmak istediğim bir
şeyler var. Dikkat ederseniz Main() metodunun adından sonra parantezlerin
arasına “string[] args” yazdım. Bu parantezin içine yazdıklarım gerçekte
dizi değişken tanımlamaktan başka bir şey değildir Ancak şu anda bundan
söz etmeyeceğim. Bu nedenle bu derslerden azami verimi almak istiyorsanız
anlatılmayanlara değil anlatılanlara odaklanmalısınız. Main metodu içinde
tanımlanan dizi değişkene "args" adını vermek C# programcılarının bir
alışkanlığıdır. Tabi benzer alışkanlık sayısal bilgileri saklamak amacıyla
tanımlanan değişkenlere ad seçerken de vardır ve "i" ve "j" sık kullanılan
değişken adlarıdır. Her ne kadar i ve j’nin değişken adı olarak kullanılması
bütün dünyanın bir alışkanlığı olsa bile Türkiye’de bazı öğretim üyelerine
göre i ve j adında değişkenler tanımlamak suçtur.
Şimdi yukarıda verdiğim C# programının başlangıç noktası olan Main()

metodu içinde bir değişkene yer vereceğim. Bu değişkeni Main() metodu
içinde tanımladım. Değişkeni Main() metodu tarafından sınırlanan kod bloğu
yerine Class bloğu içinde tanımlayabilirdim.
class Deneme
{
static void Main(string[] args)
{
int yil;
}
}
Gördüğünüz gibi C# programlarında değişken tanımlanırken önce

değişkenin tipi sonra adı yazılmaktadır. Buradaki int bu değişkenin integer
yani tamsayı tipindeki bilgileri saklayabileceğini işaret etmektedir.
Programcılıkta değişken tanımlamayı günlük hayatta telefon edip bir otelde

yer ayırmaya benzetmek mümkündür. Bu değişkeni tanımlamakla
derleyiciye demiş oluyorum ki, programın ileriki safhalarında integer bilgileri
bellekte tutma gereğini duyabilirim. Bu nedenle bana bellekte bu amaçla
kullanacağım bir yer ayırt.
Bu kısacak kodu iki cümle ile yorumlamak gerekirse şunlar söylenebilir: Bu

programdaki “Deneme” adlı Class’ın Main() adında bir metodu
bulunmaktadır. Main() metodu içinde yaşayabilecek “yil” adında ve Integer
tipindeki bilgilerin aktarılabileceği bir değişken tanımlanmıştır. Bu değişkeni
Main() metodu içinde tanımladığım için yalnızca Main() metodunun sınırları
içinde yaşar. Fark etmiş olabileceğiniz gibi C# programlarında Class ve
metot başlatılan satırlar hariç her satırın sonuna “;” konulmaktadır.
Bu kodu NET uyumlu Visual Basic için yazsaydım biraz farklı olurdu. Ancak
temel mantıkta pek farklılık yoktur. .NET uyumlu Visual Basic'te de zorunlu
olmamakla birlikte uygulamalar Class halinde düzenlenmekte ve Class’ların
içinde metotlar, alanlar(yani değişkenler), özellikler, olaylar, Interface’ler
olabilmektedir. Lütfen olay nedir, özellik nedir, Interface nedir gibi sorularla
şimdilik meşgul olmayın.
Şimdiye kadar incelediğim bütün kaynaklarda, bütün kitaplarda değişkenler

adında bir bölüm mutlaka vardı. Kitaplarda değişkenler adlı bölümün olması
doğal olmasına doğal da değişkenler sanki C, Basic ve Pascal programlama
dillerindeki değişken kullanımı gözetilerek anlatılmaktadır. Bu derslerde
değişkenler Class bağlamında kısaca anlatılacaktır.
Yukarıda belirtildiği gibi Class’lar metotları barındırabilmektedir. Ayrıca C#

programlarında Main() metodunun bulunması zorunludur. Yukarıda verdiğim
en kısıtlı C# programı içinde hazırladığım Class’ta değişiklik yapıp 2. bir
metoda yer verdim. Herhangi bir satır içermeyen bu metot bu hali ile
herhangi bir işlem yapmaz. Bu metodu da hem static hem de void olarak
işaret ettiğimi fark etmiş olmalısınız. Yarın bir gün metot adı benzerliği
suçlanmak istemeyenler bu metoda Türkçe yerine gavurca bir ad
verebilirler. Mesaj’ın Türkçe bir kelime olmadığı gerçeğine rağmen…
class Deneme
{
{
int yil;
}
static void Mesaj()
{
}
}
Daha önce C#, C++, Delphi gibi bir programlama dili ile program geliştirmiş
iseniz yani az çok kod yazdıysanız bu derste anlatılanlar size basit
gelecektir. Programcılıkta tecrübeli arkadaşlara bir önerim var; sizler bu
yazıda ne anlatıldığı ile değil, nasıl anlatıldığı ile ilgilenebilirsiniz. Belki bir
üniversitenin öğretim görevlisisiniz, belki de bir Microsoft eğitim merkezinde
eğitmensiniz. Bu yazıdaki amacım C# gibi bir programlama dilinin nasıl
kolay öğrenilebileceği konusunda deneme yapmaktır.
Şimdi yukarıda verdiğim basit C# kod dosyası içinde Mesaj() adını verdiğim
metodu Main() metodunun içinden işleteceğim. Hazırladığım metot aynı
sınıfın içinde olduğu için herhangi bir hazırlık yapmadan direk adıyla çağırıp
işletmek mümkündür.
class Deneme
{
{
int yil;
Mesaj();
}
static void Mesaj()
{
}
}
Bu hali ile bu C# programı veya CS uzantılı kod dosyası DOS penceresinde

derlenip EXE hazırlanıp çalıştırılırsa Main() metodu otomatik olarak işletilir.
Çünkü yukarıda söylendiği gibi C# programları Main() metodundan itibaren
çalışmaya başlarlar.
Bu programı aşağıdaki gibi düzenlemiş olsaydım değişen bir şey olmazdı.

Çünkü C# derleyicisi Main() metodunu bulup programın başlangıç noktası
yapar. Bu kısa örnekte “yil” adını verdiğim değişkeni hiç kullanmadığım için
C# derleyicisi derleme sırasında uyarı mesajı verir.
class Deneme
{
static void Mesaj()
{
}
{
int yil;
Mesaj();
}
}
Şimdi bu Mesaj() adını verdiğim metoda müdahale edip işletildiği zaman

ekrana bilgi yazılmasını sağlayacağım. Konsolda yani DOS penceresinde
çalışan C# projelerinde ekrana bilgi yazma işlemleri .NET Framework ile
gelen Console sınıfında tanımlı olan Write() veya WriteLine() metotları ile
yapılmaktadır.
Tam bu noktada elime fırsat geçmişken biraz kendimi savunmak istiyorum.

Yıllardır Memik YANIK aleyhine konuşanların en genel geçer suçlaması
şuydu: “Memik YANIK kitaplarını ekran görüntüleri ile doldurup şişiriyor”.
Gördüğünüz gibi yukarıda Not Defteri ile hazırladığım toplam 12 satırdan
meydana gelen kodun kendisini vermek yerine kodu yazmış olduğum Not
Defteri penceresinin ekran görüntüsünü verdim. Bu metni kitap için yazmış
olsaydım ekran görüntüsünü belli bir oranda küçültüp kitapta daha az yer
kalmasını sağlardım.
Aşağıda ise bu ekran görüntüsünü verdiğim Not Defteri penceresine yazmış

olduğum kodun kendisi var. Sizce kitap metni içinde hangisi çok yer kaplar,
ekran görüntüsü mü yoksa kodun kendisi mi? Seçilen puntoya bağlı olarak
değişse bile aralarında önemsenecek bir farkın olmadığını söyleyebilirim. Ne
ki ekran görüntüsü halinde verilen kısa kodları incelemek bazen daha
kolaydır. Neden mi bazen? Çünkü kitap metni içinde kullanılmak istenen kod
15-20 satır kadarsa kodun kendisi yerine kodu yazıldığı ekran görüntüsü
verilebilir. Ancak kod uzunsa ekran görüntüsü yerine kodun kendisini
vermek gerekir.
class Deneme
{
{
int yil;
Mesaj();
}
static void Mesaj()

{
System.Console.WriteLine("Fenerbahçe");
}
}
Bu şekilde düzenlenen C# uygulaması DOS penceresinde derlenip

çalıştırıldığında ekrana “Fenerbahçe” yazdırıldıktan sonra programın
çalışması sona erer. Çünkü C# ile geliştirilmiş programların çalışması Main()
metodunun sonuna gelindiğinde biter.
Mesaj() metoduna yazdığım satır hakkında biraz konuşmak gerekirse;

“System.Console.WriteLine("Fenerbahçe");” satırındaki System bir
namespace’tir. Şimdi diyeceksiniz Namespace nedir? Cevabım hazır:
Lütfen merakınızı sonraya saklayın; halk dili ile söylemek gerekirse “üzümü
ye bağını sorma”.
Kısaca anlatmak gerekirse Class’lar Namespace’lerin içine

yerleştirilmektedir. System adlı Namespace .NET Framework ile gelen en
önemli Namespace’tir ve çok sayıda Class’ı barındırmaktadır. DOS
penceresine veya konsola bilgi yazmak üzere hazırladığım satırdaki Console
bir Class’tır. Çok sayıda metoda sahip olan bu Class’ın sayesinde konsol yani
DOS penceresi ile ilgili istenen işlemler yapılabilmektedir. Bu satırdaki
WriteLine() ise Console sınıfının bir metodudur.
Bu konuyu bir okulda, bir dershanede veya seminerde anlatıyor olsaydım

C# hakkında biraz bilgisi olanlar “Memik bey WriteLine() static bir metot
değil mi?” diye sorabilirlerdi. Soruyu soranlara cevabım “evet, WriteLine()
metodu statik bir metottur”. Tabii dersi veya semineri izleyenlerin bazıları
“statik olanla olmayan metot arasında ne fark vardır” diye soru soracaklardı,
bazıları ise keşke bu konuşulanları anlasaydım diye iç geçireceklerdi. Fırsat
bu fırsat deyip hemen statik olan ve olmayan metotlar hakkında uzun
açıklamalar yapmayacağım. Arkadaşlar lütfen biraz sabır.
Programları Derlemek
Bazılarınız bu kısacak örneği bile hemen denemek, bu CS uzantılı dosyayı

derleyip EXE dosya hazırlamak istiyor olabilir. Bu isteğe uyup CS uzantılı
kod dosyasını derleyip EXE yapma üzerinde duracağım. Not Defteri ile
hazırlayacağınız kod dosyalarını yerleştirmek üzere ayrı bir klasör
hazırlamanızı öneririm. Bu klasör “C:” sürücüsünün kök klasöründe olursa
ulaşılması kolay olur.
C#’ın kurallarına uyarak yazdığınız programları derleyip EXE dosya

hazırlayacak program dosyası(CSC.EXE) Windows’un kurulu olduğu klasörün
altında “Microsoft.NET\Framework” klasöründe yer almaktadır.
.NET Framework’ün başka sürümünden yararlanıyorsanız bu klasörün adı

farklı olabilir.
Hazırlayacağınız CS uzantılı dosyaları bu CSC.EXE dosyasının bulunduğu

klasöre kaydetmeli veya Denetim Masasındaki Sistem seçeneği ile ekrana
getirilen Sistem Özellikleri diyalog kutusunda Gelişmiş sekmesindeki
Sistem Değişkenleri seçeneğinden yararlanmalısınız. Path seçeneğinin
içeriğine aşağıda verdiğim satırlardan birisini ekleyip bilgisayarı yeniden

başlatırsanız istediğiniz yerden CS uzantılı kod dosyalarını derleyebilirsiniz.
“C:\WINDOWS\Microsoft.NET\Framework\v3.5;”
"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727;"
Kullandığınız bilgisayara Visual Studio 2008'i kurulu ise Başlat menüsünden

Visual Studio 2008 Command Prompt komutu verilerek açılan DOS
penceresinde yukarıda anlatılan şekilde Path ayarlaması yapılmasa bile C#
programlarını istediğiniz yerde derleyebilirsiniz.
C# derleyicisinin kullanım şekli ve parametreleri hakkında bilgi edinmek

istiyorsanız DOS penceresinde “CSC /?” yazıp enter tuşuna basabilirsiniz.
Şimdi sıra geldi bu programı derlemeye. Bu amaçla bir DOS penceresi açıp
komut satırına “CSC ILK.CS” yazıp Enter tuşuna basınca C# programı
derlenmeye başlandı. Yazdığım programda herhangi bir hata olmadığı için
EXE dosya hazırlandı.
Yazdığım C# programında Main() metodu içinde “yil” adında ve int tipinde

bir değişken tanımlamış olmama rağmen bu değişkeni hiç kullanmadığım
için derleyici uyarıda bulundu. Bu uyarı ILK.CS dosyasından yola çıkılıp
ILK.EXE dosyasının hazırlanmasına engel değildir. Derleyici uyarı yerine hata
mesajı vermek zorunda kalsaydı EXE dosya hazırlanmazdı.
Tekrarlamak gerekirse yukarıdaki gibi yapılan derleme sonucu CS uzantılı

C# programı ile aynı ada sahip bir EXE dosyası hazırlanır. Aşağıda verdiğim
ekran görüntüsünü bu EXE dosyayı çalıştırdıktan sonra aldım. Derleme
sonucu hazırlanan EXE dosya ancak .NET Framework kurulu bilgisayarda
çalışır. Bu EXE dosyayı alıp .NET Framework 2.0 kurulu olmayan(çünkü
yukarıda derleme işlemini .NET Framework 2.0 ile gelen C# derleyicisi ile
yaptım) başka bir bilgisayara götürdüğünüzde çalışmaz. Aşağıda verdiğim
ekran görüntüsünü hazırladığım EXE dosyayı çalıştırdıktan sonra aldım.
Hazırlayıp derlediğim C# programı ekrana bu bilgiyi yazdıktan sonra yani

Main() metodunun sonuna gelindiğinde çalışması otomatik olarak sona
erer. Şimdi bu örmekte öyle bir ayarlama yapalım ki programın veya EXE
dosyanın çalışması Enter tuşuna basıncaya kadar devam etsin. Programın
çalışmasının Enter tuşuna basıncaya kadar devam etmesini sağlamak üzere
Deneme adını verdiğim Class'ın Main() metoduna bazı eklemeler yaptım.
class Deneme
{
{
int yil;
Mesaj();
System.Console.WriteLine();
System.Console.Write("Çıkmak için Enter Tuşuna Basın");
System.Console.Read();
}
static void Mesaj()
{
System.Console.WriteLine("Şampiyon Fenerbahçe");
}
}
Gördüğünüz gibi Console sınıfının WriteLine() metodunu Mesaj() adını
verdiğim metodun içinden başka bir deyişle Main() metodunun içinde
kullandım. Bu örnekte Main() metodu içinde önce Mesaj() adını verdiğim
metot çağrıldığı için ekrana önce “Şampiyon Fenerbahçe” yazılır. Mesaj()
metodunun çağrıldığı satırdan sonra yine WriteLine() metodu
kullanılmaktadır. Bu kez WriteLine() metoduna ekrana yazılmak üzere bilgi
parametre olarak verilmediği için ekranın o satırı boş kalır. Bir sonraki
satırda ise WriteLine() yerine Write() metodunu kullandım.
WriteLine() metodu kendisine parametre olarak verilen bilgiyi ekrana yani

DOS penceresine yazdıktan sonra imleci bir sonraki satırın başına alır.
Write() metodu ise WriteLine() metodundan farklı olarak imleci bir sonraki
satırın başına almaz. Burada programın çalışmasının kendiliğinden sona
ermesini engelleyen metot ise Read(). Bu şekilde düzenlenen C# programı
derlenip çalıştırıldığında aşağıdaki gibi bir sonuç alınır.
Console sınıfının Read() metodu gerçekte kullanıcının gireceği bilgileri

programa veya bir değişkene aktarılırken işlevsel olmaktadır. Bu örnekte
kullanıcının bilgi girmesini istemediğim için Console sınıfının Read()
metodundan önce herhangi bir değişken adı yazmadım. Diğer yandan
yukarıda verdiğim örnekte asıl anlatmak istediğim şuydu: C# programları
Class’lar şeklinde hazırlanmakta ve Class’larda işlem yapan kod blokları
metot şeklinde düzenlenmektedir.
Bu düşünce ile hazırladığım kısacık örnekte Main() metodundan başka

Mesaj() adında bir metot hazırlayıp Main() metodu dahilinde işlettim. Şimdi
bu örnekte değişiklik yapıp Mesaj() adını verdiğim metodu silip çalışma
anında “yil” adını verdiğim değişkene bilgi aktarmaya çalışacağım.
class Deneme
{
{
int yil;
System.Console.Write("Hangi Yıldayız : ");
yil = System.Console.Read();
}
}
Bu şekilde değiştirdiğim C# programında önce Console sınıfının Write()

metodu ile kullanıcıya mesaj verdikten sonra bir sonraki satırda Read()
metodu sayesinde kullanıcıdan istenen bilgiyi “yil” adını verdiğim değişkene
aktardım. Aşağıda verdiğim ekran görüntüsünü bu kısa programı derleyip
çalıştırdıktan sonra aldım.
Ekrana mesaj yazarken Write() yerine WriteLine() metodunu kullansaydım

imleç bilgi girişi için bir sonraki satırda beklerdi. Şimdi bu C# programına
ekleme yapıp kullanıcıdan istenip “yıl” adını verdiğim değişkenine aktarılan
bilgiyi WriteLine() metodu ile tekrar ekrana yazacağım.
class Deneme
{
{
int yil;
System.Console.Write("Girdiğiniz Yıl :");
System.Console.WriteLine(yil);
}
}
Bu şekilde düzenlenen örnek derlenirken hata vermediği gibi çalıştırıldığında

da hata vermez ama girilen yıl bilgisi ile sonradan WriteLine() metodu ile
ekrana yazılan yıl bilgisi birbirinden farklı olur. Aşağıda verdiğim ekran
görüntüsünü bu C# programını derleyip çalıştırdıktan sonra aldım.
Yukarıda verilen koda dikkat ederseniz konsoldan bilgi okuma işlemi Read()
metodu ile yapılmaktadır. Read() metodu konsoldan okuma yaparken
girilen bilginin ilk karakterinin ASCII kodunu geriye göndermektedir. Bu
program derlenip çalıştırılıp “Hangi Yıldayız :” sorusuna “A” ile cevap
verilirse ekrana 65 yazılır. Çünkü “A” hafinin ASCII kodu 65’dir.
Console sınıfının ReadLine() metodu ise farklı bir şekilde çalışmaktadır ve

konsoldan yani DOS penceresinden okuduğu bilginin String tipte olduğunu
varsaymaktadır. Bu nedenle yukarıda verdiğimde örnekte değişiklik yapıp
okuma işlemini Read() yerine ReadLine() metodu ile yapmaya çalıştım.
class Deneme
{
{
int yil;
yil = System.Console.ReadLine();
}
}
Bu şekilde değiştirdiğimiz C# programını derlemek istersek derleyici hata

rapor eder. Çünkü Console sınıfının ReadLine() metodu tarafından okunup
geriye gönderilen bilgi String tipte olmasına rağmen burada int tipindeki
değişkene aktarmaya çalışıyorum. Bu hatanın önüne geçmek için string tipte
bir değişken tanımlayıp kullandım.
class Deneme
{
static void Main()
{
string str;
str = System.Console.ReadLine();
System.Console.WriteLine(str);
}
}
Bu hali ile programımız istediğimiz sonucu verir. Bu örnekte konsoldan

girilen “yıl” bilgisi matematiksel işlemlerde kullanılmadığı için rakamlardan
meydana gelse bile string yani karaktersel bilgi olarak değerlendirmenin bir
sakıncası olmaz.
Bu Bölümün Özeti
Not Defteri ile yazdığımız ilk programda Class bloğuna yer verdik. Bildiğiniz
gibi C# programlarında blok başı “{“ ile ve blok sonu ise “}” ile işaret
edilmektedir. C# programları çalışmaya Main() metodundan itibaren
başladıkları için Class’ın sınırları içinde Main() metoduna yer verdim. Main()
metodu içinde Console sınıfının WriteLine() metodu ile konsola yani DOS
penceresine bilgi yazmayı denedik. Ayrıca .NET Framework ile gelen C#
derleyicisi ile yani CSC.EXE dosyası ile CS uzantısı ile kaydettiğimiz C#
programlarını derleyip EXE dosya hazırladık.
Yukarıda yazılanları okurken kafanızda bazı soruların belirdiğini tahmin

etmek zor değildir. Programcılık biraz da bisiklet sürmeyi öğrenmek gibidir:
Önceler sık sık bisikletten düşersiniz, insanların 2 teker üzerinde nasıl
düşmeden gittiklerine hayret edersiniz. Sonra 50 metre düşmeden
gittiğinizde birden bisiklet sürmesini öğrendiğinizi fark edersiniz. Birçok kişi
programcılığa nereden başlayacağı konusunda tereddüde düşüyor. Bu
soruların cevaplarını bu dersler boyunca birlikte araştıracağız.
BÖLÜM 3
BAZI DEĞŞKEN TĐPLERĐ ve NAMESPACE'ler
Bu yazıları neden mi kaleme almıştım? Programcılık kitaplarının ilk
sayfalarında konuları sıfırdan ele alıp adım adım anlatınca bazı arkadaşlar
kitabın anlatım düzeyine itiraz etmeye başladılar. Ben de çözüm olarak
henüz yolun başında olanları gözeterek birkaç makale yazdım. Burada yer
sonunu olmadığı için en küçük ayrıntıdan bile söz etmeye çalıştım.
Şimdi izninizle konunun biraz dışına çıkacağım:Tıp doktorları kendi

aralarında tıp konuştuklarında tıp kavramlarını sıkça kullanırlar ve kolayca
anlaşırlar. Ne var ki doktorun birisi hastasıyla konuştuğunda tıp kavramlarını
kullanmaz ve halk dili ile hastasıyla diyalog kurmaya çalışır. Doktorumuz
hastalarıyla tıp kavramlarını kullanmadan iyi diyalog kurabiliyorsa başarılı
doktor olur. Yıllardır camiadan bir çok kişi Memik Yanık'ı hep giriş düzeyi
kitaplar yazmakla suçladılar. Habu ki en zoru giriş düzeyi kitaplar yazmaktır.
Bakalım şimdi de Memik Yanık'ı giriş düzeyi makaleler yazıyor diye
suçlayacaklar mıdır? Ötesi anlı şanlı üniversitelerimizin Profesör unvanına
sahip hocaları bu metinde verdiğim kısacak kodlarda tanımladığım
değişkenlerin adını çalma suçunu işlediğimi tekrar rapor edecekler midir?
Kaldığımız Yerden Devam Edelim
Bir önceki bölümde Not Defteri ile kısa bir C# programı hazırlayıp “ilk.cs”
adıyla kaydetmiştik. Devamında bu CS uzantılı C# programını konsolda
derleyip EXE dosya hazırlamıştık. Hatta örneğimizin son hali beklediğimiz
sonucu vermemişti. Bu bölümde ilk olarak bir önceki derste yaptığımız
örneği düzelteceğiz. Bir önceki bölümde hazırladığımız örneğin son şeklini
aşağıda verdim.
class Deneme
{
{
int yil;
}
}
Not: Bu kısacık kodda "Yil" adında ve int tipinde bir değişken tanımladım.
Bildiğiniz gibi sene bilgisini aktarmak üzere değişken adı seçimini yapan
programcıların aklına yil'ın gelmesi yüksek bir ihtimaldir. Asıl demek

istediğim şudur:Değişken adı olarak yil’ı kendi namı hesabına kaydetmiş
yani register etmiş birisi resmi belgeleri ibraz edip(!) beni uyarırsa burada
"yil" adını verdiğim değişkene "yillar_yillar" veya "Kaybolan_yillar" gibi bir
ad verebilirim(!).
Bu koda dikkat ederseniz konsoldan bilgi okuma işlemi Read() metodu ile
yapılmaktadır. Read() metodu konsoldan okuma yaparken girilen bilginin ilk
karakterinin ASCII kodunu geriye göndermektedir. Bu örnek program
çalıştırılıp “Hangi Yıldayız :” sorusuna “A” ile cevap verilirse ekrana 65
yazılır. Çünkü “A” harfinin ASCII kodu 65’dir.
Console sınıfının ReadLine() metodu ise farklı bir şekilde çalışmaktadır ve

konsoldan yani DOS penceresinden okuduğu bilginin String tipte olduğunu
varsaymaktadır. Bu nedenle yukarıda verdiğimde örnekte değişiklik yapıp
okuma işlemini Read() yerine ReadLine() metodu ile yapmaya çalıştım.
class Deneme
{
{
int yil;
yil = System.Console.ReadLine();
}
}
Bu şekilde değiştirdiğimiz C# programını derlemeye çalışırsak hata meydana

gelir. Çünkü ReadLine() metodu tarafından okunup geriye gönderilen bilgi
String tipte olmasına rağmen burada int tipindeki değişkene aktarmaya
çalışıyorum. Bu hatanın önüne geçmek için “yil” adını verdiğim değişken
yerine string tipte bir değişken tanımlayıp kullandım.
Daha önce az çok kod yazmış olanların bileceği gibi aşağıda verdiğim kodun
hiç bir orijinal tarafı yoktur. Buna rağmen Prof. unvanlı birisi "bu kodda
Memik Yanık başka kaynaklardan çalıntı yapmıştır" diye rapor tanzim

ederse, ona "haklısın hocam sizden iyi bilecek değiliz" demekten elimizden
başka bir şey gelmez.
class Deneme
{
{
string str;
str = System.Console.ReadLine();
System.Console.WriteLine(str);
}
}
Bu hali ile programımız istediğimiz sonucu verir. Bu örnekte konsoldan

girilen “yıl” bilgisi matematiksel işlemlerde kullanılmadığı için rakamlardan
meydana gelse bile string yani karaktersel bilgi olarak değerlendirmenin bir
sakıncası olmaz.
Şimdi bu örnekte değişiklik yapıp kullanıcıdan 2 sayısal bilgi isteyip bunları

birbirleri ile çarptıktan sonra sonucu ekrana yani konsola yazacağım. Bu
amaçla önce 2 string değişken tanımlayıp Console sınıfının ReadLine()
metodu ile okunan bilgileri bu değişkenlere aktardım.
Bu program bu hali ile kaydedilip çalıştırılırsa konsoldan girilen bilgiler string

değişkenlere aktarılır. Bu örnekteki amacımız kullanıcının sayısal bilgi
girmesini ve bu sayıları birbiri ile çarpıp ekrana yazmak olduğu için
matematiksel işlem öncesi String değişkenlerin içeriğini int tipindeki
değişkenlere aktarmak gerekir. Bu amaçla bu C# programına ekleme yapıp

int tipinde 2 değişken tanımladım. Ardından string değişkenlerin içeriklerini
dönüştürüp int tipindeki bu değişkenlere aktardım.
class Deneme
{
{
string str1;
string str2;
int sayi1;
int sayi2;
System.Console.Write("Đlk sayıyı girin : ");
str1 = System.Console.ReadLine();
System.Console.Write("Đkinci sayıyı girin: ");
sayi1 = System.Int16.Parse(str1);
}
}
Bu kodda sizin için yeni olan System adlı namespace’de yer alan Int16
yapısıdır. String bilgiyi int tipindeki değişkene aktarırken bu yapının Parse()
metodunu kullandım. Bazı kaynaklarda Int16 yapısından Class diye söz
edilmiş olsa bile bunu sorun yapmamak gerekir. Bu dönüştürme işlemini
yaparken Int16 yerine Int32 yapısının Parse() metodunu kullanabilirdim.
Merak edenlere duyurmak isterim: Memik Yanık'ın yıllar önce yayınlanan

Clipper kitabından bu yana yazdığı bütün kitaplarda integer tipindeki
değişkenlere ad ararken tercihini Sayi1 ve Sayi2'den yana kullandı. Ne ki
sayi1, sayi2'yi değişken adı olarak seçmesi onun hırsız olarak suçlanmasına
neden oldu? Bu kodda tanımlanan değişkenlere Sayi1, Sayi2 gibi adlar
vermenin mecburiyet olmadığının kanıtlamak için bu kodu aşağıdaki gibi
düzenledim.
Hiç kaygılanmayın bu değişkenlere gavurca adlar seçildiğinde bile kod

hatasız çalışıyor. Çevrenizde "hayır bu kodun çalışabilmesi için değişken
adının mutlaka sayi1, sayi2 olarak seçilmesi şarttır diyen öğretim üyelerine,
millete programcılık öğreten kurs sahiplerine rastlarsanız "hocam haklısınız,
C# derleyicisi C#’ın kurallarını sizden iyi mi bilecek?" deyiniz.
class Deneme
{
{
string str1, str2;
int number1, numberi2;

number1 = System.Int16.Parse(str1);
number2 = System.Int16.Parse(str2);
}
}
Hemen bir hatırlatmada bulunmak isterim:Her ne kadar bu örnekte

kullanıcıya "sayı girin" mesajı verilmiş olunsa bile kullanıcı konsoldan sayısal
bilgi yerine karaktersel bilgi girerse Parse() metodu dönüştürme
yapamayacağı için hata meydana gelir. Bu tip karşılaşılması muhtemel
hataların önüne geçmek için hata kontrol blokları hazırlanabilir. Tabii bu
bölümde try-catch deyimlerinden söz etmeyeceğiz. Merak edenler C#
kitabımdan alıp kişisel sitemde sizinle paylaştığım Hata Yakalamak ve
Exception Sınıfları makalesine bakabilirler. Bu makaleyi okuyanlar sıfıra
bölme hatasını anlatmak için gerekli değişkenlere ad seçerken başka Türkçe
kaynaklardan çalıntı yapmanın şart olup olmadığını öğrenirler.
Bu şekilde konsoldan girilen bilgileri Parse() metodu ile dönüştürüp int

tipindeki değişkenlere aktardıktan sonra matematiksel işlem yapabiliriz.
Matematiksel işlem sonucu bulunacak değeri aktarmak üzere int tipinde 3.
bir değişken tanımladım.
Bu kodu dikkatice incelerseniz bir satırda aynı tipte birden fazla değişkeni
tanımlamış olduğumuzu görürsünüz. Hemen hatırlatmak gerekirse; bu
programı derleyip çalıştırıp sonra 1. sayı ile 2. sayının çarpımı sonucu elde
edilen sayısal bilgi 2147.483.647’den büyük olursa hata meydana gelir.
Ayrıca string bilgileri Int16 yapısının Parse() metodu ile dönüştürdüğümüz

için konsoldan girilen sayılar 32767’den büyük olmamalı. Int16 yapısının
Parse() metodu yerine Int32 yapısının Parse() metodunu kullansaydım 1.
veya 2. sayı 2147.483.647 gibi büyük bir değer olabilirdi.
Çarpma işlemi sonucu bulunan değeri Console sınıfının WriteLine()

metodu sayesinde direk konsola yazmak mümkün olmasına rağmen amacım
bazı konuları anlatmak olduğu için üçüncü bir string değişken tanımlayıp
çarpma işlemi sonucu bulunan değeri dönüştürüp bu değişkene aktardım.
Bu işlemi nasıl yaptığımı aşağıda görebilirsiniz.
class Deneme
{
{
string str1,str2, sonuc_str;
int sonuc, sayi1, sayi2;
sonuc = sayi1 * sayi2;
sonuc_str = System.Convert.ToString(sonuc);
}
}
Dikkat ederseniz burada int tipindeki değişkenin içeriğini string tipindeki

değişkene aktarabilmek için Convert sınıfının ToString() metodundan
yararlandım. C# ile az çok uğraşmış olanlar bu işlemin daha kısa bir
yolunun olduğunu ileri sürebilirler. Bu arkadaşlar haklıdırlar; dönüştürme
yaparken Convert sınıfının ToString() metodu yerine Object sınıfının
ToString() metodunu kullanabilirsiniz.
Object sınıfının ToString() metodunun nasıl kullanıldığını daha sonra

anlatacağım. ToString() metodu ile integer bilgiyi string bilgiye
dönüştürdükten sonra WriteLine() metodu ile konsola yazdım. Tabii bu kısa
açıklamayı yapmasaydım bazı üniversitelerin öğretim üyeleri "Parse()
metodunun nasıl kullanıldığını Memik Yanık'ın bilmesine imkan yoktur.
Mutlaka başka Türkçe kitaplardan çalıntı yapmıştır" diyebilirlerdi.
class Deneme
{
{
string str1,str2, sonuc_str;
int sonuc, sayi1, sayi2;
sonuc = sayi1 * sayi2;
sonuc_str = System.Convert.ToString(sonuc);
System.Console.WriteLine("Sayıların çarpımı :"+ sonuc_str);
System.Console.Write("Devam etmek için bir tuşa basın");
System.Console.Readkey();
}
}
Biraz da Namespace’lerden söz edelim..
Şimdi yukarıda uzun uzun anlatılan örneği bir tarafa bırakıp başka bir örnek
hazırlayacağım. C# programlarını yazarken Visual Studio veya C# için
hazırlanmış Express Edition’dan yararlanma yoluna henüz gitmediğimiz için
CS uzantılı C# kodunu yine Not Defteri ile hazırlayacağız. Hazırladığım basit
C# programını aşağıda verdim. DOS penceresinde derlenip DOS
penceresinden bilgi alış verişi yapan C# programlarına konsol uygulaması
adı verilmektedir.
Class Sinif_1
{
public static void Main()
{
System.Console.Write("Efes Pilsen Basketbol Takımı");
System.Console.ReadLine();
}
}
Bu şekilde hazırlanan C# programı DOS ortamında derlenip çalıştırılırsa

belirtilen bilgi Write() metodu sayesinde DOS penceresine yani konsola
yazılır. Bir sonraki satırda kullanılan ReadLine() metodu sayesinde enter
tuşuna basılıncaya kadar program çalışmaya devam eder. Bu örnekte
ReadLine() yerine Read() metodu kullanılsaydı değişen bir şey olmazdı.
Tabii bu 3 satırlık kodda ReadLine() yerine ReadKey() metodunu
kullanırsanız uygulamanın çalışmasını sona erdirmek için herhangi bir tuşa
basılabilir.
.NET Framework adı verilen sınıf kitaplığı ile gelen sınıfların Namespace adı
verilen yapılarda saklandığını biliyorsunuz. C# programlarında kullanmak
istediğiniz Class hangi Namespace’in içinde yer alıyorsa o namespace’ı
using deyimi ile programa dahil etmelisiniz veya yukarıda yapıldığı gibi
içerdiği sınıfları kullanmak istediğiniz namespace’in adını metodun önüne
her seferinde yazmalısınız.
DOS penceresi ile ilgili Console sınıfı System adlı Namespace’te yer aldığı
için Write() metodundan önce bu sınıfın yer aldığı Namespace’in adını
yazdım. Söz konusu Namespace’teki sınıfları programınızda çok kez
kullanıyorsanız her seferinde Namespace’in adını bu şekilde yazmak yerine
aşağıda yapıldığı gibi ilgili Namespace’i using deyimi ile koda dâhil
edebilirsiniz. using deyimi ile olmayan bir namespace’i C# programınıza
dahil etmek istemeniz yani olmayan bir namespace'in kaynaklarından
yararlanmak istemeniz halinde derleme sırasında hata meydana gelir.
using System;
Class sinif_1
{
{
Console.Write("Efes Pilsen Basketbol Takımı");
Console.ReadLine();
}
}
C# programlarınızda .NET Framework ile gelen Namespace’lerdeki hazır

sınıfları kullanmanın ötesinde kendi hazırladığınız class’ları bir Namespace’in
içine koymanız gerekir. Yukarıda bunu yapmamış olmamıza rağmen
herhangi bir hata meydana gelmedi. Çünkü programcı yazdıklarını bir
Namespace’e yerleştirmediği zaman C# derleyicisi kendiliğinden bir
Namespace hazırlamaktadır. Şimdi yukarıda verdiğim programdaki “Sinif_1”
adını verdiğim Class’ı bir Namespace’e dahil edeceğim.
using System;
namespace Tokmak
{
class sinif_1
{
{
Console.Write("Efes Pilsen Basketbol Takımı");
Console.ReadLine();
}
}
}
Yukarıda bold yapılan paragrafı ve bu kısa C# kodunu; C++ veya Java gibi
nesneye yönelik programlama dilleri hakkında az çok bilgi sahibi olan
birisine gösterseniz şaşırıp “bunda önemli olan nedir veya üzerinde
durulacak ne var ki?” diye size soru yöneltmesi yüksek ihtimaldir. Çünkü
konuya kendi açısından bakacaktır. Bu dersleri C# veya nesneye yönelik
programcılık konusunda yeni olanları düşünerek kaleme aldığım için
yukarıda verdiğim kısa kod ve kalın(bold) yapılan açıklama karşısında
duraklamanız normaldir. Bu düşünce ile aşağıda farklı renge boyanan
paragrafı kaleme aldım.
C# veya Visual Basic’in .NET uyumlu sürümü ile program yazanların

kaçmakla kurtulamayacakları 2 kavramdan birisi Class, diğeri ise
Namespace’tir. Nesneye yönelik programcılığın temeli olan Class kavramı
hakkında bu derslerde henüz doğru dürüst bilgi verilmemiş olmakla birlikte
sanırım Class kavramı hakkında kafanızda beliren soruların üzerinde
durmamayı şimdilik başarıyorsunuz Class bir yana bir de Namespace’ten söz
edilince kafanızdaki sorular önem kazanmaya başlamış olabilir.
Birden Fazla Main() Metodu
Uygulamanızda birden fazla Class varsa Main() metodunun hangi Class’ta

olduğunun önemi yoktur. Çünkü C# derleyicisi Main() metodunun hangi
Class’ta olduğunu arayıp buluyor. Uygulamadaki birden fazla sınıfta Main()
metodu varsa hangisinin kullanılacağının belirtilmesi gerekir. Bu konuda
bilgi vermek için aşağıdaki gibi bir C# programı hazırladım.
using System;
class sinif_1
{
{
Console.Write("Program Đlk sınıftaki Main ile başladı");
Console.ReadLine();
}
}
class sinif_2
{
{
Console.Write("Program Đkinci sınıftaki Main ile başladı");
Console.ReadLine();
}
}
Bu örneğe dikkat ederseniz Main() metodunun parametresiz olduğunu veya

parantezin içine herhangi bir değişken adı yazmadığımı görürsünüz. Ayrıca
bu örnekte Namespace hazırlamadığımı fark etmiş olmalısınız.
Bu şekilde hazırlanan C# programı bilinen şekilde derlendiğinde hata

meydana gelir. Derleme satırında hangi sınıftaki Main() metodunun
kullanılmak istendiği belirtilmelidir. Bu program aşağıdaki gibi derlenirse
uygulama ilk sınıftaki Main() metodundan itibaren çalışmaya başlar.
Write ve WriteLine Metotları
Yukarıda verdiğim örneklerde konsola yalnızca bir bilgi yazdım. Şimdi

konunun anlaşılmasına katkı olması için 4 bilgiyi yazacağım. Bu amaçla
aşağıda verdiğim C# programını hazırladım. Eğer saygıdeğer bir yazarımız
kitabında Console sınıfının Write() metodunu anlatırken benim gibi konsola
Futbol takımlarının adını yazmayı tercih etmişse yandım. Çünkü o i ve j gibi
değişkenleri kullanmak, Selection Sort gibi bütün programcılar tarafından
bilinen sıralama tekniğini kullanmanın suç olduğunu ileri süren Prof'ların
olduğu bir memlekette programcılık üzerine yazmak cesaret istiyor.
using System;
namespace Tokmak
{
class sinif_1
{
{
Console.Write("Fenerbahçe");
Console.Write("Galatasaray");
Console.Write("Beşiktaş");
Console.Write("Trabzonspor");
Console.ReadLine();
}
}
}
Bu programda Write() metodu ile konsola 4 bilgi arka arkaya yazılmakta ve

ReadLine() metodu ile programın işletimi askıya alınmaktadır. Write()
metodu ile konsola bilgi yazıldıktan sonra imleç yazma işleminin
tamamlandığı yerde bekleyeceği için bu program derlenip çalıştırılırsa

aşağıdaki gibi bir sonuç elde edilir.
Bu bilgilerin ayrı satırlara yazılmasını sağlamak için Write() yerine

WriteLine() metodunu kullanabilirsiniz. WriteLine() metodu kendisine
parametre olarak verilen bilgiyi belirtilen ortama(burada konsol) yazdıktan
sonra imleci bir sonraki satırın başına alır.
using System;
namespace Tokmak
{
class sinif_1
{
{
Console.WriteLine("Fenerbahçe");
Console.WriteLine("Galatasaray");
Console.WriteLine("Beşiktaş");
Console.WriteLine("Trabzonspor");
Console.Read();
}
}
}
Write() metodu ile konsola yazılan metnin sonuna satır başı

karakterini(“\n”) ekleyerek aynı sonucu alabilirsiniz. Satır başı karakterinin
nasıl kullanıldığını aşağıda görebilirsiniz.
using System;
class sinif_1
{
{
Console.Write("Fenerbahçe\n");
Console.Write("Galatasaray \n");
Console.Write("Beşiktaş \n");
Console.Write("Trabzonspor \n");
Console.Read();
}
}
Ey programcı olmak isteyen arkadaş: Burada anlatılanları birçok kitapta

veya sitede görmüş olmalısınız. Hele hele Console sınıfının ReadLine gibi
metotları hakkında bilgi içeren binlerce siteyi bulman mümkündür. Lütfen
eğri otursanız bile doğru konuşun; sizce bu metnin anlatım biçiminden yani
cümle şeklinden başka orijinal bir yanı var mıdır? Bence yoktur. Buna
rağmen birileri çıkıp "Memik Yanık bu metni garanti benim kitaptan çalmıştır
veya çeviriştir" derse nasıl bir tepki verirdiniz? Lütfen gülmeyiniz, derler..
Hem de Prof unvanına sahip birileri bu iddiayı onaylarlar. Bir sonraki derste
C# için hazırlanmış Express Edition'dan söz edeceğiz.
BÖLÜM 4
KONSOL UYGULAMALARI ve EXPRESS EDITION
C#’la ilgili ilk derse söylemiş olmama rağmen tekrar edelim: Bu derslerin
amacı programcılık ve C# öğrenmek isteyenlere ilk öğrenmeleri gereken
konuları anlatmaktır. C# ile çalışmaya bu dersleri okuyarak başlayanların
C# öğrenme süreleri kısalacaktır, C# kitaplarında yazılanları, C# derslerinde
anlatılanları anlamaları kolaylaşacaktır. Bu nedenle elinizdeki C# konulu
kitapları okumadan, dokümanları incelemeden önce bu dersleri okumanızı
öneriyorum.
Bildiğiniz gibi Microsoft firması 2002 yılından bu yana .NET Framework adı
verilen sınıf kitaplığını ücretsiz olarak dağıtmaktadır. Bütün .NET Framework
sürümlerinde hazır sınıflardan başka Visual Basic, C# ve C++ derleyicileri
de bulunmaktadır. Başka bir deyişle herhangi bir .NET Framework
sürümünden yararlanıp Visual Basic veya C# diliyle uygulamalar geliştirmek
mümkündür. Ne ki Not Defteri veya başka bir editörle C# veya Visual Basic
programlarını yazıp DOS penceresinde derlemek zahmetli olup günümüz
şartlarında iğneyle kuyu kazmak gibidir. C#’la ilgili 2. ve 3. derste Not
Defteri ile konsol uygulamaları geliştirip C#’a alışmaya çalışmıştık.
Çözüm ise Microsoft ürünü Visual Studio adı verilen program geliştirme
aracından yani IDE’den yararlanmaktadır. Visual Studio paketi ile hem Web
uygulamaları hem C# hem C++ hem de Visual Basic dilini kullanan
uygulamalar geliştirmek mümkündür. Microsoft firması 2004 yılından
itibaren dillere özel ve Visual Studio’nun kısıtlı özelliklere sahip sürümlerini
hazırlayıp ücretsiz olarak dağıtmaya başladı. Bu sürümlere Express Edition
adı verildi. Visual Studio 2008 için konuşmak gerekirse Visual Studio 2008
ile .NET Framework 3.5 destekli ve istenilen programlama dilinde uygulama
geliştirmek mümkün iken Visual Basic’e özel Express Edition ile ancak Visual
Basic uygulaması geliştirmek mümkündür.
Bu söylenenlerden yola çıkarak C# için hazırlanmış Express Edition hakkında

şunlar söylenebilir: Not Defteri ile uygulama geliştirmek istemeyenler ve
Visual Studio’yu pahalı bulup edinemeyenler Express Edition’la idare
edebililer.
Bu bölümde C# için hazırlanmış Express Edition 2008’in program geliştirme

ortamı hakkında kısaca bilgi verilecektir. Tekrar etmek gerekirse Express
Edition ilgili programlama dilinin veya derleyicinin adı olmayıp “program
geliştirme ortamının” veya yaygın bilinen adıyla IDE’nin adıdır. C# için
hazırlanan Express Edition yazdığınız programları derlerken .NET Framework
ile gelen C# derleyicisinden yararlanır. Visual Basic uygulaması geliştirmek

isteyenlerin Visual Basic için hazırlanmış Express Edition’ı, Web uygulaması
geliştirmek isteyenlerin ise Visual Web Developer Express Edition’la
ilgilenmeleri gerekir. Bu arada bir isimlendirme yanlışlığını vurgulayalım. Bu
yanlışlığın ası kaynağı Microsoft firmasıdır. Örneğin Microsoft’un sitesine
bakıldığı zaman Visual Basic’le ilgili Express Edition’ın adı “Microsoft Visual
Basic 2008 Express Edition”. Đlk bakışta bu adlandırmada 2008’in Visual
Basic derleyicisin sürümünü işaret ettiğini sanabilirsiniz. Hal bu ki buradaki
2008 derleyicinin sürümü yerine IDE’nin sürüm numarasıdır. Express
Edition’lar piyasaya verildiğinden bu yana bu yanlışlığa defalarca işaret
etmeme rağmen bir çok kaynakta 2008’in bir Visual Basic sürümü olduğu
yazılmaktadır.
Visual C# Đçin Hazırlanmış Express Edition’ı Kurmak
C# için hazırlanmış Express Edition’ı bilgisayarınıza kurmadan önce

bilgisayarınıza .NET Framework 2.0 veya 3.5 sürümünü kurmalısınız. C# için
hazırlanmış Express Edition’ın 2005 sürümünü kullanacaksanız .NET
Framework 2.0 sürümü yeterli olmaktadır. Express Edition’ın 2008
sürümünü kullanmak istiyorsanız daha önceden .NET Framework 3.5
sürümünü kurmuş olmalısınız. Đleri ki sayfalarda işaret edileceği üzere .NET
Framework 3.5 sürümünü bilgisayarınıza kurmadan C# için hazırlanmış
Express Edition’ın 2008 sürümünü kurmanız halinde Express Edition ile
birlikte .NET Framework’ün 3.5 sürümü otomatik olarak Microsoft’un
sitesinden indirilip kurulur. C# ile program geliştirme konusunda henüz
yolun başında olanlar için kullanılacak Express Edition sürümünün 2005
veya 2008 olmasının fazla bir önemi yoktur.
Şimdi sırada C# için hazırlanan Express Edition’ı kurmak var.

Microsoft.com’da arama yapıp aşağıda ekran görüntüsünü verdiğim sayfayı
buldum. Gördüğünüz gibi bu sayfada değişik programlama dilleri için
hazırlanmış olan Express sürümlerin linkleri var. Bazı Express sürümlerin
birden fazla dil için hazırlanan kopyaları olduğundan Select a Language
başlıklı liste kutusunda dil seçmek gerekir.
Select a Language liste kutusunda Đngilizce veya başka bir dili seçtiğinizde
veya Download linkini tıkladığınızda yaklaşık 2.5 MB‘lık vcssetup.exe
dosyası indirilmek üzere sizden izin istenir. C# yerine Visual Basic ile
ilgileniyorsanız Visual Basic’le ilgili Download linkini tıklamalısınız.
Bu EXE dosyayı indirip çalıştırdığınızda ilk olarak aşağıda verdiğim diyalog

kutusu ekrana gelir. Welcome Setup başlıklı bu diyalog kutusundaki onay
kutusunu seçtiğinizde kurma işlemi sırasında yaşadığınız sorunlar
Microsoft’a iletilir.
Welcome başlıklı bu diyalog kutusunda herhangi bir işlem yapmadan Next

düğmesini tıklayınca bu kez ekrana lisans hakları ilgili pencere geldi. Kurma
işlemine devam etmek üzere lisans hakları ile ilgili penceredeki ilgili radyo
düğmesini seçip Next düğmesini tıklarsanız ekrana aşağıda verilen
Installation Options diyalog kutusu gelir. Visual Studio ve C#’la ilgili
dokümanların indirilip kurulmasını istiyorsanız bu diyalog kutusundaki
Microsoft Express MSDN... onay kutusunu seçmelisiniz.
Bu arada Microsoft’un sitesinden SQL Server’ın Express Edition adı verilen

ücretsiz sürümünün indirilip kurulmasını istiyorsanız SQL Server’la ilgili onay
kutusunu seçmelisiniz. C# ile geliştireceğim uygulamalarda veritabanı
olarak hep Access kullanacağım demiyorsanız SQL Server’ın kurulmasını
sağlamalısınız. Bu metni kaleme aldığım günlerde SQL Server’ın Express
Edition’ın en son sürüm nosu 2005 iken şu günlerde 2008 sürümü kullanıma
sunuldu.
Tabii SQL Server’la ilgili bu onay kutusunu seçmeden C# için hazırlanan

Express sürümü kuracak olursanız daha sonradan SQL Server’a gerek
duyduğunuzda Microsoft’un sitesinden indirip kurabilirsiniz. Daha önce SQL
Server’ın Express sürümünü indirdiğim için tekrar indirilsin istemedim.
Ayrıca bu sırada kullandığım bilgisayarda SQL Server’ın Express sürümü
kurulu olsaydı bu seçenek Installation Options diyalog kutusunda
bulunmazdı.
Ekranda Installation Options diyalog kutusu varken Next düğmesini

tıkladığınızda Visual C# 2008 Express Edition’ın kurulacağı sürücü ve
klasörün belirlendiği Destination Folder başlıklı diyalog kutusu ekrana
gelir. C# için hazırlanmış Express Edition’a ait dosyalar “\Program
Files\Microsoft Visual Studio 9.0” klasörünün altında hazırlanan bir klasöre

yerleştirilmektedir. Express Edition’a ait dosyaların başka bir klasöre
yerleştirilmesini istiyorsanız bu diyalog kutusunda ayarlama yapabilirsiniz.
Bana sorarsanız bu diyalog kutusunda herhangi bir değişiklik yapmayın ve
C# için hazırlanmış Express Edition’ın 2008 sürümünü varsayılan klasöre
kurun. Merak edenlere hemen söyleyelim: Kullanılan bilgisayarda hem
Visual Studio hem de istenen Express Edition’lar olabilmektedir. Yani
Express Edition kuranlar sonradan Visual Studio’yu kurabilirler.
Bu ekran görüntüsünü aldığım sırada kullandığım bilgisayara .NET

Framework 3.5 kuruluydu. Bu nedenle kurulacak bileşenlerin listelendiği bu
diyalog kutusunda .NET Framework 3.5 listelenmiyor. Bu sırada kullandığım
bilgisayara .NET Framework kurulu olmasaydı bu diyalog kutusunda
kurulacağı işaret edilen seçenekler daha fazla olabilirdi.
Đşleme devam etmek üzere Install düğmesini tıklarsanız kurma işlemi

seçilen bileşenlere ve Internet’in hazına bağlı olarak kısa sürede
tamamlanır. Kurma işlemi tamamlandığında ekrana aşağıda verilen Setup
Complete diyalog kutusu getirilir. Bu diyalog kutusundaki Windows
Update linkini tıklayabilir veya Microsoft’un sitesinden servis

paketlerini(varsa) daha sonra indirip kurabilirsiniz.
Visual C# Đçin Hazırlanmış Express Editon’ı Register Etmek
Anlatılan şekilde kurulan Express Edition’ı register etmeden 30 gün boyunca

kullanabilirsiniz. Ürün ücretsiz olduğu için register işlemini sorun yapmayın
derim. Đnsanlar kurdukları programı hemen kullanmak istiyorlar ve nasıl olsa
30 günüm var deyip Register işlemini erteliyorlar. Ben de bu alışkanlığa
uyup Setup Complete diyalog kutusundaki Exit düğmesini tıklayıp Register
işlemi sonraya bıraktım. C# için hazırlanmış Express Edition’ı
çalıştırdığınızda aşağıdaki gibi bir pencere ile karşılaşırsınız.
Bu sırada nasıl proje hazırlanıp nasıl kod yazıldığı ayrı bir konudur. Đleriki
sayfalarda bu konu işlenecektir. Eski Türk filmlerindeki gibi 30 günün göz
açıp kapayıncaya kadar geçtiğini varsayıp hemen Register etmeye çalışalım.
Bu amaçla Help menüsünden Register Product komutunu verelim. Help
menüsünden bu komutu verdiğinizde ekrana aşağıda verilen diyalog kutusu
gelir. Bu diyalog kutusunda sizden register anahtarı isteniyor.
Bu anahtar elimizde olmadığına göre Microsoft’tan isteyeceğiz. Microsoft’tan

Registration anahtarını istemek için bu diyalog kutusundaki Register now
linkini tıklamak gerekiyor. Bu linki tıkladığınızda karşınıza aşağıda verdiğim
sayfa gelir ve mail adresinizle parolanız istenir.
Gerek olmamasına rağmen bu işlem için başka bir mail adresini kullanmak
istiyorsanız veya mail adresiniz yoksa Sign up now düğmesini tıklayıp
Hotmail’den yeni bir adres edinebilirsiniz. Mevcut mail adresinizi ve
parolanızı girip Sing in düğmesini tıkladığınızda ekrana aşağıda verilen
sayfa getirilerek sizden bazı ek bilgiler istenir.
Đstenen bilgileri girip sayfanın alt kısmındaki Continue düğmesini tıklayıp

işleme devam ettiğinizde aşağıda verilen sayfa ekrana getirilerek sizin için
hazırlanan kayıt anahtarı sayfaya yazılır.
Bu anahtarı kopyalayıp Help menüsündeki Register Product komutu ile

ekrana getirilen diyalog kutusuna yapıştırmak gerekiyor. Aşağıda verilen
ekran görüntüsünü bu işlemi yaptıktan sonra aldım.
Register anahtarını bu diyalog kutusuna yapıştırıp Complete Registration

düğmesini tıkladığınızda işlem tamamlanmış olur. Anlatılan şekilde Express
Edition’ı register edip ondan sonra Help menüsünden Register Product
komutunu verdiğinizde ekrana aşağıdaki gibi bir diyalog kutusu getirilerek
ürünün zaten kayıtlı olduğu işaret edilir.
Visual C# 2008 Express Edition’ı(bu adlandırma kafaları karıştırdığı için

zaman zaman “C# için hazırlanan Express Edition” deme gereğini
duyuyorum) kurup çalıştırırsanız aşağıdaki gibi Visual C# 2008 Express
Edition penceresi ile karşılaşırsınız. Bu ekran görüntüsünü dikkatlice
incelediğinizde pencerenin sol tarafında gizlenmiş Toolbox penceresinin sağ
tarafında ise açık durumda olan Solution Explorer penceresinin olduğunu
görürsünüz.
Kurup çalıştırdığım Express Edition’in 2005 sürümü olsaydı aşağıdaki gibi

sonuçla karşılaşırdım. Bu derslerin içeriği bağlamında Express Edition’ın
2005 ile 2008 sürümü arasında pek fark yoktur.
Visual C# 2005/2008 Express Edition çalıştırıldığında yeni proje

hazırlayabilmeniz veya mevcut projeleri açabilmeniz için Start Page ekrana
getirilmektedir. Recent Projects kutusundaki Open ve Create seçenekler
ile mevcut projeleri açabilir ve yeni projeler hazırlayabilirsiniz. Đsterseniz
Start Page sayfasını kapatabilirsiniz. Bazı arkadaşlarımız C# ile çalışırken
Express Edition yerine Visual Studio’yu tercih edebilirler. Bu dersler
bağlamında Visual Studio ile Express Edition birbirinden pek farklı değildir.
Proje Hazırlamak
Daha önce açılıp kapatılan C# projeleri Start Page sayfasında Recent

Projects kutusunda listeleniyor. Mevcut projelerden birisini açmak
istiyorsanız Open seçeneğinin karşısındaki Project linkini tıklayabilir veya
File menüsünden komut verebilirsiniz. Yeni bir C# projesi hazırlamak üzere
Start Page’deki Create seçeneğinin Project linkini tıklarsanız ekrana New
Project diyalog kutusu gelir. Bu diyalog kutusunda Visual C# için
hazırlanan Express Edition ile birlikte verilen şablonlar listelenmektedir.
Bu sırada C# için hazırlanmış Express Edition yerine Visual Studio kullanıyor

olsaydım New Project diyalog kutusunda daha fazla seçenek olurdu. Çünkü
Visual Studio ile C# uygulamalarından başka Visual Basic, C++ ve Web
uygulamalarını geliştirmek mümkündür.
Madem daha önceki derslerde DOS penceresinde derlenip çalıştırılan C#

programları hazırladık; kaldığımız yerden devam etme niyetine bir konsol
uygulaması hazırlayalım. Bu amaçla New Project diyalog kutusunda
Console Application şablonunu seçip Name kutusuna konsol
uygulamasına vermek istediğim adı yazdım. Bu şablonu seçip OK düğmesini
tıklarsanız aşağıdaki gibi bir Express Edition penceresi ile karşılaşırsınız.
Express Edition tarafından hazırlanan bu kodu incelerseniz size yabancı

gelen fazla bir şeyin olmadığını fark edersiniz. Şimdiye kadar
anlattıklarımıza ek olarak using deyimiyle System.Collections.Generic,
System.Linq ve System.Text adlı namespace’lerdeki sınıflardan
yararlanılmak istendiği işaret edilmiştir. Zaten daha önce verdiğimiz kısacık
örneklerde bu namespace’lerdeki sınıflara gerek duymamıştık. New Project
diyalog kutusunda uygulamaya vermiş olduğum ad aynı zamanda
Namespace adı olarak kullanılmış. Devamında Program adında bir Class
hazırlanmış. Başka bir deyişle Express Edition, kod dosyasının adını aynı
zamanda Class adı olarak kullanmış. Tabii sizler bu Class’a yani sınıfa başka
bir ad verebilirsiniz. Her C# uygulamasında Main() metodunun olması

zorunlu olduğu için bu Class’ın sınırları içinde Main() metoduna yer verilmiş.
Bu şartlarda “Proje1” adını verdiğim konsol uygulaması henüz kaydedilmiş

değildir. Şimdi henüz herhangi bir değişiklik yapmadığımız bu konsol
uygulamasını kaydedelim. Bu amaçla Express Edition’ın File menüsünden
Save All komutunu verebilir veya Standard araç çubuğundaki Save All
düğmesini tıklayabilirsiniz. File menüsünden Save All komutunu verdiğinizde
ekrana aşağıda verdiğim Save Project diyalog kutusu gelir.
Her ne kadar projeyi veya konsol uygulamasını hazırlarken New Project

diyalog kutusunda bir ad vermekle birlikte projeyi kaydederken bu adı
değiştirme imkanımız var. Projeye vermek istediğiniz adı Name kutusuna,
projenin kaydedileceği klasörü ise Location klasörüne yazmanız gerekir.
Klasör adını doğrudan yazmak yerine Browse düğmesini tıklayıp mevcut
klasörlerden birsini seçebilirsiniz.
Save Project diyalog kutusuna ayrıca Solution Name başlıklı bir metin
kutusu bulunmaktadır. C# için hazırlanmış Express Edition veya Visual
Studio sayesinde hazırlanan bir veya birden fazla proje bir araya getirilerek
Solution hazırlanmaktadır. Başlangıçta proje adı ile proje grubu işlevi gören
“Solution” adının aynı olacağı varsayılmaktadır. Projenin kaydı sırasında
hazırlanan dosya veya klasörleri sizlere göstermek için Solution’a farklı bir
ad verdim.
Express Edition veya Visual Studio ile hazırlanan projelerin geçerli

kullanıcıya ait “Belgelerim” klasörünün altındaki “Visual Studio
2008\Projects” klasörüne kaydedilmek istendiği varsayılmaktadır. Bu konsol
uygulaması için Express Edition tarafından hazırlanan klasör ve dosyalara

dikkatinizi çekmek için Location metin kutusunda “C:\Projeler” yazdım.
C# projesi hazırlanırken belirtilen klasörün altında önce Solution ile aynı ada
sahip bir klasör hazırlanıyor. Ardından Solution’a ait klasörün içinde proje
için ayrı bir klasör hazırlanmaktadır. Çünkü Solution’lar çok sayıda projeye
sahip olabilirler. Proje için hazırlanan klasör ve dosyaları aşağıda
görebilirsiniz.
Bu ekran görüntüsünü incelerseniz Solution için hazırlanan klasörün içinde

proje ile aynı ada sahip bir klasörün hazırlanıp projeye ait dosyaların bu
klasöre yerleştirildiğini görebilirsiniz. Solution birden fazla projeden
meydana gelmeyecekse Solution ile projeye ait dosyaların bir arada olmasını
sağlayabilirsiniz.
Solution için ayrı bir klasör hazırlanmasını istemiyorsanız Save Project

diyalog kutusundaki Create directory for solution onay kutusunu pasif
duruma getirmelisiniz. Bu onay kutusunu pasif duruma getirdiğinizde Save
Project diyalog kutusunda Solution’a ad veremezsiniz. Aşağıda verilen
ekran görüntüsünü “Create directory for solution” onay kutusunu pasif
duruma getirip “Proje1” adında bir konsol uygulaması hazırladıktan sonra
aldım.
Eminim ki bu dersleri izleyenlerin çoğunluğu şimdiye kadar bilgisayarlarına

Express Edition’ı kurdular ve bu metni okurken bir taraftan yukarıda
yaptığım gibi kendileri de konsol uygulaması hazırladılar. Bu ekran
görüntüsüne veya kendi hazırladığınız proje için hazırlanan klasöre
bakarsanız Express Edition’ın konsol uygulaması için çok sayıda klasör ve
dosyayı hazırladığını fark etmiş olmalısınız. Beni dinlerseniz şimdilik kafayı
bu dosyaların işlevine takmayın.
C# için hazırlanmış Express Edition ile yukarıda anlatılan şekilde hazırlanan

projeyi çalıştırırsanız projenin çalışması ile çalışmasının sona ermesi bir olur.
Projenin veya konsol uygulamasının çalışmasının hemen sona ermesini
engellemek için Program.cs dosyasındaki Main() metoduna aşağıdaki gibi 3
satır ekledim.
using System;
using System.Collections.Generic;
using System.Text;
namespace Proje1
{
class Program
{
{
System.Console.WriteLine("www.memikyanik.com");
System.Console.Write("Çıkmak için bir tuşa basın");
System.Console.ReadKey();
}
}
}
Bu satırlar Express Edition penceresinde Main() metodu ile sınırlanan bloğa

yazılıp sonra da Debug menüsünden Start Debugging komutu verilir veya
Standard araç çubuğundaki Start Debugging düğmesi tıklanırsa Express
Edition otomatik olarak derleme yapıp EXE dosyayı hazırlayıp çalıştırır.

Aşağıda verdiğim ekran görüntüsünü bu konsol uygulamasını Debug
menüsündeki Start Debugging komutu ile çalıştırdıktan sonra aldım.
Express Edition tarafından hazırlanan EXE dosya projeye ait klasörün

altındaki Bin klasörü içinde yer alan Debug klasörüne kaydedilir. Bu EXE
dosyayı alıp .NET Framework kurulu başka bilgisayarda çalıştırabilirsiniz.
Fırsattan istifade hemen kısa bir reklam arası vereceğim: Daha önce Visual
Studio veya Express Edition’ı temel alan programcılık kitabı incelemiş
olanların malumu olduğu gibi dünyanın hiçbir yerinde hiç kimse Visual
Studio veya Express Edition’ı böyle anlatmıyor. Hele hele biraz sonra
anlatacaklarımı hiçbir kitabın başlangıç sayfalarında bulamazsınız. C# veya
.NET uyumlu başka programlama dili hakkında kitap veya makale yazanlar
burada anlattıklarımı bilmiyorlar mı? Bilmez olurlar mı? Mutlaka bilirler, belki
de bazıları Memik YANIK’tan daha iyi biliyorlardır. O zaman neden
anlatmazlar bunları? Nedeni çok basit: Onların Memik YANIK gibi ilk
okumada anlaşılma gibi bir kaygıları yoktur. Tabii Memik YANIK ilk okumada
mutlaka anlaşılacağım dediği için veya böyle bir tercihi olduğu için başka
yazarların 10 sayfada anlattıklarını Memik YANIK en fazla 12 sayfada anlatır.
Bu nedenledir ki bazıları her fırsatta “Memik YANIK kitaplarını ekran
görüntüleri ile doldurup şişiriyor” diye beni suçlarlar. Bu derslerde yer ve
sayfa sorunu olmadığı için kitaplarda kullandığımda çok daha fazla ekran
görüntüsüne yer verdim.
Express Edition tarafından hazırlanan SLN uzantılı dosya Solution dosyasıdır.

Tekrar etmek gerekirse Solution’lar proje grubu gibi işlev görmekte ve
birden fazla proje üzerinde çalışıldığı zaman kolaylıklar sağlamaktadır. Bu
örnekte konsol uygulamamız bir projeden meydana geldiği için SLN uzantılı
dosyayı şimdilik unutabiliriz.
Buradaki “csproj” uzantılı dosya ise proje dosyasıdır. “csproj” uzantılı proje
dosyalarında projedeki form ve class’lar hakkında bilgi bulunmaktadır.
Express Edition tarafından hazırlanan proje dosyasının içeriğini size
göstermek için Not Defteri’nden yararlandım. XML formatındaki bu dosyaya
ilgisiz kalabilirsiniz.
Konsol uygulaması için Express Edition tarafından hazırlanan SLN ve

CSPROJ uzantılı dosyalarla ilgimizi şimdilik kopardıktan sonra geriye bir tek
“program.cs” dosyası kaldı. Şimdi “Program.cs” dosyasını Not Defteri ile açıp
içeriğini size göstereceğim.
Gördüğünüz gibi bu satırlar Express Edition penceresinde yazdıklarımızla

aynıdır. Daha önceki C# sürümlerini ve Visual Studio 2003’ü kullananlar için
söylemek gerekirse; Microsoft firması Visual Studio 2005 ve C# 2.0’dan
itibaren C# projelerinde “Program.cs” adında bir dosya hazırlamaya başladı.
Konsol uygulamalarında başlangıçta kod içeren bir tek “Program.cs” dosyası
olduğu için uygulama çalıştırıldığında işletilmesini istediğiniz satırları Main()
metodunun içine yazabilirsiniz. Şimdi öyle bir ayarlama yapacağım ki bu
uygulama çalıştırıldığı zaman ekrana bir pencerenin gelmesini sağlayacağım.
Bu kodu dikkatlice incelerseniz using deyimiyle System.Windows.Forms

adlı Namespace’deki Class’lardan yararlanılmak istendiği belirtilmiş. Aynı
satırı sizler yazmaya kalkışırsanız hata meydana gelir. Çünkü bu Namespace
.NET Framework ile gelen System.Windows.Forms.dll adlı DLL
dosyasında yer almaktadır. .NET Framework’e ait klasöre baktığınızda bu
dosyayı görebilirsiniz.
Konsol uygulamaları dahilinde ekrana pencere getirmek için bu DLL

dosyasının konsol uygulamasına dahil edilmesi gerekiyor. Başka bir deyişle
Express Edition’ın bu referans hakkında bilgilendirilmesi gerekir. Bunun için
Express Edition penceresi içinde yer alan Solution Explorer penceresinden
yararlanıp Add Reference diyalog kutusunu ekrana getirip
System.Windows.Forms.dll referansını uygulamaya dahil etmelisiniz.
Aşağıda verdiğim ekran görüntüsünü bu referans veya DLL dosyasını

uygulamaya dahil ettikten sonra aldım. Her ne kadar burada referansın
uygulamaya dahil edildiğinden söz edilse bile gerçek tam böyle değildir.
Yapılan, Express Edition’ın dolayısıyla C# derleyicisinin bu referanstan
yararlanılmak istendiği konusunda haberdar edilmesinden ibarettir.
Bu konuda daha sonra bilgi verileceği için bu örneği denemeyebilirsiniz.

Konsol uygulamaları üzerinde fazla durmayacağım için referans nedir gibi
soruları atlıyorum. Yukarıda verdiğim konsol uygulaması çalıştırıldığı zaman
önce bir DOS penceresi açılır. Ardından yaptığım hazırlıktan dolayı ekrana
bir pencere gelir. Bu pencereyi kapattığınızda konsol uygulamasının
çalışması sona erer ve DOS penceresi kapatılır.
Buna rağmen yukarıda verilen kodun üzerinde biraz duralım. Main()

metoduna yazdığım bu satırların ilkinde “Form1” adında ve
System.Windows.Forms adlı Namespace’teki Form sınıfı tipinde bir
değişken tanımlanmaktadır. Devamında new anahtar kelimesi ile Form
sınıfının örneğini alıp(yani nesne hazırlayıp) referansını Form1 adını
verdiğim değişkene aktardım. En son olarak bu Form nesnesini Application

sınıfının Run() metoduna parametre olarak verdim. Dikkat ederseniz burada
tanımladığım değişkene Form1 adını verdim. Yarın bir gün birisi çıkıp bu
değişken adını yani Form1’i kendi namı hesabıma Register ettim derse gülüp
geçin.
Windows Forms Uygulamaları
Daha önceki derslerde söylendiği gibi konsol uygulamalarına çok az ihtiyaç

duyacağınız için Express Edition ile hazırlanan konsol uygulamaları üzerinde
fazla durmaya gerek duymadan Windows Forms denilen normal
uygulamalara odaklanacağız. Bu nedenle yukarıda hazırladığım konsol
uygulamasını kapatıp ekrana New Project diyalog kutusunu getirip
Windows Application şablonunu seçtim.
C# için hazırlanan Express Edition ile hazırlanan projelerde New Project

diyalog kutusunda projeye verilen ad sonradan değiştirilebilmektedir.
Projeye vermek istediğim adı Name kutusuna yazıp OK düğmesini tıklayınca
aşağıdaki gibi bir Visual C# 2005 Express Edition penceresi ile
karşılaştım.
Windows Application şablonu ile hazırlanan projeye bir form dahil

edilmekte ve bu formun görsel yapısı Express Edition penceresine
gerilmektedir. Bu proje üzerinde herhangi bir değişiklik yapmadan Debug
menüsündeki Start Debugging komutu ile çalıştırırsanız karşınıza bu form
veya pencere gelir.
Bu formun üzerine hemen düğmeler, TextBox’lar veya ListBox’lar

yerleştirmek yerine Windows Application şablonu ile hazırlanan projenin
özelliklerine bakalım. Bu amaçla Solution Explorer penceresini açtım.
Express Edition ile C# projesi hazırlandığı zaman çok kullanılan bazı

referanslar veya namespace ve sınıfları içeren DLL dosyaları projeye dahil
edilmektedir. Hatırlarsanız yukarıdaki sayfalarda konsol uygulaması
dahilinde ekrana form veya pencere getirmek için
System.Windows.Forms’deki Form adlı sınıftan yararlanmıştık.
Üzerinde çalışılan projede .NET Framework ile gelen sınıflardan birisinden

yararlanmak için o sınıfın yer aldığı Namespace’i içeren DLL dosyasının veya
referansın projeye dahil edilmesi gerektiği için Solution Explorer
penceresinden yararlanıp Add Reference diyalog kutusunu ekrana
getirmiştik.
Benzer durum Express Edition ile hazırlanan Windows Forms uygulamaları

için de geçerlidir. Visual C# 2008 Express Edition en çok gerek duyulan
referansları projelere kendisi dahil ettiği için bir süre referanslar ile
ilgilenilmeyebilir. Express Edition ile hazırlanan projelere dahil edilen
referansları size göstermek için Solution Explorer penceresinde References
seçeneğine ait artı(+) işaretini tıkladım.
Gördüğünüz gibi Express Edition tarafından

6 referans veya DLL dosyası Windows
Forms uygulamalarına otomatik olarak
dahil edilmektedir. Yararlanmak istediğiniz
sınıf hangi DLL dosyası veya referansta yer
alıyorsa o referansın Solution Explorer
penceresinden yararlanılarak projeye dahil
edilmesi gerekir. .NET Framework ile gelen
herhangi bir sınıftan yararlanabilmek için
referansın projeye dahil edilmesi yetmez
ayrıca ilgili Namespace’in Imports deyimi
ile koda dahil edilmesi gerekir.
Birçok yerli yabancı kaynakta bu altını çizdiğim paragrafın benzerini bulma

ihtimali yüksektir. Bu paragrafta söylenenler yanlış olmasa bile eksiktir ve
okurun konuyu en başından yanlış kavramasına neden olmaktadır. Gelin bu
paragrafı yeniden yazalım. .NET Framework ile birlikte çok sayıda DLL
dosyası gelmektedir ve dosyalar Windows’un kurulu olduğu klasörün
altındaki Microsoft.NET\Framework klasörüne yerleştirilmektedir.
Daha önce söylendiği gibi bu DLL dosyalarında Namespace’ler

bulunmaktadır. Örneğin System.Windows.Forms.dll adlı dosyada
System.Windows.Forms adlı namespace yer almaktadır. Namespace’lerde
ise Class’lar ve/veya yapılar bulunmaktadır. Uygulamanızda hangi Class’ı

kullanmak istiyorsanız o Class’ın yer aldığı namespace’i içeren DLL dosyasını
yani referansı Solution Explorer penceresinde listelemeniz gerekiyor. Bir
referansı Solution Explorer penceresinde listelemek demek bir bakıma Visual
Studio veya Express Edition’a “bu referanstan yararlanmak istiyorum”
demektir. Yoksa uygulamaya dahil edilen bir şey yok. Söz konusu DLL
dosyası yerinde duruyor. Yararlanmak istediğiniz sınıfın yer aldığı
Namespace’i içeren DLL dosyasını Solution Explorer penceresinde
listeledikten sonra aşağıda verdiğim kodda olduğu gibi Class adından önce
Namespace adını yazarak söz konusu namespace’teki istediğiniz gibi
Class’tan yararlanabilirsiniz.

{
System.Windows.Forms.Form Form1;
Form1 = new System.Windows.Forms.Form();
Form1.Text = "memikyanik.com";
System.Windows.Forms.Application.Run(Form1);
}
Her seferinde Class adından önce Namespace adını yazmak istemiyorsanız

using deyimiyle söz konusu Namespace’teki Class’lardan yararlanmak
istediğinizi Visual Studio veya Express Edition’a belirtebilirsiniz. Buradaki
using deyimi DOS’un Path komutu ile benzer işleve sahiptir.
using System;
using System.Windows.Forms;
namespace Proje1
{
class Program
{
{
Form Form1;
Form1 = new Form();
Form1.Text = "memikyanik.com";
Application.Run(Form1);
}
}
}
Üzerinde çalışılan proje hakkında bilgi edinilmek istendiği zaman başvurulan

Solution Explorer penceresini dikkatlice incelerseniz projedeki formla ilgili
olarak 3 dosyanın hazırlanmış olduğunu görürsünüz. Burada dikkatinizi
öncelikle “Program.cs” dosyasına çekmek istiyorum. Daha önceki derslerden
bildiğiniz gibi C# projelerinin başlangıç noktası Main() metodudur. Express
Edition veya Visual Studio ile hazırlanan projelerde Main() metodu

“Program.cs” adlı kod dosyasında bulunduğu için bu dosya önemlidir.
Her ne kadar bu dosya önemlidir desem bile bu dosyaya kayıtsız kalıp usta
işi programlar yazmak mümkündür. Ne ki işin geri planının anlaşılması için
bu dosyanın üzerinde biraz durmak bir zorunluluk. Solution Explorer
penceresinde “Program.cs” dosyasını çift tıklarsanız bu kod dosyasının
içeriği görüntülenir.
Express Edition tarafından hazırlanan bu kodu dikkatlice incelerseniz

System, System.Collections.Generic ve System.Windows.Forms adlı 3
Namespace’deki sınıfların kullanılmak istendiği konusunda using deyimiyle
ayarlama yapılmış olduğunu görebilirsiniz. Program.cs dosyasındaki diğer
satırlar hakkında şimdi verilecek bilgilerin altyapısı olmadığı için üzerinde
fazla durmayacağım. Buna rağmen şu satırı dikkatinize sunmak istiyorum.
Application.Run(new Form1());
Bu satırı daha önce görmüş olanlar şöyle bir açıklamayı okumuş olabilirler:
“Uygulama Run() metodu ile başlatılmaktadır”. Aslında bu tek cümlelik
tanım yanlış değildir. Ne ki bu tanım, bu satırla nelerin yapıldığını, geri

planda nelerin geliştiğini açıklamaya yetmiyor.
Konunun devamında anlatılacağı gibi Express Edition ile bir Windows Forms
uygulaması hazırlandığında System.Windows.Forms adlı Namespace’teki
Form adlı Class’ın mirasçısı “Form1” adında bir Class hazırlanmaktadır. Đşte
bu satırda “Form1” adlı Class’ın örneği alınıp Application nesnesinin Run()
metoduna parametre olarak verilmektedir. Yeterince açık olmayan bu 2
cümlenin açıklamasını bir sonraki derse bırakıyorum.
BÖLÜM 5
VISUAL STUDIO ĐLE PROGRAM GELĐŞTĐRMEK
Bu derste Visual Studio’nun program geliştirme ortamı hakkında kısaca bilgi

verilecektir. Daha önce Visual Studio’nun herhangi bir sürümünü
kullandıysanız bu dersi atlamak isteyebilirsiniz. Bu derse en azından göz
gezdirmenizi önermek isterim. Çünkü bu derste ileride işlenecek bazı
konulara temel oluşturan birkaç ayrıntıdan söz edilmektedir. Aslında C#
programlama dilinden bağımsız olarak Visual Studio hakkında yüzlerce sayfa
yazılabilir. Ne ki bu derslerde böyle bir amacım yoktur. Bu derslerde amaç
C# programlama dilini ve .NET Framework ile gelen sınıflar hakkında
başlangıç düzeyi bilgi vermek olduğu için Visual Studio hakkında kısa bir
özet yapılmakla yetinildi.
Visual Studio 2008’in kurulması kolay ve sorunsuzdur. Visual Studio 2008

DVD’si sürücüye takıldığında veya “Setup.exe” programı çalıştırıldığında
ekrana aşağıda verilen pencere gelmektedir. Visual Studio’nun değişik
sürümleri bulunmaktadır. Professional sürüm işinizi görecektir. Visual
Studio’nun deneme sürümünü microsoft.com’dan indirebilirsiniz.
Bu penceredeki ilk seçenek tıklandığında size birkaç tanıdık soru

yöneltildikten sonra kurma işlemi tamamlanmaktadır. Bu tanıdık sorulardan
birisi Visual Studio’ya ait dosyaların kurulacağı sürücü ve klasördür. Visual
Studio varsayım olarak C:\Program Files\Microsoft Visual Studio 9.0\
klasörüne kurulmaktadır.
68 Memik Yanık - Visual C#’a Başlangıç Kitabı
Bu pencerede kurma tipi olarak Custom seçilirse Install düğmesi yerini

Next düğmesine bırakır. Önce Custom radyo düğmesini seçip Next
düğmesini tıkladığınızda ekrana Visual Studio’nun kurulacak bileşenlerinin
seçildiği pencere gelir.
Bölüm 6: Windows Forms Uygulamaları 69
Bu pencereden yararlanıp Visual Studio’nun kurulacak bileşenlerini

seçebilirsiniz. Örneğin Visual Studio ile Visual Basic veya C++ dilinde
uygulama geliştirmeyi düşünmüyorsanız bu dillerle ilgili bileşenlerin
kurulmalarını engelleyebilirsiniz. Visual Studio bilgisayara kurulduktan sonra
Başlat menüsünde Microsoft Visual Studio 2008 adında bir program grubu
hazırlanmakta ve bu program grubuna Visual Studio’ya ait kısayollar dahil
edilmektedir.
Visual Studio kurulup başlatıldığında ekrana aşağıda verilen diyalog kutusu

getirilerek program geliştirme ortamının düzenlenmesi konusunda seçim
yapmanız istenir. C# programları geliştirmek istediğim için bu diyalog
kutusunda Visual C#’ı seçtim. Bu seçim sayesinde Visual Studio’nun ortamı
C#’ın varsayılan seçimlerine göre ayarlanır.
Bu diyalog kutusunda Visual C#’ı seçtiğinizi varsayalım. Bir süre sonra

Visual Basic’in ayarlarına dönmek isterseniz Tools menüsünden Import
and Export komutu verildiği zaman çalışmaya başlayan Wizard’ın ilk
adımını temsil eden diyalog kutusunda Reset all Settings radyo düğmesini
seçip ortamın hangi dilin varsayılan ayarlarına göre düzenleneceği
konusunda seçim yapılan bu diyalog kutusunu ekrana getirebilirsiniz.
Bu diyalog kutusundaki Reset all settings radyo düğmesini seçip Next

düğmesiyle işleme devam ettiğinizde Wizard ekrana Choose a Default
Collection of Settings diyalog kutusunu getirir. Hangi dilin ayarlarının
geçerli olmasını istiyorsanız o dili seçebilirsiniz. Örneğin eski bir Visual Basic
programcısı iseniz C# uygulamaları geliştirirken Visual Basic’in ayarlarının
geçerli olmasını sağlayabilirsiniz.
Visual Basic’in varsayılan ayarları ile Visual C#’ın ayarları arasındaki önemli
farklardan birisi şudur: Visual Basic ayarları geçerli iken Visual Studio sizi
hazırladığınız projeyi hemen kaydetmek zorunda bırakmıyor. Tabii bu
diyalog kutusunda hangi dilin varsayılan ayarlarını seçerseniz seçin
sonradan Tools menüsünden Options komutu ile ekrana getirilen diyalog
kutusunda ortam ayarlarında istediğiniz değişikliği yapabilirsiniz. 2004
yılında yayınlanan C# kitabımda Data Adapter Configuration Wizard ile
DataAdapter nesnesinin özelliklerini ayarladım diye yargılandığıma göre
yarın bir gün yerli yazarın birisi çıkıp bu Import and Export Settings
Wizard’ı kullanmayı ilk ben akıl ettim derse sorumluluk kabul etmem.
Ayrıca bu memlekette Wizard tarafından ekrana getirilen diyalog kutularının
birden fazla kitapta aynı sırada olduğunu rapor edecek çok sayıda bilim
adamı(!) olduğuna göre bu Wizard’dan yararlanmak risk teşkil edebilir.
Visual Studio çalıştırıldığında yeni proje hazırlayabilmeniz veya mevcut

projeleri açabilmeniz için Start Page ekrana getirilmektedir. Bu sayfadaki
Recent Projects kutusunda Open adı altında gruplanan seçenekler ile
mevcut projeleri açabilirsiniz. Create adı altında gruplanan 2 seçenekten

yararlanıp yeni proje hazırlayabilirsiniz.
Mevcut projelerden birisini açmak istiyorsanız Open adı altında gruplanan

seçeneklerden Project’i tıklamanız gerekir. Project seçeneğini tıklarsanız
geçerli kullanıcıya ait “Belgelerim” klasörünün altında yer alan Visual
Studio Projects klasöründeki projeler listelenir. Visual Studio ile hazırlanan
her proje için ayrı bir klasör hazırlanmakta ve projeye ait dosyalar bu
klasöre kaydedilmektedir.
Visual Studio ile C# projesi hazırlamak üzere Start Page’deki Create adı
altında gruplanan 2 seçenekten Project’i tıklarsanız ekrana New Project
diyalog kutusu gelir. Project types kutusunda listelenen seçenekler Visual
Studio’nun bilgisayara kurulan bileşenlerine göre değişmektedir. C# projesi
hazırlamak istediğim için Project types kutusunda Visual C# ve
Templates kutusunda Windows Foms Application şablonunu seçtim.
Tam bu noktada bazen kafaların karışmasına neden olan Visual C# ile C#

ayrımına değinmek gerekiyor. Visual C#, Microsoft firmasının ticari
markasıdır. Madem C# programlama dilini Microsoft firması geliştirdi ve bu
kitapta Microsoft firması tarafından geliştirilen Visual Studio’dan
yararlanıyoruz C# ile Visual C# aynı anlamda kullanılabilir.
C# uygulamalarını geliştirirken Visual Studio yerine C# için hazırlanmış

Express Edition’ı kullanıyor olsaydım New Project diyalog kutusunda
daha az şablon listelenirdi. Aşağıda verilen ekran görüntüsü C# için
hazırlanmış Express Edition’a aittir.
Visual Studio 2003 veya 2005 ile C# projesi hazırlanmak istendiği zaman
ekrana getirilen New Project diyalog kutusunda .NET Framework
sürümünü tercih etme imkanı yoktu. Visual Studio 2003 ile .NET Framework
1.1 uyumlu projeler hazırlanabilirken Visual Studio 2005 ile .NET 2.0
uyumlu projeler hazırlanabiliniyordu. Visual Studio 2008’de ise proje
hazırlarken .NET Framework’ün 2.0, 3.0 veya 3.5 sürümlerinden birisini
seçme imkanın bulunmaktadır. New Project diyalog kutusunda seçilen
.NET Framework sürümüne göre Templates liste kutusunda listelenen
şablonlar değişmektedir.
Başlangıçta projeler için(yani eğitim amaçlı projelerde) .NET Framework’ün

2.0 veya 3.5 sürümünü seçmenin bir önemi olmamasına rağmen 3.5
sürümünü tercih ettim. New Project diyalog kutusunda .NET Framework’ün
2.0 sürümünü tercih ederseniz C# 3.0 ile ilgili bazı yeniliklerden
yararlanamazsınız. Örneğin LINQ teknolojisi ile sorgulama yapamazsınız.
New Project diyalog kutusunun alt kısmında Name seçeneğinden
yararlanarak projenin adını girebilir ve Location seçeneği ile projenin
kaydedileceği klasörü belirleyebilirsiniz.
Visual Studio ile hazırlanan C# projelerinin geçerli kullanıcıya ait

Belgelerim klasörünün altında bulunan Visual Studio Projects klasörüne
kaydedileceği varsayılmaktadır. Hazırlamak istediğim projeyi “C:”
sürücüsündeki “\Projeler” klasörüne kaydetmek istediğim için Browse
düğmesini tıklayıp klasör seçilen Project Location diyalog kutusunu ekrana
getirip bu klasörü seçtim.
Yukarıda anlatılan şekilde proje hazırladığınızda Visual Studio ayrıca bir

Solution hazırlamaktadır. Solution’lar proje grubu gibi işlev görmektedir.
Başlangıçta projenin adı aynı zamanda Solution adı olarak kullanılmaktadır.
Solution’a birden fazla proje dahil edeceksiniz farklı bir ad vermeniz önerilir.
Proje hazırlanırken Visual Studio tarafından oluşturulan klasörleri
gösterebilmek için Solution’a farklı bir ad verdim. Bu ayarlamalardan sonra
New Project diyalog kutusunu kapatırsanız Visual Studio projeyi hazırlar ve
aşağıdaki gibi bir Visual Studio penceresi ile karşılaşırsınız.
Başlangıçta Solution Explorer ve Properties pencereleri Visual Studio

penceresinin sağ tarafına yuvalanmış durumdadır. Sol tarafta ise Toolbox
gizlenmiş durumdadır. Bu ekran görüntüsü Visual Studio bilgisayara
kurulduktan hemen sonra alındığı için sizin bilgisayarda Visual Studio ile ilgili
pencerelerin yerleşim şekli farklı olabilir.
Proje hazırlanırken belirtilen klasörün altında proje ile aynı ada sahip bir
klasör hazırlanıyor. Buna göre her Visual C# projesi için ayrı bir klasör
hazırlanmaktadır. Proje için hazırlanan klasör ve dosyaları aşağıda
görebilirsiniz.
Bu ekran görüntüsünde Solution için hazırlanan klasörün içinde proje ile

aynı ada sahip bir klasörün hazırlandığını görebilirsiniz. Solution birden fazla
projeden meydana gelmeyecekse Solution ile projeye ait dosyaların bir
arada olmasını tercih edebilirsiniz. Solution için ayrı bir klasörün
hazırlanmasını istemiyorsanız New Project diyalog kutusundaki Create
directory for solution onay kutusunu pasif duruma getirmelisiniz.
Projeye ait klasöre kaydedilen “Form1.cs” uzantılı dosya projedeki formu

temsil etmektedir. Formların görsel yapısı ile ilgili bilgiler Designer.cs
dosyalarında tutulurken “resx” uzantılı dosyalarda ise formla ilgili
kaynaklar(resource) tutulmaktadır. Visual Studio tarafından hazırlanan C#
projesi dosyalarına “csproj” uzantısı verilmektedir. Visual Studio ile proje
hazırladığınızda aynı zamanda bir Solution hazırlanır ve Solution’a ait bilgiler
“sln” dosyalarında saklanmaktadır.
Yukarıda örnek olması için hazırladığım C# projesine "Proje1" adını verdim.

Bu proje adını yerli programcılık kitabı yazarları daha önceden kendi
adlarına register etmiş olabilir. Bu nedenle kendinizi riske etmeyip Proje1

yerine projelere argo veya gavurca adlar vermeniz önerilir. Örneğin Proje1
yerine “Project1” veya “En_baba_proje” gibi adları tercih edebilirsiniz.
Solution Explorer Penceresi
Üzerinde çalıştığınız projeye hangi formların ve dosyaların dahil edilmiş

olduğunu görmek istiyorsanız Visual Studio’nun Solution Explorer
penceresine bakabilirsiniz. Solution Explorer penceresinde bir bakıma
projeye ait klasörün içeriği görüntülenmektedir. Solution Explorer
penceresinin başlık çubuğunu çift tıklayıp bağımsız pencere olmasını
sağlayabilirsiniz. Aşağıda verilen ekran görüntüsünü proje için 2. bir form
hazırladıktan sonra aldım. Projeye 2. bir form dahil etmek demek gerçekte
.NET Framework ile gelen Form sınıfının mirasçısı 2. bir sınıf hazırlamak
demektir. Tıpkı Form1 sınıfında olduğu gibi Form2 sınıfının bir yarısı
Form2.cs dosyasında, diğer yarısı ise Form2.Designer.cs dosyasında yer
almaktadır.
Solution ve proje hakkında bilgi içeren bu pencereyi View menüsünden

komut vererek veya Standard araç çubuğundaki ilgili düğmeyi tıklayarak
ekrana getirebilirsiniz. Bu ekran görüntüsünü aldığım sırada “Proje1” adını
verdiğim projede Form1 ve Form2 adında 2 form vardı. Visual Studio ile
hazırlanan projelerde her form için ikisi CS uzantılı 3 dosya
hazırlanmaktadır.
Windows Forms Application şablonu ile hazırlanan projenin kaydedildiği

klasöre bakıldığında Bin ve Obj adında 2 klasörün hazırlandığı görülür.
Visual Studio başlangıçta bu 2 klasörü Solution Explorer penceresinde
listelemiyor. Üzerinde çalıştığınız proje ile ilgili bütün dosya ve klasörlerin
listelenmesini istiyorsanız Solution Explorer penceresindeki Show All Files
düğmesini tıklamanız gerekir. Bu düğmenin işlevini aşağıda görebilirsiniz.
C# projesine dahil edilmiş referansları görmek istiyorsanız Solution Explorer

penceresinde References seçeneğini tıklamalısınız. Visual Studio 2008 ile
hazırlanan C# projelerine 8 referans otomatik olarak dahil edilmektedir. Ek
bir işlem yapmaya gerek kalmadan bu referanslarda bulunan
namespace’lerdeki sınıfları kullanabilirsiniz. DLL dosyaları veya buradaki
adıyla referanslar doğaları gereği gerek duyulduğunda belleğe yüklenirler.
.NET Framework ile gelen veya kendi hazırladığınız referanslardan

birisindeki sınıflardan yararlanacaksanız References seçeneğine ait kısayol
menüsünden Add Reference komutunu vermelisiniz. Her ne kadar burada
referans eklemeden söz edilse bile eklenen herhangi bir şey yoktur. Yapılan
şudur: Yararlanılmak istenen referanslar hakkında Visual Studio
bilgilendirilmektedir. Yoksa referanslar yani DLL dosyaları ilgili klasörde
durmaktadır.
Bu komutu verirseniz ekrana Add Reference diyalog kutusu gelir. Projede

kullanmak istediğiniz bileşen veya referansı seçip OK düğmesini tıklamanız
yeterlidir.
Bu pencerede .NET sekmesinde listelenen her seçenek veya referans

gerçekte .NET Framework ile gelen birer DLL dosyasıdır. Kendiniz Visual
Studio ile gelen Class Library şablonu ile kolayca DLL dosyaları hazırlayıp
.NET Framework ile gelenlerde oluğu gibi bu DLL dosyalarından
yararlanabilirsiniz.
Form Designer ve Code Editor Pencereleri
Şimdiye kadar verilen ekran görüntülerinden tespit olabileceğiniz gibi yeni

bir proje hazırlandığınızda projeye otomatik olarak dahil edilen formun
görsel yapısı Visual Studio penceresinin Form Designer adı verilen orta
kısımda görüntülenmektedir. Aşağıda verdiğim ekran görüntüsünü aldığım
sırada projedeki ilk formun görsel yapısı görüntüleniyordu.
Açık olan her form veya kod dosyası için Windows Form Designer
penceresinin üst kısmında bir sekme hazırlanmaktadır. Bu sırada Solution
Explorer penceresinde Form2.cs’nin üzerinde çift tıklama yaparsanız bu kod
dosyası dahilinde hazırlanan Class’ın yani Form2’nin görsel yapısı
görüntülenir. Açık olan formlardan birisine ait kodları görmek istiyorsanız o
formu seçip View menüsünden Code komutunu vermelisiniz.
Form2 aktif form iken View menüsünden Code komutu verilirse bu formu
oluşturan kodlar görüntülenir. Aşağıda verilen ekran görüntüsünü almadan
önce Solution Explorer ve Properties pencerelerini gizledim. Bu kodu
yakından incelediğinizde “Form2” adında ve .NET Framework ile gelen Form
sınıfının mirasçısı bir Class’ın hazırlandığını görürsünüz.
Projedeki 2. formu temsil eden Form2 sınıfına ait kodların bir kısmı bu
dosyada iken diğer yarısı “Form2.Designer.cs” dosyasında bulunmaktadır.
Projedeki mevcut kod dosyalarını açmak için Solution Explorer penceresine
başvurmak yerine File menüsünden Open-File komutunu verebilirsiniz.
Kod yapısı görüntülenen formun görsel yapısını görmek istiyorsanız View

menüsünden Designer komutunu vermelisiniz. Projedeki formlara ait
kodları veya görsel yapılarını görüntülerken Solution Explorer penceresinden
yararlanabilirsiniz. Söz konusu forma ait kısayol menüsünden View
Designer komutunu verirseniz formun görsel yapısı, View Code komutunu
verirseniz forma ait kodlar görüntülenir.
ToolBox Penceresi
Visual Studio bilgisayara kurulup başlatıldığında ekrana getirilen bir diğer

pencere Toolbox penceresidir. Toolbox’ta formların üzerine
yerleştirebileceğiniz kontroller yani .NET Framework ile gelen hazır sınıflar
listelenmektedir. Visual Studio penceresinin sol tarafında Toolbox’tan başka
ayrıca Server Explorer penceresini temsil eden bir düğme bulunmaktadır.
Bu ekran görüntüsünü aldığım sırada Server Explorer penceresi açık

olmasına rağmen gizlenmişti. Bu pencereden veritabanı işlemleri yapılırken
yararlanılmaktadır. Bu derslerde veritabanı işlemlerinden söz edilmediği için
Server Explorer penceresini kapattım.
Toolbox’ın otomatik gizlenme özelliğini iptal etmek istiyorsanız Auto Hide

düğmesini tıklamalısınız. Auto Hide özelliği devrede değilken Toolbox
penceresinin başlık çubuğunda çift tıklama yapıp bağımsız pencere olmasını
sağlayabilirsiniz.
.NET Framework ile birlikte Toolbox’ta birer düğme ile temsil edilenlerden
çok daha fazla kontrol verilmektedir. Üzerinde çalıştığınız forma
yerleştirmek istediğiniz kontrol Toolbox’ta yer almıyorsa Tools menüsünden
Choose Toolbox Items veya Toolbox’a ait kısayol menüsünden Choose Items
komutunu verebilirsiniz.
Örneğin SQL Server veya Access veritabanlarına bağlanırken kullanılan

SqlConnection ve OleDbConnection kontrolleri başlangıçta Toolbox’ta yer
almıyor. Bu kontrollere gerek duyanların Toolbox’a ait kısayol menüsünden
komut verip ekrana gelen Choose Toolbox Items diyalog kutusunda
ayarlama yapmaları gerekir.
Toolbox’ta listelenen kontrollerin birisini seçip forma yerleştirmek demek

gerçekte söz konusu kontrolün yani Class’ın örneğini almak olarak
düşünmek gerek. Forma yerleştirilen kontrol söz konusu Class’ın yani
formun bir üyesi olur. Tabii Button veya TextBox gibi sınıfların örneklerini
alırken yani nesne hazırlarken Visual Studio’dan yararlanmak yerine bu
işlemi kod yazarak yapabilirsiniz.
Form ve Kod Pencerelerinin Organizasyonu
Şimdiye kadar verilen ekran görüntülerinden tespit etmiş olabileceğiniz

Properties, Toolbox, Solution Explorer ve Server Explorer gibi pencerelerin
dışında açık olan her form için Visual Studio penceresinin orta kısmında bir
sekme hazırlanmaktadır. Programcı açık olan hangi formla ilgileniyorsa o
formu temsil eden sekmeyi tıklar. Aşağıda verilen ekran görüntüsünü
aldığım sırada açık durumda olan 3 form vardı ve Form2’nin görsel yapısı
görüntüleniyordu.
Programcı bu sırada Form1 veya Form2’ye ait sekmeyi tıklayıp bu formları

görüntüleyebilir. Başka bir deyişle bu şartlarda form pencerelerini simge
durumuna küçültmek mümkün değildir. Açık olan her formun ayrı bir
pencereye sahip olmasını istiyorsanız Tools menüsündeki Options komutu
ile ekrana getirilen diyalog kutusunda ayarlama yapmalısınız.
Options diyalog kutusunda General adı altında gruplanan seçeneklerden

Multiple documents radyo düğmesini seçerseniz açık olan her form ayrı
bir pencereye sahip olur ve bu pencereleri simge durumuna küçültebilirsiniz.
Aşağıda verilen ekran görüntüsünü “Multiple documents” radyo düğmesini
seçtikten sonra aldım.
Bu ekran görüntüsünü aldığım sırada 3 form açıktı. Bu pencerelerinin

boyutlarını ve Visual Studio penceresi içindeki konumlarını istediğiniz gibi
ayarlayabilirsiniz. Bu metni kaleme alırken ekran görüntülerini istediğim gibi
ayarlayabilmek için Options diyalog kutusunda Multiple documents radyo
düğmesini seçip formların bağımsız pencere olmalarını sağladım.
Projelerinin Bileşenleri
Visual Studio ile geliştirilen uygulamalara Solution adı verilmekte ve

Solution’larda projeler bulunmaktadır. Üzerinde çalıştığınız Solution
hakkında bilgi edinmek istiyorsanız Solution Explorer penceresine
bakabilirsiniz. Madem C# uygulamalarını geliştirirken Visual Studio veya
Express Edition kullanıyoruz Visual Studio’nun hazırladığı projeler
hakkında bilgi edinmek gerekir.
Visual Studio ile hazırlanan C# projelerinde formlardan ve formları temsil

eden kod dosyalarından başka “Program.cs” adında bir kod dosyası
bulunmaktadır. Visual Studio veya Express Edition ile hazırlanan C#
projeleri çalışmaya bu dosyadan başlamaktadır. Çünkü C# projelerinin
başlangıç noktası olan Main() metodu bu kod dosyasında bulunmaktadır.
“Program.cs” dosyası Visual Studio 2003’te yoktu. Bu dosyanın en önemli
işlevi Main() metodunu içermesidir. Main() metodunu alıp başka bir kod
dosyasına yerleştirirseniz “Program.cs” dosyasına gerek kalmaz. Madem
Visual Studio kullanıyoruz bence Program.cs dosyasını aynı şekilde
bırakmakta fayda vardır.
C# projeleri Main() metoduna sahip olmak zorundadır. Çünkü C# projeleri

tıpkı C ve C++ projelerinde olduğu gibi Main() metodundan itibaren
çalışmaya başlarlar. Ayrıca Main() metodu public ve static olmalıdır. Bu
örnekte Main() metodu geriye bir değer göndermediği için void olduğu
işaret edildi.
C# projelerinin ikinci önemli bileşenleri formlar ve formlarla ilgili kod

dosyalarıdır. Visual Studio, projelere dahil edilen her form için 3 ayrı dosya
hazırlamaktadır. Asıl kod dosyaları yani programcının yazdığı kodlar form ile
aynı ada sahip CS uzantılı dosyada saklanmaktadır. Formun görsel yapısı ile
ilgili bilgiler ise “Designer.cs” dosyasında tutulmaktadır. Designer.cs
dosyasının içeriği genellikle Visual Studio tarafından oluşturulduğu için
programcılar pek ilgilenmezler.
Visual Studio, formlara ait Designer.cs dosyasındaki kodları bir bakıma

tasarım anında yorumlayıp söz konusu form çalışma anında ekrana
geldiğinde nasıl bir görünüme sahip olacağı konusunda programcıyı önceden
yani tasarım anında bilgilendirmektedir.
Formun üzerine nesne yerleştirilmesi veya formun özelliklerinde değişiklik

yapılması halinde Visual Studio tarafından geri planda “Designer.cs”
dosyasında değişiklik yapılır. Başka bir deyişle formların ve formalara
yerleştirilen nesnelerin görsel özellikleriyle ilgili satırlar
“FormAdı.Designer.cs” dosyasında bulunmaktadır. Tabii bu C# derleyicisi
için şart değildir. Çünkü bu ayrım Visual Studio’nun tercihidir.
Projelerdeki her form için “cs”” ve “resx” uzantılı 3 dosya hazırlanmaktadır.

Not Defteri ile CS uzantılı dosyaları açıp inceleyebilir veya değiştirebilirsiniz.
Aşağıda verilen ekran görüntüsünü Form1’e ait CS dosyasını Not Defteri ile
açtıktan sonra aldım.
.NET Framework ile gelen Form sınıfının mirasçısı sınıfları kendiniz kod
yazarak hazırlayabilirsiniz ancak bu durumda Visual Studio penceresi içinde
formların görsel yapısının görüntülenmesinde sorunlar yaşanır.
C# projeleri hard diske “csproj” uzantısı ile kaydedilmektedir. “csproj”

uzantılı proje dosyalarında projedeki form ve class’lar hakkında bilgi
bulunmaktadır. “csproj” uzantılı dosyanın içeriğine bakıp projede kaç form
ve class’ın olduğunu öğrenebilirsiniz.
Đleri ki sayfalarda değinileceği gibi Visual Studio ile yeni bir proje
hazırlandığı zaman ayrıca “sln” uzantılı bir Solution dosyası hazırlanıyor.
Visual Studio ile hazırlanan C# projelerinde yukarıda sözü edilen dosyalara
ek olarak Properties adı altında gruplanan 5 dosya daha bulunmaktadır. Bu
5 dosya sayesinde projenin özellikleri ayarlanmaktadır. Örneğin uygulama
dahilinde kullanılan resim dosyaları Resources.resx dosyasına dahil
edilebilmektedir. Bu 5 dosya projeye ait klasörün içinde Properties
klasöründe saklanmaktadır.
Üzerinde çalıştığınız projenin başka bilgisayarlarda kullanılmak veya

çalıştırılmak üzere alınan/götürülen dosyaların hepsine birden Assembly
denilmektedir. Assembly tek exe dosyadan meydana gelebileceği gibi çok
sayıda resim, text vb. dosyasından da oluşabilir. Assembly hakkındaki
bilgiler Properties klasöründe tutulan AssemblyInfo.cs dosyasında
tutulmaktadır. Bu dosyanın içeriği Project Properties penceresinden
ulaşılan Assembly Information diyalog kutusunda yapılan ayarlardan
etkilenmektedir. Bana sorarsanız henüz yolun başında olanların Assembly
nedir ne işe yarar gibi sorularla ilgilenmelerine gerek yoktur.
Yukarıdaki sayfalarda ekran görüntüsü verilen New Project diyalog

kutusunda değişik amaçlar için kullanabileceğiniz çok sayıda şablon
listelenmektedir. Bu kitapta bu şablonların birkaçından söz edilecektir.
Örneğin Empty Project şablonu herhangi bir forma ve “Program.cs”
dosyasına sahip olmayan bir proje hazırlamaktadır.
Visual Studio veya Express Edition ile hazırlanan projeler hakkında bilgi
sahibi olmanız için New Project diyalog kutusunu ekrana getirip Empty
Project şablonu ile bir proje hazırlayıp kaydettim. Aşağıda verilen ekran
görüntüsünden tespit edeceğiniz gibi Solution Explorer penceresinde
herhangi bir klasör veya dosya listelenmiyor.
Bu şartlarda projenin kaydedildiği klasöre bakacak olursanız sadece solution

ve proje dosyalarının hazırlandığını görebilirsiniz. Daha sonra bu proje için
Main() metodunu içeren "Program.cs" dosyasını ve başlangıç formunu
hazırlayabilirsiniz.
Solution Hazırlamak
Yukarıdaki sayfalarda Solution Explorer penceresiyle ilgili olarak verilen bazı

ekran görüntülerinde Solution varken bazılarında yoktu. Üzerinde çalıştığınız
Solution tek projeden meydana geliyorsa Solution Explorer penceresinde
Solution adının yer almasına gerek duymayabilirsiniz. Bu durumda Tools
menüsündeki Options komutu ile ekrana getirilen diyalog kutusunda
Project and Solutions seçenek grubunda ayarlama yapmalısınız. Bu
diyalog kutusunda Always show solution onay kutusunu pasif duruma
getirirseniz Solution Explorer penceresinde Solution adı listelenmez.
Yukarıda belirtildiği gibi Visual Studio ile yeni bir proje hazırladığınızda
ayrıca bir Solution hazırlanmaktadır. Bu konuda adım adım bilgi vermek
için Visual Studio’nun File menüsünden komut verip New Project diyalog
kutusunu ekrana getirdim.
Visual Studio, projeye verilen adı aynı zamanda Solution adı olarak
kullanmaktadır. Karışıklık olmasın diye proje adı ile Solution adının farklı
olmasını sağladım. Bu şartlarda OK düğmesi tıklanırsa kullandığım
bilgisayardaki “C:\Projeler” klasöründe “Solution1” adında bir klasör
hazırlanıp solution’a ait SLN uzantılı dosya bu klasöre konulur. Ayrıca bu
klasörün içinde proje için “WindowsApplication1” adında bir klasör hazırlanıp
projeye ait dosya ve diğer klasörler bu klasörün içine konulur.
Bildiğiniz gibi New Project diyalog kutusundaki Create directory for

solution onay kutusu seçili değilken solution için ayrı bir klasör
hazırlanmayıp proje ve solution dosyaları bir arada tutulmaktadır. Tekrar
etmek gerekirse Visual Studio ile bir C# projesi hazırladığınızda otomatik
olarak SLN uzantılı bir solution dosyası hazırlanmaktadır. Solution’lar
projeleri gruplamaya yaradıkları için geliştirdiğiniz uygulama birden fazla
projeden meydana gelmeyecekse SLN uzantılı Solution dosyasını
unutabilirsiniz.
Otomatik olarak hazırlanan Solution’u görmek istiyorsanız Solution

Explorer penceresine bakabilirsiniz. Birden fazla proje söz konusu olmadığı
sürece otomatik olarak hazırlanan Solution işlevsel değildir. Başka bir
deyişle aynı anda birden fazla projeyi açmayı düşünmüyorsanız
Solution’larla ilgilenmenize gerek yoktur.
Visual Studio tarafından hazırlanan Solution’a ait kısayol menüsündeki New

Project komutu ile yeni bir projeyi veya Existing Project komutu ile
mevcut projelerden birisini Solution’a dahil edebilirsiniz. Kısayol
menüsünden New Project komutunu verirseniz ekrana Add New Project
diyalog kutusu gelir.
Tahmin edebileceğiniz gibi Solution’larda .Net destekli ve Microsoft ürünü

herhangi bir programlama dili ile hazırlanmış başka projeler olabilmektedir.
Konumuz C# olduğu için Project Types kutusunda Visual C# Projects ve
Templates liste kutusunda ise Windows Application’i seçip OK düğmesini
tıklayınca Solution Explorer penceresi aşağıda verilen şekle dönüştü.
Solution’da birden fazla proje varken bu projelerden birisi aktif projedir.

Aktif projenin adı Solution Explorer penceresinde kalın olarak yazılmaktadır.
Yanda verilen ekran görüntüsünü aldığım sırada “WindowsApplication1” adlı
proje aktifti. Diğer projeyi aktif proje yapmak istiyorsanız o projeye ait
kısayol menüsünden Set as StartUp Project komutunu vermelisiniz.
Solution’daki projelerden birisini çıkarmak istiyorsanız o projeye ait kısayol
menüsünden Remove komutunu verebilirsiniz.
Yukarıda otomatik olarak hazırlanan Solution’a sonradan 2. bir projeyi dahil

ettim. Ancak işe boş bir Solution hazırlamakla başlayabilirsiniz. Đçeriği boş
solution hazırlamak istiyorsanız New Project diyalog kutusundaki Blank
Solution şablonundan yararlanabilirsiniz.
Herhangi bir proje içermeyen yeni bir Solution hazırlamak için Project
Types liste kutusunda Visual Studio Solutions ve Templates kutusunda
ise Blank Solution şablonunu seçip solution için klasör seçip OK düğmesini
tıklarsanız aşağıdaki gibi Visual Studio penceresi ile karşılaşırsınız. Bu sırada
Solution’a dahil edilmiş olan herhangi bir proje olmadığı için Solution
Explorer penceresinde yalnızca Solution adı listelenir.
Bu sırada mevcut projelerden birisini Solution’a dahil edebilir veya Solution

için yeni bir proje hazırlayabilirsiniz. Bu işlemler için Solution Explorer
penceresinde Solution’a ait kısayol menüsünden New Project veya
Existing Project komutlarından birisini verebilirsiniz. Herhangi bir zamanda
SLN uzantılı Solution dosyasını açmanız halinde Solution’a dahil edilmiş olan
bütün projeler açılır.
Projeleri Çalıştırmak Ve Derlemek
Şimdi sırada yukarıdaki sayfalarda anlatılan şekilde hazırlanan projeleri

çalıştırmak, test etmek ve derlemek var. Bu düşünce ile New Project
diyalog kutusunu ekrana getirip Windows Forms Application şablonu ile
“Proje1” adında bir proje hazırlayıp bu projeyi “C:” sürücüsünde “\Proje1”

klasörüne kaydettim. Projeyi kaydettiğim klasörü özellikle işaret ettim.
Çünkü proje çalıştırıldığında veya derlendiğinde geri planda Visual Studio
tarafından hazırlanan dosyalardan söz etmek istiyorum.
Ayrıca New Project diyalog kutusunda Create directory for solution onay
kutusu pasif duruma getirip proje hazırlanırken otomatik olarak hazırlanan
Solution’la ilgili dosyanın ayrı bir klasöre konulmasını engelledim. Program
geliştirme aracı yani IDE olarak Visual Studio yerine C# için hazırlanmış
Express Edition’ı kullananlar için şunu söylemek isterim: Projeleri
çalıştırmak bağlamında Visual Studio ile Express Edition birbirinden pek
farklı değildir.
Şimdi hazırladığım projede herhangi bir değişiklik yapmadan, başlangıç

formuna kontrol yerleştirmeden ve başka bir Class hazırlamadan
çalıştıracağım. Projeleri çalıştırmak, başka bir deyişle projeyi test edip hata
içerip içermediğini kontrol etmek için genellikle Debug menüsündeki Start
Debugging komutu kullanılmaktadır. Genellikle dedim; çünkü projeleri
çalıştırmanın başka yöntemleri de vardır.
Çalışır durumdaki projeye ait ilk formu Kapat düğmesi ile kapatıp projenin
çalışmasını sona erdirip tasarım moduna geçebilirsiniz. Projenin çalışmasını
sona erdirip Design moduna geçilirse Visual Studio’nun Toolbox ve
Properties gibi pencereler tekrar görüntülenir.
Visual Studio ile hazırlanan C# projeleri Debug menüsünden komut

verilerek çalıştırıldıkları, başka bir deyişle test edildikleri zaman Visual
Studio tarafından otomatik olarak EXE dosya hazırlanmaktadır. Proje
çalıştırıldığında hazırlanan EXE dosyanın yerini aşağıda görebilirsiniz. Bu EXE

dosya ancak proje hazırlanırken tercih edilen .NET Framework
sürümünün(2.0, 3.0 veya 3.5) kurulu olduğu bilgisayarda çalışabilir.
Aşağıda ekran görüntüsü verilen dosya listesindeki “pdb” uzantılı dosyaya
dikkatinizi çekmek istiyorum. Kodun debug edilmesi yani hatalardan
ayıklanması işlemiyle ilgili bilgiler bu dosyaya yazılmaktadır. Tabii bu
bölümde hata ayıklama işlemleri üzerinde durmayacağımız için “pdb”
uzantılı dosyanın işlevinden söz edilmeyecektir.
Yukarıda söylendiği gibi Visual Studio ile hazırladığınız C# projesini çalıştırıp

test etmek için Debug menüsünden Start Debugging komutunu verebilir
veya direk F5 tuşuna basabilirsiniz. Aslında Debug menüsünden bu komutu
vermekle Visual Studio’ya bir bakıma “hazırladığım projeyi entegre hata
ayıklayıcının nezaretinde test etmek istiyorum ve varsa hatalarından
ayıklamak istiyorum” demiş oluyorsunuz. Üzerinde çalıştığınız projeyi
Ctrl+F5 tuşları ile çalıştırırsanız projeyi entegre Debugger’dan bağımsız
çalıştırmış olursunuz.
En başında belirtmek gerekir ki Start Debugging komutu verildiği zaman

proje için otomatik olarak hazırlanan EXE dosya başkalarına verilecek, başla
bir deyişle projeden yararlanacaklara verilecek EXE kopya değildir. Elbette
Start Debugging komutu sayesinde otomatik olarak hazırlanıp projeye ait
klasörün içinde yer alan “\Bin\Debug” klasörüne yerleştirilen EXE dosyayı
alıp başka bilgisayarda çalıştırmak mümkündür. Ancak debug modunda iken
hazırlanan EXE dosyanın dağıtılması önerilmiyor.
Şimdi gelelim şu Debug moduna. Programcılar genelde uygulamalarını

geliştirmeyi ve test etmeyi Debug modunda yaparlar. Ne zaman ki
uygulama tamamlanıp testlerden geçer o zaman Release sürümü hazırlayıp
kullanıcılara öyle verirler. Yukarıdaki sayfalarda işaret edildiği gibi Visual
Studio ile yeni C# projesi hazırlanıp kaydedildiği zaman projeye ait klasörün
içinde “Bin” ve “Obj” adında 2 klasör hazırlanmaktadır.
Derleme sırasında hazırlanan geçici dosyalar “Obj” klasörüne konulmaktadır.

Obj klasörünün altında “Debug” ve “Release” adında 2 klasör
hazırlanmaktadır. Aynı şekilde “Bin” klasörünün içinde yine “Debug” ve
“Release” adında 2 klasör hazırlanmaktadır. Uygulamanın Debug sürümü
Bin klasörünün içinde bulunan \Bin\Debug klasörüne konulurken Release
sürümü \Bin\Release klasörüne yerleştirilmektedir.
Yukarıda belirtildiği gibi Visual Studio ile bir Windows Forms Application
hazırlayıp bu uygulamayı kaydedip sonrada Debug menüsünden Start
Debugging komutunu verdiğinizde Visual Studio söz konusu uygulamayı
önce derlemektedir. Tabi Visual Studio bu işlemi yaparken .NET Framework
ile gelen C# derleyicisini kullanmaktadır. Derleme işlemi sırasında
hazırlanan dosyalar \uygulama\obj\Debug klasörüne yerleştirilmektedir.
Start Debugging komutu verildiği zaman Visual Studio derleme yapıp bu

dosyaları hazırladıktan sonra ayrıca “uygulama\Bin\Debug” klasörüne kodun
EXE’sini ve birkaç dosya daha yerleştirilip bu EXE dosya çalıştırılmaktadır.
Hazırladığınız proje veya Solution’ı çalıştırıp test etmek yerine derlemek

istiyorsanız Build menüsündeki komutlardan yararlanmanız gerekir. Build
menüsünde gerçekte aşağıda verilen ekran görüntüsündekinden daha fazla
komut bulunmaktadır. Başlangıçta Solution’ların derlemesiyle ilgili komutlar
Build menüsünde yer almıyor. Eğer birden fazla projeyi bir Solution’da
topluyorsanız Tools menüsünden komut verip ekrana Options diyalog
kutusunu getirip Project And Solutions sekmesinde ayarlama
yapabilirsiniz.
Bu menüdeki komutların adlarına üzerinde çalışılan projenin adı

eklenmektedir. Bu sırada üzerinde çalıştığım projenin Proje1’di. Üzerinde
çalıştığınız projeyi derlemek üzere Build menüsünden Build komutunu
verirseniz Visual Studio projenizi derler. Derleme sırasında önce Uygulama
adı\obj\Debug klasörüne bazı dosyalar yerleştirilir.
Derleme işleminin ikinci aşamasında birisi EXE olmak üzere birkaç dosya
hazırlanıp “Uygulama adı\Bin\Debug” klasörüne yerleştirilir. EXE dosyayı çift
tıklayıp veya Başlat menüsünden Çalıştır komutunu verip projenizi
çalıştırabilirsiniz. Tabii profesyonel programcılar projeleri için kurma CD’si
hazırlayıp uygulamalarını öyle dağıtırlar. Kurma CD’sini Visual Studio ile
gelen Setup Wizard’dan yararlanarak hazırlayabilirsiniz.
Derleme sonucu hazırlanıp “\Obj\Debug” ve “\Bin\Debug” klasörlerine

yerleştirilen dosyaları silmek istiyorsanız Build menüsünden Clean
komutunu vermelisiniz. Daha önce derlediğiniz projeyi Build komutu ile
tekrar derlediğinizde projenin yalnızca değişen kısımları gözetilir. Rebuild
komutu ise projeyi sanki ilk kez derleniyormuş gibi yeni baştan derler.
Debug modundan Release moduna geçmek istiyorsanız Visual Studio’nun

Debug menüsünden komut verip Cunfiguration Manager diyalog
kutusunu ekrana getirmelisiniz. Başlangıçta bu komut Debug menüsünde
yer almıyor ve bu nedenle Tools menüsündeki Options komutu ile ekrana
getirilen diyalog kutusunda ayarlama yapmak gerekmektedir.
Options diyalog kutusunda Project and Solution seçenek grubundaki

Show advanced build configurations onay kutusunu seçmelisiniz. Bu
ayarlamayı yapıp Debug menüsünde Cunfiguration Manager komutunun
yer almasını sağlayıp bu komutu verdiğinizde akrana aşağıda verilen diyalog
kutusu gelir.
Bu ekran görüntüsünü aldığım sırada üzerinde çalıştığım projenin dahil

olduğu Solution bir tek projeye sahipti. Bu sırada Solution’da birden fazla
proje olsaydı bu projeler de listelenirdi. Bu diyalog kutusundaki Active
Solution configuration ve Active solution platform liste kutularında
yapılan seçimlerden bütün projeler etkilenmektedir.
Active Solution configuration liste kutusunu açıp Release’i seçerseniz

Debug modundan Release moduna geçmiş olursunuz. Bu andan itibaren
Debug menüsünden Start Debugging komutunu verip projeyi çalıştırırsanız
EXE kodun Release sürümü hazırlanır ve bu EXE dosya “\Bin\Release”
klasörüne yerleştirilir. Bu sırada yani Release modunda iken Build
menüsünden Clean… komutunu verirseniz “\Obj\Release” ve “\Bin\Release”
klasörlerine yerleştirilmiş dosyalar silinir.
Debug modunda iken Build menüsünden Build… veya Rebuild… komutu

verilerek derleme yapıldığında derleme sonucu hazırlanan dosyalar yine
“\Obj\Release” ve “\Bin\Release” klasörlerine yerleştirilmektedir. Hangi
modda olduğunuzu öğrenirken Project Properties penceresinden
yararlanabilirsiniz.
Bu dersi baştan sonra inceleyenlerin tespit etmiş olabileceği gibi bazı küçük
ayrıntılar hariç burada anlatılan işlemlerin hemen hepsini başka kaynaklarda
bulmak mümkündür. Hatta daha önce eski Visual Basic ve Delphi IDE’sini az
çok kullanmış olanların kaynak karıştırmalarına bile gerek kalmadan bu
metinde anlatılanları kendilerinin zaten biliyor olmaları uzak bir ihtimal
değildir. Buna rağmen yarın bir gün sırf bu metni kaleme aldım diye
yargılanmamak, sanık pozisyonunda hakim karşısına çıkmamak için ek
açıklama yapma gereğini duyuyorum: Ey yetkililer, ey yerli programcılık
kitabı yazarları; 1994 yılından bu yana Microsoft’un IDE’lerini kullanan
programlama dilleri üzerine çok sayıda kitap yazmış birisi olarak yukarıdaki
sayfalarda yazdıklarımı gidip bozuk cümlelerle dolu yerli programcılık
kitaplarından öğrenmemin bir mantığı var mıdır? Yani yukarıda verilen
bilgilerin daha önce yayınlana bazı programcılık kitaplarında yer alıyor
olması bence Visual Studio’nun suçudur. Keşke Visual Studio “at sahibine
göre kişner” atasözünü kendisine rehber edip yazarına ve programcısına
göre çalışsa, yazarına göre işlem yapsa…
BÖLÜM 6
WINDOWS FORMS UYGULAMALARI
Daha önceki derslerde önde C# için hazırlanmış Express Edition sonra da Visual
Studio hakkında ön bilgi verdik. Bu derste ise Express Edition ile Windows Forms
hazırlayacağız. Bu derste yazılanlar itibarı ile Express Edition kullanmak ile Visual
Studio kullanmak arasında pek bir fark yoktur. Başka bir deyişle bilgisayarlarına
Visual Studio kurmuş olanlar bu derste yazılanları zorluk çekmeden uygulayabilirler.
Đlk derslerinde konsol uygulaması hazırlamamızın nedeni C# uygulamaları hakkında

adım adım bilgi vermekti. Yoksa konsol uygulamalarına çok özel durumlarda ihtiyaç
duyulmaktadır. Bu nedenle bundan sonra Windows Forms denilen normal
uygulamalara odaklanacağız. Bu nedenle Express Edition’ı başlatıp File menüsünden
komut verip New Project diyalog kutusunu ekrana getirip Windows Application
şablonunu seçtim.
C# için hazırlanan Express Edition ile hazırlanan projelerde New Project diyalog
kutusunda projeye verilen ad sonradan değiştirilebilmektedir. Projeye vermek
istediğim adı Name kutusuna yazıp OK düğmesini tıklayınca aşağıdaki gibi bir
Visual C# 2008 Express Edition penceresi ile karşılaştım.
Windows Application şablonu ile hazırlanan projeye bir form dahil

edilmekte ve bu formun görsel yapısı Express Edition penceresine
getirilmektedir. Bu formun üzerine hemen düğmeler, TextBox’lar ve
ListBox’lar yerleştirmek yerine Windows Forms Application şablonu ile
hazırlanan projenin özelliklerine bir bakalım. Bu amaçla Solution Explorer
penceresini açtım.
Express Edition ile C# projesi hazırlandığı zaman çok kullanılan bazı sınıfları
içeren referanslar yani DLL dosyaları projeye dahil edilmektedir. Daha
doğrusu Express Edition’a bazı referanslardaki sınıflardan yararlanılmak
istendiği söylenmektedir. Hatırlarsanız yukarıdaki sayfalarda konsol
uygulaması dahilinde ekrana form veya pencere getirmek için
System.Windows.Forms’deki Form adlı sınıftan yararlanmıştık.
Üzerinde çalışılan projede .NET Framework ile gelen sınıflardan birisinden

yararlanmak için o sınıfın yer aldığı namespace’i içeren DLL dosyasının veya
referansın Solution Explorer penceresinde listelenmesi gerektiği için Solution
Explorer penceresinden yararlanıp Add Reference diyalog kutusunu ekrana
getirmiştik. Benzer durum Express Edition ile hazırlanan Windows Forms
uygulamaları için de geçerlidir. Express Edition en çok gerek duyulan
referansları kendiliğinden Solution Explorer penceresinde listelemektedir.
Üzerinde çalışılan proje hakkında bilgi edinilmek istendiği zaman başvurulan

Solution Explorer penceresine dikkatlice bakarsanız projedeki formla ilgili
olarak 3 dosyanın hazırlanmış olduğunu görürsünüz. Burada dikkatinizi
öncelikle “Program.cs” dosyasına çekmek istiyorum. Yukarıdaki sayfalarda
işaret edildiği C# projelerinin başlangıç noktası Main() metodudur. Express
Edition veya Visual Studio ile hazırlanan projelerde Main() metodu
“Program.cs” adlı kod dosyasına konulduğu için bu dosya önemlidir.
Solution Explorer penceresinde “Program.cs” dosyasını çift tıklarsanız bu

kod dosyasının içeriği görüntülenir. Hemen belirtmek gerekir ki Main()
metodunun Program.cs dosyasında olması şart değildir. Microsoft firması
Main() metodunun “Program.cs” dosyasında olmasını tercih ettiği için bu
tercihe bağlı kalmanız önerilir.
Express Edition tarafından hazırlanan bu kodu dikkatlice incelerseniz

System, System.Collections.Generic, System.Windows.Forms gibi
namespace’lerdeki sınıfları direk kullanabilmeniz, yani sınıf adından önce

namespace adını yazmak zorunda kalmamanız için using deyimi ile
ayarlama yapılmış olduğunu görürsünüz. “Program.cs” dosyasındaki Main()
metodundaki son satırı yukarıdaki sayfalarda görmüştük.
Windows Forms uygulamalarında System.Windows.Forms’deki sınıfları direk

kullanabilmeniz için Express Edition tarafından using deyimi ile ayarlama
yapıldığı için sınıf adından önce namespace adı yazılmamış. Bu satırı daha
önce görmüş olanlar şöyle bir açıklamayı okumuş olabilirler: “Uygulama
Run() metodu ile başlatılmaktadır”. Aslında bu tek cümlelik tanım yanlış
değildir. Ne var ki bu tanım bu satırla nelerin yapıldığını, geri planda nelerin
geliştiğini açıklamaya yetmiyor.
Konunun devamında anlatılacağı gibi Express Edition ile Windows Forms

uygulaması hazırlandığında System.Windows.Forms adlı namespace’teki
Form adlı Class’ın mirasçısı “Form1” adında bir Class hazırlanmaktadır. Đşte
bu satırda “Form1” adlı Class’ın örneği alınıp Application sınıfının Run()
metoduna parametre olarak verilmektedir. Konu üzerinde düşünmenizi
sağlamak için Windows Forms uygulamasının “Program.cs” dosyasındaki
Main() metodunu aşağıdaki gibi düzenledim.
static void Main()

{
string mesaj = "Proje başlatıldı, Form1 ekrana getirilecek";
MessageBox.Show(mesaj);
}
Express Edition tarafından hazırlanan Main() metodundan sildiğim 2 satır

mutlaka gerekli olan satırlar değildir. Kod kısalsın diye sildim. Main()
metodunun bu halinde önce string tipte bir değişken tanımlayıp bilgi
aktardım. Değişken tanımlama ile tanımlanan değişkene bilgi aktarma
işlemini ayrı satırlarda yapabilirdim. Đleri de yerli bir yazarın “Memik Yanık
değişkenimizin adını çalmış” suçlamasından kendimi kurtarmak için bu kodu
bir de aşağıdaki gibi düzenledim.
static void Main()

{
string msg = "Proje başlatıldı, Form1 ekrana getirilecek";
MessageBox.Show(msg);
}
Bu şekilde String tipteki değişkeni tanımlayıp bilgi aktardıktan sonra .NET

Framework ile gelen MessageBox sınıfının Show() metodu ile bu
değişkenin içeriğini bir diyalog kutusu içinde ekrana getirdim. Dolayısıyla
Main() metodu bu şekilde düzenlenen proje çalıştırıldığı zaman ekrana önce
aşağıdaki gibi bir diyalog kutusu gelir.
Bu diyalog kutusu kapatıldığında ise sıra Application sınıfının Run()

metodunun kullanıldığı satıra gelir ve ekrana projenin formu gelir. Run()
metodunun kullanıldığı satırı incelerseniz Form1 sınıfının örneğinin new
anahtar kelimesi kullanılarak parantezlerin içine alındığını görürsünüz. Bir
sınıfın örneğini alma yani nesne hazırlama işleminin anlaşılmasına katkı
olması için bu projenin Main() metodunu aşağıdaki gibi düzenledim.
static void Main()

{
string msg = "Proje başlatıldı, Form1 ekrana getirilecek";
MessageBox.Show(msg);
Form1 Baslangic_formu;
Baslangic_formu = new Form1();
Baslangic_formu.Text = "İlk Form";
Application.Run(Baslangic_formu);
}
Şimdi gelin bu 6 satırlık kodu yorumlayalım. Express Edition veya Visual

Studio ile Windows Forms uygulaması hazırlandığı zaman .NET Framework
ile gelen ve System.Windows.Forms’de yer alan “Form” sınıfının mirasçısı
“Form1” adında bir sınıf hazırlanmakta ve bu sınıfla ilgili “Form1.cs” ve
“Form1.Designer.cs” adında 2 kod dosyası hazırlanmaktadır. Burada yani bu
Main() metodunda yaptığım, önce Express Edition tarafından Windows
Forms uygulaması için otomatik olarak hazırlanan Form1 tipinde(sınıf) bir
değişken tanımlamak, sonra bu sınıfın örneğini new anahtar kelimesi ile
hazırlayıp(nesne hazırlamak) tanımladığım değişkene aktarmaktır. En son
satırda ise Form1 tipindeki nesneyi Application sınıfının Run() metoduna
parametre olarak verdim. Ne zaman ki Application sınıfının Run() metoduna
parametre olarak verilen form kapatılır o zaman projenin çalışması sona
ermiş olur.
Formlar Đçin Hazırlanan Kodlar
Express Edition veya Visual Studio ile yeni bir proje hazırlandığında projeye
“Form1” adında bir formun dahil edildiğini biliyorsunuz. Formu oluşturan
kodları görüntülemek için Solution Explorer penceresinde söz konusu form
seçili iken View menüsünden Code komutunu verebilirsiniz. Aşağıdaki
ekran görüntüsünü incelediğinizde projedeki her form için hazırlanan CS
dosyalarının ilkinde en başta kullanılması muhtemel sınıfların yer aldığı
namespace’ler işaret edilmektedir. Ardından form ile aynı ada sahip bir
Class hazırlanmaktadır.
Bu class System.Windows.Forms adlı namespace’teki Form adlı Class’ın

mirasçısı olduğu için çok sayıda özellik ve metoda sahip olur. Bu koda dikkat
ederseniz önce namespace bloğu bulunmaktadır ve projenin adı namespace
adı olarak kullanılmaktadır. Devamında public ve partial olarak işaret
edilen class bloğu gelmektedir. Hazırlanan Class’a Form1 adı verilmiş.
Hazırlanmak istenen Class’ın adından sonra mirasçı(bu sınıfa bazı

programcılar ana sınıf-base class diyorlar) pozisyonundaki “Form” sınıfının
adı yazılmış. Hazırlanmak istenen Class ile mirasçı Class’ın adını birbirinden
ayırmak için “:” kullanılmaktadır. Form sınıfı System.Windows.Forms’de 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ı yazılmaya 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 adı verilmektedir.
Form1 adı verilen Class’ın yapıcı metodunda yalnızca
InitializeComponent() metodu işletilmektedir. Form1 sınıfıyla ilgili
InitializeComponent metodu “Form1.Designer.cs” adlı ikinci kod

dosyasında yer almaktadır.
Formların ve formların üzerine yerleştirilen nesnelerin özellikleri

Form1.Designer.cs dosyasında ayarlanmaktadır. Designer.cs dosyasında
da “Form1” adında bir Class bulunmaktadır. Başka bir deyişle “Form1” adlı
Class’ın bir kısmı Form1.cs’de diğer kısmı “Form1.Designer.cs” dosyasında
bulunmaktadır.
7
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.
“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, sınıfla ilgili olarak hazırlanan nesnelerin
zamanı gelince bellekten silmesiyle ilgilidir.
Şimdi “Form1” için Visual Studio tarafından hazırlanan satırları ve bu
satırlarda kullanılan metot ve anahtar kelimelerin bazılarından söz
edeceğim. Visual Studio her form için Form1.Designer.cs dosyasında
yukarıda verilen satırlardan daha fazlasını hazırlamaktadır. Tasarım anında
Properties penceresinde yapılan değişiklilere 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. Aşağıda verilen
kodda bu bölgeye yazılan satırları görebilirsiniz.
namespace Project1
{
partial class Form1
{
private System.ComponentModel.IContainer components=null;
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.Text = "Form1";
}
}
}
IntializeComponent() metodundaki satırlar Toolbox’tan yararlanılarak

formun üzerine yerleştirilen nesnelere göre artabilmektedir. Bu sırada
Toolbox’tan yararlanıp forma nesne 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.
Formlara Nesne Yerleştirmek
Yukarıdaki sayfalarda Express Edition veya Visual Studio ile hazırlanan C#

projeleri hakkında biraz bilgi sahibi olduktan sonra şimdi sırada forma
button nesnesi yani düğme yerleştirmek var. Tabii bazılarınız hemen bunu
bilmeyecek ne var diye sorabilirler. Siz yine de okumaya devam edin.
Formlara nesne yerleştirip bunlar için kod yazabilmek için yeni bir proje
hazırladım ve projenin ilk(aynı zamanda başlangıç) formuna button nesnesi
yerleştirebilmek için Toolbox’ı açtım.
Toolbox’ta listelenen seçeneklere Component adı verilmektedir. Bu

seçeneklere kontrol da denilebilir. Bu kontroller gerçekte .NET Framework
ile birlikte gelen birer Class’tır. Express Edition formlara yerleştirilebilinen
class’ların örneklerini alıp kullanmanız konusunda size yardımcı olmaktadır.
Daha açık bir anlatımla Toolbox’tan Button adlı kontrolü seçip formu
tıklarsanız Button sınıfından yola çıkıp “button1” adında bir nesne hazırlamış
olursunuz.
Forma bu şekilde button1 adında bir Button nesnesi yerleştirince Express

Edition bizim için gidip bu formun “Form1.Designer.cs” adlı kod dosyasına
bazı satırlar ekledi. Bu satırların sayesinde button1 nesnesi formun üzerinde
görünmeye başladı. Başka bir anlatımla, forma Button nesnesi
yerleştirmekle biz gerçekte Express Edition’a diyoruz ki “formun üzerinde şu
özelliklere sahip bir düğmenin olması için git Form1.Designer.cs dosyasında
bazı ayarlamalar yap, button nesnesi hazırlayan satırlar ekle”.
Şimdi gidip bakalım Express Edition bizim için projedeki ilk formun
Form1.Designer.cs dosyasına neler yazmış? Form1.Designer.cs dosyasında
aşağıda verilen ekran görüntüsünde görülenlerden daha fazla satır olmasına
rağmen ekran görüntüsü küçük olsun diye yalnızca button1 nesnesiyle ilgili
satırların görünmesine izin verdim.
Toolbox’tan yararlanıp forma button nesnesi yerleştirildiği zaman Express

Edition(aynı şeyler Visual Studio içinde söylenebilir) ilk olarak “button1”
adında ve System.Windows.Forms.Button tipinde bir değişken
tanımlıyor. Bu sırada forma 2. bir button nesnesi yerleştirmeniz halinde
Express Edition buna button2 adını verir. Tabi forma yerleştirmiş olduğunuz
nesnelere sonradan istediğiniz adı verebilirsiniz. Siz siz olun bu nesnelere
“aktar” gibi yerli yazarlar tarafından sık kullanılan adlar vermeyin.
Bakarsınız yarın bir gün yerli yazarın birisi düğme adımı çalmışsınız diye
sizden şikayetçi olur. Bu nedenle düğmelere argo isimler vermeniz önerilir.
Express Edition veya Visual Studio, System.Windows.Forms.Button

tipindeki değişkeni tanımladıktan sonra form için daha önce hazırlanan
InitializeComponent() adlı metotta önce new anahtar kelimesi ile button
nesnesi hazırlıyor. Devamında bu nesnenin Name, Location, Size, Text
gibi birkaç özelliğini ayarlıyor. Bu sırada Form1.Designer.cs dosyasından
button nesnesi ile ilgili satırları silerseniz button nesnesini formun üzerinden
kaldırmış olursunuz. Çünkü formun üzerinde button nesnesinin olmasına
neden olan satırlar bunlardır. Bu satırlarla oynayıp button nesnesinin
özelliklerinde değişiklik yapabilirsiniz. Formların ve forma yerleştirilen
nesnelerin özelliklerini fare ile ayarlamak daha kolay olduğu için
programcılar çok gerekmedikçe nesnelerin özelliklerini ayarlamak için
Designer.cs dosyasına başvurmazlar.
Forma düğme yerleştirmenin geri planında nelerin olduğu konusunda biraz

bilgi sahibi olduktan sonra şimdi button1 adlı düğmenin başlık metnini yani
Text özelliğini değiştireceğim. Bu amaçla Form1.cs(Design) sekmesini
tıklayıp Express Edition penceresi içinde Form1.Designer.cs adlı kod dosyası
yerine Form1’in görsel yapısının görüntülenmesini sağladım.
Formların ve forma yerleştirilen nesnelerin özelliklerini ayarlarken

Properties penceresinden yararlanılmaktadır. Properties penceresini
görüntülemek için View menüsünden komut vermek gerekmektedir. Aşağıda
verdiğim ekran görüntüsünü “button1” nesnesinin Text özelliğini
değiştirdikten sonra aldım. Aslında button1 adlı nesnenin Text özelliğini bu
şekilde değiştirmekle risk almış oldum. Çünkü yarın bir gün yerli bir yazar
ortaya çıkıp “Göster’i benim kitaptan çalmışsın” diye beni dava edebilir.
Properties penceresinde button1 adlı nesnenin Text özelliğinde değişiklik

yapılırsa Express Edition bu değişikliği anında Form1.Designer.cs dosyasına
yansıtır. Bu button nesnesinin adını değiştirmek istemiş olsaydım Properties
penceresinde Name özelliğinde değişiklik yapardım.
Şimdi öyle bir ayarlama yapacağım ki kullanıcı çalışma anında Form1’deki

düğmeyi tıkladığı zaman bir diyalog kutusu içinde kullanıcıya mesaj
verilmesini sağlayacağım. Bu işlem için yerli yabancı diğer kitapların aksine
size hemen button1’in üzerinde çift tıklama yapın sonra da şu satırı yazın
demeyeceğim.
Đşin özünü anlatmak için Form1’in görsel yapısı görüntülenirken View

menüsünden Code komutunu verip Form1’e ait “Form1.cs” adlı kod
dosyasının görüntülenmesini sağladım. Ekran görüntüsü küçük olsun diye
using bloğundan şu anda gerekli olmayan bazı satırları sildim.
Kafanızın karışmaması için baştan alayım: Express Edition veya Visual

Studio ile Windows Forms uygulaması hazırlanıp uygulamaya dahil edilen
her form için 2 kod dosyası hazırlanmaktadır. Form1.cs dosyasında
programcının yazdığı kodlar yer alırken formun görsel yapısı ile ilgili satırlar
Form1.Designer.cs dosyasında yer olmaktadır. Derleme sırasında bu 2
dosya bir araya getirilmektedir.
Bu şekilde bir sınıfa ait kodların birden fazla kod dosyası arasında
paylaşılmasına Partial Class(parçalı sınıf) denilmektedir. Form1.cs
dosyasına dikkatli baktığınızda InitializeComponent() metodunun
işletildiğini görebilirsiniz. Bu metodun yani InitializeComponent
metodunun Form1.Designer.cs dosyasında olduğunu biliyorsunuz.
Şimdi Form1.cs dosyasındaki Form1 sınıfının sınırları içinde button1 nesnesi

tıklandığında işletilmek üzere bir metot hazırlayacağım. Hazırladığım metot
Object ve EventArgs tipinde 2 parametreye sahiptir. Çünkü herhangi bir
button nesnesinin Click olayını ancak Object ve EventArgs tipinde 2
parametreye sahip metotlar temsil edebilmektedir.
public partial class Form1 : Form

{
public Form1()
{
InitializeComponent();
}
private void ilk_button_Click(object sender, EventArgs e)
{
MessageBox.Show(“Düğmeyi tıkladınız”);
}
}
Kendi hazırladığım metoda ilk_button_Click() adını verdim. Doğrusu,

metoda, ilgili nesnenin adını çağrıştıracak bir adın verilmesidir. Çalışma
anında projenin formundaki düğme tıklansa bile bu metot işletilmez. Bizim
yapmamız gereken button1 nesnesinin Click olayı ile, bu metodu
ilişkilendirmek olmalıdır. Bu ilişkilendirmeyi yapmaya en uygun yer
Form1.Designer.cs dosyasındaki InitializeComponent() metodudur. Bu
metodun içine yazdığım satırı aşağıda görebilirsiniz.
Bu satırda eşitliğin sol tarafındaki “button1” düğmenin adıdır. Eşitliğin sol

tarafındaki Click ise button1 nesnesinin tıklama olayını işaret etmektedir.
Tabii bu satırdaki “this” gözünüzden kaçmamıştır: this, kendisi için metot
yazılan “Form1” sınıfını temsil etmektedir. Eşitliğin sağ tarafında ise
parantezin içine yazılanın Form1.cs adlı kod dosyasında hazırladığım
metodun adı olduğunu söylemekle yetineceğim.
Bu ayarlamadan sonra çalışma anında ne zaman Form1’deki düğme

tıklanırsa Form1.cs’deki ilk_button_Click() metodu işletilir. Dikkat
ettiyseniz yukarıda Form1’deki düğme için metot hazırlama ve bu metodu
Click olayı ile ilişkilendirme konusunda Express Edition’dan yararlanmadım.
Şimdi hem Form1.cs dosyasındaki metodu hem de Form1.Designer.cs

dosyasına yazıp yukarıda işaret ettiğim satırı sileceğim. Ardından metot
hazırlama ve bu metodu Click olayı ile ilişkilendirme işlemini yaparken
Express Edition’dan yararlanacağım. Tasarım anında forma yerleştirdiğiniz
button nesnesini çift tıklamanız halinde Express Edition sizin için hem bir
metot hazırlar hem de yukarıda verilen satırın benzerini hazırlayıp
Form1.Designer.cs dosyasındaki InitializeComponent() metoduna ekler.
Aşağıda verdiğim ekran görüntüsünü yukarıda kendi hazırladığım metodu
silip tasarım anında “button1” nesnesini çift tıkladıktan sonra aldım.
Bu metot button1 nesnesinin Click olayını temsil etmesi için hazırlandığı için
Express Edition metoda ad seçerken nesnenin ve olayın adını kullandı. Tabii
bu şart değildir. Anlatılan şekilde hazırladığınız metoda istediğiniz adı
verebilirsiniz.
Bu andan itibaren çalışma anında Form1’e yerleştirdiğim düğme çalışma

anında tıklandığında bu metot işletilir. Tabi bu metot henüz işletilebilir
herhangi bir satır içermediği için çalışma anında düğme tıklanıp Click
olayının meydana gelmesi sağlansa bile tepki vermez.
Tahmin edeceğiniz gibi tasarım anında formdaki düğme çift tıklandığında bu

metodun hazırlanmasından başka Form1.Designer.cs dosyasında bulunan
InitializeComponent() metoduna yukarıda verdiğim satır eklenerek bu
metot ile button1 nesnesinin Click olayı ilişkilendirildi.
Forma yerleştirilen button ve diğer nesnelerin ilgili olayıyla metotların ilişkisi

istenirse Properties penceresinde kurulabilir. Aşağıda verdiğim ekran
görüntüsünü aldığım sırada Properties penceresinde button1 nesnesinin
özellikleri listeleniyordu.
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ünü button1 nesnesinin özellikleri
listelenirken Events düğmesini tıkladıktan sonra aldım.
Bu button nesnesinin Click olayı Express Edition(veya Visual Studio)

tarafından daha önceden Form1.cs dosyasındaki button1_Click()
metoduyla ilişkilendirildiği için Click olayının karşısında bu metodun adı
yazılıdır. Bu sırada Click olayının karşısındaki metodun adını silerseniz
Express Edition gider Form1.Desing.cs dosyadaki metot ile olayı
ilişkilendiren satırı siler.
Konu üzerinde düşünmenizi sağlamak için forma button2 adında 2. bir

düğme yerleştirip Properties penceresinden yararlanıp bu düğmenin Click
olayına button1_Click adını vermiş olduğum metodun adını aktardım.
Bu şartlarda çalışma anında formdaki 2. düğme tıklandığında Express

Edition’den yararlanıp button1 için hazırlayıp button1_Click() adını verdiğim
metot işletilir. Bu şartlarda button1_Click() metodu ile, hem button1’in hem
de button2’nin Click olayı ilişkilendirildiği için çalışma anında ister button1
ister button2 tıklansın aynı metot işletilir. Hem button1 hem de button2 için
Properties penceresinde Click olayı için aynı metodu seçmenin etkisiyle
Form1.Designer.cs dosyasına aşağıda verdiğim 2 satır eklenir.
this.button1.Click += new System.EventHandler(this.button1_Click);

this.button2.Click += new System.EventHandler(this.button1_Click);
Şimdi ise forma bir TextBox yerleştireceğim. Öncelikle forma daha önce
yerleştirdiğim button1 ve button2 adlı düğmeleri sileceğim. Forma
yerleştirdiğiniz düğmeleri seçip Delete tuşuna basarsanız Express Edition
gider Form1.Designer.cs dosyasında bu düğmelerle ilgili ne var ne yok her
şeyi siler. Ancak tasarım anında düğmeyi çift tıklayarak veya kendi
hazırladığınız bir metot varsa Form1.cs dosyasından silinmez. Söz konusu
metoda gerek duymuyorsanız kendiniz silebilirsiniz.
Forma yerleştirmiş olduğunuz TextBox’ı tasarım anında çift tıklarsanız

Express Edition TextBox’ın TextChanged olayı için metot hazırlamak
istediğinizi varsaymaktadır. Bu nedenle TextBox’ı çift tıklarsanız hem
Form1.cs dosyasının içeriği görüntülenir hem de aşağıdaki gibi bir metot
hazırlanır.

{
public Form1()
{
}
private void textBox1_TextChanged(object sender, EventArgs e)
{
}
}
Bu metot çalışma anında TextBox’ın içeriği değiştirildikçe otomatik olarak

işletilir. Ancak kendim bu TextBox’ın TextChanged olayı için değil KeyPress
olayı için metot hazırlamak istiyorum. Şimdi bir tekrar yapalım: Tasarım
anında formu çift tıklarsanız Express Edition ve Visual Studio sizin formun
Load olayı için bir metot hazırlamak istediğinizi, Button nesnesini çift
tıkladığınızda button nesnenin Click olayı için metot hazırlamak istediğinizi
ve TextBox’ı çift tıkladığınızda ise TextChanged olayını temsil edecek bir
metot hazırlamak istediğinizi varsaymaktadır. Madem forma yerleştirdiğim
TextBox’ın KeyPress olayını temsil edecek bir metot hazırlamak istiyorum o
halde söz konusu TextBox seçili iken Properties penceresinde TextBox’a ait
olaylarının listelenmesini sağlamalıyım.
Bu TextBox’la ilgili olarak KeyPress olayı meydana geldiğinde(yani imleç

TextBox’ın içinde iken kullanıcı klavyenin herhangi bir tuşuna bastığında)
işletilmek üzere daha önce hazırladığınız bir metot varsa bu olaya ait liste
kutusunu açıp bu metodu KeyPress olayıyla ilişkilendirebilirsiniz.
Bu amaçla kullanabileceğimiz herhangi bir metodumuz olmadığı için

KeyPress olayının üzerinde çift tıklama yapmalıyız. KeyPress olayını çift
tıkladığınızda Express Edition hem bir metot hazırlar hem de
Form1.Designer.cs dosyasına müdahale edip bu metot ile KeyPress olayını
ilişkilendirir.

{
public Form1()
{
}
private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
{
}
}
Express Edition tarafından hazırlanan bu metotta, metot adından sonra

parantezlerin içinde (object sender, KeyPressEventArgs e) bilgisi var.
Başka bir deyişle TextBox1’in KeyPress olayını temsil etmek üzere
hazırlanan bu metot Object ve KeyPressEventArgs tipinde 2 parametreye
sahiptir. Basılan tuşu temsil eden bilgi metoda KeyPressEventArgs
tipindeki “e” adındaki parametre ile gönderilir. TextBox’ın içinde iken Enter
tuşuna basıldığı zaman TextBox’a girilmiş bilgileri bir diyalog kutusu içinde
ekrana getirmek için bu metodu aşağıdaki gibi düzenledim.
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 TextBox’ın “Text” özelliğinin içeriği ekrana

getiriliyor. En son basılan tuşun kodu 13 değilse imleç TextBox’ın içinde bilgi
girişi için beklemeye devam eder.
Forma yerleştirilen TextBox ve Button gibi nesnelerin değişik olaylarını

temsil etmek üzere metot hazırlama işleminin kavranmasına katkı olması
için TextBox’ların Enter ve Leave olaylarından söz edeceğim. Formdaki
herhangi bir nesneden TextBox’ın üzerine gittiğinizde veya imlecin
TextBox’a yerleşmesine neden olduğunuzda Enter olayı meydana gelir. Bu
olayın nasıl kullanıldığına örnek olması için forma birden fazla TextBox
yerleştirip ilk TextBox’ın Enter olayını temsil etmek üzere aşağıda verdiğim
metodu hazırladım.
Tabii yarın bir gün yerli yazarın birisi ortaya çıkıp TextBox’ların Enter olayını
temsilen metot hazırlamayı ilk ben akıl ettim, dolayısıyla fikri haklarıma
tecavüz ettiniz buyurun mahkemeye derse hiç şaşırmamak gerekir. Zira bu
memlekette bu böyle bir iddiayı onaylayacak çok sayıda bilim eri vardır.
private void textBox1_Enter(object sender, EventArgs e)

{
textBox1.BackColor = Color.GreenYellow;
}
Bu metoda yazılan satır sayesinde textBox1’in üzerine gidildiğinde zemin

rengi değişikliği olur. Kullanıcı TextBox’a bilgi girip başka bir kontrolün yani
nesnenin üzerine gittiğinde ise zemin rengini eski halinde çevirmek
istiyorsanız aynı TextBox’ın Leave olayını temsil eden(yani Leave olayı
meydana geldiğinde işletilen) metodu aşağıdaki gibi düzenleyebilirsiniz.
private void textBox1_Leave(object sender, EventArgs e)

{
textBox1.BackColor = Color.White;
}
Bazen istenen miktarda bilgi girmediği için kullanıcının TextBox’tan
ayrılmasına izin verilmek istenmez. Bu gibi durumlarda Validated olayından
yararlanılır. Kullanıcı TextBox’ı boş geçmek istediğinde buna izin vermemek
için TextBox’ın Validated olayını temsil eden metodu aşağıdaki gibi
düzenledim. Bu metotta kullanılan Focus() metodu ile formdaki istenen
nesnenin üzerine gidilebilmektedir.
private void textBox1_Validated(object sender, EventArgs e)

{
if (textBox1.Text == "")
{
MessageBox.Show("Bu alanı boş geçemezsiniz");
textBox1.Focus();
}
}
Projeler Đçin 2. Form Hazırlamak
Yukarıdaki sayfalarda işaret edildiği gibi Express Edition ile gelen Windows
Forms Application şablonu ile hazırlanan projeler “Form1” adında bir
forma sahip olmakta ve bu form projenin başlangıç formu olmaktadır.
Projenizde 2. bir formun olmasını istiyorsanız Express Edition’nın Project
menüsünden Add Windows Form komutunu verip ekrana aşağıda verilen
Add New Item diyalog kutusu getirmelisiniz.
Bu diyalog kutusunda üzerinde çalıştığınız projeye kod dosyaları, formlar vs

eklerken kullanabileceğiniz şablonlar listelenmektedir. Projeye normal bir
form eklemek istediğim için Windows Form şablonunu seçtim. Bu diyalog
kutusunda kod dosyasına vereceğiniz ad aynı zamanda hazırlanacak sınıfın
yani formun adı olarak kullanılmaktadır. Üzerinde çalıştığım projeye Form2
adında ikinci bir form ekleyince Express Edition penceresi aşağıda verilen
şekle dönüştü.
Add New Item diyalog kutusundaki Windows Form şablonundan yararlanıp

üzerinde çalıştığım projeye Form2 adında 2. form dahil edince bu formu
temsilen ikisi kod dosyası olmak üzere toplam 3 dosya hazırlandı.
Form2.Designer.cs dosyasında formun görsel yapısı ile ilgili kodlar
bulunurken “Form2.cs” dosyasında ise programcının yazdığı satırlar
olmaktadır.
Şimdi projedeki 2. formu başlangıç formu olarak ayarlayacağım. Başka bir

deyişle proje çalıştırıldığı zaman ekrana 2. formun gelmesini sağlayacağım.
Bu amaçla Program.cs dosyasındaki Main() metodunda Applicaiton
sınıfının Run() metoduna parametre olarak Form1 sınıfının örneği yerine
Form2’nin örneğini parametre olarak verdim.
static void Main()

{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
}
Projeki 2. Formu Ekrana Getirmek
Projenizdeki ikinci formu yani başlangıç formu olarak kullanılmayan formu

ekrana getirmek istiyorsanız bazı hazırlıkları yapmanız gerekir. Üzerinde
çalıştığım projedeki 2. formu ekrana getirirken kullanmak üzere ilk forma bir
düğme yerleştirdim ve bu düğmenin Click olayını temsil etmek üzere
aşağıda verdiğim metodu hazırladım. Bu metoda yazdığım satır ile Form2
sınıfından yola çıkılarak “ikinci_Form” adında bir nesne hazırlanmaktadır.
Bakmayın siz başka kitaplarda bu işleme “yavru(m) değişken tanımlama”
demelerine burada Form2 sınıfının örneği hazırlanmaktadır, yani nesne
hazırlanmaktadır.
private void button1_Click(object sender, EventArgs e)

{
Form2 ikinci_form = new Form2();
}
Yukarıdaki sayfalarda belirtildiği gibi herhangi bir Class’ın(burada Form2)

örneği hazırlanırken new anahtar kelimesi kullanılmaktadır. new anahtar
kelimesinden sonra ilgili sınıfın yapıcı yani constructor metodunu
kullanmak gerekiyor. 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.
Bazı yazarlar bir sınıfın örneğini almaya yavru değişken tanımlama

diyorlar. Tabii bazılarınızın aklına yavru değişken olduğuna göre torun
değişken nasıl tanımlanır sorusu gelmiş olabilir. Size bir tiyo: Dünyanın en
zor işlerinden birisi nesneye yönelik programcılık kavramlarına sahip
olmadan C# gibi %100 nesneye yönelik programlama dilini anlatmaya
soyunmaktır.
Bu metoda yazdığım satırda gerçekte 2 işlem yapılmaktadır. Đlk işlemde

Form2 tipinde 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 örneği(daha doğrusu nesnenin referansı) tanımlanan
değişkene aktarılmaktadır.
Bu şekilde hazırlanan Form2 tipindeki nesne Show() metodu ile ekrana

getirilir. “Form” sınıfının Show() metodunun nasıl kullanıldığını aşağıda
görebilirsiniz. 2 form içeren proje başlatıldığında projenin ilk formunun
kendiliğinden ekrana geldiğini biliyorsunuz.

{
ikinci_form.Show();
}
Bu kodda Form2 sınıfının örneğinin referansını tutacak değişkene ikinci_form

adını verdim. Olur ya yerli yazarın birisi de kitabında ikinci_form adında bir
değişken tanımlamıştır. Tedbir almazsam değişken adı çalmakla
suçlanabilirim. “değişken adı çalmış mı” sorusuna cevap aramak amacıyla
bu metni okuyacaklara rehber olması bakımından yukarıda verdiğim kodu
bir de aşağıdaki gibi düzenledim. Yani böylece değişkenlere ad seçerken
çaresiz kalıp başka kitaplardan değişken adı çalmayı tercih etmediğimi
bilgisayar tahsili yapmış öğretim üyelerine, bilen kişilere ve yerli yazarlara
kanıtlamış oluyorum.

{
Form2 ikinci_kazma = new Form2();
ikinci_kazma.Show();
}
Böylece değişkenlere ad bulabildiğimi kanıtladıktan sonra konumuza devam

edebiliriz. Ekranda 2. form varken yukarıda verilen kod işletildiğinde, yani
formdaki düğme tekrar tıklandığında aynı formun 2. veya 3. kopyası ekrana
getirilir. Projedeki 2. formun 2. ve 3. kopyasının aynı anda ekrana gelmesini
engellemek için kullanılabilinecek değişik teknikler olmakla birlikte ilk aklıma
geleni yazacağım. Bu amaçla yukarıda hazırladığım kodu değiştirip Show()
metodu yerine ShowDialog() metodunu kullandım.

{
ikinci_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üğmeye ait Click() metodunun
dışına alınabilinir. Aşağıda verilen kodda bu işlemi nasıl yaptığımı
görebilirsiniz.
Yukarıda verdiğim kodda “ikinci_form” adındaki değişkeni button1_Click()

metodu sınırları içinde tanımladığım için bu değişken yani nesne ancak bu
metodun sınırları içinde yaşar. Aşağıda verdiğim kodda ise bu değişkeni
metodun sınırları dışına, başka bir Class bloğuna aldığım için bu nesne bu
Class’ın her yerinde yaşar.

{
ikinci_form.Show();
}
Bu şartlarda formdaki düğmeyi tekrar tıklasanız bile projedeki 2. form tekrar

ekrana getirilmez. Ancak bu şekilde ekrana getirdiğiniz 2. formu kapattıktan
sonra Show() metodu ile tekrar 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 bellekten
silinir. 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() metodu ile ekrana getiren
satırları aynı metoda yazdım ama form nesnesini new anahtar kelimesi ile
tekrar oluştururken mevcut olup olmadığını araştırdım. Söz konusu form
henüz oluşturulmadıysa null olmaktadır.
Form2 ikinci_form;
{
if (ikinci_form == null || ikinci_form.IsDisposed)
{
ikinci_form = new Form2();
ikinci_form.Show();
}
}
Yukarıdaki sayfalarda yazılanlara göre projede kaç form olursa olsun

“Program.cs” dosyasında 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 farklı sonuçlar elde edebilirsiniz. Bu konuda bilgi vermek
için 2 forma sahip yeni bir proje hazırladım ve Program.cs dosyasındaki
Main() metodunu aşağıdaki gibi düzenledim.
static void Main()

{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
}
Bu şartlarda proje çalıştırılırsa Run() metodunun kullanıldığı ilk satırda

projenin ilk formu ekrana getirilir. Đlk form kapatıldığında Run() metodunun
2. kez kullanıldığı satır işletilir ve 2. form ekrana getirilir. Bu şartlarda
Form2 kapatıldıktan sonra projenin çalışması sona erer.
Formları Kapatmak ve Projelerin Çalışmasını Sona Erdirmek
Projenizin başlangıç formunu kapattığınızda ister o sırada açık olan başka

form olsun ister olmasın projenin çalışması sona erer. Đster projenin
başlangıç formu ister diğer formlar kapatılmak istensin kapatılma öncesi
FormClosing olayı meydana gelmektedir. Bu olay meydana geldiği zaman
işletilecek bir metot hazırlayarak kullanıcıyı uyarabilir veya formun
kapatılmasını engelleyebilirsiniz.
Bu amaçla Properties penceresinde projenin ilk formunun özellikleri

listelenirken Events sekmesine geçtim ve FormClosing olayını çift tıklayıp
Express Edition’nın aşağıdaki gibi bir metot hazırlamasını sağladım.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)

{
}
Metodun yapısı incelendiğinde birisi object tipinde diğeri

FormClosingEventArgs tipinde 2 parametreye sahip olduğu görülür.
Kullanıcı formu kapatmak isteyip FormClosing olayının meydana gelmesine
neden olduğunda metotta “e” adı verilen FormClosingEventArgs tipindeki
parametreden yararlanıp formun kapatılmasını kullanıcının onayına
bağlayabilirsiniz. Bu işlemin nasıl yapıldığını anlatmak için bu metodu
aşağıdaki gibi düzenledim.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)

{
DialogResult Sonuc;
Sonuc=MessageBox.Show("Pencere kapatılsın mı?",
Kapatma", MessageBoxButtons.YesNoCancel);
if (Sonuc == DialogResult.No || Sonuc == DialogResult.Cancel)
{
e.Cancel = true;
}
}
Bu kodda önce DialogResult tipinde bir değişken tanımladım. Çünkü

kullanıcıdan onay alınırken kullanılan MessageBox sınıfının Show() metodu
geriye DialogResult tipinde bilgi göndermektedir. Bu metotta MessageBox
sınıfının Show() metodunun 3 parametreli sürümünü kullandım. 3.
parametre olarak MessageBoxButtons.YesNoCancel kullanarak ekrana
getirilecek diyalog kutusunda Evet, Hayır ve Đptal düğmelerinin olmasını
sağladım.
MessageBox sınıfının Show() metodu ile ekrana getirmek istediğim diyalog

kutusunda Durdur, Yeniden Dene ve Yoksay düğmelerinin olmasını istemiş
olsaydım 3. parametre olarak MessageBoxButtons.AbortRetryIgnore
sabitini kullanırdım. MessageBox sınıfının Show() metodu, tıklanan düğmeye
bağlı olarak geriye DialogResult tipinde bir değer göndermektedir. Geriye
gönderilen bilgiyi öğrenmek için “Sonuc” değişkenin içeriğini kontrol edip
kullanıcı hayır veya iptal düğmesini tıkladıysa metodun
FormClosingEventArgs tipindeki 2. parametresinin Cancel özelliğini True
yapıp formun kapatılmasını engelledim.
Kullanıcı MessageBox sınıfının Show() metodu ile ekrana getirilen diyalog

kutusunda Evet düğmesini tıklarsa “if” deyimi ile yapılan karşılaştırma doğru
değerini vermeyeceği için “e” adlı parametrenin Cancel özelliği false olarak
kalmaya devam edeceği için formun kapatılmasının önüne geçilmemiş
olunur.
Yukarıda işaret edildiği gibi projenizin başlangıç formunu kapatmanız

halinde projenin çalışması sona ermektedir. Varsayalım ki karşınızda
projenizin başlangıç formu yok ve siz projenin çalışmasını sona erdirmek
istiyorsunuz. Bu durumda önce başlangıç formunu aktif form yapıp sonra
kapatırsınız. Projenizin çalışmasını sona erdirirken Application sınıfının Exit()

metodundan yararlanabilirsiniz. Bu metodun nasıl kullanıldığını anlatmak
için forma “Cikis” adında bir düğme yerleştirip bu düğmenin Click olayını
temsil eden metodu aşağıdaki gibi düzenledim.
private void Cikis_Click(object sender, EventArgs e)

{
DialogResult onay;
onay = MessageBox.Show("Projeden Çıkılsın mı?",
"Onay Kutusu", MessageBoxButtons.YesNo);
if (onay == DialogResult.Yes)
{
Application.Exit();
}
}
Bu metotta önce DialogResult tipinde bir değişken tanımladım. Ardından

kullanıcıdan programdan çıkılıp çıkılmayacağı konusunda MessageBox
sınıfının Show() metodu sayesinde onay alınmaktadır. Show metodu bu
şekilde kullanıldığında ekrana getirilecek diyalog kutusunda Evet veya Hayır
düğmeleri olur.
Kullanıcı bu diyalog kutusundaki Evet düğmesini tıklarsa “onay” değişkenine

“DialogResult.Yes” bilgisi, Hayır düğmesini tıkladığında ise “DialogResult.No”
bilgisi aktarılır. “onay” adını verdiğim değişkenine "DialogResult.Yes" sabiti
aktarılmışsa if deyimine parametre olarak verilen karşılaştırmanın sonucu
doğru olur ve “{“ ile “}” işaretleri arasında bulunan satır işletilir ve
Application.Exit(); satırı ile projenin işletimi sona erdirilir
PictureBox Konrolü
.NET Framework ile gelip Visual Studio ve Express Edition’nın Toolbox’ında

yer alan çok sayıda kontrol bulunmaktadır. Gerçekte birer sınıf olan bu
kontrollerin her birisinin farklı işlevleri vardır. Bu kitapçıkta ancak birkaç
kontrolden söz edebildik. Programcılığa henüz adım atanların ilgisini çeken
kontrollerden birisi PictureBox olduğu için kısaca PictureBox’tan söz
edeceğiz. Bu amaçla Toolbox’tan yararlanıp üzerinde çalıştığım projenin
formuna PictureBox nesnesi yerleştirdim.
Forma PictureBox nesnesini yerleştirdikten sonra PictureBox tarafından

sınırlanan alanda istediğiniz resim dosyasının içeriğini görüntüleyebilirsiniz.
Bu işlemi Properties penceresinde yapmak yerine kod yazarak yapacağım.
Bu amaçla forma Button nesnesi yerleştirip bu düğmenin Click olayı ile
ilişkilendirdiğim metodu aşağıdaki gibi düzenledim.
private void resim_sec_Click(object sender, EventArgs e)

{
pictureBox1.Image= System.Drawing.Bitmap.FromFile("C:\\jazz.jpg");
}
Bu metoda yazdığım satırda System.Drawing’de bulunan Bitmap sınıfının

FromFile() metodu ile ilgilendiğim jpg dosyasını okuyup PictureBox
nesnesinin Image özelliğine aktardım. Express Edition ve Visual Studio ile
hazırlanan projelerde System.Drawing adlı namespace kod dosyasının
başında using deyimi ile kullanılacak sınıfların aranacağı listeye dahil
edildiği için Bitmap sınıfından önce namespace adını yazmayabilirdim.
Burada dikkat edilmesi gereken bir nokta var: C#’ta “\” karakteri özel bir
karakter olduğu için çift “\\” kullanmak gerekiyor.
PictureBox’ta görüntülenecek dosyayı çalışma anında seçebilmek için forma

ayrıca bir OpenFileDialog nesnesi yerleştirdim. OpenFileDialog nesnesi
çalışma anında formun üzerinde görünmediği, başka bir deyişle görsel bir
kontrol olmadığı için formun altında hazırlanan panele yerleştirilmektedir.
Çalışma anında kullanıcı formdaki düğmeyi tıkladığında ekrana dosya seçimi

yapılan diyalog kutusunu getirmek ve seçilen dosyayı PictureBox’ta
görüntülemek için yukarıda verdiğim kodu aşağıdaki gibi düzenledim.

{
System.Windows.Forms.DialogResult Sonuc;
openFileDialog1.Filter = "Resim Dosyaları |*.JPG;*.BMP;*.GIF";
Sonuc = openFileDialog1.ShowDialog();
if (Convert.ToString(Sonuc) == "OK")
{
string Dosya = openFileDialog1.FileName;
pictureBox1.Image = System.Drawing.Bitmap.FromFile(Dosya);
}
}
Bu kodda tanımladığım değişken ve nesnelere verdiğim adlar(resim_sec,

Sonuc ve Dosya) herkesin aklına gelebilecek birer değişken adı olduğu için
“değişken adı hırsızı” olarak anılmam an meselesidir. Bu nedenle yani bu
kodda tanımlanan değişkenlere başka adlar verilse bile kodun çalışacağını
kanıtlamak için bu kodu bir de aşağıdaki gibi düzenledim.
private void adam_sec_Click(object sender, EventArgs e)

{
System.Windows.Forms.DialogResult hatice_netice;
openFileDialog1.Filter = "Resim Dosyaları |*.JPG;*.BMP;*.GIF";
hatice_netice = openFileDialog1.ShowDialog();
if (Convert.ToString(hatice_netice) == "OK")
{
string kutuk_oglu_kutuk = openFileDialog1.FileName;
pictureBox1.Image=System.Drawing.Bitmap.FromFile(kutuk_oglu_kutuk);
}
}
Bu metotta önce System.Windows.Forms.DialogResult tipinde bir

değişken tanımladım. Bu değişkenden dosya seçilen diyalog kutusunu
kullanıcının hangi düğme ile kapattığını öğrenirken yararlanacağım.
Devamında OpenFileDialog nesnesinin Filter özelliğini ayarladım. Bu
ayarlama sayesinde OpenFileDialog nesnesi ile ekrana getirilecek diyalog
kutusunda yalnızca geçerli klasördeki JPG, BMP ve GIF uzantılı dosyaların
listelenmesini sağladım.
FromFile() metodunun işlevi üzerinde düşünmenizi sağlamak için önce bir

Bitmap tipinde bir değişken tanımladım. Devamında FromFile() metodu ile
okuduğum resim dosyasını Bitmap nesnesine, oradan da PictureBox’a
aktarmaya çalıştım.

{
Bitmap resim;
resim = Bitmap.FromFile("C:\\jazz.jpg");
pictureBox1.Image = resim;
}
Đlk bakışta bu 3 satırlık koddan sonuç alınabileceği sanılabilir. Gerçekte bu

kod hataya neden olur. Çünkü Bitmap sınıfının FromFile() metodu geriye
Image tipinde nesne göndermesine rağmen Bitmap tipindeki değişkene
aktarmaya çalıştık. Yukarıda FromFile() metodunun geriye gönderdiği
nesneyi direk PictureBox’ın Image tipindeki Image özelliğine aktardığımız
için sorun yaşamamıştık. Bu 3 satırlık kod aşağıdaki gibi düzenlenirse hata
meydana gelmez.

{
Image resim;
resim = Image.FromFile("C:\\jazz.jpg");
}
Programcıların en çok gerek duydukları işlemlerden birisi tipler arasında

dönüştürme yapmaktır. Image tipindeki nesneyi Bitmap tipindeki nesneye
aktarmak için bu kodu değiştirip Bitmap tipinde değişken tanımlayıp
FromFile() metodunun geriye gönderdiği Image tipindeki nesneyi
dönüştürüp Bitmap tipindeki değişkene aktardım.

{
Bitmap resim;
resim = (Bitmap)Bitmap.FromFile("C:\\jazz.jpg");
}
Burada 2. satırdaki “(Bitmap)” ile söz konusu bilgi Bitmap tipine

dönüştürülmektedir. Đlgilenilen nesne hangi tipe dönüştürülmek isteniyorsa
o tip parantezlerin içinde dönüştürülmek istenen nesnenin önüne
yazılmalıdır. Burada kafaların karışmasına neden, Bitmap sınıfının
FromFile() metodunun geriye Bitmap yerine Image tipinde bilgi
göndermesidir. Bitmap sınıfının FromFile() metodu yerine Image sınıfının
FromFile() metodunu kullansaydım dönüştürme yapmaya gerek kalmazdı.

{
Image resim;
resim = Image.FromFile("C:\\jazz.jpg");
}
Dönüştürme işleminin anlaşılmasına katkı olması için şimdi de ICO uzantılı

bir dosyayı PictureBox’ta görüntüleyeceğim. Bu amaçla hazırladığım kodu
aşağıda görebilirsiniz. System.Drawing’de yer alan Icon sınıfının Bitmap ve
Image sınıflarında olduğu gibi FromFile() gibi bir metodu olmadığı için
ilgilendiğim ico uzantılı dosyayı Icon sınıfının yapıcı metoduna parametre
olarak verdim.

{
Icon ikon = new Icon("C:\\kapat.ico");
pictureBox1.Image = (Image)ikon ;
}
Đlk bakışta bu kodun hatasız çalışıp Icon tipindeki nesnenin Image tipine
dönüştürülüp PictureBox’ta görüntüleneceği sanılabilir. Ne ki burada
yapıldığı gibi icon tipindeki nesneyi Image nesnesine dönüştürmek mümkün
olmadığı için Icon sınıfının ToBitmap() metodundan yararlanmak gerekiyor.
Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz.

{
Icon ikon = new Icon("C:\\kapat.ico");
pictureBox1.Image = ikon.ToBitmap() ;
}
C# 3.0 Kitabım Hakkında
Aslında bu kitap üzerine konuşmadan önce yayınlanmış başka C# kitaplarını

incelemiş olsaydım bu kitabın farkını daha rahat ortaya koyabilirdim. Ne var
ki i, j, şayi1, sayi2 gibi değişkenleri çalmakla suçlanıp dava edildiğim
günden bu yana Türk yazarlar tarafından kaleme alınmış kitaplara mümkün
mertebe bakmıyorum. Tabi bazılarınız hemen beni uyaracaklardır: Türk
yazarlar tarafından kaleme alınmış kitapları incelemeden "değişken adı
benzerliği" kabahatinden kendini nasıl korursun? Valla keçeyi bir kez suya
attık ve değişken çalmakla suçlanıp hakim karşısına çıktığıma göre cesur
olmaktan başka çare yoktur. Eklemem gerek: Değişken adı çalmakla
suçlanmama neden olan sizlersiniz. Eğer beni dava eden ve şahane kitaplar
yazan saygıdeğer yazarların programcılık kitaplarını üçer beşer satın
alsaydınız şu anda mahkemelerde sürünmezdim. Size önerim Memik
Yanık'ın hepsiburada.com'dan veya kitapyurdu.com'da bulacağınız kitabı
yerine Memik Yanık'ı değişken çalmakla suçlayıp dava eden yazarların
şahane C# kitaplarını en azından ikişer adet satın almanızdır.
Biliyorsunuz C# 3.0 kitabım biraz gecikmeyle bir süre önce yayınlandı.

Bilmeyenler için hatırlatmak gerekirse gecikme nedeni kitapta değişken adı
tadilatına(!) gitmiş olmamdır. Madem kitapta verdiğim kısa kısa kodlarda
değişken adı ve nesne adı benzerliği kabahatini işlememek için kitabı yeni
baştan düzenlemek gerekti. Ben de kitaba birkaç yeni bölüm ekleyip bazı
konulara ayrılan sayfaların sayısını azalttım. Bununla da yetinmedim;
şartları zorlayıp kenar boşluklarını azaltıp kitapta daha çok konuya yer
vermeye çalıştım. C# 3.0 üzerine yazdığım bu kitabın nasıl bir kitap
olduğunu, nasıl bir anlatım biçimine sahip olduğunu merak edenler bu
kitaptan alıp kişisel web sitemde daha önce yayınladığım Hata Yakalamak
ve Exception Sınıfları ile C# Uygulamalarında Word’den Yararlanmak
adlı makalelerime bakabilirler. Tabii C# konusunda henüz yolun başında
olanların bu makalelere bakıp kitap hakkında değerlendirme yapmaları zor
olacağı için kitap hakkında biraz konuşacağım.
Meraklılara önerim şudur: Bütün web sitelerini gezin, sizde veya

arkadaşlarınızdaki bütün C# konulu kitapları elinize alın ve C# uygulamaları
dahilinde Word'den nasıl yararlanıldığını anlatan metinlere bir bakın. Sonra
da yukarıda verdiğim linkte bu kitabın ilgili bölümüne şöyle bir göz gezdirin.
Memik Yanık'ın anlatımında bir fark göremiyorsanız "Ne de olsa bu adam i,
j, sayi1, sayi2, deger gibi değişkenlerin adını çalmış birisi" deyip bu kitaptan
uzak durun. Kitabın bir bölümüne bakıp değerlendirme yapmak yanıltıcı
olabilir diyorsanız bir de Hata Yakalamak ve Exception Sınıfları adlı bölüme
bakın. Yok hayır Đngilizcesi yeterli olmayan Memik Yanık çeviri yapmıştır
diyorsanız şu linkteki Programcılar Đçin Yazarlık Dersleri adlı e-book'u biraz
inceleyin derim. Bu e-book'tan bilgisayar ve programcılık üzerine yazmayı
düşünen arkadaşlarınıza söz etmeyi unutmayın.
Bu kitabı yazarken ağırlıklı olarak Visual Studio kullanmış olsam bile Visual
Studio yerine C# için hazırlanmış olan Express Edition kullananlar
herhangi bir zorluk çekmezler. Ötesi bazı yüksek okullarda verilen C#
derslerinde başlangıçta konsol uygulamaları tercih ediliyor. Bu nedenle bazı

arkadaşlarımız gidip C# anlatılırken yalnızca konsol uygulamalarının
kullanıldığı kitapları tercih ediyorlar. En başta belirtmeliyim ki bu kitapta
konsol uygulamaları hakkında yeterince bilgi vardır.
En kapsamlı Türkçe C# kitabı iddiası ile hazırladığım bu kitapta bazı

konularda ayrıntıya giremedim. Örneğin Generic sınıfları kabul edilebilir bir
ayrıntıda anlatabilmem için kitaba en az 50 sayfa daha eklemem gerekirdi.
Kitapta giriş düzeyinde bilgi verilen bir diğer konu LINQ teknolojisidir.
Yurtdışında yalnızca LINQ hakkında bilgi içeren çok sayıda kitabın
yayınlandığını söylersem ne demek istediğim sanırım anlaşılır. Kısaca
anlatmak gerekirse; C# öğrenmeye bu kitapla başlayanları veya C#
konusunda kendini geliştirmek isteyenleri temelden alarak C# ve .NET
programcılığı uzmanlık düzeyine çıkarmayı hedefledim.
Bu kitabın farkı nedir diye soracaklara vereceğim cevap şudur: Bu kitapta

bütün konular ilk okumada anlaşılacak yalınlıktadır. Hayır hayır bu yalınlık
yalnızca değişken tanımlama, Integer bilgiyi String bilgiye dönüştürmenin
nasıl anlatıldığı sayfalarla sınırlı değildir. Örneğin bu kitapta Windows
Mesajları adlı bölümde anlatılanlar da ilk okumada anlaşılacak yalınlıktadır.
Benzer şeyler Garbage Collector hakkında yazılanlar için de geçerlidir.
Kolay okunmanın, hemen anlaşılmanın formülü nedir diye merak edenler
Yazarlık Dersleri adını verip sizlerle paylaştığım e-book’a bakabilirler.
Bu kitabı edinmek isteyenler seckin.com.tr'den, hepsiburada.com'dan veya

kitapyurdu.com'dan talep edebilirler. Bu kitabın fiyatı hakkında
değerlendirme yapmak isteyenlere kitabın fiyatını toplam sayfa sayısına
bölüp sayfa başına ne ödediklerini öğrenmelerini önermek isterim. Kitap
fiyatları konusunda bir cümle daha : Satın aldığınız kitaba(yayınlanmasının
üzerinden yıllar geçmemişse) ödediğiniz ile, kitabın kapak fiyatı arasında
uçurumlar yani %30, %40 gibi farklar varsa kitabın kapak fiyatı pazarlama
taktiği olarak yüksek seçilmiştir denilebilir. Bir kitap satış sitesi kitabın
kapak fiyatı üzerinde %15-20 indirim yapması son derece normaldir.
C# 3.0 Kitabımı Anlattım
Bu yazının amacı bu kitabın satışını arttırmak değildir. Bu yazının amacı olsa

olsa böyle bir kitaba ihtiyacı olmayanların bu kitabı satın alıp para ve zaman
kaybetmelerinin önüne geçmek olabilir. Her ne kadar bu kitap .NET 3.5
destekli C# 3.0’ı anlatmak kaygısı ile kaleme alınmış olsa bile C# 3.0
piyasaya verileli az olmadı. Bu bilgiyi şunun için yazdım: Mevcut bir işletim
sisteminin veya bir programlama dilinin yeni sürümü çıktığında özellikle yurt
dışında sıcağı sıcağında yeni sürümle gelen yeniliklere odaklanan kitaplar
yazılıp yayınlanmaktadır. Böyle kitaplar eski sürüm hakkında bilgisi olup
yeni sürümle gelen yeni özellikler hakkında hemen bilgi edinmek isteyenlere
uygundur. En başta söylemeliyim ki bu kitap C# 3.0 ve .NET 3.5’la gelen
yenilikleri anlatmak kaygısı ile kaleme alınan bir kitap değildir. Başka bir
deyişle bu kitabın hedef okuru programcılık nedir az çok bilip C# ve nesneye
yönelik programcılıkta uzman olmayı kafasına koyanlardır. Bu nedenledir ki
bu kitapta konular temelden ele alınarak 1100 sayfa boyunca C# anlatıldı.
C# anlatılırken .NET Framework 3.5 ile gelen C# 3.0 derleyicisi ve Visual
Studio 2008 kullanıldı. Bu yazıda asıl bu kitapta C#’ı nasıl anlattım sorusuna
cevap aramaya çalışacağım.
Elbette C# uygulamaları geliştirmek için kullanılan bilgisayara .NET

Framework kurulup Not Defteri programı ile istenen programları yazmak
mümkün olsa bile bu zahmetlidir. Bu nedenle C# veya .NET uyumlu başka
bir programla diliyle uygulama geliştirmek isteyenler Visual Studio’yu veya
C# için hazırlanmış Express Edition’ı kullanmayı tercih ediyorlar. Bu
nedenledir ki bu kitabın başında 18 sayfa boyunca Visual Studio ile
hazırlanan C# uygulamalarının temel özellikleri ve bu uygulamaların nasıl
derlenip çalıştırıldığı ve nasıl debug edildiğinden kısaca söz edildi. Đşte bu
kitabın ilk bölümüyle ilgili olarak kitaptan alınmış bir paragraf : “Bu bölümde
ileride işlenecek bazı konulara temel oluşturan birkaç ayrıntıdan söz
edilmektedir. Aslında C# programlama dilinden bağımsız olarak Visual
Studio hakkında yüzlerce sayfa yazılabilir. Ne ki bu kitabın böyle amacı
yoktur.” Kitabın içindekiler sayfasına bakıp “bu kitabın 18 sayfası ekran
görüntüleriyle doldurulmuş” diye eleştireceklere şunu söylemek isterim: Đlk
bölümde Visual Studio’nun yardımıyla uygulama geliştirilirken karşılaşılan en
önemli kavramlardan birisi olan Debug ve Release modlarından söz
edilmektedir.
Bu kitabın C# ile Programcılığa Giriş adlı 2. bölümünde C# ve nesneye

yönelik programcılık hakkında kuşbakışı bilgi verilmektedir. Bu sayede
okurun C# ve nesneye yönelik programcılık hakkında temel bilgilere sahip
olması hedeflendi. Bu kitabı incelemeden eleştirmeyi kafalarına koymuş
olanlara şunu söylemek isterim:Memik Yanık’ın C# 3.0 kitabının 36
sayfadan meydana gelen Programcılığa Giriş adlı 2. bölümünü okuyanlar
metotlarla olayları karıştırmazlar, Application sınıfının işlevinden bi haber
olmazlar, formların nasıl hazırlanıp ekrana getirildiğini bilirler. Aşağıda

verdiğim paragrafı kitaptan olduğu gibi buraya aldım: “Daha önce az çok
kod yazmış olanlar bir sonraki bölüme şöyle bir baktıklarında bütün
yazılanların bildikleri konular olduklarını sanabilirler. Sanabilirler diyorum
çünkü bir sonraki bölümde C# ile program yazılırken gerek duyulan pek çok
kavram hakkında teknik açıklamalar yapılmaktadır. Bu nedenle bu kitabı
eline alan herkesin bir sonraki yani 2. bölümü dikkatli okumasını
öneriyorum. Tabii bu öneri kitapçıda veya herhangi bir yerde bu kitabı satın
almayacakları önceden belli olup ta meraktan bu kitabı şöyle bir gözden
geçirenleri veya C# hakkında yeterince bilgisi olanları kapsamıyor. Böyle bir
kitaba ihtiyaçları olmayanların bir sonraki bölümde yazılanlara yabancı
olmamaları normaldir. Bir sonraki bölümün gerek içerik gerekse de
konuların işleyişi bakımından bütün yerli yabancı kaynaklardan ayrıldığını
söyleyebilirim.” Elbette bu kitabın 2. bölümünde yazılanların bir kısmının
başka kaynaklarda bulunma ihtimali yüksektir. Programcılık kitaplarında
bilim yapmadığımıza göre bu kitapta anlatılan her konunun başka kaynakları
bulunması son derece normaldir. Kitapların arasındaki en önemli fark
konuların anlatım biçimi ve hikâye edilme tarzıdır.
Gelelim bu kitabın Konsol Uygulamaları adlı 2. bölümüne. Bir sonraki

bölüm bir bakıma Programcılığa Giriş adlı 2. bölümün devamı gibidir. Çünkü
Konsol Uygulamaları adını verdiğim 3. bölümde C# kodu yazılmak
istendiği zaman “ilk” gerek duyulacak kavramlar ve en çok kullanılan .NET
sınıflarını anlatmaya çalıştım. Her ne kadar konsol uygulaması geliştirip
başkasına verme ihtimaliniz düşük olsa bile bir sonraki bölümde C# ile
program yazmanın geri planı üzerinde biraz durulmaktadır. Tabii bununla da
yetinilmeyip Konsol Uygulamaları dahilinde Windows Formlarının nasıl
ekrana getirilebileceği anlatılarak referans ve namespace kavramları
hakkında ön bilgi verilmeye çalışılmaktadır. Yine bazı arkadaşlar “madem
Windows formuna gerek duyuyorsun da neden konsol uygulaması
hazırladın” diye sorabilirler. Bu soruyu soran arkadaşlara aşağıda verilen 2
Main() metodunu incelemelerini önermek isterim.

{
Form1 F1 = new Form1();
F1.ShowDialog();
Console.ReadKey();
}
{
Form1 F1 = new Form1();
F1.Show();
Application.Run();
Console.ReadKey();
}
Sizce Memik Yanık konsol uygulamasının Main() metodunu bu şekilde

düzenlemekle neyi hedeflemektedir? Sizce hangi kaynakta(yerli yabancı fark
etmez) Form nesnesi Application sınıfından yararlanılmadan Show()
metodu ile ekrana getirilmeye çalışılmıştır? Hayır hayır Memik Yanık
Amerika’yı yeniden keşfetmiyor; Memik Yanık’ın burada yaptığı okurun
dikkatini Application sınıfının işlevine çekmektir. Sizce Application sınıfı
hakkında yeterince bilgi edinmemiş birisi Windows mesajlarını hakkıyla
anlayabilir mi?
Gelelim bu kitabın 4. bölümde anlatılan şu Namespace kavramına. Her ne

kadar bu kitabın 2. ve 3. bölümlerinde referans ve namespace’lerden söz
edilmiş olsa bile .NET programcılığında henüz yolun başında olan birisi için
Namespace kavramı hakkıyla öğrenmesi gereken kavramlardan birisidir.
Tabi henüz yolun başında olan birisine namespace kavramını en başta
anlatacağım deyip kafasını karıştırmamak gerekir. Bu düşünce ile
namespace’ler hakkında bilgi vermeye kısıtlı bir konsol uygulaması
hazırlayarak başladım. Çünkü C# derleyicisinin derleme yaparken neyin sınıf
neyin namespace olduğuna karar verirken nasıl bir yöntemi kullandığının
bilinmesi gerekiyor. Bu nedenle Memik Yanık’ın kitabında derleme hakkında
bilgi verirken “System.dll” ve “System.core.dll” adlı referanslardan söz etti.
Namespace adlı bölümün ileri ki sayfalarında .NET Framework ile gelen
Namespace’lerdeki sınıfları kullanmaktan öte programcıların kendi sınıflarını
nasıl namespace olarak düzenleyebileceklerinden söz edildi. Tabii ki C#
konulu kitapların hemen hepsinde nasıl namespace hazırlandığından söz
edilmektedir.
Memik Yanık’ın C# kitabının 5. bölümünde 36 sayfa boyunca değişkenler

hakkında bilgi verilmektedir. Bazı okurlara göre değişkenlere bu kadar sayfa
ayırmanın gerekçesi nedir diye sorabilirler. Elbette daha önce C# hakkında
az çok bilgi edinmiş olanları göz önüne alırsak değişkenlere daha az sayfa
ayırmak gerekirdi. Örneğin daha önce C# konulu kaynakları okumuş olanlar
değişkenlerin nasıl tanımlanıp nasıl ilk değer aktarıldığını bilirler. Her ne
kadar bu bölümde Nullable tiplerden, Parse() metodundan, Convert
sınıfından söz edilse bile bu kitabı bu bölüm bağlamında değerlendirecek
olursam şunları söyleyebilirim: Bu kitabın bu bölüm bağlamında bir artısı
varsa değişkenlerin bütün yönleri ile ele alınmış olmasıdır. Bu nedenle
değişkenler konusunu bu kitaptan okuyan birisi değişkenlerle ilgili olarak
başka kaynaklara bakma gereğini duymaz. Benzer şeyler bu kitabın 6.
bölümü için de söylenebilir. Çünkü kitabın 6. bölümünde 18 sayfa boyunca
dizi değişkenler ve Array sınıfı her yönüyle en ince ayrıntısına kadar
anlatılmaktadır. Belki bu kitap Değişkenler adlı bölüm bağlamında şöyle
eleştirilebilir: Bu metni biraz kesip, bazı metot ve işlemlerden söz etmeyip
birkaç sayfa tasarruf edebilirdiniz. Ancak ben tercihimi dizi değişkenleri her
yönüyle anlatmak yönünde yaptım. Yani istedim ki bu kitabı edinenler C#’la
ilgili temel konuları öğrenirken başka kaynaklara başvurma gereğini
duymasın.
Şimdi sırada bu kitapta toplam 8 sayfa yer tutan Operatörler adlı bölüm
var. Tabi hemen bazı arkadaşlar 8 sayfa boyunca artı(+), eksi(-), bölme(/)
vs.. operatörlerinden söz etmiş olduğumu düşünebilirler. Bu bölümde bu
operatörlere kısaca değinilmiş olsa bile asıl ağırlık Kaydırma Operatörleri
ile as ve is operatörlerine verildi. Çünkü as ve is operatörleri çok sık
kullanılmaktadır. Devamında 3 sayfa boyunca bit düzeyinde işlem yapılırken
kullanılan operatörlerden söz edildi. Matematiksel işlemlerde kullanılan
operatörler hakkında bu kitapta yazılanlar çıkarılsa bile sayfa sayısı
değişmiyordu. Bit düzeyinde işlem yapılırken kullanılan operatörlerden
yararlanmak son derece teknik bir işlem olmasına rağmen konular öyle
hikaye edildi ki ilk okumada mutlaka anlaşılacak yalınlıktadır.
Bu kitabın Blok Kontrol adlı bölümünde 10 sayfa boyunca if, while, for,
foreach’ten söz edildi. Bu kitabın bu bölüm bağlamında diğer kitaplara bir
artısı pek yoktur. Ancak başlangıçta zor anlaşılan foreach döngüsünü daha
önce hiç duymamış olanlar bile bu kitabın ilgili sayfalarını okuduklarında
foreach döngülerine hemen hakim olabilirler.
Bu kitabın 9. bölümünde 26 sayfa boyunca string işlemlerinden ve Math

sınıfındaki metotlardan söz edilmektedir. Neden mi bu konuyu önemsedim?
Çünkü kod yazılırken en çok yapılan işlemlerin başında string işlemleri
gelmektedir. Elbette String ve Math sınıflarının bazı metotlarını göz ardı edip
bu bölümün sayfa sayısını 22’ye düşürmek mümkündü. Bu durumda C# ile
programcılıkta yeni olan okurların başka kaynaklara başvurma ihtiyacı
olurdu. Açıkçası istedim ki bu kitabı her kim edinirse String ve Math sınıfının
metotları konusunda eksiksiz bilgiye sahip olsun. Örneğin String sınıfının
Splip metodunu ayrıntılı bir şekilde anlattım. Bu kitabın 14 sayfalık 10.
bölümü bir bakıma String Đşlemleri adlı 9. bölümün devamı gibidir. Çünkü
10. bölümde StringBuilder sınıfından ve Düzenli Đfadelerden söz
edilmektedir. Tam bu noktada bu kitabın boyutlarından kısaca söz etmek
istiyorum. Bu kitabın yazı alanın genişliği tam tamına 13 cm’dir. Đsim
vermeye gerek yok aynı genişliğe sahip(16 cm) birçok kitapta yazı alanı
genişliği en fazla 11.5 cm’dir. Asıl demek istediğim şudur: Toplam 1074
sayfa olan bu kitap başka yayınevlerinin ölçüleri ile basılsaydı sayfa sayısı en
az 1200 olurdu. Yani anlayacağınız bu kitabın sayfa sayısını azaltmak sürekli
çaba harcadım.
11. bölümde 16 sayfa boyunca tarih ve zaman bilgileri bütün ayrıntıları ile
anlatılmaktadır. Başka bir deyişle bu kitabı okuyan birisi için tarih ve zaman
bilgileri üzerinde yapılan işlemler bağlamında bilmediği hiçbir ayrıntı kalmaz.
Ayrıca bu bölümü okuyanlar Ticks özelliği ve TimeSpan yapısı hakkında
bilgi sahibi olurlar. Bazı arkadaşlar yine itiraz edip Tarih ve zaman bilgileri
üzerinde yapılan işlemleri anlatmak için 16 sayfa fazla değil mi? Bir görüşe
göre evet. Şartları zorlayıp bu bölümün sayfa sayısını 12 veya 14’e indirmek
mümkündü. Ötesi birçok kitapta bu konuya ayrılan sayfa sayısı üç beştir.
Buna rağmen neden mi bu konuyu bütün ayrıntıları ile anlattım. Çünkü
izlediğim forumlarda zaman ve tarihsel bilgiler üzerinde yapılan işlemlerle

ilgili çok sayıda soru sorulmaktadır. Başka bir deyişle her C# programcısının
bu işlemlere ihtiyacı olduğundan herkesin bu işlemler hakkında bilgi sahibi
olması gerekiyor.
Bu kitabın 12. bölümünde toplam 12 sayfa boyunca Pointer değişkenlerden

söz edilmektedir. Son derece teknik bir konu olan Pointer değişkenler
hakkında bu kitapta yazılanlar ilk okumada anlaşılacak yalınlıktadır. Ötesi bu
bölümde IntPtr tipi değişkenlerden söz edilmektedir. Türkiye’de IntPtr tipi
Pointer değişkenlerden ilk söz edenin Memik Yanık olduğunu dikkatinize
sunmak isterim. IntPtr tipi Pointer değişkenler çok mu önemlidir?
Windows’un API adı verilen fonksiyonlarını kullanmayı düşünüyorsanız IntPtr
tipi Pointer değişkenler hakkında az da olsa bilgi sahibi olmak
durumundasınız.
Her ne kadar bu kitabın Programcılığa Giriş ve Konsol Uygulamaları adlı

2. ve 3. bölümlerinde Class kavramından az çok söz edilmiş olsa bile
konunun ayrıntıları 13. bölümden itibaren anlatılmaktadır. Birçok yerli
yabancı kitapta Class’lardan söz edilirken memeli hayvanlardan, arabalardan
vs. söz edilir. Başka bir deyişle Class kavramının zor anlaşılması için herkes
görüş birliğine varmış gibi. Memik Yanık nesneye yönelik programcılık
şudur, şu ilkeleri vardır vs demeden direk kod üzerinde Class kavramından
söz eder. Örneğin Memik Yanık bu kitabın ta ilk sayfalarında şöyle bir cümle
kurdu: “C# programlarını Class olarak düzenlemek zorunluluğu vardır. Bu
nedenle aşağıdaki gibi bir Class bloğu hazırladım”. Bu kadar basit. Henüz
yolun başında olan ve programcılıkla ilgili temel kavramlardan bile bi haber
olan birisine memelilerden, arabalardan vs söz etmek kafaları
karıştırmaktan öte bir işe yaramaz. Ötesi C#’la ilgili kaynaklarda değişken-
alan ayrımından hiç söz edilmez. Tamam kitabın başında eski alışkanlıklara
uyup alanlara değişken denilmesi belki anlatım kolaylığı sağlıyor ama
Class’lar ve nesneye yönelik programcılık anlatılırken değişkenlerin gerçekte
alan olduğundan hiç söz edilmez.
Daha önce az çok program yazmış ve nesne nedir Class nedir sorularına
verecek cevabı olan birisi Memik Yanık’ın kitabındaki “Class’lar ve Nesneye
Yönelik Programcılık” adlı 38 sayfalık bölüme şöyle baktığına kesin burun
kıvıracaktır. Sanki Memik Yanık bu bölümü C# uzmanları için yazmış ta
uzmanların bu metinden öğreneceği yeni bir şey yokmuş. Sanki Memik
Yanık bu bölümü herkesin işine yarayacak Class örnekleri hazırlamak için
kaleme almış. Bu bölümün amacı Class’lar ve Class’ların üyelerinden söz
etmektir, yapıcı ve yok edici metotların nasıl hazırlandığını okura
göstermektir, statik yapıcı metotların işlevinden söz etmektir. Eğer okurun
birisi bu bölümü okuyup Class’lar hakkında genel bilgiye sahip oluyorsa bu
bölüm işlevini yerine getirmiştir. Her ne kadar bu kitabın “Class’lar ve
Nesneye Yönelik Programcılık” adlı bölümde Class’ların en önemli üyesi
metotlardan söz edilmiş olsa bile metotlar ayrı bir bölümde ayrıntılı bir
şekilde incelendi. Başka bir deyişle Memik Yanık’ın C# 3.0 kitabının 16

sayfalık 14. bölümünü okuyanlar metotlarla ilgili her tür bilgiye sahip
olurlar.
Bu kitabın 15. ve 16. bölümlerinde Đndeksleyiciler ve Interface’lerden söz

edildi. Nesneye yönelik programcılıkta indeksleyiciler zor anlaşılan
konulardan birisidir. Memik Yanık 10 sayfalık bu bölümü öyle bir kaleme aldı
ki hayatında daha önce indeksleyici kavramını hiç duymamış olanlar bile ilk
okumada yazılan her şeyi anlayabilirler. Benzer şeyler 12 sayfa boyunca
Interface’ler hakkında bilgi verilen bölüm için de söylenebilir. Gelelim
nesneye yönelik programcılığın hem önemli hem de zor anlaşılan 2
konusuna: Delegate ve Olaylar. Sizce Delegate’ler ve Olaylar neden zor ve
genellikle yanlış anlaşılan 2 konudur. Tabi bazı arkadaşlar şöyle bir yorum
getirecekler: Forma bir Button nesnesi yerleştirirsin sonra tasarım anında bu
button nesnesini çift tıklarsın vs.. Zaten Delegate ve Olayların zor ve yanlış
anlaşılmasının temelleri Button nesnesinden ve tasarım anında Button
nesnesi çift tıklandığında hazırlanan kodun anlatılış şeklinde yapılmaktadır.
Hal bu ki gerçek başkadır: Tasarım anında formdaki Button nesnesi çift
tıklandığında Visual Studio programcının söz konusu Button nesnesinin Click
olayını temsil edecek bir metot hazırlamak istediğini varsayıp Click olayının
yapısına uygun bir metodu hazırlayıp Click olayıyla ilişkilendirmektedir. Tabii
kullanıcı çalışma anında button nesnesini tıkladığında Button nesnesiyle ilgili
olarak Click olayının nasıl tetiklendiğinden söz edilmediği için konu havada
kalıyor. Memik Yanık bu düşünceyle 20 sayfa boyunca delegate ve
olaylardan söz etti.
Bu kitabın 16 sayfalık Stuct ve Enum Tipleri adlı bölümünü okuyanlar

Struct’ların ne olduğu, hangi amaçlarla kullanıldığı, sınıflarla struct’lar
arasında ne gibi farkların olduğunu kısa sürede öğrenirler. Devamında Enum
tipleri hakkında ayrıntılı bilgiye sahip olduğu gibi Enum’larla ilgili olarak
başka kaynaklara başvurma ihtiyacı kalmaz. Gelelim bu kitabın 12 sayfalık
Object Sınıfı adlı bölümüne. Bütün C# kitaplarında dakka 1 gol 1 misali
daha ilk sayfadan Object sınıfından söz edilir. Okur kitabın sonuna kadar
gelir ama hala Object sınıfı hakkında derli toplu bilgiye rastlamaz. Object
sınıfı hakkında yeterli bilgiye sahip olmayan okur ToString() metoduyla ilgili
olarak anlatılanları kavramakta zorlanır. Memik Yanık ne mi yaptı? Kitabının
ortalarına bile gelmeden Object sınıfının önemli gördüğü özelliklerini ve
metotlarını anlaşılır bir dille anlattı.
Bu kitabın mevcut yerli yabancı C# kitaplarına fark atılan bölümlerden bir

diğeri Koleksiyon Sınıfları adlı 20. bölümdür. Bu bölümde 48 sayfa
boyunca .NET Framework ile koleksiyon sınıfları ve bu sınıflarla ilgili bütün
Interface’ler ayrıntılı bir şekilde anlatılmaktadır. Bu bölümün tümünü
okuyan birisi kendisini koleksiyon uzmanı olarak ilan edebilir. Koleksiyonlar
konusu oldukça kapsamlı olduğu için BitArray, BitConverter, Buffer,
StringCollection ve StringDictionary sınıflarını ayrı bir bölüm olarak
düzenledim. Tabi hemen aklınıza Generic koleksiyonları ne yaptınız Sorusu

gelmiş olabilir. Bu kitabın 22. bölümünde 26 sayfa boyunca önce .NET
Framework ile gelen Generic koleksiyon sınıflarından, devamında Generic
sınıflarından söz ettim. Yurt dışında yalnızca Generic sınıflardan söz edilen
bağımsız kitaplar yazıldığına göre bu kitabımda Generic koleksiyonları ve
sınıfları bütün yönleriyle anlatmadığımı tahmin etmiş olmalısınız.
Şimdi sözünü edeceğim 3 bölüm gerek içerik gerekse de anlatım şekli

bakımından mevcut(tabi bu değerlendirme benim görebildiğim kitaplarla
sınırlıdır) kitaplara fark atmaktadır. Her ne kadar Hata Ayıklamak ve Debug
Đşlemleri adlı 18 sayfalık bölümün ilk 7 sayfasında anlatılan konuları hemen
her kaynakta bulmak mümkün olsa bile bu bölümün diğer sayfalarında
Debug, Trace, TextWriterTraceListener ve EventLogTraceListener
sınıfları hakkında ayrıntılı bilgi verilmektedir. 27. bölümde ise hata
yakalanırken kullanılan Exception sınıfları anlatılmaktadır. Tabii ki başka
kaynaklarda da Exception sınıfları hakkında bilgi bulabilirsiniz. Gelelim şu
Application sınıfına. Diğer kaynaklarda Application sınıfının bazı özellikleri
ve metotları hakkında bilgi veriliyor olsa bile hiçbir kaynakta 14 sayfa
boyunca yalnızca Application sınıfından söz edilmemektedir.
Bu kitabın içindekiler sayfasına bakan birisi Form Sınıfının Özellikleri,

Olayları ve Metotları adlı bölümde 18 sayfa boyunca klasik olarak
formların herkes tarafından bilinen özelliklerinden söz edildiğini sanabilir.
Đşte size bu bölümden alınma 3 satırlık kod.
protected override void OnCreateControl()

{
base.OnCreateControl();
}
Tabii ki burada bu 3 satırlık kodun işlevinden söz etmeyeceğim, demek

istediğim şudur: Bu koda başka basılı kaynaklarda rastlama ihtimaliniz son
derece düşüktür. Başka bir deyişle bölümün adı Form Sınıfının Özellikleri
olsa bile son derece teknik bilgiler içermektedir.
Bu kitabın diğer basılı kaynaklar bağlamında en sıradan bölümü “Sık

Kullanılan Kontroller” adlı bölümüdür. Bu bölümde sık kullanılan 20’ye yakın
kontrol 36 sayfa boyunca anlatılmaktadır. Bu kontroller anlatılırken daha
önce az çok kod yazmış herkesin ilk bakışta tahmin edeceği özellik ve
metotlardan söz edilmedi.
Bu kitabın Dosya ve Klasör Đşlemleri adlı 36. bölümünde 28 sayfa

boyunca C# kodu yazan birisinin gerek duyması muhtemel bütün bilgiler
verilmektedir. Başka bir deyişle bu bölümü okuyanlar dosya ve klasör
işlemleri bağlamında başka kaynaklara başvurma ihtiyacını duymazlar.
Kapsam bir yana Memik Yanık’ın kitabının bu bölümünü okuyanlar

yorulmazlar, anlatılanları izlemekte zorluk çekmezler.
Şimdi bu kitabın mevcut basılı kitaplar bağlamında bence açık ara önde
olduğu 3 bölümden kısaca söz edeceğim. Birçok kaynakta C# uygulamaları
dahilinde Word ve Excel’den nasıl yararlanıldığı kısaca anlatılırken Memik
Yanık’ın kitabında bu konu 32 sayfa boyunca ayrıntılı bir şekilde
anlatılmıştır. Ayrıca bu anlatma öyle bir anlatmadır ki ilk okumada
anlaşılmayacak bir tek cümle bile yoktur. Benzer şekilde Api Fonksiyonları
adlı bölümde Memik Yanık programcıların en çok gerek duyduğunu sandığı
API fonksiyonlarını 32 sayfa boyunca anlatmıştır. Windows Mesajları adlı
bölümde ise Memik Yanık 32 sayfa boyunca son derece teknik bir konuyu ilk
okumada anlaşılacak yalınlıkta anlatmıştır. Bu kitabın hepsi ileri düzey
konular olan diğer bölümlerinden söz etmeye gerek duymadım. Çünkü ileri
düzey konulara gerek duyanlar zaten neyi aradıklarını biliyorlar.
Buraya kadar C# kitabımım yarısından biraz fazlasından söz ettim. Kitabın

diğer bölümlerini de anlatıp bu yazının sayfa sayısını iki katına çıkarırsam
tamamını okuyanların oranı düşüreceği için bu kitabım üzerine konuşmayı
burada kesiyorum.
C# 3.0 Kitabımın Önsözü...

2004 yılında yayınlanan ilk C# kitabım 950 sayfaydı ve yeni başlayanların öncelikle
öğrenmek isteyeceklerini sandığım konuları içeriyordu. Başka bir deyişle konuları
bütün ayrıntılarıyla anlatmak yerine 950 sayfaya mümkün mertebe çok sayıda
konuyu sığdırmayı hedefleniştim. Bu nedenle ilk C# kitabımda hem temel konulara
yer vermiş hem de veritabanı yani ADO.NET konuları yeterli ağırlıkta işlenmişti.
Tabii 950 sayfada hem başlangıç hem de veritabanı konularına yer verince ileri
düzey denilen bazı konular kitapta kendilerine yer bulamamıştı. Sonra Visual Studio
2005’i temel alan C# 2.0 kitabım üzerinde çalışmaya başlamıştım. 2005 yılı başında
yazmaya başladığım bu kitabımın hem sayfa sayısını biraz artırıp hem de başlangıç
düzeyi diye bilinen konulara ayrılan sayfaları azaltma yoluna gidip kitabın içeriğinin
daha doyurucu olmasını hedeflemiştim. Ne var ki bölümleri kaleme aldıkça sayfa
sayısı tahminlerimin üzerine çıkmıştı. 1200 sayfalık bir C# kitabını tercih etmediğim
için 2 cilt olarak düzenlemeye karar vermiştim. C# 2.0 kitabımın ilk cildi yaklaşık
730 sayfa iken yalnızca ADO.NET’le ilgili konuları içeren 2. cilt 420 sayfaydı. Başka
bir deyişle C# 2.0 kitabım toplam 1150 sayfa olmasına rağmen ileri düzey diye
adlandırılan bazı konuları içermiyordu. Örneğin Assemby’ler, Attribute’ler ve
Reflection sınıfları hakkında bilgi verme imkanım olmamıştı.
Gelelim bu kitaba. ADO.NET hakkında bilgi içermeyen bu kitap 1070 sayfa olmasına
rağmen, ileri düzey diye anılan bir çok konuda ayrıntılı bilgi içermesine rağmen
kaleme alıp bu kitapta kullanmadığım elimde yaklaşık 300 sayfalık metin
bulunmaktadır. Başka bir anlatımla 2005 yılı sonunda yayınlanan ve C# 2.0’ı
anlatmak kaygısı ile kaleme aldığım kitabımın 1. cildinin üzerine 300 sayfayı
ekleyince bu kitap çıktı. Tabii bunu yaparken bölümleri yeniden kaleme alıp C# 3.0
ile gelen yeni özelliklerden söz ettim.
Bu kitaba önsöz yazarken C# kitabımın 1. cildi için hazırladığım önsözün bir kısmını
buraya alacağım: Bir programlama dilini anlatma kaygısı ile yazılan kitaplarla ilgili
olarak Başlangıç Düzeyi ile Başlangıç Konuları kavramları bazen birbirine
karıştırılıyor. Örneklemek gerekirse; başlangıç düzeyi bir kitapta değişkenler
hakkında bilgi içeren sayfalarda Pointer değişkenlerden söz edilmez. Ötesi başlangıç
düzeyi kitaplarda değişkenler hakkında bilgi verilirken ayrıntılara inilmez.
Düzeyi başlangıç olmayan kitaplar ise başlangıç konularını içerebilir. Bu açıdan bir
değerlendirme yapmak gerekirse, bu kitap ister istemez bazı başlangıç konularını
içermektedir. Ancak bu kitapta ileri düzey diye değerlendirilen kitaplardaki birçok
konu hakkında ayrıntılı bilgi bulunmaktadır. Örneğin usta bir programcının
değişkenler hakkında ne bilmesi gerekiyorsa hepsi bu kitapta bulunmaktadır. Buna
rağmen bu kitapta her konu başlangıç düzeyi kitaplarının basitliğinde anlatıldı. Yine
örneklemek gerekirse bu kitapta Pointer değişkenler ve Attribute’ler hakkında bilgi
içeren sayfalar ilk okumada anlaşılacak yalınlıktadır.
Bu kitabı kaleme alırken beni en çok zorlayan çalışma, kitapta hangi konulara yer
yerip, kitap için seçtiğim konulara ayrılacak sayfaların sayısını tespit etmek oldu.
Örneğin Assembyl’ler hakkında mutlaka bilgi vermek gerekiyordu. Ötesi Assembly
kavramı hakkında bilgi sahibi olmayan birisine mevcut assembly’lerden söz etmenin
zorluğu ortadadır. Đşte asıl zorluk burada başlıyor:Çünkü Assembly çok geniş bir
konudur. Kitapta hiç söz edilmemesi başka sorun, bütün yönleri ile anlatıldığında
başka sorunlara neden olmaktadır. Benim tercihim orta yolu bulmak şeklinde oldu.
Yani Assembly’leri bütün yönleri ve ayrıntıları ile anlatmak yerine temel
özelliklerinden söz etmekle yetindim.
Benzer orta yol tercihini Attribute’ler, Generic sınıflar, Windows Mesajları, Reflection
için de yaptım. Gelelim bu kitapta torpil geçtiğim konulara: 2004 yılında yazdığım
C# kitabını kaleme alırken başka bir C# kitabından çalıntı yapmakla suçlandım.
Suçlamaların asıl dayanak noktası değişken adı benzerliğiydi. Değişken adı
benzerliğine sıfıra bölme hatasının, Selection Sort işleminin ve Word belgeleri
üzerinde nasıl işlem yapıldığının anlatıldığı sayfalarda vs. rastlanmıştı. Her ne kadar
benzer olduğu söylenen değişkenlerin adlarının bir çoğunu 1994 yılında yayınlanan
Clipper kitabımda yıllar önce kullanmış olsam bile çalıntı yapmakla suçlandığım
konulara bu kitapta torpil geçip daha ayrıntılı bir şekilde ele aldım. Belki bu şekilde
bu konuları bildiğime bir kaç kişiyi inandırmış olurum. Ötesi değişken adı
benzerliğinden dolayı tekrar suçlanmamak için Osmanlıca bir sözlük edinip bazı
değişkenlere Osmanlıca adlar verdim.
Memik Yanık ve Programcılık
Programcılık üzerinde yoğun bir şekilde çalışmaya 1989 yılında başladım. O

günlerde işletim sistemi olarak DOS’un 3.30 sürümü yaygındı. Programcılık
denilince akla GW Basic, Pascal ve C gelirdi. Tabii o günlerde yaygın olarak
kullanılan dBASE III Plus’ı unutmamak gerek. dBASE III+ yorumlayıcı bir ortam
sunduğu için programcıları dBASE derleyicisi arayışına sevk ediyordu. Bu arada
dBASE’den daha iyi bir dBASE iddiası ile Fox firması tarafından hazırlanıp piyasaya
verilen FoxPro’yu unutmamak gerekir. Konu program yazmak olduğunda FoxPro her
zaman dBASE’den iyi olmuştur. Tam bu günlerde dBASE kodu yazmak isteyenlerin
imdadına bir dBASE derleyicisi olan Clipper yetişti. Clipper ne mi yapıyordu? dBASE
III+’ın tekstine bağlı kalınarak(%100 değil) yazılan kodu derleyip kendi başına
çalışan EXE yapıyordu. Bununla da yetinmeyip dBASE’e kolayca ekler yapılmasının
önünü açıyordu. O günlerde yüzlerce yazılım firması Clipper için Library’ler
hazırlamıştı(Funcky Lib’i unutmamak gerek). En yaygın kullanılan Clipper sürümü
Summer 97 idi.
Bir süre sonra dBASE’in o günlerdeki sahibi A. Tate firması büyük gürültülerle
dBASE IV’ü çıkardı. Clipper ise dBASE IV uyumlu olmayı bırakıp Clipper 5.0 ile kendi
yoluna devam etti. Clipper ile veritabanı işlemleri son derece kolay olduğu için
binlerce yerli yazılım firması uygulamalarını Clipper ile geliştiriyordu. Clipper ile
çalışmayı sevince bir süre sonra Clipper üzerine yazılar yazmaya başladım. 1992
yılında o zamanın bilgisayar dergilerinde Clipper konulu çok sayıda yazım
yayınlandı. O günlerde Clipper konulu bir tek Türkçe kitap vardı. Bu kitap ise Ankara
merkezli Ekonomist yayınevinden çıkan çeviri bir kitaptı. Yani anlayacağınız Clipper
konulu Türkçe kaynak yok gibiydi. Bu nedenle Clipper konulu kitap yazmaya karar
verdim. Şu aralar Memik Yanık’ı değişkenlerini çalmakla itham edenler belki o
günlerde yaşları itibarı ile bilgisayarla henüz tanışmamıştı. Üstelik Memik Yanık
bugünlerde çalmakla itham edildiği değişkenlerin adlarını Clipper kitabında
kullanmıştı.
Tekrar etmek gerekirse; Clipper kitabını kaleme alırken yıl 1993, internet yok,
Türkçe yayınlanmış bir tek Clipper kitabı var. Ki bu kitap kapsamlı değildi. Bu
şartlarda son derece kısıtlı Đngilizcesi ile Memik Yanık taraflı tarafsız herkes
tarafından beğenilip çok satan Clipper 5.2 kitabını yazıp yayınlıyor. Üstelik
bugünlerde değişken çalmakla itham edilen Memik Yanık bu kitabında verdiği
kodlarda i, j, sayi, dosya vs adında değişkenler tanımlayıp kullanıyor(!). Bir Allahın
kulu çıkıp Memik Yanık bu kitabı yani Clipper kitabını çevirmiştir demiyor.
Diyemezlerdi çünkü kitabın içeriğinin bir kısmını daha önce dergilerde
yayınlamıştım. Neyse uzatmayayım; Memik Yanık 1993 yılında Internet’in olmadığı
günlerde bir tek Türkçe kaynağın olduğu günlerde Clipper 5.2 adında süper bir
programcılık kitabı yazdı mı? Yazdı. Bu kitap sayesinde binlerce kişi programcı oldu
mu? Cevap net:Oldu. Bu yıllarda insanlar Clipper ile harıl harıl program yazarken
hiçbir üniversite ve yüksek okulda Clipper dersleri verilmiyordu.
Programcılar dBASE IV yerine Clipper’a yönelince A.Tate firması(o günlerde Borland

tarafından satın alınmıştı) dBASE derleyicisi arayışına girmişti. Derken Borland
firması şu anda adını hatırlamadığım bir firmanın dBASE derleyicisini satın alıp
dBASE IV Compiler adıyla piyasaya verdi. Elimde bir tek Help metinleri varken
1995 yılınca gece gündüz çalışıp dBASE IV Compiler adında bir kitap hazırladım. O
günlerde dBASE IV Compiler hakkında bırakın Türkçe kaynağı yabancı kaynak
bulmak bile Türkiye şartlarında imkansız gibiydi. Yabancı kaynak olsa bile benim
için değişen bir şey olmazdı. Çünkü Clipper ve dBASE IV Compiler kitaplarını kaleme
alırken programcıların ihtiyaçlarını gözetiyordum. Clipper ile program geliştiren birisi
ne biliyorsa, neleri kullanıyorsa kitaplarda o konulara yer veriyordum. Bir süre
sonra Windows uyumlu programcılık yaygınlaşmaya başlayınca Borland firması
dBASE’in Windows uyumlu sürümünü çıkardı ama fazla tutulmadı. Çünkü bu sırada
Microsoft firması Access’i piyasaya vermişti. Kısaca özetlemek gerekirse dBASE
Compiler üzerine yazdığım kitap alanında tek kaldı. Yani dBASE IV Compiler kitabı
dolayısıyla Memik Yanık’ın dava edilmesi mümkün değildi.
dBASE IV Compiler kitabını tamamladıktan sonra FoxPro 2.6 üzerinde çalışmaya

başladım. FoxPro 2.6’nın hem DOS hem de Windows 3.1 uyumlu sürümü vardı.
Amacım Windows programcılığını anlatmak olduğu için Windows sürümünü tercih
etmiştim. Daha önce Clipper ve dBASE Compiler konulu kitaplar yazmış olmam
benim için avantajdı. Sizleri hemen uyarmak isterim o günlerde FoxPro’nun
Windows sürümünü kendisine konu edinen başka kitap olmadığından bugün ki gibi
Memik Yanık’ı kitaplarından değişken çalmakla veya Selection Sort sıralama
algoritmasını almakla suçlayacak kimse yoktu. Dolayısıyla Memik Yanık’ı FoxPro 2.6
kitabında başkalarına ait değişkenleri çalma suçlamasını onaylamak Prof unvanlı
kimseye nasip olamadı.
Sanırım FoxPro 2.6 kitabım çok iyi olmuştu ki o zamanın Microsoft genel müdürü
beni telefonla arayıp teşekkür etmişti. Đzin verin 2 cümle daha ekleyeyim: Yani daha
önce hakkında kitabı bırakın makale bile yazılmamış bir konuda Memik Yanık kitap
yazıyor, hem de o günün şartlarına göre çok iyi bir kitap yazıyor. Sonra aradan tam
10 yıl geçiyor birileri çıkıyor Memik Yanık’ı sıfıra bölme hatasını anlatmak üzere
yazdığı 3 satırlık kodun kendi kitaplarından çalıntı olduğunu iddia ediyor. Kanıt ise
bu 3 satırlık kodda kullanılan sayi1, sayi2 adı verilen değişkenlermiş. Yani Memik
Yanık sınıfa bölme hatasını anlatmak için yazdığı kodda tanımladığı değişkenlere
sayi1, sayi2 yerine number1, number2 adlarını vermiş olsaydı kitabında verdiği 3
kod değerinden çok şey kaybedecekti(!).
Gelelim Visual Basic 3.0 kitabına. Microsoft firması daha önce Visual Basic’nin 2
sürümünü çıkarmış olsa bile ilgi 3.0 sürümü ile geldi. Visual Basic 3.0 piyasaya
verildikten sonra bir süre sonra Microsoft Press tarafından yayınlanmış kitap
Türkçe olarak yayınlandı. Son derece kısıtlı bir içeriği sahip bu kitabı görünce Visual
Basic konulu kitap yazmaya karar verdim. Uzun uğraşlar sonucu Visual Basic 3.0
kitabım çıktı. Bu kitap çok beğenildi. Çünkü Visual Basic konusu ilk kitabım o günün
şartlarına göre çok sayıda ileri düzey konu içeriyordu. Örneğin kod yazarak çalışma
anında Access veritabanının nasıl hazırlandığını adım adım ilk anlatan Memik
Yanık’tır. Bilmeyenlere hatırlatmak isterim: Visual Basic 3.0 Windows’un 3.1
sürümüne gerek duyuyordu. Ötesi Visual Basic 3.0 piyasaya verildiği günlerde
insanlar Windows’u yeni yeni kullanmaya başlamışlardı. Dolayısıyla programcılığa
çok sonra başlayıp uzman programcı olan bazı arkadaşlar Memik Yanık’ın 1995
yılında yazdığı Visual Basic kitabını bugünün şartlarına göre değerlendirip yorum
yapıyorlar. Bu arkadaşlar son birkaç yıl içinde yayınlanan ADO.NET, Delphi 2007,
C# 3.0 ve Visual Basic 9.0 kitaplarımı artık 5-6 yıl sonra güncelliklerini
kaybettiklerinde zahmet edip değerlendirirler.
C# 3.0 Kitabımdan Alınma Örnek Bölüm

C# UYGULAMALARINDA WORD’den YARARLANMAK
Bu uzun makaleyi yakında zamanda yazımını tamamladığım C# 3.0
kitabımdan aldım. Kitaptan aldığım bu metne bazı eklemeler yapıp küçük
değişiklikler yaptım. Son yıllarda yayınlanan programcılık kitaplarının bir
bölümü okurlar kitap hakkında fikir sahibi olsunlar diye nette
yayınlanmaktadır. Ne var ki C# 3.0 kitabımın bu bölümünü burada sizinle
paylaşıyor olmamın nedeni başka. Çünkü sözünü ettiğim kitabın hata
yakalamakla ilgili uzunca bölümünü daha önce sizlerle zaten paylaşmıştım.
Başka bir deyişle bu bölümü yayınlama nedenim kitabın içeriği ve anlatım
şekli konusunda sizleri bilgilendirmek değildir.
Kısaca açıklayayım: 2004 yayınlanan C# kitabımda toplam 8 sayfada C#

uygulamalarında Word ve Excel’den nasıl yaralanıldığını ayrıntıya girmeden
kendimce anlatmıştım. Tabii C# uygulamalarında Word belgeleri ve Excel
tabloları üzerinde nasıl işlem yapılabildiğini annemim karnında iken
öğrenmemiştim. Bu konuda bilgi edinmek için MSDN’e ve birkaç
programcılık sitesine bakmıştım. Doğal olarak Word belgeleri üzerinde işlem
yapılırken kullanmam gereken sınıfların hangileri olduklarını öğrenmiştim.
Ötesi bu sınıfların hangi referans ve namespace’lerde olduğunu öğrenip ona
göre nasıl bir hazırlamak yapmak gerektiğini araştırmıştım.
C# 1.0 kitabımı kaleme aldığım günlerde birkaç yerli web sitesinde yukarıda
sözünü ettiğim soruların cevapları zaten vardı. Buna rağmen birileri çıkıp
Memik Yanık kitabında Word ve Excel’le ilgili olarak yazdıklarını “bizim
kitapları okumadan öğrenmiş olamaz” dediler. Sanki söz konusu olan bir pop
müzik sanatçısı ile yapılmış özel bir söyleşiymiş, sanki ikinci bir kaynağın
olabilme ihtimalinin sıfır olduğu özel bir araştırmaymış söz konusu olan. Hal
bu ki Microsoft gibi derleyici üreten firmalar derleyicileri hakkında en küçük
ayrıntıları bile derleyiciyi piyasaya vermeden çok önce açıklıyorlar. Yoksa
insanlar nasıl program yazarlardı, yazarlar nasıl programcılık kitapları
yazarlardı? Yayınlanıp piyasada satılan bir programcılık kitabını edinip bir
konuyu öğrenmek doğal olmasına rağmen C# kitabımın Word ve Excel’le
ilgili bölümünü yazarken yerli web sitelerindeki 2 yazıyı ve MSDN’de birkaç
metodun orijinal yapısına bakmakla yetinmiştim.
C# uygulamaları dahilinde Word belgeleri ve Excel tabloları üzerinde işlem

yaparken tanımlamam gereken değişkenlere ad verebildiğimi ve kullanılması
gereken metotların yapısını ve parametrelerini yerli kaynaklara bakmadan
öğrenebildiğimi kanıtlamak için C# 3.0 kitabımda Word ve Excel
uygulamaları üzerinde nasıl işlem yapıldığı bölümdeki sayfa sayısını biraz
arttırıp bugün kadar bu konuda kaleme alınmış en uzun ve ayrıntılı metni
hazırladım. Belki bu sayede Memik Yanık çeviri yapıyor diyenler, Memik
Yanık değişken çalıyor diyenler ellerini vicdanlarına götürme gereğini
duyarlar. Kısa bir süre sonra bu metni nasıl kaleme aldığımı adım adım
açıkladığım bir makale hazırlayıp “Programcılar Đçin Yazarlık Dersleri 4”
adıyla yayınlayacağım.
C# projelerinde Word ve Excel’in kaynaklarından kolaylıkla

yararlanabilirsiniz. Bu sayede kullanıcının bilgi girmesi gerektiği zaman
karşısına Word penceresini veya tablo hazırlaması gerektiği zaman Excel
penceresini getirebilirsiniz. Bu makalede C# uygulamaları dahilinde Word ve
Excel ile yapılabilineceklerin ancak bir özetine yer verebildim. Kitabımın bu
bölümünü ilk kaleme aldığımda uzunluğu 10 sayfaydı. Ne ki özel
nedenlerden dolayı bu bölüme biraz torpil geçip sayfa sayısını arttırdım. Bu
sayede bu konuda en ayrıntılı Türkçe metni kaleme almış oldum. Madem
şimdiye kadar hiçbir Türkçe kaynakta bu konu bu kadar ayrıntılı anlatılmadı
o halde yerli kaynaklardan izinsiz alıntı yapmış olma ve değişken adı çalma
ihtimalim azalmış oluyor(!). Her ne kadar bu bölümde yalnızca Word ve
Excel’den söz edilmiş olunsa bile C# uygulamaları dahilinde diğer Office
programlarından da yararlanmak mümkündür.
C# projesi dahilinde Word’den yararlanmak istiyorsanız ilk olarak Solution

Explorer penceresinde References seçeneğine ait kısayol menüsünden
komut verip Add Reference diyalog kutusunu ekrana getirip COM
sekmesindeki Microsoft Office 11 Object Library adlı bileşeni seçip
uygulamaya dahil etmelisiniz. Daha doğrusu C# uygulamasını bu
referanstan haberdar etmelisiniz.
Bu ekran görüntüsünü aldığım sırada kullandığım bilgisayarda Word 2003

yüklüydü. Kullanılan bilgisayara Word’ün XP sürümü yüklüyse bu bileşenin
adı Microsoft Office 10 Object Library olur.
2003 içinde ilk C# kitabımı kaleme alırken Add Reference diyalog kutusunda
araştırmaya çıkıp acaba Word belgeleri üzerinde işlem yaparken hangi
referansı kullanmak gerekiyordur sorusuna kendimce cevap arasaydım
bulmak zor olmazdı. Ancak çok daha önce birkaç yerli web sitesinde bu
konu üzerine yazılmış makaleler ilk yayınlandıklarında okuduğum için Word
belgeleri üzerinde işlem yaparken gerek duyulacak sınıfların hangi
namespace’lerde, bu namespace’lerin ise hangi referanslarda yer aldığını
biliyordum.
Visual Studio 2005 ile hazırlanan projelerde bu bileşen seçilip OK düğmesi

tıklandığında projeye 3 referans eklenirdi. Visual Studio 2008’de yukarıda
yapılan işlem projeye yalnızca Microsoft.Office.Core referansının
eklenmesine neden olmaktadır. Bu nedenle Add Reference diyalog
kutusunu tekrar ekrana getirip .NET sekmesinde ayrıca
Microsoft.Office.Interop.Word referansını projeye eklemek
gerekmektedir.
Proje bu 2 referans hakkında bilgilendirildikten sonra kodun en üstüne

aşağıda verdiğim 2 satırı yazarak ilgili namespace’lerdeki Class’lardan
yararlanmak istediğinizi işaret etmelisiniz. Başlangıçta
Microsoft.Office.Core’deki sınıflardan yararlanmayacağımız için using

bloğunda bu namespace’in adını işaret etmeyebilirsiniz.
using Microsoft.Office.Core;
using Microsoft.Office.Interop.Word;
Gerekli referansları projeye dahil edip(başka bir deyişle bu referanslardan

derleyiciyi haberdar ettikten…) bu namespace’lerdeki class’lardan
yararlanacağımı using deyimiyle işaret ettikten sonra forma yerleştirdiğim
düğmenin Click olayını temsil eden metodu aşağıdaki gibi düzenledim.
private void Word_penceresi_Click(object sender, EventArgs e)

{
Microsoft.Office.Interop.Word.ApplicationClass Word_uygulamasi;
Word_uygulamasi= new Microsoft.Office.Interop.Word.ApplicationClass();
}
Şimdi burada biraz duralım. Bu 2 satırlık kodda örneğini aldığım sınıfın adı
Word.ApplicationClass. Bu sınıftan yola çıkıp hazırlanacak nesneye
“Word_uygulamasi” gibi Türkçe bir ad verilirsek(yani bu sınıfa Türkçe bir
karşılık ararsak) başka Türkçe kaynaklarla benzer değişken adını kullanma
tehlikesi ile karşı karşıya gelebiliriz. Başka bir deyişle başka yazarların
kıymetli değişkenlerinin adını çalmakla suçlanabiliriz. Bunun önüne geçmek
için, başka bir deyişle 2 satırlık bu kodda tanımlanan değişkene
programcılar ad seçerken başka kaynaklardan değişken avına çıkmalarının
mecburi olmadığını kanıtlamak için bu kodu aşağıdaki gibi düzenledim. Yani
başlangıçta Word_uygulamasi adını verdiğim değişkenin adını
“Word_nesnesi” olarak değiştirdim.

{
Microsoft.Office.Interop.Word.ApplicationClass Word_nesnesi;
Word_nesnesi = new Microsoft.Office.Interop.Word.ApplicationClass();
}
Tabii programcıların yazacakları kodların başkaları tarafından görülmesi

düşük ihtimal olduğu için değişkenlere ad seçerken kendilerini birden
“değişken hırsızı” olarak görmeleri zordur. Bu nedenle bu kodu aşağıdaki
gibi değiştirip kendinizi iyice sağlama alabilirsiniz.

{
Microsoft.Office.Interop.Word.ApplicationClass Word_tokmagi;
Word_tokmagi = new Microsoft.Office.Interop.Word.ApplicationClass();
}
Bu metotta Word.ApplicationClass nesnesini hazırlama işlemini 2 satırda

gerçekleştirdim ve söz konusu Class’ın yer aldığı namespace’i işaret ettim.
Daha önceden bu namespace’deki sınıflardan yararlanmak istediğimi using
deyimi ile belirttiğim için bu kodun satırlarını kısaltmak mümkündür. Bu
metoda yazılan ilk 2 satır sayesinde Word programı başlatılır ama ekranda
görünmez. Word penceresinin ekranda görünmesi için
Word.ApplicationClass’tan yararlanarak hazırladığınız nesnesinin Visible
özelliğini true yapmalısınız. Bu nedenle yukarıda verdiğim metoda 3. bir
satır ekledim.

{
ApplicationClass Word_nesnesi;
Word_nesnesi = new ApplicationClass();
Word_nesnesi.Visible = true;
}
Projeyi çalıştırıp bu metodu işletince aşağıdaki gibi bir sonuç elde ettim. Bu
şekilde açılan Word penceresinde herhangi bir belge olmaz. Bu sırada komut
verip Word penceresinde yeni belge hazırlayabilir veya mevcut belgeleri
açabilirsiniz. Daha açık bir anlatımla yukarıda hazırladığımız
ApplicationClass nesnesi Başlat menüsünden komut vererek ekrana
getirdiğimiz Word penceresini temsil ediyor.
Şimdi yukarıda verdiğim kodda değişiklik yapıp Word penceresi ekrana

getirildiği zaman boş bir belgenin hazırlanmasını sağlayacağım. Yukarıda
hazırladığımız ApplicationClass nesnesinin Documents adında bir
koleksiyonu bulunmakta ve açılan(ya da hazırlanan) Word belgeleri bu
koleksiyonda saklanmaktadır. Başka bir deyişle hazırlanacak belgenin veya
Document nesnesinin bu koleksiyona eklenmesi gerekiyor.
Yukarıda verdiğim ekran görüntüsünü aldığım sırada Word penceresi içinde

görüntülenen herhangi bir belge olmadığı için Documents koleksiyonu
herhangi bir elemana sahip değildir. Document nesneleri DocumentClass

sınıfının Add() metodundan yararlanılarak hazırlanmaktadır. Bu amaçla
Document nesnesi hazırlayıp bu nesneyi Add() metodu ile
ApplicationClass nesnesine ekleyeceğim. Başka bir deyişle Document
nesnesi klasik yöntemle new anahtar kelimesiyle sınıftan yola çıkılarak
hazırlanıp sonra da ilgili koleksiyona eklenmiyor. Add() metodu, hem nesne
hazırlama hem de koleksiyona ekleme işlemini bir seferde yapmaktadır.
Lütfen uzatmama izin verin: Öncelikle Microsoft’un sitesine yani MSDN’de

burada sözünü ettiğim Add() metodu ile ilgili olarak verilen örneği size
sunacağım. Aşağıda verdiğim kod eski sürüme göre hazırlanmış. Bu kitapta
C# hakkında bilgi verirken Visual Studio 2008 ve C# 3.0’ı kullandığım için
küçük farklılıklar olabilir.
object missing = System.Reflection.Missing.Value;

object template = @"C:\Test\SampleTemplate.dot";
this.Application.Documents.Add(ref template, ref missing, ref missing, ref missing);
Burada dikkatinize sunmak istediğim asıl konu Add() metodunun 4

parametreye sahip olmasıdır. Parametrelerden ilkinde hazırlanmak istenen
Word belgesine temel oluşturacak DOT uzantılı şablon dosyası verilmektedir.
Zaten ilk parametrenin yararlanılmak istenen şablon olması gerektiği
MSDN’den aldığım 2 satırlık kodda işaret ediliyor. Başka bir deyişle 1.
parametrede sorun yok ve şablon olarak kullanmak istediğimiz DOT uzantılı
dosyayı ve yolunu belirteceğiz. Word başlatılıp içeriği boş bir belge
hazırlandığında “normal.dot” adlı şablon dosyasının kullanıldığını
biliyorsunuz. Yıllar önce Word konulu kitap yazmış birisi olduğum için
umarım birileri çıkıp “DOT uzantılı dosya hakkında yukarıda yazdığım
cümleyi başka kaynaktan izin alıntı yaptığımı ileri sürmezler.
Add() metodunun 2., 3. ve 4. parametreleri ise

System.Reflection.Missing.Value tipindedir. Microsoft’un programcıları
tarafından Add() metodunu örneklemek için yazılan bu 3 satırlık kodda 2.,
3. ve 4. parametre için önceden “missing” adında değişken tanımlamışlar.
Her ne kadar bu örnek kodda Add() metodunun 2., 3. ve 4. parametreleri
aynı tipte olsa bile farklı işlevleri vardır. Bu parametrelerin işlevlerini ileriki
sayfalarda sırasıyla anlatacağım. Gerçekte Add() metodunun son 3
parametresiyle ilgilenmeyebilirsiniz.
Madem C# uygulaması dahilinde yeni bir Word belgesi hazırlayacağız Add()

metodunu yukarıdaki gibi kullanmaktan başka çaremiz yoktur. Belki de
vardır ama bu konuda bilgim ne yazık ki yoktur. Belki birileri çıkıp yukarıda
yapısını verdiğim Add() metodunu kullanmadan nasıl Word belgesi
hazırlandığını anlatırlar. Biz de o tekniği kullanırken mucitlerini anarız,
kendilerine her seferinde teşekkür ederiz.
Şimdilik Add() metodunu kullanmak dışında başka teknik olmadığına göre

ilk olarak kullandığım bilgisayarda arama yapıp “Normal.dot” adlı dosyayı
bulup “C:” sürücüsünün kök klasörüne kopyaladım. dot uzantılı bu şablon
dosyasının adını ise “sablon” adını verdiğim bir değişkene aktardım.
Sonra da Microsoft’un programcılarının yaptığı gibi

System.Reflection.Missing.Value tipinde bir değişken tanımladım. Madem bu
değişken Value tipindedir ben de aklı evvellik yapıp yani bütün imkanlarımı
seferber edip bu değişkene orijinal bir ad bulamayınca bu değişkene
Türkçesi olan “deger” adını verdim. Bu 2 hazırlıktan sonra yukarıda verdiğim
kod aşağıda verilen şekle dönüştü.

{
object sablon = "C:\\Normal.dot";
object deger = System.Reflection.Missing.Value;
}
Her ne kadar Value tipindeki değişkene ad verirken Türkçe karşılığını

kullanmış olsam bile “deger” birçok programcı ve yazar tarafından kullanılan
bir değişken adı olduğu için riske girmeye cesaret edemeyip bu değişkene
ad verirken MSDN’den değişken adı çalma yolunu tercih ettim. Çünkü elin
gavurları değişkenlerinin adları konusunda hak talep etmiyorlar. Sözünü
ettiğim 2 değişkeni tanımladıktan sonra hazırlanacak belgenin aktarılacağı
bir DocumentClass nesnesi hazırladım. DocumentClass nesnesine gönül
rahatlığı ile Belge1 adını verdim. Çünkü Word belgelere Belge1, Belge2 gibi
adlar veriyor. Microsoft firması beni değişken adlarını çalmakla
suçlamayacağına göre tehlike yoktur.

{
Microsoft.Office.Interop.Word.Document Belge1 = new DocumentClass();
}
Bu hazırlıklardan sonra şimdi sırada Add() metodunu kullanıp Word

belgesini hazırlamak var. Bu amaçla bu koda ekleme yaptım. Aşağıda
verilen kod işletildiğinde tıpkı Word başlatılıp başlangıçta “Belge1” gibi ada
sahip bir belge hazırlandığı gibi C# uygulaması dahilinde Word başlatılıp
“Belge1” adında bir belge hazırlanmış olunur. Bu belgeye istenildiği gibi bilgi
girilip kaydedilebilir.

{
Microsoft.Office.Interop.Word.Document Belge1 = new DocumentClass();
Belge1 = Word_nesnesi.Documents.Add(ref sablon,
ref missing, ref missing, ref missing);
}
Bundan 4 yıl önce yayınlanan ilk C# kitabımda konuyu uzatmak istemediğim

için bu kodu bir seferde vermiştim. Bu kez ayrıntılara girmek istediğim için
adım adım anlatmaya çalışıyorum. Bu kodu dikkatle incelerseniz 2., 3. ve 4.
parametrelerin aynı olduklarını fark ederseniz. Çünkü bu 3 parametrenin
System.Reflection.Missing.Value tipinde olması sağlanırsa varsayılan
değerler kullanılır. Bunu bir de şöyle açıklamak gerek: Her ne kadar Add()
metodu 4 parametreye sahip olsa bile bunlardan ilki hariç diğer üçünü
belirtme gereğini duymuyorum. Buradaki karmaşanın geri planında Word
kaynaklı sınıfların yönetilen(managed) kod olmamalarında yatıyor. Tabi
System.Reflection.Missing.Value tipindeki değişken Türkçe bir ad
verilseydi kod belki biraz daha okunur olurda ama değişken adı çalmış olma
ihtimali artardı.
Đlk C# kitabım için Add() metodu hakkında günlerce araştırma yapmama

rağmen Add() metodunun son 3 parametresi hakkında net bilgilere
ulaşamamıştım. Đleriki sayfalarda hakkında bilgi verilecek Open()
metodunun 3. parametresinin işlevi açılacak belgeye ReadOnly özelliğini
veriyor olması beni yanıltmıştı. C# 1.0 kitabımı yazarken Add() metodunun
2. parametresinden ise hiç söz etmemiştim.
Şimdi gelelim 2. parametrenin asıl işlevine. C# uygulaması dahilinde Word

belgesi hazırlama amacınız yeni bir şablon hazırlamak ise 2. parametreden
yararlanabilirsiniz. Bu parametrenin işlevini göstermek için object tipinde
bir değişken tanımlayıp true yaptım.
ApplicationClass Word_nesnesi = new ApplicationClass();

Document Belge1 = new DocumentClass();
{
object yeni_sablon = true;
ref yeni_sablon, ref missing, ref missing);
}
Bu şekilde düzenlenen kod ile C# uygulaması dahilinde hazırlanan Word

belgesi hazırlanıp sonra da kaydedilmek istendiğinde varsayılan kayıt tipi
DOT uzantılı şablon olur. Tabii Farklı Kaydet diyalog kutusundaki Kayıt
Türü liste kutusunda kayıt türü olarak Word Belgesi veya başka bir format
seçilebilir. C# uygulaması dahilinde DOT uzantılı şablon dosyası hazırlamak
istemiyorsanız Add() metodunun 2. parametresi ile ilgilenmeyip bu
parametrenin System.Reflection.Missing.Value tipinde bir değişken olmasını
sağlayabilirsiniz.
Word uygulamasını temsil eden ApplicationClass nesnesi için yeni belge

hazırlanırken kullanılan Add() metodunun 3. parametresinin adı
DocumentType. Toplam 5 farklı değer alabilen bu parametre
kullanılmadığında, başka bir deyişle bu parametrenin yerine
System.Reflection.Missing.Value tipinde bir değişken kullanıldığında boş bir
belge hazırlanmak istendiği varsayılır. 3. parametrenin nasıl kullanıldığını
aşağıda görebilirsiniz.

{
object yeni_sablon = false;
object belge_tipi = WdNewDocumentType.wdNewBlankDocument;
ref yeni_sablon, ref belge_tipi, ref missing);
}
Bu koda dikkat ederseniz WdNewDocumentType adında bir Enum’un

olduğunu fark ederseniz. C# uygulaması dahilinde hazırlamak istediğim
Word belgesini web sayfası olarak değerlendirmek gibi bir amacım olsaydı
Add() metodunun 3. parametresini aşağıdaki gibi düzenlerdim
object belge_tipi = WdNewDocumentType.wdNewWebPage;
Microsoft.Office.Interop.Word’de yer alan WdNewDocumentType adlı

enum tipinin üyelerinin işlevlerini aşağıda tablo halinde verdim. Ek açıklama
yapmak gerekirse Word’ün güncel sürümleri ile istenen tipte ve içerikte
belgeler hazırlamak mümkündür.
Üye adı Đşlevi
wdNewBlankDocument Bol belge
wdNewEmailMessage E-mail
wdNewFrameset Frameset
wdNewWebPage Web sayfası
wdNewXMLDocument XML belgesi
Şimdi gelelim hazırlanan belgenin Word penceresinde görünmesini sağlayan

veya engelleyen 4. parametresine. 4. parametre yerine
System.Reflection.Missing.Value tipinde bilgi içeren Object tipinde bir
değişken kullanıldığında hazırlanan belge ekranda görünmektedir. Yukarıda
anlatılan şekilde hazırladığınız belgenin görünmesini istemiyorsanız bu
parametre için object tipinde bir değişken tanımlayıp false aktarmalısınız. Bu
işlemin nasıl yapıldığını aşağıda görebilirsiniz.

{
object gorunme = true;
ref yeni_sablon, ref belge_tipi, ref gorunme);
}
Bu şekilde düzenlenen kod işletilirse Word başlatılıp içeriği boş(tabii

Normal.dot’ın orijinal olduğunu varsayıyorum. Yani Microsoft’tan geldiği
şekli ile..) bir Word belgesi hazırlanıp ekrana getirilir. Gerçekte başka
yazarlar veya programcılar tarafından daha önce kullanılma ihtimali yüksek
olan “gorunme” adlı değişken yerine Microsoft’un verdiği kısa örneklerde
kullandığı visible’ı değişken adı olarak kullanmanız önerilir. Hazırlayıp Word
penceresine getirdiğiniz belgenin görüntülenmesini istemiyorsanız 4.
parametreyi false yapmalısınız. Aşağıda verilen kod işletildiğinde Word
penceresi ekrana gelir ama Add() metodu ile hazırlanan belge
görüntülenmez.

{
object visible = false;
ref yeni_sablon, ref belge_tipi, ref visible);
}
Hazırlayıp geri planda kod yazarak bilgi aktarıp sonra kaydetmek istediğiniz
Word belgesinin ekranda görünmesini istemeyebilirsiniz. Tabii
ApplicationClass nesnesinin Visible özelliğini false yapıp Word penceresini
görünmesini engellediyseniz Add() metodunun 4. parametresinin false ya da
true olmasının bir önemi olmuyor.
Bildiğiniz Word belge hazırlarken DOT uzantılı şablon dosyalarından

yararlanmaktadır ve Normal.dot şablonu varsayılan şablondur. Konu kolay
anlaşılsın diye bu şablonu “C:” sürücüsünün kök klasörüne kopyaladım.
Yukarıda anlatılan şekilde düzenlenen Add() metodu işletilirse ekrana
aşağıdaki gibi bir Word penceresi gelir. Bu sırada Word belgesine istediğiniz
gibi bilgi girebilir ve yeni belgeler hazırlayabilirsiniz.
Yine Word ile çalışırken arka arkaya birden fazla belgeyi hazırlayıp birden
fazla belge üzerinde çalışmak mümkündür. Şimdi yukarıda verdiğim koda
ekleme yapıp arka arkaya 2 Word belgesi hazırlayacağım.

{
object visible = true;
Belge1.Activate();
}
Tahmin edeceğiniz C# uygulaması dahilinde hazırlanan belgelerin birisi aktif

belgedir. Aktif belge normal şartlarda son hazırlanan veya açılan belgedir.
Hangi belgeyi aktif belge yapmak istiyorsanız Active() metodunu o belgeyi
temsil eden nesneye uygulamanız yeterlidir. Bu metodun nasıl kullanıldığını
yukarıda görebilirsiniz. Mevcut belgelerin nasıl açıldığı anlatıldıktan sonra
açık belgelerin arasında nasıl dolaşıldığı konularında bilgi verilecektir.
Word Belgelerine Bilgi Girmek
Yukarıda anlatılan şekilde hazırlanan Word belgesine doğrudan bilgi

girebileceğiniz gibi kod yazarak bilgi aktarabilirisiniz. Doğrudan bilgi
girdiğiniz Word belgesini C# uygulaması dahilinde kaydedebilir, kapatabilir
veya içeriğini yazdırabilirsiniz. Başka bir deyişle Word programı ile normal
şartlarda yapılan her işlemi C# uygulaması dahilinde kod yazarak
yapabilirsiniz.
Đlk olarak yukarıda anlatılan şekilde hazırladığım Word belgesine kod

yazarak bilgi girmeyi deneyeceğim. Belgelere bilgi girilirken Range
nesnesinin InsertAfter() veya InsertBefore() metotlarından
yararlanabilirsiniz. InsertAfter() metodunun nasıl kullanıldığını anlatmak için
Document tipindeki değişken tanımlandığım satırı metodun dışına alıp
“Form1” sınıfının bütün metotlarında yaşayabilmesine imkan sağladım.
Ardından forma bir düğme yerleştirip aşağıda verdiğim kodu yazdım. Forma
yerleştirdiğim bu düğmeye “ekle” adını vermek yerine Osmanlıca karşılık
aradım uygun düğme adı aklıma gelmedi. Çünkü “ekle” tehlikeli bir düğme
veya değişken adıdır, bakarsınız ekle’yi birileri register etmiştir, kullanım
hakkını 50 yıllığına satın almıştır.
private void ekle_Click(object sender, EventArgs e)

{
Belge1.Range(ref missing, ref missing).InsertAfter("Fenerbahçe");
}
Word penceresini açıp ekrana getirmek amacıyla hazırladığım metoda

eklediğim bu satır sayesinde ekleme noktasının bulunduğu yere
InsertAfter() metoduna parametre olarak verilen bilgi yazılır. Proje
çalıştırılıp bu kod işletildiğinde aşağıdaki gibi bir sonuç alınır.
Bildiğiniz gibi yeni bir Word belgesi hazırlandığı zaman belge içeriği boş bir
paragrafa sahip olmakta ve Enter tuşuna her basılışta yeni bir paragraf
hazırlanmaktadır. Bu şartlarda yani C# uygulaması dahilinde içeriği boş bir
belge hazırlanıp imleç belgenin başlangıç noktasında iken InsertAfter()
yerine InsertBefore() metodu kullanılmış olunsaydı aynı sonuç alınırdı.
Şimdi bu Word belgesine kod yazarak bir paragraf ekleyip tekrar bilgi
gireceğim. Belgeye paragraf ekleme işlemi, yani Paragraphs koleksiyonuna
eleman ekleme işlemi Add() metodu ile yapılmaktadır. Bu metodun nasıl
kullanıldığını aşağıda görebilirsiniz. Document nesnesinin Paragraphs
koleksiyonundan yararlanıp her türlü paragraf işlemlerini yapmak
mümkündür.

{
Belge1.Range(ref missing, ref missing).InsertAfter("Fenerbahçe");
Belge1.Paragraphs.Add(ref missing);
Belge1.Range(ref missing, ref missing).InsertAfter("Beşiktaş");
}
Bu şekilde düzenlenen kod işletilirse aşağıdaki gibi bir sonuç alınır. Bu sırada
Word belgesi 2 paragrafa sahiptir. Aynı şekilde Word belgesine istediğiniz
gibi bilgi girebilirsiniz.
Şimdi örnek olması için Word belgesine mevcut bir ListBox’ın elemanlarını
aktaracağım. Bu işlemi yapmak üzere hazırladığım kodu aşağıda verdim.
Benzer mantıkla veritabanından okunan kayıtların her birisi Word belgesine
ayrı bir satır olarak aktarılabilinir.
private void naklet_Click(object sender, EventArgs e)

{
int sayi = listBox1.Items.Count;
for (int i = 0; i < sayi; i++)
{
string satir = listBox1.Items[i].ToString() ;
Belge1.Range(ref missing, ref missing).InsertAfter(satir);
Belge1.Paragraphs.Add(ref missing);
}
}
Yukarıda anlatılan şekilde C# uygulaması dahilinde hazırlanan Word

belgesine bilgi aktarma işlemi asıl Selection nesnesinin TypeText()
metodu ile yapılmaktadır. Bu metodun nasıl kullanıldığını aşağıda
görebilirsiniz.

{
Word_nesnesi.Selection.TypeText("Fenerbahçe");
}
Bu metot aktif Word belgesinde imleç nerede bulunuyorsa imlecin sonuna

kendisine parametre olarak verilen bilgiyi yazar. Başka bir deyişle söz
konusu belgede seçili bir kısmı yoksa bunun imlecin bulunduğu yer olduğu
varsayılır.
Şimdi yukarıda verdiğim örneği değiştirip ListBox’ın içeriğini Word belgesine

aktarırken Selection nesnesinin TypeText() metodundan yararlanacağım.
Değişken adı benzerliğinden suçlanmamak için bu işlemi yapacak düğmeye

“Aktar” yerine “naklet” adını verdim.

{
int sayi = listBox1.Items.Count;
for (int i = 0; i < sayi; i++)
{
string satir = listBox1.Items[i].ToString() ;
Word_nesnesi.Selection.TypeText(satir);
Word_nesnesi.Selection.TypeText("\n");
}
}
C# uygulamasının formundaki bir TextBox’a yazdığınız her karakterin

anında Word belgesine aktarılmasını istiyorsanız söz konusu TextBox’ın
KeyPress olayını temsil eden metodu aşağıdaki gibi düzenleyebilirsiniz.
TextBox aracılığı ile Word belgesine aktarmak istediğiniz metin birden fazla
satırdan meydana gelecekse MultiLine özelliğini True yapmanız gerekir.
private void textBox1_KeyPress(object sender,KeyPressEventArgs e)

{
char kar = e.KeyChar;
Word_nesnesi.Selection.TypeText(kar.ToString());
}
Bu 2 satırlık kod ile Word belgesine TextBox aracılığı ile bilgi aktarırken
TextBox’ın MutliLine özelliği True iken Enter tuşuna basılıp bir alt satıra
inildiğinde Word belgesinde yeni bir paragrafa geçilmiş olunur. Aktif Word
belgesine paragraf eklerken Selection sınıfının TypeParagraph()
metodunu kullanabilirsiniz.
private void Parag_ekle_Click(object sender, EventArgs e)

{
Word_nesnesi.Selection.TypeParagraph();
}
Nasıl ki ListBox’ların Items koleksiyonları varsa C# uygulamaları dahilinden

hazırlanan Word belgelerinin yani Document nesnelerinin Characters,
Words, Sentences, Paragraphs ve Sections koleksiyonları vardır. Bu
koleksiyonlardan yararlanarak belge hakkında bilgi edinebilir veya belge
üzerinde bazı işlemleri yapabilirsiniz.
Şimdi C# projesi dahilinde hazırladığım Word belgesinin içeriğini forma

yerleştirdiğim RichTextBox’a aktaracağım. Bu işlem için Range nesnesini
aşağıdaki gibi kullandım.

{
richTextBox1.Text=Belge1.Range(ref missing, ref missing ).Text;
}
Yukarıda Word penceresine yazılanları RichTextBox’a aktarırken Range()

nesnesine parametre olarak System.Reflection.Missing.Value sabitini
içeren object tipindeki “missing ” adını verdiğim değişkeni kullandım. Word
penceresine yazılanların hepsini değil de belli sayıdaki karakterini aktarmak
istiyorsanız alınacak ilk ve son karakterin sıra numarasını Range() nesnesine
aşağıdaki gibi parametre olarak vermelisiniz.
private void Aktar_Click(object sender, EventArgs e)

{
object Baslama = 0;
object Bitis = 500;
richTextBox1.Text =Belge1.Range(ref Baslama, ref Bitis).Text;
}
Şimdi ise C# uygulaması dahilinde açtığım Word belgesinin içeriğini

okumaya çalışacağım. Word belgesindeki ilk kelimeyi okumak istemiş
olsaydım aşağıdaki gibi bir satır yazardım. Bu kodda kullandığım
“Word_nesnesi” C# uygulaması dahilinde hazırladığım Word penceresini,
ActiveDocument ise o sırada aktif olan belgeyi temsil etmektedir. Açık
olan her hangi bir belge yokken bu satır işletilirse hata meydana gelir.
textBox1.Text = Word_nesnesi.ActiveDocument.Words[1].Text;
Tekrar uyarmak gerekirse, konu C# uygulaması dahilinde açılan Word

belgesi olduğunda Words gibi koleksiyonların ilk elemanın sıra numarası 0
olmayıp 1’dir. Belgedeki bütün kelimeleri yani bütün içeriğini okumak
istemiş olsaydım aşağıdaki gibi kod yazardım.
int sayi = Word_nesnesi.ActiveDocument.Words.Count;

for (int i = 1; i <= sayi; i++)
{
richTextBox1.Text = richTextBox1.Text +
Word_nesnesi.ActiveDocument.Words[i].Text;
}
Yukarıda belirtildiği gibi ActiveDocument nesnesinin Words’den başka

Characters koleksiyonu bulunmaktadır. Bu koleksiyondan yararlanıp Word
belgesinden istenen karakterler okunabilir. Şimdi Word belgesinin 2.
cümlesini okuyup RichTextBox’a aktaracağım. Word programı cümleleri
birbirinden ayırırken nokta ve ardından gelen boşluktan yararlanmaktadır.
Başka bir deyişle cümle sonunu işaret etmek üzere yazılan noktadan sonra
boşluğa yer verilmezse Word cümlenin devam ettiğini sanıyor.
richTextBox1.Text = Word_nesnesi.ActiveDocument.Sentences[2].Text;
C# uygulaması dahilinde açtığım veya hazırlayıp bilgi aktardığım Word

belgesinden paragraf bazında okuma yapmak isteseydim aşağıdaki gibi kod
yazardım. Aşağıda verilen satır sayesinde belginin ilk paragrafı
RichTextBox’a aktarılır.
richTextBox1.Text= Word_nesnesi.ActiveDocument.Paragraphs[1].Range.Text;
Aktif belgenin bütün içeriğini okumak istemiş olsaydım aşağıdaki gibi kod
yazardım.

int sayi = Word_nesnesi.ActiveDocument.Paragraphs.Count;
for (int i = 1; i <= sayi; i++)
{
richTextBox1.Text=
richTextBox1.Text+Word_nesnesi.ActiveDocument.Paragraphs[i].Range.Text;
}
Word Belgesi Đçeriğini Biçimlemek
Bildiğiniz gibi Word ile çalışırken imlecin bulunduğu noktanın biçim özellikleri
nasılsa yeni girilen karakterler de aynı biçim özelliklerine sahip olmaktadır.
Bu nedenle kullanıcılar çoğunlukla metnin genellinde kullanacakları biçim
özelliklerini ayarlayıp öyle bilgi girerler. Benzer şekilde C# uygulaması
dahilinde hazırladığınız Word belgesine kod yazarak aktarmak istediğiniz
metin için önceden biçim özelliklerini ayarlayabilirsiniz. Bu işlemin nasıl
yapıldığını aşağıda görebilirsiniz.

{
object visible = true;
ref missing, ref belge_tipi, ref visible);
Word_nesnesi.Selection.Font.Name = "Tahoma";
Word_nesnesi.Selection.Font.Size = 11;
Word_nesnesi.Selection.Font.Bold = 1;
}
Selection.Font.Bold özelliği Integer tipinde olduğu için 0 veya 1 değerini

aktarmak gerekmektedir. O normali temsil ederken 1 veya daha büyük
değerler Bold’u temsil etmektedir. Şimdi ise C# uygulaması dahilinde
hazırlanan Word belgesinin mevcut içeriğinin seçili durumda olan kısmının
altı çizili olmasını sağlayacağım. Bu amaçla forma bir düğme yerleştirip
aşağıda verdiğim kodu yazdım.
private void alti_cizili_Click(object sender, EventArgs e)

{
Word_nesnesi.Selection.Font.Underline=WdUnderline.wdUnderlineSingle;
}
Word belgesinin seçili durumda olan kısmını altı çizili yapacak kodu button
nesnesinin Click olayını temsil eden metoda yazmak yerine CheckBox
nesnesinin CheckedChanged olayını temsil eden metoda aşağıdaki gibi
yazabilirsiniz.
private void alt_ciz_CheckedChanged(object sender, EventArgs e)

{
if (alt_ciz.Checked == true)
Word_nesnesi.Selection.Font.Underline=WdUnderline.wdUnderlineSingle;
else
Word_nesnesi.Selection.Font.Underline =WdUnderline.wdUnderlineNone;
}
Word ile normal şartlarda yapılabilinen bütün biçimleme işlemleri C#

uygulaması dahilinde hazırlanan Word belgesine kolaylıkla
uygulanabilmektedir. Bu kitap bir Word kitabı olmadığı için ancak birkaç
biçimleme işleminden söz edeceğim. Şimdi ise C# uygulaması dahilinde
hazırlanan Word belgesindeki geçerli veya seçili durumdaki paragrafın
hizalama özelliklerini ayarlamak üzere forma bir CheckBox yerleştirip
aşağıda verilen kodu yazdım. Bu kod sayesinde üzerinde bulunulan paragraf
veya seçili durumdaki paragraflar sağa doğru hizalanır.
private void saga_hizali_CheckedChanged(object sender, EventArgs e)

{
Word_nesnesi.Selection.Paragraphs.Alignment =
WdParagraphAlignment.wdAlignParagraphRight;
}
Word Belgesi Üzerinde Hareket Etmek
C# uygulaması dahilinde hazırladığınız Word belgesinde imlecin yerini kod

yazarak kolayca değiştirebilirsiniz. Bu konuda bilgi vermek için forma bir
düğme yerleştirdim ve aşağıda verdiğim kodu yazdım.
private void Basa_git_Click(object sender, EventArgs e)

{
object unit = Microsoft.Office.Interop.Word.WdUnits.wdStory ;
Word_nesnesi.Selection.HomeKey(ref unit, ref missing);
}
Bu kodda ilk olarak object tipinde 2 değişken tanımladım. Bu değişkenlere

Microsoft’un programcılarının alışkanlığına uyarak “missing” ve “unit”
adlarını verdim. Sizler bu değişkenlere istediğiniz adı verebilirsiniz. “unit”
adını verdiğim değişkene Microsoft.Office.Interop.Word’de yer alan
WdUnits adlı enum’un wsStory elemanını aktardım. Devamında Word
uygulamasının Selection nesnesine HomeKey() metodunu uyguladım. Bu
kod işletildiğinde imleç aktif belgenin başına gider. Eğer belgenin sonuna
gitmek istemiş olsaydım bu kodu aşağıdaki gibi düzenlerdim. Bu 2 kod
arasında tek fark HomeKey() yerine EndKey() metodunun kullanılmış
olmasıdır.
private void sona_git_Click(object sender, EventArgs e)

{
object unit = Microsoft.Office.Interop.Word.WdUnits.wdStory;
Word_nesnesi.Selection.EndKey(ref unit, ref missing);
}
Üzerinde bulunulan satırın sonuna gidilmek istendiğinde ise aşağıdaki gibi

kod yazılmalıdır. Bu kodun belgenin başına veya sonuna gidilirken kullanılan
koddan farkı “unit” adını verdiğim değişkene aktarılan sabit bilgidedir.
Belgenin başına giderken yararlandığım “unit” adlı değişkene
WdUnits.wdStory sabitini aktarırken satır üzerinde hareket etmek üzere
tanımladığım bu değişkene WdUnits.wdLine aktardım.
Selection nesnesine uygulanan EndKey() yerine HomeKey() metodunu

yazsaydım bu kod üzerinde bulunulan satırın başına gidilmesine neden
olurdu. Burada “unit” adını verdiğim object tipindeki değişkene
“WdUnits.wdLine” aktardığım için işlemler satır bazında yapılır.

object unit = Microsoft.Office.Interop.Word.WdUnits.wdLine;
Word_nesnesi.Selection.EndKey(ref unit, ref missing);
Şimdi ise belgenin içeriği üzerinde hareket etmeyi paragraf bazında

yapacağım. Aşağıda verdiğim kod işletildiğin imlecin yatay konumu
değişmeden bir sonraki paragrafın üzerine gedilir.

object unit = Microsoft.Office.Interop.Word.WdUnits.wdParagraph;

Word_nesnesi.Selection.MoveDown(ref unit, ref missing,ref missing);
Sanki aşağı ok tuşuna basılmış gibi bir imlecin yatay konumu değişmeden
bir sonraki satırın üzerine gitmek istiyorsanız aşağıdaki gibi kod
yazabilirsiniz.

Word_nesnesi.Selection.MoveDown(ref unit,ref missing, ref missing);
Đmlecin üzerinde bulunulan satırdaki bir sonraki kelimenin başına veya bir
önceki kelimenin sonuna gitmesini istiyorsanız bu kodda “unit” adını
verdiğimiz object tipindeki değişkene WdUnits.wdWord sabitini
aktardıktan sonra Word uygulamasını temsil eden nesneye MoveLeft()
veya MoveRight() metodunu uygulamanız gerekir. Bu metotların nasıl
kullanıldığını aşağıda görebilirsiniz.

object unit = Microsoft.Office.Interop.Word.WdUnits.wdWord;
Word_nesnesi.Selection.MoveLeft(ref unit,ref missing, ref missing);
Seçim Đşlemleri ve Range Nesnesi
Word belgesinin bütün içeriğini seçmek istiyorsanız Select() metodundan

yararlanabilirsiniz. Bu metodun nasıl kullanıldığını anlatmak için forma
“Tümünü Seç” başlıklı bir düğme yerleştirip bu düğmenin Click olayı ile
ilişkilendirdiğim metodunu aşağıdaki gibi düzenledim.
private void Tumunu_sec_Click(object sender, EventArgs e)

{
Belge1.Select();
}
Select() metodunu burada yapıldığı gibi Document nesnesine uygulamak

yerine ApplicationClass nesnesinin ActiveDocument nesnesine aşağıdaki
gibi uygulayabilirsiniz.
Word_nesnesi.ActiveDocument.Select();
Word belgesinin bütün içeriğini seçerken Range nesnesinden

yararlanabilirsiniz. Aşağıda verdiğim kodda önce söz konusu belgedeki
karakter sayısını öğrendim. Çünkü DocumentClass nesnelerinin Characters
adında bir koleksiyonu bulunmaktadır.
private void Tumunu_sec_Click(object sender, EventArgs e)

{
object baslangic = 0;
object bitis = Belge1.Characters.Count;
Belge1.Range(ref baslangic, ref bitis).Select();
}
Yukarıdaki sayfalarda yapılan bazı işlemlerin Range nesnelerine

uygulandığını fark etmiş olmalısınız. Biçimleme ve diğer işlemler için
önceden Range nesnesi hazırlayıp işlemleri Range nesnesine
uygulayabilirsiniz. Range nesnesini nasıl hazırladığımı aşağıda görebilirsiniz.
Tahmin edeceğiniz gibi bu satırlar bir metoda yazılıp işletilirse “Belge1” adlı
Document nesnesinin bütün içeriği Bold yapılır.
object ilk = 0;
object son = Belge1.Characters.Count;
Range erim = Belge1.Range(ref ilk, ref son);
erim.Bold = 1;
Bu kodda “Belge1” adlı Document nesnesinin bütün içeriğini Range nesnesi

olarak değerlendirdim. Range nesnesini hazırlarken ApplicationClass
sınıfının ActiveDocument özelliğinden yararlanabilirsiniz. Bu nedenle
aşağıda verilen kod işletildiğinde aktif belgenin bütün içeriği aynı şekilde
bold yapılır.
object ilk = 0;
object son = Word_nesnesi.ActiveDocument.Characters.Count;
Range erim =Word_nesnesi.ActiveDocument.Range(ref ilk, ref son);
erim.Bold = 1;
Şimdi ise aktif belgenin ilk paragrafını Range nesnesi olarak

değerlendireceğim. Başka bir deyişle aktif belgenin ilk paragrafının bir
Range nesnesi tarafından temsil edilmesini sağlayacağım. Tahmin
edeceğiniz gibi aşağıda verilen kod işletildiğinde C# uygulaması dahilinde
açılan Word uygulamasının aktif belgesinin ilk paragrafı panoya kopyalanır.
private void Kopyala_Click(object sender, EventArgs e)

{
Range erim = Word_nesnesi.ActiveDocument.Paragraphs[1].Range;
erim.Copy();
}
Şimdi ise “Word_nesnesi” adını verdiğim Word uygulamasının aktif

belgesinin seçili durumdaki kısmını Range nesnesi olarak değerlendireceğim.
Aktif belgenin seçili durumda olan herhangi bir kısmı yoksa bu kodun bir
işlevi olmaz.
private void alti_cizili_Click(object sender, EventArgs e)

{
Range erim = Word_nesnesi.Selection.Range;
erim.Underline = WdUnderline.wdUnderlineSingle;
}
Word belgesinin seçilen kısmı Word uygulamasının Selection nesnesine

aktarılmaktadır. Copy() veya Cut() metodu ile Selection nesnesinin içeriğini
panoya veya başka bir nesneye aktarabilirsiniz. C# projesi dahilinde Word
belgesi açıp kullanıcıya Word aracılığı ile işlem yapması pek istenmez.
Aşağıda verilen kod işletildiğinde aktif belgenin seçili durumdaki kısmı kesilip
panoya alınır.
Range erim = Word_nesnesi.Selection.Range;

erim.Cut();
Şimdi ise aktif belgede imlecin mevcut konumunun sağındaki ilk 10

karakteri seçeceğim. Tabi seçme işlemine başlamadan yukarıdaki sayfalarda
anlatılan şekilde istenen yere konumlandırılması gerekir.
private void Sec_Click(object sender, EventArgs e)

{
object son = 10;
object unit = Microsoft.Office.Interop.Word.WdUnits.wdCharacter;
Word_nesnesi.Selection.MoveEnd(ref unit, ref son);
}
Bu koda dikkat ederseniz MoveEnd() metoduna 1. parametre olarak verilen

“unit” adlı değişkene WdUnits.wdCharacter aktarıldığı için imleç 2.
parametre kadar sağa gider. Başka bir anlatımla imlecin ilk bulunduğu
yerden başlamak üzere 10 karakter seçilir. MoveEnd() metodu aşağıdaki
gibi kullanılırsa imlecin sağındaki 2 kelime seçilmiş olur. Bu belgenin seçili
durumda olan kısmı varsa seçili kısım 2 kelime artmış olur.

{
object son = 2;
object unit = Microsoft.Office.Interop.Word.WdUnits.wdWord;
}
Benzer şekilde bu kodda “unit” adını verdiğim değişkenin içeriğinde

değişiklik yapıp seçme işleminin satır, paragraf veya sayfa bazında
yapılmasını sağlayabilirsiniz. Seçim işlemi bütün satırı veya paragrafı
seçmek şeklinde olmayıp o sırada imlecin bulunduğu noktadan sonrası
üzerinde etkili olur. Örneğin imleç belgenin bir satırın orta kısmında iken
aşağıda verilen kod işletilirse 1.5 satır kadar seçimi yapılmış olunur.

{
object son = 2;
}
Word Belgesinde Arama Đşlemleri
C# uygulaması dahilinde hazırladığınız Word belgelerinde arama

yapacaksanız belgenin aramaya konu etmek istediğiniz kısmını Range ya da
Selection nesnesi ile belirtebilirsiniz. Range nesnesi ile yapılan arama
tekniğine öncelik verdiğim için forma bir düğme ve TextBox yerleştirip
aşağıda verdiğim kodu hazırladım.
private void Ara_Click(object sender, EventArgs e)

{
object aranan_str = textBox1.Text;
object ilk = 0;
object kar_sayi = Word_nesnesi.ActiveDocument.Characters.Count;
Range erim = Word_nesnesi.ActiveDocument.Range(ref ilk,ref kar_sayi);
}
Bu kod sayesinde kullanıcı Word belgesinde aramak istediği metni TextBox’a

girip bu düğmeyi tıkladığında belgenin tümünü kapsayacak Range nesnesi
hazırlamış olur. Sizler aramayı belgenin tümü yerine istediğiniz kısmı ile
sınırlayabilirsiniz.
Belgenin aramaya konu edilecek kısmı bu şekilde tespit edildikten sonra sıra
arama yapılırken kullanılan ve Microsoft.Office.Interop.Word’de yer alan
Find arayüzünün örneğini almaya gelir. Find nesnesini nasıl hazırladığımı
aşağıda görebilirsiniz.

{
object ilk = 0;
Range erim=Word_nesnesi.ActiveDocument.Range(ref ilk, ref kar_sayi);
Microsoft.Office.Interop.Word.Find arama_nesnesi;
arama_nesnesi = erim.Find;
}
Arama yapmak üzere hazırladığım bu kodda Range nesnesinin Find özelliğini

Find tipindeki değişkene aktararak Find nesnesi hazırlamış oldum. Sıra geldi
Execute() metodu ile arama yapmaya. Word’de normalde arama yapılırken
ekrana getirilen diyalog kutusunda nasıl çok sayıda seçenek bulunuyorsa
Execute() metodu da çok sayıda parametreye sahiptir. Biz aranacak metni
1. parametre olarak vermekle yetineceğiz ve diğer bütün parametrelerin
yerine System.Reflection.Missing.Value içeriğine sahip Object tipinde bir
değişkeni kullanacağız. Object tipindeki bu değişkene “deger” gibi Türkçe bir
ad verip kendimi tehlikeye atmadım.

{
object ilk = 0;
Range erim=Word_nesnesi.ActiveDocument.Range(ref ilk,ref kar_sayi);
arama_nesnesi = erim.Find;
arama_nesnesi.Execute(ref aranan_str, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing,
ref missing, ref missing);
if (arama_nesnesi.Found == true)
MessageBox.Show("Aranan Bilgi Bulundu");
}
Gördüğünüz gibi Execute() metodu toplam 15 parametreye sahiptir.

Kendisine 1. parametre olarak verilen bilgi söz konusu belgenin Range
nesnesi ile işaret edilen kısmında varsa Find nesnesinin Found özelliği true
olmaktadır. Arama işleminin seyri hakkında bilgi edinirken Find nesnesinin
Found özelliğine bakmak yerine Execute() metodunun geriye gönderdiği
bool bilgiye bakabilirsiniz. Aranan bilgi bulunduğunda Execute() metodu
geriye true göndermektedir.
Yukarıda söylendiği gibi arama işlemi belgenin Range nesnesi ile işaret
edilen kısmında yapılabildiği gibi Selection nesnesinden yararlanılabilir.
Selection nesnesinden yararlanılarak nasıl arama yapıldığını aşağıda
görebilirsiniz. Bu kitabı Word kitabına çevirmemek için Execute()
metodunun parametreleri hakkında bilgi vermedim.

{
object unit = Microsoft.Office.Interop.Word.WdUnits.wdStory;
Word_nesnesi.Selection.HomeKey(ref unit, ref missing);
arama_nesnesi = Word_nesnesi.Selection.Find;
bool sonuc = arama_nesnesi.Execute(ref aranan_str, ref missing,
if (sonuc)
MessageBox.Show("Aranan Bilgi Bulundu");
}
Word Belgesini Kaydetmek
Yukarıdaki sayfalarda C# uygulaması dahilinde yeni Word belgesi hazırlayıp

bilgi girmiştik. Şimdi sırada kod yazarak hazırlayıp bilgi girdiğimiz belgeyi
kaydetme var. Đşin meraklılarını düşünerek bu işlem için kullanılan
SaveAs() metodunun orijinal yapısını vereceğin. Bu metodun yapısı
incelendiğinde tam tamına 16 parametreye sahip olduğu görülür. Ancak
ürkmenize gerek yok bu 16 parametreden ilki hariç diğerlerini kullanmak
isteğe bağlıdır.
public virtual void SaveAs(

[In, Optional] ref object FileName,
[In, Optional] ref object FileFormat,
[In, Optional] ref object LockComments,
[In, Optional] ref object Password,
[In, Optional] ref object AddToRecentFiles,
[In, Optional] ref object WritePassword,
[In, Optional] ref object ReadOnlyRecommended,
[In, Optional] ref object EmbedTrueTypeFonts,
[In, Optional] ref object SaveNativePictureFormat,
[In, Optional] ref object SaveFormsData,
[In, Optional] ref object SaveAsAOCELetter,
[In, Optional] ref object Encoding,
[In, Optional] ref object InsertLineBreaks,
[In, Optional] ref object AllowSubstitutions,
[In, Optional] ref object LineEnding,
[In, Optional] ref object AddBiDiMarks
);
Bu bölüme ayrılan sayfa sayısını fazla arttırmamak için bütün

parametrelerden söz etmeyeceğim. Yukarıda Add() metodu hakkında bilgi
verilen sayfalardan bildiğiniz Word belgelerini, açarken, hazırlarken ve
kaydederken varsayılan değerlere bağlı kalınmak istenen parametrelerin
yerine System.Reflection.Missing.Value sabiti aktarılmış Object
tipindeki bir değişkeni kullanmak mümkündür.
C# projesi dahilinde hazırlanan Word belgesinin nasıl kaydedildiğini

anlatmak için forma bir SaveFileDialog nesnesi ve “Kaydet” adında bir
düğme yerleştirip aşağıda verdiğim kodu hazırladım. Kaydetmek istediğim
belge yukarıda hazırlayıp ve “Belge1” adını verdiğim DocumentClass
nesnesidir.
Karışıklık olmasın diye DocumentClass ve ApplicationClass nesnelerini

hazırladığım satırları “Kaydet” düğmesi için hazırladığım metodun yakınına
taşıdım. Ayrıca kaydetme işlemi sırasında hazırlanacak DOC uzantılı
dosyanın adını kullanıcıdan istemek için forma bir SaveFileDialog nesnesi
yerleştirdim.

private void Kaydet_Click(object sender, EventArgs e)
{
saveFileDialog1.ShowDialog();
object Dosya = saveFileDialog1.FileName;
Belge1.SaveAs(ref Dosya, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing);
}
O sırada C# uygulaması dahilinde hazırlanan Word belgesini kaydetmek

üzere bu kod işletildiğinde kullanıcıdan önce dosya adı istenir. Adını
girdiğiniz dosyaya DOC uzantısını vermeniz önerilir. Çünkü bu sırada
kaydedilmek istenen DocumentClass nesnesi hazırlanırken belge tipinin
DOC uzantısı verilen normal belge olduğunu varsayıyoruz. Ayrıca kayıt
sırasında kayıt türü konusunda bir ayarlama yapmadık. Bu kod işletilip
kullanıcının girdiği belge adı o sırada açık Word penceresinin başlığına
yazılır.
Word’ü az çok kullanmış olanların bildiği gibi Word belgeleri kaydedilirken

Farklı Kaydet diyalog kutusunda istenen kayıt türü seçilebilmektedir.
Benzer seçimi C# uygulaması dahilinde hazırladığınız belgeleri kaydederken
yapabilirsiniz. Şimdi yukarıda hazırladığım Word belgesini bu kez RTF
formatında kaydedeceğim. Bunu yaparken kayıt türünü SaveAs()
metodunun 2. parametresinde belirteceğim.

private void Kaydet_Click(object sender, EventArgs e)
{
saveFileDialog1.ShowDialog();
object Dosya = saveFileDialog1.FileName;

object kayit_turu = WdSaveFormat.wdFormatRTF;
Belge1.SaveAs(ref Dosya, ref kayit_turu, ref missing,
ref missing, ref missing, ref missing);
}
Bu kodda yukarıdakinden farklı olarak object tipinde bir değişken

tanımlayıp Microsoft.Office.Interop.Word de yer alan WdSaveFormat adlı
enum’un wdFormatRTF üyesini bu değişkene aktardım. Devamında
“kayit_turu” adını verdiğim değişkeni SaveAs() metoduna 2. parametre
olarak verdim.
Word Belgelerini Kapatmak
Şimdi ise C# uygulaması dahilinde hazırlayıp sonra da SaveAs() metodu ile

kaydettiğim Word belgesini kapatacağım. Bu amaçla forma Kapat
adında(Close mı deseydim, belki Kapat’ı birileri register etmiştir) bir düğme
yerleştirip aşağıda verdiğim kodu hazırladım.
private void Kapat_Click(object sender, EventArgs e)

{
Belge1.Close(ref missing, ref missing, ref missing);
}
Đşaret edilen belgeyi kapatmak amacıyla kullanılan Close() metodu 3

parametreye sahiptir. Bu metodu varsayılan değerlere göre işletmek
istiyorsanız yine object tipinde bir değişken tanımlayıp bu değişkene
System.Reflection.Missing.Value aktarıp her 3 parametrenin yerine
kullanmalısınız. Bu durumda son hali kaydedilmemiş bir belge Close()
metodu ile kapatılmak istenirse otomatik olarak ekrana Farklı Kaydet
diyalog kutusu gelir. Kapatılmak istenen belgede yapılan değişikliklerin
kaydedilmesi konusunda size uyarı bulunulmasını istemiyorsanız Close()
metodunun 1. parametresini aşağıdaki gibi düzenleyebilirsiniz.
private void Kapat_Click(object sender, EventArgs e)

{
object degisikleri_kaydet = WdSaveOptions.wdDoNotSaveChanges;
Belge1.Close(ref degisikleri_kaydet, ref missing, ref missing);
}
Word belgesi yerine C# uygulaması dahilinde açtığınız Word penceresini

kapatmak veya Word’ün çalışmasını sona erdirmek istiyorsanız
ApplicationClass sınıfının Quit() metodunu kullanabilirsiniz. Bu metodun
nasıl kullanıldığını aşağıda görebilirsiniz.

{
Word_nesnesi.Quit(ref missing, ref missing, ref missing);
}
C# uygulaması dahilinde açtığınız Word penceresini kapatırken açık olan

belgelerle ilgili olarak ekrana Farklı Kaydet diyalog kutusu getirilir. Bu
diyalog kutusunun gelmesini istemiyorsanız Quit() metodunun ilk
parametresi ile aşağıdaki gibi ayarlama yapmalısınız.

{
object uyari = WdSaveOptions.wdDoNotSaveChanges;
Word_nesnesi.Quit(ref uyari, ref missing, ref missing);
}
Yukarıdaki sayfalarda işaret edildiği gibi Word uygulamasını temsil eden

ApplicationClass sınıfının Documents adında bir koleksiyonu
bulunmaktadır. O sırada C# uygulaması dahilinde açılan veya hazırlanan her
belge bu koleksiyonun üyesi yapılmaktadır. Açık olan belgelerin sayısını
öğrenmek Count özelliğine bakabilirsiniz.
int sayi = Word_nesnesi.Documents.Count;
Documents koleksiyonundaki mevcut belgelerden birisini elde etmek

istiyorsanız Documents koleksiyonun get_item() metodundan
yararlanabilirsiniz. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz.
Burada dikkat edilmesi gereken ince nokta Documents koleksiyonun ilk
elemanın sıra numarasının 1 olmasıdır.
Document Belgem = new DocumentClass();

object sira = 1;
Belgem = Word_nesnesi.Documents.get_Item(ref sira);
Mevcut Word Belgelerini Açmak
Yukarıdaki sayfalarda önce Word’ü başlattık. Sonra Add() metodu ile yeni
belge hazırlayıp Word penceresine getirip bilgi girip biçimlendirdik. Ardından
bu belgeleri kaydetmeyi denedik. Şimdi sırada mevcut Word belgelerini
açmak var. Tabi Word ile mevcut belgelerini açabilmek için daha önceden
ApplicationClass sınıfı ile Word’ü başlatmış olmak gerekir. Yukarıdaki
sayfalarda Word’ün varsayılan ayarlarına bağlı kalıp Word başlatıldığı zaman
ekrana içeriği boş bir belge getirdik.
Word başlatıldığında otomatik olarak hazırlanan Word belgesine bilgi

girilmeden mevcut belgelerden birisi açıldığında Word otomatik olarak
hazırladığı belgeyi kapatmaktadır. C# uygulamaları dahilinde mevcut
belgeler DocumentClass sınıfının Open() metodu ile açılmaktadır. Çok
sayıda parametreye sahip bu metodun yapısını aşağıda görebilirsiniz.
Document Open(
[In] ref object FileName,
[In, Optional] ref object ConfirmConversions,
[In, Optional] ref object ReadOnly,
[In, Optional] ref object AddToRecentFiles,
[In, Optional] ref object PasswordDocument,
[In, Optional] ref object PasswordTemplate,
[In, Optional] ref object Revert,
[In, Optional] ref object WritePasswordDocument,
[In, Optional] ref object WritePasswordTemplate,
[In, Optional] ref object Format,
[In, Optional] ref object Encoding,
[In, Optional] ref object Visible,
[In, Optional] ref object OpenAndRepair,
[In, Optional] ref object DocumentDirection,
[In, Optional] ref object NoEncodingDialog,
[In, Optional] ref object XMLTransform);
Gördüğünüz gibi Open() metodu da tıpkı SaveAs() metodu gibi çok sayıda
parametreye sahiptir. Açılacak dosyanın işaret edildiği ilk parametre hariç
diğerlerini hazırlayıp kullanmak zorunda değilsiniz. Başka bir deyişle ilk
parametre hariç diğerlerinin yerine kullanmak üzere object tipinde bir
değişken tanımlayıp bu değişkene System.Reflection.Missing.Value
sabitini aktarıp kullanabilirsiniz.
Mevcut Word belgelerinden birisini Open() metodu ile nasıl açabileceğinizi

anlatmak için karışıklık olmasın diye yeni bir proje hazırladım ve forma
OpenFileDialog nesnesi yerleştirip aşağıda verdiğim kodu hazırladım.
Çünkü amacımız DocumentClass sınıfının Open() metodunu yakından
incelemektir. Değişken adı benzerliği kabahatini işleme olasılığını azaltmak
için düğme adının bir kısmını Đngilizce bir kısmını Türkçe yaptım.
Document Belge1;
private void Dosya_open_Click(object sender, EventArgs e)
{
Belge1 = new DocumentClass();

openFileDialog1.ShowDialog();
object kutuk = openFileDialog1.FileName;
Belge1 = Word_nesnesi.Documents.Open(ref kutuk, ref missing,
}
Gördüğünüz gibi ilk parametre hariç diğer 15 parametre olarak

System.Reflection.Missing.Value aktardığım object tipindeki değişkeni
kullandım. Bu kod işletildiğinde ekrana gelecek Open diyalog kutusunda
seçilecek dosya açılıp Word penceresine gelir. Tabii kullanıcı dosya seçimi
yapılan diyalog kutusunda dosya seçmez veya uygun olmayan bir dosyayı
seçerse hata meydana gelir. Konuyu uzatmamak ve kodun kısa olmasını
sağlamak için hata kontrol işlemlerini yapmadım.
Anlatılan şekilde DocumentClass sınıfının Open() metodu ile açıp Word

penceresine getirdiğiniz belgenin içeriğinde değişiklik yapılmasını(yani
dosyanın değiştirilmesini) istemiyorsanız Open metoduna 3. parametre
olarak System.Reflection.Missing.Value sabitini aktardığınız Object tipindeki
değişken yerine object tipinde başka bir değişken tanımlayıp true aktarıp
kullanmanız gerekir. Bu işlemi nasıl yaptığımı aşağıda görebilirsiniz.
Document Belge1;
{
object yalniz_read = true;
Belge1 = Word_nesnesi.Documents.Open(ref kutuk, ref missing,
ref yalniz_read, ref missing, ref missing,
}
Bu şekilde düzenlenen Open() metodu ile açılan Word belgesinde değişiklik

yapılabilir ancak değişiklikler açılan dosyaya yansıtılamaz. Đsterseniz
belgenin yeni halini başka bir dosya adı altında kaydedebilirsiniz. Open
metodu ile açmak istediğiniz dosya DOC uzantılı değilse ve dönüştürme
öncesi kullanıcıdan onay alınsın istiyorsanız Open() metoduna 2. parametre
olarak true içeriğe sahip object tipindeki bir değişkeni kullanmalısınız.
Document Belge1;
{
object izin_iste = true;
object yalniz_read = false;
Belge1 = Word_nesnesi.Documents.Open(ref kutuk,
ref izin_iste, ref yalniz_read, ref missing,
}
Kitabın sayfa sayısını arttırmamak için Open() metodunun burada sözü

edilmeyen diğer 13 parametresinin her birisinin işlevlerini araştırmayı size
bırakıyorum.
Word Belgelerini Yazdırmak
C# projesi dahilinde hazırladığınız veya açtığınız Word belgesini yazdırmak

istiyorsanız ApplicationClass sınıfının Printout() metodundan
yararlanmanız gerekir. Bu metot tıpkı SaveAs() ve Open() metotları gibi
çok sayıda parametreye sahip olduğu için kullanılması biraz zahmetlidir.
public virtual void PrintOut(

[In, Optional] ref object Background,
[In, Optional] ref object Append,
[In, Optional] ref object Range,
[In, Optional] ref object OutputFileName,
[In, Optional] ref object From,
[In, Optional] ref object To,
[In, Optional] ref object Item,
[In, Optional] ref object Copies,
[In, Optional] ref object Pages,
[In, Optional] ref object PageType,

[In, Optional] ref object PrintToFile,
[In, Optional] ref object Collate,
[In, Optional] ref object ActivePrinterMacGX,
[In, Optional] ref object ManualDuplexPrint,
[In, Optional] ref object PrintZoomColumn,
[In, Optional] ref object PrintZoomRow,
[In, Optional] ref object PrintZoomPaperWidth,
[In, Optional] ref object PrintZoomPaperHeight);
Bu metodun nasıl kullanıldığını anlatmak için mevcut Word belgelerinin nasıl

açıldığını anlatmak üzere hazırladığım projenin formuna “Yazdir” adında bir
düğme yerleştirdim. Ardından bu düğmenin Click olayını temsil eden
metodu aşağıdaki gibi düzenledim.
private void Yazdir_Click(object sender, EventArgs e)

{
Word_nesnesi.PrintOut(ref missing, ref missing, ref missing,
}
Verilen koddan fark etmiş olabileceğiniz gibi PrintOut() metodunun bütün

parametrelerinde System.Reflection.Missing.Value sabiti aktarılmış
object tipindeki değişkeni kullanmak mümkündür. Bu şekilde düzenlenen
PrintOut() metodu aktif belgenin tümünü yazıcıya gönderir. Geçerli belgenin
tümü yerine seçili durumdaki kısmını yazıcıya göndermek istiyorsanız
PrintOut() metodunun 3. parametresini aşağıdaki gibi ayarlamalısınız.

{
object secim = WdPrintOutRange.wdPrintSelection;
Word_nesnesi.PrintOut(ref missing, ref missing, ref secim,
}
Aktif belgenin seçili kısmı yerine geçerli sayfayı yani belgenin o sırada
üzerinde olunan sayfasını yazdırmak istemiş olsaydım “secim” adını vermiş
olduğum değişkenin içeriğini aşağıdaki gibi ayarlardım.
object secim = WdPrintOutRange.wdPrintCurrentPage;

ApplicationClass nesnesi sayesinde ekrana getirilen Word penceresinde

DocumentClass nesnesi sayesinde içeriği görüntülenen Word belgesinin belli
numaraya sahip sayfalarını yazdırmak istiyorsanız bu sayfaları PrintOut()
metodunun 5. ve 6. parametreleri ile işaret etmeniz gerekir. Tabi bu
durumda 3. parametrenin ayrıca ayarlanması gerekir. PrintOut() metodu
aşağıdaki gibi düzenlenirse aktif belgenin 2. ve 3. sayfaları yazdırılır.

{
object secim = WdPrintOutRange.wdPrintFromTo;
object first_sayfa = "2";
object last_sayfa = "3";
Word_nesnesi.PrintOut(ref missing, ref missing, ref secim,
ref missing, ref first_sayfa, ref last_sayfa, ref missing,
}
Konuyu uzatmamak için PrintOut() metodunun diğer parametrelerinin

işlevini size bırakıyorum. Aktif belgeyi hemen yazdırmak yerine
önizleme(Preview) modunda incelemek istiyorsanız ApplicationClass
nesnesinin PrintPreview özelliğini true yapabilirsiniz. Bu özelliğin nasıl
kullanıldığını anlatmak için forma bir düğme yerleştirip aşağıda verdiğim
satırı yazdım. Bu metot işletirse sanki Word penceresine geçip Dosya
menüsünden Önizleme komutu verilmiş gibi önizleme moduna geçilir.
private void on_izle_Click(object sender, EventArgs e)

{
Word_nesnesi.PrintPreview = true;
}
ADO.NET KĐTABIMIN ÖNSÖZÜ

Bu kitabı birkaç cümle ile bize anlat denmiş olsaydı cevabım şu olurdu: Bu
kitapta 420 sayfa boyunca ADO.NET anlattım. Bunu yaparken okurların C#
hakkında temel bilgilere sahip olduğunu varsaydım. Bu kitaptan biraz
zahmetli de olsa Visual Basic .NET kullanıcıları da yararlanabilirler. Çünkü
her 2 programlama dili de .NET Framework ile gelen aynı sınıfları kullanıyor.
Bu kitap SQL Server konulu bir kitap olmamasına rağmen daha önce SQL
Server’ı hiç kullanmamış olanların kitaptan yararlanmasını sağlamak için yer
yer SQL Server’dan söz ettim. Hemen soranlar olacaktır: Bu kitapta
ADO.NET hakkında her konuda bilgi var mı? Bu soruya vereceğim elbette
hayırdır. Tam 420 sayfa boyunca ADO.NET anlattım. Bu kitap 300 sayfa
olsaydı bazı konular kitapta yer almazdı. Kitabı 420 yerine 500 sayfa olarak
düzenlemiş olsaydım kitaba başka konular ekler, mevcut konulardan
bazılarını ise daha ayrıntılı anlatırdım. Örneğin C# uygulaması dahilinde C#
kodu yazarak SQL Server için Store Procedure veya kullanıcı tanımlı
fonksiyon hazırlama gibi konuları daha ayrıntılı anlatırdım, ClickOnce için
ayrılan sayfaların sayısı iki katına çıkardı.
Yakın bir zamana kadar kitaplarımda kullandığım 3-5 satırlık kodları bazen
ekran görüntüsü olarak kitap metni içinde kullanırdım. Bu sayede kodu
incelemek daha kolay oluyordu. Bazıları bu ekran görüntülerini “kitap
şişirme” olarak değerlendirip Memik YANIK’ın kitaplarını eleştiriyorlardı. Hal
bu ki kitap metni içinde direk kod yerine, kodun olduğu ekran görüntüsünü
kullanmanın kitabın sayfa sayısı üzerinde etkisi çok sınırlıydı. Bunu
kanıtlamak için oturup çalışıp bir yazı hazırlayıp kişisel sistemde yayınladım.
Bu kitapta kod içeren ekran görüntülerinden mümkün mertebe kaçındım.
Tabii ki bu demek değildir ki bu kitapta hiç ekran görüntüsü yoktur. Zaten
ekran görüntüsü kullanmadan bazı konuları anlatmak mümkün değildir.
Örneğin Setup Wizard’ı anlatırken ekran görüntüsü kullanmak
zorundasınız.
Bu kitapta yazılanları anlamak için tekrar tekrar okumak zorunda

kalmazsınız. Çünkü Memik YANIK’ın kaleminden çıkan kitaplar klasik
programlama kitapları gibi değildir, Memik YANIK’ın tarafından yazılan
kitaplarda Help tadı yoktur, Memik YANIK’ın cümleleri çeviri kokmaz. Bu
nedenledir ki bu kitap kolay okunur, bu kitapta yazılanları anlamak için akla
karayı seçmezsiniz.
Yakında bir zamanda Microsoft firması Visual Studio 2008’i piyasaya

verecektir. Bu arada birçok kişi Visual Studio 2005’i kullanmaya devam
edecektir. Ayrıca 2008 yılı için SQL Server’ın yeni sürümü piyasaya
verilebilir. Bu kitapta veritabanı olarak genellikle SQL Server’ın 2005
sürümünü kullandım. Hemen belirtmek gerekirse, bu kitap program
geliştirme aracı olarak ister Visual Studio 2005 ister Visual Studio 2008
kullanılsın herhangi bir uyum sorunu yaşanmaya ihtimali düşüktür. Benzer
şekilde bu kitabın içeriği bakımından veritabanın SQL Server 2005 veya SQL
Server 2008 olmasının önemli bir etkisi yoktur. www.memikyanik.com’dan
mail ve MSN adresimi alıp her türlü sorununuzu yazabilir veya direk benimle
bağlantı kurabilirsiniz.
Delphi 2007 Kitabım Nasıl Bir Kitaptır?

Biraz tarih: 1995 yılının sonları; daha önce Visual Basic hakkında kitap
yazmış birisi olarak görsel programlamaya yatkındım ve görsel program
geliştirme araçlarını anlatma konusunda hazırlığım vardı. Çünkü Visual
Basic’in TextBox’ı ile Delphi’nin Edit’i benzer işlev ve özelliklere sahip
oldukları için fazla yabancılık çekmeyeceğimi düşünmüştüm. Ötesi, o
günlerde Pascal uzmanı olmasam bile Pascal diline yabancı değilim.
Neyse uzatmayalım; 7-8 aylık yoğun bir çalışmanın sonucu Delphi kitabını
hazırladım. Daha sonra bu Delphi kitabına eklemeler yaptım. En son Ezel
Balkan adıyla yayınladığım Delphi 7 kitabı 920 sayfa olup potansiyel
okurların beklentilerinin büyük bir kısmını karşılayacak bir içeriğe sahipti.
Açıkça belirtmek gerekirse 2006 yılı ortalarında elimde okurlardan ilgi
gördüğü için 3 baskı yapan 920 sayfalık kitap varken tam 10 ay boyunca
Delphi üzerinde çalışıp Delphi 2007 for Win32 kitabını yazdım. Bundan şu
sonucu çıkarabilirsiniz: Ezel Balkan adıyla yayınladığım 920 sayfalık Delphi
kitabımla burada sözünü ettiğim kitap arasında dağlar kadar fark var.
Delphi 2007 kitabını ilk yazmaya başladığım sırada normal çalışma

tempomla 3 aylık bir sürenin yeterli olacağını düşünüyordum. Açık yazmak
gerekirse, elimde 920 sayfalık Delphi 7 kitabı vardı; düzey yükseltme adına
bazı konuları kitaptan çıkaracaktım. Böylece Delphi 2007 kitabı yaklaşık 950
sayfa olacaktı. Son Delphi kitabıma 100 sayfa eklersem eksikliklerini büyük
oranda azaltmış olacaktım ve bu kitap en kapsamlı Türkçe Delphi kitabı
olabilecekti. Başka bir deyişle ilgi gören son Delphi kitabımdan 70 sayfa
çıkarıp yerine 100 sayfa ekleyecektim.
Bazı sayfaları madem çıkaracaktın da neden 3 yıl önce bu sayfaları kitaba

ekledin diye soranlar olabilir? Bu soruya Delphi.NET kitabımdan örnek
vererek anlatacağım: Delphi.NET kitabımda Transaction’lar hakkında bilgi
verirken önce SQL Server 2000 ile gelen Interprise Manager’dan
yararlanıp 2 basit Stored Procedure hazırlayıp işlettim. Sonra bunları
Transaction bloğuna alıp işlettim. Đstedim ki SQL Server dahilinde
Transaction’leri kullanmamış olanlar konuya kolayca adapte olsunlar. Bu
durumda SQL Server ve Transaction’lar hakkında ortalama düzeyde bilgisi
olanlar için kitabın sayfa sayısı 3 sayfa boşuna artmış oldu. Ancak SQL
Server konusunda ortalama düzeyde bilgisi olmayanların Delphi projesi

dahilinde Transation’lerin nasıl kullanıldığını anlamalarını garanti etmiş
oldum. Đşte kitabın sayfa sayısını azaltma bu gibi konularda oluyor. Örneğin
potansiyel okurların çoğunluğunun artık Paradox veritabanları hakkında
bilgiye ihtiyacı yoktur deyip kitabın Paradox veritabanları hakkında bilgi
içeren sayfalarını azaltırsınız.
Neyse konudan uzaklaşmayayım: Başlangıçta 920 sayfalık Delphi 7 kitabının

850 sayfasını yeni kitabımda kullanmayı düşünürken “Memik YANIK hep
başlangıç düzeyi kitaplar yazar, yeni başladıysan önerebilirim, ancak Memik
YANIK kitapları yeterli değildir” şeklindeki yaygın eleştiriden sanırım
etkilendim ki elimdeki kitabın 850 sayfasını yeni kitapta kullanmayı
düşünürken bir de baktım kitabın düzeyini yükseltme adına neredeyse her
şeyi yeni baştan yazmışım.
Şimdi yukarıda kısaca özetlediğim Memik YANIK kitaplarının yeni

başlayanlar için uygun olduğu şeklindeki genel inanışa biraz değinmek
istiyorum. Konumuz Delphi olsun: Delphi’yi öğrenip program yazmaya karar
verdiniz. Yani yolun başındasınız. Bu durumda edindiğiniz kitabın en önemli
işlevi sizi cesaretlendirmesi ve hevesinizi kırmamasıdır. Çünkü öğrenme
isteği ve çalışma azmi kimsede sonsuz değildir. Bu nedenle metni öyle
kaleme almalıyım ki okur okumakta zorlanmamalı, yazdığımı anlaması için
başka kaynaklara başvurma ihtiyacını duymamalıdır. Örneğin birkaç gün
önce C# kitabımı yazarken Access veritabanlarında kullanıcılar için parola
tanımlama ve mevcut kullanıcının parolasını C# uygulaması dahilinde isteme
gibi konulara örnek verirken yazdıklarımın havada kaldığını fark ettim.
Çünkü bu konulara programcılık kitaplarında yer verilmezken Access
kitaplarında ise olaya programcı gözü ile bakılmıyordu.
Bunu fark edince bendeki mevcut kitaplara baktım. Birisi Microsoft Press’ten
çıkmış 1000 sayfalık kapsamlı kitap olmakla birlikte diğer 3 kitapta
yazılanlar yanlış olmamakla birlikte hiç birisi Access veritabanı kullanan
programcının güvenlikle ilgili olarak gerek duyacağı bilgileri içermiyordu.
Ayrıca yazılanları anlamak kolay değildi. Kitabın birisinde yazar açıklama
yapmadan okuru ikna etmeden direk Wizard hakkında bilgi veriyordu. Ben
ne mi yaptım? Önce okuru karşılaşacağı muhtemel sorunlar hakkında
bilgilendirdim. Devamında onu ikna ettim. Sıra Wizard’a geldiğinden okur ne
yapacağını zaten biliyordu. Şimdi sorayım: ne yazdığı belli olmayan kolay
okunmayan kitap ileri düzey oluyordu da konunun ilk okumada anlaşılması
için başka yazarların 3 sayfada anlattıklarını 4 sayfada anlatan Memik
Yanık’ın kitabı neden başlangıç düzeyi oluyor? Kişisel görüşüme göre bir
kitapta yazılanlar zor anlaşılıyorsa ya okur yanlış bir kitap seçmiştir ya da
kitap kötü kaleme alınmıştır.
Programcılıkta belli bir noktaya gelmiş olanlar kitaplar hakkında

konuştuklarında ister istemez kendi pencerelerinden bakarak değerlendirme
yapıyorlar. Hal bu ki kendisinin programcılık kitabından öğreneceği çok az

şey kalmıştır. Olur ya zamanında gerek duymadığı için ilgilenmediği bir
konuyu sonradan merak ettiğinde elindeki kitaba bakar. Başka bir deyişle
artık neyin ne olduğunu, neyin ne işe yaradığını biliyordur. Kitaptan aradığı
olsa olsa bilmediği veya unuttuğu işlemin “nasıl yapılacağıdır”. Hal bu ki yeni
başlayan veya o programlama dilinden henüz ekmeğini çıkarmayan kişi
neyin ne işe yaradığını bilmiyordur. Bu nedenle ona konuları adım adım
anlatmak gerekiyor. Tabii konular adım adım anlatılınca ister istemez sayfa
sayısı artıyor.
Bu görüşe bir de örnek verelim: Konu Delphi’de interface’ler olsun. Usta

programcımız interface’lerin ne olduğunu ne işe yaradıklarını biliyordur da
belki gerek duymadığı için Delphi’de nasıl hazırlandığını bilmiyordur veya
unutmuştur. Usta programcımız kitaptan bu konuyu öğrenmek istediğinde
işin hikaye kısmından haklı olarak hemen sıkılır. Çünkü interface’lerin ne
olduğunu ne işe yaradığını zaten biliyordur. Ne var ki bir yazar olarak
interface’leri anlatmaya başlamadan ön bilgi vermeyi tercih ederim. Ön bilgi
verilmeden hemen asıl konuya geçilirse Interface’lerin nasıl hazırlanıp
kullanıldığı öğrenilse bile temeli bilinmediği için kısa sürede unutulur. Bu
açıdan Delphi 2007 kitabıma baktığımda hiçbir konunun üzerinin örtülüp
ezbere anlatılmadığını, her konunun nedenleri ile derinlemesine incelendiğini
rahatlıkla söyleyebilirim.
Çok sayıda forum sitesinde Delphi ile ilgili olarak daha önce sorulmuş ve
cevaplanmış binlerce soru vardır, yayınlanmış yüzlerce makale vardır. Bu
şartlarda kalkıp Memik Yanık’ın 1100 sayfalık Delphi kitabına 49 YTL
ödemek caiz midir? Delphi’ye merak sarsaydınız bu kitaba 49 YTL öder
miydiniz? Bazı arkadaşlar bu soruya hayır diye cevap vereceklerdir. Çünkü
merak ettiği konuları forumlara soracağını, Delphi hakkında sitelerde
yüzlerce makalenin olduğunu, hatta yerli yabancı çok sayıda E-Book bile
bulabileceğini söyleyeceklerdir.
Çok zamanınız varsa, sınırsız öğrenme isteğiniz varsa; ötesi hiç aceleniz
yoksa, bir iki yıl içinde Delphi ile program yazmayı düşünmüyorsanız,
öğrenciyseniz ve yakın bir zamanda geçmeniz gereken bir Delphi dersi
yoksa masraf yapıp Memik YANIK’ın Delphi kitabını almanıza gerek yoktur.
Ötesi ben çevirmenlerin kurduğu cümleleri iki üç kez okumaktan sıkılmam,
çeviri kitaplarda yazılanları anlayamazsam suçu kitabın yazarı-çevirmeni
yerine kendimde ararım diyorsanız 49 YTL verip Memik Yanık’ın Delphi
kitabını almanıza gerek yoktur.
Tecrübe açısından orta düzeydeki bir programcının Delphi ile ilgili olarak
şimdiye kadar merak edip cevabını arayıp bulduğu 100 sorunun olduğunu
varsayalım. Delphi ile program yazmaya karar veren birisinin bu soruların
hepsini bir veya birden fazla kitapta cevap bulması, bu soruların hepsinin
cevabını okuldaki veya kurstaki hocasından alması veya gece gündüz
forumlarda zaman harcayarak cevap bulması mümkün değildir. Kişisel

görüşüme göre Delphi ile ilgili olarak karşılaşmanız muhtemel olan ilk 25
sorunun cevabını kitaptan almaz veya gittiğiniz kurstan bu sorulara cevap
verilmezse geriye kalan 75 soruya forumlardan makalelerden cevap bulmak
yıllarınızı alır. O zamana kadar da o programlama dili güncelliğini kaybeder.
Memik YANIK bu kitabında Delphi ile program yazmak isteyenlerin
karşılaşması muhtemel olan soruların hepsine cevap vermeyi hedeflemedi.
Hedeflediği şudur: Bu kitabı okuyanlar Delphi ilgili her konuyu öğrenebilecek
potansiyele sahip olurlar.
Forumlarda Delphi veya başka programlama dili konusunda henüz yolun

başında olanlar sık sık Delphi’de ustalaşmak, program yazmak istediğini
yazıp nasıl bir yol izlemesi gerektiğini sorar ve kitap önerin derler. Ne var ki
bazen Delphi konusunda belli bir düzeye gelmiş arkadaşların bazıları böyle
sorulara “kitaba gerek yok, e-book’lara bak, sitelerdeki makaleleri oku,
merak ettiğin konu olduğunda cevabını bulamadığın sorular olduğunda
forumlara yaz” derler. Aslında söyledikleri, önerdikleri tümden yararsız ve
geçersiz şeyler değildir.
Memik Yanık’ın Delphi kitabını okuyan kişi temel konulara vakıf olduğu için
soru sormasını biliyordur, verilen cevapları anlıyordur. Forum yöneticileri
foruma soru yazanların dertlerini net olarak yazamadıklarından, soruların
açık olmadığından sürekli dert yanarlar. Soruların(Delphi konusundaki
soruların diyelim) anlaşılmaz olmasının nedeni o kişinin Memik YANIK’ın
Delphi kitabını okumamış olması ve o programla dili ile ilgili temel
kavramlara sahip olmamasıdır.
Hele hele bazıları e-book meraklısıdır. Gerekli gereksiz yüzlerce konuları

içeren e-book’ları bulup biriktirirler. Sanki sınırsız zamanları var, sanki
tarayıcılar gibi 3-5 saniyede bir sayfayı okuyup bir daha unutmamak üzere
belleklerine kaydediyorlar. Arkadaşlar e-book’lar yararsızdır demem ama
daha önceden Memik YANIK kitabı okumadıysanız e-book’ların size katkıları
sınırlı olacaktır.
Son olarak Delphi 2007 kitabım hakkında şunları söyleyebilirim: Kitabın

sayfa sayısını azaltmak için yoğun çabalar göstermeme rağmen, yaklaşık
1100 sayfa olmasına rağmen bu kitapta Delphi ilgili her konuya yer
verebildiğimi söyleyemem. Gerekli gördüğüm bazı eksiklikleri kaleme alıp
kişisel Web sitemde yayınlayacağım. Tekrar etmek gerekirse bu kitabımın
düzeyini gereği kadar yükseltmiş olmama ve ta en başından Nesneye
Yönelik Programcılık penceresinden bakarak konuları kaleme almış olmama
rağmen bu kitapta yine ilk okumada anlaşılmayacak hiçbir konu yoktur.
Bu kitapta yalnızca bir veritabanına bağlı kalmadım. Eski Paradox başta

olmak üzere Interbase, FireBird, Access, SQL Server ve MySQL
veritabanlarını Delphi projeleri dahilinde kullanmayı denedim. Ne var ki
MySQL’e yeterince yer verdiğimi söyleyemem. Bu kitap bir Delphi kitabı

olduğu için Delphi projeleri dahilinde erişim sağlanan her veritabanını yeteri
ayrıntıda anlatmak zaten imkan dışıydı. Belki bu kitap tekrar basıldığında
MySQL’e yeterince ağırlık verme imkanım olur.
Memik YANIK’ın programcılık kitaplarının ayırt edici özelliklerinden birisi

okurun hevesini kırmamasıdır. Çünkü Memik YANIK teknik konular nasıl
anlatıldığında, nasıl cümleler kurulduğunda okurun ilgisi dağılmaz,
anlatılanları kavrar? Sorularına verilecek cevapları vardır. Eğer programcılık
kitabının yazarı dönüp yazdığı metne bakıp okurlar tarafından nasıl
algılanacağı konusunda kafa yormazsa ve bu konuda fikri hazırlığı yoksa
yazdıkları doğru olsa bile zor anlaşılır.
Her ne kadar bu kitabın kapağında sırayla Delphi 20007 for Win32, Turbo
Delphi ve Delphi 2006 olmakla birlikte Delphi 7 ve Delphi 2005 kullanıcıları
da bu kitaptan yararlanabilir. Bu kitabın içeriğinin büyük bir kısmı Delphi 7
için de geçerlidir. Bir diğer konu şudur: Borland’ın C++ Builder derleyicisini
kullanarak C++ hakkında bilgi sahibi olduysanız C++ Builder ile gelen
görsel kitaplık ve kontroller hakkında(özellikle veritabanı işlemleri) bilgi
edinmek isteyenler bu kitaptan belli oranda yararlanabilirler.
Bu metni niye mi kaleme aldım: Çünkü Türkiye’de kimse zahmet edip

programcılık kitapları üzerine bir şey yazmıyor. Bu nedenle iş başa düştü ve
kendi kitabım hakkında yazmak istedim. “Kitabın hakkında yazarken objektif
olabildin mi?” diye soranlara elbette diye cevap veririm.

C# E-Kitap Memik Yanik

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C# E-Kitap Memik Yanik

Uploaded by

Copyright:

Available Formats

C#’a Başlangıç Kitabı

Son yazdığım C# kitabımda başlangıç düzeyi konuların ağırlığını azaltmayı

Bu e-book’u inceleyenlerin fark edeceklerini sandığım bir diğer konu ise C#

Öğretim üyeleri veya programcılık dersini veren hocalar öğrencilere ders

Bu dersleri kaleme alırken gerçekte klasik anlamda bir amacım yoktu:

Yıllardır bilgisayar ve programcılık üzerine yazarken temel ilkem veya ön

C# Programcısı Đçin Gerekli Araçlar

Birileri bu dersleri 2 cümle ile anlatın derlerse söyleyeceklerim şunlardır:

dersleri okuyan bazı arkadaşlar 200 sayfalık başlangıç düzeyi C# kitaplarına

Orada burada Memik YANIK ve kitapları aleyhine konuşan, yazan birilerini

C# programlama dili ile ilgili bu dersleri izleyebilmek için başlangıçta

Kullandığınız bilgisayarda Windows XP kuruluysa .NET Framework'ü

dağıtıldı. Yakın bir zamanda ise .NET Framework’ün 3.0/3.5 sürümleri

Bu dersler boyunca anlatılanları izleyip küçük örnekleri deneyebilmeniz için

Bu paragrafı yukarıda .NET Framework’ün sürümlerimden söz edilen

Ne var ki çok sayıda dosyadan meydana gelebilen C# uygulamalarını Not

Son 2 paragraftan kafası karışanlar için ek açıklama: Microsoft firma .NET

Visual Studio son derece gelişmiş ve program yazmayı kolaylaştırdığı gibi

Karışıklık olmasın diye bir konuyu tekrarlayalım:C# derleyicisi .NET

Kısaca anlatmak gerekirse Visual C# için hazırlanmış Express Edition,

istemeyenlere uygundur. Bana sorarsanız C#’ı öğrenirken Express Edition

Yıllardır konu programcılık üzerine yazmak olduğunda asıl olanın anlatma

.NET Framework’ü Kurmak

Herhangi bir programlama dili ile çalışılıp uygulama geliştirilmek

Şu günlerde kullanıma sunulan .NET Framework’ün en son sürümünün

Kullandığınız bilgisayara .NET Framework kurulu ise hemen C# programları

csc.exe dosyası) sayesinde derleme yapıp EXE dosya hazırlayabilirsiniz. Bu

Şimdi microsoft.com’a uğrayıp .NET Framework 3.5’ı indireceğim. Bu amaçla

Yaklaşık 3 Mb’lık bu dosyayı indirip bilgisayarıma kaydettikten sonra

Program Yazmaya Başlıyoruz.

Konu .NET uyumlu programlama dilleri ve özellikle C# olduğunda ilk

Quick Basic, Pascal ve C gibi klasik programlama dillerinde kod dosyaları

procedure ayrımı da yoktur. Başka bir deyişle programcılar yapmak

Zamanla programlar büyüyüp karmaşıklaştıkça paketlenmesi ihtiyacı doğdu.

Yerli yabancı ayrımı yapmadan bugüne kadar hangi kaynağa baktıysam

Đstediğiniz ayrıntıda polimorfizm’den söz edin, istediğiniz kadar biyolojiden

Aşağıda en basit veya en kısıtlı, en az satıra sahip bir C# programı

En az satıra sahip bu C# programındaki Main() metodunun hem static hem

Şimdi yukarıda verdiğim C# programının başlangıç noktası olan Main()

Gördüğünüz gibi C# programlarında değişken tanımlanırken önce

Programcılıkta değişken tanımlamayı günlük hayatta telefon edip bir otelde

Bu kısacak kodu iki cümle ile yorumlamak gerekirse şunlar söylenebilir: Bu

Şimdiye kadar incelediğim bütün kaynaklarda, bütün kitaplarda değişkenler

Yukarıda belirtildiği gibi Class’lar metotları barındırabilmektedir. Ayrıca C#

Bu hali ile bu C# programı veya CS uzantılı kod dosyası DOS penceresinde

Bu programı aşağıdaki gibi düzenlemiş olsaydım değişen bir şey olmazdı.

Şimdi bu Mesaj() adını verdiğim metoda müdahale edip işletildiği zaman

Tam bu noktada elime fırsat geçmişken biraz kendimi savunmak istiyorum.

Aşağıda ise bu ekran görüntüsünü verdiğim Not Defteri penceresine yazmış

static void Mesaj()

Bu şekilde düzenlenen C# uygulaması DOS penceresinde derlenip

Mesaj() metoduna yazdığım satır hakkında biraz konuşmak gerekirse;

Kısaca anlatmak gerekirse Class’lar Namespace’lerin içine

Bu konuyu bir okulda, bir dershanede veya seminerde anlatıyor olsaydım

Bazılarınız bu kısacak örneği bile hemen denemek, bu CS uzantılı dosyayı

C#’ın kurallarına uyarak yazdığınız programları derleyip EXE dosya

.NET Framework’ün başka sürümünden yararlanıyorsanız bu klasörün adı

Hazırlayacağınız CS uzantılı dosyaları bu CSC.EXE dosyasının bulunduğu

içeriğine aşağıda verdiğim satırlardan birisini ekleyip bilgisayarı yeniden

Kullandığınız bilgisayara Visual Studio 2008'i kurulu ise Başlat menüsünden

C# derleyicisinin kullanım şekli ve parametreleri hakkında bilgi edinmek

Yazdığım C# programında Main() metodu içinde “yil” adında ve int tipinde

Tekrarlamak gerekirse yukarıdaki gibi yapılan derleme sonucu CS uzantılı