<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ayşe Nur Bakırcı on Medium]]></title>
        <description><![CDATA[Stories by Ayşe Nur Bakırcı on Medium]]></description>
        <link>https://medium.com/@aysenurbakirci?source=rss-3f2592915aab------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*KWTDhu75iQ8Pc6-j</url>
            <title>Stories by Ayşe Nur Bakırcı on Medium</title>
            <link>https://medium.com/@aysenurbakirci?source=rss-3f2592915aab------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 22:29:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aysenurbakirci/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[EarlGrey ile iOS Uygulamalarına Otomasyon Testleri]]></title>
            <link>https://medium.com/deliveryherotechhub/earlgrey-ile-ios-uygulamalar%C4%B1na-otomasyon-testleri-5d04eedf0bb8?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d04eedf0bb8</guid>
            <category><![CDATA[yemeksepeti]]></category>
            <category><![CDATA[earlgrey2]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[uitest]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Thu, 05 Jan 2023 07:51:50 GMT</pubDate>
            <atom:updated>2023-01-05T07:51:50.110Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*i3ICHFeYv8rpwRuq_hSxbg.png" /><figcaption>Image from <a href="https://www.raywenderlich.com/21020457-ios-unit-testing-and-ui-testing-tutorial">raywenderlich.com</a></figcaption></figure><p>Herkese merhaba, bu yazımda iOS uygulamalarında UI Test yazmak için kullandığımız EarlGrey’den bahsedeceğim. İyi okumalar.</p><h3>UI Test Nedir? Neden kullanılır?</h3><p>Bir uygulama geliştirilirken, her yeni özellik eklendiğinde uygulamaya eklenen bu özelliklerin etkilerini sık sık kontrol etmek isteriz. Ancak çok sayıda ekran ve özelliğe sahip olduğumuz durumlarda, uygulamaya eklenen her yeni özelliği kontrol etmek yorucu olabilir. Arayüz kontrollerinin zorlaştığı durumlarda projeye UI Test ekleyerek bu kontrollerin XCode aracılığıyla yapılmasını sağlayabiliriz.</p><p>Apple, UI test için bize XCTest adlı yerel bir framework sağlar. Bu framework sayesinde UI test metotlarını ekleyerek UI test sınıfları oluşturabilir, UI elemanları ile iletişim kurabilir ve ögelerin kontrollerini sağlayabiliriz. Bu sayede projede yapılan değişikliklerin kullanıcı arayüzünde istemediğimiz durumlara yol açıp açmadığını pratik bir yolla öğrenmiş oluruz.</p><p>Tabii ki her şeyde olduğu gibi UI testlerde de ihtiyacımız doğrultusunda kullanabileceğimiz birden çok yapı mevcuttur. Bu yapılardan bazıları aşağıda belirtilmiştir.</p><h3>UI Test İçin Kullanılabilinecek Yapılar</h3><p>Test framework’leri, verimli bir şekilde testleri yürütmemizi sağlayan araçlardır. Bu framework’ler sayesinde; uygulamaları hızlı ve pratik şekilde test edebilir, test sonuçlarının analizine ulaşabilir ve uygulamayı test ederken kaynak kullanımının daha az olmasını sağlayabiliriz.</p><h4><a href="https://developer.apple.com/documentation/xctest"><strong>XCUITest</strong></a></h4><p>XCTest, Apple’a ait resmi iOS test framework’üdür. Bu yapı ile iOS uygulamasına birim testi, performans testi ve arayüz testi gibi çeşitli testleri uygulayabiliriz. XCUITest ise XCTest’in bir alt sınıfıdır ve iOS uygulamasına arayüz testi yazılmasını sağlar. Bu yapı ile UI testleri kaydedip, kaydettiğimiz testleri çalıştırabildiğimiz için UI test senaryoları oluşturmak diğerlerine göre daha kolaydır.</p><h4><a href="https://github.com/kif-framework/KIF"><strong>KIF (Keep It Functional)</strong></a></h4><p>KIF, iOS uygulamaları için tasarlanmış, açık kaynak bir arayüz test framework’üdür. Bu framework de otomasyon testleri için XCTest target’ını kullanır. Bu sayede doğrudan projeye entegre olabilir. KIF ile oluşturulan testler gerçek hayatta uygulamanın kullanıcı tarafından nasıl kullanılacağını taklit eder.</p><h4><a href="https://github.com/google/EarlGrey">EarlGrey</a></h4><p>EarlGrey, Google tarafından iOS uygulamalarını test etmek için geliştirilmiş, XCTest ve XCUITest ile birleştirilebilir açık kaynak arayüz test framewok’üdür. EarlGrey ile testler yürütülürken, işlemler yalnızca görünür olan ui elemanları üzerinden ilerletilir. Bu sebeple EarlGrey ile oluşturulmuş testlerin daha hızlı ve güvenilir olduğunu söyleyebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-cpGCCBy-ZApVLx6rrMEvQ.png" /></figure><h3>EarlGrey Kullanarak Test Yazmak</h3><p>Github üzerinden EarlGrey deposunu incelerseniz <a href="https://github.com/google/EarlGrey">EarlGrey</a> ve <a href="https://github.com/google/EarlGrey/tree/earlgrey2">EarlGrey2</a> şeklinde iki versiyonun olduğunu görebilirsiniz. Bu versiyonlar arasında birkaç temel farklılık vardır. Bunlar;</p><ul><li>EarlGrey Unit Test Target’ını kullanırken, EarlGrey2 UI Test Target’ını kullanır. Bunun sebebi de EarlGrey2&#39;nin EarlGrey ve XCUITest’in birleştirilerek oluşturulmasıdır.</li><li>EarlGrey unit testlerle birlikte çalıştığı için uygulama ile etkileşime girmemizi sağlayan bir white-box test aracıdır diyebiliriz. Ancak EarlGrey2 UI testler üzerinden çalıştığı için aynı şeyi söyleyemeyiz. Ancak yine de EarlGrey2&#39;de white-box testlerini ilerletmek istersek,EarlGrey2 içerisindeki <a href="https://github.com/google/eDistantObject">eDistantObject</a>’i kullanabiliriz.</li></ul><p>Aşağıdaki kurulum ve örnekler EarlGrey2 kullanılarak oluşturulmuştur. Siz kendi kullanım alanınıza ve ihtiyaçlarınıza göre hangisini kullanacağınızı belirleyebilirsiniz.</p><h4>Kurulumu;</h4><p>1- GitHub üzerinden EarlGrey&#39;i kendi bilgisayarımıza klonlayarak kurulum işlemine başlayabiliriz. Burada versiyon 2&#39;yi kullanacağımızdan versiyon 2&#39;nin bulunduğu <em>earlgrey2</em> branch’ini klonlamalıyız.</p><pre>git clone -b earlgrey2 https://github.com/google/EarlGrey.git</pre><p>2. Klonlama işlemi tamalandıktan sonra, proje dosyasındaki <em>download_deps.sh</em> dosyasını çalıştırarak EarlGrey’in kurulumunu sağlamalıyız.</p><pre>sh Scripts/download_deps.sh</pre><p>3- Bu işlemleri tamamladıktan sonra <em>EarlGrey.xcodeproj</em>’i açıp <strong>AppFramework</strong> ve <strong>TestLib</strong> target’larından build alabildiğimizden emin olmamız gerekiyor.</p><p>4- Bu aşamadan sonra sıra EarlGrey’i UI testlerini yazacağımız projeye eklemeye geldi. Başarılı bir şekilde build aldıktan sonra <strong>EarlGrey.xcodeproj</strong>’u kendi proje dosyamızın altına ekliyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*15WGYn6b1EN9jvKryLL3Fg.png" /></figure><p>Bu adımda, hem kendi projemize ait hem de EarlGrey’e ait tüm target’ları XCode’da görmemiz gerekiyor. Bunları kontrol ederek doğru eklediğinizden emin olabilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i9RDpCqZGW_5PRLLp-dYyw.png" /></figure><p>Şimdi EarlGrey’i projede kullanılabilir hale getireceğiz.</p><p>Bu kısımda EarlGrey’i projeye entegre etmek için uygulamamızın UI Test target’ı üzerinde yapmamız gereken birkaç işlem vardır. Eğer sizin uygulamanızda henüz bir UI Test target’ı yoksa <strong>File &gt; New &gt; Target &gt; UI Test Bundle</strong> seçerek projenize UI Test target’ı ekleyebilirsiniz.</p><p>5- Öncelikle kullanacağımız framework’ü kullanmak istediğiniz herhangi bir proje ile ilişkilendirmemiz gerekiyor. Bu yüzden UI Test target’ında <em>Link Binary With Libraries</em> kısmına <strong>libTestLib.a</strong> kütüphanesini ekleyerek başlayabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LY1YOcLqTh42f7jcqgosWg.png" /></figure><p>6- EarlGrey içerisinde Objective-C sınıfları mevcuttur. Bu sınıfların projemizde oluşturulmasını sağlamak için <em>Other Linker Flags</em> kısmına <strong>-ObjC </strong>eklemeliyiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bnjyKgpEP1dtGvoT9t_h2w.png" /></figure><p>7- -ObjC ayarından sonra <strong>EarlGrey</strong>’in ve EarlGrey içerisindeki <strong>eDistantObject</strong>’in dosya yollarını <em>User Header Search Paths</em> kısmına ekleyerek devam edebiliriz. Bu sayede proje içerisinde kullanacağımız bu yapılara ulaşabileceğiz.</p><pre>$YOUR_PROJECT_DIR/EarlGrey<br>$YOUR_PROJECT_DIR/EarlGrey/Submodules/eDistantObject</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oVeKaeRCXjRs2bHLsQ0Qpg.png" /></figure><p>8- Build Phases’a dönüp, Copy files içerisinde <strong>Absolute Path</strong> seçerek aşağıdaki path’i ekliyoruz.</p><pre>$(TARGET_BUILD_DIR)/…/…/{YOUR_APP_NAME}.app/Frameworks</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a4DtgvNE5Fvh4wtCu24mOQ.png" /></figure><p>9- Bundan sonra testlerde kullanacağımız metotları içeren <strong>EarlGrey.swift</strong> dosyasını projemize eklememiz gerekiyor. Ben indirip eklemek yerine <em>TVSeriesAppUITests</em> içerisine yeni swift dosyası oluşturmayı ve gerekli metotları buraya aktarmayı tercih ettim. Kullanacağımız dosyayı <a href="https://github.com/google/EarlGrey/blob/earlgrey2/TestLib/Swift/EarlGrey.swift"><strong>buradan</strong></a> görüntüleyebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S3AJkcLKZ3q4zWeiPapwOw.png" /></figure><p>10- Header dosyaları Objective-C ile oluşturulmuş yapıları projede swift ile kullanmamızı sağlar. Burada da <em>TVSeriesAppUITests</em> içerisine bir header dosyası eklememiz gerekiyor. Bu dosyayı <strong>File &gt; New &gt; File &gt; Header File </strong>seçerek ekleyebilirsiniz. Bu oluşturduğumuz header dosyasının içerisine <a href="https://github.com/google/EarlGrey/blob/earlgrey2/TestLib/Swift/EarlGreySwiftBridgingHeader.h"><strong>burada</strong></a> bulunan kodları ekleyebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b8_jp8HH54xc0f3pWMnZMA.png" /></figure><p>11- Son olarak Objective-C Bridging Header kısmına da bu eklediğimiz header dosyasının dosya yolunu ekliyoruz. Bu sayede eklediğimiz header dosyasının XCode tarafından kullanılabilmesine olanak tanımış oluruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*13m6UISH82iJK4GAJFk4aw.png" /></figure><p>Biraz uzun sürse de kurulumumuz bitti. Denemek için aşağıdaki testi kullanabilirsiniz. 😃</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/285b5fbaf03b8f0e46125bb527c1b564/href">https://medium.com/media/285b5fbaf03b8f0e46125bb527c1b564/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ruJFuTtQw28p3rKiuKoHWA.png" /></figure><p>Eğer kurulum başarılı bir şekilde tamamlandıysa bu test de başarılı olacaktır.</p><h4>Kullanımı;</h4><p>EarlGrey içerisinde üç ana bileşen mevcuttur;</p><ul><li><strong>GREYMatcher:</strong> Ekranda bir UI elemanının bulunmasını sağlar.</li><li><strong>GREYAction:</strong> UI elemaları üzerinde işlemler yürütür.</li><li><strong>GREYAssertion:</strong> Bir UI elemanının durumunu doğrular.</li></ul><p>Aşağıdaki örneği inceleyecek olursak;</p><pre>EarlGrey<br>    .selectElement(with: &lt;GREYMatcher&gt;)<br>    .perform(&lt;GREYAction&gt;)<br>    .assert(&lt;GREYAssertion&gt;)</pre><ol><li>Kullanılan ilk method test etmek istediğimiz UI elemanını bulur.</li><li>Sonraki adımda bulunan UI elemanı üzerinde istenilen aksiyon gerçekleştirilir.</li><li>Son adımda ise bu UI elemanının son durumu kontrol edilir.</li></ol><p>EarlGrey ile test yazarken kullanacağımız bir diğer bileşen ise <strong>accessibilityIdentifier</strong>’dır. EarlGrey ekranda bulunan UI elemanını bulmak için bu elemanlara verilmiş accessibilityIdentifier’ları kullanır.</p><p>Aşağıdaki örnekte yazıldığı gibi uygulamada bulmak istediğimiz UI elemanına bir id vererek bu id’yi test içerisinde <em>grey_accessibilityID()</em> ile çağırmamız, test yürütülürken bu elemana ulaşmamızı sağlar.</p><pre>homePage.accessibilityIdentifier = &quot;TVSeriesHomePage&quot;</pre><p>Aşağıdaki test örneğinde, TVSeries uygulaması içerisinde popüler dizilerin olduğu sekmeye gidilip açılan dizi listesinde kaydırma yapılabilmesi durumu test edilmiştir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4aef9238bc5c715e6a63918586327466/href">https://medium.com/media/4aef9238bc5c715e6a63918586327466/href</a></iframe><ol><li>İlk adımda EarlGrey <strong>selectElement</strong> metoduna verilmiş ID’ye sahip UI elemanını bulur, sonrasında <strong>assert</strong> ile bu UI elemanının görüntülenip görüntülenmediğini test eder.</li><li>Sonraki aşamada <em>TVSeriesPopularTab</em> ID’sine sahip buton bulunarak perform ile bu butona tıklanması sağlanır. Bu sayede uygulama popüler dizilerin olduğu listeyi görüntüler.</li><li>Son aşamada ise popüler dizi listesinde kaydırma yapılıp yapılmadığı kontrol edilir.</li></ol><p>Buradaki işlemlerin tamamı başarıyla tamamlandığında testimiz başarıyla sonuçlanır. Başarılı bir test sonucundan ise uygulamamızın işlevselliğinin istenildiği gibi olduğunu çıkartabiliriz.</p><p>Okuduğunuz için teşekkür ederim. Umarım faydalı olmuştur. Soru ve önerileriniz için bana ulaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d04eedf0bb8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/earlgrey-ile-ios-uygulamalar%C4%B1na-otomasyon-testleri-5d04eedf0bb8">EarlGrey ile iOS Uygulamalarına Otomasyon Testleri</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS ve Concurrency (Eşzamanlılık)-Operation]]></title>
            <link>https://medium.com/deliveryherotechhub/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-operation-c675f474dfda?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/c675f474dfda</guid>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[yemeksepeti]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Mon, 11 Apr 2022 07:45:30 GMT</pubDate>
            <atom:updated>2022-04-11T07:45:30.340Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9ntwU2VKLgHmJo9jzUT64w.png" /></figure><p>Herkese merhaba, <a href="https://medium.com/yemeksepeti-teknoloji/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-gcd-792173e821f2">önceki yazımda</a> Grand Centra Dispatch yapısını ve nasıl kullanıldığını anlatmaya çalıştım. Burada ise <a href="https://developer.apple.com/documentation/DISPATCH">GCD</a>’nin üzerine inşa edilmiş ve asenkron görevler üzerinde daha fazla etkileşime sahip olmamızı sağlayan <a href="https://developer.apple.com/documentation/foundation/operation">Operation</a> yapısını anlatacağım.</p><h3>Operation</h3><p>Operasyonlar, tek bir görevle ilişkili soyut sınıflardır. Soyut sınıf oldukları için doğrudan kullanılamazlar. Operasyonları, özel alt sınıflar oluşturarak veya BlockOperation gibi sistemde tanımlı olan alt sınıflar yardımıyla kullanabiliriz.</p><p>Operasyonlar, görevlerin güvenli bir şekilde yürütülmesini ve koordine edilmesini sağlar. Bu yapının özellikleri, bağımlılık oluşturulabilmesi, durumlarının takip edilebilmesi ve iptal edilebilmesidir.</p><p>Operasyonlar kullanılırken dikkat edilmesi gereken nokta, oluşturulan bir operasyon nesnesinin yalnızca bir kez çalıştırılabilmesidir. Bu yüzden projelerde, her görev için bir operasyon nesnesi oluşturularak bu nesnelerin OperationQueue’ya eklenmesi tercih edilir.</p><p>Operasyonları yürütmenin bir diğer yolu da <em>start</em> metodudur. OperationQueue kullanmak istemediğimiz durumlarda, operasyonları <em>start</em> metoduyla manuel olarak yürütebiliriz. Ancak start metodu, işlemi o an bulunulan thread’de seri çalıştırdığı için OperationQueue’ya göre sisteme daha fazla yük getirecektir.</p><p>Bir operasyonu iptal etmek istediğimizde ise <em>cancel</em> metodunu kullanabiliriz.</p><h3>Operation Durumları</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*93O_P7wCHgAh1T2JgELyrw.png" /></figure><p>Her operasyonun bir yaşam döngüsü vardır. Yaşam döngüsünün çeşitli bölümlerinde oluşan durumları takip ederek operasyonun ilerleyişi hakkında bilgi sahibi olabiliriz. Bu durumlar;</p><ul><li><strong>isReady:</strong> Operasyonun çalışmaya hazır olduğunu belirten durumdur.</li><li><strong>isExecuting:</strong> isReady durumundaki bir operasyonun durumu, <em>start</em> methodu çağrıldığında veya OperationQueue’ya eklendiğinde <em>isExecuting</em> olur. Bu operasyonun yürütüldüğü anlamına gelir.</li><li><strong>isCancelled:</strong> Operasyon devam ederken, <em>cancel</em> methodu çağrılırsa bu operasyonun <em>isCancelled</em> özelliği <em>true</em> olur. Ancak başlatılan işlem sonlandırılmaz. Tamamlanana kadar devam eder.</li><li><strong>isFinished:</strong> Operasyonun tamamlandığını belirten durumdur. Operasyon iptal edilse de isFinished durumuna geçer.</li></ul><h3>Operation Oluşturmak</h3><h4>— Block Operation</h4><p>BlockOperation, sistemde tanımlı bir operasyon sınıfıdır. Bu yapı karmaşık işlemler içermeyen basit operasyonların oluşturulması için kullanılabilir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7814d7c94780caa3b64d8bf1b7fee90b/href">https://medium.com/media/7814d7c94780caa3b64d8bf1b7fee90b/href</a></iframe><p>Yukarıdaki örneği incelersek;</p><ol><li>Öncelikle BlockOperation kullanılarak yeni bir operasyon oluşturulmuştur.</li><li>Oluşturulan operasyona yeni bir işlem daha eklemek için BlockOperation’ın <em>addExecutionBlock</em> metodu kullanılmıştır. Bu adımdan sonra, elimizde bir operasyon nesnesi ve bu operasyon nesnesinin yürüteceği iki görev vardır.</li><li>Operasyonlar tamamlandıktan sonra, tamamlandığını belirten bir işlem yapmak için <em>completionBlock</em> özelliği kullanılmıştır. CompletionBlock yalnızca operasyonun içerisindeki tüm görevler tamamlandığında çalışır.</li><li>Son olarak bu operasyonun işlenebilmesi için başlatılması gerekir. Burada <em>start</em> metodu yardımıyla operasyon başlatılmıştır.</li></ol><p>Yukarıda oluşturduğumuz yapı çalıştırıldığında aşağıdaki çıktıyı alırız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ojVMv2PhtkDE3ieQjGovig.png" /></figure><h4>— Subclassing Operation</h4><p>Operasyonları BlockOperation ile oluşturup kolay bir şekilde kullanabilsek de, projelerde operasyonları kullanmamızın sebebi karmaşık ve yeniden kullanılabilir işlemleri gerçekleştirmektir. Bu yüzden projelerde operasyonlar genel olarak alt sınıflar oluşturularak kullanılırlar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/882c772957a49f5750c08bdc8e4bb979/href">https://medium.com/media/882c772957a49f5750c08bdc8e4bb979/href</a></iframe><p>Yukarıdaki örneği incelersek;</p><ol><li>StringOperation adında yeni bir alt sınıf oluşturulmuştur. Bu yapı terminale yazı yazdıran basit bir operasyon örneğidir.</li><li>Operasyon nesnesi yürütüldüğünde yapılması gereken işlemler, Operation sınıfından override edilen <em>main </em>metodu içerisine yazılır.</li><li>Main metodu içerisinde yapılacak işlemler oluşturulurken, operasyonun iptal edilip edilmediğini de kontrol edilebilir. Bu kontroller operasyon iptal edildiğinde fazladan işlem yapmaktan kaçınmamızı sağlar.</li><li>Oluşturduğumuz StringOperation sınıfından yeni bir operasyon nesnesi oluşturabilir, bu operasyona da completionBlock ekleyebiliriz. Buradaki yapı, BlockOperation yapısıyla aynıdır.</li><li>Oluşturduğumuz operasyon nesnelerini, OperationQueue’ya ekleyerek operasyonun başlamasını sağlarız. Yukarıda da belirttiğim gibi operasyonlar <em>start</em> metodu çağrılarak veya OperationQueue’ya eklenerek başlatılır. Burada da operasyon, OperationQueue’ya eklenerek başlatılmıştır.</li></ol><p>Yukarıda oluşturduğumuz yapı çalıştırıldığında aşağıdaki çıktıyı alırız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YpaypPVRK2xPJgm9_Mc8Fw.png" /></figure><h3>Operation Queue (Operation Kuyrukları)</h3><p>Bir operasyonun performanslı bir şekilde ilerlemesini sağlayan yapı OperationQueue’dur. GCD’de bulunan DispatchQueue’lar gibi, OperationQueue’lar da operasyonları yürütmek, zamanlanmasını sağlamak ve aynı anda çalışabilecek operasyon sayısını kontrol etmek için kullanılır.</p><p>Operasyon kuyruklarının özelliklerini kısaca listelersek;</p><ul><li>Operasyon kuyrukları varsayılan olarak background QoS değerine sahiptir. Bu sayede kuyruğa eklenen görevler kullanıcı deneyimini etkilemeden çalışır.</li><li>Operasyon kuyruklarına eklenen görevler hazır olma durumlarına göre çağrılır ve işlem bitene kadar kuyrukta kalır. Bu görevler kuyrukta kaldığı için operasyon kuyruğu hafızada korunur. Bu yüzden görevleri tamamlanmamış bir operasyon kuyruğunu askıya almak, memory leak oluşmasına yol açabilir.</li><li>Operasyon kuyruklarıyla çalışırken, aynı anda yapılması gereken görev sayısını <em>maxConcurrentOperationCount</em> özelliği ile belirtebiliriz. Bu özelliğe herhangi bir değer vermezsek operasyon kuyruğu aynı anda sürdürebildiği kadar operasyonu sürdürecektir. Eğer bu özelliğin değerini 1&#39;e eşitlersek operasyon kuyruğu seri bir kuyrukmuş gibi çalışacaktır.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4ae44349cb5408d454a68156fb8e1fff/href">https://medium.com/media/4ae44349cb5408d454a68156fb8e1fff/href</a></iframe><p>OperationQueue’ya hiçbir özellik eklenmediği durumda aldığımız çıktı:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EAeOrjelVABb-6TJfj5w5Q.png" /></figure><p>OperationQueue’nun <em>maxConcurrentOperationCount</em> özelliğinin 1 olduğu durumda aldığımız çıktı:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5rI6T9BeCT7BtiTQLKA14w.png" /></figure><h3>Operation Bağımlılıkları</h3><p>Operation yapısını GCD’den ayıran önemli kısımlardan birisi de operasyonların bağımlılıklarıdır. Birbiriyle,</p><ul><li>Ön koşul işlemi tamamlanmadan bağımlı işlemin başlamaması,</li><li>İlk operasyondan ikincisine veri geçirmek için önce ilk operasyonun tamamlanması</li></ul><p>şeklinde ilişkileri olan operasyonlar arasında bağımlılıklar oluşturabiliriz.</p><p>Operasyon bağımlılıklarını yönetmek için kullanılan iki farklı metod vardır. <em>addDependency</em> metodu operasyona bağımlılık eklemek için kullanılırken, <em>removeDependency</em> metodu eklenen bağımlılığın kaldırılması için kullanılır.</p><p>Birbirine bağımlı operasyonlar oluşturduğumuzda, bir operasyonun bağımlı olduğu tüm işlemler tamamlanmadan operasyon <em>isReady</em> durumuna geçemez. Bu durum işlemler tamamlanmadan operasyonun başlamamasını sağlar. Bağımlılıklar için operasyonun başarılı veya başarısız tamamlanması önemli değildir. Operasyon başlatılmadan önce bağımlı olduğu herhangi bir operasyon başarısız olarak tamamlansa da operasyon yürütülecektir. Eğer bağımlı operasyonların herhangi birinde hata olduğunda diğer operasyonların devam etmemesini istersek, bunu manuel olarak kontrol etmemiz gerekir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/add7df890cd6c469bc5bff4d745fd6e3/href">https://medium.com/media/add7df890cd6c469bc5bff4d745fd6e3/href</a></iframe><p>Yukarıdaki örnekte öncelikle DownloadModelOperation, modeli indirir. Model indirildikten sonra DownloadImageOperation indirilen model içerisindeki resmi indirir. Son olarak eğer resimleri filtrelemek istersek ImageFilterOperation ile indirilen resimler filtrelenir. Göründüğü gibi buradaki tüm işlemler birbiriyle bağlantılıdır. Bu görevler arasında bağımlılık oluşturmak, görevlerin daha sağlıklı ilerlemesini sağlar.</p><p>Proje içerisinde 1. adımı incelediğimizde, downloadImage ile downloadModel arasında bağımlılık oluşturulmuştur. Bu durum, downloadModel tamamlandıktan sonra downloadImage’ın hazır olacağı anlamına gelir. Aynı bağımlılık imageFilter ile downloadImage arasında da oluşturulmuştur.</p><p>2. adımda ise imageFilter ile downloadImage’a arasındaki bağımlılık kaldırılmıştır.</p><p>Üç operasyonun da birbirine bağlı olduğu durumda aldığımız çıktı;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iNTiJ8GRselT4hvY7tbyAw.png" /></figure><p>imageFilter’ın bağımlılığı kaldırıldığında, herhangi bir operasyonun tamamlanmasını beklemeyeceği için diğerlerinden önce tamamlanacaktır. Bu durumda alacağımız çıktı;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R2dsyOjcCjnTEdyAGdAiGA.png" /></figure><p>Son olarak, operasyon yapısını daha iyi örnekleyebilmek için daha önce oluşturduğum TVSeries uygulamasından birkaç örnek göstereceğim. 🙃TVSeries, <a href="https://www.themoviedb.org/">tmdb</a>’den dizileri alarak görüntülenmesini ve bu diziler hakkında ufak bilgilere ulaşmamızı sağlayan basit bir uygulamadır. Bu uygulama içersinde operasyonlar, internetten aldığımız dizilerin afişlerinin indirilmesini sağlamaktadır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a7ec2bf1aa485dc04be370d3e18237e/href">https://medium.com/media/4a7ec2bf1aa485dc04be370d3e18237e/href</a></iframe><p>İlk olarak işlemleri yaparken kullanacağımız ImageRecord sınıfı oluşturulmuştur. Bu sınıf, internetten aldığımız modeli, kullanıcıya göstereceğimiz UIImage’ı ve bu UIImage’ın yüklenme aşamalarını gösteren bir durum değişkeni içermektedir.</p><p>Bu model ile internetten aldığımız dizi modeli içerisinde bulunan imagePath’i, bir UIImage’a dönüştürüp kullanıcının görüntüleyebilmesini sağlayacağız.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0817fcd71e22e3736b85c9346b60851f/href">https://medium.com/media/0817fcd71e22e3736b85c9346b60851f/href</a></iframe><p>Yukarıdaki örnekte ise, eğer seçilen index’teki model’in durumu <em>ready</em> ise yani model var ve yüklenmeye hazırsa, operasyon nesnesi oluşturup bu operasyon nesnesini OperationQueue yardımıyla yürütürüz. Bu yürütmenin sonucunda, ImageRecord içerisindeki model’den imagePath alınır ve bu path ile yüklenen afiş yine ImageRecord içerisindeki UIImage’a eşitlenir. Bu sayede kullandığımız ImageRecord modelinden direkt kullanacağımız UIImage’a erişebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b83e2b194194bb42a190448c0a84ffb9/href">https://medium.com/media/b83e2b194194bb42a190448c0a84ffb9/href</a></iframe><p>Projeyi ayrıntılı incelemek isterseniz aşağıdaki linkten ulaşabilirsiniz. 🙂</p><p><a href="https://github.com/aysenurbakirci/TvSeriesApp">GitHub - aysenurbakirci/TvSeriesApp: VIPER design pattern</a></p><p>Okuduğunuz için teşekkür ederim. Umarım faydalı olmuştur. Soru ve önerileriniz için bana ulaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c675f474dfda" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-operation-c675f474dfda">iOS ve Concurrency (Eşzamanlılık)-Operation</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS ve Concurrency (Eşzamanlılık)-Thread Safety]]></title>
            <link>https://medium.com/deliveryherotechhub/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-thread-safety-6ca4c32e928f?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ca4c32e928f</guid>
            <category><![CDATA[yemeksepeti]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Tue, 08 Mar 2022 10:41:54 GMT</pubDate>
            <atom:updated>2022-03-08T10:41:54.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_xUmd_xEVqH6_k-IALtcRg.png" /></figure><p>Concurrency ile çalışmaya başladığımızda bilmemiz gereken en önemli konulardan birisi thread safety konusudur. Concurrency ile birlikte birden çok thread ve bu thread’ler üzerinde ilerleyen birden çok görevle uğraşmaya başlarız. Bu işler doğru takip edilmediğinde doğal olarak bize sorun çıkartır. Concurrency ile daha hızlı ve kesintisiz bir uygulama oluşturmaya çalışırken, kendimizi çıkılmayacak bir durum içerisinde bulabiliriz. Kaçınmamız gereken bu durumlardan bazıları aşağıda anlatılmıştır.</p><h4>Race Condition</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*S8Them4vSu9h2bgcXT6o0Q.png" /></figure><p>Elimizdeki bir değişkene, birden fazla thread’in aynı anda erişimi olduğunda karşımıza çıkabilecek bir durumdur. Yukarıdaki örneği incelersek; başlangıç değeri 1 olan bir değişkenin değeri, farklı thread’ler üzerinden iki kez arttırılmaya çalışılmıştır. İlk thread henüz yeni değeri değişkene yazmadan ikinci thread değişkenin değerini 1 olarak okuduğu için bu iki işlemin sonucunda yeni değerimiz 3 olması gerekirken 2 olarak kalmıştır.</p><p>Bir değişkenin değerini birden fazla thread kontrol ediyorsa, karışıklık olmaması için gelen işlemleri sıraya alabilir ve race condition oluşmasını engelleyebiliriz. İşlemleri sıraya almamızın en kolay yöntemi ise seri kuyruk kullanarak bu değişkene yapılan işlemleri sırayla yaptırmak olacaktır.</p><h4>Deadlock</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*34Y64JW8tHr_CZ-lmPU1Qg.png" /></figure><p>Sync, wait, semafor gibi görevleri bekleten yapıları kullanıyorsak deadlock oluşmasına sebep olabiliriz. Bu durumda iki farklı görev birbirini engeller veya birbirini bekler. Sonuç olarak thread’ler sonsuza kadar bekleme sürecine girerler ve thread’de bulunan diğer görevler gerçekleşemez. Bu durumu daha iyi anlamak için aşağıdaki örneği inceleyebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZqEx2ctnbAwGE8MGewdh3g.png" /></figure><p>Bu örnekte ilk görev tamamlandıktan sonra ikinci görevin başlatılması gerektiği zaman deadlock oluşur. Bunun nedeni seri kuyruklarda bir görevin önceki görev bittikten sonra başlatılabilmesidir. Örneğe baktığımızda, 2. görevin başlatılabilmesi için, 1. görev tamamlanmalıdır. Ancak 2. görev, 1. görevin içinde olduğundan 1. görevin tamamlanmış olabilmesi için 2. görevin de tamamlanmış olması gerekir. Bu çakışma deadlock oluşmasına ve uygulamanın çökmesine sebep olur.</p><h4>Priority Inversion</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*B6aklsCR_V5uc_SR66TCyg.png" /></figure><p>Bir kuyruğa, kuyruğun QoS(<a href="https://developer.apple.com/documentation/dispatch/dispatchqos">Quality of Service</a>) değerinden daha yüksek seviyeli bir görev gönderdiğimizde priority inversion oluşur ve kuyruğun QoS değeri görevin değerine yükseltilir. Bu yeni değer kuyrukta bulunan tüm görevlerde geçerlidir. Kuyruğun QoS değeri yükseldiğinde, düşük öncelikli olarak planladığımız görevleri daha yüksek öncelikle yaptığımız için düşük önceliğe sahip görevlerin önemli görevlerimizin önüne geçmesine sebep olabiliriz. Bu durum oluştuğunda görevler doğru sırayla yapılmayabilir veya uzun süren background görevleri yüksek öncelikle yapılarak kullanıcıyı etkileyebilir. Bu yüzden görevlerin önceliklerine dikkat ederek, doğru kuyruklara göndermeliyiz.</p><p>Thread safety için asenkron görevlerle birlikte kullanabileceğimiz bazı sınırlamalar da mevcuttur. Bu sınırlamalar görevleri doğru şekilde ilerletebilmemiz için bize yardımcı olur.</p><h4>Thread Barrier</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*sXkSMFVyGMLM9saeTmCCQg.png" /></figure><p>Asenkron bir şekilde ilerlerken, görevlerin devam etmesi için bir görevin tamamlanması gerekebilir. Örneğin yukarıdaki örnekte yapılması gereken 6 tane işimiz var. Bu kuyrukta ilk 3 görev bittikten sonra 4. görevin yapılması ve 4. görevden sonra diğer görevlerin devam etmesi gerekiyor. Bu gibi durumlarda göreve bir flag ekleyerek görevlerin istediğimiz şekilde ilerlemesini sağlayabiliriz. Bu durumu bir örnekte inceleyecek olursak;</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/45c5e5a041730a7cb59061187846d016/href">https://medium.com/media/45c5e5a041730a7cb59061187846d016/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/1*GtGXBi90aIsGGtOQGFHFrA.png" /></figure><p>Yukarıdaki örneği incelediğinizde 🍍 görevine bir bariyer eklediğimizi farketmişsinizdir. Sonuçta da gördüğünüz gibi 🍍 görevinin öncesindeki tüm görevler tamamlandıktan sonra 🍍 görevi başlatılır ve tamamlanır. 🍍 görevinden sonra kuyruk tekrar asenkron şekilde çalışmaya devam eder.</p><h4>Semaphore</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*HNN2f8X725hEv36ZT7M_sg.png" /></figure><p>Semaforları, elimizde aynı anda yapabileceğimiz çok fazla iş olduğunda bu işleri parçalar halinde yapmak için kullanabiliriz. Örneğin, yapmamız gereken 15 gibi fazla sayıda görev olduğunu düşünelim, bu görevlerin aynı anda yapılması yerine aşama aşama, 2 veya 3 gibi küçük sayılarda görev grupları halinde ilerlemesini istediğimiz durumlarda semaphore’ları kullanabiliriz.</p><p>Thread Barrier için yaptığımız örneği biraz değiştirerek semaphore’lara uygun hale getirip inceleyelim. 🙂</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/68110f80538cfaccb13130776d9d2f6d/href">https://medium.com/media/68110f80538cfaccb13130776d9d2f6d/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/1*PxWe-zdWm8vnkPsRU4vDOA.png" /></figure><p>Semaphore’u oluştururken verdiğimiz başlangıç değeri aynı anda kaç adet görevi devam ettirmek istediğimizi temsil eder. Yukarıdaki örnekte verdiğimiz 1 başlangıç değeri semaphore sayacına vereceğimiz başlangıç değeridir. Peki semaphore sayacı ne? Bunları nasıl kontrol ediyoruz? Hepsinin cevabı wait ve signal methodlarında. 🙂</p><p>Semaphore’ları ilerletirken kullanmamız gereken iki farklı method mevcuttur. Bunlar;</p><ul><li><strong>signal(): </strong>Signal, görevi tamamlandığında çağrılmalıdır. Signal methodu bizim semaphore sayacını 1 arttırmamızı sağlar. Bu da semaphore’da bir görev için yer açıldığı anlamına gelir.</li><li><strong>wait():</strong> Wait, bir göreve başlamadan önce çağrılmalıdır. Semaphore’a yeni bir göreve başlayacağımızı wait ile belirtiriz. Wait methodu da semaphore sayacını 1 azaltmamızı sağlar.</li></ul><p>Yukarıdaki örnekte semaphore sayacının başlangıç değeri 1 verilmiştir. Bu aynı anda iki göreve izin verir. İlk görevi başlattığımızda <em>wait</em> methodu çağrılır, bu sayede sayaç 1 azalır ve 0 olur. Bir görevi daha başlattığımızda ise sayaç 0&#39;dan daha küçük bir değer alır ve kuyruk bu görevlerden birisi tamamlanana kadar donar. Görevlerden birisi bitip <em>signal</em> methodu çağrıldığında ise semaphore sayacı 1 arttırılır ve semaphore’da bir görev için boş yer açılır. Bu boşluk bir sonraki görevle doldurulur ve aynı anda maksimum iki görev ilerletilecek şekilde görevler tamamlanmaya devam eder.</p><p>Bir önceki yazımda concurrency konusundan bahsetmiştim. Eğer incelemek isterseniz <a href="https://medium.com/yemeksepeti-teknoloji/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-gcd-792173e821f2">buradan</a> ulaşabilirsiniz. Okuduğunuz için teşekkür ederim. Yorum ve önerilerinizi benimle paylaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ca4c32e928f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-thread-safety-6ca4c32e928f">iOS ve Concurrency (Eşzamanlılık)-Thread Safety</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS ve Concurrency (Eşzamanlılık)-GCD]]></title>
            <link>https://medium.com/deliveryherotechhub/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-gcd-792173e821f2?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/792173e821f2</guid>
            <category><![CDATA[yemeksepeti]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Wed, 02 Feb 2022 12:57:44 GMT</pubDate>
            <atom:updated>2022-02-02T12:57:44.655Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/679/1*ISclDkJQ2cymWZpg0-KrqQ.png" /></figure><p>Herkese merhaba, bu yazımdaki konumuz Apple dökümanlarında <a href="https://developer.apple.com/documentation/swift/swift_standard_library/concurrency">Concurrency</a> olarak gördüğümüz eşzamanlılık. Bu konunun benim gibi mobil uygulama geliştirmeye yeni başlayan kişilerin henüz tanışmadığı ama öğrenince de neden öğrenmemişim diyeceği bir konu olduğunu düşünüyorum. En azından benim için öyle oldu.🙂</p><p>Yazıya başlarken temel olarak eşzamanlılığın ne olduğuna bakmak yazıyı anlamamızı kolaylaştıracaktır. Bir uygulama düşünelim, bu uygulamaya işleri aynı anda yapabilme yeteneğini kazandırdığımızda bu uygulamanın işlerini eşzamanlı olarak ilerletmiş oluruz. Yani kısaca eşzamanlılık aynı anda birden fazla işi yapabilme yeteneğidir. Uygulamamız işleri aynı anda yürüttüğünde daha hızlı yanıt verebilir ve kullanıcı için kesintisiz bir uygulama deneyimi oluşturmamızı sağlar.</p><p>Peki eşzamanlılığı nasıl sağlıyoruz? Belki thread’leri duymuşsunuzdur. Thread’leri işlerimizi üzerinde ilerlettiğimiz iplikçikler gibi düşünebiliriz. Kullandığımız cihazda çekirdek sayısına bağlı olarak aynı anda kullanabileceğimiz birden fazla thread mevcuttur. Bu threadleri ve üzerinde yürüttüğümüz işleri kontrol ederek eşzamanlılığı sağlayabiliriz. Burada thread’leri yönetmek derken korkmaya hiç gerek yok, uygulama içerisinde direkt thread’lerle uğraşmayacağız.🙂 Apple belli API’lar ile bunu bizim için oldukça kolay hale getirmiş zaten.</p><p>Uygulamanızın çalışmasını birden çok iş parçacığına bölmenin birçok avantajı vardır. Bunlar;</p><ul><li><strong>Daha hızlı yürütme:</strong> Görevleri farklı iş parçacıklarında yürüterek, görevlerin birbirinden bağımsız ve daha hızlı şekilde tamamlanmasını sağlayabiliriz.</li><li><strong>Duyarlılık:</strong> Arka planda gerçekleşen işleri main thread dışında bir thread’de yaparak kullanıcının yaşayacağı donma gibi sorunları en aza indirebiliriz.</li><li><strong>Optimize edilmiş kaynak tüketimi:</strong> İş parçacıkları, işletim sistemi tarafından optimize edilmiştir. Bu yüzden uygulamanın kaynak tüketimi konusunda bize yardımcı olabilir.</li></ul><p>Sıra geldi bu eşzamanlılığı nasıl gerçekleştirebileceğimiz kısmına.🙂Eşzamanlılık için kullanabileceğimiz iki yapı mevcuttur. Bunların en çok kullanılanı GrandCentralDispatch yani GCD, diğeri ise Operation’lardır. Aslında yapılan işlemlerin temeline baktığımızda Operation da GCD’nin soyutlanmış halidir. Biz Operation ile çalıştığımızda arka planda dolaylı olarak GCD ile çalışmış oluruz. Ancak oluşturulması ve üzerinde yaptığımız işlemler ayrıntılı olduğu için ayrı bir başlık olarak ele alınmaktadır.</p><h3>GrandCentralDispatch (GCD)</h3><p>Bir uygulamanın üzerinde çalıştığı çok çekirdekli donanımdan yararlanarak eşzamanlı çalışmak istediğimizde aklımıza ilk olarak GCD gelmelidir. GCD içerisinde belirli özelliklere sahip FIFO (First In First Out) kuyruklarını içerir. Bu kuyruklara görevleri eklediğimizde, sistem bizim için thread’lerin yönetilmesini sağlar.</p><h4>DispatchQueue</h4><p>GCD ile iletişim kurarak farklı threadler ile çalışabilmek için öncelikle DispatchQueue oluşturmamız gerekir. Bir kuyruk oluşturup görevleri bu kuyruğa atarak yürütmeye çalıştığımızda, sistem gerekli thread’leri oluşturarak görevlerin farklı thread’ler üzerinde yürütülmesini sağlayacaktır. Proje içerisinde projenin kendine ait farklı özelliklerde dispatch queue’ları bulunur. Kullanılabilir kuyruklar yalnızca önceden tanımlanmış kuyruklarla sınırlı değildir. Eğer istersek kendimiz de farklı kuyruklar oluşturabiliriz. Ancak dikkat etmeliyiz, donanımın aynı anda çalıştırabileceği thread sayısı sınırlıdır. Bu yüzden çok fazla thread oluşturmamız uygulamayı iyi yönde etkilemeyecektir.</p><h4>DispatchQueue Oluşturmak</h4><p>DispatchQueue ile kuyruk oluştururken öncelikle belirlememiz gereken özellik bu kuyruğun seri (serial queue) mi yoksa eşzamanlı (concurrent queue) mı olması gerektiğidir. Seri kuyruklar tek bir thread’e sahip olabiliyorken, eşzamanlı kuyruklar farklı sayılarda (donanımın izin verdiği kadar) thread’lere sahip olabilir. Bunları tabii ki ihtiyaçlarımıza göre belirliyoruz.🙃</p><h4><strong>— </strong>Seri Kuyruk <strong>(</strong>Serial Queue<strong>) Oluşturmak</strong></h4><p>Yukarıda da bahsettiğim gibi seri kuyruk olarak adlandırdığımız kuyruklar yalnızca tek bir thread’e sahip olan kuyruklardır. Tek bir thread’e sahip olduğu için de aynı anda yalnızca bir görevin başlatılmasına izin verebilir.</p><p>Seri kuyruklara verebileceğimiz en önemli örnek Main Queue’dur. Main queue, uygulama başlatıldığında otomatik olarak oluşturulan ve uygulamanın UI işlemleri gibi büyük öncelik taşıyan görevleri ilerleten bir seri kuyruktur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E3CoS703XiQyjJzCOS7usw.png" /></figure><p>Seri bir kuyruk üzerinde ilerletmemiz ve ana kuyruğu etkilememesi gereken işlemlerimiz olduğunda DispatchQueue ile yeni bir seri kuyruk oluşturabiliriz. Seri kuyruk oluştururken dikkat etmemiz gereken tek nokta kuyruğa verilen <em>label</em> değerinin benzersiz olmasıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xOdPa94JDxRaHrf1c7okCA.png" /></figure><h4><strong>— </strong>Eşzamanlı Kuyruk <strong>(</strong>Concurrent Queue<strong>) Oluşturmak</strong></h4><p>Birden fazla thread’e sahip olduğu için aynı anda birçok görevi ilerletebilen kuyruklar eşzamanlı kuyruklardır. Uygulama içerisinde var olan eşzamanlı kuyrukları kullanmak istediğimizde global kuyrukları kullanabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QFKfUysQNP3ymJTqgu_taQ.png" /></figure><p>Eğer yapacağımız görevler için özel bir kuyruk oluşturmak istersek DispatchQueue ile yeni bir kuyruk oluşturabiliriz. Eşzamanlı kuyruk oluşturmak istediğimizde seri kuyruklardan farklı olarak <em>attributes</em> değerini .concurrent olarak belirtmemiz gereklidir. Eğer <em>attibutes</em> değerini vermezsek, bu değerin varsayılan olarak bize seri kuyruk oluşturur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hAzfUw_L2BS76Aq_sluRpA.png" /></figure><h4>Oluşturduğumuz DispatchQueue’ları Kullanmak</h4><p>Thread’leri, bu thread’lerin kuyruklarla olan ilişkisini, seri ve eşzamanlı kuyrukların farklarını ve bunların nasıl oluşturulduğunu inceledik. Sıra oluşturduğumuz bu kuyrukları nasıl kullanacağımızı öğrenmeye geldi. Ancak bu kuyrukları nasıl kullanacağımıza bakmadan önce anlamamız gereken iki önemli konu var. Bunlardan ilki QoS değerleri diğeri ise Senkron ve Asenkron kavramlarıdır.</p><h4>— Quality Of Services (QoS)</h4><p>Kuyruklar ile çalışırken bu kuyrukların veya görevlerin hizmet kalitesini tanımlayabiliriz. Bu yapı sayesinde görevlere öncelikler vererek kaynakların uygun görevlere ayrılmasını, uygulamanın daha duyarlı olmasını ve pil tasarrufu yapabilmeyi sağlayabiliriz. Kullanabileceğimiz altı farklı QoS değeri vardır.</p><ul><li><strong>.userInteractive: </strong>Kullanıcının doğrudan etkileşim halinde olduğu UI ve animasyonlar gibi işlemlerde kullanılması önerilir. Bu kuyrukta ilerletilen görevler anında tamamlanabilecek görevler olmalıdır.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f979be2cbf05168cc3d0d5372021ea9/href">https://medium.com/media/6f979be2cbf05168cc3d0d5372021ea9/href</a></iframe><ul><li><strong>.userInitiated: </strong>Kullanıcı ile bağlantılı olduğu için hemen gerçekleşmesi gereken ancak eşzamanlı da ilerletilebilinen görevlerde kullanılması önerilir. Örneğin local veritabanından veri okumamız gerektiğinde kullanabiliriz. Bu kuyruktaki görevler en fazla birkaç saniye sürecek görevler olmalıdır.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e7aee43fb36675f77f93949e960bac1a/href">https://medium.com/media/e7aee43fb36675f77f93949e960bac1a/href</a></iframe><ul><li><strong>.default: </strong>Kullanıldığında bir QoS değeri tanımlanmamış olarak varsayılır ve işlem önceliğine sistem karar verir. Sistem her şeyi planlayabiliyorken bu seçimi sisteme bırakmak ne kadar doğru görünse de default kullanımı her zaman doğru bir yaklaşım olmayacaktır. Çünkü görevleri yürütürken belirlediğimiz öncelik görevlerin doğru çalışabilmesi için önemlidir. Beklediğimiz önceliği sistem vermezse bu görevlerin yürütülmesinde sorun oluşturabilir.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/06b45d840c774b1a0d1e1a738ffe61f6/href">https://medium.com/media/06b45d840c774b1a0d1e1a738ffe61f6/href</a></iframe><ul><li><strong>.utility: </strong>Genellikle uzun sürebilecek hesaplamalar, sürekli veri beslemeleri gibi devam eden işlemlerde kullanılır. Bu önceliğe sahip kuyruklar üzerinde görevler ilerlerken sistem performans ve enerji verimliliğini dengede tutmaya çalışır. Bu kuyruktaki görevlerin süresi birkaç dakikayı geçmemelidir.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c91669651abe01b6b2e27354d5b059ba/href">https://medium.com/media/c91669651abe01b6b2e27354d5b059ba/href</a></iframe><ul><li><strong>.background: </strong>Kullanıcıyı doğrudan etkilemeyen, arka planda gerçekleşen, veritabanı bakımı, uzak sunucu senkronizasyonu gibi işlerde kullanılması önerilir. Sistem bu kuyruktaki görevler ilerlerken enerji verimliliğine öncelik verir. Bu kuyruğa eklenen görevler dakikalarca sürebilecek uzun görevlerdir.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6c5b73f0314a4c67c8f485368e7de4f8/href">https://medium.com/media/6c5b73f0314a4c67c8f485368e7de4f8/href</a></iframe><ul><li><strong>.unspecified: </strong>Herhangi bir QoS bilgisinin olmadığını temsil eder. QoS bilgisinin olması gerektiği yerlerde kullanılması tavsiye edilmez.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/72fa5e4c89b9f9c6e4d5f6838791ca12/href">https://medium.com/media/72fa5e4c89b9f9c6e4d5f6838791ca12/href</a></iframe><p><strong>NOT: </strong>Kuyrukları QoS değerini belirterek oluşturabiliriz. Ancak kuyrukların QoS değeri her zaman belirttiğimiz seviyede kalmayacaktır. Eğer bir kuyruğa kuyruğun QoS seviyesinden daha yüksek seviyeli bir görev gönderirsek, görevin yürütüldüğü kuyruğun QoS değeri sistem tarafından görevin QoS değerine yükseltilir. Bu yalnızca belirtilen görev için geçerli değildir. Sonrasında gelen görevler de kuyruğun güncel QoS değerine göre yürütülürler.</p><h4>— Senkron (Synchronous) ve Asenkron (Asynchronous) Görevler</h4><p>Oluşturduğumuz kuyruklara görevler ekleyip bu görevlerin yürütülmesini sağlarken, yürüttüğümüz görevlerin senkron mu yoksa asenkron mu ilerleyeceğini de belirtmemiz gerekir.</p><ul><li><strong>Senkron Görevler: </strong>Senkron çalışan görevler birbirini bekleyen görevlerdir diyebiliriz. Bir görevi bir kuyruğa senkron olarak gönderdiğimizde, kuyruktaki diğer görev başlatılmadan önce devam eden senkron görevin tamamlanması beklenir.</li><li><strong>Asenkron Görevler:</strong> Asenkron çalışan görevler senkron görevler gibi birbirini beklemez. Bu görevler kuyrukta başlatıldıktan sonra farklı thread’lerde çalışabilir. Bir diğer görevin çağrılabilmesi için, başlatılan görevin bitmesine gerek yoktur.</li></ul><blockquote>Sürekli karşılaştığımız soru: Asynchronous (asenkronluk) ve concurrency (eşzamanlılık) aynı şey midir?</blockquote><blockquote>İlk bakışta ikiside birden fazla işlemin aynı anda yapılmasını sağlıyormuş gibi görünse de kuyrukları farklı noktalarda etkiler. Senkron veya asenkron olmak, bir görevi yürüttüğümüzde kuyruğun bir sonraki görevi yürütmeden önce devam eden görevi bekleyip beklememesi gerektiğini belirtirken, seri veya eşzamanlı olmak kuyruğun sahip olabileceği thread sayısının bir veya birden fazla olacağını belirtir.</blockquote><p>İşte şimdi sıra geldi oluşturduğumuz bu seri kuyrukları kullanmaya. :)</p><h4>— Seri Kuyrukları Kullanmak</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/150db087ee0af451409f3a4691f93ead/href">https://medium.com/media/150db087ee0af451409f3a4691f93ead/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VxN_ibNLgrc7jmF0fo4IWw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FCEQgo_ZJFmm77wqpdpP6A.png" /></figure><p>Bu örneği incelediğinizde, dikkatinizi çeken kısım seri kuyruk kullanmamıza rağmen asenkron görevlerin farklı thread’lerde olduğu olabilir. Burada asenkron görevin mantığı gereğince görev başlatıldıktan sonra farklı thread’e devredilir. Aynı kuyruk üzerinde ilerleyen asenkron görevler farklı thread’lerde olsa da, kuyruk üzerinde bulunan bir iş bitmeden diğer iş başlamayacaktır.</p><p>Aynı zamanda kuyruğa senkron görev gönderdiğimizde yalnızca mevcut görev ilerletilirken, asenkron görev gönderdiğimizde kuyruktaki görevle birlikte kuyruğa dahil olmayan görevin de yürütüldüğünü farketmişsinizdir. Bu da seri kuyruklardaki senkron ve asenkron ilerleyişin farkını bize gösterir.</p><h4>— Eşzamanlı Kuyrukları Kullanmak</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b47068ec6957d605c3abf7c23a67db69/href">https://medium.com/media/b47068ec6957d605c3abf7c23a67db69/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*plozr7fFszEOmDK5gjytdQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nrL9usZnTEo-rEIlGAOQpg.png" /></figure><p>Benim düşünceme göre, eşzamanlı kuyruklardaki senkron ve asenkron ilerleyişi seri kuyruklara göre daha anlaşılır. Eğer görevlerin beraber ilerlemesi bizim için bir sorun oluşturmayacaksa eşzamanlı kuyruklara asenkron görevler göndererek görevlerin daha hızlı ilerlemesini sağlayabiliriz. Ancak bu eşzamanlı kuyrukta bitmesini beklememiz gereken bir görev olursa, bu görevi senkron şekilde kuyruğa göndererek görev bittikten sonra diğer işlemlerin devam etmesini sağlayabiliriz.</p><h4>DispatchWorkItem</h4><p>Yukarıdaki örnekleri incelediğinizde farketmişsinizdir. Kuyruklara görevleri sync veya async methodlarında bulunan closure ile gönderiyoruz. Ancak bunun tek yolu bu closure’ın kullanımı değildir. DispatchWorkItem kullanarak bu kuyruklara görevler gönderebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/98118a4fd49492b41bc886f0454e67e1/href">https://medium.com/media/98118a4fd49492b41bc886f0454e67e1/href</a></iframe><p>DispatchWorkItem’lar, görevleri oluşturmak dışında görevler üzerinde daha fazla kontrole sahip olmamızı da sağlar. Örneğin bir görevi iptal etmemiz veya bir diğer görev tamamlanana kadar bekletmemiz gerekebilir. Bu gibi durumlarda dispatchWorkItem’lar ile kullanabileceğimiz methodlar mevcuttur.</p><ul><li><strong>Notify: </strong>Bir dispatchWorkItem ile ilerlerken, bu görevden hemen sonra başlaması gereken bir görevimiz olduğunda bunu notify methodu ile belirtebiliriz.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f04e91453dd576bf2e2ef8975086002/href">https://medium.com/media/4f04e91453dd576bf2e2ef8975086002/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wSiQZqZkOdiVFG305-QFOg.png" /></figure><ul><li><strong>Cancel: </strong>Bir dispatchWorkItem’ın yürütülmesini iptal etmemiz gerektiğinde cancel metodunu kullanabiliriz. Eğer görev henüz başlamamışsa görev yürütülmez, devam eden bir görevi iptal edersek görevin isCancelled özelliği <em>true</em> olur. Devam eden bir görevi iptal ettiğimizde görev durdurulmaz, tamamlanana kadar yürütülür.</li><li><strong>Wait: </strong>Bir görevi bekletmek için kullanabiliriz ancak görevi bekletmek senkron ilerleyen bir işlem olduğundan görevin bulunduğu kuyruğu bloke edecektir. Yani main queue üzerinde kullanılmaması gerekir.</li></ul><h4>DispatchGroup</h4><p>Görevlerlerle beraber bu görevleri ekleyebileceğimiz DispatchGroup’lar da mevcuttur. Birbirleriyle bağlantılı birden fazla görevimiz varsa bunlar DispatchGroup’lar aracılığıla yürüterek görevler üzerinde daha fazla kontrolümüz olmasını sağlayabiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/afcf3f33926c39571e77af377d6be297/href">https://medium.com/media/afcf3f33926c39571e77af377d6be297/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*29XX6Qq7M8y-DJrI3ikqGg.png" /></figure><p>Yukarıdaki örneği incelediğimizde iki farklı görevi bir gruba dahil ederek ilerlettik ve görevler üzerinde bazı kontrolleri denedik.</p><ul><li><strong>Wait:</strong> DispatchWorkItem’da da olduğu gibi grubun beklemesini sağlar. Yukarıdaki örneği inceleyecek olursak, wait ile grup 4 saniye bekletilerek bu süre içerisinde işin bitip bitmediği kontrol edilir. Süre geçtikten sonra iş durdurulmaz, yalnızca belirtilen sürede işin bitip bitmediğini kontrol etmiş oluruz. Burada dikkat etmemiz gereken nokta wait methodunun senkron ilerleyen bir method olduğunu ve bulunduğu kuyruğu bloke ettiğidir.</li><li><strong>Notify:</strong> DispatchWorkItem’da kullandığımız notify ile aynı işleve sahiptir. DispatchGroup, içerisindeki görevlerin tamamlanıp tamalanmadığını takip edebilecek özelliklere sahiptir. En son tüm işler bittiğinde görevlerin bittiğini bildirmek veya görevlerden sonra yapılması gereken bir işi yapmak için notify kullanılabilir. Notify methodu Wait’in aksine asenkron olarak çalışan bir methodtur ve gruptan işlerin tamamlandığı bilgisini aldığında çalışır.</li></ul><p>DispatchGroup’larla çalışırken, kullandığımız kuyruklar mevcut gruba işin bitip bitmediği hakkında bilgi verir. Ancak kuyruklar işin bitip bitmediğini her zaman doğru bir şekilde takip edemez. Örneğin bir görevin içerisinde closure ile çalıştığımızı düşünelim. Closure’lar ile çalışırken bu görev sanki tamamlanmış gibi görünür ancak arka planda çalışmaya devam eder. Bu ve bunun gibi durumlarda ilerlerken kullanabileceğimiz methodlar vardır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8dc45c4b22b5476edd145d95e5018b47/href">https://medium.com/media/8dc45c4b22b5476edd145d95e5018b47/href</a></iframe><p>Yukarıdaki örnekte <em>enter</em> methodu bu görevin başladığını, <em>leave</em> methodu ise görevin bittiğini temsil eder. Kuyruğun takip edemeyeceği durumlarda, görevin bitip bitmediğini elle belirterek işlerin doğru ilerlemesini sağlayabiliriz.</p><p>Concurrency, derin ve pratik yapılması gereken bir konu. Nerede kullanacağımı bilmiyorum diyebilirsiniz. Ancak farklı projeleri inceleyerek eşzamanlılığı nerede nasıl kullanacağımızı anlayabiliriz. Okuduğunuz için teşekkür ederim. Yorum ve önerilerinizi benimle paylaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=792173e821f2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/ios-ve-concurrency-e%C5%9Fzamanl%C4%B1l%C4%B1k-gcd-792173e821f2">iOS ve Concurrency (Eşzamanlılık)-GCD</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RxSwift’e Küçük Bir Başlangıç Bölüm 3: RxTest ve RxBlocking]]></title>
            <link>https://medium.com/deliveryherotechhub/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-3-rxtest-ve-rxblocking-a759d4a1056e?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/a759d4a1056e</guid>
            <category><![CDATA[rxswift]]></category>
            <category><![CDATA[rxtests]]></category>
            <category><![CDATA[rxcocoa]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[yemeksepeti]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Mon, 03 Jan 2022 12:08:52 GMT</pubDate>
            <atom:updated>2022-01-14T11:09:07.694Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gE1EJUzvTBkdABoy89pgSA.jpeg" /><figcaption>Image from <a href="https://www.raywenderlich.com/7408-testing-your-rxswift-code">raywenderlich.com</a></figcaption></figure><p>Herkese tekrar merhaba. Önceki yazılarımda <a href="https://medium.com/yemeksepeti-teknoloji/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-f3186f7ec675">RxSwift</a> ve <a href="https://medium.com/yemeksepeti-teknoloji/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-2-rxcocoa-dd5553210004">RxCocoa</a> ile reaktif kod yazdık. Sıra bu kodları test edebilmemiz için oluşturulmuş yapıları incelemeye geldi. :) Bunlar RxTest ve RxBlocking! Bu yazımda reactive kodların nasıl test edileceğini anlatacağım.</p><h4>— RxBlocking</h4><p>RxBlocking, bir observable’ı BlockingObservable’a dönüştürerek bize sonuç verir. Bu yüzden RxBlocking kullanmadan önce BlockingObservable’ın ne olduğunu anlamamız, bu yapıyı kullanmamızı da kolaylaştıracaktır.</p><ul><li><strong>BlockingObservable: </strong>BlockingObservable, dizi tamamlanana kadar veya zaman aşımı oluşana kadar observable’ın çalıştığı iş parçacığını bloke eden yapıdır. Bu da asenkron işlemlerin testlerini daha kolay hale getirir. BlockingObservable’ları yalnızca testte değil kodun diğer kısımlarında da kullanabiliriz ancak bu durum asenkron çalışmaya uygun olmadığı için doğru bir yaklaşım olmaz.</li></ul><p>Bir observable’ı, BlockingObservable’a dönüştürmek için <strong>toBlocking() </strong>operatörünü kullanmamız yeterlidir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/91c913366d2a7dc0a4203fa432f95a14/href">https://medium.com/media/91c913366d2a7dc0a4203fa432f95a14/href</a></iframe><p>Observable’ları blocking ile test ederken operatörleri de kullanabiliriz. Burada kod test edilirken kullanılan 3 farklı operatörden bahsedeceğim.</p><ul><li><strong>toArray:</strong> toArray observable’ın yaydığı tüm ögeleri bir dizi olarak almamızı sağlar. Bir observable’a gelen tüm ögelerin test edilmesi gerektiğinde bu yapıyı kullanabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x-e8ZEVj6e-XMUsF0QOVvA.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a0d86d85716a577921ac9febe1a3dc06/href">https://medium.com/media/a0d86d85716a577921ac9febe1a3dc06/href</a></iframe><ul><li><strong>first:</strong> Observable’ın yaydığı ilk ögeyi almamızı sağlar. Bu yapıyı observable’ın öge yaymaya başlayıp başlamadığını test etmek istediğimizde kullanabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*erN1uGLUSm8dPM-IIfBiHw.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8d936388aa1c84978e5adb70524cf01/href">https://medium.com/media/b8d936388aa1c84978e5adb70524cf01/href</a></iframe><ul><li><strong>last: </strong>Observable’ın yaydığı son ögeyi almamızı sağlar. Observable’ın tamamlanıp tamamlanmadığının kontrolünü last operatörü ile birlikte test edebiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L0M7SAIMaGHh88RZm2H69g.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d7f26d86dd3530abe5a1e6502761cb9b/href">https://medium.com/media/d7f26d86dd3530abe5a1e6502761cb9b/href</a></iframe><p>toArray, first veya last operatörü kullanılırken bu operatörler herhangi bir öge bulamazsa <em>NoSuchElementException</em> hatasını, eğer ögeleri alabiliyorsak istediğimiz sonucu döndürür. Bu yüzden try ile birlikte kullanmamız gerekir.</p><p>RxBlocking kullanımı asenkron işlemlerin testlerini oldukça kolaylaştırır. Ancak bu yapının da bazı dezavantajları vardır.</p><ul><li>Sonsuz observable’ları bekletemeyeceğimizden RxBlocking yapısını yalnızca sonlu observable’lar ile kullanabiliriz.</li><li>Observable’ları duraklattığımız için uzun sürede gerçekleşecek işlemler beklendiği için testlerin tamamlanma süresi de uzar.</li></ul><h4>— RxTest</h4><p>Asenkron işlemleri test edebilmemizi sağlayan bir diğer kütüphane RxTest kütüphanesidir. RxBlocking kullanırken observable’ın bulunduğu zamanlayıcıyı dondurarak observable’ın ögelerini yaymasını bekliyorduk. Artık RxTest ile testleri de asenkron olarak ilerletmeye başlayabiliriz. Bu kütüphane içerisinde temel olarak kullanacağımız üç yapı mevcuttur.</p><ul><li><strong>Test Scheduler</strong></li></ul><p>TestScheduler ile asenkron dizilerin hangi zamanlarda hangi olayları yaydığını takip edebilir, bu olayların istediğimiz gibi yayılıp yayılmadığını kontrol edebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/79c3ad18b9df0be1b1c4890b74d18308/href">https://medium.com/media/79c3ad18b9df0be1b1c4890b74d18308/href</a></iframe><p>Yukarıdaki örnekleri inceleyecek olursak;</p><ol><li>TestScheduler oluştururken kullandığımız initalClock’ın anlamı test scheduler’in başlangıç zamanıdır. Burada inital clock’ı sıfıra eşitlememiz test scheduler’ı testin başlangıç saatinde başlatmak istediğimizi gösterir.</li><li>Scheduler üzerinde çalışacak bir observer oluşturabiliriz. Bu observer ile test etmek istediğimiz observer’ı birbirine bağlarsak (bind operatörü ile) test ettiğimiz observer’ın yaydığı tüm ögeleri, ögelerin yayıldığı zamanla birlikte kaydedebilmemizi sağlar.</li><li>Scheduler üzerinde observable oluşturabiliriz. Bu observable istediğimiz zamanlarda, istediğimiz ögeleri yaymamızı sağlar. Bu sayede hangi olayın ne zaman yayılacağını söyleyip, buna uygun tepkiler alıp almadığımızı kontrol edebiliriz.</li><li>Bir test scheduler oluşturduğumuzda, bu scheduler’ı kullanabilmek için her testte scheduler’ı başlatmamız gerekir. TestScheduler başlatılmadan olay yayamaz veya olayları takip edemeyiz.</li></ol><ul><li><strong>Cold Observable ve Hot Observable</strong></li></ul><p>Asenkron testler yazılırken istediğimiz zamanlarda, istediğimiz ögeleri yayabilmek için observable oluşturduğumuzu söylemiştik. Bu observable’ları ihtiyacımıza göre iki farklı şekilde oluşturabiliriz.</p><p>Bunlardan ilki <strong>Cold Observable</strong>’dır. Cold observable’lar kullandığımız diğer observable’lar gibi olayları yayabilmek veya olayları takip edebilmek için aboneliğe ihtiyaç duyarlar. Asenkron işlemlerle, HTTP veya TCP bağlantıları gibi işlemler gerçekleştirilirken kullanılabilir.</p><p>İkinci observable ile <strong>Hot Observable</strong>’dır. Hot observable’lar öge yaymak veya ögeleri takip edebilmek için aboneliğe ihtiyaç duymazlar. Variable, property, constant, dokunma veya mouse koordinatları, UI kontrol değerleri vb. yapılarla kullanılabilir.</p><p>Şimdi de RxTest ile ilgili bir örnek zamanı. 🙂</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/87dbe15bd2956cc971b56729d2fc1cef/href">https://medium.com/media/87dbe15bd2956cc971b56729d2fc1cef/href</a></iframe><p>Yukarıda, veriler yüklenirken gösterilen bir activity indicator’e bağlı loading observable’ının testi yapılmıştır. Bu testi adım adım inceleyelim.</p><ol><li>Test edeceğimiz loading observable yalnızca activity indicator’ın gösterilip gösterilmeyeceğini takip eder. Bu yüzden bool olarak tanımlanmıştır. Burada tipi bool olan bir observable’ı test edeceğimiz için yine bool tipinde bir observer tanımlarız.</li><li>Kod içerisinde kullandığımız ve test edeceğimiz loading observable ile test scheduler üzerinde oluşturduğumuz observer’ı birbirine bağlarız. Bu işlem sonucunda loading’in aldığı olayları oluşturduğumuz observer’ı kullanarak zamanları ile birlikte takip edebiliriz.</li><li>Kod içerisindeki loadData bizim verilerimizi yüklemek için kullandığımız tetikleyicidir. Void tipindedir ve her olay aldığında öncelikle loading observable’ına true değer gönderilir, sonrasında veriler alınır ve verilerin tamamı alındıktan sonra loading observable’ına false değer gönderilir. Burada scheduler üzerinde oluşturduğumuz observable’a 50. ve 100. zamanlarda iki farklı olay gönderip sonrasında bu olayların loading’i doğru şekilde etkileyip etkilemediğini kontrol edebiliriz.</li><li>Biz observer ve observable’ımızı bir zamanlayıcı üzerinde tanımladık ve olayları bu zamanlayıcı üzerinden takip edeceğiz. Ancak ögeleri alıp almadığımızı kontrol etmeden önce olayların gerçekleşmesi ve bu olayları takip edebilmemiz için kullanacağımız scheduler’ı başlatmamız gerekir.</li><li>Son olarak test etme kısmına geldik. Öncelikle son adımda gördüğünüz gibi loading’in beş olay almasını bekliyoruz. Bu beş olayın ilki loading’in başlangıç değeridir. Loading oluşturulurken verdiğimiz ilk değer false olduğu için 0. zamanda loading false değerini alır. Sonrasında 3. adımda oluşturduğumuz cold observable ile 50. zamanda bir olay gönderdiğimizi görüyoruz. Bu olay loadData’nın tetiklenmesini, dolayısıyla yükleme başladığı için loading’in true değer almasını sağlar. Bu sayede loading’in aldığı ikinci değerin 50. zamanda true olduğunu söyleyebiliriz. Yine aynı zamanda yükleme bittikten sonra loading false olacağı için üçüncü olay da 50. zamanda false olur. Bu işlemin aynısını testteki 100. zaman için de uygulanır. Burada next durumlarını test ettiğimiz gibi complete ve error durumlarını da test edebiliriz.</li></ol><p>Bu yazımla birlikte RxSwift macerasını sonlandırmış bulunuyorum. 🙂 Bundan sonrası RxSwift ile kodlar yazıp RxTest ile test ederek bu konuları iyice anlamak diyebilirim.</p><p>Okuduğunuz için teşekkür ederim, herhangi bir fikriniz veya yorumunuz olursa benimle paylaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a759d4a1056e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-3-rxtest-ve-rxblocking-a759d4a1056e">RxSwift’e Küçük Bir Başlangıç Bölüm 3: RxTest ve RxBlocking</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RxSwift’e Küçük Bir Başlangıç Bölüm 2: RxCocoa]]></title>
            <link>https://medium.com/deliveryherotechhub/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-2-rxcocoa-dd5553210004?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd5553210004</guid>
            <category><![CDATA[yemeksepeti]]></category>
            <category><![CDATA[rxcocoa]]></category>
            <category><![CDATA[rxswift]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Fri, 17 Dec 2021 08:46:20 GMT</pubDate>
            <atom:updated>2022-01-14T11:08:37.185Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rSZVo2bFB_J5kb8rCfOmYA.jpeg" /></figure><p>Herkese merhaba, reactive programlamaya başladığımızda kullanacağımız her şey RxSwift ile sınırlı kalmıyor. Şimdi de RxCocoa ile ilgili bilgilere geçebiliriz. :) RxSwift’i anlattığım ilk yazımı okumak isterseniz <a href="https://medium.com/yemeksepeti-teknoloji/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-f3186f7ec675">buradan</a> ulaşabilirsiniz.</p><h3>RxCocoa</h3><p>RxSwift, swift dilinin temel yapılarını reaktif olarak kullanmamızı sağlarken, RxCocoa, iOS gibi SDK sınıflarını, UI denetimlerini reaktif olarak kullanmamıza olanak sağlar. RxCocoa içerisinde relay, driver, binding, control event ve control property yapıları mevcuttur.</p><h4>— Relay</h4><p>Relay’lar yalnızca ögeleri kabul edebilen yapılardır. Bir relay ile onError, onCompleted veya onNext durumları kullanılmaz. Relay’lara yalnızca yeni öge ekleyebilir ve abone olarak her yeni öge geldiğinde bazı işlemler gerçekleştirebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fe305d798fc4e52f502340d671e0a4b8/href">https://medium.com/media/fe305d798fc4e52f502340d671e0a4b8/href</a></iframe><ul><li><strong>Behavior Relay: </strong>Behavior Subject gibi Bir başlangıç değeriyle başlar. Her yeni subscribe abone olmadan önce yayılan son ögeyi (yayılan öge yoksa başlangıç değerini) ve devamında gelen ögeleri alır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V0scJGPFK5-5k_D6k3F2cA.png" /></figure><ul><li><strong>Publish Relay:</strong> Publish Subject gibi boş bir şekilde başlar. Her yeni subscribe yalnızca abone olduktan sonra yayılan ögeleri alabilir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*um20m7wKTCDkTIwfnbYCHQ.png" /></figure><p><strong>NOT:</strong> Subject ve relay’ları benzer özelliklere sahiptir. Bu iki yapıyı ayıran en önemli özellik relay’ların yalnızca öge kabul etmesi sebebiyle sonlandırılamamasıdır.</p><h4><strong>— Driver</strong></h4><p>UI elemanlarını kullanırken dikkat etmemiz gereken bazı durumlar vardır. Bunlar UI elemanlarının yalnızca Main Scheduler üzerinde çalışması ve UI ile yaptığımız işlemlerin observable hata aldığında sonlanmasıdır. Observable ile çalışırken bu durumların kontrolü bizim sorumluluğumuzdadır.</p><p>RxCocoa ile birlikte, observable’a kural ekleyip bu kuralların doğru ilerleyip ilerlemediğini takip etmek yerine Driver kullanabiliriz. Driver’lar observable’ların özelleştirilmiş halidir diyebiliriz.</p><p>Aşağıdaki örnekte <em>observable</em> ve <em>driver</em> aynı özelliklere sahiptir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/01ad3edc6e2cc5adbbea248aed72b46d/href">https://medium.com/media/01ad3edc6e2cc5adbbea248aed72b46d/href</a></iframe><p><strong>Driver özellikleri;</strong></p><ul><li>Driver’lar yalnızca Main Scheduler üzerinde çalışırlar.</li><li>Driver’lar error durumu ile sonlandırılmazlar. Onun yerine driver’ların herhangi bir error durumunda alabilecekleri varsayılan değerleri vardır.</li><li>Driver’lar shareReplay ile observer’lara son ögesini paylaşır. Bu sayede driver’a abone olan her observer’ın başlangıçta bir değeri olacaktır.</li></ul><p>Kısaca Driver’lar UI’ın her zaman bir şeyler gösterebilmesini ve gösterilen verilerin doğru olmasını sağlamak için kullanılır.</p><h4><strong>Bir Observable’ı Driver Olarak Kullanmak</strong></h4><p>Bir observable’ı driver’a çevirirken driver’lara error durumunda alabileceği varsayılan değerler vermemiz gerekiyor. Bu üç farklı şekilde yapılabilir:</p><ul><li><strong>onErrorJustReturn: </strong>Driver hata durumunda varsayılan bir değeri döndürür.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xx4b85JSqjSco974exaAXQ.png" /></figure><p>Yukarıdaki driver Int değere sahip olduğu için hata durumunda yaymak için varsayılan Int değere ihtiyaç duyar.</p><ul><li><strong>onErrorDriveWith:</strong> Driver hata durumunda başka bir driver’ı sürdürür.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2jlnSvvTXdPOXc5l4ZfiZw.png" /></figure><p>Yukarıdaki driver hata durumunda sürdürebilmek için kendisiyle aynı tipte bir driver’a ihtiyaç duyar.</p><ul><li><strong>onErrorRecover:</strong> Bu yapı da <em>onErrorDriveWith</em> gibi hata durumunda bir driver sürdürmemizi sağlar. Tek farkı oluşan error durumunu da yakalayabilmemizdir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TwQ9FJghOj3V1A5yfeAxzQ.png" /></figure><p>Aldığımız error durumuna göre closure içerisinde işlem yapıp sonuç olarak sürdürdüğümüz driver ile aynı tipte bir driver sürdürmemize olanak sağlar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6cb1b9b0137ac0023ae3e5ed221986da/href">https://medium.com/media/6cb1b9b0137ac0023ae3e5ed221986da/href</a></iframe><h4>Bir Driver’ı Observable Olarak Kullanmak</h4><p>Driver’ı observable olarak kullanmamız gerektiğinde yapmamız gereken ekstra bir işlem yoktur. Yalnızca driver’ın artık observable olarak kullanılacağını belirtmemiz yeterli olur.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/11e3f76474d9cf152aa463547edf8343/href">https://medium.com/media/11e3f76474d9cf152aa463547edf8343/href</a></iframe><h4>— Control Property ve Control Event</h4><p>Control Property ve Control Event, UI elementlerinin bazı özelliklerini temsil eder.</p><h4>Control Property</h4><p>Control property, UI elemanlarının özelliklerini rx olarak temsil eder.Control property bir observer abone olduğunda veya yeni öğe geldiğinde yeni olay yayar. Bu yapının bazı özellikleri vardır.</p><ul><li>Control Property hiç hata vermez, başarısız olmaz.</li><li>Her zaman share(replay:1) özelliğini taşır. Yani yeni abonelere son aldığı değeri yayar.</li><li>Deallocate edildiği zaman Complete durumunu yayar.</li><li>Her zaman Main Scheduler üzerinde çalışır.</li></ul><p>Bu yapıya bir örnek verecek olursak, label ve textField içerisindeki text’ler birer control property’dir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b15d3672261777cb9619d2a7c0672424/href">https://medium.com/media/b15d3672261777cb9619d2a7c0672424/href</a></iframe><h4>Control Event</h4><p>Control event, UI elemanlarının olaylarını rx olarak temsil eder. Bu yapının bazı özellikleri vardır.</p><ul><li>Control event hiç hata vermez, başarısız olmaz.</li><li>Yeni abonelere herhangi bir değer yaymaz. Yeni aboneler yalnızca abone olduktan sonra gelen olayları takip edebilir.</li><li>Deallocate edildiği zaman Complete durumunu yayar.</li><li>Her zaman Main Scheduler üzerinde çalışır.</li></ul><p>Bu yapıya bir örnek verecek olursak, button’un tıklanması bir control event’tir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c90296e191533127c71d190669ca6e7c/href">https://medium.com/media/c90296e191533127c71d190669ca6e7c/href</a></iframe><h4>— Binding</h4><p>Binding RxCocoa içerisinde en çok karşılaşacağımız yapıdır ve observable’ları birbirine bağlamamızı sağlar. Bu yapı iki observable arasında kullanılacağı gibi, observable ve control property, observable ve control event arasında da kullanılabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mkni51iFiyTWxgHyA6MNqw.png" /></figure><p>Binding işlemini kullandığımız observable’a göre iki farklı operatör ile yapabiliriz. Bağlayacağımız yapı eğer bir observable, subject veya relay ise <strong>bind(to:)</strong> kullanırız. Eğer bir driver ile bir yapıyı bağlayacaksak <strong>drive()</strong> kullanmalıyız.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d535bac4adc58aa8d5994dde8484f307/href">https://medium.com/media/d535bac4adc58aa8d5994dde8484f307/href</a></iframe><p>Yukarıdaki örneklerde bir label text’i ile observable ve driver bağlanmıştır. Buradaki yapı observable’a gelen text’leri label içerisine atmamızı ve label’ın bu text’leri göstermesini sağlar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e4fb1f8db6a5b51573bd9c3223a633ee/href">https://medium.com/media/e4fb1f8db6a5b51573bd9c3223a633ee/href</a></iframe><p>Burada button’un tap olayı bir control event’tir. Hatırlayacağınız gibi bir control event başlangıç değeri almayacağından bir publish subject ile bağlayabiliriz. Burada butona tıklandığında buttonTapped yeni bir olay alır ve buton her tıklandığında yapılması gereken işlemleri bu şekilde gerçekleştirebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1516094c6570ae6c94d055a39855ee91/href">https://medium.com/media/1516094c6570ae6c94d055a39855ee91/href</a></iframe><p>Burada textfield’in içerisindeki text bir control property’dir. Control property başlangıç değeri aldığı için burada behavior subject kullanabiliriz. TextField içerisine herhangi bir text girildiğinde textChanged yeni bir olay alır ve aldığımız text ile ilgili işlemlerimizi gerçekleştirebiliriz.</p><p>Bu konuda temel bilgiyi edindikten sonra farklı kaynakları inceleyip örnekler yaparak kendinizi kolayca geliştirebilirsiniz. Eğer RxTest ve RxBlocking’i anlattığım yazımı da okumak isterseniz <a href="https://medium.com/yemeksepeti-teknoloji/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-3-rxtest-ve-rxblocking-a759d4a1056e?p=a759d4a1056e">buradan</a> ulaşabilirsiniz.</p><p>Okuduğunuz için teşekkür ederim, herhangi bir fikriniz veya yorumunuz olursa benimle paylaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd5553210004" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-2-rxcocoa-dd5553210004">RxSwift’e Küçük Bir Başlangıç Bölüm 2: RxCocoa</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RxSwift’e Küçük Bir Başlangıç]]></title>
            <link>https://medium.com/deliveryherotechhub/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-f3186f7ec675?source=rss-3f2592915aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3186f7ec675</guid>
            <category><![CDATA[rxswift]]></category>
            <category><![CDATA[yemeksepeti]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Ayşe Nur Bakırcı]]></dc:creator>
            <pubDate>Thu, 25 Nov 2021 14:56:01 GMT</pubDate>
            <atom:updated>2022-01-14T11:07:58.175Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rSZVo2bFB_J5kb8rCfOmYA.jpeg" /></figure><p>Merhaba. Burada sizlere RxSwift çalışırken aldığım notlardan herkesin yararlanabileceği ufak bir yol haritası çıkarmaya çalışacağım.</p><p>Öncelikle RxSwift en kısa tanımıyla gözlemlenebilir dizileri (observable) kullanarak asenkron kod yazmamızı sağlayan bir yapıdır. Peki bu yapıyı neden kullanmalıyız? Öncelikle senkron bir kod akışını ele aldığımızda her işlevin sırayla yapıldığını görüyoruz. Elimizde farklı işlemleri, farklı iş parçaları üzerinde aynı anda yürütebileceğimiz bir yapı varken yapacağımız işleri sırayla yapmak istemeyebiliriz. İşte burada RxSwift kullanmaya başlayabiliriz. :)</p><p>Böyle kullanışlı bir yapının elbette ki zorlukları olacaktır. RxSwift kullanırken birden çok eşzamanlı ilerleyen bileşeni takip edebilmeli, kodların doğru sırayla çağırdığımızdan da emin olmalıyız.</p><h3>RxSwift</h3><p>RxSwift içersinde, kullandığımız üç temel yapı vardır.</p><h4>1. Observable</h4><p>Değişiklikleri yayan yapılardır. Biz bir gözlemlenebilir dizi (observable) oluşturduğumuzda, aslında değişikliklerini takip edebileceğimiz asenkron bir dizi oluşturmuş oluruz. Takip ettiğimiz bu diziye her yeni öge geldiğinde bazı işlemleri gerçekleştirebiliriz. Bir observable 4 farklı olay yayabilir.</p><ul><li><strong>onNext: </strong>Bir sonraki olayı temsil eder. Diziye eklenen her yeni ögeyi onNext ile takip edebiliriz.</li><li><strong>onCompleted:</strong> Observable başarılı bir şekilde tamamlandığında bu olay gösterilir. Tamamlanmış bir observable yeni olaylar yaymaz.</li><li><strong>onError:</strong> Observable bir hata ile karşılaştığında bu olay gösterilir. Hata alan bir observable yeni olaylar yaymaz.</li><li><strong>onDisposed:</strong> Observable tamamlanıp hafızadan atılacağı an oluşan olaydır.</li></ul><p>Olayları takip ederken sonlu veya sonsuz olacak şekilde iki farklı observable kullanılır.</p><p><strong>Sonlu observable</strong> bir süre yeni olay yaydıktan sonra onError veya onCompleted ile sonlanan yapıdır. Burada örnek olarak internetten dosya indiren bir observable düşünebiliriz. Dosya indirilirken her öge onNext ile alınır. Eğer herhangi bir hata ile karşılaşırsak onError durumu, indirme hata almadan devam eder ve dosyanın indirmesi başarılı bir şekilde biterse onComplete durumu ile observable sonlanır.</p><p><strong>Sonsuz observable</strong> ise uygulamanın çalıştığı süre boyunca olay almaya devam eden yapıdır. Burada cihaz yönü değişikliğini takip eden bir observable örnek olabilir. Cihaz yönü değişiklikleri uygulama çalıştığı süre boyunca devam edebileceği için bu observable uygulama kapanana kadar sonlanmamalıdır.</p><p><strong>Observable Oluşturmak;</strong></p><p>Bir observable oluşturmak için üç farklı operatör kullanılabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4wK-LKyynnf-GDY6xWX6mQ.png" /></figure><ul><li><strong>Just </strong>operatörü ile tek bir öge içeren observable oluşturulabilir.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5451c0d50e53ae19979d05cc1f629ad9/href">https://medium.com/media/5451c0d50e53ae19979d05cc1f629ad9/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-2B__k9fmi1sOvk-SbZrEA.png" /></figure><ul><li><strong>Of </strong>operatörünü kullanarak birden fazla öge içeren observable oluşturabiliriz. Burada eklenen ögelerin hepsi aynı tipte olmalıdır.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/01d22d71bdafa8e2aa97e6b2fbac073e/href">https://medium.com/media/01d22d71bdafa8e2aa97e6b2fbac073e/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xQcxBxrRePtlrPOnUA9Zdw.png" /></figure><ul><li><strong>From </strong>operatörünü kullanarak dizi içeren observable oluşturabiliriz. Oluşturulan observable dizinin içindeki her elemanın farklı ögeler olarak tutacaktır.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/799f58d912b7c442ac37872f9d1680eb/href">https://medium.com/media/799f58d912b7c442ac37872f9d1680eb/href</a></iframe><p><strong>Observable’a Subscribe Olmak;</strong></p><p>Oluşturulan bir observable olayları yayabilmek için bir subscriber’a ihtiyaç duyar (Kim takip edilmeyecek ögeleri yaymak ister ki :) ). Subscribe kullanarak observable’ın yeni olaylar yaymasını sağlayabilir, observable’ın yaydığı durumları ve ögeleri takip edebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f23da3c42e1ec6167a1eed7b4562ebf/href">https://medium.com/media/4f23da3c42e1ec6167a1eed7b4562ebf/href</a></iframe><p>Yukarıdaki örneklerdeki gibi farklı yöntemlerle olaylara ve olaylar içerisindeki ögelere ulaşabiliriz.</p><p>Observable’lar yalnızca ögeleri yaymak zorunda değildir. Ögeler olmadan boş veya hiçbir şey yaymayan observable oluşturabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ys0KJJhBbF6HDnKv1cgPsw.png" /></figure><p>Empty ile oluşturulan observable bize yalnızca <strong>onCompleted </strong>durumunu döndürecektir. Never ile oluşturulan observable ise <strong>hiçbir durum yaymayan ve sonlandırılmayan </strong>bir observable’dır. Sonsuz süreyi temsil etmek için kullanılabilir.</p><p><strong>NOT: </strong>Yukarıdaki kod örneklerinde belki dikkatinizi çekmiştir. Subscribe sonrasında kullandığımız <strong>dispose</strong> yapısı mevcut. Bu yapı sayesinde artık kullanmayacağımız observable’ları hafızadan atabiliriz. Observable’lar ile çalışırken bunu kullanmayı unutmamalısınız, hafızadan atılmayan her observable uygulamanın performansını kötü etkileyecektir.</p><h4>— Subject</h4><p>Subject’ler hem observable hem de observer olarak kullanabileceğimiz yapılardır. Farklı durumlara göre kullanabileceğimiz farklı türleri mevcuttur.</p><ul><li><strong>Publish Subject: </strong>Boş bir şekilde başlar. Her yeni subscribe yalnızca abone olduktan sonra yayılan ögeleri alabilir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lfcgFcMZduOaYVcvFvgovQ.png" /></figure><ul><li><strong>Behavior Subject:</strong> Bir başlangıç değeriyle başlar. Her yeni subscribe abone olmadan önce yayılan son ögeyi (yayılan öge yoksa başlangıç değerini) ve devamında gelen ögeleri alır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5GKwJ2HGNXDERhejcnyD2w.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8067ccdf039b1d47657f86e4d090594f/href">https://medium.com/media/8067ccdf039b1d47657f86e4d090594f/href</a></iframe><h4>2. Operatör</h4><p>Observable’ı kullanırken bazı olayları kısıtlamak veya yalnızda işimize yarayacak ögeleri filtrelemek isteyebiliriz. Bunun gibi durumlarda observable ile birlikle kullanabileceğimiz birçok operatör vardır.</p><ul><li><strong>ignoreElements(): </strong>Tüm ögelerin filtrelenmesi için kullanılır. Yalnızca onError veya onComplete durumlarını takip etmemiz gerektiğinde bu operatörü kullanabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iACF0bro1A-fk79YBHCxew.png" /></figure><ul><li><strong>elementAt():</strong> ElementAt operatörü parametre olarak bir sayı alır ve takip ettiğimiz gözlemlenebilir dizide yalnızca verilen indexte bulunan ögeyi almamızı sağlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WG8wX2XgBMspsjNZV9wuVg.png" /></figure><ul><li><strong>filter():</strong> Gelen dizideki ögeleri filter operatörü içerisine yazığımız koşula göre filtreleyebilmemizi sağlar. Takip ettiğimiz observable’dan yalnızca koşula uyan ögeleri alabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G1fGPCTKkdhpwfwRTzxFNg.png" /></figure><ul><li><strong>skip():</strong> Parametre olarak sayı alır. Observable’dan gelen ögelerden verilen sayı kadarını atlayarak ögeleri almamızı sağlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iVw_o0v3YMqvHMMA1WAnlw.png" /></figure><ul><li><strong>skipWhile():</strong> Takip ettiğimiz observable’da, operatör içerisine yazılan koşula uyan ilk öge atlanır ve diğer ögeler koşula uysa da alınmaya devam eder. Yani bu yapı filter gibi uzun ömürlü değildir, yalnızca koşula uyan ilk öge için geçerlidir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DfysokBWrJgmgVg50uk1rA.png" /></figure><ul><li><strong>skipUntil():</strong> Parametresi bir observable’dır. Operatöre verilen observable’ı trigger olarak adlandırdığımızı düşünelim. Takip edeceğimiz gözlemlenebilir dizinin ögelerini yalnızca trigger yeni bir durum aldığına takip etmeye başlayabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JVCsxrUG6pgMUbI81qei9w.png" /></figure><ul><li><strong>take():</strong> Parametre olarak sayı alır. Takip ettiğimiz observable’dan verilen sayı kadar öge almamızı sağlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g_beQ5UXJ6hYWCDpdkNcgg.png" /></figure><ul><li><strong>takeUntil():</strong> Parametresi bir observable’dır. Operatöre verilen observable’ı trigger olarak adlandırdığımızı düşünelim. Takip edeceğimiz gözlemlenebilir dizinin ögelerini yalnızca trigger’a yeni bir öge gelene kadar takip edebiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1weQSC30gFcCtTtdbUoUSA.png" /></figure><ul><li><strong>distinctUntilChange():</strong> Üst üste gelen aynı ögeleri filtrelemek için kullanabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QjDlNLTdHrj4Ycu4FXDf8g.png" /></figure><ul><li><strong>toArray():</strong> Gözlemlenebilir diziden gelen tüm ögeleri bir dizi içerisine toplayarak ögeleri dizi olarak almamızı sağlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2fkOjOfdEmjuEeVJG4bVEQ.png" /></figure><ul><li><strong>map(): </strong>Dizi ögeleri üzerinde yapmak istediğimiz tüm değişiklikleri uygulamamızı sağlayan yapıdır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0VZ3wrY4RRqlap-oTzjy6Q.png" /></figure><ul><li><strong>mapWithIndex(): </strong>Map operatörü ile aynı işleve sahiptir. Tek fark ögeyle birlikte ögenin indexini de alarak işlem yapabilmemizdir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AotUxW6hXUJMea60hpXQng.png" /></figure><ul><li><strong>flatMap():</strong> Observable’ın her ögesinin değişimlerini ayrı ayrı takip edip sonrasında bu ögeleri birleştirerek tek bir observable oluşturan operatördür.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QfYYaZv6ygVxAwQoRDEOIw.png" /></figure><ul><li><strong>compactMap(): </strong>Diğer map işlemleri gibi observable’dan gelen ögeler için işlemler uygular. Bu yapının farkı gelen ögeler optional ise içerisini kontrol eder, eğer bir değer yoksa boş ögeyi diziden atar, varsa ögeyi optional olmaktan çıkartır ve bu ögelerle bir observable oluşturur.</li><li><strong>startWith(): </strong>Gelen dizinin ilk indeksine eleman eklemek için kullanılır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bJue3ufvlYeyHYVejgVc5Q.png" /></figure><ul><li><strong>concat(): </strong>İki gözlemlenebilir diziyi birleştirmek için kullanılır. İlk dizinin ögeleri tamamlandıktan sonra ikinci dizinin ögeleri alınmaya başlanır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q9D3Eg9pMSAbxLgwtzV_Vw.png" /></figure><ul><li><strong>merge(): </strong>İki gözlemlenebilir diziyi birleştirmek için kullanılır. İki diziden de gelen ögeleri aynı anda takip ederek tek bir gözlemlenebilir dizi olarak kullanabilmemizi sağlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ayy5So_m0Ol1UkiF_OvaSA.png" /></figure><ul><li><strong>combineLatest(): </strong>İki diziden gelen ögeleri aynı anda takip ederek yeni bir observable oluşturur. Bu yapıyı birden çok observable’ı birlikte izlememiz gerektiğinde kullanabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mYAg-M3vG_NMtFXTaI6fLg.png" /></figure><ul><li><strong>zip():</strong> combineLatest ile aynı görevde kullanılır ancak zip iki observable da öge yaymadan yeni bir öge yaymaz. Aşağıdaki örnekte sunny ögesinin kullanılabilmesi için right dizisine de yeni bir öge gelmelidir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5hRTK9adg5iMeIobzxg70g.png" /></figure><ul><li><strong>withLatestFrom(): </strong>Operatöre verilen observable öge yaymaya devam ederken, kaynak observable’a herhangi bir öge geldiğinde, iki observable’ın da son değeri alınarak bir observable oluşturulur. Burada yalnızca bir observable’ı takip edebildiğimiz gibi ikisini beraber de takip edebiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NZj0USJnDKE0LQOAs9TwKg.png" /></figure><ul><li><strong>sample(): </strong>Burada kaynak observable değer yaymaya devam eder. Sample operatörüne parametre olarak verilen observable her yeni öge yaydığında, kaynak observable’ın yaydığı son öge alınır ve bir observable oluşturulur.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HKbt23AmlntRIbuIsCh2DA.png" /></figure><ul><li><strong>amb(): </strong>Amb operatörüne verilen observable’lardan hangisi önce olay yaymaya başlarsa o observable’a subscribe olunur. Diğer observable’ların yaydığı olaylar artık takip edilmez.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y0sjaS41WF3uerFlaP9X8w.png" /></figure><ul><li><strong>switchLatest(): </strong>Bu operatör karmaşık olduğu için bir örnek vererek açıklayacağım. Öncelikle elimizde 2 adet Int tipinde observable olduğunu düşünelim. Burada trigger olarak kullanacağımız observable’ın tipinin de Int tipinde bir observable olarak belirlenmesi gerekiyor. Trigger olarak belirlediğimiz observable’a switchLatest operatörünü ekleyip ögelerimizi almak için neler yapacağımıza bakabiliriz. Burada başta belirlediğimiz observable’lardan hangisinden öge almak istiyorsak, trigger olarak belirlediğimiz observable’a bu observable’ı yeni bir öge olarak göndermemiz gerekiyor. Yani kısaca biz trigger’a hangi observable’ı onNext olarak verirsek, o observable’ın değerlerini almaya devam ediyoruz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oPwRiZY5jaVRMzXkQvNvEg.png" /></figure><ul><li><strong>reduce(): </strong>Operatör içersinde verilen işlemi ilk ögeden başlayıp, işlem sonucunu bir sonraki ögeye dahil ederek tüm ögelere uygular. Observable tamamlandığında toplam sonuç yayınlanır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iO8RljDPkcrVzDV4xatFoQ.png" /></figure><ul><li><strong>scan(): </strong>Operatör içersinde verilen işlemi ilk ögeden başlayıp, işlem sonucunu bir sonraki ögeye dahil ederek tüm ögelere uygular. Her işlemin sonucu yayınlanır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CGziXTezFFDviSP9s9gV3A.png" /></figure><ul><li><strong>replay(): </strong>Parametre olarak sayı alır. Observable’ın yaydığı son ögelerin kaydedilmesini ve yeni subscriber’lara yayılmasını sağlar. Örneğin parametre olarak 3 verdiğimizi düşünelim. Bu observable’ın yaydığı son 3 öge kaydedilir ve observable tarafından her yeni subscriber’a ilk olarak bu 3 öge yayılır.</li><li><strong>replayAll(): </strong>Replay ile aynı işlevde kullanılır, observable’ın yaydığı tüm ögeleri kaydetmek istersek replayAll kullanabiliriz.</li><li><strong>delaySubscription(): </strong>Bir observer’ın ögeleri almaya başladığı zaman geciktirilir. Burada observable beklemez ve öge yaymaya devam eder. Observer observable’ın yaydığı ögeleri nerede yakalarsa oradan almaya başlar ve devam eder.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p810TS89jdX5vXOj5fQRGw.png" /></figure><ul><li><strong>delay(): </strong>Bir observable’ın öge yayma süresi geciktirilir. Burada verilen süre geçtikten sonra observable ögelerini yaymaya başlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*htM7DKcgPPTAzi7M1IxtnQ.png" /></figure><ul><li><strong>timeOut(): </strong>Belirtilen zaman dilimi içerisinde observable yeni öge yaymazsa observable onError durumu ile sonlandırılır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*97Jdvirkp1cLBwrxk-UcMg.png" /></figure><ul><li><strong>share(): </strong>Bir observable’a birden fazla abonelik oluşturmak istediğimizde, aboneliklerimiz observable’ın farklı zamanlarında oluşabilir ve her abonelikte aynı sonucu alamayabiliriz. Bu sorunun oluşmaması için share operatörü kullanılır. Share operatörü ile paylaşılan observable’a yapılan her abonelik aynı sonucu almamızı sağlar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uf80sUT6MVwU56dzdagqUQ.png" /></figure><ul><li><strong>retry(): </strong>Observable herhangi bir hata ile karşılaşırsa işlemin tekrar yapılmasını sağlar. Parametre olarak verilen sayı kadar veya sonsuz sayıda deneme yapılabilir.</li><li><strong>catch(): </strong>Observable herhangi bir hata ile karşılaşırsa varsayılan bir değer verilerek observable’ın hata ile sonlanması engellenir.</li><li><strong>do(): </strong>Observable’ın yaşam döngüsünü kontrol etmemizi sağlar. Subscribe gibi onNext, onComplete ve onError durumlarını içerir ve herangi bir durumda bazı işlemleri gerçekleştirebiliriz. Ancak subscribe gibi observable’ın yeni olaylar yaymasını sağlamaz.</li><li><strong>subscribe(): </strong>Observable’ın yeni olaylar yaymasını ve bu olayların sonucunda işlem yapmamızı sağlar. Bir observable subscribe olmadan yeni olaylar yaymaz.</li><li><strong>dispose(): </strong>Tamamlanan observable’ın hafızadan atılmasını sağlar.</li></ul><h4>3. Scheduler</h4><p>Yazının başında da belirttiğim gibi, RxSwift kullanırken zamanlayıcıları doğru kullanmak da çok önemlidir. Zamanlayıcılar yazdığımız asenkron kodun çalıştığı iş parçacığını temsil eder. Eğer bir observable’ın hangi zamanlayıcı üzerinde çalışacağını belirtmezsek, aboneliğin oluşturulduğu zamanlayıcının üzerinde çalışmaya devam edecektir. Bu her zaman bizim için iyi bir durum olmayabilir, bu yüzden özellikle belli zamanlayıcılarda çalışması gereken kodların hangi zamanlayıcıda çalışacağını kendimiz belirlemeliyiz. Burada en başta dikkat etmemiz gereken nokta UI işlemleri ve UI’ı etkileyen işlemler main thread’de, JSON işlemleri gibi uzun süren işlemlerin de arka planda bir thread’de çalıştırılmasıdır.</p><p>RxSwift’te kullanabileceğimiz 4 farklı scheduler(zamanlayıcı) vardır:</p><ul><li><strong>MainScheduler: </strong>UI işlemleri veya yüksek öncelikli işlemler için bu zamanlayıcıyı kullanabiliriz. Uzun süreli işlemleri bu zamanlayıcı üzerinde gerçekleştirmemeliyiz. Örneğin main scheduler üzerinde yaklaşık 5 saniye süren bir olay gerçekleştirdiğimizde bu kullanıcı arayüzünün 5 saniye boyunca kullanılamamasına sebep olacaktır.</li><li><strong>SerialDispatchQueueScheduler: </strong>Arka planda gerçekleşen eşzamanlı işlemlerin seri olarak ilerlemesini istediğimizde bu zamanlayıcıyı kullanabiliriz.</li><li><strong>ConcurrentDispatchQueueScheduler: </strong>Arkaplanda birden çok ve uzun süreli işlemleri aynı anda yapmamız gerektiğinde bu zamanlayıcıyı kullanabiliriz.</li><li><strong>OperationQueueScheduler: </strong>Arka planda ilerleyen işlemler üzerinde daha fazla kontrole sahip olmamızı sağlar.</li></ul><p><strong>NOT:</strong> MainScheduler ve SerialDispatchQueueScheduler seri ilerleyen, ConcurrentDispatchQueueScheduler ve OperationQueueScheduler eşzamanlı ilerleyen zamanlayıcılardır.</p><p>Bu zamanlayıcıları oluşturduğumuz observable ile kullanmak için 2 farklı operatör mevcuttur. Bu operatörlerin nasıl kullanılacağını anlamak için öncelikle bir observable’ın yapısını incelemeliyiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sRPsQR7EO0C7oQ51uh267w.png" /></figure><p>Oluşturduğumuz yapıda aboneliğin oluşturulduğu ve ögelerin yayıldığı kısım subscription, yayılan olayları takip edip işlemler gerçekleştirdiğimiz kısım ise observing kısmıdır. Yukarıdaki kodların main scheduler üzerinde ilerlediğini ele alalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZDvHvozvNTdV5I0h5WtADQ.png" /></figure><ul><li><strong>subscribe(on:_): </strong>Subscribe on oluşturduğumuz observable’ın subscription ve observing kısımlarının çalıştığı zamanlayıcıyı değiştirmemizi sağlar. Main scheduler üzerinde ilerlemeye başlayan kodlarımızı subscribe on ile arkaplanda çalışan bir scheduler üzerinde ilerlemesini sağlayabiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ajtO4PESl4_xBP_CSgOSg.png" /></figure><ul><li><strong>observe(on:_): </strong>Subscribe on yapısı tüm yapının ilerlediği zamanlayıcıyı değiştirirken observe on yalnızca observing kısmını etkiler. Yukarıdaki örnekte main kısmı da background bir zamanlayıcıya geçmişti. Ancak observing kısmında herhangi bir UI işlemi varsa bunu main scheduler üzerinde geri alabilmeliyiz. Bu durumda observe on kullanarak bunu gerçekleştirebiliriz.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SBchdzhIJGns0nDHE7WC-A.png" /></figure><p>Bunların sonucunda umarım RxSwift konusunda fikir sahibi olmanızı sağlamışımdır. Bir sonraki yazımda da RxCocoa’dan bahsettim. Okumak isterseniz <a href="https://medium.com/yemeksepeti-teknoloji/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-b%C3%B6l%C3%BCm-2-rxcocoa-dd5553210004">buradan</a> ulaşabilirsiniz.</p><p>Okuduğunuz için teşekkür ederim, herhangi bir fikriniz veya yorumunuz olursa benimle paylaşabilirsiniz. 🙂</p><p><a href="https://www.linkedin.com/in/aysenurbakircii/">Ayşe Nur Bakırcı - Jr. Software Engineer - Yemeksepeti | LinkedIn</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3186f7ec675" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deliveryherotechhub/rxswifte-k%C3%BC%C3%A7%C3%BCk-bir-ba%C5%9Flang%C4%B1%C3%A7-f3186f7ec675">RxSwift’e Küçük Bir Başlangıç</a> was originally published in <a href="https://medium.com/deliveryherotechhub">Delivery Hero Tech Hub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>