Merhaba Arkadaslar,

Gectigimiz gun ozlem duydugum bilgisayar oyunlarindan birisi olan Warcraft II' nin ses efektlerini arar halde buldum kendimi. Olay tabi ses efektlerinin mukemmelliginden cikti oyuncu karakterlerine kadar geldi. Gerek Orc' lar da gerek Human' lar da super kahramanlar vardi. Buyuculer, okcular, isciler ve daha niceleri. Pek cogumuzun bu oyun basinda saatler harcadigindan ve sabah ezanina kadar kaldigindan eminim.

Nedense soz konusu karakterleri bir arastirma konusunda kullanma ihtiyaci da hissettim. Tesadufe bakin ki ayni anda .Net tarafinda da bir konuyu arastirmaktaydim. Sonuc olarak asagidaki konu icin onlari kendi bakis acimdan degerlendirmeye karar verdim. Bakalim bu gunku yazimizda nasil bir maceraya daliyor olacagiz Haydi buyrun oyleyse baslayalim.

Asenkron calisma cok uzun zamandir hayatimizda. Ancak yazilim gelistiriciler icin halen daha tam anlamiyla mukemmel degil. Ozellikle .Net Framework acisindan olaya baktigimizda. Yine de her .Net Framework surumunde, User Experience' in yogun ve cevap verebilirligi yuksek ekranlarin tasarlanmaya calisildigi senaryolarda, gelistiricilerin ellerinde daha guclu kozlar olusmakta. Burada en buyuk yardimci tabiki Framework icerisine dahil edilen Built-In operasyonlar/fonksiyonlar.

Bu alanlardan birisi de tahmin edilecegi uzere dosya giris cikis islemleri(IO operasyonlari). Dosyalama islemleri ozellikle .Net Framework 4.0 surumune kadar senkron(Synchronous) olarak isletilebilen operasyonlardan ibaretti. Diger yandan .Net Framework 4.0 surumu ile birlikte StreamReader ve StreamWriter gibi siniflara BeginRead, BeginWrite gibi temel asenkron calisabilme metodlari ilave edildi.

Bilindigi uzere en basit mana da bir islevi baslatip aninda koda donebilmek icin IAsyncResult arayuzunun(Interface) kullanildigin BeginX, EndX gibi dahili metodlardan yararlanilir. Bu, olay tabanli asenkron programlamaya(Event Based Asynchronous Programming) da olanak tanimaktadir.

Bu yeni metodlar sayesinden dosyalara asenkron olarak yazmak veya kaynakta yine asenkron olarak okuma yapmak mumkun. Yine de ortada gelistiriciler icin bir sikinti var. O da kodun karmasikligi ve yazim zorlugu.

IO islemlerinde neden asenkron calismaya ihtiyac duyariz?

Bu soruyu da cevaplamak onemli. Ilk etapta kullanicilarin ele aldiklari ekranlarin cevap verebilirligi(Responsivable) yer almakta. Kullanicilar sabirsiz kisilikte insanlar. O nedenle ozellikle bir IO islemi sirasina ekranin kitlenmesini(kitlenmis gibi gozukmesini) istemezler. Diger yandan ikinci bir sebep te tamamen performans ile alakalidir. Bazi hallerde IO islemi gercekten cok zaman alan ve sistem kaynaklarini onemli olcude tuketen hareketliliklere gebedir. Dolayisiya bu yuku asenkron olarak dagitabilmek onemlidir.

Pek tabi .Net Framework 4.5 ile birlikte ozellikle async ve await anahtar kelimelerinin de devreye girmesi ile IO tarafi icin de bazi iyilestirmeler yapildi. Bu iyilestirmeler sayesinde IO islemleri sirasinda cevap verebilirligi yuksek olan ekranlarin tasarlanmasi daha kolay hale gelmekte. Buna ek olarak CLR(Common Language Runtime) takimi bu yeni fonksiyonellikler icin es zamanli(Concurrent) calismanin performansini da arttirici iyilestirmeler yapmis. Ancak bana gore belki de en onemli avatajimiz, gelistirici acisindan bakildiginda, ihtiyaclarin daha kolay yazilabiliyor olmasi.

Gercek hayattan;

daha onceden calistigim bir banka da, sistemler arasinda veri tasinmasi veya disaridan gelen bazi verilerin database ortamlarina alinmasi, buyuk boyutlu ve genellikle text tabanli olan dosyalar uzerinden yapilmaktaydi. Cogunlukla otomatik olarak devreye giren ve bir SQL Job ile iliskilendirilmis olan SSIS(Sql Server Integration Services) paketleri soz konusuydu.

Ancak SSIS' de ayri bir uzmanlik alani gerektirmekte ve bazi durumlarda soz konusu dosya aktarim islemleri, Form tabanli uygulamalar icerisinden yapilmak zorundaydi.

Hal boyle olunca bazi vakalarda, boyutu 650 megabyte' in uzerinde olan dosyalar icin uygulama ekraninin kilitlenmesi de son derece dogaldi. Hele de bu bir banka olunca sureci asenkron olarak calistirmak sarttir. Iste size Asenkron IO islemleri icin kocaman bir sebep

Yeni Fonksiyonlar

Biz bu makalemizde ozellikle StreamReader ve StreamWriter siniflarina gelen ve asenkron IO islemlerini yapmamizi saglayan yeni metodlari incelemeye calisiyor olacagiz. Konsept olarak sadece kullanim sekillerini incelemek niyetindeyiz. Bu sebepten senaryolarimizi bir Console uygulamasi uzerinden ele alacagiz. StreamReader ve StreamWriter gibi IO sinfilarina ilave edilen asenkron metodlari bulmamiz aslinda son derece kolay. Isimlendirme standardi olarak sonu async kelimesi ile biten metodlar aradigimiz fonksiyonlar olacaktir

Dilerseniz ise ilk olarak asenkron yazma islemleri ile baslayalim ki elimizde buyukce bir test dosyasi da olussun

Bu amacla basit ama isi zevkli hale getirecek de bir on hazirlik yapacagiz. Senaryomuzda en az 10milyon elementten olusan bir oyun sahasi bulunacak. Bu saha icerisinde okcu, sovalye, mancinik, kale gibi karekterlere yer verecegiz. Bu karakterlere ait baska bilgileri de tutuabiliriz. Ornegin bulunduklari kita, harita uzerindeki koordinat bilgisi, guc seviyleri, hangi taraftan olduklari(insan, bilgisayar, hayalet ) gibi.

E tabi bu karakterlerden olusan kumeyi uretecek bir de yardimci tipimizin soz konusu oldugunu dusunebiliriz. Lafi fazla uzatmadan on hazirlik icin kullanacagimiz kod parcalarina bir goz atalim dilerseniz.

GameElement.cs;

using System;

namespace NewIOFunctions
{
    public class GameElement
    {
        public int Id { get; set; }
        public string Actor { get; set; }
        public int Force { get; set; }
        public string Type { get; set; }
        public string MainLand { get; set; }
        public int X { get; set; }
        public int Y { get; set; }

        public override string ToString()
        {
            return String.Format("{0}|{1}|{2}|{3}|{4}|({5};{6})", Id.ToString(), Actor, Force, Type, MainLand,X.ToString(),Y.ToString());
        }
    }
}

GameCreator.cs;

using System;
using System.Collections.Generic;

namespace NewIOFunctions
{
    public static class GameCreator
    {
        // Test verileri icin ornek bir kume
        // Savas alanina yerlestirecegimiz aktorler
        static string[] actors = { "Archer", "Footman", "Knight", "Castle", "Rider", "Catapult" };
        // Bu aktorlerin guclerini temsil eden degerler.
        static int[] forceValues = { 100, 200, 300, 400 };
        // Bu yerlestirilen aktorlerin hangi tipten oldugunu belirtecek taraf bilgileri(Ghost enteresan bir karakterdir. Yeri gelince Human yeri gelince Computer tarafinda oluyor :)
        static string[] types = { "Human", "Computer", "Ghost" };
        static string[] mainlands = { "Mordor", "Middle Earth", "Other Side", "Wrong Side", "Red Zone", "Deadly Land", "Kolburg" };

        public static List<GameElement> CreateRandomElements(int size)
        {
            List<GameElement> elements = new List<GameElement>(size);
            Random randomizer = new Random();
            for (int i = 0; i < size-1; i++)
            {
                GameElement element = new GameElement();
                element.Id = i;
                element.Actor = actors[randomizer.Next(0, actors.Length - 1)];
                element.Force=forceValues[randomizer.Next(0, forceValues.Length - 1)];
                element.Type = types[randomizer.Next(0, types.Length - 1)];
                element.MainLand = mainlands[randomizer.Next(0, mainlands.Length - 1)];
                element.X = randomizer.Next(-90, 90);
                element.Y = randomizer.Next(-90, 90);
                elements.Add(element);
            }
            return elements;
        }
    }
}

static GameCreator sinifinin CreateRandomElements isimli metodu istenen boyuta gore rastgele veriler ile uretilen GameElement tipinden bir koleksiyon dondurecek sekilde tasarlanmistir.

Dilerseniz buradaki uretim isini Task Parallel Library_ yi ve Concurrent koleksiyonlari da isin icerisine katarak asenkron doldurabilirsiniz. Ama dikkatli olun. Her uretiminizde 10milyonluk bir set elde edemessiniz. Tabi Thread_ leri en azindan gereken yerlerde kilitleyip senkronize etmedikce

Simdi asil senaryolarimiza gecebiliriz. Ilk etapta uretilen bu rastgele veri icerigini fiziki bir dosyaya asenkron moda da nasil yazdirabilecegimizi incelemeye calisacagiz. Bu nedenle Program.cs iceriginde asagidaki kodlar ile ise baslayabiliriz.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;

namespace NewIOFunctions
{
    class Program
    {
        static void Main(string[] args)
        {
            //10 milyonluk bir test kumesi uretiyoruz. Bunu asenkron gelistirmedigimizden biraz zaman alacaktir.
            var gameZone = GameCreator.CreateRandomElements(10000000);
            var taskResult=WriteFileAsync(gameZone, Path.Combine(Environment.CurrentDirectory, "GameZone.txt"));
            Console.WriteLine("Islemler devam ediyor...");
            // Dosya yazma ile iliskili islemlerin tamamlanmasi icin uygulamayi bekletiyoruz.
            taskResult.Wait();
            Console.WriteLine("{0} adet satir yazildigi bilgisi geldi.", taskResult.Result.ToString());
        }

        // WriteFileAsync metodundan geriye bilincli olarak bir Task tipi dondurduk. Boylece burayi cagirdigimiz Main metodu sonuna gelindiginde ilgili Task' in tamamlanip tamamlanmadigini kontrol edebiliriz.
        private static async Task<int> WriteFileAsync(List<GameElement> elements, string filePath)
        {
            Console.WriteLine("Yazma islemi baslatildi.");

            Stopwatch watcher = new Stopwatch();
            watcher.Start();

            // StreamWriter tipini uretiyoruz ve parametre olarak veriyi yazacagimiz dosya adresini belirtiyoruz
            using (StreamWriter writer = new StreamWriter(filePath))
            {
                foreach (var element in elements)
                {
                    // Awaitable olan WriteLineAsync metodunu cagiriyor ve icerigi yazdiriyoruz.
                    await writer.WriteLineAsync(element.ToString());
                }   
            }
           
            watcher.Stop();
            Console.WriteLine("Yazma islemi tamamlandi. Toplam sure {0} milisaniye.",watcher.ElapsedMilliseconds.ToString());

            return elements.Count;
        }
    }
}

Ornegimizi calistirdigimizda asagidakine benzer bir sonuc ile karsilasiriz.

Uretilen dosya iceriginin bir kismi da asagidaki gibidir.

Tabi bu dosyayi Notepad acmayi nasil basardi anlayabilmis degilim Yine de siz kendi sistemlerinizde zorlanmamak adina, Notepad2' yi veya Notepad++' i kullanmayi dusunebilirsiniz.

Dikkat edilecegi uzere WriteFileAsync' e yapilan cagri icerisinde StreamWriter tipinin await edilebilir WriteLineAsync metodu kullanilmaktadir. WriteFileAsync metodu aslinda geriye bir Task<int> tipi dondurmek zorunda degildir. Bunu daha cok, Wait metodu kullanilarak baslatilan Task' in islemlerini bitirene kadar uygulamanin beklemesi ve islenen satir sayisinin bir degerinin ana Thread tarafindan elde edilebilmesi icin kullandik. Nitekim uygulamayi akisina birakip Wait cagrisini gerceklestirmessek, tum icerik yerine program sonlanana kadar yazilabilen kisim fiziki olarak aktarilacaktir.

Ornek senaryonun isletilisi sirasinda gozden kacirilmamasi gereken bir nokta da, aslinda dosyaya yazma isleminin asenkron olarak gerceklestirilmemesidir. Yani, GameElement tipindeki koleksiyon iceriginin es zamanli(Concurrent) olarak yazilmasi gibi bir durum ortada yoktur. Dosya icerigine baktigimizda, icerigin sirali olarak yazilmis olmasinin nedeni de budur. Yanlis bir asenkron algi olusmamasi icin bu hususu belirtmek istedim. Nitekim dosya icerigini asenkron olarak doldurmak tamemen farkli bir vakadir.

Dilerseniz bir de dosyadan okuma islemini basit bir senaryo ile ele almaya calisalim. Yine satir satir okuma adimini gerceklestirebiliriz. Iste kod icerigimiz.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;

namespace NewIOFunctions
{
    class Program
    {
        static void Main(string[] args)
        {
            var readTaskResult = ReadFileLineByLineAsync(Path.Combine(Environment.CurrentDirectory, "GameZone.txt"));
            Console.WriteLine("Islemler devam ediyor...");
            readTaskResult.Wait();
            Console.WriteLine("Sonuclar");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(readTaskResult.Result[i].ToString());
            }
        }

        private static async Task<List<GameElement>> ReadFileLineByLineAsync(string file)
        {
            Console.WriteLine("Okuma islemi baslatildi.");
            List<GameElement> elements = new List<GameElement>();
            Stopwatch watcher = new Stopwatch();
            watcher.Start();

            using (StreamReader reader = new StreamReader(file))
            {
                string line;
                while (!String.IsNullOrEmpty(line = await reader.ReadLineAsync()))
                {
                    string[] columns=line.Split('|');
                    elements.Add(new GameElement
                    {
                        Id=Convert.ToInt32(columns[0]),
                        Actor=columns[1],
                        Force=Convert.ToInt32(columns[2]),
                        Type=columns[3],
                        MainLand=columns[4],
                        X=Convert.ToInt32(columns[5].Split(';')[0].TrimStart('(')),
                        Y = Convert.ToInt32(columns[5].Split(';')[1].TrimEnd(')'))
                    }
                    );
                }
            }

            watcher.Stop();
            Console.WriteLine("Okuma islemi tamamlandi. Toplam sure {0} milisaniye.", watcher.ElapsedMilliseconds.ToString());

            return elements;
        }       
    }
}

Okuma isleminin tamamlanmasini takiben ,uretilen GameElement icerikli generic List koleksiyonunun metoddan neden bu sekilde bir Task tipi ile donduruldugu noktasinda kafalarda bir soru isaret olabilir. Neden normal bir liste dondurmedik? Ya da neden out veya ref isaretli metod parametrelerine basvurmadik? Cevap async kullanmis olmamizdir. Bu sekilde isaretlenmis metodlar void, Task ya da Task<T> donusune sahip olabilir. Ayrica ref ve out kullanimina izin verilmez.

Ornegimizin calismasi tabiki biraz uzun surebilir. Kolay degil yaklasik 450 megabyte' lik bir icerigin okunmasi soz konusu. Iste ornek ekran ciktimiz.

Her iki ornekte de onemli olan, dosyadan satir bazinda okuma ve dosyaya satir bazinda yazma islemlerini iceren fonksiyonelliklerin ana uygulamadan bagimsiz olarak asenkron calisabiliyor olmalaridir. Bir baska deyisle es zamanli(Concurrent) olarak bir dosya icerisine yazma veya okuma islemi soz konusu degildir.

Async olarak kullanilabilecek baska IO metodlari da mevcuttur. Bunlari asagidaki sekilde siralayabiliriz.

• ReadAsync
• ReadToEndAsync
• ReadBlockAsync
• WriteAsync
• WriteLineAsync
• FlushAsync

Parcalanmis Asenkronluk

Son bir senaryo ile yazimiza devam edelim dilerseniz  

Bu kez 10milyon element' ten olusan sahimizi 10 parcaya bolup her bir parca icerisinde ayri bir Text dosyaya yazma islemini, asenkron manada simule etmeye calisiyor olacagiz. Iste senaryoya istinaden ele alabilecegimiz kod parcalari.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace NewIOFunctions
{
    class Program
    {
        static void Main(string[] args)
        {
            //10 milyonluk bir test kumesi uretiyoruz. Bunu asenkron gelistirmedigimizden biraz zaman alacaktir.
            var gameZone = GameCreator.CreateRandomElements(10000000);
            var r=WriteTo10File(gameZone);
            Console.WriteLine("Islemler devam ediyor...Lutfen bekleyiniz");
            r.Wait();
            Console.WriteLine("Program sonlandiriliyor");
        }

        private static async Task WriteTo10File(List<GameElement> elements)
        {
            for (int i = 1; i <= 10; i++)
            {
                string fileName = Path.Combine(Environment.CurrentDirectory, "GameZone_" + i.ToString() + ".txt");
                await WriteFileAsyncV2(elements.Skip((i-1)*1000000).Take(1000000).ToList(), fileName);
            }
            Console.WriteLine("Tum dosya yazma islemleri tamamlandi.");
        }

        private static async Task WriteFileAsyncV2(List<GameElement> elements, string filePath)
        {
            using (StreamWriter writer = new StreamWriter(filePath))
            {
                foreach (var element in elements)
                {
                    // Awaitable olan WriteLineAsync metodunu cagiriyor ve icerigi yazdiriyoruz.
                    await writer.WriteLineAsync(element.ToString());
                }
                Console.WriteLine("{0} icin islemler tamamlandi.",filePath);
            }
        }
    }
}

Hem WriteTo10File hem de WriteFileAsyncV2 metodlari async olarak isaretlenmis olup kendi iclerinde await edilebilir operasyon cagrilarina yer vermektedirler. Ilk olarak 10milyonluk kume 10  esit parca seklinde ele alinmakta ve her bir alt kumenin asenkron bir metod ile calisacak sekilde ilgili dosyalara yazdirilmasi islemi gerceklestirilmektedir.

Dosyaya satir bazli yazma islemi icin yine WriteLineAsync fonksiyonunundan yararlanilmaktadir. WriteTo10File metoduda kendi icerisinde 1milyonluk kumelere ayirdigi element listelerini ayri dosyalara yazmak icin WriteFileAsyncV2 metodunu await anahtar kelimesi ile cagirmaktadir ki bu da gozden kacirilmamasi gereken bir noktadir. Kodun calisma zamani ciktisi asagida goruldugu gibidir.

Tabi klasor yapisina bakildiginda  GameZone_1_ den GameZone_10_ a kadar 10 farkli dosyanin uretildigi ve icerisine de 10milyon kumenin 1milyon parcalarinin yazildigi gorulebilir.

Senaryolarimiz ile Console uzerinden basit pratiklerimizi yapmis olduk. Simdi bu pratikleri gercek hayat senaryolari ile degerlendirmeye calismaliyiz. Dolayisiyla islemlerimizi artik gorsel arabirimi olan ve gercekten de cevap verilebilirlige ihtiyac duyan Windows Forms, WPF(Windows Presentation Foundation) ve belki de Asp.Net gibi uygulama cesitlerinde ele almaliyiz. Her zaman oldugu gibi bu kutsal gorevi siz degerli meslektaslarima birakiyorum Boylece geldik bir yazmizin daha sonuna. Tekrardan gorusunceye dek hepinize mutlu gunler dilerim.

NewIOFunctions.zip (48,16 kb)