Silverlight 3.0 içerisinde DataForm kullanımı.

0 dakikada yazıldı

5768 defa okundu

Düzenle

DataForm kontrolüne hızlı bir şekilde göz atıldığında aslında
ASP.NET'teki DetailsView kontrolüne benzetilebilir. Bu önyargı ile
hızlıca konumuza giriş yaparken gelin ilk olarak bir Silverlight 3
projesine nasıl DataForm kontrolünü ekleyebiliriz inceleyelim.

DataForm kontrolü sahnede...

DataForm kontrolü Silverlight ile beraber gelen harici kontrollerden
biri. Yani DataForm kontrolü Silverlight 3'ün RunTime'ında bulunmuyor.
Öyle hemen istediğimiz yerde anında kullanamıyoruz. Eğer bizim
uygulamamız bu kontrolü kullanmak istiyorsa ona ait DLL'i referans
alarak kendi XAP dosyası içerisinde taşımak zorunda. Tabi bu harici
DLL'ler ile ilgili cachleme vs işlemleri de mümkün fakat bu konuda
makalemizin şimdilik dışında.

Durum böyle ise DataForm kontrolünü kullanabilmek için hemen  Visual
Studio içerisinde yeni bir SL 3.0 projesi yaratıp projemize sağ
tıklayarak "Add Reference" diyip
System.Windows.Controls.Data.DataForm'ı referans olarak eklemeliyiz.
Böylece artık bu DLL içerisindeki kontrolleri kullanabiliriz. Fakat daha
işimiz bitmedi. Projemize eklemiş olduğumuz bu Assembly içerisindeki
kontrolleri XAML tarafında veya Blend 3 içerisinde kullanabilmemiz için
ayrıca XAML tarafına da DLL'imizi tanıtmamız gerekiyor.

[XAML]

<UserControl
x
:Class="SilverlightApplication10.MainPage"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   Width="400"
Height
="300"

   xmlns:dataControls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.DataForm" >

    <Grid
x
:Name="LayoutRoot"
Background
="White">

        <dataControls:DataForm x:Name="birDataForm"></dataControls:DataForm>

    </Grid>

</UserControl>

Yukarıda gördüğünüz şekli ile DLL'imizi dataControls adı altında
XAML tarafına da aldık. Sonrasında da içerisinde bulunduğumuz sayfadaki
Grid'in içine yine dataControls XML namespace'i üzerinden giderek
Assembly içerisinde DataForm sınıfından bir instance alıyoruz. Artık
sahnede bir DataForm var. Tüm bu işlemleri otomatik olarak yapmak
isterseniz Visual Studio içerisinde XAML dosyasını açarak araç
çubuğundan da DataForm kontrolünü sürükleyip sahneye bırakabilirsiniz.
Visual Studio sizin için otomatik olarak DLL'i referans alıp gerekli
XAML tanımlamalarını da yapacaktır. Bu noktada ufak bir detaya dikkat
çekmek istiyorum. Şu an Silverlight 3.0 Beta olduğu için Visual Studio
içerisinde designer tarafında desteği biraz zayıf. O nedenle araç
çubuğundan herhangi bir kontrolü XAML dosyanıza sürükleyip bırakmak
isterseniz sadece kod tarafına bırakabileceğinizi söylemem gerek.

Hemen bir veri bağlayalım!

Kontrolümüz artık sahnede olduğuna göre hemen bir veri bağlayarak neler
yapabiliyoruz göz atalım. İlk olarak bağlayacağımız veriyi temsil edecek
olan sınıfımızı yaratalım.

[VB]

Public Class Entities

    Public Class Urun

 

        Private PAdi As String

        Public Property Adi() As String

            Get

                Return PAdi

            End Get

            Set(ByVal value As String)

                PAdi = value

            End Set

        End Property

 

        Private PSatis As Double

        Public Property Satis() As Double

            Get

                Return PSatis

            End Get

            Set(ByVal value As Double)

                PSatis = value

            End Set

        End Property

 

    End Class

End Class

[C#]

    public class Entities

    {

        public class Urun

        {

            private string PAdi;

            public string Adi

            {

                get { return PAdi; }

                set { PAdi = value; }

            }

 

            private double PSatis;

            public double Satis

            {

                get { return PSatis; }

                set { PSatis = value; }

            }

        }

    }

Gördüğünüz gibi sınıfımızın adı Urun ve içerisinde de iki adet
farklı Property var. Bu sınıfımızdan yola çıkarak birden çok Urun
yaratıp bunları da DataForm kontrolümüze veri kaynağı olarak vereceğiz.
Ama gelin bunun öncesinde tek bir Urun sınıfı yaratarak DataForm'a
verelim bakalım neler yapacak.

[VB]

    Private Sub MainPage_Loaded(ByVal sender As Object,
ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded

        birDataForm.CurrentItem = New
Entities.Urun() With {.Adi = "Ürün Adi", .Satis = 20}

    End Sub

[C#]

        void  MainPage_Loaded(object sender, RoutedEventArgs e)

        {

            birDataForm.CurrentItem = new Entities.Urun { Adi = "Ürün Adi", Satis = 20 };

        }

Daha önceden XAML tarafında yaratmış olduğumuz DataForm kontrolüne isim
olarak birDataForm ismini verdiğimiz için kod tarafında da aynı
isimle ulaşıp şimdilik DataForm'un CurrentItem özelliğine yeni bir
nesne atıyoruz. Söz konusu nesne daha önce tanımlamış olduğumuz Urun
sınıfının bir instance'ı.

DataForm içerisinde tek bir kaydın düzenlenmesi.
DataForm içerisinde tek bir kaydın düzenlenmesi

Gördüğünüz üzere DataForm otomatik olarak kendisine bağlanan veri
içerisinde tüm Property'ler için hem Textblock ve Textbox'lar
yerleştirebiliyor hem de söz konusu Property'lerin adlarını da yanına
yazarak aslında kabaca bir veri giriş ve düzenleme ekranı oluşturuyor.
DataForm içerisinde sol üstte bulunan Edit düğmesine tıklarsanız ortaya
veriyi düzenleyebileceğiniz bir ekran gelirken "Save" düğmesi de hemen
altta kendini gösteriyor. Tabi ki bu aşamadan sonra özelleştirilmesi
gereken birçok nokta var. İşte biz de makalemizin devamında bu noktalara
değineceğiz.

MetaData aşkı!

Eğer ASP.NET Dynamic Data projeleri üzerine biraz çalışma şansınız
olduysa veri kaynağı olarak kullanılan sınıflara verilen MetaData'lar
ile beraber birçok şeyin ayarlanabildiğini hatırlayacaksınız. DataForm
ile beraber çalışırken de aslında çoğu kuralı MetaData'lar ile
DataForm'a bağlayacağımız veri kaynağı seviyesinde ayarlamamız
gerekiyor. Örneğin yukarıdaki projemizde Urun adındaki nesnemizi
tanımlarken Adi ve Satis Property'lerinde tabi ki Türkçe
karakterler kullanmadık. Oysa DataForm bu Property'leri istemci tarafına
açarken belki de Türkçe karakterler de içeren düzgün isimleri açmalı
değil mi?

[VB]

Public Class Entities

    Public Class Urun

 

        Private PAdi As String

        <System.ComponentModel.DataAnnotations.Display(Name:="Adı")> _

        Public Property Adi() As String

            Get

                Return PAdi

            End Get

            Set(ByVal value As String)

                PAdi = value

            End Set

        End Property

 

        Private PSatis As Double

        <System.ComponentModel.DataAnnotations.Display(Name:="Satış")> _

        Public Property Satis() As Double

            Get

                Return PSatis

            End Get

            Set(ByVal value As Double)

                PSatis = value

            End Set

        End Property

 

    End Class

End Class

[C#]

    public class Entities

    {

        public class Urun

        {

 

            private string PAdi;

            [System.ComponentModel.DataAnnotations.Display(Name = "Adı")]

            public string Adi

            {

                get { return PAdi; }

                set { PAdi = value; }

            }

 

            private double PSatis;

        **    [System.ComponentModel.DataAnnotations.Display(Name =** "Satış")]

            public double Satis

            {

                get { return PSatis; }

                set { PSatis = value; }

            }

 

        }

    }

Yukarıdaki kod içerisinde Urun sınıfımızı tanımlarken neleri
değiştirediğimize dikkat edelim. Her bir Property'i tanımlarken bir de
MetaData veriyoruz. System.ComponentModel.DataAnnotations sınıfı
altında kullanabileceğiniz bir çok farklı MetaData'yı bulabilirsiniz.
Bunların bazılarına makalemiz içerisinde göz atacağız. Şu an için
Display MetaData'sını vererek söz konusu Property'lerin DataForm
tarafından hangi isimle gösterilmesi gerektiğini belirtiyoruz. Tabi ki
bu noktada istediğimiz gibi Türkçe karakterler kullanabiliriz. Bundan
sonraki örnek kodlarda Urun sınıfının tüm tanımını değil sadece
MetaData koyduğumuz satırların etrafını yazacağım.

[VB]

        <System.ComponentModel.DataAnnotations.Display(Name:="Satış", Description:="Bu satış değeridir")> _

        Public Property Satis() As Double

Yukarıdaki şekli ile tanımlanan bir Display MetaData'sında ek olarak bir
de Description verisi bulunuyor. Bu parametreye herhangi bir değer
verilmesi halinde DataForm içerisinde bu Property'nin yanında bir ünlem
işareti belirecektir. Kullanıcılar söz konusu ünlem işaretinin üzerine
fareleri ile geldiklerinde ise açıklamanızı görebilirler.

MetaData içerisinde Description yer alırsa...
MetaData içerisinde Description yer alırsa...

Şu ana kadar yaptığımız işlemlerin hepsinde belki de en sinir bozucu
noktalardan biri DataForm içerisinde tüm Property'lerin sınıf
tanımındaki sıra ile gösteriliyor olmasıdır. Aslında bu sırayı da
değiştirebiliyoruz.

[VB]

        Private PAdi As String

        <System.ComponentModel.DataAnnotations.Display(Order:=1)>
_

        Public Property Adi() As String

            Get

                Return PAdi

            End Get

            Set(ByVal value As String)

                PAdi = value

            End Set

        End Property

 

        Private PSatis As Double

        <System.ComponentModel.DataAnnotations.Display(Name:="Satış", Description:="Bu satış değeridir", Order:=0)> _

        Public Property Satis() As Double

            Get

                Return PSatis

            End Get

            Set(ByVal value As Double)

                PSatis = value

            End Set

        End Property

Display MetaData'sını tanımlarken verebileceğiniz Order parametresi
doğrudan bu Property'lerin hangi sıra ile DataForm içerisinde
gösterileceğini belirliyor. Sıfırdan başlayarak vereceğiniz bu sayılarla
küçükten büyüğe doğru gidecek sırada Property'ler ekrana getirilecektir.
Bizim örneğimizde üstte Satis altta Adi parametreleri yer
alıyor.

Binding yollarında...

İlk örneğimizde DataForm'a bağladığımız nesne kod tarafında içerisinde
bulunduğu scope dışında yaşayamayacağı için pek anlamlı bir örnek
olmamıştı. DataForm içerisinde edit işlemi yapılsa da söz konusu bağlı
değişken arkada yaşamadığı için edit işleminin de anlamı kalmıyor. Fakat
eğer DataForm'a bağladığınız değişkenleri kod tarafında sürekli canlı
tutarsanız DataForm içerisindeki değişikliklerin doğrudan nesneye
yansıtıldığını da görebilirsiniz. Duruma göre bu işlevselliği
değiştirmek veya bazen arka taraftaki nesnede bulunan bazı Property'leri
DataForm içerisinde göstermemek de isteyebilirsiniz. Örneğin bizim Urun
nesnesinin bir PK property'si olsaydı kesin onu göstermek istemezdir.

[VB]

        <System.ComponentModel.Bindable(False)> _

        Public Property Adi() As String

Yukarıdaki gibi herhangi bir Property'yi doğrudan Bindable False olarak
işaretleyebilirsiniz. Böylece söz konusu Property hiçbir şekilde bağlı
olduğu kontroller tarafından gösterilmeyecektir. Diğer yandan bu
Property'nin gösterilmesi fakat değerinin değiştirilemesini isterseniz
bu sefer de aşağıdak şekilde Bindable'a ikinci bir parametre vererek tek
yönlü veri bağlantısı oluşturabilirsiniz.

[VB]

        <System.ComponentModel.Bindable(True,
ComponentModel.BindingDirection.OneWay)> _

        Public Property Adi() As String

Yukarıdaki şekli ile bu Property DataForm'un edit modunda gözükse de
değeri değiştirilemeyecektir.

Ya Validation gerekirse?

Belki de DataForm kontrolünün en can alıcı noktalarından biri tüm
validasyon işlemlerini de kısmen MetaData üzerinden yapabiliyor olmamız.
Örneğin bazı Property'lerin kullanıcı tarafından boş geçilememesini
isteyebilirsiniz. Bu ve bu gibi tüm Validation işlemleri için yine
System.ComponentModel.DataAnnotations sınıfı altındaki tanımlardan
faydalanabiliriz.

[VB]

       
<System.ComponentModel.DataAnnotations.Required(ErrorMessage:="Boş geçilemez")> _

        Public Property Adi() As String

Yukarıdaki örnek kodda da görebileceğiniz üzere Required olarak
işaretlediğimiz Adi Property'sine bir de ErrorMessage vermişiz.
DataForm kontrolü bu Property ile ilgili gerekli validasyonları yapmakla
kalmayacak, herhangi bir sorun olduğunda MetaData içerisinde
tanımladığımız hatayı da güzel bir şekilde kullanıcıya gösterecek.

Basit bir validasyon örneği!
Basit bir validasyon örneği!

Validasyon yöntemlerinden bazıları bir önceki örneğimizdeki gibi hazır
bir şekilde tanımlanmış bizim kullanımızı bekliyor. Bunlardan biri de
doğrudan sayısal değerlerin alabilecekleri değer aralığını kontrol eden
Range sınıfı.

[VB]

        <System.ComponentModel.DataAnnotations.Range(1, 10,
ErrorMessage:="Aman!")> _

        Public Property Satis() As Double

Range MetaData'sını biz örneğimizde anlamlı olması açısından Satis
Property'sine verelim. Artık yukarıdaki tanımlama ile beraber Satis
Property'si kesinlikle 1 ile 10 arasında olmak zorunda. Aksi durumda
MetaData içerisinde tanımladığımız ErrorMessage kullanıcıya
gösterilecektir.

[VB]

        <System.ComponentModel.DataAnnotations.StringLength(10)> _

        Public Property Adi() As String

Hazır gelen kontrollerden biri de StringLenght kontrolü. Bu MetaData ile
beraber söz konusu Property'e atanabilecek metin uzunluğunun en yüksek
değerini tanımlamış oluyoruz. Böylece kullanıcılar daha yüksek değerler
girdiğinde eğer tanımlanmış ise özel hata mesajları da gösterilebiliyor.

Eğer isterseniz tüm bu validasyonların yanı sıra daha karmaşık
RegularExpression yapıları da kullanabilirsiniz. Bizim örneğimizde
varsayalım ki kullanıcıların ürünlere isim verirken hep büyük harf ile
başlamalarını istiyoruz. Bu durumda aşağıdaki gibi bir RegEx
tanımlamasını işimizi görecektir.

[VB]

       
<System.ComponentModel.DataAnnotations.RegularExpression("^[A-Z]+[a-zA-Z]*$",
ErrorMessage:="Büyük harfle
başlamalı"
)> _

        Public Property Adi() As String

Hardcore Validasyon?

Bazı durumlarda validasyon ile ilgili RegEx'ler de işinizi görmeyebilir.
Bizim örneğimizde bu duruma uygun anlamlı bir senaryo yaratmak zor olsa
da diyelim ki ürünlerimiz A harfi ile başlıyorsa fiyatlarının kesinlikle
10 ile 20 arasında olması gerekiyor. Bu senaryoyu gerçek hayata taşırken
aslında farklı Property'lerin farklı iş kuralları ile kontrol edilmesi
gerektiğini de düşünebilirsiniz. Böyle bir durumda tamamen farklı bir
mekanizma kullanabilmek için CustomValidation yapısı bizi bekliyor.

[VB]

    Public Class Kontrol

        Public Shared Function UrunKontrol(ByVal BirUrun As Urun) As Boolean

            If
BirUrun.Adi.StartsWith("A") Then

                If BirUrun.Satis > 10
And BirUrun.Satis < 20 Then

                    Return True

                Else

                    Return False

                End If

            Else

                Return True

            End If

        End Function

    End Class

[C#]

    public class Kontrol

    {

        public static bool UrunKontrol(Urun BirUrun)

        {

            if
(BirUrun.Adi.StartsWith("A"))

            {

                if (BirUrun.Satis >
10 & BirUrun.Satis < 20)

                {

                    return true;

                }

                else

                {

                    return false;

                }

            }

            else

            {

                return true;

            }

        }

    }

Yukarıdaki gördüğünüz kod içerisinde Kontrol adında bir sınıfın
içinde Shared / Static olarak tanımlanmış bir Validasyon metodu
bulunuyor. Metod aslında alıştığımız .NET metodlarından farklı değil.
UrunKontrol adını verdiğimiz bu metod kendisine parametre olarak
verilen bir Urun nesnesini kontrol ederek geriye True veya
False şeklinde Valid / Uygundur veya InValid / Uygun Değildir mesajı
döndürmüş oluyor. Bu hazırladığımız validasyon metodunun herhangi bir
Urun nesnesine uygulanması için ise Urun nesnesinin tanımına ufak
bir MetaData eklemesi yeterli olacaktır.

[VB]

    <System.ComponentModel.DataAnnotations.CustomValidation(GetType(Kontrol), "UrunKontrol", ErrorMessage:="Olmadı!")> _

    Public Class Urun

[C#]

    [System.ComponentModel.DataAnnotations.CustomValidation(typeof(Kontrol), "UrunKontrol", ErrorMessage = "Olmadı!")]

    public class Urun

    {

    }

CustomValidation olarak tanımladığımız bu kontrol mekanizmasını
sınıfımıza bağlarken ilk olarak validasyon yapacak olan sınıfın tipini
veriyoruz. Sonrasında bu sınıf içerisinde hangi metodun kullanılacağını
bir String parametre olarak verip bir de eğer istiyorsak validasyon
işlemi False döndürdüğünde gösterilmek üzere ErrorMessage
ayarlıyoruz. İsterseniz bu mekanizmayı sınıf bazında değil doğrudan
Property bazında da kurabilirsiniz.

Herşey kontrol altında...

Tüm bahsettiğimiz validasyon sistemlerine ek olarak bazen bir ürün
düzenlenmesi ile ilgili istemci tarafında DataForm ile yaratılan
süreçlere müdahale etmek de isteyebilirsiniz. Örneğin bir ürün
kaydedilirken adı boş ise belki ona varsayılan bir isim vermek
isteyeceksiniz veya bir ürünün kayıt moduna geçildikten sonra herhangi
bir değişiklik yapılmadan kayıt modundan çıkılmasını engellemek de
isteyebilirsiniz. Bu gibi daha birçok senaryo olabilir.

[VB]

    Public Class Urun

        Implements
ComponentModel.IEditableObject

 

        Private PAdi As String

        Public Property Adi() As String

            Get

                Return PAdi

            End Get

            Set(ByVal value As String)

                PAdi = value

            End Set

        End Property

 

        Private PSatis As Double

        Public Property Satis() As Double

            Get

                Return PSatis

            End Get

            Set(ByVal value As Double)

                PSatis = value

            End Set

        End Property

 

        Public Sub BeginEdit() Implements
System.ComponentModel.IEditableObject.BeginEdit

 

        End Sub

 

        Public Sub CancelEdit() Implements
System.ComponentModel.IEditableObject.CancelEdit

 

        End Sub

 

        Public Sub EndEdit() Implements
System.ComponentModel.IEditableObject.EndEdit

 

        End Sub

    End Class

[C#]

        public class Urun :
IEditableObject

        {

            private string PAdi;

            public string Adi

            {

                get { return PAdi; }

                set { PAdi = value; }

            }

 

            private double PSatis;

            public double Satis

            {

                get { return PSatis; }

                set { PSatis = value; }

            }

 

            public void BeginEdit()

            {

                throw new NotImplementedException();

            }

 

            public void CancelEdit()

            {

                throw new NotImplementedException();

            }

 

            public void EndEdit()

            {

                throw new NotImplementedException();

            }

        }

Kendi sınıfınıza IEditableObject interface'ini implemente ettiğiniz
anda artık sınıfınızın BeginEdit, CancelEdit ve EndEdit gibi
durumları olacak. Bu durumlara dair kod bloklarına yazacağınız kodlar
edit işlemi başladığında, iptal edildiğinde veya bittiğinde
çalıştırılacaktır. Böylece siz de bu süreçlerde nesne ile ilgili
değişiklikleri rahatlıkla yapabilirsiniz.

Çoklu kayıt desteği de var.

DataForm kontrolünü epey karıştırmış olsak da aslında hiç
bakmadığımız bir özelliği var. Örneklerimizin başından beridir sadece
tek bir nesne yarattık ve DataForm'un CurrentItem'ına atadık.
Oysa DataForm kontrolünün ItemsSource'una da birden çok nesne
içeren listeler bağlanabilir.

** [VB]**

    Private Sub MainPage_Loaded(ByVal sender As Object,
ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded

        Dim liste As New
System.Collections.ObjectModel.ObservableCollection(Of Entities.Urun)

        liste.Add(New Entities.Urun()
With {.Adi = "Ürün Adi", .Satis = 20})

        liste.Add(New Entities.Urun()
With {.Adi = "Ürün Adi2", .Satis = 30})

        liste.Add(New Entities.Urun()
With {.Adi = "Ürün Adi3", .Satis = 40})

        birDataForm.ItemsSource = liste

    End Sub

[C#]

        void MainPage_Loaded(object sender, RoutedEventArgs e)

        {

            System.Collections.ObjectModel.ObservableCollection<Entities.Urun> liste = new System.Collections.ObjectModel.ObservableCollection<Entities.Urun>();

            liste.Add(new Entities.Urun { Adi = "Ürün Adi", Satis = 20 });

            liste.Add(new Entities.Urun { Adi = "Ürün Adi2", Satis = 30 });

            liste.Add(new Entities.Urun { Adi = "Ürün Adi3", Satis = 40 });

            birDataForm.ItemsSource = liste;

        }

Kodumuzda bu sefer tamamen deneme amaçlı olarak içerisinde birden çok
Urun bulunan bir ObservableCollection kullanıyoruz. Uygulamamızı
çalıştırdığımıda DataForm kontrlünün sağ üstünde navigasyon
kontrolleri de yerini alıyor. Böylece artık DataForm kontrolü
içerisinde birden çok nesnenin de gezilerek düzenlenebileceğini görmüş
olduk.

Çoklu kayıt düzenleme ekranı.
Çoklu kayıt düzenleme ekranı.

Yukarıdaki ekran görüntüsünde sağ üst köşede gördüğünüz düğmeler sadece
kayıtlar arasında gezintiyi sağlamıyor. Ayrıca bulunan kaydın
düzenlenebilmesinin yanı sıra yeni bir kayıt eklenebilmesini hatta
silinebilmesini de sağlayabiliyorlar. Hali hazırda nesnemize bir
ObservableCollection bağladığımız için zaten tüm değişiklikler
otomatik olarak nesneye de yansıyacaktır.

AutoGenerateFields ?

Sanırım ASP.NET ile biraz uğraşan herkes AutoGenerateFields deyince ne
demek istediğimi anlayacaktır. Bir DataForm'un normal şartlarda
kendisine verdiğimiz veriye uygun şekilde gerekli TextBox vs kayıt
düzenleme kontrollerini otomatik olarak yaratmasını sağlayan özellik
AutoGenerateFields'in varsayılan değeri olan "True" değerinde saklı.
Eğer AutoGenerateFields özelliğini False olarak ayarlarsanız
artık veri kaynağından gelen her verinin ne şekilde görsel ekrana
yansıtılacağını tek tek sizin ayarlamanız gerekecektir. Tabi bu durum da
bazı senaryolarda özelleştirme adına şart oluyor. Şimdi gelin bu konunun
detaylarına bakalım.

[XAML]

        <dataControls:DataForm AutoGenerateFields="False"
x:Name="birDataForm">

           
<dataControls:DataForm.Fields
>

                <dataControls:DataFormCheckBoxField />

                <dataControls:DataFormComboBoxField />

                <dataControls:DataFormDateField />

                <dataControls:DataFormTemplateField />

                <dataControls:DataFormTextField />

            </dataControls:DataForm.Fields>

       
</dataControls:DataForm
>

Yukarıdaki kod çalışır bir kod olmayacaktır. Fakat kabaca bir
DataForm'un içerisinde gösterilecek verilerin ayarlanması ile ilgili
kullanabileceğimiz Field tiplerini ve DataForm içerisine nasıl
yerleştirebileceğimizi inceleyebilirsiniz. Bu Field tiplerinin her biri
aslında farklı veri tiplerini hedefliyorlar. Örneğin CheckBoxField
Boolean tipindeki verilerin gösterimi için rahatlıkla
kullanılabilirken TextField ise metin tabanlı ve özünde TextBox
olarak gösterilecek verileri temsil edecektir. Eğer bu Field tipleri
size yeterli gelmiyorsa ve kendi özel Field tasarımınızı yaratmak
istiyorsanız bu sefer de DataFormTemplateField'i kullanabilirsiniz.

[XAML]

        <dataControls:DataForm

           AutoGenerateFields="False"

           x:Name="birDataForm">

           
<dataControls:DataForm.Fields
>

                <dataControls:DataFormTextField

                  
FieldLabelContent
="Kayıt Adı"

                   Binding="{Binding
Adi
}" />

                <dataControls:DataFormTextField

                  
FieldLabelContent
="Satış
Sayısı"

                   Binding="{Binding
Satis
}" />

            </dataControls:DataForm.Fields>

       
</dataControls:DataForm
>

Bir önceki adımda veri bağlantısını da yaptığımız DataForm üzerinden
ilerlersek ilk olarak AutoGenerateFields özelliğini False olarak
ayarlayıp sonrasında da iki tane TextField ekliyoruz. Her bir
TextField'in veri kaynağından hangi veriyi alıp göstereceğini
belirlemek için tabi ki veri kaynağımız olan nesnelerin property'lerine
ait adları vermemiz gerekiyor. Bu aşamada her bir Field'in Binding
özelliğine bir Binding atıyoruz ve Property adı ile veri
bağlantısını da tamamlıyoruz. Son olarak yine her bir TextField'e de
FieldLabelContent vererek bu Field'ler için yaratılacak
TextBox'ların yanına konacak Label'ların da içeriğini belirlemiş
oluyoruz. Ayrıca isterseniz FieldLabelPosition gibi Field'lere ayrı
farklı özellikleri de değiştirerek ana görsel öğelerin dizilimine
müdahale edebilirsiniz.

Eğer DataForm kontrolüne bağladığınız nesnelerin çok sayıda Property'si
varsa bunları belirli gruplar ve altbaşlıklar ile de göstermek
isteyebilirsiniz. Bunun için DataFormFieldGroup nesnesini
kullanabilir hatta bu grupların arasına da DataFormSeparator'lar
koyabilirsiniz.

[XAML]

        <dataControls:DataForm

           AutoGenerateFields="False"

           x:Name="birDataForm">

           
<dataControls:DataForm.Fields
>

                <dataControls:DataFormHeader

                   Content="Düzenlenecek şeyler" />

                <dataControls:DataFormSeparator />

                <dataControls:DataFormFieldGroup

                   Orientation="Horizontal">

                    <dataControls:DataFormTextField

                      
FieldLabelPosition
="Top"

                      
FieldLabelContent
="Kayıt Adı"

                       Binding="{Binding
Adi
}" />

                    <dataControls:DataFormTextField

                      
FieldLabelPosition
="Top"

                      
FieldLabelContent
="Satış
Sayısı"

                       Binding="{Binding
Satis
}" />

                </dataControls:DataFormFieldGroup>

            </dataControls:DataForm.Fields>

       
</dataControls:DataForm
>

Yukarıdaki kod içerisinde ilk olarak bir FormHeader bulunuyor.
Sonrasında bir Separator da kullandıktan sonra elimizdeki
TextField'leri bir Fieldgroup içerisine aldık. FieldGroup'un
Orientation özelliğini de Horizontal yaptığımızda artık bu grup
içerisindeki kayıt düzenleme nesneleri yan yana gösterilecektir.

Özelleştirilmiş bir DataForm kontrolü.
Özelleştirilmiş bir DataForm kontrolü.

Daha da özelleştirelim, daha da!

Eğer yukarıdaki Field yapılarını özelleştirmek sizin ihtiyaçlarınızı
gidermediyse aslında bir adım daha ileri giderek tüm görsel yapıyı
değiştirme şansınız da var. Bunun için artık DataForm'un
DisplayTemplate ve EditTemplate özelliklerine eğilmemiz şart.

[XAML]

        <dataControls:DataForm

           AutoGenerateFields="False"

           x:Name="birDataForm">

            <dataControls:DataForm.HeaderTemplate>

                <DataTemplate></DataTemplate>

            </dataControls:DataForm.HeaderTemplate>

            <dataControls:DataForm.DisplayTemplate>

                <DataTemplate></DataTemplate>

            </dataControls:DataForm.DisplayTemplate>

            <dataControls:DataForm.EditTemplate>

                <DataTemplate></DataTemplate>

            </dataControls:DataForm.EditTemplate>

            <dataControls:DataForm.InsertTemplate>

                <DataTemplate></DataTemplate>

            </dataControls:DataForm.InsertTemplate>

        </dataControls:DataForm>

Yukarıda gördüğünüz şekilde düzenlenen Template / Şablon yapıları birer
DataTemplate olarak tanımlanır ve bu şablonlar içerisinde tanımlı
görsel tasarımlar doğrudan DataForm kontrolü tarafından kullanılır.

[XAML]

        <dataControls:DataForm

           AutoGenerateFields="False"

           x:Name="birDataForm">

            <dataControls:DataForm.DisplayTemplate>

                <DataTemplate>

                    <StackPanel>

                        <TextBlock

                           Text="{Binding
Adi
}"></TextBlock>

                        <TextBlock

                           Text="{Binding
Satis
}"></TextBlock>

                    </StackPanel>

                </DataTemplate>

            </dataControls:DataForm.DisplayTemplate>

            <dataControls:DataForm.EditTemplate>

                <DataTemplate>

                    <StackPanel>

                        <TextBox

                           Text="{Binding
Adi
}"></TextBox>

                        <TextBox

                           Text="{Binding
Satis
}"></TextBox>

                    </StackPanel>

                </DataTemplate>

            </dataControls:DataForm.EditTemplate>

        </dataControls:DataForm>

Yukarıdaki XAMl içerisinde DataForm kontrolümüzün DisplayTemplate ve
EditTemplate şablonlarına basit birer StackPanel yerleştiriyoruz. Bu
StackPanel'ler içerisinde DisplayTemplate'te TextBlock'lar var,
EditTemplate'te ise TextBox'lar var. Tüm bu kontrollerin
Text özellikleri veri kaynağından uygun Property'lere bağlı durumda.
Veri bağlama işlemini yine klasik Binding sistemi ile yapıyoruz.
Kontrol normalde TextBlock'ları gösterirken düzenleme moduna geçince ise
EditTemplate içerisindeki TextBox'ları gösterecektir. Tabi siz
örneklerinizde basit birer StackPanel yerine çok daha özelleştirilmiş
görsel tasarımlar kullanabilirsiniz.

Sonuç

Görüldüğü üzere DataForm kontrolü kendisinden beklenenden çok daha
fazlasını sunabilecek bir kontrol olarak karşımızda. İş uygulamalarında
sürekli hazırladığınız çoğu formun Silverlight içerisinde rahatlıkla ve
en önemlisi de hızlı bir şekilde oluşturulabilmesini sağlıyor. İster
basit ister karışık validasyon kurallarınız olsun, ister basit ister
karışık ve özelleştirilmiş bir tasarımınız olsun DataForm kontrolü her
durumda size uyum sağlayabilecek şekilde tasarlanmış. Eh hadi ;) Sıra
sizde...

Hepinize kolay gelsin....