İlkay İlknur

just a developer...

Microsoft Connect Etkinliğinden Notlar

Geçtiğimiz haftalarda düzenlenen Microsoft Connect etkiliğinde duyurulan yeniliklerle ilgili kısa bir video çektim.

Video içerisinde değindiğim konulara ait linkler

Umarım faydalı olur.



C# 6.0 Webiner Kaydı

Daha önce planlaması için anket paylaştığım C# 6.0 webinerini gerçekleştirdik. Webiner sırasında C#'in geleceğinden, Roslyn compilerlarından ve C# 6.0 ile beraber gelecek olan özelliklerden bahsettik.

Webiner içerisinde değindiğim tüm özellikler şu an preview durumda. Bu nedenle ilerleyen dönemlerde Microsoft'un bu özelliklerde değişiklik yapması da oldukça doğal. Bu yüzden webineri izlerken bu noktayı aklımızın bir köşesinden tutmakta fayda var.

İyi Seyirler :)



Bir Solukta C# 6.0

Build'in 2.gün özetinde size Roslyn ve yeni C# versiyonu olan C# 6.0 versiyonundan bahsetmiştim. Hatta twitter'dan veya Facebook'tan takip ediyorsanız gelen yenilikleri açıklandığı gibi paylaşmıştım.

Bu yazıda da istiyorum ki C# 6.0 ile beraber gelmesi muhtemel özelliklere kısaca bir göz atalım. Gelmesi muhtemel özellikler diyorum çünkü buradaki özelliklerde henüz tasarım aşamasındalar. Yani bahsettiğim bir özellik bir bakmışınız 2 ay sonra değişmiş :)

Nasıl Deneriz

C# 6.0 ile beraber gelmesi muhtemel özellikleri test etmek için Roslyn End User Preview'ı kurmanız yeterli. Roslyn End User Preview içerisinde yeni C# ve VB compilerları ile Roslyn kullanarak implemente edilmiş Visual Studio özelliklerini bulunuyor.

Roslyn End User Preview bir Visual Studio extensionı (.vsix) olarak geliyor. Yani doğrudan çift tıkla bilgisayarınıza yükleyebilirsiniz.

Peki Ya Kaldırmak İstersek

Roslyn compilerları henüz preview aşamasındalar. Yani productionda kullanılması doğru değil ve Microsoft tarafından da desteklenmiyor. Bu yüzden diyelim ki kodunuzu yazdınız ve production ortamına kodu atmanız gerekiyor. Bunun için Roslyn compilerlarını devre dışı bırakıp şu anki eski compilerlarla kodunuzu derlemeniz gerekiyor. Bunu yapmak için Visual Studio 2013 içerisindeki Extensions ekranını kullanarak Roslyn extensionını devre dışı bırakabilirsiniz.

Unutmadan, extensionı disable ettikten sonra Visual Studio'yu yeniden başlatmak gerekiyor.

Rosly'nin kurulumu ve kaldırma işlemleri bu basit. Artık uçuşa geçmek için hazırız :) O zaman başlıyoruz...

Primary Constructors

Primary constructorlar, en basit anlatımla bizim constructor parametrelerini class veya struct tanımında yapmamızı sağlar.

Örneğin,
public class Insan(string name,string surname)
{

}

Biraz farklı geldi değil mi :)

Burada aslında yapmak istediğimiz şey Insan tipi içerisine name ve surname adında string parametreleri olan bir constructor eklemek ve bu constructora geçilen parametrelerin değerlerini de class içerisindeki name ve surname isimli fieldlarda saklamak. Özetle yukarıda yazdığımız kodun şu an kullandığımız versiyon olan C# 5.0'da karşılığı şu şekilde.
public class Insan
{
    private string name;
    private string surname;

    public Insan(string name, string surname)
    {
        this.name = name;
        this.surname = surname;
    }
}

Gördüğünüz gibi primary constructors ile beraber yukarıdaki gibi kod yazmaktan kurtulmuş oluyoruz ve böylece class veya struct'ın tanımlanması sırasında o tiple ilgili bazı özellikleri bildirebiliyoruz. Primary constructorsla beraber immutable nesne geliştirme de artık oldukça kolaylaşacak. Bu konuya başka bir makale de değineceğim...

Auto Propertyler İçin Initializer

C# 6.0 ile beraber gelen ve benim en beğendiğim özelliklerden biri olan auto property initializerları ile auto propertyler için daha kolay bir syntax ile değer ataması yapabiliyoruz. Örneğin,
public class Insan
{
    public string Name { getset; } = "Mahmut";
    public string Surname { getset; } = "Batmaz";
}

Yukarıda görmüş olduğunuz syntax ile Name ve Surname propertylerine default değer ataması yapabilmekteyiz.

Eğer Name ve Surname propertylerini immutable yapmak isterseniz property tanımı içerisindeki setterı kaldırırsanız Insan tipi içindeki propertylerin sürekli olarak "Mahmut" ve "Batmaz" değerlerini döndürdüğünü görebiliriz.

public class Insan
{
    public string Name { get; } = "Mahmut";
    public string Surname { get; } = "Batmaz";
}

Using Static

Açıkca söylemem gerekirse bu özellik de C# 6.0 içerisinde en beğenmediğim özellik :) Yalan yok. İlk gördüğümden beri alışamadım. Eğer VB kullandıysanız bu özelliği zaten VB tarafından hatırlayacaksınız. Özetle bir tip içerisindeki static metotları tipin adını belirtmeden kullanmanıza olanak sağlıyor. Örneğin, Math tipi içerisindeki static metotları kullanmak istediğimizde şu şekilde bir kod yazmamız gerekiyor.

using System;

namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            double x = Math.Pow(2, 3);
        }
    }
}

Ancak C# 6.0 ile beraber tipin adını using ifadesine ekleyerek tip ismi kullanmadan doğrudan metot adıyla metodu çağırabilmekteyiz.

using System.Math;

namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            double x = Pow(2, 3);
        }
    }
}

Büyük projelerde bu şekilde kullanımların karışıklığa neden olacağını düşünüyorum. Özellikle eklenecek birden fazla static tiple beraber Intellisense static metotlarla dolacaktır. Bunun yanında kodun okunabilirliği açısından bu özelliğin negatif bir etkisi olacağını düşünüyorum.

Declaration Expressions

Gelelim C# 6.0'daki en sevdiğim özelliğe :) Bu özellikle beraber artık expressionlar içerisinde tanımlama yapabiliyoruz. Bunun en  güzel kullanım yeri de out parametreler.
namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "123";
            bool isParsed = int.TryParse(s, out int result);
        }
    }
}

Exception Filters

VB ve F#'ta olup da C#'da olmayan özelliklerden biri de exception filters. Exception filters ile catch ifadeleri içerisine filtreler yazabiliyoruz. Böylece yazdığımız catch bloğunda sadece bizim verdiğimiz exception filtresine uygun exceptionlar yakalanıyor. Filtreye uymayan exceptionlar ise stacktrace'i kaybolmadan yoluna devam ediyor.

Örneğin,
using System;
using System.Data.SqlClient;

namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Do Operation");
            }
            catch (SqlException sqlEx) if (sqlEx.Number == 100)
            {
                Console.WriteLine("Log Exception");
            }
        }
    }
}

Indexed Element Initialization

C# içerisindeki object ve collection initializerları ile çok hızlı bir şekilde object ve collectionlar tanımlayıp ilgili alanlara değer atamalarını veya eleman eklemelerini çok hızlı bir şekilde yapabiliyoruz.

C# 6.0 ile beraber bu özelliklere ek olarak artık initializer içerisinde belirli indexteki elemalara da atama yapmak mümkün hale geliyor.

using System.Collections.Generic;

namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>()
            {
                [2] = 1,
                [8] = 10
            };

            Dictionary<stringstring> dic = new Dictionary<stringstring>()
            {
                ["key1"] = "value1",
                ["key12"] = "value2"
            };
        }
    }
}

Indexed Member Access

Bu özellik de açıkcası C# 6.0'da şu ana kadar en garipsediğim özellik :) Bu özellikle beraber artık string index üzerinden eriştiğimiz elemanlara daha kolay bir syntax ile erişebilmekteyiz. Yani eskiden foo["bar] şeklinde yazdığımız kodu C# 6.0 ile beraber foo.$bar şeklinde yazabilmekteyiz.

using System.Collections.Generic;

namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<stringstring> dic = new Dictionary<stringstring>();
            dic.$key1 = "value1";
            dic.$key12 = "value2";
        }
    }
}

Hatta bir önceki maddedeki özellikle bu özelliği birleştirip collection initializerların yazımını kolaylaştırmak da mümkün.

using System.Collections.Generic;

namespace ConsoleApplication37
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<stringstring> dic = new Dictionary<stringstring>()
            {
                $key1 = "value1",
                $key12 = "value2"
            };
        }
    }
}

Catch ve Finally Bloklarında Await Kullanımı

C# 5.0 ile beraber async-await keywordleri geldiğinde en büyük kısıtlamalardan biri catch ve finally bloglarında await keywordünün kullanılamamasıydı. Eğer async loglama metotlarınız varsa veya finallyde nesneleri async olarak dispose etmek veya close etmek istiyorsak asenkron metotları senkron olarak çağırmak zorunda kalıyorduk. Ancak C# 6.0 ile beraber artık bu kısıtdan da kurtuluyoruz.

private static async Task DoAsync(Resource resource)
{
    try
    {
        resource.DoOperation();
    }
    catch (Exception ex)
    {
        await LogAsync(ex);
    }
    finally
    {
        await resource.CloseAsync();
    }
}

Bitirirken...

C# 6.0 ile beraber gelmesi muhtemel özellikleri kısaca inceledik. Zaten ilerleyen günlerde her özellik için ayrı ayrı detaylı yazılar yazacağım. Ancak bu yazıda istedim ki ilk dalgada gelen özelliklere genel bir bakış atalım.

C# 6.0 ile gelen özelliklere baktığımızda aslında bu versiyonda dilin herhangi bir baskın temasının olmadığını görüyoruz. Yani C# 5.0'da tema async programlama iken C#  4.0'da ise dinamik programlama ana temaydı ve bu temalara yönelik çalışmalar yapılmıştı. Ancak bu versiyonda developerların işlerini kolaylaştıracak pek çok ufak tefek özelliğin geldiğini görüyoruz. Bu özelliklerle beraber de artık daha hızlı kod yazabilme imkanına sahip olacağız.

Bu versiyonda neden bu şekilde bir tema olmadan ilerlendi diye sorabilirsiniz :) Birinci neden şu anda programlama dünyasında çözülmesi gerek majör bir problemin olmaması. İkinci neden ise bu özellikleri C# ekibinin uzun zamandır yapmak isteyip de eski compiler kodları yüzünden yapamaması. Çünkü artık Roslyn compilerlarıyla bu yukarıda gördüğünüz gibi özellikleri çok daha hızlı bir şekilde dil içerisine ekleyebiliyorlar.

Yazının en başında da bahsettiğim gibi bahsettiğim özellikle şu anda End User Preview'da olan özellikler. İlerleyen dönemlerde yeni preview versiyonları çıkacak ve yeni dil featureları da dil içerisine eklenecektir. Ancak yeni previewları beklemeden C# ve VB programlama diline getirilmesi planlanan özelliklere buradan erişebilirsiniz.

Görüşmek Üzere,

Not : Blog yazıları haricinde sosyal medya üzerinden anlık paylaşımlarımı Twitter ve  Facebook'tan takip edebilirsiniz.



Build 2014'de İkinci Gün - Roslyn Preview, Open Source ve Fazlası

Build konferansında ikinci gün keynote'u da sona erdi. İkinci gün ilk güne nazaran oldukça sönüktü diyebilirim.

Ama şikayetlerden önce güzel haberlerle başlayalım.

Yeni Roslyn Previewleri

Roslyn projesinden eğer takip ediyorsanız 1 yıldan fazla bir zamandır bu projeden pek ses çıkmıyordu. Ancak compilerların yazımının tamamlanmasıyla beraber bugün Anders Hejlsberg 2 yeni preview'ı izleyenlere duyurdu. Bu previewler,

  • Roslyn End User Preview :  C# ve VB'nin yeni versiyonlarında olması planlanan özellikler ile bir sonraki Visual Studio versiyonuyla beraber IDE içerisine eklenecek olan özellikler bu paket içerisinde bulunuyor. Roslyn ile beraber neler geliyor, programlama dili versiyonlarında neler olacak gibi soruların cevaplarını merak ediyorsanız end user preview'ı indirip hemen test edebilirsiniz. End user preview Visual Studio Extension'ı olduğu için istediğiniz zaman kolay bir şekilde end user preview'ı visual studiodan kaldırabilirsiniz. End User Preview'ı buradan indirebilirsiniz.
  • Roslyn SDK Preview : Eğer C# ve VB compilerlarını içerisindeki API'ları kullanarak yazılan bir kodu analiz eden uygulamalar yazmak veya Visual Studio içerisinde çeşitli refactoring araçları geliştirmek isterseniz Roslyn SDK'ini kullanabilirsiniz. Roslyn SDK Preview'ı da buradan indirebilirsiniz.
Ayrıca gördüğüm kadarıyla Microsoft, Roslyn ismi yerine .NET Compiler Platform ismini kullanmayı düşünüyor. İlerleyen zamanlarda Roslyn isminin ürün isminden çıkarıldığını görebiliriz.

ROSLYN OPEN SOURCE !

Roslyn projesiyle beraber developerlardan gelen en büyük isteklerden biri Roslyn source code'unun open source olmasıydı. Microsoft developerların sesine kulak verdi ve Roslyn open source oldu. Keynote'daki en güzel anlarından biri de şüphesiz ki Anders Hejlsberg'in Roslyn'nin source code'unu sahnede CodeProject'e koymasıydı.

Roslyn projesi artık http://roslyn.codeplex.com/ burada. Source code'u  da tamamen açık. Sizde kaynak kodu indirip isterseniz kendi dil featurelarınızı geliştirip Microsoft'a gönderebilirsiniz. Ama baştan söyliyim bu işler çok da kolay değil :)

C# 6.0

Roslyn End User Preview'ı indirirseniz içerisinde Microsoft'un C#'in ve VB'nin bir sonraki versiyonlarında programlama dillerine eklemeyi düşündüğü özellikleri göreceksiniz. Bu özelliklerin bir  listesine buradan ulaşabilirsiniz.

C# 6.0 ile gelen yenilikler ilgili yazmış olduğum yazıya buradan erişebilirsiniz.

.NET Foundation

Microsoft'un son zamanlarda open souce tarafına bakış açısı ortada. Şu anda pek çok Microsoft'un development ürünü(Entity Framework, ASP.NET vb..) open source durumda. Dün de hatırlarsanız WinJS'in open source olduğunu duyurmuştum. Bugünse Roslyn compilerı open source oldu. .NET Foundation ise developerların open source Microsoft teknolojilerine hızlı bir şekilde ulaşabilecekleri ve katkıda bulunabilecekleri bir platform. Microsoft burada Xamarin ve sektördeki bazı ortaklarıyla iş birliği de yapıyor. .NET Foundation sayfasına buradan erişebilirsiniz.

Windows Azure Haberleri

Build'de ikinci gün aslında heyecanla Azure tarafındaki gelişmeleri bekliyorduk. Ancak ne yazık pek de fazla yeni haber duyma şansımız olmadı. Keynote'un genelinde Azure tarafında daha önceden duyurulan yeniliklerin demosu yapıldı. Ama yine de daha önceden duymadığımız bazı güzel yenilikler de var.

Yeni Azure Management Portali

Azure tarafındaki bana göre en heyecan verici duyuru yeni Azure management portaliydi. Yeni portal biraz Windows 8 içindeki start screen'i bize anımsatıyor.

Portale giriş yaptığınızda karşınıza gelen ekrandan pek çok metriğe aynı anda ulaşabiliyorsunuz. Ayrıca bir sayfa açmak istediğinizde sayfalar dashboard'un yan tarafında sırayla açılıyor. Böylece her  açtığınız sayfa bir önceki sayfanın yanında açılıyor. Böylece hem bir anda istediğiniz birden fazla sayfaya bakabiliyorsunuz hem de odak noktanızı kaçırmıyorsunuz.

Şu an yeni portalde eski portaldeki yapabildiklerinizin hepsini yapamıyorsunuz. Bu yüzden bir süre hem yeni hem de eski portal yan yana gidecek. Yeni portal'e https://portal.azure.com/ adresinden ulaşabilirsiniz.

Diğer Azure Haberleri

Azure'la ilgili gelen yeniliklerin ve yapılan duyuruların hepsine detaylı olarak değinemeyeceğim. Ancak aklımda kalan yenilikler şunlar,
  • Azure Web Sites'a Java Desteği
  • Azure Scheduler GA
  • Autoscaling GA
  • 500 GB SQL Azure Database desteği.
  • Read-Access Geographically Redundant Storage GA.

Visual Studio Online GA

Visual Studio Online'da Build konferansının ikinci günü itibariyle artık preview mode'dan çıktı. Eğer gerek takım çalışması için gerekse build server vs.. olarak servisi ücretsiz kullanıyorsanız ücretsiz kullanım 6 Mayıs'tan sonra sonra eriyor. Fiyatlandırma için ise buradan bilgi alabilirsiniz.

Sıkıcı Geçen Son Saat

Build'de ikinci keynote'unun sonunda geçen sene olduğu gibi yine  Steven "Guggs" Guggenheimer and John "Shew" Shewchuk vardı. Developer Conversations başlıklı konuşma yine geçen sene olduğu gibi oldukça sıkıcıydı. Developerlara Microsoft partnerlarının yaptıkları uygulamaları göstermekle neyi amaçladıklarını ne yazık ki 2 senedir anlamış değilim.

Ayrıca WPF, Micro Framework, Windows Embedded gibi teknolojilerinde Microsoft tarafında ölmediğini belirtip bu teknolojilerle ilgili Microsoft tarafında ne yapıldığından 2 senedir bahsetmemeleri de oldukça garip bir durum oldu. Bu teknolojilere Microsoft'un önem verdiğini Microsoft partnerlarının uygulamaları üzerinden developerlara mesaj vermeye çalışmaları oldukça başarısızdı bana göre. Zaten twitterda da keynote'un son saatiyle ilgili oldukça sert yorumlar vardı. Umarım gelecek sene bu ikili build konferansında sahnede olmaz :)

Build'de 3. gün keynote yok. Artık yavaş yavaş konferansın sonuna geliyoruz. Bu saatten sonrada yeni bir haber çıkacağınız zannetmiyorum :) Zaten yeteri kadar makale yazılacak konu da çıktı :)

O zaman Build dönüşü görüşmek üzere :)



.NET Framework'ün Source Code'una Erişim Artık Daha Kolay

Her developer öyle veya böyle kod yazdığı platformda kullandığı kütüphanelerin arkasında yazılan kodu merak eder :) Tabi en çok da uygulamasında bir bug olduğunda :)

.NET tarafındaki librarylerin source code'larına eskiden zaten erişebiliyorduk. Ancak framework versiyonları ilerledikçe source code'a eriştiğimiz kaynak framework'ün hızına yetişemedi ve zamanla eski ve kullanılamaz hale ulaştı.

.NET Framework 4.5.1 ile beraber artık .NET Reference Source sitesi yenilendi ve yeni yüzüyle developerlara açıldı. Artık çok daha hızlı bir şekilde .NET Framework source code'u içerisinde gerek web sayfası üzerinden gerekse Visual Studio üzerinde gezinebiliyoruz. Visual Studio tarafındaki detaylara geçiş yapmadan önce kısaca bir websitesine bakalım.

Siteyi ilk açtığımızda sağ tarafta site içerisinde indekslenen assemblylerin listesini görüyoruz. Eğer kodunu görmek istediğiniz tipin hangi assembly içerisinde olduğunu biliyorsanız buradan hızlı bir şekilde istediğiniz kontrole erişmeniz mümkün.

Sağdaki listeden örnek olarak mscorlib assemblysini seçersek karşımıza alternatif olarak 2 görünüm geliyor. Bunlar Project ve Namespace görünümü. Bu 2 alternatif görünümü de kullanarak aradığımız tipe ulaşmamız mümkün.

Manuel olarak ilerlemek yerine adını bildiğiniz tipe search yaparak da erişebilirsiniz. Böylece assembly ve namespaceler ile uğraşmadan doğrudan istediğiniz tipin koduna erişebilirsiniz. Örneğin diyelim ki System.Collections.Generics namespace'i içerisindeki List<T> tipinin kodunu bulmak istedik. Doğrudan searche List<T> yazmamız yeterli. Böylece çok daha hızlı bir şekilde istediğimiz koda erişebilmekteyiz.

Diyelim ki search veya assembly üzerinden navigasyonla istediğimiz tipi bulduk ve kodlara eriştik. Kodlar üzerinde de gezinmemiz oldukça kolay. Tıpkı Visual Studio'da olduğu gibi herhangi bir metodun üzerine tıklarsanız doğrudan o metodun koduna erişebilirsiniz.

Web sitesindeki kod üzerinde yaptığınız her gezintide site url'inin değiştiğini göreceksiniz. Site url'i üzerinde sizin o anda gezindiğiniz kod dosyası ve satır numarası saklanıyor. Böylece eğer arkadaşınıza "Bak List<T> tipi içerisinde şöyle bir şey buldum" :) demek isterseniz göndereceğiniz link arkadaşınızı doğrudan ilgili kod satırına yönlendirecektir.

http://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs#241

Visual Studio Üzerinden .NET Framework Koduna Erişim

Diyelim ki yazdığınız uygulamayı debug ediyorsunuz ve debug ederken de .NET Framework içerisindeki kodu da debug etme ihtiyacınız doğdu. Bunun için şuradaki ayarları Visual Studio üzerinden yapmanız gerekiyor. Eğer tüm bu ayarlarla uğraşmak istemiyorsanız Visual C# MVP'si Schabse Laks'ın geliştirdiği Ref12 extension'ını kurabilirsiniz. (Extension Visual Studio 2010 ve üzerini destekliyor.)

Extension'ı yükledikten sonra kodunu görmek istediğiniz tipin üzerine gelip Go To Definition'a tıklarsanız doğrudan ilgili tipin koduna navige olabiliyorsunuz.

Eğer tüm .NET Framework'ün source code'unu indirmek isterseniz doğrudan buradaki linki kullanabilirsiniz. Visual Studio kullanarak kod üzerinde gezmek eminim daha iyi hissetirecektir sizi :)

Herşey ROSLYN Sayesinde Daha Kolay !

Tüm bu sistem nasıl yapıldı ? Bu kadar data nasıl elde edildi ? diye merak ediyor olabilirsiniz. :)

Bu sistemin arka planında Roslyn var. Roslyn sayesinde framework kodu derlenirken site içerisinde gördüğünüz herşey alınıp ayrı bir veri saklama alanına konuluyor. Sonrasında da alınan datalar üzerinde search özelliği siteye ekleniyor ve görmüş olduğunuz site çıkmış oluyor. Aslında buna benzer siteyi Roslyn kullanarak kendi kodlarınız içinde yapmanız mümkün. Diyelim ki şirket olarak bir SDK yazıyorsunuz ve SDK içinde bir developer portal yapıp SDK içerisindeki classları ve metotların açıklamalarını koyacaksınız. İşte Roslyn kullanmak için süper bir sebep :)

Roslyn ile ilgili yakında daha çok şey duymaya başlayacağız. Ancak şimdilik benim verebileceğim bilgiler bu kadar. :) Nisan ayında BUILD konferansından sonra daha rahat bir şekilde konuşabileceğimi tahmin ediyorum  ;)



C# 5.1 ya da C# 5.0.1 Gelecek Mi ? Programlama Dilleri Tarafındaki Son Durumlar

Geçen yazımızda .NET Framework 4.5.1 ile ilgili bazı konulara değinmiş ve 4.5.1 sürümüyle Microsoft'un ne yapmaya çalıştığına kısaca bakmaya çalışmıştık. Şimdi sıra geldi bir başka ürüne :)

Build sonrası aldığım bazı maillerde de  "C# ne alemde ?" , " Onlar niye 5.1 veya 5.0.1 sürümü çıkarmadılar ? " gibi sorularla karşılaştım. :) Bu soruların olması çok doğal. İnsanlarda haliyle bir beklenti oluyor. Şimdi gelelim bu soruların cevaplarına :)

Visual Studio 2013 İçerisindeki C# ve VB Compilerları

Öncelikle en çok merak edilen soruya cevap vermekte fayda var.

Soru : Visual Studio 2013 içerisinde bulunan  C# ve VB programlama dillerinde herhangi bir yenilik var mı ?

Cevap : Yok :) Visual Studio 2013 içerisinde bulunan C# ve VB compilerları Visual Studio 2012 içerisinde bulunan compilerlarla tamamen aynı. Yani Visual Studio 2013 ile beraber hiçbir programlama dili yeniliği gelmiyor.

Peki ekipler 1 senedir ne ile uğraşıyor diye sorabilirsiniz :)  Ekipler son 1 yıldır Roslyn projesini bitirmek için çalışıyor ve sona oldukça yaklaştılar. Duyurulmasının üzerinden yaklaşık olarak 3 sene geçen Roslyn projesi ile C# ve VB compilerlarını kendi dillerinde tekrardan yazılıyorlar.  Proje ile ilgili detaya girmeyeceğim ancak bu projenin bitmesiyle beraber programlama dilleri tarafında bir devrim gerçekleşecek  :) (Roslyn projesi ile ilgili detaylı bilgi için buradaki yazıma bakabilirsiniz.)

Peki yeni compilerlar ne zaman kullanılacak derseniz, Visual Studio'nun 2013 sürümünden sonraki ilk sürümüyle beraber eski compilerlar artık yerlerini Roslyn compilerlarına bırakacak. Esas o zaman programlama dilleri ve IDE tarafındaki yenilikler çok farklı boyutlara gelecek ve takip etmekte zorlanacağız diye düşünüyorum :) Belki de o zaman C# 6.1 veya C# 7.1 gibi sürümleri de görebiliyor duruma geliriz. Çünkü Roslyn ile beraber ufak yenilikleri programlama diline eklemek daha kolay ve daha kısa zaman alıyor olacak.

Roslyn'den bahsettik. Bu işin bir de C# 6.0 tarafi var tabi :)  C# 6.0 içerisinde neler olacak diye sorarsanız :) Çalışmalar devam ediyor diyebilirim şimdilik ;)

Bu kısa yazıyla beraber programlama dilleri tarafındaki sorularada umarım cevap verebilmişimdir. Sanırım artık .NET Framework ve programlama dilleri tarafındaki herşey daha net ;)

Not : Yukarıda yazmış olduğum tüm bilgileri Anders Hejlsberg'in Build'de yaptığı Channel 9 Live röportajına dayanarak toparladım. Herhangi gizli bir bilgiyi ortaya çıkarmış değilim. Belirtmek istedim :) Röportaja buradan ulaşabilirsiniz.



The Roslyn Project - 5N1K (Ne,nerede,ne zaman,nasıl,neden,kim)

Merhaba Arkadaşlar,

C# 4.0 ve VB.NET 10 programlama dili sürümleriyle beraber Microsoft tarafında bu iki programlama dilini geliştiren ekipler tek bir çatı altında toplandı. Tek bir çatı altında toplanmasının temel nedeni de aslında programlama dillerini kullanan developerların benzer ihtiyaçlarının olması ve programlama dillerinin özelliklerinin birbirlerinden farklı olmasının önüne geçilerek  ortak temalar üzerinden ilerlenmesi idi.

Tüm bu çalışmalar kapsamında C# 4.0 sürümünün release olmasından sonra programlama dili ekipleri 2 ayrı takıma ayrılarak geliştirmelere devam etmekteler. Bir ekip şu anda C# 5.0 ve VB.NET 11 ( programlama dilleri arasındaki farklılıkları gidermek amacıyla VB 11 ile beraber C#’ta uzun zamandır bulunmakta olan Iterators özelliği geliyor olacak. ) dediğimiz programlama dillerinin bir sonraki versiyonu olan ve ana teması Asenkron Programlama olarak belirlenen geliştirmelere devam ederken bir diğer ekipte daha uzun soluklu bir proje olan Roslyn kod adlı projeye devam etmekteler.

Özellikler C# programlama dilinin geleceği ile ilgili araştırmalar yaptıysanız Compiler as a Service(CaaS) konseptiyle mutlaka karşılaşmışsınızdır. İşte Roslyn projesinin temel amacı da bu. Compiler as service, yani compiler’ın bir API vasıtasıyla servis olarak dışarıya açılması.

Şu anda C# ve VB compilerının yapısına  baktığımız zaman compilerların tam bir kara kutu olduğunu söyleyebiliriz. Çünkü compilerlar yazmış olduğumuz kaynak kodu input olarak alırlar , içeride sihir gerçekleşir ve output olarak .NET assemblyleri üretirler. Compiler aslında bu sihrin gerçekleşmesi sırasında yazmış olduğumuz kod ile ilgili pek çok analiz yapar ve bir takım yapılar oluşturur. Ancak .NET assemblysi üretilmesiyle beraber compiler yaratmış olduğu bu yapıları tamamen siler ve unutur.

Ayrıca syntax highlighting, go to definition, formatting veya refactoring gibi üretkenliğimizi arttıracak olan özelliklerde de baktığımız zaman IDE tarafından sağlanan bu özelliklere sıkı sıkıya bağlı olduğumuz görmekteyiz. Developer olarak kendi ihtiyaçlarımızı karşılayacak olan refactoring mekanizmalarını gerçekleştirmemiz oldukça zor. Aslında syntax highlighting, go to definition, formatting veya refactoring gibi özellikleri incelediğimizde tüm bu özellikler arka planda compiler’ın kodu derleme ve Assembly üretme sırasında kullanmış ve yaratmış olduğu yapıları kullanmakta.

Tüm okuduklarımızı düşündüğümüze Roslyn projesi ile amaçlanan compilerın kara kutu olmaktan çıkarılarak ve içerisinde bulunan bilgilerin bir API vasıtasıyla developerlara sunulmasıdır. Bu doğrultuda da C# ve VB compilerları kendi dillerinde !!! yani managed programlama dilleriyle yeniden implemente edilemekte. Evet yanlış okunmadınız :) Bir takım tarihsel nedenlerden dolayı C# ve VB compilerları C++ programlama dili ile yazılmıştır. Ancak Roslyn projesinden C# ve VB compilerları kendi dillerinde yeniden yazılmaktalar.

Compiler içerisindeki yapıları bir API ile dışarı sunulması peki developerlar için neler sağlayacak ? Aslında yapılabilecek pek çok şey bulunmakta. İlk aklımıza gelen, özellikle dinamik programlama dillerinde gördüğümüz Read-Eval-Print Loop’lar artık implemente edilebilir durumda olacak. Programlama dili içerisindeki scripting yeteneğinin bu şekilde hayata geçtiğini görüyor olacağız. Bunun yanında Meta-Programming dediğimiz aslında program yazan program olarak Türkçe’ye çevirebileceğimiz mekanizmalarda artık gerçekleştirilebiliyor olacak. Ayrıca Language-Object-Model’a sahip olarak, yazılan kod üzerinde tüm analizleri yapabiliyor olacağız. Kendi yazacağımız extensionlar veya uygulamalar ile çok çeşitli kendimize özel refactoring mekanizmalarını hayata geçirebiliyor olacağız. Ayrıca DSL(Domain – Spesific –Languages) Embeding dediğimiz kendi uygulamamıza has bir takım komutlar arasına C# veya VB kodu yerleştirebiliyor ve bu kodları da istediğimiz zaman işletebilir durumda oluyor olacağız.

Roslyn APIs

Yazmış olduğumuz kodların .NET assembly’si haline çevrilmesi süreci aslında compiler içerisinde 4 farklı süreci içerisinde barındırmakta. Bunlar,
  • Parser : Kaynak kodu geçmiş olduğu ilk süreçtir. Bu süreç içerisinde kaynak kod parse edilerek kod tokenlara ayrılır. Ayrılan tokenlar aynı zamanda yapısal bir veri yapısına getirilirler. (Syntax Tree)
  • Symbols & Metadata Import : Bu aşamada kaynak kod içerisindeki tanımlamalar bulunur ve analiz edilir. Daha sonrasında ise sembol tabloları oluşturulması amacıyla bu tanımlamalar ile ilgili metadatalar okunarak sembol tabloları oluşturulur.
  • Binder : Bu aşamada da sembol tablosundaki tanımlamalarla kod içerisinde yapılmış olan tanımlamalar eşleştirilir.
  • IL Emitter : Son aşama olan bu aşamada ise tüm oluşturulan yapılar ve bilgiler birleştirilerek .NET Assembly’si oluşturulur.
Peki Compiler API’ları tam olarak bu süreçlerin neresine oturmakta ?

Compiler API’larını incelediğimizde aslında her bir süreci ayrı olarak içerisinde barındıran farklı API’ları görmekteyiz. Parsing süreci içerisinde Syntax Tree API bulunurken bu API ile Parsing işlemi sürecinde üretilen Syntax Tree üzerinde işlemler gerçekleştirilebilmekte. Aynı şekilde Symbol API, Binding and Flow APIs ve Emit API da geri kalan süreçler ile ilgili işlemleri içerlerinde barındırmakta.

Önceki paragraflarda IDE içerisinde bulunan ve developerların özellikle üretkenliklerini arttıran özelliklerin aslında compiler tarafından üretilen yapıları kullandığından bahsetmiştik. Peki hangi özellikler hangi aşamadaki bilgileri ve API’ları kullanmakta ?

Formatting, colorizer ve outlining gibi özelliklerin Parsing işlemi sonrasında üretilen Syntax Tree’yi kullandığını görmekteyiz. Navigate To ve Object Browser özellikleri de Symbol API tarafından sunulan Sembol Tablosuna dayanmakta. Intellisense, Rename, Extract Method, Go To Definition gibi IDE içerisinde bulunan pek çok özellikte Binding işlemi sonucunda üretilen yapılara dayanmakta. Edit and Continue ise Emit API tarafından gerçekleştirilmekte.

Compiler as Service konsepti aslında oldukça geniş ve içerisinde pek çok bilgiyi barındıran bir konsept. Roslyn projesinin tamamlanmasıyla beraber pek çok özelliğin geleceğini ve çok yaratıcı uygulamaların ortaya çıkacağını söylemek sanırım yanlış olmaz. Bu uzun soluklu projeyi en başından itibaren takip etmenizi şiddetle öneriyorum.

Roslyn projesinin ne zaman tamamlanacağını soracak olursanız açıkcası bunun için süre vermenin çok doğru olacağını düşünmüyorum. Ancak şunu söyleyebilirim ki C# 5.0 ile gelmiyor olacak :)

Roslyn projesinin şu anda CTP sürümü bulunmakta. Bu sürümü buradaki adresten indirip kurabileceğiniz gibi aynı zamanda NuGet Package Manager’a Roslyn yazarak ta projenize ekleyebilirsiniz ;) .

Bir sonraki yazımızda Roslyn ile derinlere dalıyoruz ;)



Roslyn - Scripting API ve C# Interactive Window

Merhaba Arkadaşlar,

Bir önceki yazımızda sizlerle Compiler As a Service konseptini inceleyerek Roslyn projesinin temelini oluşturan kavramları ve servisleri kısaca ve tamemen teorik olarak incelemiştik. Bu yazımızdan itibaren Roslyn ile derinlere dalmaya başlayacağız ve uygulamalı olarak Roslyn’i kullanmaya başlayacağız.

Önceki yazımızda Compiler içerisindeki servislerin birer API ile dışarıya açılmasının getireceği yeniliklerden bahsederken ilk sırada programlama dillerinin scripting özelliği kazanmasını söylemiştik. Scripting özelliği ile aslında uygulamalar içerisinde C# veya VB kodlarının dinamik olarak çalıştırılmasından söz etmekteyiz. Özellikle IronPython gibi dinamik programlama dillerine baktığımızda bu şekilde scripting özellikleri programlama dilinin yapısından dolayı mümkün olabilmekte. Hatta C# 4.0 ile beraber gelen dinamik programlama yenilikleri ve DLR (Dynamic Language Runtime) ile uygulamalarımız içerisinde şu anda Dinamik Programlama dillerinin kodlarını çalıştırabilmekteyiz.

Ancak konu C# ve VB kodlarının dinamik olarak çalıştırılabilmesine geldiğinde Roslyn öncesine kadar böyle bir şeyi gerçekleştirmek bizler için çok kolay değildi. Bunun için Reflection ve CodeDom tarafında bir takım derleme işlemleri yapmak gerekmekteydi.

Roslyn içerisinde bulunan Scripting API ile artık C# ve VB kodlarını uygulamalar içerisinde hızlı bir şekilde işletip sonuçlarını alabilmekteyiz. Şimdi ilk olarak bir Console uygulaması yaratalım ve bu uygulama içerisinden kodlarımızı dinamik olarak çalıştıralım.(Makale boyunca görmüş olduğunuz kodları çalıştırabilmek için  Roslyn.Compilers ve Roslyn.Compiler.CSharp dll’lerini referans olarak eklemeniz gerekmekte.)

ScriptEngine engine = new ScriptEngine();
engine.Execute(@"System.Console.WriteLine(""Hello Roslyn !!!"");");
Yukarıdaki kodu doğrudan çalıştırdığımızda string olarak yazmış olduğumuz kodun C# compilerı tarafından işletildiğini ve Console uygulamamızın ekranına "Hello Roslyn !!!” yazdığını görüyoruz.

Şimdi biraz daha ileri gidelim ve değişken tanımlayıp bu tanımladığımız değişkeni bir alt satırda yazmış olduğumuz bir başka dinamik kod içerisinde kullanalım.
ScriptEngine engine = new ScriptEngine();
engine.Execute(@"int x = 5;");
engine.Execute(@"System.Console.WriteLine(x);");
Yazmış olduğumuz kodu çalıştırdığımızda bakalım ne ile karşılaşacağız :)

Compiler tarafından ilk olarak yaptığımız tanımlama işletildikten sonra 2. sırada yazmış olduğumuz tanımladığımız değişkenin değerini Console’a yazdıran kod işletildiği sırada yukarıdaki exception fırlatılmakta ve x değişkeninin context içerisinde bulunmadığı söylenmekte. ;)

Buradan da çıkaracağımız sonuç şu olmalı ki ScriptEngine tipi içerisinde bulunan Execute metoduna sadece string olarak verdiğimiz C# veya VB kodları işletildikten sonra bu kodlar içerisinde yapılmış olan tüm tanımlamalar compiler tarafından unutulmakta. Peki bu tanımlamaların unutulmaması için ne yapmamız gerekiyor ?

Execution Context

C# veya VB kodlarının dinamik olarak işletilmesi sırasında daha önceden işletilen kodlarının compiler tarafından unutulmaması için kodların içerisinde çalıştırılacağı bir context belirlememiz gerekmekte. Bunun için de Roslyn tarafında kodumuzun içerisinde işletileceği bir Session belirlememiz gerekmekte ve Execute metoduna parametre olarak vereceğimiz kodun yaratmış olduğumuz Session içerisinde işletilmesi gerektiğini bildirmemiz gerekmekte.

ScriptEngine engine = new ScriptEngine();
Session session = Session.Create();
engine.Execute(@"int x = 5;", session);
engine.Execute(@"System.Console.WriteLine(x);", session);
Şimdi biraz daha ileriye gidelim ve session içerisinde bir metot tanımlayalım ve daha sonra bu metodu çağıralım.
ScriptEngine engine = new ScriptEngine();
Session session = Session.Create();
engine.Execute(@"void Print (object x){ System.Console.WriteLine(x);}",session);
engine.Execute(@"int x = 5;", session);
engine.Execute(@"Print(x)", session);
Şu ana kadar Roslyn tarafında dinamik kod işletme ile ilgili olarak temel kısımları inceledik. Ancak incelememiş olduğumuz bir nokta kaldı. O da dinamik olarak işletmiş olduğumuz kodun aslında çalıştırılmış olduğu host uygulama ile nasıl iletişimde olacağı.

Host Object

Host uygulama ile iletişimde bulunmak için Roslyn tarafında Host Object yapısını kullanmamız gerekmekte. Host Object dediğimiz yapı aslında herhangi bir tip olabilmekte. Bu tip, tanımlamış olduğumuz session içerisine dahil edilmekte ve böylece biz de dinamik olarak işleteceğimiz kodlar tarafında bu host object içerisinde bulunan tüm public üyelere erişebilmekteyiz ve istediğimiz işlemleri gerçekleştirebilmekteyiz. Örnek olarak host uygulama içerisnde şu şekilde içerisinde sayıları tutan ve bir takım işlemler gerçekleştiren bir sınıf tanımlayalım.

public class NumberList
{
 List<int> numbers = new List<int>();

 
 void Add(int i)
 {
 numbers.Add(i);
 }
 void PrintNumbers()
 {
 for (int i = 0; i < numbers.Count; i++)
 {
 Console.WriteLine("{0}- {1}", i + 1, numbers[i]);
 }
 }
}
 

Yukarıda tanımlamış olduğumuz tip host uygulama olan Console uygulamamızda yer almakta. Şimdi sıra geldi bu tipi nasıl kullanacağımıza. Eğer bir tipi host object olarak kullanmak istiyorsak öncelikli olarak bu tipi ilgili Script Engine ve Session tiplerine bildirmemiz gerekmekte.

NumberList numberList = new NumberList();
ScriptEngine engine = new ScriptEngine(new[] 
 { typeof(NumberList).Assembly.Location });
Session session = Session.Create(numberList);
engine.Execute("Add(3);", session);
engine.Execute("Add(5)", session);
engine.Execute("PrintNumbers()", session);
Uygulamamızı çalıştırdığımızda aşağıdaki gibi bir çıktı ile karşılaşmaktayız.

C# Interactive Window

C# ve VB programlama dillerine Scripting özelliğinin gelmesiyle beraber yapılabilecekler düşünüldüğünde aklımıza ilk olarak REPL(Read-Eval-Print-Loop) uygulamaları gelmekte. Yukarıda yapmış olduğumuz örneklere baktığımızda aslında bir REPL uygulaması yapmak için hemen hemen tüm parçalar elimizde. Bu nedenle REPL uygulaması kısmını tamamen size bırakıyorum ;) Ancak yine de takıldığınız noktalar olursa zaten internette Roslyn ile yapılmış pek çok REPL uygulaması bulunmakta bunlardan yararlanabilirsiz ya da İletişim bölümünden bana ulaşabilirsiniz.

Makalemizin sonlarına gelirken makalenin bu bölümünde aslında yine Roslyn ile beraber gelen ve Visual Studio içerisine entegre edilen bir REPL uygulamasından bahsediyor olacağım. Roslyn paketini bilgisayarınıza yükledikten sonra Visual Studio içerisinde View => Other Windows yolunu izlediğinizde burada “C# Interactive Window” seçeneğini görüyor olacaksınız. Buraya tıkladığımızda karşımıza gelen aslında C# kodları ile çalışan bir REPL uygulaması. Bu uygulama ile hızlı bir şekilde istediğimiz kodu yazıp sonucunu görebilmekteyiz.

Şimdi isterseniz buraya bir takım kodlar yazalım ve sonuçlarını inceleyelim.

Gördüğünüz gibi aslında bir C# uygulaması içerisinde yapabileceğimiz pek çok şeyi bu Window içerisinde yapabilmekteyiz ve sonuçlarını hemen görebilmekteyiz. Peki diğer dil özellikleri bu Window içerisinde destekleniyor mu diye soracak olursanız aslında compiler tarafından sağlanan bilgiler ile çalışan outlining, colorizer, intellisense gibi özellikler de bu window içerisinde çalışmakta. Burdan da anlıyoruz ki aslında compiler tarafından sağlanan farklı farklı API’lar birbirlerinden bağımsız olarak beraberce çalışabilmekteler. ;)

C# Interactive Window içerisinde bilmemiz gereken en önemli komutlardan biri de library referansı ekleme komutudur. #r “LibraryName” komutu ile Interactive Window içerisinde çalıştıracağınız kodlar ile ilgili gerekli referansları ekleyebilirsiniz.

Bunun yanında Interactive Window içerisindeki en güzel özelliklerden biri de yazmış olduğunuz uygulama içerisindeki kodları hızlı bir şekilde işletebilme ve sonuçlarını inceleyebilme şansı vermesi. Bunun için çalıştırmak istediğiniz kodu seçip Ctrl+Enter yapmanız yeterli. Yazmış olduğunuz kod Interactive Window içerisine kopyalanmakta ve işletilmekte. ;)

Eğer bir takım referanslar Interactive Window içerisinde tanımlı değilse kopyalamış olduğunuz kod Interactive Window içerisinde çalıştırılamayabilir. Bu nedenle öncelikle uygulama içerisinde referansların Interactive Window içerisinde referans olarak eklendiğinden emin olmamız gerekmekte. Bunun için de ilgili Project’e sağ tıklayarak “Reset Interactive Window From Project”’i seçmemiz gerekmekte.

Bu noktadan sonra ise artık yapmamız gereken ilgili kodu seçip Ctrl+Enter ile C# Interactive Window içerisinde işletmek.

Not : Interactive Window şu anda sadece C# için bulunmaktadır. İlerleyen sürümlerde VB için de Interactive Window duyurulacaktır.

Gördüğünüz gibi Compiler As a Service (CaaS) konsepti oldukça geniş ve bir o kadar da eğlenceli bir konu :) Bu yazımızda her ne kadar sadece Scripting API’yi incelemiş olsakta sırf bu API’yı kullarak bile yapabileceğimiz pek çok şey bulunmakta. Bu yüzden bir C# veya VB developer olarak herkese Roslyn projesini takip etmesini öneriyorum.

Umarım sizler için faydalı bir makale olmuştur.

Not: Makale içerisindeki kodlar Roslyn CTP-1 ile yazılmış ve test edilmiştir.



Tüm Yönleriyle C# 5.0 Webineri Kaydı

Merhaba Arkadaşlar,

23 Şubat 2012 tarihinde Nedirtv Şubat Ayı özel Level 300 webinerleri kapsamından yapmış olduğum "Tüm Yönleriyle C# 5.0" webinerinin kaydını sizlerle paylaşıyorum.

Webiner süre olarak tahmin ettiğimden biraz daha uzun sürse de (yaklaşık 2 saat kadar :) ) faydalı bir webiner olduğunu düşünüyorum. :)

Webineri kayıt altına alan ve bana ulaştıran Bahtiyar Dilek'e teşekkür ederim.

Mart ayında ise Akdeniz Bölgesinde bir seminerde olacağım. Detaylar  çok yakında... :)

Webineri buradan download edebilirsiniz.

Görüşmek Üzere,