Programcılar İçin Yazarlık Dersleri 4
‘C# Uygulamalarında Word'den Yararlanmak’ Makalesini Nasıl Yazdım?
Bu yazıda yakın bir zamanda kaleme aldığım C# 3.0 kitabım için C# uygulamaları dahilinde Word belgeleri ve Excel tabloları üzerinde nasıl işlem yapıldığını anlattığım yaklaşık 30 sayfalık bölümü nasıl kaleme aldığımı anlatacağım. Tıpkı sinema yönetmenlerinin çektikleri filmler üzerinde konuşmaları gibi. Bunu niye mi yaptım? Cevap oldukça kısa: 1992 yılından bu yana bilgisayar ve programcılık üzerine yazıyorum. Yazdığım kitap sayısı 3-5 olunca otoriteler(!) hep bir ağızdan Memik YANIK’ı çeviri yapmakla itham ettiler. Böyle bir şeyin olmadığını her fırsatta söylememe rağmen birçok insan yazdıklarımı veya yazma stilimi incelemek yerine kitaplarımı okumadan beni çeviri yapmakla suçladılar. İşte bu yazı bir bakıma bu suçlamalara cevap verip yazdıklarımın çeviri olamayacağını anlatmaya çalışacağım. 30 sayfalık bir metni anlatmak için daha fazla sayfaya ihtiyaç olsa bile sözünü ettiğim makale veya kitaptan aldığım bölümün ancak bir kısmını anlatabildim.
Tabii ki bu yazının tek amacı çeviri yapmadığımı kanıtlamak değildir. Bu yazının bir diğer amacı belki de önemli amacı C# 3.0 kitabımın sözünü ettiğim bölümünde verdiğim 3-5 satırlık kodlarda tanımladığım değişkenlere ad seçerken başka kitaplardan 3-5 satırlık kodlara değer katan eşsiz değişken adlarını çalmanın(!) önemini dikkatinize sunmaktır. Belki de 1994 yılında yazdığım(hatta 1992-93 yıllarında bilgisayar dergilerinde çıkan yazılarımda) Clipper 5.2 kitabımda kullandığım değişkenlerin adlarını(dosya, sayi, i vs..) aradan 10 yıl geçip unutup(!) başka kitaplardan bu değişken adlarını nasıl çalabildiğim konusunda sizleri bilgilendirmeye çalışacağım. Başka bir deyişle 3-5 satırlık kodlarda i, j, dosya ve deger’i değişken adı olarak kullanırken başka kitaplardan değişken çalmanın nasıl bir mecburiyet olduğunu ortaya koyacağım(!).
Başka bir anlatımla; bir yazar düşünün ki günümüzden tam 14 yıl yazdığı programcılık konulu ilk kitabında verdiği örneklerde i, j, sayi, dosyaadi vs adında değişkenker tanımlayıp kullanıyor. Aradan 10 yıl geçip başka bir programcılık kitabını yazarken hazırlamak istediği 3-5 satırlık kısa örneklerde bu değişken adlarını tekrar kullanmak istiyor. Çünkü hazırladığı üç beş satırlık örnek kodlarda değişkenlere gerek duyuyor. Kaderin bir cilvesi mi nedir Memik Yanık adlı yazar 10 yıl önce tanımladığı bu değişkenlerin adlarını unutuyor. Başka bir deyişle iç-içe iki for döngüsü hazırlamak isterken donup kalıyor ve aklına değişken adı olarak kullanabileceği hiçbir harf gelmiyor(!). Karşısındaki rafta 14 yıl önce yazdığı kendi kitabına bakmak yerine başka yazarların kitaplarına bakıp i, j, dosya, sayi1, sayi2 gibi değişken adlarını çalmayı tercih ediyor(!).
Yukarıda sözünü ettiğim C# kitabım yaklaşık 1100 sayfadır ve Word ve Excel’le ilgili bölüm kitabın sonlarında yer almaktadır. Dolayısıyla kitabı edinen okurlar bu bölümün bulunduğu sayfalara geldiklerinde(tabii okurların kitabın bölümlerini sırayla okuduğunu varsayıyoruz) C# ve .NET Framework uyumlu program geliştirme konularına artık yabancı olmayanlardır. Hedef okur grubunun Class nedir, nesne nasıl hazırlanır, hata nasıl yakalanır, referans ve namespace nedir gibi sorulara cevap verebildiğini varsaydım. Hatta hedef okur grubuna girenlerden bazıları C# ile profesyonel kalitede uygulama geliştirip ancak Word ve Excel gibi programlarının imkanlarını C# uygulamalarında henüz kullanmamış olabilirler. Bu arkadaşlar kitabın bu bölümünü okurken işin hikaye kısmını geçip direk olarak 3-5 satırlık kodlara bakarlar.
Her ne kadar bu metni kitap okurunu düşünerek kaleme almış olsam bile benzer yaklaşımı programcılık derslerinde de sergilemek gerekir diye düşünüyorum. Çünkü benzer sorular programcılık derslerini dinleyen öğrencilerin de zihnini meşgul eder. Öğrencinin zihnini meşgul eden sorular öngörülmeyip cevaplanmazsa öğrencinin anlatılanları izlemesi güçleşir. Tecrübeli ve işini seven hocalar öğrencilerin zihinlerini meşgul eden soruları doğru tahmin edip cevapladıktan sonra asıl konularına dönerler.
Bu şartlarda C# 3.0 kitabımın Word ve Excel’le ilgili bölümüne geçip ilk sayfaya bakan kişinin ilk merak edeceği şey Word veya Excel’in kaynaklarını kullanırken hangi referanslardan yararlanmak gerektiğidir. Yoksa bu kişiler birçok kaynakta yapıldığı gibi 2-3 sayfa boyunca ön bilgiye ya da işin hikaye kısmına öncelikle ihtiyaç duymazlar. Diyeceksiniz ki ey “Memik YANIK C# uygulamaları dahilinde Word ve Excel gibi programların imkanlarından yararlanma üzerine yazılan bir iki sayfalık hikaye gereksiz midir?” Bu soruya vereceğim cevap şudur: Kesinlikle gereklidir. Ne ki birçok okur işin hikaye veya ön bilgi kısmını okumayı sevmiyor.
Yıllardır programcılık kitaplarını kaleme alırken çıkış noktamı hep “ilk okumada anlaşılmak” üzerine kurdum. İlk okumada anlaşılmanın bir ayağında yazılanları iyi kaleme alıp okuru hazırlamak olsa bile başka bir ayağında okurun okumak istemeyeceği veya okumakta zorlanacağı teorik açıklamalardan kaçınmak vardı. Örneğin sözünü ettiğim bu bölümde COM teknolojisi hakkında yazılacak 2 sayfayı okurların çoğu okumaz. Çünkü programcılık öğrenmek isteyen okurların çoğunun ortak derdi teorik bilgi edinmek değildir. Tabii Memik YANIK kitaplarında bolca teorik bilgiye yer vermemesi otoriteler tarafından suçlanmasına neden olsa bile okurları yormaya, sabırlarını test etmeye hakkım olmadığı düşüncemin arkasındayım. Yani okurların çoğunluğu C# uygulaması dahilinde Word belgelerinin nasıl hazırlanıp kaydedildiğini merak etmektedir. Çünkü bu okurların büyük bir yüzdesinin COM teknolojisi konulu tez hazırlama amaçları yoktur.
İşin hikaye kısmını burada kesip gelelim C# uygulaması dahilinde Word’den nasıl yararlanıldığına. Yukarıda işaret edildiği üzere C# ve .NET programcılığı hakkında temel bilgilere sahip birisi C# kodu ile Word belgelerini okumak veya yazmak istediğinde ilk merak edeceği konu kullanması gereken sınıfların hangi namespace’lerde olduğu ve bu namespace’lerin hangi referanslarda yani hangi DLL dosyalarında olduklarıdır.
Bu düşünce ile metni(yani kitabımdaki ilgili bölümü, yani burada sizinle paylaştığım makaleyi) kaleme alırken hemen Visual Studio’nun Solution Explorer penceresinden yararlanıp Add Reference diyalog kutusunu ekrana getirip Word belgeleri üzerinde işlem yaparken gerek duyulacak referansları eklemek gerektiğinden söz ettim. Önceliği Word belgelerine verdiğim için Excel tabloları üzerinde işlem yapmayla ilgili sayfalarda bu konu tekrarlanacaktır.
Word belgeleri üzerinde işlem yaparken gerek duyulacak referans Word ve Visual Studio sürümüne göre değişmiyor olsaydı bu ekran görüntüsünü kullanmayabilirdim. Visual Studio’nun 2003 ve 2005 sürümlerinde Add Reference diyalog kutusunda .NET sekmesinde ilgili referans veya DLL dosyası seçilip OK düğmesi tıklandığında Solution Explorer penceresinde birden fazla referans listeleniyordu. Visual Studio 2008’de durum değiştiği için okurun dikkatini çekmek ve kullandığım Word sürümünü görmesi açısından Add Reference diyalog kutusu ile ilgili 2 ekran görüntüsüne yer verdim. Her ne kadar 2 ekran görüntüsüne yer vermiş olsam bile bu ekran görüntülerinin alt kısmını kesip sayfa üzerinde fazla yer kaplamasının önüne geçtim. Tabii Memik YANIK’ın kitabında Add Reference diyalog kutusu ilgili 2 ekran görüntüsü gören bazı otoriteler hemen notlarını verirler:”Memik YANIK’ın kitaplarında ekran görüntülerinden başka bir şey yoktur(!)”.
Word belgesi üzerinde işlem yapılırken gerek duyulacak referansları uygulamaya dahil ettikten sonra okurların aklına gelmesi kuvvetle muhtemel soru şudur: Word belgeleri üzerinde işlem yaparken yararlanacağım sınıflar hangi namespace’lerde bulunuyor? Çünkü .NET Framework ortamı için kod yazan programcılar kod satırlarının kısa olmasını sağlamak için kullanmak istedikleri sınıfların yer aldığı namespace’leri kodun en başında using anahtar kelimesi ile belirtmeyi tercih ediyorlar. Bu düşünce ile yazdığım metne aşağıda verdiğim satırları ekledim. C# kitabımın ilgili bölümünden aldığım satırları ve kodları italik yaptım.
Projeye bu 2 referansı dahil ettikten sonra aşağıda verdiğim 2 satırı yazarak ilgili namespace’lerdeki Class’lardan yararlanmak istediğinizi belirtmelisiniz. 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;
Bu noktada okur artık C# uygulaması dahilinde Word programını çalıştırmak için hangi sınıftan yola çıkıp nesne hazırlaması gerektiğini merak eder. Bu nedenle zaman kaybedilmeden gerek duyacağı nesnenin nasıl hazırlaması gerektiğini anlatmak gerekir. Bu amaçla kitabımda aşağıda verdiğim kodu verdim.
private void Word_penceresi_Click(object sender, EventArgs e)
{
Microsoft.Office.Interop.Word.ApplicationClass Word_uygulamasi;
Word_uygulamasi=new Microsoft.Office.Interop.Word.ApplicationClass();
}
Bu kodda ApplicationClass sınıfının yer aldığı namespace’in adını bilerek yazdım. Madem using bloğunda Microsoft.Office.Interop.Word’deki sınıflardan yararlanmak istediğimi işaret ettim o halde bazılarınız neden bu satırı uzattın diye sorabilirler. Her ne kadar hazırladığım metinde C# uygulaması dahilinde Word belgeleri üzerinde işlem yapılırken kullanılan ApplicationClass sınıfının bulunduğu namespace’in adını anmış olsam bile bazı okurların gözü hemen koda kayar. Başka bir deyişle bazı okurlar “ApplicationClass sınıfı şu namespace’te bulunmaktadır” şeklinde kurulmuş cümleyi okumadan atlamış olabilirler. Bu nedenle okurun konuyu kavraması işini şansa bırakmayıp özellikle birkaç kez Class adından önce namespace adını da yazarım.
2 satırdan meydana gelen(gerçekte bu kod tek satır olarak düzenlenebilir) bu kodu incelemek son derece kolaydır. Bazı yabancı kaynaklarda yazarlar 2-3 satırlık açıklamadan sonra 30-40 satırlık kod veriyorlar. Elbette 30-40 satırlık kodu incelemek konu hakkında bilgi sahibi olanlar için birkaç dakika kadar zaman almazken o konuda bilgisi olmayan birisi için işkence gibidir. Tabii bu metni okuyan kişi C# ve .NET sınıfları hakkında artık bilgi sahibidir.
Tam bu noktada bu 2 satırı inceleyen okurlar bu kodun işlevini merak eder. Hatta metni bilgisayar başında okuyorsa hemen deneyecektir. Aslında bu koda 3. bir satırın eklenmesi gerek. Okurun C# uygulaması dahilinde açılacak Word penceresini görebilmesi 3. bir satırın mutlaka yazılması gerekiyor. Okurun dikkatini çekmek için yukarıda verdiğim koda 3. satırı bilerek eklemedim. Daha doğrusu yanlış hesabın Bağdat’tan dönmesini istedim ve devamında kitaba aşağıda verdiğim paragrafı ekledim.
Bu metoda yazılan ilk 2 satır sayesinde bir 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.
private void Word_penceresi_Click(object sender, EventArgs e)
{
ApplicationClass Word_nesnesi;
Word_nesnesi = new ApplicationClass();
Word_nesnesi.Visible = true;
}
C# üzerine yazdığım ilk kitapta bu 3 satırlık kodda Word penceresini veya Word programını temsil etmek üzere hazırladığım nesneye “Word_uygulamasi” adını vermiştim. Bu değişken adı daha önce yayınlanan Türkçe kaynaklarda kullanıldığı için 2. kez değişken adı hırsızı pozisyonuna düşmemek için küçük bir değişiklik yapıp “Word_uygulamasi” değişkenine “Word_nesnesi” adını verdim.
Bu değişiklikten şu sonucu çıkarabilirsiniz: Allah Microsoft’un programcılarından razı olsun. Çünkü değişkenlere verilecek adlar konusunda seçimi programcılara veren bir C# derleyicisi hazırlayıp programcıların istifadesine sunmuşlardır(!). Keşke daha önce başkaları tarafından tanımlanıp kullanılan değişken adlarının 2. kez kullanılmasını engelleyen bir sistem geliştirmiş olsalardı(!).
Word penceresinin görüntülenmesini sağlayan 3. satırı eklediğim bu metotta sınıf adlarından önce yukarıda yazdığım namespace adlarını kaldırdım. Okur bu satırı yazıp denediğinde sonucu zaten görecektir ama tam bu noktada ekran görüntüsünün kullanılması okuma hızını arttıracaktır. Başka bir deyişle okur yazılanlar konusunda ikna olacaktır.
Tabii bu metni veya kitabın sayfalarını sırayla okuyan birisi için bu ekran görüntüsünün işlevi en fazla 1 saniye sonra biter. Çünkü göreceğini zaten gördü. Tabii okurun beynindeki düşünceleri veya soruları Word belgelerinde olduğu gibi 3-5 dakika öncesine(yani bu ekran görüntüsünü henüz görmediği ana) götürmek mümkün olmadığı için ekran görüntüsünün fazlalık olduğunu düşünebilir.
Tahmin edileceği gibi sırada belge hazırlamayı anlatmak olmalıdır. Word başlatıldığı zaman içeriği boş bir belge otomatik olarak hazırlanıp Word penceresine getirildiği için bu ekran görüntüsündeki eksiklik okurlar tarafından hemen fark edilecektir. Okur tam bu noktada bu Word penceresi içinde belge hazırlamak için hangi sınıfın kullanılması gerektiğini merak edecektir. Bu nedenledir ki kitapta bu ekran görüntüsünün hemen altına aşağıda verdiğim paragrafı ekledim.
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 gerekir. 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 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.
Bu paragrafı okuyanlar hemen Document nesnesinin nasıl hazırlanıp Add() metodu ile Documents koleksiyonuna nasıl eklenip üye yapıldığını merak ederler. Eğer tıpkı 2004 yılında yayınlanan ilk C# kitabımda yaptığım gibi 3-5 sayfada Word belgelerinin C# uygulaması dahilinde nasıl açılıp nasıl bilgi girildiğini anlatıyor olsaydım yukarıda verdiğim 3 satırlık koda 3 satır daha ekleyip sonucu okurlara hemen gösterip ayrıntılarla ilgilenmezdim. Ancak bu yazıda sözünü ettiğim C# kitabımda Word belgeleriyle ilgili bölüme torpil geçip nispeten ayrıntılara girmek istediğim için konuyu adım adım anlatmayı tercih edip MSDN’den yararlanıp Add() metodunun orijinal yapısına kitapta yer verdim.
object missing = System.Reflection.Missing.Value;
object template = @"C:\Test\SampleTemplate.dot";
this.Application.Documents.Add(ref template, ref missing, ref missing, ref missing);
Bu metodun orijinal yapısını neden mi buraya aldım? İstedim ki işin özü anlaşılsın. Tabii kitapta bu metoda yer vermemin 2. bir nedeni var: İstedim ki bu metodun yapısını öğrenmek için mevcut Türkçe C# kitaplarına bakmak bir mecburiyet değildir, Türkçe kitaplara bakıp değişken çalmadan da C# uygulaması dahilinde Word programı çalıştırılıp Word belgeleri hazırlanabilir.
Tam bu noktada dikkatli olmak ve okuru uyarmak gerekmektedir. Çünkü .NET Framework 1.1’den 3.5’ye gelindiğinde C# uygulaması dahilinde Word programını temsil edecek nesnenin hazırlanması işleminde küçük değişiklikler yapıldı. Buna rağmen burada sözünü ettiğim Add() metodunda herhangi bir değişiklik yapılmadı.
Kitapta Add() metodunun yapısını verdikten sonra hemen kullanmak yerine parametreler hakkında açıklamalarda bulundum. Çünkü kitabın bu bölümünü kaleme almaya başlamadan önce şuna karar vermiştim: 30 sayfa boyunca C# uygulamaları dahilinde Word ve Excel programlarından nasıl yararlanıldığını anlatacaktım. Böyle bir kararı verince Add() metodunun bütün parametrelerinden söz etmek gerekiyordu.
“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 3 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.
Add() metodunun 2., 3. ve 4. parametreleri ise Object tipindedir ve System.Reflection.Missing.Value sabitini içermektedir. Microsoft’un programcıları tarafından Add() metodunu örneklemek için yazılan bu örnek kodda 2., 3. ve 4. parametre için önceden “missing” adında bir 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ırayla anlatacağım. Gerçekte Add() metodunun son 3 parametresi ile hiç ilgilenmeyebilirsiniz.”
Tam bu noktada C# programcılarının akıllarına şu soru gelmiş olabilir: Madem Add() metodunun 2., 3. ve 4. parametreleriyle ilgilenmek şart değildir o zaman neden Microsoft’un programcıları bu parametreleri isteğe bağlı yapmamışlardır? Bu soruya verilecek en kısa cevap şudur: Word uygulaması yönetilen kod değildir.
Madem elimizde Word programını temsil eden nesne var ve bu nesneyi hazırlayıp Visible özelliğini true yaptığımızda karşımıza Word penceresi geliyor o zaman yukarıda verdiğim koda ekleme yapıp Word belgesi hazırlayabiliriz. Bu düşünce ile Object tipinde 2 değişken tanımladım.
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;
}
Sablon adını verdiğim değişkene Word’le gelen mevcut dot uzantılı şablon dosyasının adını aktardım. Tabii bu işlemi yapmadan önce Word ile gelen Normal.dot adlı şablon dosyasını “C:” sürücüsünün kök klasörüne alarak kolay bulunan bir yerde olmasını sağladım. Ardından Add() metodunun 2., 3. ve 4. parametrelerinde kullanmak üzere object tipinde 2. bir değişken tanımlayıp bu değişkene Microsoft’un programcılarının yaptığı gibi System.Reflection.Missing.Value sabitini aktardım. Madem bu değişkenin içeriği Value tipindedir ben de boş bulunup bu değişkene Türkçesi olan “deger” adını verdim. Bu 2 değişkeni tanımladıktan sonra sırada DocumentClass nesnesini hazırlamak var. Yani işi özü şudur: C# uygulaması dahilinde Word belgesi açmak için yapılması gerekenleri adım adım anlatarak okurun anlatılanları ilk okumada anlamasını hedefledim. C# uygulaması dahilinde Word belgesi hazırlamak amacıyla hazırladığım kodun son halini aşağıda verdim.
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);
}
Bu kez Add() metoduna 2., 3. ve 4. parametre olarak verdiğim System.Reflection.Missing.Value aktardığım Object tipindeki değişkene ad seçerken Microsoft’un programcılarının tercihine bağlı kaldım. Her ne kadar “deger” adlı değişken bu kodda değer üstüne değer katıyor ve bu kodun daha hızlı çalışmasını sağlıyor(!) olsa bile değişken adı çalmanın alemi yok deyip Microsoft’un kullandığı missing’i tercih ettim.
Aslında yukarıda verilen kod gayet anlaşılırdır ve C# kitabımda Word belgesi hazırlamayı anlatmayı burada kesebilirdim. Madem konuyu ayrıntıları ile anlatmaya karar verdim Add() metodunun 2., 3. ve 4. parametrelerinden söz edeceğim. Yoksa birileri çıkıp memik yanık bu yazdıklarını çevirmiştir, birileri ise Memik Yanık benim kitaptan yararlanmadan bunları kaleme alamazdı derler. Bu amaçla C# kitabımda Add() metodunun 2. parametresi ile ilgili olarak aşağıda verip italik yaptığım 2 paragrafa ve koda yer verdim.
Ş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
Bu kısa açıklama ile Word belgesi hazırlayıp DocumentClass nesnesinin Documents koleksiyonuna eklerken kullanılan Add() metodunun 2. parametrenin işlevinden söz ettikten sonra sırada 3. parametre var. Bu amaçla C# kitabıma aşağıda verdiğim metni ekledim.
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 hazır 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;
Add() metodunun işlevi hakkında bu bilgileri verdikten sonra 4. parametrenin işlevinden söz ettim. Başka bir deyişle DocumentClass nesnesinin Documents koleksiyonuna belge hazırlayıp eklerken kullanılan Add() metodu hakkında bilgi sahibi olduğumu böylece kanıtlamış oldum. Üstelik bunu yerli Türkçe kitaplardan değişken adı çalmadan yaptım. Burada asıl üzerinde durmak gereken nokta şudur: C# kitabımın Word belgeleri hakkında bilgi içeren bölümünü kaleme alırken Add() metodunun parametreleri hakkında Türkçe yazılmış pek bir şey yoktu. --- Devamı var---