.Net 4.0 etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
.Net 4.0 etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

Çarşamba, Aralık 11, 2013

Microsoft .Net Framework 4.0 & 4.5 – Full Download

Merhaba,

 

.Net ile yazılım geliştiricilerin özelliklede Framework 4.x ile geliştirenlerin başlıca sorunu kurulum dosyası hazırladıklarında .Net Framework ‘ü kurmak için internete bağlanmalarıdır. Çünkü kurulum dosyaları 2-3 MB arasıdır. Yavaş internet kullanıcılarında ve kurumsal şirketlerde projelerin çok ama çok geç kurulmasına sebep olmaktadır. Bu sebepten ötürü sizlere .Net 4.x Framework ‘lerin tam kurulabilir paketlerinin linklerini sizlere sunuyorum. Umarım yararlı olur.

 

.Net Framework 4.0

.Net Framework 4.5

 

Umarım yararlı olur.

--

TT

Perşembe, Mayıs 06, 2010

Visual Studio 2010 & Windows 7 - JumpList

Windows 7 ve .Net Framework 4 hayatımıza bir çok yenilik ve güzellikle birlikte girdiler. Windows 7 optime edilmiş performans faktörleri, otomatik değişen arka plan özellikleri, başlat menüsünde yer alan ikonların üzerine tuttuğunda üstünde çıkan ufak ekranlar, bu ikonların üzerine sağ tıklama yaptığında hem uygulama ile ilgili hem de o uygulama üzerinde ki son yapmış olduğunuz işlemleri listeleyen ve bunlar gibi bir çok özellik ile kullanımızdadır. .Net Framework 4 ise geliştirilen özellikleri ile birlikte büyüyen bir yapı ile karşımıza çıktı. Ancak bu boyutsal büyümeye karşılık farklı tiplerde framework kullanım olanakları ile de geliştiricileri sevindirmeyi sürdürdü. Örneğin basit bir web uygulaması için bütün framework 'u kullanmak yerine client framework adını verdikleri o uygulama için gerekli olan bileşenlerin bulunduğu framework 'te sunarak kullanım kolaylığı ve performans faktörleri olarak faydalar sağlanmıştır.

mak89_1

Peki Windows 7 ile .Net Framework 4 arasında Windows Vista ile .Net Framework 3.x arasındaki uyum var mıdır? Bu sorunun cevabı tabii ki evet olacaktır. Windows 7 ile gelen özelliklere .Net FW4 yardımı ile erişip işlemler yapabilmemiz mümkündür. Bizde bu olanaklarından yararlanarak hazırlamış olduğumuz uygulamalarda Windows 7 'de kullanılmak üzere JumpList 'i nasıl hazırlayabileceğimizi inceleyeme çalışıyor olacağız.

JumpList nedir? JumpList, uygulamalar üzerinde yapılmış ya da yapılacak olan işlemlere basitçe erişebilmek için hazırlanan güzel bir özelliktir. Internet tarayıcısı üzerinden düşünürsek dolaşmış olduğumuz son on web sayfasının görülmesi ve tek tıklama ile tarayıcı bile açmadan girebilmek ya da Visual Studio üzerinde geliştirmiş olduğumuz son projelerin listesinin görülmesi ve tek tıklama ile o projeye erişebilme kolaylığı olarak anlatabiliriz. Aslında bizim yapacak olduğumuz işlemlerdeki adım sayısını azaltarak işlem kolaylığı tanımaktadır.

mak89_2

Şimdi Visual Studio 2010 ve .Net Framework 4 ile JumpList 'i kendi hazırlayacak olduğumuz uygulamaya nasıl entegre edebileceğimize göz atalım. Örneğimiz için boş bir WPF uygulması oluşturuyor ve OnStartup olayına aşağıdaki kod bloğunu ekliyoruz. Yapacak olduğumuz bu işlem uygulamanın eğer ki bir güncellemesi var ise varsayılan DLL ile karşılaştırdıktan sonra güncellemeleri yapması ile alakalı olacaktır. Ancak burada dikkat edilmesi gereken kullanılan JumpTast ve JumpList sınıflarıdır.

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {

        if (e.Args.Count() > 0)
        {
            MessageBox.Show("En son surumu kullanmaktasiniz.");
            Shutdown();
        }

        JumpTask task = new JumpTask
        {
            Title = "Guncellemeleri kontrol et",
            Arguments = "/guncelle",
            Description = "Gucellemeler kontrol edilir",
            CustomCategory = "Islemler",
            IconResourcePath = Assembly.GetEntryAssembly().CodeBase,
            ApplicationPath = Assembly.GetEntryAssembly().CodeBase
        };

        JumpList jumpList = new JumpList();
        jumpList.JumpItems.Add(task);
        jumpList.ShowFrequentCategory = false;
        jumpList.ShowRecentCategory = false;

        JumpList.SetJumpList(Application.Current, jumpList);
}

JumpTask sınıfını kullanarak Title, Arguments, Description, CustomCategory, IconResourcePath, ApplicationPath elemanlarına değerleri atayarak görüntüsünü hazırlıyoruz. Sonra bu hazırladığımız görevleri JumpList 'in JumpItem koleksiyonuna ekleyerek işlemleri tamamlıyor ve kullanılır duruma getirmiş bulunuyoruz. Şimdi tek yapmamız gereken uygulamayı çalıştırıp sonucu kontrol etmek olacaktır.

mak89_3

İşlemin sonucu istediğimiz gibidir. Sonuç olarak bu yazımızda VS2010 ve .Net FW4 'ü kullanarak Windows 7 'nin işlem kolaylaştırak özelliklerinde JumpList 'e nasıl bilgi ekleyebileceğimizi ve kullanabileceğimizi incelemeye çalıştık.

Umarım sizler için yararlı olabilmiştir.

Kaynak
MSDN

Turhal Temizer

info@turhaltemizer.com

Perşembe, Nisan 22, 2010

Enterprise Library 5.0

Data, ön bellek, şifreleme, istisnai durumlar ve daha bir çok özelliği hazırlamış olduğumuz uygulamalarda daha esnek ve kolay geliştirmemize olanak tanıyan Enterprise Library ‘nin 5 sürümünü aşağıdaki linkten indirebilirsiniz. Bizlere sağladığı olanaklar aşağıdan erişebilirsiniz.

  • •Major architectural refactoring that provides improved testability and maintainability through full support of the dependency injection style of development
  • •Dependency injection container independence (Unity ships with Enterprise Library, but you can replace it with a container of your choice)
  • •Programmatic configuration support, including a fluent configuration interface and an XSD schema to enable IntelliSense
  • •Redesign of the configuration tool to provide:
    •     •A more usable and intuitive look and feel
    •     •Extensibility improvements through meta-data driven configuration visualizations that replace the requirement to write design time code
    •     •A wizard framework that can help to simplify complex configuration tasks
    • •Data accessors for more intuitive processing of data query results
    • •Asynchronous data access support
    • •Honoring validation attributes between Validation Application Block and DataAnnotations
    • •Integration with Windows Presentation Foundation (WPF) validation mechanisms
    • •Support for complex configuration scenarios, including additive merge from multiple configuration sources and hierarchical merge
    • •Optimized cache scavenging
    • •Better performance when logging
    • •A reduction of the number of assemblies
    • •Support for the .NET 4.0 Framework and integration with Microsoft Visual Studio 2010
    • •Improvements to Unity

    İyi çalışmalar…

 

Pazartesi, Nisan 12, 2010

Visual Studio 2010 – RTM

Visual Studio 2010 çıktı.

Uzun bir gelişme sürecinin ardından Visual Studio 2010 resmi olarak satışa sunuldu.Visual Studio 2010

IDE üzerinde WPF ‘in nimetlerinden yararlanılarak yapılan değişiklikler, WWF ‘in tasarımın ve akış tiplerinin yenilenmesi, F# dilinin entegre edilmesi, MVC 2 ile beraber gelmesi ve diğer bir çok özelliği ile bugün VS2010 çıkmış bulunuyor. Deneme sürümünü indirip kurmak isteyenler aşağıda verecek olduğum linkten yararlanabilirler. Almak isteyenler için ise Visual Studio 2010 Ultimate satış fiyatı $11850. :)

http://www.microsoft.com/visualstudio/en-us/download

Cumartesi, Mart 13, 2010

WPF 4 & .Net Framework 4 - Workflow Designer Oluşturmak - I

Windows Workflow Foundation (WF) ile incelemelerimizi bir süredir .Net 3.0 kütüphanesi ve Visual Studio IDE 'si üzerinde alışık olduğumuz tasarım ekranı ile incelemeye ve uygulamalarımızı geliştirmeye çalışıyorduk. Ancak çok yakın bir zaman içerisinde .Net 4.0 'ın final sürümüne kavuşacağını düşünerek bu yazımızı Visual Studio 2010 IDE sinde .Net 4.0 ile Worklow Designer programlama modelini incelemeye çalışıyor olacağız.

Not: Worfklow Foundation 4.0 ile ilgili detaylı bilgi için Burak Selim Şenyurt 'un yazmış olduğu bu güzel yazıyı incelemenizi tavsiye ediyorum. Çünkü bu yazımızda uygulama bazında WF 4.0 'ı inceliyor olacağız.

Yakın zaman içerisinde karşımıza çıkacak olan Visual Studio 2010 bilindiği üzere WPF ile yeniden tasarlandı. Daha esnek ve daha kullanışlı bir tasarım ile karşımıza çıktı. Özellikle WPF 'in esnekliğini Visual Studio 2010 üzerinde kullanabileceğimize hiç şüphemiz yoktur. VS2010 'da bu değişiklikler olurken bir yandan da yenilenen görünümü, tasarım yapısı ve WPF ile hazırlanmış iş akışlarını tasarlayabildiğimiz Activity Library ekranı yardımı ile biz geliştiriciler için kullanım kolaylaşmıştır.

Bu kadar yenilenen tasarımdan bahsettikten sonra artık uygulama geliştirmeye geliştirmeye başlayabiliriz. Yazımızında başında da bahsettiğimiz gibi uygulamalarımızı VS2010 ve .Net 4.0 ile geliştiriyor olacağız. Uygulamamız esnasında bir WPF uygulamasında iş akışı süreçlerini kullanıyor olacağız.

İlk olarak VS2010 yardımı ile WPF uygulaması oluşturuyoruz.



Projemiz başarılı bir şekilde oluşturulduktan sonra proje özellikleri ekranında yapacak olduğumuz ufak birkaç işlem bulunmaktadır. Projelerde varsayılan target Framework .Net Framework 4 Client Profile seçeneği seçili olarak gelmektedir. Biz bunu .Net Framework 4 seçeneği seçili olacak şekilde değiştiriyoruz.



Bu ekranda yapmış olduğumuz değişiklik esnasında karşımıza Target Framework 'u değiştirmek istiyor musunuz? şekilde soru soran bir ekran çıkacaktır. Evet dedikten sonra artık .Net Framework 4 'ün bütün nimetlerinde faydalanır duruma geliyoruz.

Peki biz bu değişikliği neden yaptık. Çünkü belirli bir şablon tipine dahil olan bir proje yi oluşturduğumuzda yalnızca bu proje tipinde kullanılabilecek isim alanlarının ve araçlarının olduğu daha özelleştirilmiş bir framework bizlere sunulmaktadır. Sebebi ise o proje geliştirilirken onun ile ilgisi olmayan framework kısımlarını kullanmamaktır. Bunun en büyük faydası ile Garbage collector 'un daha rahat çalışması ve çabuk derleme şeklinde yorumlayabiliriz. Ancak biz bu yazımızda WF tasarım ekranını kendimiz oluşturmaya çalışacağımız için framework 'un tamamına ihtiyacamız olacaktır. Çünkü biraz önceki kısıtlı framework 'te WF geliştirmemize olanak tanıyacak olan dll 'ler yer almamaktaydı. Bu kısa bilgiyi de öğrendikten sonra işlemlerimizi yapmaya devam edebiliriz.

Şimdi uygulamamıza bir tane Class Library ekliyoruz. Sonrasında bir adet sınıf oluşturuyoruz ve bu sınıfı CodeActivity 'den türetiyoruz. Sonrasında ise aşağıdaki kodları ekliyoruz.

namespace CustomActivities
{
    using System;
    using System.Activities;
    using System.Activities.Statements;

    public class Prompt : CodeActivity
    {
        public string Text { get; set; }
        public string Response { get; set; }

        protected override void Execute(CodeActivityContext context)
        {
           throw new NotImplementedException();
        }

         public static Activity GetSimpleSequence()
         {
             return new Sequence
             {
                 Activities =
                 {
                    ;  new Prompt(),
                    ;  new Assign()
                 }
             };
        }
    }
}

Bu işlem sonrasında projeyi derliyor ve oluşturmuş olduğumuz WPF uygulamasına Add Reference ekranında projeler kısmından ekliyoruz.



Sonrasında WPF uygulamasına referans eklemeye devam ediyoruz. CodeActivity 'yi kullandığımız için projemizde System.Activities, System.Activities.Core.Presentation, System.Activities.Presentation DLL 'lerinin projeye ekli olması gerekmektedir.



Bu işlemi de tamamladıktan sonra hazırlayacak olduğumuz Workflow Designer 'i oluşturmaya başlayabiliriz.

WPF uygulaması içerisinde yer alan MainWindows.xaml üzerinde işlemler yapağız. Oluşturacak Workflow Designer 'ı WPF Grid içerisinde düzenliyor olacağız. Yaptığımız işlem sonrasında ise WorkflowDesigner 'ın içerisine Sequence aktivitenin tasarım ekranında yer alacaktır.

Şimdi tasarım ekranı üzerinde birkaç düzenleme yapalım. İlk olarak standart olması açısından tasarım ekranının boyutlarını 800x600 olarak belirliyoruz.



Biz bu işlemleri yaparken IDE 'nin yaptığımız değişiklikleri XAML kod üzerine yansıttığını unutmayalım. Yani istersek bu işlemlerin hepsinin XAML üzerinde nesnelerin özelliklerine değerler vererekte yapabilmemiz mümkündür.

Tasarım ekranı üzerinde yapmış olduğumuz işlemler sonrasında şimdi de Grid 'i özelleştireceğiz. ColumnDefinitions özelliklerine CollectionEditor yardımı ile birkaç kolon ekleyip özelliklerine değerler atayacağız.



Collection Editor 'u açtıktan sonra 3 tane kolon ekliyoruz.



Kolonları ekledik. Ancak genişlik boyutunu gördüğünüz kadarıyla 4* şeklindedir. Peki bu yıldız nedir? Kısaca açıklayalım.

Yıldız değeri kullanılan satır ya da sütunlar değişebilir şekilde kullanılabilir. Örneğin * olan değerler ilk durumda satır ve sütünlar bir kez kullanılabilirken 2* olanlar iki kez kullanılabilmektedir.

Grid üzerinde yapmış olduğumuz değişiklikler XAML kod tarafına nasıl yansıdığına kısaca göz atmak gerekirse şu şekilde olmuştur.

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition />
        <ColumnDefinition Width="4*" />
        <ColumnDefinition />
    </Grid.ColumnDefinitions>
</Grid>

Herşey güzel. Bu grid üzerine neden 3 kolon koyduk? Hemen açıklayalım. Visual Studio IDE 'sinden referans alarak ve kendi çapımızda bir Workflow ekranı yaptığımızı düşünürsek, sol tarafta ToolBox (araç kutusu) orta tarafta Workflow Designer (İş akışı tasarım) en sağ tarafta da Property Inspector (özellikler( bölümü yer alacaktır.

XAML tarafındaki işlemleri şimdilik tamamladık. Sırada kod tarafında yapacağımız işlemler var. Bunun için MainWindows.xaml 'in kod ekranını açarak işlemlerimize başlıyoruz.

İlk olarak kullanacak olduğumuz isim alanlarını ekliyor olacağız.

using System.Activities.Core.Presentation;
using System.Activities.Presentation;
using System.Activities.Presentation.Toolbox;
using System.Activities.Statements;

Kullanacak olduğumuz isim alanları hazır durumdadır. Bir Workflow Designer yaptığımıza göre WorkflowDesigner sınıfını proje içerisinde kullanıyor olamak gerekiyor.

public partial class MainWindow : Window
{
    private WorkflowDesigner wd;

    public MainWindow()
    {
        InitializeComponent();
    }
}

Şimdi ise Ekran üzerinde WorkflowDesigner oluşturabilmek için AddDesigner isimli private bir metot oluşturacağız. Bunun yardımı ile iş akışı tasarım ekranının oluşmasını ve grid 'in hangi kısmında duracağını belirtiyor olacağız.

private void AddDesigner()
{
    //WorkflowDesigner sınıfı çağırılır.
    this.wd = new WorkflowDesigner();

    //Workflow Designer 'in ekran üzerinde nerede olacağını belirtiyoruz.
    Grid.SetColumn(this.wd.View, 1);

    //Varsayılan olarak bir Sequence oluşturuyour.
    this.wd.Load(new Sequence());

    //WorkflowDesigner 'i grid 'e ekliyoruz.
    grid1.Children.Add(this.wd.View);
}

Çağırmış olduğumuz Sequence sınıfının DesignerMetaData() sınıfını içinde barındıran bir sınıf ile kayıt etmemiz gerekmektedir. Bu sebeple RegisterMetaData() isimli bir metot daha oluşturarak bu işlemi gerçekleştiriyor olalım.

//Sequence sınıfının kaydı yapılıyor.
private void RegisterMetaData()
{
    (new DesignerMetadata()).Register();
}

Sırada yapacak olduğumuz işlem ise MainWindow ekranı oluşturulurken hazırlamış olduğumuz metotları çağırmak olacaktır.

public MainWindow()
{
    InitializeComponent();
    this.AddDesigner();
     this.RegisterMetaData();

}

Çağırma işlemleri de tamamlandıktan sonra artık workflow tasarım ekranımızın ilk adımınının nasıl olduğuna göz atabiliriz. Bunun için projeyi çalıştırmak yeterli olacaktır.



İstediğimizi başardık. Artık WPF uygulamasını bir iş akışı tasarımcısı yapma konusunda ilk adımımızı attık ve tasarım bölümünü oluşturduk. Sırada yapacak olduğuğumuz işlem ise ToolBox 'ı ve Property Inspector 'u oluşturmak olacaktır.

Oluşturacak olduğumuz bu iki bölümü yaparken Workflow Designer 'ı oluşturduğumuz gibi basit bir şekilde olacaktır. Çünkü .net 4.0 'ın yapısı bize daha da fazla şekilde esnek, geliştirilebilir ve genişletirilebilir bir yapı sunmaktadır.

WPF Grid içerisine ToolBox 'ı oluşturma işlemine başlıyoruz. Bu işlem için GetToolboxControl isminde bir metot kullanırken bunu ToolboxControl den oluşturuyor olacağız.

Toolbox Category Item Collection 'nun içerisine iki değer atayacağız. Bunlar;
1. CustomActivitiex.Prompt aktivitesi,
2. System.Activities.Statements.Sequence aktivitesi olacaktır.

private ToolboxControl GetToolboxControl()
{
    // Toolbox kontrol oluşturuluyor.
    ToolboxControl ctrl = new ToolboxControl();

    //Kategorideki elemanlar için koleksiyon oluşuturuluyor.
    ToolboxCategory categoryItems = new ToolboxCategory ("category1");

    //Toolbox öğeleri oluşturulur.
    ToolboxItemWrapper tool = new ToolboxItemWrapper ("CustomActivities.Prompt",     "CustomActivities", null, null);

    ToolboxItemWrapper tool2 = new ToolboxItemWrapper ("System.Activities.Statements.Sequence",
"System.Activities, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", null, "Sequence");

    // Toolbox öğeleri kategoriye ekleniyor.
    categoryItems.Add(tool);
    categoryItems.Add(tool2);

    //kategoriye eklenen toolbox kontrolleri.
    ctrl.Categories.Add(categoryItems);

    return ctrl;
}

Toolbox kontrol 'ün içeriğini kontrolduğumuza göre şimdi de toolbox 'ı eklemek için AddToolBox() isimli metodu oluşturuyor.

private void AddToolBox()
{
    ToolboxControl tc = GetToolboxControl();
    Grid.SetColumn(tc, 0);
    grid1.Children.Add(tc);
}

SSon olarak bu metodu mainwindow metodunda çağırdıktan sonra uygulamamızı derleyerek oluşan sonuca bir göz atıyoruz.



İş akışı tasarım ekranı oluşturulması adımları olan Toolbox ve Workflow Designer bölümlerinin oluşturulmasını başarılı bir şekilde tamamlamış bulunuyoruz. Son adımımız olan Property Inspector bölümünün eklenmesi aşamasını şimdi yapıyor olalım.

Property Inspector ekranını kullanmak için her zamanki gibi eklememize yarayan bir metot oluşturacağız. Sonrasında ise bu metodu formun oluştuğu anda çağırarak işlemlerimizi tamamlıyor olacağız.

Şu ana kadar yapmış olduğumuz işlemler esnasında gördüğümüz kadarıyla aslında temek bir iş akışı tasarım ekranı oluşturmak oldukça kolaylaştırılmıştır. Özellikler ekranını hazırlarken de bu kolaylıklardan yararlanarak basitçe işlemlerimizi tamamlıyor olacağız. WorkflowDesigner sınıfının UIElement lerinden olan PropertyInspectorView yardımı ile özellikler ekranını rahatlıkla ekleyeceğiz.

private void AddPropertyInspector()
{
   Grid.SetColumn(wd.PropertyInspectorView, 2);
   grid1.Children.Add(wd.PropertyInspectorView);
}

Property Inspector ekranını da eklediğimize göre artık uygulamamızın en son haline bakabiliriz.



Sonuç tam istediğimiz gibi gözükmektedir.

Şu ana kadar yazmış olduğumuz kod parçalarının birleştirilmiş hallerine göz atmak gerekirse sonuç aşağıdaki gibi olacaktır.

using System.Windows;

using System.Activities.Core.Presentation;
using System.Activities.Presentation;
using System.Activities.Presentation.Toolbox;
using System.Activities.Statements;
using System.Windows.Controls;

namespace HostApp
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
    public partial class MainWindow : Window
    {
        private WorkflowDesigner wd;

        public MainWindow()
        {
            InitializeComponent();
            this.AddDesigner();
            this.RegisterMetaData();
            this.AddToolBox();
            this.AddPropertyInspector();
        }

        private void AddDesigner()
        {
             //WorkflowDesigner sınıfı çağırılır.
             this.wd = new WorkflowDesigner();

             //Workflow Designer 'in ekran üzerinde nerede olacağını belirtiyoruz.
             Grid.SetColumn(this.wd.View, 1);

             //Varsayılan olarak bir Sequence oluşturuyour.
             this.wd.Load(new Sequence ());

             //WorkflowDesigner 'i grid 'e ekliyoruz.
             grid1.Children.Add (this.wd.View);
        }

        //Sequence sınıfının kaydı yapılıyor.
        private void RegisterMetaData()
        {
            (new DesignerMetadata()).Register ();
        }

        //Toolbox oluşturuluyor.
        private ToolboxControl GetToolboxControl()
        {
            // Toolbox kontrol oluşturuluyor.
            ToolboxControl ctrl = new ToolboxControl();

            //Kategorideki elemanlar için koleksiyon oluşuturuluyor.
            ToolboxCategory categoryItems = new ToolboxCategory("category1");

            //Toolbox öğeleri oluşturulur.
            ToolboxItemWrapper tool = new ToolboxItemWrapper("CustomActivities.Prompt", "CustomActivities", null, null);

             ToolboxItemWrapper tool2 = new ToolboxItemWrapper("System.Activities.Statements.Sequence",
                  "System.Activities, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", null, "Sequence");

             // Toolbox öğeleri kategoriye ekleniyor.
             categoryItems.Add(tool);
             categoryItems.Add(tool2);

            //kategoriye eklenen toolbox kontrolleri.
            ctrl.Categories.Add (categoryItems);
            return ctrl;
       }

       //Ekrana toolbox bölümü eklendi.
       private void AddToolBox()
       {
            ToolboxControl tc = GetToolboxControl();
            Grid.SetColumn(tc, 0);
            grid1.Children.Add(tc);
       }

       //Özellikler (Property Inspector) bölümü ekleniyor.
       private void AddPropertyInspector()
       {
             Grid.SetColumn (wd.PropertyInspectorView, 2);
             grid1.Children.Add (wd.PropertyInspectorView);
        }
    }
}

Sonuç olarak .Net Framework 'un ve WPF 'in esnekliğinden yararlanarak çok hızlı bir şekilde iş akışı tasarım ekranının başlangıç düzeyini oluşturmuş bulunuyoruz. Bu yazımızı takiben aynı uygulama üzerinden geliştirmelerimize devam ederken CustomActivity kütüphanesini daha aktif kullanarak harici aktiviteler oluşturuyor olacağız.

Umarım yararlı olabilmiştir.
Kaynak
MSDN

Turhal Temizer

info@turhaltemizer.com

Pazar, Ekim 18, 2009

WPF - DataGrid Kullanımı

.Net Framework 4.0 'ın çıkışının yaklaşması ile WPF içerisinde de değişiklikler daha da ön plana çıkmaya başlamıştır. Özellikle bileşen paneli içerisinde oluşan gelişmeler gözlerden kaçmamaktadır. Tabii bu gelişimde WPF Control toolkitin de katkısını unutmamak gerekmektedir. Bu gelişmeler sonrası gelen en büyük yeniliklerden birisi de DataGrid kontrolüdür.

Veri tabanı ilişkisi olan ve liste şeklinde veri gösterilmesi gerektiği durumlarda en sık olarak kullanılan kontrollerin başında gelmektedir DataGrid kontrolü. Bazen yalnızca verileri gösterirken bazende DataGrid üzerinde kayıt silme, güncelleme ve yeni ekleme işlemleri de yapılabilmektedir. DataGrid kullanmanın kolaylıklarını ve avantajlarını tekrardan anlatmayacağız. Zaten yıllardır .Net programcılarının en sık kullandığı kontroldür. Ancak bu avantajlı durum Windows Presentation Foundation ile yeni nesil form ile uygulama geliştirmek isteyen yazılımcılarda durum biraz daha farklı oluyordu. Çünkü .Net 3.5 sonrasında gerçek anlamıyla kullanmaya başlayabildiğimiz WPF Control Toolkit yardımı ile DataGrid kontrolünü kullanabiliyorduk. Ama .Net Framework bünyesinde maalesef DataGrid kontrolü yer almıyodu. Özellikle eski adı WPF/E Silverlight teknolojisinde DataGrid kontrolünün daha önceden eklenmiş olması web uygulamalarında rahatlıkla bu kontrol kullanılırken neden windows form uygulamalarında kullanılamıyor şeklinde akıllara soru işaretleri doğuruyordu. Tabii ki hiçte kullanılamıyor da değildi. Biraz çaba sonrasında kendi DataGrid user controlümüzü oluşturup bunu kullanabiliyorduk. Ya da 3. parti bileşen geliştiren firmaların ürünlerinden yararlanarakta DataGrid kontrolü kullanabilmemiz mümkündü ve mümkün olacaktır. Fakat biz bu yazımızda .Net Framework 4.0 'ın içerisinde bulunacak olan WPF DataGrid kontrolünü incelemeye çalışıyor olacağız.

Not: Yazımızı Visual Studio 2010 Beta1 ve .Net Framework 4.0 Beta1 sürümleri ile geliştirmekte ve anlatmaktayız. Zaman içerisinde kullanım ve yazım standartı konusunda bir değişiklik olabilme ihtimali bulunmaktadır. Bilginize...

DataGrid kullanımı örnek üzerinde incelemeye çalışacağız. İlk olarak VS2010 Beta1 ile WPF projesi oluşturuyoruz. Sonrasında ise toolkit bölümüne bakarak DataGrid kontrolünü ve diğer bir çok kontrolü görebilmek mümkündür. Bizim yararlanacak olduğumuz DataGrid kontrolü olduğu için Controls seçeneği altında yer alan kontrollere göz atıyoruz.



Kontrolü form üzerine sürüklediğimizde XAML kod tarafında <DataGrid /> kod parçacığının eklendiğini gözlemleriz. DataGrid kontrolünün özellikleri arasında Name,Width,Height,HorizontalAligment,Margin ve diğer bir çoğu yer almaktadır.

Hazılayacak olduğumuz örnek için formun üzerine bir tane DataGrid kontrol sürükleyip bırakıyoruz. Sonrasında ise XAML tarafına aşağıdaki kod parçası eklenecektir.

Windows1.xaml
<DataGrid Height="100" HorizontalAlignment="Left" Margin="28,32,0,0" Name="dataGrid1" VerticalAlignment="Top" Width="200" />

Visual Studio üzerindeki görüntüsü ise aşağıdaki gibi olacaktır.



DataGrid içerisinde gösterecek olduğumuz verileri oluşturmaya başlayalım. Bu işlem için bir tane kullanıcı sınıfı oluşturacağız ve sonrasında oluşturmuş olduğumuz elemanlara lis yardımı ile veri ekleyerek grdi içerisinde göstereceğiz.

WPF uygulamasına bir tane Users isimli sınıf ekliyor ve içerisine aşağıdaki kod parçasını ekliyoruz.

Users.cs
using System;

namespace DataGridKullanimi
{
    public class Users
    {
        public int UserID { get; set; }
        public string CurrentName { get; set; }
        public string CurrentSurname { get; set; }
        public DateTime BirthDay { get; set; }
        public bool IsActive { get; set; }
    }
}

Kullanıcılar sınıfını oluşturduğumuza göre şimdi de kullanıcılar verisini bir listeye dolduralım.

Window1.xaml.cs
private List<Users> LoadGrid()
{
    List<Users> users = new List<Users>();
    users.Add(new Users()
    {
        UserID = 1,
        CurrentName = "a",
        CurrentSurname = "b",
        BirthDay = new DateTime(2000, 12, 11),
        IsActive = false
    });
    users.Add(new Users()
    {
        UserID = 2,
        CurrentName = "aa",
        CurrentSurname = "bb",
        BirthDay = new DateTime(1987, 12, 11),
        IsActive = true
    });
    users.Add(new Users()
    {
        UserID = 4,
        CurrentName = "aya",
        CurrentSurname = "baya",
        BirthDay = new DateTime(1960, 12, 11),
        IsActive = true
    });
    return users;
}

Kullanıcı bilgilerini listeye doldurduktan sonra artık DataGrid içerisinde kullanabiliriz. DataGrid içerisinde veriyi ItemsSource özelliği yardımı ile alıyoruz.

Bu işlem için ise,

dataGrid1.ItemsSource = LoadGrid();

kod blogunu kullanmak yeterli olacaktır. Bu işlem sonrasında projemizi çalıştırdığımız karşımıza istediğimiz gibi bir sonuç çıkacaktır.



Grid içerisinde görülecek olan verilerin satır ve sütunların boyutlarının ayarlanabilinmesi mümkündür.

Window1.xmal
XX<DataGrid Height="200" HorizontalAlignment="Left" Margin="28,32,0,0" Name="dataGrid1" VerticalAlignment="Top" Width="400" RowHeight="30" ColumnWidth="40"/>ZZ



Sabit olarak satır ve sütun özellikleri verebilmekle birlikte, en çok ve en az olabilecek boyutlarıda kullanabilmemiz mümkündür.

Grid üzerinde yer alan kolonların yatay, dikey, tamamen gibi çizgilerinin görünülebilirliklerinin ayarlanabilmesi mümkündür. Örneğin bizde grid üzerinde yer alan kolonların dikey çizgilerinin görünürlüğünü yok edelim.

Bu işlem için; GirdLinesVisibility="Vertical" özelliğini kullanmak yeterli olacaktır. Peki yapmış olduğumuz bu değişiklik sonrasında ne gibi bir ekran görüntüsüne sahip olacağız.


Grid üzerinde yapabileceğimiz işlemleri incelemeye devam ediyoruz. DataGrid içerisinde yer alan kolonlara hem bütün arkaplan için hemde satır bazlı olarak renklendirilebilmesi mümkündür.

Bu işlem için XAML kod bölümünde DataGrid in özelliklerine Background, RowBackground ve AlternatingBackground özelliklerine değerler vermemiz yeterli olacaktır.

Background="LightGray" RowBackground="LightYellow" AlternatingBackground="LightBlue"


DataGrid kullanırken arka planda aslında bir grid 'in içerisinde hazırlanmış olan bir kontrol olduğunu unutmamak gerekiyor. Bu durumda da dış kenarlıklarına hem renk hem de kalınlık verebilmemiz mümkündür. Kullanmamız gereken özellikler BorderBrush ve BorderThickness olacaktır.

XAML kod bölümünde yer alan DataGrid kontrolünün özelliklerine; BorderBrush="Red" BorderThickness="5" özelliklerini vermemiz yeterli olacaktır.



Grid içerisinde yer alan satırların ve kolonların yalnızca okunabilir olmasını istersek IsReadOnly özelliğine True değerini vermemiz yeterli olacaktır. Kullanılabiliecek bir diğer özelilk ise satırların sabit kalmasıdır. Freeze özelliği olarak bilinen bu özellikten yararlanabilmek için ilk olarak özelliği aktifleştirmek sonrasında da hangi kolondan itibaren kullanılacağınu belirtmek yeterli olacaktır. AreRowDetailsFrozen="True" FrozenColumnCount="2" şeklinde kullanılmaktadır.

Kullanabileceğimiz özellikleri incelemeye devam ediyoruz. Şimdi değinecek olduğumuz özellik ise satırların yeniden düzenlenebilirliği ve yeniden boyutlanabilirlidir. Bu iki özellik sabit bir tasarım sunmak istenildiğinde çok sık kullanılabilmektedir. CanUserReoderColumns="False" CanUserResizeColumns="False" şeklinde kullanılabilmektedir.

Sıralama, hem web uygulamalarında hem de windows uygulamalarında kullanılan DataGrid ler de en sık kullanılan özelliklerden birisidir. Bu özellike WPF DataGrid içerisinde de kullanılabilmesi mümküdür. CanUserSortColumns özelliğini kullanarak sıralama işleminin gerçekleşebilmesi mümkündür. True ve False değerlerini alabilmektedir. Bizim hazırlamış olduğumuz uygulamada kullanılmasını istemediğimiz için False özelliğini veriyoruz.

DataGrid kontrolünün değineceğimiz son özelliği ise Scroll olacaktır. Hazırlanan WPF Form içerisinde yer alan DataGrid kontrolünün içerisinde yer alan verilerin sayısının kontolün genişlik ve yükseklik değerlerinin üzerine çıkması durumunda scroll 'un çıkıp çıkmamasıdır. Kullanımı, HorizantalScrollBarVisibility ve VerticalScrollBarVisibility şeklindedir.

Anlatmış olduğumuz özellikleri de DataGrid kontrolüne ekledikten sonra karşımıza çıkan son ekran görüntüsü aşağıdaki gibi olacaktır.



Belirtmiş olduğumuz bütün özelliklerin sorunsuzca çalıştığı gözlemlenmektedir.

Sonuç olarak yazımızda WPF DataGrid kontrolünün ne işe yaradığını, ne amaçlarla kullanıldığını ve özelleştirmek istediğimizde ne tür özellikleri kullanabileceğimizi detaylı bir biçimde açıklamaya çalıştık. Tekrardan hatırtılması gereken konu ise, bu uygulama VS2010 Beta1 ve .Net FW 4.0 Beta1 sürümleri ile geliştirildi. Gelecekte çıkacak sürümlerinde değişiklik olabilme ihtimali yer almaktadır.

Herkese iyi çalışmalar diliyorum.

Umarım yararlı olabilmiştir.

Cuma, Ağustos 14, 2009

Windows 7 Upgrade – SQL Server 2008 Problem ve Çözümü

Eğer ki bilgisayarınızda Windows Vista kullanıyor ve Visual Studio 2010 Beta 1 kurulu ile Windows 7 ‘ye upgrade yaptığınızda bazı problemler ile karşılaşabiliyorsunuz. Aslına bakarsanız yaşadığınız tek problem SQL Server 2008 ‘in çalışmasında olacaktır. Bunun sebebi de Windows 7 ‘de .Net Framework 3.5.1. sürümünün yer almasının ve .Net Framework 4.0 Beta1 ‘in tam olarak stabil durumda olmamasında kaynaklanan sorun ile karşılaşabiliyorsunuz.

Sql Server 2008 management studio ‘yu açmak istediğiniz de paketleriniz eksiktir şeklinde bir hata mesajı alabiliyorsunuz. Çözüm olarak repair yapmak istediğinizde ise .Net Framework v4.0.2506 sürümün çalışmasında hata ile karşılaştım. Lütfen tekrar kurunuz şekilde bir mesaj veriyor. Bu durumda yapılması gereken download.microsoft.com adresine girdikten sonra .Net Framework 4.0 Beta1 sürümünü arattıktan sonra karşınıza çıkan ekrandan bu sürümü indiriniz ve sonrasında bilgisayarınıza kurunuz.

Yapmış olduğunuz bu işlemler sonrasında Upgrade sonrası yaşanan problemler ile karşılaşmayacak ve sorunsuzca uygulamlarınızda çalışabileceksiniz. 

Cumartesi, Temmuz 11, 2009

WPF - Visual Studio 2010 Başlangıç Sayfasının Düzenlenmesi

.Net ile yazılım geliştiricilerin en sık kullandığı geliştirme platformu Visual Studio 'dur. Sizlerinde bildiği üzere yıl başından bu yana geliştirme platformunun yeni sürümü olacak olan Visual Studio 2010 'nun CTP ve Beta1 sürümleri bizlerin kullanımına sunulmuştur. Bu sürümleri bilgisayarlara kurduğumuzda dikkatimizi çeken en büyük değişiklik görsel anlamda olmuştur. Bu değişikliği sağlayan en büyük faktör ise platformun tekrardan Windows Presentation Foundation (WPF) ile yazılmasıdır.

Daha önceki yazılarımızdan hatırlayacağınız üzere Windows Vista ve Windows 7 işletim sistemleri WPF mimarisine göre geliştirilmişti. Bu değişiklik sonucunda grafik kartı üreticileri Windows Vista uyumlu ekran kartı çıkarttılar. Peki neden Vista uyumlu ekran kartlarına gerek vardı. Çünkü Windows Vista öncesi işletim sistemleri yani Windows Form uygulamaları o kadar fazla grafik kartları kullanmasına gerek yoktu. Fakat Windows Vista ve WPF uygulamalarının yaygınlaşması ile grafik kartlarının üzerine düşen yük arttı ve bu yenilikleri sağlayacak kartlara gerekli sürücüler oluşturuldu. Bu konu ile ilgili detaylı içeriğe daha önce yayınlamış olduğumuz yazıları okuyarak edinebilirsiniz.

İnsanların görselliğe önem vermesi ve yeni geliştirilen uygulamaların WPF ve XAML 'in gücünden yararlanılarak geliştirilmesine daha da olanak tanıyordu. Ayrıca bu teknolojilerin web versiyonu olan Silverlight uygulamalarının da web üzerinde yaygınlaşması gelecekte ne denli önemli bir yer alacağını da gözler önüne seriyordu. Bu durumda yapılması gereken ise yeni geliştirecek olduğumuz projelerde görsel anlamda bir düşüncemiz var ise WPF alt yapısı üzerine geliştirilen uygulamalara dikkat etmek olacaktır.

WPF günümüzde yer alan uygulamalarda bu kadar gelişiyor ve dikkat çekiyorsa geliştiricilerinde kullandığı araçlarda geliştirmeler bu teknoloji ile yapılması düşünülebilir bir duruma gelmiştir ki Expression Studio ailesi içerisinde yer alan ürünler bahsettiklerimizi karşılar biçimdeydi. Çok daha görsel ve daha performanslı bir biçimde çalışan geliştirme ortamları ile çalışabilinmesine olanak tanınmaktadır. Expression Blend ile aramıza katılan OSLO projesinin geliştirme ekranında aşina olmaya başladığımız yeni nesil pencereler Visual Studio 2010 ile geliştirme ortamlarında da aramızdaki yerini alacaktır.

Visual Studio 2010 'a .Net 4.0 'ın eklenmesinin dışında geliştirme platformu da yeniden hazırlanmıştır. Peki, hazırlanan teknolojiyi sizlere sorsam sanırım yukarıdaki yazdıklarımızı okuduktan sonra hiç düşünmeden "WPF" diye soruyu cevaplayacaksınızdır. Neden WPF kullanıldı sorusuna kısmen cevap verdik. Fakat bunun sebeplerini biraz daha araştıralım. WPF uygulamalarının en önemli özelliği görsel öğeleri çok iyi şekilde kullanmaktadır. Grafikerlerin hazırlamış olduğu tasarımları XAML yardımı ile projelerde rahatlık kullanılıyor olması, Data Binding işlemini oldukça başarılı yapılabilmesi ve bunun gibi şu anda aklımıza gelmeyen bir çok sebepten ötürü WPF tercih edilmiştir.

Visual Studio 2010 'un neden WPF ile yazıldığını ve bize ne gibi yararlar sağlayacağına değinmeye çalıştık. Peki, Visual Studio 2010 Beta1 'in WPF ile hazırlanmış olan yeni giriş ekranın görüntüsü nasıl olduğuna bir göz atalım.



Alışık olduğumuz görünümden oldukça farklı fakat bir o kadar şık bir görünüme sahip olmuştur. Tabii yazımızın başında beri de değindiğimiz bir özelliğe sahip olmuştur. Bu da WPF ile hazırlanmış olmasıdır. Bizler de WPF yardımı ile bu ana ekran görüntüsünü düzenleyebilme imkanına sahibiz. Bu işlem için ister Visual Studio 2008 veya 2010 ortamlarından ya da Expression Studio ailesinden Expression Blend yardımı ile yapabilmemiz mümkündür. İşlemi gerçekleştirebilmemiz için bir Visual Studio 2010 üzerinde bir kaç değişiklik yapmamız gerekmektedir.

Not: İşlemlere başlamadan önce C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\StartPages klasörünün içeriğini bilgisayarda başka bir noktaya kopyalamanızı öneriyorum. Malum yeni hazırlayacağınız tasarım sonrası ana sayfanız açılmaz bir görünüme de bürünebilir. :)

Visual Studio 2010 ortamını açıyoruz ve ilk olarak Tools\Options adımlarını izleyerek Visual Studio özellikleri ekranına geliyoruz.



Karşımıza gelen ekranda Environment\Startup yolunu izledikten sonra açılan ekranda Allow Custom Start Page checkbox 'ını seçili duruma getiriyoruz.



Yapmış olduğumuz bu işlemler sonrasında artık Visual Studio 2010 'nun karşılama ekranını istediğimiz şekilde düzenleyebilinmesine olanak tanınacaktır. Peki bu işlemi nasıl gerçekleştireceğiz. Biraz önce yedeklediğimiz klasörün içerisinde yer alan proje dosyasını açarsak gördükleriniz sizi çok şaşırtacaktır.


StartPage.csproj dosyasını ister Visual Studio 2008 ister Visual Studio 2010 ile açıyoruz. VS2010 'nun ana sayfası design kodları ile karşınızdadır.



Doğruyu söylemek gerekirse bu kodları görmek pek alışık olduğumuz bir durum değildir. :)

StartPage.xaml
<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:vs="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.UI"
     xmlns:sys="clr-namespace:System;assembly=mscorlib"
     Style="{DynamicResource {x:Static vs:StartPageResourceKeys.OuterGridStyleKey}}"
    >

    <Grid.Resources>
        <!-- Welcome tab links -->
        <sys:String x:Key="Links.WhatsNew">http://go.microsoft.com/fwlink/?LinkId=123638</sys:String>
        <sys:String x:Key="Links.Walkthroughs">http://go.microsoft.com/fwlink/?LinkId=147108</sys:String>
        <sys:String x:Key="Links.Feedback">http://go.microsoft.com/fwlink/?LinkId=147445</sys:String>
        <sys:String x:Key="Links.Customize">http://go.microsoft.com/fwlink/?LinkId=123641</sys:String>

        <!-- Visual Studio tab links -->
        <sys:String x:Key="Links.MSDNLibrary">http://go.microsoft.com/fwlink/?LinkId=123642</sys:String>
        <sys:String x:Key="Links.MSDNForums">http://go.microsoft.com/fwlink/?LinkId=123643</sys:String>
        <sys:String x:Key="Links.Community">http://go.microsoft.com/fwlink/?LinkId=123644</sys:String>
    </Grid.Resources>

    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*" MinWidth="0" MaxWidth="90"/>
        <ColumnDefinition Width="*" MinWidth="530"/>
        <ColumnDefinition Width="*" MinWidth="0" MaxWidth="100"/>
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="*" MaxHeight="100"/>
        <RowDefinition Height="*" />
        <RowDefinition Height="*" MaxHeight="65"/>
    </Grid.RowDefinitions>

    <Border Grid.RowSpan="3" Grid.ColumnSpan="3" Height="800" VerticalAlignment="Top" Style="{DynamicResource {x:Static                                     vs:StartPageResourceKeys.OuterBorderStyleKey}}" />

    <!-- Logo -->
    <Image Grid.Row="0" Grid.Column="1" Style="{DynamicResource {x:Static vs:StartPageResourceKeys.LogoImageStyleKey}}" />

    <!-- RSS feed -->
    <vs:RssRotator Grid.Row="2" Grid.Column="1" Style="{DynamicResource {x:Static vs:StartPageResourceKeys.RssRotatorStyleKey}}" />


    <!-- Tray -->
    <vs:Tray Grid.Row="1" Grid.Column="1" SelectedIndex="0" x:Name="PART_Tray">

    <!-- Welcome group -->
    <vs:TrayItem Header="Welcome" x:Uid="Welcome_Header">
    <vs:TrayGroup SelectedIndex="0">

    <vs:TrayGroupItem Content="Welcome"
            ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/01_whatsnew.png"
            x:Uid="Welcome_Item"
        >
        <vs:TrayGroupItem.InnerContent>
            <StackPanel>
                <TextBlock FontSize="18pt" Foreground="#E8E8E8" Margin="15" x:Uid="Welcome_Text">Welcome to the Visual Studio 2010 Beta 1</TextBlock>
                <TextBlock Foreground="#E8E8E8" Margin="15" TextWrapping="Wrap" x:Uid="Welcome_Paragraph" >
                    This release contains many features new to Visual Studio.
                    We have created a set of walkthroughs for major new feature areas.
                    We would also appreciate hearing your feedback.
                    Thank you for taking the time to evaluate and provide your input;
                    it will help us make Visual Studio 2010 the best release ever.
                </TextBlock>
                <Button Content="More Information"
                    HorizontalAlignment="Left"
                    Margin="15"
                    Style="{DynamicResource {x:Static vs:StartPageResourceKeys.WelcomeButtonStyleKey}}"
                    Command="{x:Static vs:VSCommands.Browse}"
                    CommandParameter="{StaticResource Links.WhatsNew}"
                    x:Uid="Welcome_Button"
                />
            </StackPanel>
        </vs:TrayGroupItem.InnerContent>
    </vs:TrayGroupItem>

    <vs:TrayGroupItem Content="Walkthroughs"
        ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/02_ctpwalkthroughs.png"
        Command="{x:Static vs:VSCommands.Browse}"
        CommandParameter="{StaticResource Links.Walkthroughs}"
        x:Uid="Walkthroughs_Item"
    />

    <vs:TrayGroupItem Content="Feedback"
        ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/03_feedback.png"
        Command="{x:Static vs:VSCommands.Browse}"
        CommandParameter="{StaticResource Links.Feedback}"
        x:Uid="Feedback_Item"
    />

    <vs:TrayGroupItem Content="Customize the Start Page"
        ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/04_customizestartpage.png"
        Command="{x:Static vs:VSCommands.Browse}"
        CommandParameter="{StaticResource Links.Customize}"
        x:Uid="Customize_Item"
    />

    <vs:TrayGroupItem Content="Find and Install Extensions"
        ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/11_extensibility.png"
        x:Uid="Extensibility_Item">
        <vs:TrayGroupItem.InnerContent>
            <StackPanel>
                <TextBlock FontSize="18pt" Foreground="#E8E8E8" Margin="15" x:Uid="ExtensionManager_Text">Extension Manager</TextBlock>
                <TextBlock Foreground="#E8E8E8" Margin="15" TextWrapping="Wrap" x:Uid="ExtensionManager_Paragraph">
                    The Extension Manager allows you to find new extensions online and manage your currently installed extensions.
                </TextBlock>
                <Button Content="Show Extension Manager"
                    HorizontalAlignment="Left"
                    Margin="15"
                    Style="{DynamicResource {x:Static vs:StartPageResourceKeys.WelcomeButtonStyleKey}}"
                    Command="{x:Static vs:VSCommands.ExecuteCommand}"
                    CommandParameter="Tools.ExtensionManager"
                    x:Uid="ExtensionManager_Button"
                />
            </StackPanel>
        </vs:TrayGroupItem.InnerContent>
    </vs:TrayGroupItem>

    </vs:TrayGroup>
    </vs:TrayItem>

    <!-- Projects group -->
    <vs:TrayItem Header="Projects" x:Uid="Projects_Header">
        <vs:TrayGroup SelectedIndex="0">

            <vs:TrayGroupItem Content="Recent Projects"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/05_recentprojects.png"
                InnerContentUri="Microsoft.VisualStudio.Shell.UI.Internal;component/Packages/MRU/Controls/RecentProjects.xaml"
                x:Uid="RecentProjects_Item"
            />

            <vs:TrayGroupItem Content="New Project"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/07_newproject.png"
                Command="{x:Static vs:VSCommands.ExecuteCommand}"
                CommandParameter="File.NewProject"
                x:Uid="NewProject_Item"
            />

            <vs:TrayGroupItem Content="Open Solution"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/06_openproject.png"
                Command="{x:Static vs:VSCommands.ExecuteCommand}"
                CommandParameter="File.OpenProject"
                x:Uid="OpenProject_Item"
            />

        </vs:TrayGroup>
    </vs:TrayItem>

    <!-- Visual Studio group -->
    <vs:TrayItem Header="Visual Studio" x:Uid="VisualStudio_Header">
        <vs:TrayGroup>

            <vs:TrayGroupItem Content="MSDN Library"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/08_msdnlibrary.png"
                Command="{x:Static vs:VSCommands.Browse}"
                CommandParameter="{StaticResource Links.MSDNLibrary}"
                x:Uid="MSDNLibrary_Item"
            />

            <vs:TrayGroupItem Content="MSDN Forums"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/09_msdnforums.png"
                Command="{x:Static vs:VSCommands.Browse}"
                CommandParameter="{StaticResource Links.MSDNForums}"
                x:Uid="MSDNForums_Item"
            />

            <vs:TrayGroupItem Content="Community"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/10_community.png"
                Command="{x:Static vs:VSCommands.Browse}"
                CommandParameter="{StaticResource Links.Community}"
                x:Uid="Community_Item"
            />

            <vs:TrayGroupItem Content="Settings"
                ImageSource="pack://application:,,,/Microsoft.VisualStudio.Shell.UI;component/Images/StartPage/12_settings.png"
                Command="{x:Static vs:VSCommands.ExecuteCommand}"
                CommandParameter="Tools.Options"
                x:Uid="Settings_Item"
            />

        </vs:TrayGroup>
     </vs:TrayItem>

    </vs:Tray>
</Grid>

XAML kodu yukarıdaki gibidir. Bu kodları incelediğimizde dikkatimizi çeken kodların;
   •<vs:Tray>
   •<vs:TrayGroup>
   •<vs:TrayGroupItem>
   •<vs:RssRotator>
arasında yeralmasıdır.

Görsel olarak değişiklikler için WPF bilgimizden yararlanılarak ekran birkaç değişiklik yapıyoruz.



Gördüğünüz gibi Visual Studio 2010 'nun giriş ekranını istediğimiz biçimde düzenleyebiliyoruz. Sizlerin hayal gücünüze bağlı olarak istediğiniz şekilde başlangıç ekranı düzenleyebilmeniz mümkündür. Örneğin VS 'in başlangıç ekranında şirket logonuzu görebilmek çok güzel bir duygu olsa gerek. :)

Windows Presentation Foundation yazılım dünyasında yerini gittikçe sağlamlaştırdığını bu uygulama ile daha net bir biçimde görmekteyiz.

Umarım yararlı olabilmiştir.

Turhal Temizer
info@turhaltemizer.com

Perşembe, Mayıs 21, 2009

Visual Studio 2010 Beta1 – Kurulum ve Genel Bakış

Gün içerisinde çalışmanın dışında bir de Visual Studio 2010 ‘u kurmakla zaman harcadım. Web installer versionu ile kurduğum VS ‘in kurulum ile ilgili ekran görüntülerini size yazının devamında sunuyor olacağım. Bir çok yenilikle bizlere sunulacak olan VS2010 ilk Beta1 sürümü ile karşımızda. F# ‘tan paralel programlamaya ide güncellemesine kadar nice yeni özelliklerle biz yazılımlacıları mutlu etmeye geliyor.

Kurulum aşaması;

yeni1

yeni2

yeni3

yeni4

yeni5

Yukarıdaki işlemler sonucunda uygumala kurulmuş oluyor. Kurulum sonrası bizi karşılayan ekrandaki değişiklik oldukça köklüdür.

yeni6

yeni7

Zaman içerisinde daha detaylı bilgi vereceğim.

Perşembe, Nisan 16, 2009

WF 4.0: Extending with Custom Activities

WF ile rahatlıkla iş akışları tasarlayabilmemiz ve gerekli kurallar eşliğinde işleyebilmemiz mümkün. Bu videoda 4.0 ile gelen özelliklerle birlikte harici bir activity i nasıl tasarlayabileceğimizi ve derleyebileceğimizi gözlemliyoruz.

Not: Videoyu tam ekran olarak izleyebilmek için ya alt kısımda yer alan ekranı genişlet tuşuna basmak ya da videonun üzerine çift tıklamak yeterli olacaktır.

Get Microsoft Silverlight

WF 4.0: A First Look

Windows Workflow Foundation ‘a ilk balkış niteliğini taşıyan ve  ASP.NET, WCF ve Sharepoint ta nasıl kullanılacağına ilişkin bilgilerinde yer aldığı güzel bir video.
WF 4.0 da gelecek değişiklikler 3.x sürümünü kullanan geliştiricileri oldukça şaşırtacaktır. :)
Hadi videoyu izleyelim.

Not: Tam ekran izlemek için videonun alt kısmında yer alan genişlet simgesine tıklamanız ya da videonun üzerine çift tıklamanız yeterli olacaktır.

Get Microsoft Silverlight

Azure Service Platform

Azure Service Platformu bize neler getiriyor. PDC oturumundan izliyoruz.

Get Microsoft Silverlight

Parallel Computing Platform: An Integrated Approach to Tooling

Paralel Computing işlemlerinin nasıl yapıldığı hangi amaçlarla kullanacağımızı açıklayan güzel bir video.

Get Microsoft Silverlight

Visual Studio Team System 2010

Visual Studio Team System 2010 ile ilgili yeniliklerin anlatıldığı çok güzel bir video. İzlemenizi tavsiye ederim…

Get Microsoft Silverlight

Salı, Mart 24, 2009

YazGeliştir Seminerleri @İstanbul - Yıldız Teknik Üniversitesi

Merhabalar,

Benim konuşmacıları arasında olduğum Yazgelistir ekibi 28 Mart Cumartesi günü Yıldız Teknik Üniversitesinde olacağız. Benim anlatacağım konu Windows Presentation Foundation. Etkinlik ile ilgili duyuruyu yazının devamında okuyabilirsiniz. Katılımlarınızı büyük bir merak ve heyacanla bekliyoruz…

Duyuru;

Yazgeliştir, 2009 seminer turuna Yıldız Teknik Üniversitesi'nden devam ediyor. 28 Mart 2009 Cumartesi günü tüm gün sürecek olan, altı konuşmacının yedi ayrı konuyu anlatacağı seminerlerde sizde yerinizi alın!
Etkinlik Tarihi: 28 Mart 2009 Cumartesi

Etkinlik Programı:

09:30-10:15:    Mustafa Acungil - İş zekası nedir?
10:15-10:30:    ARA
10:30-11:15:    Mustafa Acungil - SQL Server 2008 İle Gelen Yeni Veri Tipleri
11:15-11:30:    ARA
11:30-12:15:    Volkan Korkmaz - Dynamics CRM 4.0
12:15-13:00:    YEMEK ARASI
13:00-13:45:    Turhal Temizer - Windows Presentation Foundation
13:45-14:00:    ARA
14:00-14:45:    Burak Batur - Microsoft Office SharePoint Server 2007
14:45-15:00:    ARA
15:00-15:45:    Daron Yöndem - MultiPoint Programlama
15:45-16:00:    ARA
16:00-16:45:    Emre Coşkun - Composite WPF

Etkinlik Yeri :
Yıldız Teknik Üniversitesi Beşiktaş Kampüsü, YTÜ C Blok Konferans Salonu

Cumartesi, Mart 14, 2009

C# 4.0: Dynamic Programming

If C# 3.0 was all about Language Integrated Query (LINQ), then C# 4.0 is all about dynamic programming. What exactly does that mean? It means that C# 4.0 brings some of flexibility and declarative style of programming to C#.

image_3

But what does that really mean?

To sum it up in one keyword: dynamic.

C# 4.0 is adding a new dynamic keyword which is used as a data type in much the same way the var keyword is used. Why is this important? The biggest reason is that it allows a C# program to use dynamic dispatch to more naturally create objects coming from a dynamic language.

For example, suppose you have a Calculator object declared in C#, meaning it is statically typed. You interact with your object like this:

Calculator calc = GetCalculator();
int sum = calc.Add(10, 20);

That’s pretty simple and straight forward. Now suppose the Calculator is not a statically typed .NET class (or it is a .NET class but you don’t know the specific type of class), you must do something like this:

object calc = GetCalculator();
Type calcType = calc.GetType();
object res = calcType.InvokeMember("Add",
BindingFlags.InvokeMethod, null,
new object[] { 10, 20 });
int sum = Convert.ToInt32(res);

That’s not nearly as simple. In fact, it’s downright ugly. There is a lot of non-type-safe calls and reflection going on here that you really shouldn’t have to see.

To take this a step further, if we knew that Calculator was a JavaScript class, you must use similar (but still significantly different) code:

ScriptObject calc = GetCalculator();
object res = calc.Invoke("Add", 10, 20);

int sum = Convert.ToInt32(res);

The reason for the differences in syntax is that there is no unification between the two APIs.

In C# 4.0, you can now use the following syntax:

dynamic calc = GetCalculator();
int sum = calc.Add(10, 20);

If you look at this syntax and the earlier statically typed call, you should notice that the only difference is that in C# we are declaring the data type to be dynamic.

image_6

Does this mean that C# is loosing it's roots as a statically typed language or that we should all start moving towards dynamic languages? Absolutely not. What is means is that it is now easier for you to write C# code that talks to objects (or APIs) written in dynamically typed languages. It also means that there is a unified API to talk to any dynamic language. You no longer need to worry about what language you are interoperating with to determine which C# code you must write.

So how does the dynamic keyword work? As I mentioned, it's a keyword in a similar fashion to var. You declare at compile-time the type to be dynamic, but at run-time you get a strongly typed object.

image_9

The dynamic keyword is great for writing C# code that consumes a dynamic object, but what about going the other direction and writing C# code that can be called from a dynamic language? You do this by implementing the IDynamicObject interface (or more simply, inheriting from the abstract DynamicObject class) and providing your own implementation for the member lookup and invocation.

Using the features and capabilities of the new dynamic keyword, the IDynamicObject interface, and the fact that the dynamic dispatch can dispatch to both dynamic and static types, C# effectively gets support for duck-typing.