Eğer siz de kendinize bu şekilde URL’ler ile haşır neşir buluyorsanız ve Firefox web tarayıcısını kullanıyorsanız size süper bir eklenti tavsiye etmek istiyorum: Locationbar². Bu eklenti yardımı ile adres çubuğunuzda bulunan URL segmentlerini tıklanabilir linkler haline getirebilir ve bu segmentlerin görünümün daha anlaşılır bir hale sokabilirsiniz. Benim eklenti ayarlarım şu şekilde:

Bu ayarlar ile fare imlecinizi adres çubuğunun alt kısmına yaklaştırdığınızda adres link şeklini alıyor ve o segmente kadar olan URL’ye tıklamanız suretiyle gidebiliyorsunuz. Başta biraz kullanım zorluğu çekebilirsiniz ancak sonraları alışkanlık yapıyor ve kullandığınız her tarayıcıda arar oluyorsunuz.

Butonların hemen üstündeki çizgi pencerenin beyaz arkaplanlı üst ve gri arkaplanlı alt kısımlarını ayırmada kullanılmış ve 3 boyutlu bir görünüm kazandırmış. Visual Basic 6 ile böyle bir şeyi yapmak için Line kontrollerini kullanırdık. Birer adet gri ve beyaz renkli Line kontrolünü aralık bırakmadan alt alta gelecek şekilde formumuza yerlerştirdiğimizde bu görünümü elde edebilirdik. Visual Studio’nun .NET sonrası versiyonlarında böyle bir kontrol gelmemekte. Bana kalırsa gerek de yok çünkü Form üzerine Line tarzı kontroller koymak gereksiz yere tasarım ortamını karıştırıyor. Bunun yerine Windows Forms’un nimetlerinden yararlanarak bu sorunu çok daha şık bir şekilde çözebiliriz.

Yapmamız gereken Panel kontrolünün OnPaint metodunu override edip bize sağlanan Graphics nesnesini kullanarak ControlPaint.DrawBorder3D static metodu ile istediğimiz kenara, istediğimiz tarzda bir border ekleyebiliriz. C# ile anlatacak olursam:

class EtchedBorderedPanel : Panel
{
    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
 
        ControlPaint.DrawBorder3D(e.Graphics, 
            this.ClientRectangle, 
            Border3DStyle.Etched, 
            Border3DSide.Top);
    }
}

Bu kontrolü daha sonra penceremizin alt kısmına Dock edebiliriz. En son hafta sonu projem FxLibrarian için yaptığım About dialog penceresi:

CodeProject‘teki şu makale de böyle bir kontrolü nasıl yapacağınızı anlatıyor. Biraz eski ama tekrar kullanılabilir bir kontrol yapma konusunda güzel bilgiler içeriyor.

Gelmiş geçmiş Windows’ların içinde (Millenium Edition da dahil) en fiyakalısı olan Vista’da hala bu dialog neden bulunuyor? Atlamışlar heralde… Neyse bunu gördükten sonra bir başka tarihi eser olan moricons.dll de hala yerinde mi diye baktım. Yanlış hatırlamıyorsam C:\Windows klasöründe olması gerekiyordu ama yoktu. Klasör içinde arama yapınca System32 klasöründe olduğunu gördüm:

Eğer moricons.dll içindeki 32×32 büyüklüğünde ve tamı tamına 16 renk derinliğine sahip simgelere bağımlılığı bulunan uygulamalarınız varsa korkmayın, Windows Vista altında da uygulamalarınız sorunsuz bir şekilde çalışacaktır (UAC’yi saymazsak). Backward compatibility bu olsa gerek.

Masaüstü uygulamalarında da bu tarz TextBox kullanımını görmemiz münkün. Mesela Windows Vista’da her bir Explorer penceresinin sağ üst köşesinde ve Internet Explorer 7′de bulunan arama kutularında bu kullanım mevcut:

Yine Windows Vista’da başlat menüsünün alt kısmında çıkan arama kutusunda da bunu görmekteyiz:

Sizin de bu yöntemi .NET ve Windows Forms kullanarak geliştirdiğiniz uygulamalarda kullanmanız mümkün. Ne yazık ki .NET ile gelen TextBox kontrolünün böyle bir özelliği yok, bir şekilde bunu kendimiz yapmamız gerek. İlk akla gelen yöntemlerden biri kullandığımız TextBox kontrolünün Enter ve Leave eventlerini yakalayıp yazıyı gösterme/göstermeme işlemini gerçekleştirebilirsiniz. Benzer bir yöntemle ama bu sefer biraz daha alt seviyede TextBox kontrolünü subclass ederek yeni bir kontrol oluşturabilir ve OnGotFocus/OnLostFocus metodlarını override ederek benzer işlevi yeni kontrole kazandırmanız da mümkün. Ama tahmin edebileceğiniz gibi bu yöntemler pek de temiz gibi görünmüyor. Hem yazacağımız kod gereğinden fazla karışık ve yönetilemez olacak, hem de kontrolün temiz/sorunsuz bir kullanımı olmayacak. Geçiniz…

Peki nasıl yapalım biz bu işi? Şöyle oluyor efendim; EM_SETCUEBANNER mesajını TextBox kontrolümüze User32.dll kütüphanesindeki meşhur SendMessage fonksiyonu ile göndererek. Aynen yukarıda örnek verdiğim Windows uygulamalarının da yaptığı gibi. Eğer programınız Windows XP veya sonrası bir işletim sisteminde çalışıyorsa bu yöntemi kullanarak acısız ve ağrısız bir şekilde TextBox kontrollerinize Cue Banner Text özelliği kazandırabilirsiniz.

SendMessage User32 sistem kütüphanesinde export edilmiş bir fonksiyon olduğu için bu fonksiyonu .NET içerisinden Platform Invocation veya kısaltacak olursak P/Invoke ile çağırmamız mümkün. EM_SETCUEBANNER sabitinin değeri ve SendMessage fonksiyonunun kullanacağımız versiyonu şu şekilde:

internal const uint ECM_FIRST = 0x1500;
internal const uint EM_SETCUEBANNER = ECM_FIRST + 1;
 
[DllImport("user32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr SendMessage(
    HandleRef hWnd, 
    uint msg, 
    bool wParam, 
    string lParam);

Fonksiyonun parametrelerinin ne işe yaradığınız özetlemek gerekirse; HandleRef tipindeki hWnd parametresi ile TextBox kontrolümüzün Handle değerini, msg parametresi ile EM_SETCUEBANNER sabitini, wParam ile Cue Banner metninin kontrol üzerinde iken de gösterilip gösterilmeyeceğini ve son olarak lParam ile de Cue Banner metnini göndereceğiz. Burada 3. parametre olan wParam için özel bir durum var. Windows Vista’ya kadar EM_SETCUEBANNER mesajını gönderirken bu parametre göz ardı ediliyordu. Ancak Vista ile beraber buraya true değeri göndermemiz durumunda Cue Banner metni kontrol üzerinde iken de görünüyor, ta ki kullanıcı ilk karakteri girene kadar. Eğer Windows Vista kullanıyorsanız bu özelliği başlat menüsündeki arama kutusunda deneyebilirsiniz. Aşağıdaki kod txtSearch isminde bir TextBox kontrolüne Cue Banner olarak “Search” metnini atıyor:

SendMessage(
    new HandleRef(txtSearch, txtSearch.Handle), 
    EM_SETCUEBANNER, 
    false, 
    "Search");

Kodu bu haliyle Windows Formunuzun constructoruna veya Form_Load eventine yerleştirmeniz mümkün. Ama bir kaç satır kod yazarak TextBox kontrolünden türeyen ve Cue Banner Text özelliği olan yeni bir TextBox kontrolü oluşturabiliriz. Böylelikle projenizin farklı yerlerinde böyle bir kontrol kullanacak olursanız sanki formunuza normal bir TextBox kontrolü yerleştirirmiş gibi bu kontrolü yerleştirip Properties penceresinden de Cue Banner metnini belirleyebilirsiniz.

Fark ettiyseniz Windows Explorer, IE7 ve başlat menüsünde bulunan arama kutularındaki Cue Banner metinleri gri renkte ve italik yazı tipi ile yazılmış, bizim oluşturduğumuz ise gri olmasına rağmen italik değil. Channel 9 Forumlarında littleguru adındaki kullanıcının daha önceden oluşturmuş olduğu benzer bir kontrolde ek olarak Cue Banner fontunu belirleme seçeneği de koymuş. OnGotFocus/OnLostFocus metodlarını override ederek TextBox’un o anki font değerini değiştiriyor. Ancak program çalıştığı esnada bu değerlerin (Cue Banner metni ve fontu) değişmesi gibi bazı durumunda kontrol pek sağlıklı çalışmıyor. Ayrıca bahsettiğim Vista ile gelen yeni özellik de o kontrolde uygulanmış değil. O yüzden bu işi yapan kontrolü tekrar yazmaya karar verdim. Tekrar yazmak dediysem pek de bir şey yapmadım hani, littleguru’nun kodunu baz alarak bir kaç değişiklik yaptım. Vista ile gelen özellikten de Kenny Kerr‘in Ağustos ayında MSDN Magazine’de yayınlamış olduğu Windows Vista Control Enhancements yazısını okuyunca haberim oldu.

Kontrolü ve demosunu içeren Visual Studio 2008 projesi (12kb)

AirTies ADSL Modem Reset Utility 1.0.0.0 (3,40 KB)

Not: Programı sadece kullanmakta olduğum AirTies RT-205 modeli ile test edebildim ancak diğer modeller ile de sorunsuz çalışacağını ümit ediyorum.

Güncelleme: Programın C# kaynak kodunu görebilirsiniz.

“The type System.Collections.Generic.Dictionary is not supported because it implements IDictionary.”

İnternette bu işi yapabilecek bir şeyler araştırdım ve hatrı sayılır sitede bu sorunun farklı farklı çözümlerine rastladım. Bunlardan en çok Pete Welter’in çözümü hoşuma gitti. Bu çözümde Pete Welter, Dictionary generic tipini ve IXmlSerializable tipini implement eden yeni bir tip yaratmış. Dictionary’den dolayı yeni tipimiz Dictionary ile beraber gelen tüm özelliklere sahip, oh ne güzel. IXmlSerializable tipinin gerektirdiği metodları da implement ederek XML Serialization işlemi sırasında yeni tipimizin nasıl serialize edileceğini de bildirmiş sevgili Pete Welter. Sonuç olarak temiz ve çok rahat kullanılabilir yeni bir tip ortaya çıkmış. Kod şu şekilde:

[XmlRoot("dictionary")]
public class SerializableDictionary<TKey, TValue>
    : Dictionary<TKey, TValue>, IXmlSerializable
{
    #region IXmlSerializable Members
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }
 
    public void ReadXml(System.Xml.XmlReader reader)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
 
        if (wasEmpty)
            return;
 
        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement("item");
 
            reader.ReadStartElement("key");
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            reader.ReadStartElement("value");
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            this.Add(key, value);
 
            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }
 
    public void WriteXml(System.Xml.XmlWriter writer)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement("item");
 
            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();
 
            writer.WriteStartElement("value");
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();
 
            writer.WriteEndElement();
        }
    }
    #endregion
}

Dictionary nesnemiz için serialize edilebilen key ve value tipleri seçtiğimiz sürece SerializableDictionary tipimiz de serialize edilebilir. Key/value tipleri olarak string kullandığımız bir SerializableDictionary nesnesini serialize ettiğimizde şöyle bir çıktıya sahip oluyor:

<dictionary>
  <item>
    <key>
      <string>foo</string>
    </key>
    <value>
      <string>bar</string>
    </value>
  </item>
</dictionary>

Buraya kadar her şey güzel, Dictionary yerine bu yeni tipi kullanarak varolan Dictionary yapılarımızı XML olarak da serialize edebiliriz artık. Ama bir şey içime sinmiyor hala, XML çıktısındaki etiketlerin isimlerini SerializableDictionary üzerinde hard-coded olarak yazıyoruz. Kökteki etiket ismini XmlRootAttribute’e farklı bir parametre göndererek veya SerializableDictionary tipini extend eden yeni bir tip tanımlayarak değiştirebiliriz. Ama hala alt seviyelerdeki item, key ve value şeklindeki etiket isimlerini hard-code etmek dışında bir seçeneğimiz görünmüyor. Eğer bu sınıfı tek tipteki bir Dictionary verimiz için kullanacaksak pek bir sorun yok ama farklı farklı XML çıktılarını beklediğimiz generic bir çözüm için bu tipi kullanmayı planlıyorsak bu etiket isimlerine müdahale etmenin daha generic bir yolunu bulmamız gerek (copy/paste yapmayı bir çözüm olarak aklımızdan bile geçirmiyoruz tabii ki). Bu amaçla SerializableDictionary tipini biraz değiştirerek şu kodu elde ettim:

public abstract class SerializableDictionary<TKey, TValue> 
    : Dictionary<TKey, TValue>, IXmlSerializable
{
    protected abstract string itemName { get; }
    protected abstract string keyName { get; }
    protected abstract string valueName { get; }
 
    #region IXmlSerializable Members
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }
 
    public void ReadXml(XmlReader reader)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
 
        if (wasEmpty)
            return;
 
        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement(itemName);
 
            reader.ReadStartElement(keyName);
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            reader.ReadStartElement(valueName);
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            this.Add(key, value);
 
            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }
 
    public void WriteXml(System.Xml.XmlWriter writer)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement(itemName);
 
 
            writer.WriteStartElement(keyName);
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();
 
            writer.WriteStartElement(valueName);
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();
 
            writer.WriteEndElement();
        }
    }
    #endregion
}

Override edilmek üzere 3 tane abstract property ekleyerek hard-coded string değerlerinden kurtulmuş olduk. Tipimize abstract üyeler eklediğimiz için artık bu tipi direk olarak kullanılamaz hale getirdik ve bir abstract tipimiz oldu. Tipimizi kullanmak istediğimizde yamamız gereken kod artık şu şekilde olacak:

public class Fields : SerializableDictionary<string, string>
{
    protected override string itemName
    {
        get { return "Field"; }
    }
 
    protected override string keyName
    {
        get { return "Name"; }
    }
 
    protected override string valueName
    {
        get { return "Value"; }
    }
}

Burada az önce değiştirdiğimiz SerializableDictionary tipini extend ederek kullanacağımız yeni tipi yaratıyoruz. Bu aşmada Key/Value tiplerimizi ve XML çıktısında oluşacak etiketlerin isimlerini belirtiyoruz. Eğer kök XML etiketi için kullanılacak ismin tipimizin isminden farklı olmasını istiyorsanız yeni tipin üzerinde XmlRootAttribute kullanarak bunu da belirtebilirsiniz. Bu tipimizi de artık şu şekilde kullanabiliriz:

// 2 kayıt içeren bir Dictionary oluşturalım
// .NET 3.5/VS2008 ile gelen Collection Initializers özelliği
// bu gibi durumlarda daha temiz/kısa kod yazmamıza yarıyor
Fields fields = new Fields {
    { "foo", "bar" },
    { "hede", "hödö"}
};
 
// XML Serialize işlemi için gerekli altyapıyı oluşturalım
StringBuilder sb = new StringBuilder();
 
// Burada da bir başka yenilik olan Object Initializer özelliğini
// kullanarak nesneyi oluşturduğumuz satırda nesne üzerindeki
// bazı özelliklere de ilk değerlerini verebiliyoruz
XmlTextWriter xtw = new XmlTextWriter(new StringWriter(sb)) 
    { Formatting = Formatting.Indented };
xtw.WriteRaw("");
 
// Burada XML Serialize işlemi gerçekleşiyor
XmlSerializer xs = new XmlSerializer(typeof(Fields));
xs.Serialize(xtw, fields);
 
string xmlFields = sb.ToString();
 
Console.WriteLine(xmlFields);
 
// Burada da daha önce serialize ettiğimiz nesneyi deserialize ederek
// tekrar hafızda bir nesne haline çeviriyoruz
Fields deserializedFields = xs.Deserialize(new StringReader(xmlFields)) as Fields;

Bu kodun çıktısı da şu şekilde:

<Fields>
  <Field>
    <Name>
      <string>foo</string>
    </Name>
    <Value>
      <string>bar</string>
    </Value>
  </Field>
  <Field>
    <Name>
      <string>hede</string>
    </Name>
    <Value>
      <string>hödö</string>
    </Value>
  </Field>
</Fields>

SerializableDictionary tipini bir kere tanımlayarak projemiz içerisinde bunu baz alan farklı farklı Dictionary tiplerimizi oluşturabilir, bunların farklı farklı XML çıktıları olmasını sağlayabiliriz.

Daha önce Kasım ayında çıkacağı duyurulan Visual Studio 2008 ve .NET Framework 3.5′in RTM sürümleri bugün duyuruldu. MSDN Subscription sahipleri bugün itibariyle bu ürünü indirebilir. Eğer 90 günlük deneme sürümünü indirmek istiyorsanız şu sayfaya gidip Team System Edition’larını indirebilirsiniz. Burada daha “Visual Studio 2008 Professional Edition” için download linki hazır değil ama 1 haftaya kadar o da çıkacakmış. Tamamen ücretsiz olan Express sürümlerinin 2008 versiyonları da indirilebilir durumda. .NET Framework’ün 3.5 internetten kurulan versiyonunu (2.7 MB) ve tekrar dağıtılabilen (offline) versiyonunu (197.1 MB) da Microsoft Downloads’dan indirebilirsiniz. .NET Framework 3.5 ayrıca 2.0 ve 3.0 versiyonlarının SP1′lerini de içermekte.

Kaynak.

Güncelleme: XPS formatında biri tek parça ve biri de 16 parçalık halde olmak üzere iki yeni dosya daha eklenmiş. Tek parça halinde bastırmak biraz zor olacağı için, 16 tane A4 kağıda basıp birleştirmek mümkün.

string a = null;
string b = "foo";
string c = a ?? b;

kodu çalıştırıldığında c değişkeni a null değerine sahip olduğu için b’nin değeri olan “foo” değerine sahip oluyor. İşimizi bir çok sefer kolaylaştıran diğer bir operatör ?: Ternary operatöründen bile daha okunabilir bir kod sağlıyor. Ternary ile bunu şu şekilde yazabilirdik:

string a = null;
string b = "foo";
string c = a != null ? a : b;

Hele bir de if kullansaydık bu işlem için bu kadar daha kod yazmamız gerekecekti:

string a = null;
string b = "foo";
 
if (a != null)
    c = a;
else
    c = b;

Operatörü iç içe geçmiş bir şekilde kullanırsak bir kaç değişken arasından ilk null olmayanını bulabiliriz:

string a = null;
string b = null;
string c = "foo";
string d = a ?? b ?? c; // d = "foo"

Operatörün MSDN sayfasına şuradan ulaşabilirsiniz.

Bu operatör aslında JavaScript yazarken kullandığımız || operatörü ile aynı işi yapıyor; ilk operand null değilse onu null ise sonrakini döndür.

var foo = "bar";
var baz = null;
alert(foo || baz);

Oysa ki ASP.NET’in arkasında muazzam bir framework, BCL (Base Class Library) var. Klasik ASP’de olan Request, Response, Session, vs. nesneleri bunda yok mu; var tabii ki hem de çok daha zengin, çok daha kullanılabilir. Bana göre tek yanlış olan bunların üzerine kurulan ASP.NET Web Forms yapısı. MonoRail isimli proje ile RoR’daki web programlama mantığı .NET ortamına getirilmeye çalışılıyor. Bunun ile bir proje geliştirmeye fırsatım olmadı ancak muhtemelen Web Forms mantığından daha uygulanabilir olacağını tahmin ediyorum.

İşte bu noktada ScottGu geçtiğimiz haftalarda ALT.NET konferansında Microsoft tarafından geliştirilmekte olan ASP.NET MVC Framework’unu tanıttı. Daha üzerinde çalışmalar süren bu frameworkun bu yıl sonuna doğru genel önizleme (”public preview” demek istiyorum :)) sürümü geliştiricilere bir CTP olarak sunulacak. .NET 3.5′e dahil olmayacak bu framework, aynı ASP.NET AJAX (Asynchronous Javascript And XML) (daha önce Atlas olarak da bilinen) gibi ASP.NET üzerine ek bir framework olarak dağıtılacak. 2008′in ilk yarısında da son halinin çıkması planlanıyor.

Orjinal duyuruyu ScottGu’nun blogunda; ayrıntılı bilgiyi, blog camiasından konu ile ilgili linkleri ve ScottGu’nun tanıtım videosunu (izlemeniz şiddetle tavsiye olunur) ScottHa’nın blogunda bulabilirsiniz. Konu ile ilgili (blogunu yeni keşfettiğim) Muhammed Tahiroğlu’nun yazısını da okumanız tavsiye ederim.