C#’a Başlangıç Kitabı - w3.gazi.edu.trw3.gazi.edu.tr/~enyilmaz/CSharp_E-KitapMemikYanik.pdf · kurmuş olanları da gözeteceğim. Bu dersleri izlerken Visual Studio’nun 2005

C#’a Başlangıç Kitabı

Memik Yanık [email protected]

[email protected]

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 { static void Main(string[] args) { 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 { static void Main(string[] args) { 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() { } static void Main(string[] args) { 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 { static void Main(string[] args) { 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 { static void Main(string[] args) { 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 { static void Main(string[] args) { 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 { static void Main(string[] args) { int yil; System.Console.Write("Hangi Yıldayız : "); yil = System.Console.Read(); System.Console.WriteLine(); 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

{ static void Main(string[] args) { int yil; System.Console.Write("Hangi Yıldayız : "); yil = System.Console.ReadLine(); System.Console.Write("Girdiğiniz Yıl :"); System.Console.WriteLine(yil); } }

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; System.Console.Write("Hangi Yıldayız : "); str = System.Console.ReadLine(); System.Console.Write("Girdiğiniz Yıl :"); 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 { static void Main(string[] args) { int yil; System.Console.Write("Hangi Yıldayız : "); yil = System.Console.Read(); System.Console.WriteLine(); System.Console.Write("Girdiğiniz Yıl :"); System.Console.WriteLine(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 { static void Main(string[] args) { int yil; System.Console.Write("Hangi Yıldayız : "); yil = System.Console.ReadLine(); System.Console.Write("Girdiğiniz Yıl :"); System.Console.WriteLine(yil); } }

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 { static void Main(string[] args) { string str; System.Console.Write("Hangi Yıldayız : "); str = System.Console.ReadLine(); System.Console.Write("Girdiğiniz Yıl :"); 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 { static void Main(string[] args) { 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: "); str2 = System.Console.ReadLine(); sayi1 = System.Int16.Parse(str1); sayi2 = System.Int16.Parse(str2); } }

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 { static void Main(string[] args) { string str1, str2;


int number1, numberi2; System.Console.Write("Đlk sayıyı girin : "); str1 = System.Console.ReadLine(); System.Console.Write("Đkinci sayıyı girin: "); str2 = System.Console.ReadLine(); 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 { static void Main(string[] args) { string str1,str2, sonuc_str; int sonuc, sayi1, sayi2; System.Console.Write("Đlk sayıyı girin : "); str1 = System.Console.ReadLine(); System.Console.Write("Đkinci sayıyı girin: "); str2 = System.Console.ReadLine(); sayi1 = System.Int32.Parse(str1); sayi2 = System.Int32.Parse(str2); 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 { static void Main(string[] args) { string str1,str2, sonuc_str; int sonuc, sayi1, sayi2; System.Console.Write("Đlk sayıyı girin : "); str1 = System.Console.ReadLine(); System.Console.Write("Đkinci sayıyı girin: "); str2 = System.Console.ReadLine(); sayi1 = System.Int32.Parse(str1); sayi2 = System.Int32.Parse(str2); 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 { public static void Main() { 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 { public static void Main() { 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 { public static void Main() { Console.Write("Program Đlk sınıftaki Main ile başladı"); Console.ReadLine(); } } class sinif_2 { public static void Main() { 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 { public static void Main() { 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 { public static void Main() { 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 { public static void Main() { 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 { static void Main(string[] args) { 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.

static void Main(string[] args) { 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 { static void Main(string[] args) { 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.

Application.Run(new Form1());

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); Application.Run(new Form1()); }

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); Application.Run(new Form1()); }


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 partial class Form1 : Form { public Form1() { InitializeComponent(); } 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 partial class Form1 : Form { public Form1() { InitializeComponent(); } 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); Application.Run(new Form2());

}

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.

private void button1_Click(object sender, EventArgs e) { Form2 ikinci_form = new Form2(); 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.

private void button1_Click(object sender, EventArgs e) { 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.


private void button1_Click(object sender, EventArgs e) { Form2 ikinci_form = new Form2(); 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.

Form2 ikinci_form = new Form2(); private void button1_Click(object sender, EventArgs e) { 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; private void button1_Click(object sender, EventArgs e) { 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); Application.Run(new Form1()); Application.Run(new Form2()); }

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.

private void resim_sec_Click(object sender, EventArgs e) { 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.


private void resim_sec_Click(object sender, EventArgs e) { 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.

private void resim_sec_Click(object sender, EventArgs e) { Image resim; resim = Image.FromFile("C:\\jazz.jpg"); pictureBox1.Image = resim; }

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.

private void resim_sec_Click(object sender, EventArgs e) { Bitmap resim; resim = (Bitmap)Bitmap.FromFile("C:\\jazz.jpg"); pictureBox1.Image = resim; }

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ı.

private void resim_sec_Click(object sender, EventArgs e) { Image resim; resim = Image.FromFile("C:\\jazz.jpg"); pictureBox1.Image = resim; }


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.

private void resim_sec_Click(object sender, EventArgs e) { 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.

private void resim_sec_Click(object sender, EventArgs e) { 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.

static void Main(string[] args) { Form1 F1 = new Form1(); F1.ShowDialog(); Console.ReadKey(); } static void Main(string[] args) { 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.

private void Word_penceresi_Click(object sender, EventArgs e) { 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.

private void Word_penceresi_Click(object sender, EventArgs e) { 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.

private void Word_penceresi_Click(object sender, EventArgs e) { 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ü.

private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object deger = System.Reflection.Missing.Value; ApplicationClass Word_nesnesi; Word_nesnesi = new ApplicationClass(); Word_nesnesi.Visible = true; }

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.

private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; ApplicationClass Word_nesnesi; Word_nesnesi = new ApplicationClass(); Word_nesnesi.Visible = true; 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.

private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; ApplicationClass Word_nesnesi; Word_nesnesi = new ApplicationClass(); Word_nesnesi.Visible = true; 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(); private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; object yeni_sablon = true;


Word_nesnesi.Visible = true; Belge1 = Word_nesnesi.Documents.Add(ref sablon,

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.

ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; object yeni_sablon = false; object belge_tipi = WdNewDocumentType.wdNewBlankDocument; Word_nesnesi.Visible = true; Belge1 = Word_nesnesi.Documents.Add(ref sablon,

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.

ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; object yeni_sablon = false; object gorunme = true; object belge_tipi = WdNewDocumentType.wdNewBlankDocument; Word_nesnesi.Visible = true; Belge1 = Word_nesnesi.Documents.Add(ref sablon,

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.


ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; object yeni_sablon = false; object visible = false; object belge_tipi = WdNewDocumentType.wdNewBlankDocument; Word_nesnesi.Visible = true; Belge1 = Word_nesnesi.Documents.Add(ref sablon,

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.


ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); Document Belge2 = new DocumentClass(); private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; object yeni_sablon = false; object visible = true; object belge_tipi = WdNewDocumentType.wdNewBlankDocument; Word_nesnesi.Visible = true; Belge1 = Word_nesnesi.Documents.Add(ref sablon,

ref yeni_sablon, ref belge_tipi, ref visible); Belge2 = Word_nesnesi.Documents.Add(ref sablon,

ref yeni_sablon, ref belge_tipi, ref visible); 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) { object missing = System.Reflection.Missing.Value; 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.

private void ekle_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; 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) { object missing = System.Reflection.Missing.Value; 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.

private void ekle_Click(object sender, EventArgs e) { 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.

private void naklet_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; 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.


private void naklet_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; 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. object missing = System.Reflection.Missing.Value; 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.

ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); private void Word_penceresi_Click(object sender, EventArgs e) { object sablon = "C:\\Normal.dot"; object missing = System.Reflection.Missing.Value; object visible = true; object belge_tipi = WdNewDocumentType.wdNewBlankDocument; Word_nesnesi.Visible = true; Belge1 = Word_nesnesi.Documents.Add(ref sablon,

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 missing = System.Reflection.Missing.Value; 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 missing = System.Reflection.Missing.Value; 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 missing = System.Reflection.Missing.Value; 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 missing = System.Reflection.Missing.Value;


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.

object missing = System.Reflection.Missing.Value; object unit = Microsoft.Office.Interop.Word.WdUnits.wdLine; 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 missing = System.Reflection.Missing.Value; 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.

private void Sec_Click(object sender, EventArgs e) { object son = 2; object unit = Microsoft.Office.Interop.Word.WdUnits.wdWord; Word_nesnesi.Selection.MoveEnd(ref unit, ref son); }

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.

private void Sec_Click(object sender, EventArgs e) { object son = 2; object unit = Microsoft.Office.Interop.Word.WdUnits.wdLine; Word_nesnesi.Selection.MoveEnd(ref unit, ref son); }

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. 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); 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.

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); Microsoft.Office.Interop.Word.Find arama_nesnesi; arama_nesnesi = erim.Find; object missing = System.Reflection.Missing.Value; 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, 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.

private void Ara_Click(object sender, EventArgs e) { object aranan_str = textBox1.Text; object missing = System.Reflection.Missing.Value; object unit = Microsoft.Office.Interop.Word.WdUnits.wdStory; Word_nesnesi.Selection.HomeKey(ref unit, ref missing);


Microsoft.Office.Interop.Word.Find arama_nesnesi; arama_nesnesi = Word_nesnesi.Selection.Find; bool sonuc = 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, ref missing, ref missing, 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.

ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); private void Kaydet_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; saveFileDialog1.ShowDialog(); object Dosya = saveFileDialog1.FileName; Belge1.SaveAs(ref Dosya, ref missing, ref missing, ref missing,

ref missing, ref missing, ref missing, ref missing, ref missing, 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.

ApplicationClass Word_nesnesi = new ApplicationClass(); Document Belge1 = new DocumentClass(); private void Kaydet_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; 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, ref missing, ref missing, ref missing,

ref missing, ref missing, ref missing, 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) { object missing = System.Reflection.Missing.Value; 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 missing = System.Reflection.Missing.Value; 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.

private void Cikis_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; 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.

private void Cikis_Click(object sender, EventArgs e) { object missing = System.Reflection.Missing.Value; 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.

ApplicationClass Word_nesnesi; Document Belge1; private void Dosya_open_Click(object sender, EventArgs e) { Belge1 = new DocumentClass();


Word_nesnesi = new ApplicationClass(); Word_nesnesi.Visible = true; openFileDialog1.ShowDialog(); object kutuk = openFileDialog1.FileName; object missing = System.Reflection.Missing.Value; Belge1 = Word_nesnesi.Documents.Open(ref kutuk, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, 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.

ApplicationClass Word_nesnesi; Document Belge1; private void Dosya_open_Click(object sender, EventArgs e) { Belge1 = new DocumentClass(); Word_nesnesi = new ApplicationClass(); Word_nesnesi.Visible = true; openFileDialog1.ShowDialog(); object kutuk = openFileDialog1.FileName; object missing = System.Reflection.Missing.Value; object yalniz_read = true; Belge1 = Word_nesnesi.Documents.Open(ref kutuk, ref missing, ref yalniz_read, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, 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.

ApplicationClass Word_nesnesi; Document Belge1; private void Dosya_open_Click(object sender, EventArgs e) { Belge1 = new DocumentClass(); Word_nesnesi = new ApplicationClass(); openFileDialog1.ShowDialog(); object kutuk = openFileDialog1.FileName; Word_nesnesi.Visible = true; object missing = System.Reflection.Missing.Value; object izin_iste = true; object yalniz_read = false; Belge1 = Word_nesnesi.Documents.Open(ref kutuk,

ref izin_iste, ref yalniz_read, ref missing, ref missing, ref missing, ref missing, ref missing,

ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, 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) { object missing = System.Reflection.Missing.Value; Word_nesnesi.PrintOut(ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, 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. private void Yazdir_Click(object sender, EventArgs e) { object secim = WdPrintOutRange.wdPrintSelection; object missing = System.Reflection.Missing.Value; Word_nesnesi.PrintOut(ref missing, ref missing, ref secim, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing); } 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.

private void Yazdir_Click(object sender, EventArgs e) { object secim = WdPrintOutRange.wdPrintFromTo; object first_sayfa = "2"; object last_sayfa = "3"; object missing = System.Reflection.Missing.Value; Word_nesnesi.PrintOut(ref missing, ref missing, ref secim, ref missing, ref first_sayfa, ref last_sayfa, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, 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.