Erhan Ballıeker

Resilient Network Services Bölüm 7 – Xamarin Projemizde Refit, Polly, Akavache, Fusillade ve ModernHttpClient Birlikte Kullanımı Bölüm 2

Selamlar,

Bir önceki yazımda önhazırlığını tamamladığımız yazımızın asıl kısmına geçelim.  En son IApiRequest adında bir interface oluşuturarak içerisine 3 adet readonly property koymuştuk. Şimdi hızlı bu interface implemente edecek olan gerçek ApiRequest sınıfımızı oluşturalım ve ilgili kütüphaneleri kullanmaya başlayalım.

ApiRequest adında bir class ekleyelim projemize, içeriği aşağıdaki şekilde olacak.

public class ApiRequest : IApiRequest
    {
        private readonly Lazy _background;
        private readonly Lazy _userInitiated;
        private readonly Lazy _speculative;

        public string BaseApiAddress = "https://randomuser.me/api";

        public ApiRequest()
        {
            _background = new Lazy(() => CreateClient(new RateLimitedHttpMessageHandler(new NativeMessageHandler(), Priority.Background), BaseApiAddress));
            _userInitiated = new Lazy(() => CreateClient(new RateLimitedHttpMessageHandler(new NativeMessageHandler(), Priority.UserInitiated), BaseApiAddress));
            _speculative = new Lazy(() => CreateClient(new RateLimitedHttpMessageHandler(new NativeMessageHandler(), Priority.Speculative), BaseApiAddress));
        }

        public T Background => _background.Value;

        public T Speculative => _speculative.Value;

        public T UserInitiated => _userInitiated.Value;

        public T CreateClient(HttpMessageHandler handler, string baseApiAddress = null)
        {
            var client = new HttpClient(handler)
            {
                BaseAddress = new Uri(baseApiAddress ?? BaseApiAddress)
            };

            var res = RestService.For(client);
            return res;
        }
    }

Peki gelelim yukarıda ki class ımızı satır satır inceleyelim. Bu class ımızda bu seri boyunca bahsettiğimiz kütüphanelerden hali hazırda 3 tanesini kullanmış olduk. Bunlar Fusillade, Refit ve ModernHttpClient. Sınıfımız incelersek şunları görüyoruz.

  • class ımız IApiRequest Interfaceinden türüyor, ve buradan alması gereken propertyler aşağıdaki gibi oluşturuldu.
    • public T Background => _background.Value;
    • public T Speculative => _speculative.Value;
    • public T UserInitiated => _userInitiated.Value;
  • Yukarıda bu propertylerin initalize edilme kısmını C# ın Lazy objesine bıraktık. 3 adet field ımızı class ilk başında tanımlandı. Bunların tipi Lazy olarak işaretlendi. Ve ApiRequest sınıfmızın constructor nda da bu Lazy field ların neyi ne şekilde initiazlize edileceklerini tanımladık;
    • 3 Lazy adet field ımız
      • private readonly Lazy _background;
      • private readonly Lazy _userInitiated;
      • private readonly Lazy _speculative;
    • Constructor da bunların yine Lazy sınıfının constructor ını kullanarak ne şekilde ne döneceklerini tanımladık. Aşağıda yazmış olduğumuz CreateClient metodu ile geriye sınıfı oluştururken verdiğimiz generic parametresini geri dönüyoruz.  Constructor da kullandığımız bu RateLimitiedHttpMessageHandler ve NativeMessageHandler a dikkat edelim.YAzmış olduğumuz CreateClient metodu aslında bizim için bir HttpClien oluşturacak bunu biliyoruz. Parametre olarak bu method bizden bir HttpMessageHandler istiyor.  Bu metoda Fusillade in RateLimitedHttpMessageHandler ını veriyoruz ve priority oralark da her bir interface imizden gelen her bir property karşılık olan Fusillade Priortiy lerini veriyoruz.  RateLimitedHttpMessageHandler  içerisine contructor parametresi olarak bir de ModernHttpClient ın  NativeMessageHandler ını veriyoruz. Bu sayede en alttaki CreateClient metodumuza geçmiş olduğumuz HttpMessageHandler, ModerHttpclient ın handler ını kullanan Fusillade in RateLimited handler ı olmuş oldu. Bu ikisini bir arada bu şekilde kullanabiliriz.
      • _background = new Lazy(() => CreateClient(new RateLimitedHttpMessageHandler(new NativeMessageHandler(), Priority.Background), BaseApiAddress));
      • _userInitiated = new Lazy(() => CreateClient(new RateLimitedHttpMessageHandler(new NativeMessageHandler(), Priority.UserInitiated), BaseApiAddress));
      • _speculative = new Lazy(() => CreateClient(new RateLimitedHttpMessageHandler(new NativeMessageHandler(), Priority.Speculative), BaseApiAddress));
    • Interface den gelen Propertylerimiz class ımız üzerinden seçildiğinde, LAzy sınıfı bizim ona verdiğimiz delegate i kullanarak bu sınıfı oluştururken verdiğimiz generic T objesini bizim için oluşturacak.
  • CreatClient metoduna bakalım.
    • var client = new HttpClient(handler)
    • { BaseAddress = new Uri(baseApiAddress ?? BaseApiAddress) };
      • Burada yeni HttpClient objesi oluşturup bunun runtime da bizim istediğimiz yaşayan Refit interface ini alıp haberleşme yapısı olarak geri vermesi için Refit in RestService.For generic metodu nu kullanıp içeriye client ımızı veriyoruz.
    • var res = RestService.For(client); return res;

Peki hemen bir de madem Refit i de kullandık, ilk yazıda belirttiğim bu endpoint ile haberleşecek ve userları bize getirecek olan refit Interface imizi oluşturalım.

Ben genelde bu refit interfacelerini proje içerisinde Endpoints diye bir klasör altında toplarım. Burada da öyle yapalım Endpoints diye bir klasör açalım ve içerisine

IRandomUserEndpoint diye bir interface ekleyelim

    [Headers("Content-Type : application/json")]
    public interface IRandomUserEndpoint
    {
        [Get("/")]
        Task GetUserList(int results, int page);
    }

Interfaceimizin içeriği yukarıdaki gibi olacak. Refit ile ilgili postlarımda refit kullanarak e şekilde requestleri nasıl metod haline dönüştürdüğümüzün detaylarına girmiştim. Burada özetle;

  • her bir request e “Content-Type : application/json” header ı ekliyoruz.
  • Get metodu ile direk olarak verilen base url gittiğimizi Get metodunu kullanarak söylüyoruz.
  • results ve page parametreleri de url de karşılıkları olmadığı için otomatik olarak querystring olarak request url ine eklenecekler.

Bu şekilde bahsettiğmiz url ile haberleşecek interface ide oluşturmuş olduk. gerisi refit e kalıyor.

Tüm bu yazdıklarımızdan sonra bir özetlemek istersek ne şekilde bunları kullanabiliriz ve neler olmuş olur şöyle bir üzerinden geçelim.

Uygulamada şu kodu yazdığımız anda;

IApiRequest<IRandomUserEndpoint>.UserInitiated

dediğimiz de Refit bizim için yazdığımız interface in yaşayan bir httpclient halini üretecek. Bu HttpClient a verdiğimiz Fusillade nin RateLimitedHttpMessageHandler ve ModernHttpClient ın NativeMessageHandler  ları refit oluşturacağı HttpClient ın HttpMessageHandler ları olarak kullanılacak. Yani Refit e oluşturmasını istediğimiz HttpClient nasıl bir haberleşme yağacağını söylüyoruz, bu esnada hangi handlerları kullanmasını istediğimizi söylüyoruz ve sonrasında ortaya Refit, Fusillade ve ModernHttpClient ın bir arada kullanılmış olduğu güzel bir client objesi elimze geçiyor. Ve bunun üzerinden kullanımımıza devam ediyoruz.

Bu post u burada bırakıyorum. Bir sonraki post umda bu serinin son yazısını yani kullanıma Polly e Akavache yi de nasıl dahil edeceğimize bakarak, tamamlamış olmayı umut ediyorum 🙂

Bir sonraki yazımda görüşmek üzere.

Resilient Network Services Bölüm 7 – Xamarin Projemizde Refit, Polly, Akavache, Fusillade ve ModernHttpClient Birlikte Kullanımı

Selamlar,

Bu seri boyunca bahsettiğim bu güzel kütüphaneleri artık iş üzerinde görme vakti geldi 🙂 Tüm bu kütüphanelerin bir xamarin projesinde Resilient Network services oluşturulması için nasıl bir arada kullanıcağımızı göreceğimiz bu yazımızda, kütüphanelerin detaylarını görmek için önceki yazıları da okumanızı öneririm. Buradan başlayabilirsiniz.

Refit, Fusillade, ModernHttpClient, Akavache ve Polly  kütüphanelerinin herbirinin birbirinden farklı ve aynı zamanda aynı işlevi gören özellikleri mevcut.
Öncelikle hangi kütüphaneden hangi özellikleri alıp nasıl bir yapı kuracağımızı ve bunu xamarin projelerinde nasıl kullanacağımıza bakacağız. Sırası ile kütüphanelerden alacağımız özellikler şunla olacak.

  1. Refit: Tüm Api haberleşmesini, tek bir interface altında toplayıp, HttpClient ve HttpMessageHandler yönetimini runtime da bu arkadaşa bırakacağız. Herhangi bir yerde biz HttpClient sınıfı ile ilgilenmeyeceğiz.
  2. Akavache: Api dan gelen responlarımız için tüm objelerimizi Akavache ile sqlite3, lokal veritabanında saklayacağız. Request atmaya ne zaman gitmeli, cache de varsa önce oradan okuma işlemi yada cache de olsa bile cache den sonucu hemen dönüp, yine de arka planda Api ye gidip cache deki dataları yenileme gibi işlemleri akavache ile yapacağız.AKavache de bize performanslı ve kolay bir SQLite yönetimi sunacak
  3. Fusillade: Bu güzel kütüphaneyi requestleri önceliklendirme işlemlerimiz için ve Request Limit işlemi için kullanacağız. Kullanıcı tetiklemesiyle mi birşeyler oldu, bir arka plan request imi atıyoruz, yoksa speculative bir request atıp verdiğimiz sınır boyunca belli bir data mı çekiyoruz bunu söyleyeceğiz.
  4. ModerHttpClient: En basit kullanımı olan bu kütüphanenin amacı zaten belli, daha performanslı http haberleşmesi sağlamak. kendi ardaka kullandığı native framework ler ile, bize sunduğu NativeMessageHandler ile daha performanslı network haberleşmesi sağlayacak.
  5. Polly: Bunu kullanın kullanabildiğiniz kadar 🙂 Çok fazla özelliği olan bu kütüphane de genellikle kullanılacak özellikler, api hanerleşmesinde istediğimiz senaryolara bağlı olduğundan, biz default olarak, Transient yani anlık hatalar için Retry pattern ini requestlerimizde uygulamak için kullanacağız.
    Daha da detaylarını eski yazılarımdan ve kütüphanelerin kendi github repo larından edinebilirsiniz.

Örnek olması açısından public api lardan biri randomuser.me  kullanalım. adrese gittiğinizde api ın neler sağladığını bulabilirsiniz. Biz basit bir get request i ile işe başlayalım. REquest atacağımız adres ;

https://randomuser.me/api/?results=5

Bu adres bize results querys string ile verdiğimiz sayı kadar user geriye dönecektir. Bu user a bağlı birden çok property ve ayrı class lar var. Postman üzerinden yada direk browserdan bu adrese request attığınızda karşınıza çıkacak olan response şu şekilde olacaktır.

Capture.PNG

bu json ın c# tipinde nasıl bir class a karşılık geldiğini anlamak ve yazmak için uzun uzun bakmak yerine sıkça kullandığım jsonutils.com adresine json ı yapıştıralım ve bize bu json olarak aldığımız response C# ile oluşturulmuş class lar olarak versin.

jsonutils.com a gidip aşağıdaki gibi json text alanına json string imizi girdiğimizde istediğimiz isimle ana sınıfı oluşturup buna bağlı sınıflarıda kendisi oluşturuyor.

Capture.PNG

bu endpoint e attığımız request in C# cası jsonutils in bize söylediğine göre tam olarak aşağıdaki gibi;

   public class Name
    {
        public string title { get; set; }
        public string first { get; set; }
        public string last { get; set; }
    }      
 
    public class Coordinates
    {
        public string latitude { get; set; }
        public string longitude { get; set; }
    }

    public class Timezone
    {
        public string offset { get; set; }
        public string description { get; set; }
    }

    public class Location
    {
        public string street { get; set; }
        public string city { get; set; }
        public string state { get; set; }
        public object postcode { get; set; }
        public Coordinates coordinates { get; set; }
        public Timezone timezone { get; set; }
    }

    public class Login
    {
        public string uuid { get; set; }
        public string username { get; set; }
        public string password { get; set; }
        public string salt { get; set; }
        public string md5 { get; set; }
        public string sha1 { get; set; }
        public string sha256 { get; set; }
    }

    public class Dob
    {
        public DateTime date { get; set; }
        public int age { get; set; }
    }

    public class Registered
    {
        public DateTime date { get; set; }
        public int age { get; set; }
    }

    public class Id
    {
        public string name { get; set; }
        public string value { get; set; }
    }

    public class Picture
    {
        public string large { get; set; }
        public string medium { get; set; }
        public string thumbnail { get; set; }
    }

    public class Result
    {
        public string gender { get; set; }
        public Name name { get; set; }
        public Location location { get; set; }
        public string email { get; set; }
        public Login login { get; set; }
        public Dob dob { get; set; }
        public Registered registered { get; set; }
        public string phone { get; set; }
        public string cell { get; set; }
        public Id id { get; set; }
        public Picture picture { get; set; }
        public string nat { get; set; }
    }

    public class Info
    {
        public string seed { get; set; }
        public int results { get; set; }
        public int page { get; set; }
        public string version { get; set; }
    }

    public class User
    {
        public IList results { get; set; }
        public Info info { get; set; }
    }

Bu class ları projemizde Models klasörüne (yoksa bir tane Model adında bir klasör açarak) içerisine koyalım. Diğer bir önz hazırlığımız da Fusillade tarafında bize önyüzde ve ortak kod tarafında yardımcı olması için, PriorityType adında bir enum oluşturalım.

public enum PriorityType
{
   Background,

   Speculative,

   UserInitiated
}

Hazırlığımıza devam edelim. Tüm request tiplerimizi bir arada tutacağımız bir ApiRequest interface i oluşturuyorum. Daha sonra uygulama üzerinden gidecek olan tüm requestleri bu interface i implemente eden ve başka türlü çalışmasını istediğimiz bir şekle çevirmek istersek bu şekilde ilerleek bize fayda sağlıyacaktır.

 public interface IApiRequest
    {
        T Speculative { get; }
        T UserInitiated { get; }
        T Background { get; }
    }

Interface in sadece üç adet readonly propertysi mevcut. Bundan sonra bu Interface i implemente edecek, concrete ApiRequest sınıfımızı oluşturacağız ve Fusillade,Refit ve ModernHttpClient kütüphanelerini kullanmaya başlayacağız.

Bu yazıyı burada bırakıyorum. Hazırlık kısmı olarak biraz fazla uzadı. Buradaki adımları yaptığımızda bir sonraki yazımda asıl implementasyonu benimle beraber siz de yapabilirsiniz.

Bir sonraki yazımda görüşmek üzere.

 

Resilient Network Services Bölüm 3 – Fusillade

Selamlar,

Önceki yazılarımda Resilient Network services kurgusundan ve bu kurguyu yaparken bize çok destek olacak olan kütüphanelerden bahsetmiştim.  En son REFIT ten bahsetmiştik, şimdi sıra geldi Fusillade den bahsetmeye.

Bu da yine mobil ve desktop uygulamalırınızda daha efektif işler yapabilmenizi sağlayan, Volley ve Picasso kütüphanelerinden esinlenerek oluşturulmuş bir C# kütüphanesi. Volley başarılı bir Http haberleşme kütüphanesi android tarafında. Picasso ise Android developer ların olmaz ise olmalardından bir tanesi. Peki bakalım bu Fusillade de bunlardan esinlenerek neler  yapılmış.

Öncelikle hangi ortamlarda bu kütüphaneyi kullanabileceğimizi görelim.

  • Xamarin.Android
  • Xamarin.iOS
  • Xamarin.Mac
  • Windows Desktop apps
  • WinRT / Windows Phone 8.1 apps
  • Windows Phone 8

Bu ortamların hepsinde bu kütüphaneyi kullanmamız mümkün. Kendisi portable bir kütüphane, NetStandard kütüphanesi kullanmaya başlayanlarda rahatlıkla kullanabilirler.

Peki bu kütüphane bize neler sağlar bunlara bir bakalım. Fusillade temelde HttpMessageHandler kümesi diyebiliriz. HttpClient ile yaptığımız requestlerde arka tarafta bu kullanıldığından, Fusillade kullanarak yaptığınız reuestlerin daha iyi test edilmiş senaryolar üzerine kurulu HttpMessageHandler ile çalışmasından dolayı daha verimli ve responsive uygulamalar yazmanızda yardımcı olur. Özetle Fusillade bize 4 temel fayda da bulunuyor.

  • Auto-deduplication of relevant request: Türkçe mealine gelecek olursak bu deduplication özelliğinin bize sağladığı şey şu; örneğin bir mobil uygulamanız var, sosyal medya olsun. Kullanıcıların postlarını aşağıya doğru diziyorsunuz, bir arkadaşınız 3-5 post atmış. Bunları gösterirken yanında profil resmini de göstereceksiniz değil mi? E bu resimde çok büyük olasılıkla uygulamaya gömülü olmayacağına göre network üzerinden istek atıp alacağınız bir resim olucaktır. İşte bu ve benzeri durumlarda, Fusillade birbirine benzer requestler için yalnızca tek bir request atıyor ve dönen result ı tüm instance lar ile paylaşıyor. Bu da bize daha az network trafiği oluşturucağımız için performans artısı olarak geri dönüyor.
  • Request Limiting : Bu özellik bize Fusillade tarafından anlık yapılan istekleri kısıtlama imkanı sağlıyor. Instagram’ı düşünelim, like butonuna sürekli basıp duruyoruz, her seferinde request atmak yerine bu gibi davranışları kısıtlamak istediğimiz durumlarda bu özelliğini kullanabiliriz. Yapılan istekler, Volley default u olarak anlık 4 tane olacak şekilde limitleniyor. Bunun la istediğiniz gibi oynayabilirsiniz tabii ki.
  • Request Prioritization: Bu özellik aslında en çok kullandığım Fusillade özelliklerinden biri. Uygulamanızda bir ekranda bir çok widget olduğunu aynı zamanda bunlar load olurken de uygulama responsive olduğu için kullanıcının aynı zamanda birşeylere basıp kendi birşeyleri tetiklediğini düşünelim. İşte bu gibi durumlarda Fusillade hangi requestleri önceliklendirip hangilerini geri planda bırakabileceğini söyleyebiliyorsunuz.
  • Speculative requests: Bu da yine özellikle mobil uygulamalrda kullanabileceğiniz güzel bir özellik. Örneğin ilan listesi açtınız uygulamanızda, en üstte de 5 adet reklam var, tıklanma olasılığı yüksek ilanlar. İşte Fusillade ye şunu söyleyebiliyorsunuz; 5mb data sınırın var, bu 5 adet reklamın requestlerini speculative olarak yolla, 5mb bulmadığın sürece bunların detaylarını al getir, 3. de 5mb doldu mu, o zaman gerisini getirme. Bu kullanıcıların tıklama olasılıklarını yüksek gördüğünüz senaryolarınızda requestleri önceden belli bir limit verip yollamınıza ve kullanıcı tıkladığında hiç bekletmeden doğruca ilgili cevabı göstermenize yarıyan bir özellik.

Kullanım Şekli

Fusillade yi kullanmaya başlamanın en kolay yolu NetCache  adındaki sınıf. Yukarıda yazdığım birçok özelliği zaten kapsıyor.

public static class NetCache
{
    public static HttpMessageHandler Speculative { get; set; }
 
    public static HttpMessageHandler Background { get; set; }
    public static HttpMessageHandler UserInitiated { get; set; }
}

Bu sınıfı aşağıdaki şekilde HttpClient ile beraber kullanabilirsiniz.Aşağıda ilgili request e atılacak olan isteğin kullanıcı tarafından tetiklendiğini belirtmiş olduk.

var client = new HttpClient(NetCache.UserInitiated);
var response = await client.GetAsync("https://randomuser.me/api/?results=5");
var str = await response.Content.ReadAsStringAsync();

Console.WriteLine(str);

Speculative requestlerin limiti şu şekilde değiştirebiliriz.

NetCache.Speculative.ResetLimit(1048576 * 5/*MB*/);

Offline Desteği

Cache için ben genelde Akavache kullanıyor olsamda, yada primitive tipler için platform spesific taraflardaki SharedPreference ve NSUSerDefaults u kullanıyor olsam da, Fusillade bize responseları cache leme ve offline olarak uygulamayı çalıştırma fırsatı da veriyor. Cache için olan objenizi NetCahce in RequestCache Propertysine set ettiğiniz anda gelen responselar burada cachlenir.

NetCache.RequestCache = new MyCache();

var client = new HttpClient(NetCache.UserInitiated);
await client.GetStringAsync("https://httpbin.org/get");

Daha sonra kullanıcının offline olduğu durumda NetCache ile HttpClient a request in  Offline çalışmasını istediğinizi aşağıdaki gibi söyleyebilirsiniz.

var client = new HttpClient(NetCache.Offline);
await client.GetStringAsync("https://httpbin.org/get");

Tüm kütüphane yi github  repo sundan incelemnizi öneririm.

Bir sonraki yazımda görüşmek üzere.

 

Microsoft Xamarin Istanbul Development Meetup “Xamarin Resilient Network Services Bölüm 1”

Herkese Selamlar,  biraz geç olsa da 25 ekim günü Microsoft Türkiye‘de yaptığımız etkinlikteki konuyla ilgili yazma fırsatı ancak bulabiliyorum. Güzel bir etkinlik günü geçirdik, 3 farklı değerli arkadaşımla beraber aşağıdaki konulara değinmiştik.

• .Net Core ile Dependency Injection (Özgür Kaplan)
Xamarin ile Dependency Injection (Yiğit Özaksüt)
Xamarin ile Resilient Network Services (bunu ben anlattım ve burada da uzunca değineceğim detaylarına.)
C# hakkında doğru bilinen yanlışlar ve performans ipuçları (Cihan Yakar)

Benim anlattığım Xamarin ile Resilient Network Services sunumum ile ilgili proje ve dosyaları buradan inceleyebilirsiniz.

Katılan dinleyici ve konuşmacı tüm arkadaşlara teşekkür ederek kendi konumun detaylarına giriş yapıyorum.

Bu konu ile ilgili aslında yazmak istediğim birkaç blog serisi var. Aslında genel bakış açısını burada belirtip detaylarına diğer blog postlarımda değineceğim.

İlk olarak şu Resilient(Esnek) kelimesinden başlayalım. Ne demek bir yapının esnek olması. Bu aslında şu demek;

  • Kurduğumuz yapı, belli hatalar karşısında nasıl davranacığını önceden bilen, öncelikleri belli ve değiştirilebilir esnek kırılmaz bir yapı olmalı.

Bu yapı, diğer tüm yazılım projelerinde, uygulamayı mümkün olduğunca sağlıklı bir şekilde ayakta tutmak için kullanılan mimari bölümlerin(Ölçeklenebilir olması, esnek olması, hızlı olması, güvenilir olması vs vs..) küçük bir parçası aslında.  Bu sistemin ben yazılım projelerinin olmaz ise olması Networking üzerinde anlattım, çünkü danışmanlıklarımda gördüğüm ve eğitimler de hissettiğim en büyük açık burada mevcut idi.


  using (var client = new HttpClient())
  {
    client.BaseAddress = new Uri("https://randomuser.me/api/");
    var content = await client.GetStringAsync("?results=10&page=1");
    var result = JsonConvert.DeserializeObject<ResponseModel>(content);
  }

Yıkarıda ki kod bloğunu bir bakalım. Birçok projede bir API haberleşmesi için gördüğüm kod bu kadar da kalıyor. Daha üzerine düşünülmüş olanlarda ise bu şekilde bir kullanım generic bir class içerisine yerleştirilmiş ve onun içerisinden haberleşme çağırılıyor oluyor. Fakat içeriği pek de değişmiyor. Peki bu koddaki yanlış nedir? Yada var mıdır?

Benim gördüğüm kadarı ile şöyle;

Koda ilk bakışta bir yanlış gözükmüyor olabilir. Evet derlenir ve çalışır da, hatta herşey iyi giderse response u alıp gerekli çevirme işlemlerini de yapar. Ama işte bu kod bloğunda birçok şey yolunda gider varsayılmış. Http client objesinin static tanımlanmamış olması ve bunun sıkıntılarına başka zaman değineceğim bunu şimdilik göz ardı edelim diğer konulara bakalım.

  • Internette bir sorun olduğunda bu request ne olacak
  • Server dan 500 aldığında request im ne yapmalı,  503 olduğunda ne olmalı.
  • Time out yersem ne yapmalıyım? yeniden göndermeli miyim requesti? Eğer gönderecek isem kaç kere göndermeliyim, ne kadar ara vermeliyim?
  • Response cachlenebilir bir response mu eğer öyle ise bunu da devreye koysam güzel olmaz mı?
  • Bu request uygulama içerisinde gidecek olan diğer requestlere göre bir farkı önceliği var mı?

gibi gibi sorular aklıma geliyor. İşte tüm bu konular üzerinden bir xamarin projesinde kullanmamız ve güzel bir networking altyapısı kurmanız için size 5 farklı ve değerli kütüphaneden bahsedeceğim. Ve bunların hepbirden nasıl uyumlu olarak kullanabiliriz buna değineceğim.

Kütpühaneleri şunlar;

  • Refit: The automatic type-safe REST library for .NET Core, Xamarin and .Net
  • Fusillade: An opinionated Http library for mobile development
  • ModernHttpClientPlatform spesific networking libraries to Xamarin applications
  • Akavache: An Asynchronous Key-Value Store for Native Applications
  • Polly: .Net resilience and transient-fault-handling  library

kısaca açıklamlarını direk kendi github adreslerindeki gibi yazdım kenarlarına. Detaylarına ve örneklerine sırası ile diğer postlarımda başlayacağım. Hepsinden bahsettikten sonra da bir arada bir xamarin projesinde nasıl kullanılırız buna bakacağız.

Bir sonraki yazımda görüşmek üzere.