.NET Core - Hızlı Kılavuz

.NET Core, Microsoft tarafından sağlanan en son genel amaçlı geliştirme platformudur. Farklı platformlarda çalışır ve .NET'i hızlı, esnek ve modern hale getirecek şekilde yeniden tasarlanmıştır. Bu, Microsoft'un en büyük katkılarından biridir. Geliştiriciler artık .NET ile Android, iOS, Linux, Mac ve Windows uygulamalarını tümü Açık Kaynak olarak oluşturabilirler.

Bu eğiticide, .NET Core ve .NET Framework güncellemeleri, .NET Standard ve Evrensel Windows Platform güncellemeleri vb. Dahil birkaç yeni yeniliği ele alacağız.

.NET Core'un Özellikleri

Aşağıdakiler .NET Core'un temel özellikleridir -

Açık kaynak

.NET Core, MIT ve Apache 2 lisanslarını kullanan açık kaynaklı bir uygulamadır.
.NET Core bir .NET Foundation projesidir ve GitHub'da mevcuttur.
Açık kaynaklı bir proje olarak, daha şeffaf bir geliştirme sürecini teşvik eder ve aktif ve bağlı bir topluluğu teşvik eder.

Çapraz platform

.NET Core'da uygulanan uygulama, platform hedefinizden bağımsız olarak çalıştırılabilir ve kodu yeniden kullanılabilir.
Şu anda üç ana işletim sistemini (OS) desteklemektedir
- Windows
- Linux
- MacOS
Desteklenen İşletim Sistemleri (OS), CPU'lar ve uygulama senaryoları, Microsoft, diğer şirketler ve bireyler tarafından sağlanan zamanla artacaktır.

Esnek dağıtım

.NET Core uygulamaları için iki tür dağıtım olabilir -
- Çerçeveye bağlı dağıtım
- Bağımsız dağıtım
Çerçeveye bağlı dağıtım ile uygulamanız, uygulamanızın ve üçüncü taraf bağımlılıklarının yüklü olduğu sistem genelinde .NET Core sürümüne bağlıdır.
Bağımsız dağıtım ile, uygulamanızı oluşturmak için kullanılan .NET Core sürümü, uygulamanız ve üçüncü taraf bağımlılıklarıyla birlikte dağıtılır ve diğer sürümlerle yan yana çalışabilir.

Komut satırı araçları

Tüm ürün senaryoları komut satırında gerçekleştirilebilir.

Uyumlu

.NET Core, .NET Standart Kitaplığı aracılığıyla .NET Framework, Xamarin ve Mono ile uyumludur.

Modüler

.NET Core, NuGet aracılığıyla daha küçük derleme paketlerinde yayımlanır.
.NET Framework, temel işlevlerin çoğunu içeren büyük bir derlemedir.
.NET Core, daha küçük özellik merkezli paketler olarak sunulur.
Bu modüler yaklaşım, geliştiricilerin uygulamalarına yalnızca ihtiyaç duydukları NuGet paketlerini ekleyerek uygulamalarını optimize etmelerini sağlar.
Daha küçük bir uygulama yüzey alanının faydaları, kullandığın kadar öde modelinde daha sıkı güvenlik, daha az servis, iyileştirilmiş performans ve daha düşük maliyetler içerir.

.NET Çekirdek Platformu

.NET Core Platformu aşağıdaki ana parçaları içerir -

.NET Runtime - Bir tip sistemi, montaj yüklemesi, çöp toplayıcı, yerel birlikte çalışma ve diğer temel hizmetleri sağlar.
Fundamental Libraries - İlkel veri türleri, uygulama kompozisyon türleri ve temel yardımcı programlar sağlayan bir dizi çerçeve kitaplığı.
SDK & Compiler - .NET Core SDK'da bulunan temel geliştirici deneyimini etkinleştiren bir dizi SDK aracı ve dil derleyicisi.
‘dotnet’ app host- .NET Core uygulamalarını başlatmak için kullanılır. Çalışma zamanını seçer ve çalışma zamanını barındırır, bir derleme yükleme ilkesi sağlar ve uygulamayı başlatır. Aynı ana bilgisayar, SDK araçlarını da aynı şekilde başlatmak için kullanılır.

Bu bölümde, dağıtmanız ve çalıştırmanız gereken çeşitli bağımlılıkları tartışacağız. Bunlar, Visual Studio kullanılarak geliştirilen Windows makinelerindeki .NET Core uygulamalarını içerir.

Desteklenen Windows Sürümleri

.NET Core, Windows'un aşağıdaki sürümlerinde desteklenir -

Windows 7 SP1
Windows 8.1
Windows 10
Windows Server 2008 R2 SP1 (Tam Sunucu veya Sunucu Çekirdeği)
Windows Server 2012 SP1 (Tam Sunucu veya Sunucu Çekirdeği)
Windows Server 2012 R2 SP1 (Tam Sunucu veya Sunucu Çekirdeği)
Windows Server 2016 (Tam Sunucu, Sunucu Çekirdeği veya Nano Sunucu)

Bağımlılıklar

.NET Core uygulamanızı Windows 10 ve Windows Server 2016'dan önceki Windows sürümlerinde çalıştırıyorsanız, Visual C ++ Yeniden Dağıtılabilir'i de gerektirir.
.NET Core yükleyicisini kullanıyorsanız, bu bağımlılık sizin için otomatik olarak yüklenir.
Yükleyici komut dosyası aracılığıyla .NET Core yüklüyorsanız veya kendi kendine yeten bir .NET Core uygulaması dağıtıyorsanız Visual Studio 2015 için Visual C ++ Yeniden Dağıtılabilir öğesini manuel olarak yüklemeniz gerekir.
Windows 7 ve Windows Server 2008 makineleri için, Windows kurulumunuzun güncel olduğundan ve ayrıca Windows Update aracılığıyla yüklenen KB2533623 düzeltmesini içerdiğinden emin olmanız gerekir.

Visual Studio ile Önkoşullar

.NET Core SDK kullanarak .NET Core uygulamaları geliştirmek için, istediğiniz herhangi bir düzenleyiciyi kullanabilirsiniz.
Ancak, Visual Studio kullanarak Windows üzerinde .NET Core uygulamaları geliştirmek istiyorsanız, aşağıdaki iki sürümü kullanabilirsiniz:
- Visual Studio 2015
- Visual Studio 2017 RC
Visual Studio 2015 ile oluşturulan projeler varsayılan olarak project.json tabanlı olurken, Visual Studio 2017 RC ile oluşturulan projeler her zaman MSBuild tabanlı olacaktır.

Bu bölümde, .NET Core'un Ortam Kurulumunu tartışacağız. .NET Framework'ün önemli bir yeniden tasarımıdır. Uygulamanızda .NET Core kullanmak için kullanabileceğiniz iki sürüm vardır:

Visual Studio 2015
Visual Studio 2017 RC

Visual Studio 2015

Visual Studio 2015'i kullanmak için aşağıdakileri yüklemiş olmanız gerekir -

Microsoft Visual Studio 2015 Güncelleştirme 3
Microsoft .NET Core 1.0.1 - VS 2015 Tooling Preview 2

Microsoft, SQL Server'ı da içeren ve buradan indirilebilen ücretsiz bir görsel stüdyo sürümü sağlar. https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx ve Microsoft .NET Core 1.0.1 - VS 2015 Tooling Preview 2 şu adresten indirilebilir: https://www.visualstudio.com/downloads/

Aşağıdaki URL'deki kurulum yönergelerini de takip edebilirsiniz. https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio 2015 Kurulumu

Visual Studio 2015'i yüklemek için şu adımları izleyin -

Step 1- İndirme tamamlandığında, yükleyiciyi çalıştırın. Aşağıdaki iletişim kutusu görüntülenecektir.

Step 2 - Tıklayın Install kurulum sürecini başlatmak için.

Step 3 - Kurulum tamamlandığında aşağıdaki iletişim kutusunu göreceksiniz.

Step 4 - Bu iletişim kutusunu kapatın ve gerekirse bilgisayarınızı yeniden başlatın.

Step 5- Başlat Menüsünden Visual Studio'yu açın; aşağıdaki iletişim kutusunu alacaksınız. Yüklemesi ve nihayet ilk kez kullanılması birkaç dakika sürebilir.

Step 6 - Yüklendikten sonra aşağıdaki ekranı göreceksiniz.

Step 7 - Visual Studio kurulumu tamamlandığında, Visual Studio'yu kapatın ve Microsoft .NET Core - VS 2015 Tooling Preview 2'yi başlatın.

Step 8 - Onay kutusunu işaretleyin ve Yükle'yi tıklayın.

Step 9 - Kurulum tamamlandığında aşağıdaki iletişim kutusunu göreceksiniz.

Artık uygulamanızı .NET Core kullanarak başlatmaya hazırsınız.

Visual Studio 2017

Bu öğreticide, Visual Studio 2015 kullanacağız, ancak Visual Studio 2017'yi kullanmak istiyorsanız, Visual Studio için .NET Core araçlarının deneysel bir sürümü Visual Studio 2017 RC'ye dahildir ve yükleme yönergelerini burada görebilirsiniz. https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio 2015, .NET Core uygulamaları geliştirmek için tam özellikli bir geliştirme ortamı sağlar. Bu bölümde, Visual Studio içinde yeni bir proje oluşturacağız. Visual Studio 2015 aracını yükledikten sonra, yeni bir .NET Core Uygulaması oluşturmaya başlayabilirsiniz.

İçinde New Project iletişim kutusunda, Şablonlar listesinde, Visual C # düğümünü genişletin ve .NET Core'u seçin ve aşağıdaki üç yeni proje şablonunu görmelisiniz

Sınıf Kitaplığı (.NET Core)
Konsol Uygulaması (.NET Core)
ASP.NET Core Web Uygulaması (.NET Core)

Yeni Proje iletişim kutusunun orta bölmesinde, Konsol Uygulaması (.NET Core) öğesini seçin ve "FirstApp" olarak adlandırın, ardından Tamam'a tıklayın.

Visual Studio yeni oluşturulan projeyi açacak ve Çözüm Gezgini penceresinde bu projedeki tüm dosyaları göreceksiniz.

.NET çekirdek konsol uygulamasının çalışıp çalışmadığını test etmek için aşağıdaki satırı ekleyelim.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Program { 
      public static void Main(string[] args) { 
         Console.WriteLine("Hello guys, welcome to .NET Core world!"); 
      } 
   } 
}

Şimdi uygulamayı çalıştırın. Aşağıdaki çıktıyı görmelisiniz.

.NET Core, standart sayısal integral ve kayan nokta ilkellerini destekler. Ayrıca aşağıdaki türleri de destekler -

System.Numerics.BigInteger üst veya alt sınırı olmayan bir integral türü olan.
System.Numerics.Complex, karmaşık sayıları temsil eden bir türdür.
System.Numerics ad alanındaki Tek Yönerge Çoklu Veri (SIMD) etkin vektör türleri kümesi.

İntegral türleri

.NET Core, uzunluk olarak bir bayttan sekiz bayta kadar farklı aralıklardaki hem işaretli hem de işaretsiz tamsayıları destekler. Tüm tam sayılar değer türleridir.

Aşağıdaki tablo integral türlerini ve boyutlarını temsil etmektedir;

Tür	İmzalı / İmzasız	Boyut (bayt)	Minimum değer	Maksimum değer
Bayt	İmzasız	1	0	255
Int16	İmzalandı	2	32.768	32.767
Int32	İmzalandı	4	−2.147.483.648	2.147.483.647
Int64	İmzalandı	8	−9.223.372.036.854.775.808	9,223,372,036,854,775,807
SByte	İmzalandı	1	-128	127
UInt16	İmzasız	2	0	65.535
UInt32	İmzasız	4	0	4.294.967.295
UInt64	İmzasız	8	0	18.446.744.073.709.551.615

Her integral türü, standart bir aritmetik, karşılaştırma, eşitlik, açık dönüştürme ve örtük dönüştürme işleçleri kümesini destekler.

System.BitConverter sınıfını kullanarak bir tamsayı değerindeki tek tek bitlerle de çalışabilirsiniz.

Kayan nokta türleri

.NET Core, aşağıdaki tabloda gösterilen üç temel kayan nokta türü içerir.

Tür	Boyut (bayt)	Minimum değer	Maksimum değer
Çift	8	−1.79769313486232e308	1.79769313486232e308
Tek	4	−3.402823e38	3.402823e38
Ondalık	16	,279,228,162,514,264,337,593,5 43,950,335	79.228.162.514.264.337.593.543,9 50.335

Her kayan nokta türü, standart bir aritmetik, karşılaştırma, eşitlik, açık dönüştürme ve örtük dönüştürme işleçleri kümesini destekler.
BitConverter sınıfını kullanarak Double ve Single değerlerinde ayrı bitlerle de çalışabilirsiniz.
Decimal yapısının, bir ondalık değerin ayrı bitleriyle çalışmak için Decimal.GetBits ve Decimal.Decimal (Int32 ()) adlı kendi yöntemleri ve bazı ek matematiksel işlemleri gerçekleştirmek için kendi yöntem kümeleri vardır.

BigInteger

System.Numerics.BigInteger, teorik olarak değeri üst veya alt sınırlara sahip olmayan rastgele büyük bir tamsayıyı temsil eden değişmez bir türdür.
BigInteger türünün yöntemleri, diğer integral türlerindekilere yakından paraleldir.

Karmaşık

System.Numerics.Complex türü karmaşık bir sayıyı temsil eder, yani gerçek sayı bölümü ve sanal sayı bölümü olan bir sayı
Standart bir dizi aritmetik, karşılaştırma, eşitlik, açık dönüştürme ve örtük dönüştürme işleçlerinin yanı sıra matematiksel, cebirsel ve trigonometrik yöntemleri destekler.

SIMD

Numerics ad alanı, .NET Core için bir dizi SIMD etkin vektör türü içerir.
SIMD, bazı işlemlerin donanım düzeyinde paralelleştirilmesine izin verir, bu da vektörler üzerinden hesaplamalar yapan matematiksel, bilimsel ve grafik uygulamalarında büyük performans iyileştirmeleri sağlar.
.NET Core'daki SIMD etkin vektör türleri aşağıdakileri içerir -
- Single türünde 2, 3 ve 4 boyutlu vektörler olan System.Numerics.Vector2, System.Numerics.Vector3 ve System.Numerics.Vector4 türleri.
- Herhangi bir ilkel sayısal türden bir vektör oluşturmanıza olanak tanıyan Vector <T> yapısı. İlkel sayısal türler, Ondalık dışında System ad alanındaki tüm sayısal türleri içerir.
- İki matris türü, System.Numerics.Matrix3 × 2, 3 × 2 matrisi temsil eder; ve System.Numerics.Matrix4 × 4, 4 × 4 matrisi temsil eder.
- Üç boyutlu bir düzlemi temsil eden System.Numerics.Plane türü ve üç boyutlu fiziksel dönüşleri kodlamak için kullanılan bir vektörü temsil eden System.Numerics.Quaternion türü.

Bu bölümde, .NET yönetimli kod platformunun en önemli özelliklerinden biri olan Çöp toplama kavramını ele alacağız. Çöp toplayıcı (GC), belleğin tahsisini ve serbest bırakılmasını yönetir. Çöp toplayıcı, otomatik bir hafıza yöneticisi görevi görür.

Belleği nasıl tahsis edeceğinizi ve serbest bırakacağınızı veya bu belleği kullanan nesnelerin ömrünü nasıl yöneteceğinizi bilmenize gerek yoktur.
Bir “yeni” anahtar sözcük içeren bir nesneyi her bildirdiğinizde veya bir değer türü kutu içine alındığında bir ayırma yapılır. Tahsisler genellikle çok hızlıdır
Bir nesneyi ayırmak için yeterli bellek olmadığında, GC, belleği yeni ayırmalar için kullanılabilir hale getirmek için çöp belleği toplamalı ve atmalıdır.
Bu süreç olarak bilinir garbage collection.

Çöp Toplamanın Avantajları

Çöp Toplama aşağıdaki faydaları sağlar -

Uygulamanızı geliştirirken belleği manuel olarak boşaltmanıza gerek yoktur.
Ayrıca, yönetilen yığın üzerindeki nesneleri verimli bir şekilde tahsis eder.
Nesneler artık kullanılmadığında, bu nesneleri hafızalarını temizleyerek geri kazanacak ve hafızayı gelecekteki tahsisler için kullanılabilir durumda tutacaktır.
Yönetilen nesneler, başlamak için otomatik olarak temiz içerik alır, böylece kurucularının her veri alanını başlatması gerekmez.
Ayrıca bir nesnenin başka bir nesnenin içeriğini kullanamadığından emin olarak bellek güvenliği sağlar.

Çöp Toplama Şartları

Çöp toplama, aşağıdaki koşullardan biri doğru olduğunda gerçekleşir.

Sistemin fiziksel belleği düşüktür.
Yönetilen öbek üzerinde ayrılmış nesneler tarafından kullanılan bellek kabul edilebilir bir eşiği aşıyor. Bu eşik, işlem devam ederken sürekli olarak ayarlanır.
GC.Collectyöntem çağrılır ve hemen hemen tüm durumlarda, çöp toplayıcı sürekli çalıştığı için bu yöntemi çağırmanız gerekmez. Bu yöntem öncelikle benzersiz durumlar ve testler için kullanılır.

Nesiller

.NET Çöp Toplayıcısının 3 nesli vardır ve her neslin, ayrılmış nesnelerin depolanması için kullanılan kendi yığını vardır. Çoğu nesnenin ya kısa ya da uzun ömürlü olduğuna dair temel bir ilke vardır.

Önce Nesil (0)

Nesil 0'da, nesneler önce tahsis edilir.
Bu nesilde, nesneler, bir sonraki çöp toplama gerçekleştiğinde artık kullanımda olmadıklarından (kapsam dışında) olduklarından, genellikle ilk nesli geçmezler.
Generation 0 hızlı bir şekilde toplanır çünkü ilişkili yığın küçüktür.

İkinci Nesil (1)

Nesil 1'de nesnelerin ikinci bir şans alanı var.
Kısa ömürlü, ancak nesil 0 koleksiyonunda (genellikle rastlantısal zamanlamaya dayalı olarak) hayatta kalan nesneler 1. nesle gider.
Nesil 1 koleksiyonları da hızlıdır çünkü ilişkili yığın da küçüktür.
İlk iki yığın küçük kalır çünkü nesneler ya toplanır ya da bir sonraki nesil yığına yükseltilir.

Üçüncü Nesil (2)

2. Nesil'de, tüm uzun nesneler yaşar ve yığını çok büyüyebilir.
Bu nesildeki nesneler uzun süre hayatta kalabilir ve nesneleri daha fazla tanıtmak için yeni nesil bir yığın yoktur.
Çöp Toplayıcı, Büyük Nesne Yığını (LOH) olarak bilinen büyük nesneler için ek bir yığın içerir.
85.000 bayt veya daha büyük nesneler için ayrılmıştır.
Büyük nesneler, nesil yığınlarına tahsis edilmez, ancak doğrudan LOH'ye tahsis edilir.
Nesil 2 ve LOH koleksiyonları, uzun süredir çalışan veya büyük miktarda veri üzerinde çalışan programlar için fark edilir bir zaman alabilir.
Büyük sunucu programlarının GB'ların 10'unda yığınları olduğu bilinmektedir.
GC, programın yürütülmesini engellediği süreyi azaltmak için çeşitli teknikler kullanır.
Birincil yaklaşım, programın yürütülmesini engellemeyecek şekilde bir arka plan iş parçacığı üzerinde olabildiğince fazla çöp toplama işi yapmaktır.
GC ayrıca, geliştiricilerin davranışını etkilemeleri için birkaç yol sunar ve bu, performansı iyileştirmek için oldukça yararlı olabilir.

Bu bölümde, .NET Core'un yürütme sürecini anlayacağız ve bunu .NET Framework ile karşılaştıracağız. Yönetilen yürütme süreci aşağıdaki adımları içerir.

Bir derleyici seçmek
Kodunuzu MSIL'de derleme
MSIL'i yerel koda derleme
Koşu kodu

Derleyici Seçmek

Çok dilli bir yürütme ortamıdır, çalışma zamanı çok çeşitli veri türlerini ve dil özelliklerini destekler.
Ortak dil çalışma zamanının sağladığı faydaları elde etmek için, çalışma zamanını hedefleyen bir veya daha fazla dil derleyicisi kullanmanız gerekir.

Kodunuzu MSIL'de derleme

Derleme, kaynak kodunuzu Microsoft Ara Diline (MSIL) çevirir ve gerekli meta verileri oluşturur.
Meta veriler, her türün tanımı, her türün üyelerinin imzaları, kodunuzun başvurduğu üyeler ve çalışma zamanının yürütme sırasında kullandığı diğer veriler dahil olmak üzere kodunuzdaki türleri açıklar.
Çalışma zamanı, yürütme sırasında gerektiği şekilde dosyadan ve çerçeve sınıfı kitaplıklarından (FCL) meta verileri bulur ve çıkarır.

MSIL'i Yerel Koda Derleme

Yürütme zamanında, bir tam zamanında (JIT) derleyici MSIL'i yerel koda çevirir.
Bu derleme sırasında kod, kodun tür açısından güvenli olup olmadığının belirlenip belirlenemeyeceğini öğrenmek için MSIL ve meta verileri inceleyen bir doğrulama sürecinden geçmelidir.

Koşu Kodu

Ortak dil çalışma zamanı, yürütmenin gerçekleşmesini sağlayan altyapıyı ve yürütme sırasında kullanılabilecek hizmetleri sağlar.
Yürütme sırasında, yönetilen kod, çöp toplama, güvenlik, yönetilmeyen kodla birlikte çalışabilirlik, diller arası hata ayıklama desteği ve gelişmiş dağıtım ve sürüm oluşturma desteği gibi hizmetleri alır.

.NET Çekirdek Kod Yürütme Süreci

Şimdi kodun .NET Core ile nasıl yürütüldüğünü .NET Framework ile karşılaştıralım. .NET Core'da, .NET Framework'ün bir parçası olan bu bileşenlerin pek çok değişimi vardır.

.NET Core'da artık Roslyn for C # ve VB gibi yeni bir derleyici serimiz var.
NET Core ile F # kullanmak istiyorsanız, yeni F # 4.1 derleyicisini de kullanabilirsiniz.
Aslında bu araçlar farklıdır ve C # 6 veya sonraki bir sürümünü kullanıyorsak Roslyn'i .NET Framework ile de kullanabiliriz çünkü C # derleyicisi yalnızca C # 5'e kadar destekleyebilir.
.NET Core'da, bir çerçeve sınıf kitaplığımız (FCL) yok, bu nedenle farklı bir kitaplık seti kullanılıyor ve şimdi CoreFx'e sahibiz.
CoreFx, .NET Core için sınıf kitaplıklarının yeniden uygulanmasıdır.
Ayrıca CoreCLR olarak bilinen .NET Core ile yeni bir çalışma zamanımız var ve bir JIT Derleyicisinden yararlanıyoruz.
Şimdi soru, zaten .NET çerçevesinde sahip olduğumuz tüm bu bileşenlerin yeniden uygulanmasına neden sahip olduğumuzdur.
Dolayısıyla cevap, Microsoft'un neden .NET Core'u uyguladığıyla aynı.

Modüler bir uygulama oluşturmak ve uygulamak .NET Core'un başka bir düşüncesi. NET Framework'ün tamamını yüklemek yerine, uygulamanız artık yalnızca gerekli olanı yükleyebilir. Görsel stüdyoya gidip modülerliği görelim.

İşte Çözüm Gezgini'ndeki basit .NET Core uygulamamız. Referansları genişletmemize izin verin ve .NETCoreApp referansını göreceksiniz.

.NETCoreApp'in içinde NuGet'e paket başvurusunu göreceksiniz; hadi genişletelim.

NuGet Paketi referanslarının tüm serisini göreceksiniz. .NET Framework'te çalıştıysanız, bu ad alanlarının çoğu tanıdık gelecektir, çünkü .NET Framework'te kullanmaya alışmışsınızdır.

.NET Framework birçok farklı parçaya bölünür ve CoreFx ile yeniden uygulanır; bu parçalar ayrıca ayrı paketler olarak dağıtılır.

Şimdi NETStandard.Library'yi genişletirseniz, ek referanslar göreceksiniz. Bu uygulamada kullandığımız System.Console'u bile fark edeceksiniz.
Artık .NET Framework'ün içindeki her şeyi getirmek zorunda değilsiniz, sadece uygulamanız için ihtiyacınız olanı getirin.
Başka faydalar da var; örneğin, bu modüller istenirse ayrı ayrı güncellenebilir.

Modülerlik, performans avantajları sağlar ve uygulamanız, özellikle ASP.NET Core uygulaması daha hızlı çalışabilir.

Bu bölümde, .NET Core proje dosyalarını ve projenize mevcut dosyaları nasıl ekleyebileceğinizi tartışacağız.

Halihazırda oluşturulmuş bazı dosyalara sahip olduğumuz basit bir örneği anlayalım; Bu dosyaları FirstApp projemize eklemeliyiz.

İşte uygulaması Student.cs dosya

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Student { 
      public int ID { get; set; } 
      public string LastName { get; set; } 
      public string FirstMidName { get; set; } 
      public DateTime EnrollmentDate { get; set; } 
   } 
}

İşte uygulaması Course.cs dosya.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace FirstApp { 
   public class Course { 
      public int CourseID { get; set; } 
      public string Title { get; set; } 
      public int Credits { get; set; } 
   } 
}

Şimdi bu üç dosyayı diskinize ve projenizin kaynak klasörüne kaydedelim.

Şimdi .NET'e aşina iseniz ve bu geleneksel bir .NET çerçeve konsol uygulamasıysa, bu dosyaları Visual Studio'daki projenize nasıl ekleyeceğinizi anlamak önemlidir.
Dosyaları proje klasörünüze kopyalamak için önce çözüm gezginine sürüklemeniz gerekir, çünkü projenizin bu dosyalara başvurması gerekir.
.NET Core'un faydalarından biri proje dosyasıyla (project.json) alınan yaklaşımdır; dosyaları sadece projemizin köküne bırakabiliriz ve sonra bunlar otomatik olarak projemize dahil edilir.
Visual Studio'daki geleneksel .NET Framework uygulaması için geçmişte yaptığımız gibi dosyalara manuel olarak başvurmak zorunda değiliz.

Şimdi projenizin kökünü açalım.

Şimdi üç dosyayı da projenizin kök dizinine kopyalayalım.

Artık kök klasöre kopyalanan tüm dosyaları görebilirsiniz.

Şimdi Visual Studio'ya geçelim; aşağıdaki iletişim kutusunu alacaksınız.

Tıklayın Yes to All projenizi yeniden yüklemek için.

Artık dosyalar projenize otomatik olarak dahil edilecektir.

Bu bölümde, .NET Core uygulamanıza nasıl paket ekleyeceğinizi ve belirli bir paketi nasıl bulacağınızı tartışacağız. Doğrudan NuGet'e gidip paket ekleyebiliriz, ancak burada başka yerler de göreceğiz.

Şimdi burada bulunan .NET Core kaynak koduna gidelim - https://github.com/dotnet/corefx

CoreFx deposunda, src klasör -

Ve farklı paketlere karşılık gelen tüm klasörlerin listesini göreceksiniz. Şimdi Json'ı arayalım -

Paketinizi bulmanın başka bir yolu vardır, .NET Framework'e aşina iseniz muhtemelen çeşitli türleri biliyorsunuzdur, ancak .NET Core'da paketlerin bir araya getirilmesi tamamen farklıdır ve bu paketlerin nerede olduğunu bilemezsiniz.

Türü biliyorsanız, ters paket aramasını kullanarak arama yapabilirsiniz. https://packagesearch.azurewebsites.net/

Buraya bulmak istediğiniz her tür paketi girebilirsiniz. Ardından, bu site NuGet'i tarayacak ve sizin için ilgili paketleri bulacaktır.

Şimdi arayalım DataContractJson.

Şimdi aynı paketi aldığımızı göreceksiniz; pakete tıklayalım.

Şimdi NuGet sayfasını göreceksiniz; bu pakete ihtiyacınız olduğunu onaylamanız gerekiyor. Bunu birkaç yöntem kullanarak uygulamanıza ekleyebilirsiniz.

Project.json dosyasını açalım.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      } 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "dnxcore50" 
      } 
   } 
}

Bu yeni proje formatıdır ve bu dosyanın içinde bağımlılıklar bölümünü göreceksiniz. Aşağıda gösterildiği gibi yeni bir bağımlılık ekleyelim.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
      "System.Runtime.Serialization.Json": "4.0.2" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "dnxcore50" 
      } 
   } 
}

Şimdi referanslarınıza bakarsanız, göreceksiniz ki System.Runtime.Serialization.Json paket projenize eklenir.

Başka bir yol da NuGet Yöneticisine gidip eklemek istediğiniz pakete göz atmaktır.

Bu bölümde, .NET Core kullanarak bir UWP uygulamasının nasıl oluşturulacağını tartışacağız. UWP, Windows 10 UWP uygulaması olarak da bilinir. Bu uygulama Windows'un önceki sürümlerinde çalışmaz, ancak yalnızca Windows'un gelecekteki sürümlerinde çalışacaktır.

Aşağıda, UWP'nin sorunsuz çalışacağı birkaç istisna verilmiştir.

Yerel olarak çalıştırmak istiyorsanız, Windows 10'a sahip olmalısınız, Windows 8'de de geliştirebilirsiniz ve ardından Emulator'da çalıştırmanız gerekir, ancak Windows 10'u kullanmanız önerilir.
UWP uygulaması için ayrıca Windows 10 SDK'ya ihtiyacınız olacaktır. Visual Studio 2015 kurulumunu açalım ve ardından Visual Studio'yu değiştirelim.
Seçili özellikler sayfasında aşağı kaydırın ve Evrensel Windows Uygulama Geliştirme Araçlarını göreceksiniz, bu seçeneği aşağıda gösterildiği gibi işaretleyin.

Burada SDK'nın farklı sürümlerini ve Araçlar'daki en son güncellemeleri de görebilirsiniz, İleri'ye tıklayın.

Şimdi tıklayın Install buton.

Kurulum tamamlandığında, sisteminizi yeniden başlatmanız gerekecektir.

Şimdi bu adımları izleyerek UWP'yi uygulayalım.

İlk olarak, Visual Studio 2015'i başlatın.
Dosya menüsüne tıklayın ve Yeni → Proje'yi seçin; Yeni Proje iletişim kutusu görünecektir. İletişim kutusunun sol bölmesinde farklı şablon türlerini görebilirsiniz.

Sol bölmede, ağaç görünümünü görebilirsiniz, şimdi Şablonlar → Görsel C # → Windows'tan Evrensel şablonu seçin.
Orta bölmeden Boş Uygulama (Evrensel Pencereler) şablonunu seçin.
Yazarak projeye bir isim verin UWPFirstApp Ad alanında ve Tamam'ı tıklayın.

Hedef sürüm / minimum sürüm iletişim kutusu görüntülenir. Bu eğitim için varsayılan ayarlar uygundur, bu nedenle projeyi oluşturmak için Tamam'ı seçin.

Burada, tüm Windows 10 Cihazlarını hedefleyebilen tek bir projemiz var ve hem .NET Core hem de UWP'nin çoklu hedeflemeyi basitleştirdiğini fark edeceksiniz.
Yeni bir proje açıldığında, dosyaları Çözüm Gezgini bölmesinin sağ tarafında görüntülenir. Dosyalarınızı görmek için Özellikler sekmesi yerine Çözüm Gezgini sekmesini seçmeniz gerekebilir.
Boş Uygulama (Evrensel Pencere) minimal bir şablon olmasına rağmen, yine de çok sayıda dosya içerir. Bu dosyalar, C # kullanan tüm UWP uygulamaları için gereklidir. Visual Studio'da oluşturduğunuz her proje, dosyaları içerir.
Çalışan örneği görmek için MainPage.XAML'i açalım ve aşağıdaki kodu ekleyelim.

<Page 
   x:Class = "UWPFirstApp.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPFirstApp" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel HorizontalAlignment = "Center"> 
         <TextBlock Text = "Hello, world!"  
            Margin = "20" 
            Width = "200" 
            HorizontalAlignment = "Left"/> 
         <TextBlock Text = "Write your name." 
            Margin = "20" 
            Width = "200" 
            HorizontalAlignment = "Left"/> 
         <TextBox x:Name = "txtbox"  
            Width = "280" 
            Margin = "20" 
            HorizontalAlignment = "Left"/> 
         <Button x:Name = "button" Content = "Click Me" 
            Margin = "20" 
            Click = "button_Click"/> 
         <TextBlock x:Name = "txtblock"  
            HorizontalAlignment = "Left" 
            Margin = "20"/> 
      </StackPanel> 
   </Grid> 

</Page>

Aşağıda C # 'da butona tıklama olayı verilmiştir.

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Runtime.InteropServices.WindowsRuntime; 

using Windows.Foundation; 
using Windows.Foundation.Collections; 

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation;  

// The Blank Page item template is documented at 
// http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPHellowWorld { 
   /// <summary> 
   /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
   public sealed partial class MainPage : Page { 
      public MainPage() { 
         this.InitializeComponent(); 
      }  
      private void button_Click(object sender, RoutedEventArgs e) { 
         if (txtbox.Text != "") 
            txtblock.Text = "Hello: " + txtbox.Text; 
         else 
            txtblock.Text = "You have not write your name"; 
      } 
   } 
}

Şimdi yukarıdaki kodu yerel makinede çalıştıralım ve aşağıdaki pencereyi göreceksiniz. Şimdi metin kutusuna herhangi bir ad yazın veClick Me buton.

Bu bölümde MSBuild'in ne olduğunu ve .NET Core ile nasıl çalıştığını tartışacağız. MSBuild, Microsoft ve Visual Studio için derleme platformudur. UWP uygulamasında proje klasörünü açarsanız hem project.json hem de * .csproj dosyalarını görürsünüz.

Ancak önceki .NET Core Konsol uygulamamızı açarsanız, project.json ve * .xproj dosyalarını görürsünüz.

.NET Core yapı sistemi veya project.json yapı sistemi, UWP gereksinimleri için yeterli değildir; UWP'nin hala * .csproj (MSBuild) Build sistemini kullanmasının nedeni budur.
Ancak project.json, yapı sistemi söz konusu olduğunda taşınacaktır.
Şimdi, Konsol uygulamasına eklediğimiz haliyle UWP uygulamanıza birkaç mevcut dosya eklemek istiyorsanız, bu dosyaları proje klasörüne eklemeniz gerekir. Ayrıca, projenize Çözüm Gezgini'ne de dahil etmeniz gerekecektir.

Şimdi şu dosyalara bakalım; bu dosyaları proje klasörünüze kopyalayın.

Visual Studio'ya geri dönelim ve Solution Explorer'ı açalım.

Artık UWP uygulamalarında sadece dosya kopyalamanın yeterli olmadığını görebilirsiniz çünkü Solution Explorer'da bu dosyaları göremiyoruz.
Şimdi bu dosyaları da tıklayarak eklemeliyiz. Show All Files simgesi yukarıdaki ekran görüntüsünde vurgulanır ve artık proje klasöründeki tüm dosyaları göreceksiniz.

Bu iki dosya hala projemize dahil edilmemiştir. Bu dosyaları dahil etmek için, bu dosyaları seçin ve herhangi bir dosyaya sağ tıklayın ve ardındanInclude in Project.

Şimdi bu dosyalar da dahildir. Öngörülebilecek iyi bir şey, SKD araçlarının gelecekteki sürümlerinde * .csproj için dosyaları bırakma ve ayrıca Visual Studio'ya proje.json yaklaşımıdır.

Bu bölümde, Konsol uygulamamız ile UWP uygulamamız arasındaki referansları tartışacağız. Konsol uygulamanızın Çözüm Gezgini'ndeki Referanslara bakarsanız, aşağıda gösterildiği gibi .NETCoreApp'i göreceksiniz.

.NETCoreApp, .NET Core uygulamasını hedefleyen yeni bir çerçevedir. Şimdi UWP uygulamasının Referanslarına bakarsanız, aşağıda gösterildiği gibi biraz farklı görünecektir.

Bunun ana nedeni, UWP'de * .csproj'a sahip olmamızdır, bu yüzden eski stil referanslara geri döndük ve bu proje türü ile yalnızca bir çerçeveyi hedefleyebiliyoruz.
Referanslar yine de benzer. Artık UWP uygulamasında Miscrosoft.NETCore.UniversalWindowsPlatform NuGet Paketi başvurusunun Konsol uygulamasındaki Microsoft.NETCore.App NuGet başvurusuna benzer olduğunu görebilirsiniz.
Hem Miscrosoft.NETCore.UniversalWindowsPlatform hem de Microsoft.NETCore.App meta paketidir, bu da diğer paketlerden oluştukları anlamına gelir.
Konsol uygulamasında, Microsoft.NETCore.App içindeki diğer paketleri inceleyebilir ve görebiliriz, ancak aynı Miscrosoft.NETCore.UniversalWindowsPlatform'u Solution Explorer'da yapamayız.
Bununla birlikte, buna bakmak için NuGet Paket Gezgini olan başka bir aracı kullanabiliriz. Şimdi bu url'yi tarayıcıda açalım -https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application ve küçük bir yardımcı programın indirildiğini göreceksiniz.
İndirme tamamlandığında, o dosyaya çift tıklayın.

Tıklayın Install NuGet Paket Gezgini'nde yüklemeyi başlatmak için.

Kurulum bittiğinde aşağıdaki iletişim kutusunu göreceksiniz.

Şimdi tıklayalım Open a package from online feed seçeneği.

Varsayılan olarak nuget.org beslemesini arayacaktır. Şimdi arama kutusunda Microsoft.NETCore.UniversalWindowsPlatform'u arayalım ve aşağıda gösterildiği gibi 1 sonuç göreceksiniz.

Tıkla open bağlantı ve bu meta paketin üst düzey bağımlılıklarını açacaktır.

Şimdi .NETCore uygulaması için .NETCore meta paketini ve UWP uygulaması için meta paketini yan yana açalım.

Artık her bir meta paketin farklı paketlerden oluştuğunu görebilirsiniz.
.NET Core, en azından bu noktada .NET Framework'te bulunan sınıfların bir alt kümesidir, ancak büyümektedir ve .NET Framework'ün temel sınıflarına göre olacaktır.
UWP, .NET Core tabanlıdır ve Windows Mağazası geliştirme için kullanılabilen API'lerin bir üst kümesidir.

Artık .NET Core sayesinde geliştirme için daha fazla API'ye sahibiz.

Windows Runtime bileşenleri, C #, Visual Basic, JavaScript ve C ++ dahil herhangi bir dilden başlatabileceğiniz ve kullanabileceğiniz bağımsız nesnelerdir. Önceki bölümde gördüğümüz .NET Core meta paketine ek olarak, UWP uygulamasının varsayılan olarak bir Evrensel Windows SDK referansı da vardır.

Evrensel Windows, Windows Çalışma Zamanı'na referanstır ve bir dizi API sözleşmesine dahil edilmiştir.

Bir cihaz ailesindeki API kümesi, API sözleşmeleri olarak bilinen alt bölümlere ayrılmıştır. Burada farklı API sözleşmelerinin bir listesini bulabilirsinizhttps://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

Windows çalışma zamanı içindeki bu API'lerin çoğu, tek bir sözleşmeye dahil edilir. Şimdi API Sözleşmeleri sayfasında Universal anahtar kelimesini arayalım.

Çeşitli API'lerin bağlantılarını görebilir ve ayrıca Universal ailesinin 12 sayfalık dokümantasyona sahip olacak kadar büyük olduğunu görebilirsiniz.

Ayrıca bu sayfada telefon API sözleşmesini de arayabilirsiniz.

Şimdi tıklayalım Windows.Phone.PhoneContractve aşağı kaydırın; şimdi telefonun veya mobil cihazın pil bilgilerini göreceksiniz.

Bu bilgiyi zaten sahip olduklarınızın üzerine eklemek istiyorsanız, referansları manuel olarak eklemelisiniz. Şimdi Visual Studio'ya gidelim ve Çözüm Gezgini'ndeki Referanslar'a sağ tıklayalım.

Seçiniz Add References…

Artık Evrensel Windows için yeni referans kategorisini görebilirsiniz; Bu kategori altında, temel Evrensel Windows API sözleşmelerine atıfta bulunan Çekirdek vardır

Uzantılar, işlevselliği genişletmemize izin verir ve Mobil, Masaüstü ve diğer Uzantılar için farklı referanslar göreceksiniz.
Farklı SKD uzantıları vardır ve daha fazla API almak için en üste ekleyebilirsiniz.
Farklı versiyonları da görebilirsiniz. Bu nedenle, güncellenmiş API'leri almak için en son sürümü aldığınızdan emin olun ve ardından Tamam'ı tıklayın.

Şimdi görebilirsin Windows Mobile Extensions for the UWP referans olarak eklenir.

Bir sınıf kitaplığı, herhangi bir uygulamadan çağrılabilen türleri ve yöntemleri tanımlar.

.NET Core kullanılarak geliştirilen bir sınıf kitaplığı, kitaplığınızın .NET Standart Kitaplığının bu sürümünü destekleyen herhangi bir .NET platformu tarafından çağrılmasına olanak tanıyan .NET Standart Kitaplığı'nı destekler.
Sınıf kitaplığınızı bitirdiğinizde, onu üçüncü taraf bir bileşen olarak dağıtmak isteyip istemediğinize veya bir veya daha fazla uygulamayla birlikte paketlenmiş bir bileşen olarak dahil etmek isteyip istemediğinize karar verebilirsiniz.

Konsol uygulamamıza bir sınıf kitaplığı projesi ekleyerek başlayalım; sağ tıklayınsrc Çözüm Gezgini'nde klasör ve seçin Add → New Project…

İçinde Add New Project iletişim kutusunda, .NET Core düğümünü seçin, ardından Sınıf Kitaplığı (.NET Core) proje şablonunu seçin.

Ad metin kutusuna, aşağıdaki şekilde gösterildiği gibi proje adı olarak "UtilityLibrary" girin.

Sınıf kitaplığı projesini oluşturmak için Tamam'ı tıklayın. Proje oluşturulduktan sonra yeni bir sınıf ekleyelim. Sağ tıklayınproject Solution Explorer'da ve seçin Add → Class...

Orta bölmede sınıfı seçin ve ada ve alana StringLib.cs girin ve ardından Add. Sınıf eklendikten sonra, StringLib.cs dosyasında aşağıdaki kodu değiştirin.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace UtilityLibrary { 
   public static class StringLib { 
      public static bool StartsWithUpper(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false; 
         Char ch = str[0]; 
         return Char.IsUpper(ch); 
      } 
      public static bool StartsWithLower(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false; 
         Char ch = str[0]; 
         return Char.IsLower(ch); 
      } 
      public static bool StartsWithNumber(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
         return false;  
         Char ch = str[0]; 
         return Char.IsNumber(ch); 
      } 
   } 
}

Sınıf kitaplığı, UtilityLibrary.StringLibgibi bazı yöntemler içerir, StartsWithUpper, StartsWithLower, ve StartsWithNumber Bu, geçerli dize örneğinin sırasıyla büyük harf, küçük harf ve sayı ile başlayıp başlamadığını gösteren bir Boolean değeri döndürür.
.NET Core'da, Char.IsUpper yöntemi, bir karakter büyük harf ise, true değerini döndürür, Char.IsLower yöntemi, bir karakter küçük harfli ise true değerini döndürür ve benzer şekilde, bir karakter sayısal ise Char.IsNumber yöntemi true döndürür.
Menü çubuğunda Build, Build Solution'ı seçin. Proje hatasız derlenmelidir.
.NET Core konsol projemizin sınıf kitaplığımıza erişimi yoktur.
Şimdi bu sınıf kitaplığını kullanmak için konsol projemize bu sınıf kitaplığının referansını eklememiz gerekiyor.

Bunu yapmak için FirstApp'i genişletin ve Referanslar'a sağ tıklayın ve Add Reference…

Referans Yöneticisi iletişim kutusunda, sınıf kitaplığı projemiz olan UtilityLibrary'yi seçin ve ardından OK.

Şimdi konsol projesinin Program.cs dosyasını açalım ve tüm kodu aşağıdaki kodla değiştirelim.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
using UtilityLibrary; 

namespace FirstApp { 
   public class Program { 
      public static void Main(string[] args) { 
         int rows = Console.WindowHeight; 
         Console.Clear(); 
         do { 
            if (Console.CursorTop >= rows || Console.CursorTop == 0) { 
               Console.Clear(); 
               Console.WriteLine("\nPress <Enter> only to exit; otherwise, enter a string and press <Enter>:\n"); 
            } 
            string input = Console.ReadLine(); 
            
            if (String.IsNullOrEmpty(input)) break; 
            Console.WriteLine("Input: {0} {1,30}: {2}\n", input, "Begins with uppercase? ", 
            input.StartsWithUpper() ? "Yes" : "No"); 
         } while (true); 
      } 
   } 
}

Şimdi uygulamanızı çalıştıralım ve aşağıdaki çıktıyı göreceksiniz.

Daha iyi anlamak için, projenizde sınıf kitaplığınızın diğer genişletme yöntemlerinden yararlanalım.

Bu bölümde, PCL'nin (Taşınabilir Sınıf Kitaplığı) ne olduğunu ve ayrıca neden PCL'ye ihtiyacımız olduğunu tartışacağız. Bu kavramı anlamak için, önceki bölümde oluşturduğumuz sınıf kitaplığı proje klasörünü açalım.

Bu klasörde, project.json ve CS dosyalarına ek olarak * .xproj dosyamız olduğunu görebilirsiniz ve bunun nedeni Visual Studio kurulum .NET Core proje tipinin * .csproj yerine * .xproj olmasıdır.

Microsoft tarafından belirtildiği gibi, * .xproj kaldırılacak, ancak yine de önizleme 2 araçlarında burada. UWP uygulamasının * .csproj kullandığını belirttiğimiz gibi.

Artık * .csproj'u referansa ve * .xproj'a almak mümkün değil ve bu işlevsellik uygulanmayacak çünkü * .xproj taşınacak.

Bunun yerine, konsol uygulaması ile UWP uygulaması arasında paylaşılabilen bir sınıf kitaplığına ihtiyacımız var ve işte PCL geliyor.

PCL nedir

Şimdi PCL'nin ne olduğunu anlayalım -

Taşınabilir Sınıf Kitaplığı projesi, birden fazla .NET Framework platformunda çalışan yönetilen derlemeler yazmanıza ve oluşturmanıza olanak tanır.
Paylaşılan iş mantığı gibi birçok projede paylaşmak istediğiniz kodu içeren sınıflar oluşturabilir ve ardından farklı proje türlerinden bu sınıflara başvurabilirsiniz.
Ayrıca, Microsoft platformları için hızlı ve kolay bir şekilde platformlar arası uygulamalar ve kitaplıklar oluşturmanıza yardımcı olabilir.
Taşınabilir sınıf kitaplıkları, kod geliştirme ve test etme sürelerini ve maliyetlerini azaltmanıza yardımcı olabilir.
Taşınabilir .NET Framework derlemeleri yazmak ve oluşturmak için bu proje türünü kullanın ve ardından Windows ve Windows Phone gibi birden çok platformu hedefleyen uygulamalardan bu derlemelere başvuruda bulunun.

Şimdi Çözüm Gezgini'nden oluşturduğumuz sınıf kitaplığını kaldıralım. Aynı zamanda Çözüm klasöründen silin ve yeni bir proje öğesi ekleyin.

Seçin Visual C# → Windows sol bölmede şablonu ve orta bölmede Sınıf Kitaplığı (Taşınabilir) öğesini seçin.

Ad alanına StringLibrary girin ve tıklayın OK bu projeyi oluşturmak için.

Şimdi referans verilecek hedef çerçeveleri seçmemiz gerekiyor. Windows Universal ve ASP.NET Core'u bir anlığına seçelim, sonra yeniden hedefleyelim. TıklayınOK.

PCF formatında yeni bir proje oluşturduğunu görebilirsiniz. Şimdi Çözüm Gezgini'nde StringLibrary projesine sağ tıklayıp Özellikler'i seçelim.

Hedef .NET Platform Standardına tıklayın.

Evet'i tıklayın; şimdi bir küçük farkla aynı sınıf kitaplığıdır. Aradaki fark, UWP tarafından da kullanılabilmesidir, çünkü * .xproj yerine * .csproj dosyası içerir.

Şimdi yeni bir sınıf ekleyelim; bunun için Çözüm Gezgini'nde projeye sağ tıklamanız veAdd → Class...

Orta bölmede sınıfı seçin ve girin StringLib.cs ad alanına ve ardından tıklayın Add. Sınıf eklendikten sonra, StringLib.cs dosyasında aşağıdaki kodu değiştirin.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
  
namespace StringLibrary { 
   public static class StringLib { 
      public static bool StartsWithUpper(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsUpper(ch); 
      } 
      public static bool StartsWithLower(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsLower(ch); 
      } 
      public static bool StartsWithNumber(this String str) { 
         if (String.IsNullOrWhiteSpace(str)) 
            return false; 
         Char ch = str[0]; 
         return Char.IsNumber(ch); 
      } 
   } 
}

Bu taşınabilir sınıf kitaplığı projesini oluşturalım ve hatasız derlenmelidir. Şimdi bu taşınabilir sınıf kitaplığının referansını konsol projemize eklememiz gerekiyor. Bu nedenle, FirstApp'ı genişletin ve Referanslar'a sağ tıklayın veAdd Reference…

Referans Yöneticisi iletişim kutusunda, taşınabilir sınıf kitaplığı projemiz olan StringLibrary'yi seçin ve ardından OK.

StringLibrary referansının konsol projesine eklendiğini ve project.json dosyasında da görülebildiğini görebilirsiniz.

Şimdi uygulamayı tekrar çalıştırabilirsiniz ve aynı çıktıyı göreceksiniz.

Şimdi taşınabilir sınıf kitaplığınızın diğer uzantı yöntemlerini projenizde kullanalım. Aynı taşınabilir kitaplık, UWP uygulamanızda da kullanılacaktır.

Bu bölümde, kitaplığınıza nasıl referans ekleneceğini tartışacağız. Kitaplığa referans eklemek, konsol projesi ve UWP projesi gibi diğer projelerinize referans eklemek gibidir.

Artık PCL projesinin varsayılan olarak bazı referanslara sahip olduğunu görebilirsiniz. Ayrıca uygulama ihtiyacınıza göre başka referanslar da ekleyebilirsiniz.

PCL kitaplığında, project.json dosyasını da görebilirsiniz.

{ 
   "supports": {}, 
   "dependencies": { 
      "NETStandard.Library": "1.6.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

Kitaplığınıza referans eklemenin bir yöntemi, bunu doğrudan project.json dosyasına yazmaktır. Gördüğünüz gibi, aşağıdaki kodda gösterildiği gibi bağımlılıklar bölümünün altına bazı referanslar ekledik.

{ 
   "supports": {}, 
   "dependencies": { 
      "NETStandard.Library": "1.6.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1", 
      "System.Runtime.Serialization.Json": "4.0.3", 
      "Microsoft.EntityFrameworkCore": "1.1.0" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

Şimdi bu dosyayı kaydedelim ve şimdi kitaplığınıza referansların eklendiğini göreceksiniz.

Kitaplığınıza başvuru eklemenin diğer yöntemi NuGet Paket Yöneticisidir. Şimdi sağ tıklayalımStringLibrary (Portable) proje ve seç Mange NuGet Packages…

Gözat sekmesinde, herhangi bir NuGet paketinde arama yapabilirsiniz; "System.Runtime.Serialization.Primitives" paketini eklemek istediğimizi söyleyelim.

Tıkla Install düğmesine, aşağıdaki ekranı görüntüleyecektir.

Şimdi tıklayın OK buton.

Son olarak, I AcceptBu NuGet paketinin kurulumunu başlatmak için düğme. Yükleme tamamlandığında, "System.Runtime.Serialization.Primitives" NuGet paketinin kitaplığınıza eklendiğini göreceksiniz.

Bu bölümde, kitaplığınızı nasıl paylaşacağınızı tartışacağız. NuGet Packageböylece başka bir proje içinde tüketilebilir. Bir paket oluşturmak, ya genel nuget.org galerisi ya da kuruluşunuz içindeki özel bir galeri aracılığıyla paketlemek ve başkalarıyla paylaşmak istediğiniz kodla başlar. Paket ayrıca aşağıdaki gibi ek dosyalar da içerebilir:readme paket yüklendiğinde görüntülenir ve belirli proje dosyalarına dönüşümleri içerebilir.

Şimdi kütüphanemizden bir NuGet paketi oluşturacağımız basit bir örneği ele alalım. Bunu yapmak için komut istemini açın ve kütüphane projenizin project.json dosyasının bulunduğu klasöre gidin.

Şimdi aşağıdaki komutu çalıştıralım.

dotnet help

Sonunda, new, restore ve build gibi farklı komutlar görebilirsiniz.

Son komut pack;bu bir NuGet paketi oluşturacaktır. Şimdi aşağıdaki komutu çalıştıralım.

dotnet pack

Artık NuGet paketlerinin bin klasöründe üretildiğini görebilirsiniz; bin \ Debug klasörünü açalım.

Şimdi soru NuGet Paket Gezgini'ni kullanabileceğimizi görmek için NuGet paketlerinin içinde ne olduğu. Şimdi NuGet Paket Gezgini'ni açalım.

İlk seçeneği seçin Open a local package.

Seçin StringLibrary.1.0.0.nupkg ve tıklayın Open.

Paket içeriği bölümünde sadece StringLibrary.dll'ye sahip olduğumuzu görebilirsiniz. Paket meta verileri bölümünde, bu kitaplık hakkında Id, Sürümler ve tüm bağımlılıklar gibi biraz bilgi göreceksiniz.

Şimdi açalım StringLibrary.1.0.0.symbols.nupkg.

Bu NuGet paketinde, kaynak dosyaları ve *.pdbdosya da. Çift tıklarsanızStringLib.cs dosya, kaynak kodunu da görürsünüz.

Buradaki soru, meta verileri sürüm, yazarlar ve açıklama gibi nasıl yapılandırabileceğidir.

Project.json dosyası, .NET Core projelerinde proje meta verilerini, derleme bilgilerini ve bağımlılıkları tanımlamak için kullanılır. Şimdi project.json dosyasını açalım ve aşağıdaki ek bilgileri ekleyelim.

{ 
   "authors": [ "Mark Junior" ], 
   "description": "String Library API", 
   "version" : "1.0.1-*", 
   "supports": {}, 
   
   "dependencies": { 
      "Microsoft.EntityFrameworkCore": "1.1.0", 
      "Microsoft.NETCore.Portable.Compatibility": "1.0.1", 
      "NETStandard.Library": "1.6.0", 
      "System.Runtime.Serialization.Json": "4.0.3", 
      "System.Runtime.Serialization.Primitives": "4.3.0" 
   }, 
   "frameworks": { 
      "netstandard1.3": {} 
   } 
}

Artık burada eklenen yazar adı, açıklama ve sürüm gibi ek bilgileri görebilirsiniz. Bu dosyayı kaydedelim, kütüphane projesini oluşturalım ve sonra “dotnet pack” komutunu tekrar çalıştıralım.

Bin \ Debug klasörünün içinde, StringLibrary NuGet paketlerinin 1.0.1 sürümüyle üretildiğini görebilirsiniz; NuGet Paket Gezgini'nde açalım.

Güncellenen meta verileri göreceksiniz. Şimdi soru, onu başka bir pakette nasıl kullanabiliriz.

NuGet feed'inde bir yerde yayınlayarak başlamalıyız ve sonra onu başka bir projede tüketebiliriz.

Güncellenen meta verileri yayınlamak için iki seçenek vardır -

Nuget.org'da yayınlayın
Meta verileri özel NuGet akışına gönderin

Burada özel NuGet beslemesini kullanacağız çünkü nuget.org'da bir hesap kurmaktan çok daha kolay. Paketinizi nuget.org'da nasıl yayınlayacağınızı öğrenmek için, burada belirtilen tüm yönergeleri takip edebilirsiniz.https://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package.

Güncellenen meta verileri özel NuGet akışına göndermek için bu adımları izleyin.

Step 1- Başlamak için nuget komut satırı yardımcı programına ihtiyacımız var ve onu yüklemeliyiz. Şimdi NuGet Paket Yöneticisini açalım ve nuget.commandline'ı arayalım.

Step 2 - Nuget.Commandline'ı seçin ve tıklayın Install.

Step 3 - Tıklayın OKNuget.Commandline'ı yüklemek için. Aşağıdaki URL'den indirerek manuel olarak da yükleyebilirsiniz.https://dist.nuget.org/index.html ve ardından ortam değişkenini ayarlayın.

Step 4 - Kurulum bittikten sonra komut istemini tekrar açalım ve bin\Debug NuGet paketlerinin bulunduğu klasör ve aşağıdaki komutu belirtin -

nuget add StringLibrary.1.0.1.nupkg -Source D:\PrivateNugetPackages

Step 5 - Yukarıdaki komutta StringLibrary.1.0.1.nupkg paketini özel feed'imize ekliyoruz ve konum D:\PrivateNugetPackages, -Kaynak paket kaynağını belirtir.

Step 6 - Gördüğünüz gibi StringLibraryyüklendi; StringLibrary özel beslemeye daha fazla eklenebilir.

Step 7 - O klasöre gidelim.

Step 8 - İçinde stringlibrary klasöründe, sürüm adına sahip başka bir klasör göreceksiniz ve burada 1.0.1.

NuGet paketi burada bulunur.

Bu bölümde, oluşturduğumuz ve özel bir NuGet feed'inde yayınladığımız NuGet paketini nasıl tüketeceğimizi tartışacağız. Bu yüzden önce bir Xamarin.Forms projesi oluşturacağız. Öncelikle Xamarin.Forms'un ne olduğunu anlamamız gerekiyor.

Xamarin.Forms, geliştiricilerin hızla çapraz platform kullanıcı arabirimleri oluşturmasına olanak tanıyan bir çerçevedir.
Xamarin.Forms, geliştiricilerin Android, iOS, Windows ve Windows Phone arasında paylaşılabilen kullanıcı arayüzlerini kolayca oluşturmasına olanak tanıyan, platformlar arası yerel olarak desteklenen bir UI araç seti soyutlamasıdır.
Kullanıcı arabirimleri, hedef platformun yerel denetimleri kullanılarak oluşturulur ve Xamarin.Forms uygulamalarının her platform için uygun görünümü ve hissi korumasına olanak tanır.

Xamarin.Forms'u başlatmak için Visual Studio 2015'te bazı ek özelliklere ihtiyacımız var. Visual Studio 2015'inizi değiştirelim ve aşağıdaki platformlar arası mobil geliştirme seçeneğinin seçildiğinden emin olalım.

Kurulum bittiğinde, Xamarin'i seçerek güncelleyelim. Tools → Options…

Aşağı kaydırın ve sol bölmede Xamarin'i genişletin ve ardından Other. İletişim kutusunun sağ üst köşesinde,Check Now güncelleme olup olmadığını görmek için.

Güncellemelerin mevcut olduğunu görebilirsiniz, tıklayın Downloadİndirmeye başlamak için düğmesine basın. İndirme tamamlandığında, güncellemeleri yüklemeniz için bilgilendirileceksiniz.

Şimdi Visual stüdyosunu tekrar açalım ve File → New → Project… menü seçeneği.

Sol bölmede, Visual C# → Cross-Platform şablonunu seçin ve orta bölmede Blank Xaml App (Xamarin.Forms Portable). Adı Ad alanına girin ve Tamam'ı tıklayın.

Hedef Sürümü ve Minimum Sürümü seçin ve Tamam'a tıklayın.

Bir dizi proje göreceksiniz; üstte Android, iOS, UWP, Windows 8.1 ve Windows Phone 8.1 gibi tüm platformlar arasında paylaşılacak olan PCL kitaplığımız var.

Burada, PCL kitaplığına odaklanacağız ve buraya biraz kod getireceğiz. Kodu genişletelim.

Bu Xamarin.Forms şablonunda, genel App.xaml ve MainPage.xaml'i görebilirsiniz, bu platformlar arasında çalışan Xamarin.Forms XAML çerçevesini kullanır.

Kodlarımızı içe aktarmamız gerekiyor ve ayrıca son bölümde kurduğumuz özel NuGet beslemesine ihtiyacımız var.

Şimdi NuGet Paket Yöneticisini açalım. Paket kaynağı açılır listesinin yanındaki tekerleğe tıklayın.

Özel beslememizi buraya eklememiz gerekiyor, plus (+) button.

Başka bir onay kutusunun eklendiğini göreceksiniz. Available package sources bölümünde bir ad ve kaynak yolu belirleyelim ve OK.

Şimdi Gözat sekmesine gidelim ve Paket kaynağı açılır listesinden Özel Kaynak'ı seçelim ve StringLibrary NuGet paketini göreceksiniz. StringLibrary'yi seçin ve tıklayınInstall.

Tamam'a tıkladığınızda bir hata göreceksiniz.

Kitaplığı .NETPortable profil sürüm 259 ile kullanamıyoruz, bu hatayı bir sonraki bölümde düzelteceğiz.

Bu bölümde, Xamarin.Forms projesindeki özel beslememizden NuGet paketini kurarken aldığımız hatayı düzelteceğiz.

Sorunu kısaca daha iyi anlayacağız. Başlamak için, PCL kitaplığına sağ tıklayıp Özellikler'i seçelim.

Bu sayfada, hedeflenen tüm çerçeve dizisini göreceksiniz. Hatadan, .NETPortable profilinin 259 bizim StringLibrary 1.0.1 ile uyumlu olmadığını görebilirsiniz. Ancak, .NET Standard 1.1 kitaplığından başvuru almaya çalışıyor.

Şimdi .NET Standart Kitaplığını görelim ve hangi platformun kitaplığımızla uyumlu olmadığını belirleyelim.

Windows Phone Silverlight 8'in .NET Standard 1.0 ile uyumlu olduğunu görebilirsiniz. Aşağıdaki web sayfasını açarsanız, Profile259'un yalnızca .NET Standard 1.0'ı destekleyebileceğini göreceksiniz.

Şimdi Windows Phone Silverlight 8'in işaretini kaldıralım.

Tıkla OK buton.

Şimdi bu sorunu düzeltmek için Tamam'a tıklayın ve Hedefleri Değiştir iletişim kutusunu iptal edin ve ardından Paket Yöneticisi Konsolunu açın ve aşağıdaki komutu yürütün.

PM > Uninstall-Package Xamarin.Forms

Şimdi PCL kütüphanesinin Özelliklerine gidelim. Değiştir düğmesine tıklayın.

Windows Phone Silverlight 8'in işaretini kaldırın ve Tamam'a tıklayın.

Artık Windows Phone Silverlight 8'in Hedeflenen çerçevede artık bulunmadığını görebilirsiniz. Artık hedef olan profili de görebilirsiniz. Bunu görmek için PCL kitaplığını kaldıralım ve XamarinApp.csproj dosyasını düzenleyelim.

Artık TargetFrameworkProfile'ın Profile111 olduğunu görebilirsiniz.

Belgeleri açarsanız, Profile111'in .NET Standard 1.1'i desteklediğini görürsünüz.

Şimdi PCL'yi yeniden yükleyelim ve NuGet Paket Yöneticisini açalım ve StringLibrary paketini özel beslemeden yüklemeyi deneyelim.

Bağımlılık davranışı açılır listesinden Bağımlılıkları Yoksay'ı seçin ve ardından Install.

StringLibrary paketinin artık özel beslemeden yüklendiğini görebilirsiniz. PCL Referanslarını genişletirseniz, StringLibrary referansının da aşağıda gösterildiği gibi eklendiğini göreceksiniz.

Windows Phone Silverlight 8 sorunu için Xamarin.Forms'u kaldırdık. Xamarin.Forms'un yeniden yüklenmesi gerekiyor. Aynı sürümün kurulması tavsiye edilir.

Kurulum tamamlandığında, uygulamanızda StringLibrary işlevini kullanmamıza izin verin.

Bu bölümde, .NET Core kullanarak bir Test projesinin nasıl oluşturulacağını tartışacağız. Birim testi, birim adı verilen bir uygulamanın en küçük test edilebilir parçalarına sahip yazılım için bir geliştirme sürecidir. Herhangi bir uygun işlem için ayrı ayrı ve bağımsız olarak incelenirler. Birim testi otomatik veya manuel olarak da yapılabilir.

Şimdi Yeni Proje iletişim kutusunu açalım ve Visual C# → .NET Core şablonu.

Bu iletişim kutusunda, birim testi için bir proje şablonu olmadığını görebilirsiniz. Bir birim test projesi oluşturmak için komut satırı yardımcı programını kullanmalıyız. Oluşturduğumuz Solution klasörüne gidelim; bir test klasörü oluşturun ve test klasörünün içinde başka bir klasör oluşturun ve onu çağırınStringLibraryTests.

Şimdi aşağıdaki komutu yürüterek yeni bir test projesi oluşturmak için dotnet komut satırı yardımcı programını kullanalım -

dotnet new -t xunittest

Artık yeni bir C # projesinin oluşturulduğunu görebilirsiniz; çalıştırarak klasöre bakalımv komut ve göreceksin project.json ve Tests.cs dosyaları aşağıda gösterildiği gibi.

İşte project.json dosyasındaki kod.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "debugType": "portable" 
   }, 
   "dependencies": { 
      "System.Runtime.Serialization.Primitives": "4.1.1", 
      "xunit": "2.1.0", 
      "dotnet-test-xunit": "1.0.0-rc2-192208-24" 
   }, 
   "testRunner": "xunit", 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "Microsoft.NETCore.App": { 
               "type": "platform", 
               "version": "1.0.1" 
            } 
         }, 
         "imports": [ 
            "dotnet5.4", 
            "portable-net451+win8" 
         ] 
      } 
   } 
}

Test.cs dosyasındaki kod aşağıdadır.

using System; 
using Xunit; 
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(true); 
      } 
   } 
}

NuGet'ten gerekli bağımlılıkları getirmek için aşağıdaki komutu çalıştıralım -

dotnet restore

Testi gerekli bağımlılıklar geri yüklendiğinde çalıştırabiliriz.

Derlemenin başarılı olduğunu görebilirsiniz; aşağı inerken, yapılan test hakkında bazı bilgiler görebilirsiniz.

Şu anda 1 test yürütüldü, 0 hata, 0 başarısız, 0 atlandı ve yürütme sürecinde geçen süre de bilgi olarak belirtildi.

Bu bölümde, Visual Studio'da testlerin nasıl çalıştırılacağını tartışacağız. .NET Core, test edilebilirlik düşünülerek tasarlandı, böylece uygulamalarınız için birim testleri oluşturmak her zamankinden daha kolay. Bu bölümde, test projemizi Visual Studio'da çalıştırıp yürüteceğiz.

FirstApp çözümünü Visual Studio'da açalım.

Gördüğünüz gibi sadece iki projesi var ve o projeyi çözümümüze eklemediğimiz için test projesini göremeyeceksiniz.

Önce bir klasör ekleyip onu arayalım test.

Sağ tıklayın test Klasör.

Seçiniz project.json dosyala ve tıkla Open.

Aşağıdaki ekran görüntüsü kodu gösteriyor Tests.cs dosya çıktı olarak.

Varsayılan uygulama budur ve sadece True'nun true'ya eşit olduğunu test etmektedir. Bu, xUnit test çerçevesidir ve test yöntemini açıklayan ve belirten Fact özniteliğini göreceksiniz.

using System; 
using Xunit; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(true); 
      } 
   } 
}

Aşağıdaki uygulamasıdır project.json dosya.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "debugType": "portable" 
   }, 
   "dependencies": { 
      "System.Runtime.Serialization.Primitives": "4.1.1", 
      "xunit": "2.1.0", 
      "dotnet-test-xunit": "1.0.0-rc2-192208-24" 
   }, 
   "testRunner": "xunit", 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "Microsoft.NETCore.App": { 
               "type": "platform", 
               "version": "1.0.1" 
            }
         }, 
         "imports": [ 
            "dotnet5.4", 
            "portable-net451+win8" 
         ] 
      } 
   } 
}

İçinde project.jsonfile, test çerçevesine en önemli bağımlılık, Fact özniteliğini getiren xunit'tir. Xunit ile test etmek için test çerçevesini ve API'leri getirir.

Bizde de var dotnet-test-xunit, bu, xunit'in özellikle .NET Core ile çalışabilmesi için benimseyen bir araçtır. dotnet testkomut satırı yardımcı programı. Sonra göreceksintestRunner xunit'i çalıştıracak ve ayrıca netcoreapp1.0 çerçeve.

Aşağıda .NETCore.App bağımlılığını göreceksiniz.

Visual Studio'da testi çalıştırmak için, Test Gezgini'ni Test → Window → Test Explorer menü seçeneği.

Ve Visual Studio'nun testi otomatik olarak algıladığını görebilirsiniz. Testin adı şunlardan oluşur:namespace.className.TestMethodName. Şimdi tıklayalımRun All button in Test Explorer.

Önce kodu oluşturacak ve testi çalıştıracak ve testin harcadığı toplam süreyi göreceksiniz. Test başarısız olduğunda çıktıyı görebilmemiz için test yöntemini değiştirelim.

using System; 
using Xunit; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void Test1() { 
         Assert.True(false); 
      } 
   } 
}

Tekrar tıklayarak testi yapalım. Run All düğme bağlantısı.

Şimdi görebilirsiniz test başarısızlık.

Bu bölümde, StringLibrary'imizi test edeceğiz ve bunu yapmak için, varsayılan kuralı izleyebilmemiz için projelerimizi yeniden düzenlememiz gerekiyor.

Açalım global.json dosya.

{ 
   "projects": [ "src", "test" ], 
   "sdk": { 
      "version": "1.0.0-preview2-003131" 
   } 
}

Bu dosyanın en üstünde proje ayarlarını göreceksiniz ve aşağıdaki gibi bazı klasörler oluşturacaktır: src ve test varsayılan olarak.

Kural gereği, bu klasörlerde projelerimiz olmalıdır, bu yeni kuraldır ve .NET Core'un bir parçası olarak kullanılacaktır.

Çözüm Gezgini'nde, hem konsol projesinin hem de kitaplık projesinin içinde olduğunu görebilirsiniz. src Test projesi içindeyken klasör test Klasör.

Ve Çözüm Gezgini'ndeki proje yapısı, projelerin diskte fiziksel olarak nerede bulunduğunu temsil etmez. Şimdi Çözüm klasörünü açalım ve göreceksiniz.StringLibrary proje içinde değil src Klasör.

İkisini de görebilirsin src ve test klasörler, içinde belirtilen kurala eşlenir global.jsondosya. Ancak, standart olmayan bir StringLibrary projemiz var. Şimdi ekleyelimStringLibrary içindeki proje src Klasör.

Src klasöründe iki projemiz var ve tüm projeleri doğru kullanabilmemiz için sorunu çözmemiz gerekiyor. Visual Studio'ya geri dönelim ve StringLibrary projesine sağ tıklayıp Kaldır seçeneğini seçelim. Onu silmez, ancak yalnızca projeyi kaldırır.

Şimdi src klasörüne sağ tıklayın ve seçin Add → Existing Project…

Şu anda içinde bulunan StringLibrary projesine göz atın. src klasörü seçin StringLibrary.csproj dosyala ve tıkla Open.

Şimdi referansını kaldırmamız gerekiyor StringLibrary -den project.json konsol uygulamasının dosyası.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
      "NuGet.CommandLine": "3.5.0", 
      "System.Runtime.Serialization.Json": "4.0.3" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { }, 
         "imports": "dnxcore50" 
      } 
   } 
}

Değişiklikleri kaydedin ve ardından bir referans ekleyin StringLibrary yine konsol projenizde.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      }, 
   "NuGet.CommandLine": "3.5.0", 
      "System.Runtime.Serialization.Json": "4.0.3" 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "dependencies": { 
            "StringLibrary": { 
               "target": "project" 
            } 
         }, 
         "imports": "dnxcore50" 
      } 
   } 
}

Şimdi her şey yeniden çalışıyor olmalı ve inşa edebilirsiniz StringLibrary ve sonra FirstApp(konsol projesi) hatasız. Şimdi xunit kullanarak StringLibrary işlevselliğini test edelim. Test projemize StringLibrary referansı eklememiz gerekiyor. StringLibraryTests projesinin Referansları'na sağ tıklayın ve Referans Ekle… öğesini seçin.

Tıklayın OK bir referans ekleyecek StringLibrarytest projemize. Şimdi aşağıdaki kodu şuradakiTests.cs dosya.

using System; 
using Xunit; 
using StringLibrary; 
  
namespace Tests { 
   public class Tests { 
      [Fact] 
      public void StartsWithUpperCaseTest() { 
         string input = "Mark"; 
         Assert.True(input.StartsWithUpper()); 
      } 
      [Fact] 
      public void StartsWithLowerCaseTest() { 
         string input = "mark"; 
         Assert.True(input.StartsWithLower()); 
      } 
      [Fact] 
      public void StartsWithNumberCaseTest() { 
         string input = "123"; 
         Assert.True(input.StartsWithNumber()); 
      } 
   } 
}

StringLibrary'nin işlevselliğini test edecek üç test yöntemimiz olduğunu görebilirsiniz. TıklayalımRun All bağlantı ve aşağıdaki çıktıyı Test Gezgini'nde göreceksiniz.

Testleri komut satırından da çalıştırabilirsiniz. Komut istemini açalım vedotnet test komut.

Bu bölümde, Yönetilen Genişletilebilirlik Çerçevesini (MEF) tartışacağız. MEF, üçüncü taraf eklenti genişletilebilirliği için kullanılabilir veya gevşek bağlı eklenti benzeri bir mimarinin faydalarını normal uygulamalara getirebilir.

MEF, hafif, genişletilebilir uygulamalar oluşturmak için bir kitaplıktır.
Uygulama geliştiricilerin, yapılandırma gerektirmeden uzantıları keşfetmelerine ve kullanmalarına olanak tanır.
MEF, .NET Framework 4'ün ayrılmaz bir parçasıdır ve büyük uygulamaların esnekliğini, sürdürülebilirliğini ve test edilebilirliğini artıran .NET Framework'ün kullanıldığı her yerde mevcuttur.
MEF'i, ister Windows Forms, WPF veya başka bir teknoloji kullanıyor olsun, istemci uygulamalarınızda veya ASP.NET kullanan sunucu uygulamalarında kullanabilirsiniz.
MEF şu şekilde taşınmıştır: Microsoft.Composition .NET Core için de ama kısmen.
Bir tek System.Composition taşınır ve System.ComponentModel.Compositionhenüz mevcut değil. Bu, bir dizindeki derlemelerden türleri yükleyebilen kataloglara sahip olmadığımız anlamına gelir.

Bu bölümde, sadece MEF'i .NET Core uygulamasında nasıl kullanabileceğimizi öğreneceğiz.

NET Core konsol uygulamasında MEF'i kullanacağımız basit bir örneği anlayalım. Şimdi yeni bir .NET Core konsol projesi oluşturalım.

Sol bölmede şunu seçin: Templates → Visual C# → .NET Çekirdek ve ardından orta bölmede Konsol Uygulaması (.NET Core) öğesini seçin.

Ad alanına projenin adını girin ve Tamam'ı tıklayın.

Proje oluşturulduktan sonra, MEF'i kullanabilmemiz için Microsoft.Composition referansını eklememiz gerekiyor. Bunu yapmak için, Çözüm Gezgini'nde projeye sağ tıklayalım veManage NuGet Packages…

Aramak Microsoft.Composition ve tıklayın Install.

Tıkla OK buton.

Tıkla I Accept buton.

Kurulum tamamlandığında, Referanslar'da bir hata bulacaksınız.

Açalım project.json dosya.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
  
   "dependencies": { 
      "Microsoft.Composition": "1.0.30", 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1" 
      } 
   }, 
  
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "dnxcore50" 
      } 
   } 
}

Görebilirsiniz Microsoft.Composition bağımlılık eklendi, ancak sorun şu ki bu paket ile uyumlu değil dnxcore50. Bu yüzden ithal etmemiz gerekiyorportablenet45+win8+wp8+wpa81. Şimdi değiştirelimproject.json aşağıdaki kod ile dosya.

{ 
   "version": "1.0.0-*", 
   "buildOptions": { 
      "emitEntryPoint": true 
   }, 
   "dependencies": { 
      "Microsoft.Composition": "1.0.30", 
      "Microsoft.NETCore.App": { 
         "type": "platform", 
         "version": "1.0.1"
      } 
   }, 
   "frameworks": { 
      "netcoreapp1.0": { 
         "imports": "portable-net45+win8+wp8+wpa81" 
      } 
   } 
}

Bu dosyayı kaydedin ve hatanın düzeltildiğini göreceksiniz.

Referansları genişletirseniz, bir referans göreceksiniz. Microsoft.Composition.

Öncelikle, dışa aktarılacak bir arayüz oluşturmalı ve arayüzü uygulamalı ve sınıfı export niteliği ile dekore etmeliyiz. Şimdi yeni bir sınıf ekleyelim.

Ad alanına sınıfınızın adını girin ve tıklayın Add.

Aşağıdaki kodu şuraya ekleyelim: PrintData.cs dosya.

using System; 
using System.Collections.Generic; 
using System.Composition; 
using System.Linq; 
using System.Threading.Tasks; 
  
namespace MEFDemo { 
   public interface IPrintData { 
      void Send(string message); 
   } 
   [Export(typeof(IPrintData))] 
   public class PrintData : IPrintData { 
      public void Send(string message) { 
         Console.WriteLine(message); 
      } 
   } 
}

Yukarıda belirtildiği gibi, Kataloglar Microsoft.Composition ad alanında kullanılamaz. Bu nedenle, tüm türleri Assembly'den export özniteliğiyle yükleyecek ve Program.cs dosyasındaki Compose yönteminde gösterildiği gibi import özniteliğine ekleyecektir.

using System; 
using System.Collections.Generic; 
using System.Composition; 
using System.Composition.Hosting; 
using System.Linq; 
using System.Reflection; 
using System.Threading.Tasks; 
  
namespace MEFDemo { 
   public class Program { 
      public static void Main(string[] args) { 
         Program p = new Program(); 
         p.Run(); 
      } 
      public void Run() { 
         Compose(); 
         PrintData.Send("Hello,this is MEF demo"); 
      } 
      [Import] 
      public IPrintData PrintData { get; set; } 
      
      private void Compose() { 
         var assemblies = new[] { typeof(Program).GetTypeInfo().Assembly }; 
         var configuration = new ContainerConfiguration() 
            .WithAssembly(typeof(Program).GetTypeInfo().Assembly); 
         
         using (var container = configuration.CreateContainer()) { 
            PrintData = container.GetExport<IPrintData>(); 
         } 
      } 
   } 
}

Şimdi uygulamanızı çalıştıralım ve uygulamanızı başlatarak çalıştığını göreceksiniz. PrintData sınıf.

MEF hakkında daha fazla bilgi edinmek için aşağıdaki URL'yi ziyaret edelim https://msdn.microsoft.com/en-us/library/dd460648%28v=vs.110%29.aspx daha fazla ayrıntı için.

Bu bölümde, .NET Core'da gelecek özellikleri anlayacağız. Aşağıdaki URL'yi tarayıcıda açarak .NET komut satırı araçlarıyla başlayacağız.https://github.com/dotnet/cli

İlerleme hakkında daha fazla bilgi edinmek için, aşağı kaydırarak .NET Core SDK'nın en son sürümünü indirebilir ve Yükleyici ve İkili Dosyalar bölümünü göreceksiniz.

Farklı işletim sistemleri için önizleme araçlarının en son sürümünü görebilirsiniz, işletim sisteminize göre Yükleyiciyi seçmemize izin verin.

.NET Core 2.0 önizleme 1 üzerinde çalışıyoruz.

Şimdi komut istemini açarak ve aşağıdaki komutu uygulayarak mevcut araçlarımıza bakalım.

dotnet --info

NET Komut Satırı Araçları'nın şu anda yüklü olan sürümüyle ilgili bilgileri aşağıda gösterildiği gibi göreceksiniz.

Şu anda önizleme 2 aracımız olduğunu görebilirsiniz. Şimdi aşağıdaki komutu çalıştıralım.new komut.

dotnet help new

Projenin yeni komut dili için C # ve F # gibi ve proje türü vb. Seçebilirsiniz.

Şimdi .NET Core'un son sürümündeki değişiklikleri görelim. Yükleyici indirildikten sonra, yüklemek için üzerine çift tıklayın. Kur'a tıklayın.

Aşağıdaki ekran görüntüsü kurulum sürecini göstermektedir.

Kurulum sürecini başlatacaktır. Kurulum tamamlandıktan sonra, bu iletişim kutusunu kapatın.

Komut istemini açın ve aşağıdaki komutu yürütün.

dotnet --info

NET Komut Satırı Araçları'nın şu anda yüklü olan sürümünün bilgilerini aşağıda gösterildiği gibi göreceksiniz.

Artık .NET Core 2'nin preview1 aracına sahip olduğumuzu görebilirsiniz. Şimdi .NET Core 2 preview1'deki yeni komutu görmek için komut isteminde aşağıdaki kodu çalıştıralım.

dotnet help new

Komut, paketleri paket önbelleğine indirmenize yardımcı olur.

Komut, .NET Core 2 önizleme1'deki yeni komutla ilgili bilgileri içeren aşağıdaki web sayfasını açar.

Aşağı kaydıralım, artık daha fazla şablonla .NET Core uygulamasını oluşturabileceğimizi görebilirsiniz.

Şimdi yaratabiliriz mstest, web, mvc ve webapi komut satırını kullanarak da projeler.

.NET Core, project.json dosyasını kaldırmaya ve MSBuild ve * .csproj'a geri dönmeye karar verdi. Bu, henüz piyasaya sürülen .Net Core 2.0 önizleme1 aracında zaten olan bir şeydir. Bu oldukça hayal kırıklığı yaratıyor, çünkü project.json bir temiz hava soluydu. Ancak anlaşılabilir bir durumdur ve birçok avantajı da vardır.

Şimdi değişimin getirdiği avantajları tartışalım:

Mevcut Visual Studio çözümlerinin .NET Core'a geçişini kolaylaştırır.
Bu büyük bir değişiklik ve aynı zamanda MSBuild temelli CI / RM'deki mevcut yatırımlardan yararlanmayı da sağlayacak.
MSBuild'de derleme sırasında, artımlı derleme, derleme süresi bağımlılıklarını çözme, yapılandırma yönetimi vb. Düşünebiliriz.
Artık sadece ASP.NET Core değil, aynı zamanda konsol uygulamaları, UWP uygulamaları vb. İle ilgili olduğu için dotnet cli'yi zamanında göndermek için çok fazla çalışma gerekiyor.

MSBuild ve * .csproj'daki değişiklikler aşağıdadır -

Project.json dosyası (* .xproj), MSBuild (* .csproj) ile değiştirilecektir.
Project.json içindeki özellikler, * .csproj dosyasında birleştirilmeye başlayacaktır.
Paket listesi hakkında ne yapacakları henüz belli değil, ancak bunu json olarak saklayabileceklerinden bahsedildi. nuget.json veya birleştirin *.csproj.
Sözde bu geçiş, Visual Studio kullanılıyorsa sorunsuz ve potansiyel olarak otomatik olmalıdır.

MSBuild'in Avantajları

MSBuild açık kaynak kodludur ve GitHub'da mevcuttur ve tamamen çapraz platform olmaya bağlıdır.
MSBuild, önemli ölçüde basitleştirecek ve *.csproj.
Microsoft ayrıca, Visual Studio'ya ihtiyaç duymadan birçok senaryoyu mümkün kılacak yeni bir proje sistemi sunuyor ve ayrıntılar bu URL'de verilmiştir. https://github.com/dotnet/roslyn-project-system/.
Amaç, MSBuild kurulumunda bile, derlemeler ve projelerle çalışmanın Visual Studio IDE'de olduğu kadar sorunsuz olacağıdır.

MSBuild vs project.json

Şimdi aşağıdaki komutu çalıştırarak .NET Core önizleme2 araçlarıyla yeni bir konsol projesi oluşturalım.

dotnet new -t console

Bu proje dahilinde oluşturulan tüm dosyaları görmek için, dir komut.

İki dosyanın oluşturulduğunu görebilirsiniz, Program.cs ve project.json dosya.

Şimdi aşağıdaki komutu çalıştırarak .NET Core 2 preview1 aracı ile bir konsol uygulaması oluşturalım.

dotnet new console

Bu proje dahilinde oluşturulan tüm dosyaları görmek için, dirkomut. Üç dosyanın oluşturulduğunu görebilirsiniz,Program.cs, NuGet.config ve MSBuild.csproj project.json dosyası yerine.

Şimdi karşılaştıralım project.json ve MSBuild.csproj dosyaları yan yana.

Solda json formatında dosya var, sağda ise dosya XML formatındadır. Bunu project.json dosyasında, bağımlılıklar bölümünde görebilirsiniz.netcoreapp1.0MSBuild.csproj dosyasındayken, netcoreapp2.0.

Bu bölümde, komut satırı yardımcı programını kullanarak MSBuild (* .csproj) dosyanızı nasıl geri yükleyeceğinizi ve oluşturacağınızı tartışacağız. NET Core 2.0 önizleme 1'de hangi komutların mevcut olduğunu görmek için aşağıdaki komutu çalıştıralım.

dotnet help

Yeni, geri yükleme, oluşturma vb. Gibi tüm komutları göreceksiniz.

Aşağıdaki varsayılan uygulama şu şekildedir: Program.cs dosya.

using System;  
namespace MSBuild { 
   class Program { 
      static void Main(string[] args) { 
         Console.WriteLine("Hello World!"); 
      } 
   } 
}

Şimdi ilerlemeyi görmek için aşağıdaki komutu uygulayalım.

dotnet build

Çok fazla hata göreceksiniz. Bu hataların düzeltilmesi gerekiyor.

Şimdi aşağıdaki komutu çalıştıralım.

dotnet restore

Tüm paketlerin geri yüklendiğini görebilirsiniz. Bazı yeni klasörler ve dosyalar da oluşturulmuştur.

Dizin yapısını görmek için aşağıdaki komutu çalıştıralım.

tree /f

Aşağıda dizin yapısı verilmiştir -

Şimdi aşağıdaki komutu tekrar çalıştırarak projeyi yeniden oluşturalım.

dotnet build

Artık proje herhangi bir hata olmadan başarıyla inşa edilecek ve MSBuild.dll de yaratılacaktır.

Çıktıyı görmek için aşağıdaki komutu çalıştıralım -

dotnet run

Konsolunuzda aşağıdaki çıktıyı görebilirsiniz.

Bu bölümde, aşağıdakileri içeren konsol uygulamasını geçireceğiz project.json yerine dosya oluşturma sistemi MSBuild (*.csproj). Yani, aşağıdaki dosyaları içeren eski bir projemiz var.

Şimdi soru şu, neden göçe ihtiyacımız var? Bu proje, .NET Core 1.0 önizleme 2 araçları kullanılarak oluşturulmuştur ve şimdi .NET Core 2.0 önizleme 1 araçlarını yükledik. Şimdi bu uygulamayı .NET Core 2.0 komut satırı yardımcı programını kullanarak oluşturduğunuzda, aşağıdaki hatayı göreceksiniz.

Bunun nedeni project.jsonderleme sistemi artık .NET Core 2.0'da mevcut değil, bu nedenle düzgün çalışabilmesi için geçişe ihtiyacımız var. Mevcut komutları görmek için aşağıdaki komutu çalıştıralım.