.NET Core - คู่มือฉบับย่อ

.NET Core เป็นแพลตฟอร์มการพัฒนาสำหรับวัตถุประสงค์ทั่วไปล่าสุดที่ดูแลโดย Microsoft มันทำงานบนแพลตฟอร์มต่างๆและได้รับการออกแบบใหม่ในลักษณะที่ทำให้. NET รวดเร็วยืดหยุ่นและทันสมัย สิ่งนี้ถือเป็นหนึ่งในการสนับสนุนที่สำคัญของ Microsoft ขณะนี้นักพัฒนาสามารถสร้างแอปพลิเคชัน Android, iOS, Linux, Mac และ Windows ด้วย. NET ทั้งหมดใน Open Source

ในบทช่วยสอนนี้เราจะกล่าวถึง. NET Core และนวัตกรรมใหม่บางอย่างรวมถึงการอัปเดต. NET Framework, การอัปเดต. NET Standard และ Universal Windows Platform เป็นต้น

ลักษณะของ. NET Core

ต่อไปนี้เป็นลักษณะสำคัญของ. NET Core -

โอเพ่นซอร์ส

  • .NET Core เป็นการใช้งานแบบโอเพนซอร์สโดยใช้ใบอนุญาต MIT และ Apache 2

  • .NET Core เป็นโครงการ. NET Foundation และพร้อมใช้งานบน GitHub

  • ในฐานะที่เป็นโครงการโอเพ่นซอร์สจะส่งเสริมกระบวนการพัฒนาที่โปร่งใสมากขึ้นและส่งเสริมชุมชนที่กระตือรือร้นและมีส่วนร่วม

ข้ามแพลตฟอร์ม

  • แอปพลิเคชันที่ติดตั้งใน. NET Core สามารถรันได้และสามารถใช้โค้ดซ้ำได้โดยไม่คำนึงถึงเป้าหมายแพลตฟอร์มของคุณ

  • ปัจจุบันรองรับระบบปฏิบัติการหลักสามระบบ (OS)

    • Windows

    • Linux

    • MacOS

  • ระบบปฏิบัติการ (OS) ซีพียูและสถานการณ์แอพพลิเคชั่นที่รองรับจะเติบโตขึ้นเมื่อเวลาผ่านไปซึ่งจัดหาโดย Microsoft บริษัท อื่น ๆ และบุคคลทั่วไป

การปรับใช้ที่ยืดหยุ่น

  • การปรับใช้งานสำหรับแอปพลิเคชัน. NET Core สามารถมีได้สองประเภท -

    • การปรับใช้ตามกรอบ

    • การปรับใช้ที่มีอยู่ในตัว

  • ด้วยการปรับใช้ที่ขึ้นอยู่กับเฟรมเวิร์กแอปของคุณจะขึ้นอยู่กับ. NET Core เวอร์ชันทั้งระบบซึ่งแอปของคุณและการอ้างอิงของบุคคลที่สามได้รับการติดตั้ง

  • ด้วยการปรับใช้ที่มีอยู่ในตัวเวอร์ชัน. NET Core ที่ใช้ในการสร้างแอปพลิเคชันของคุณจะถูกปรับใช้ร่วมกับแอปของคุณและการอ้างอิงของบุคคลที่สามและสามารถทำงานเคียงข้างกันกับเวอร์ชันอื่น ๆ

เครื่องมือบรรทัดคำสั่ง

  • สถานการณ์ของผลิตภัณฑ์ทั้งหมดสามารถใช้งานได้ที่บรรทัดคำสั่ง

เข้ากันได้

  • .NET Core เข้ากันได้กับ. NET Framework, Xamarin และ Mono ผ่าน. NET Standard Library

โมดูลาร์

  • .NET Core เผยแพร่ผ่าน NuGet ในชุดประกอบขนาดเล็ก

  • .NET Framework เป็นแอสเซมบลีขนาดใหญ่ที่ประกอบด้วยฟังก์ชันหลักส่วนใหญ่

  • .NET Core มีให้ใช้งานในรูปแบบแพ็คเกจที่มีคุณลักษณะเป็นศูนย์กลางขนาดเล็ก

  • วิธีการแบบแยกส่วนนี้ช่วยให้นักพัฒนาสามารถเพิ่มประสิทธิภาพแอพของตนโดยรวมเฉพาะแพ็คเกจ NuGet ที่พวกเขาต้องการในแอพของพวกเขา

  • ประโยชน์ของพื้นที่ผิวแอปขนาดเล็ก ได้แก่ การรักษาความปลอดภัยที่เข้มงวดขึ้นการให้บริการที่ลดลงประสิทธิภาพที่ดีขึ้นและค่าใช้จ่ายที่ลดลงในรูปแบบที่จ่ายสำหรับสิ่งที่คุณใช้

แพลตฟอร์ม. NET Core

.NET Core Platform ประกอบด้วยส่วนหลักดังต่อไปนี้ -

  • .NET Runtime - จัดเตรียมระบบประเภทการโหลดการประกอบเครื่องเก็บขยะการทำงานร่วมกันแบบเนทีฟและบริการพื้นฐานอื่น ๆ

  • Fundamental Libraries - ชุดของไลบรารีเฟรมเวิร์กซึ่งมีประเภทข้อมูลดั้งเดิมประเภทองค์ประกอบของแอปและยูทิลิตี้พื้นฐาน

  • SDK & Compiler - ชุดเครื่องมือ SDK และคอมไพเลอร์ภาษาที่เปิดใช้งานประสบการณ์พื้นฐานสำหรับนักพัฒนาซอฟต์แวร์ที่มีอยู่ใน. NET Core SDK

  • ‘dotnet’ app host- ใช้เพื่อเปิดแอพ. NET Core มันเลือกรันไทม์และโฮสต์รันไทม์ให้นโยบายการโหลดแอสเซมบลีและเปิดแอพ โฮสต์เดียวกันยังใช้เพื่อเปิดเครื่องมือ SDK ในลักษณะเดียวกัน

ในบทนี้เราจะพูดถึงการอ้างอิงต่างๆที่คุณต้องใช้ในการปรับใช้และเรียกใช้ ซึ่งรวมถึงแอปพลิเคชัน. NET Core บนเครื่อง Windows ที่พัฒนาโดยใช้ Visual Studio

เวอร์ชัน Windows ที่รองรับ

.NET Core ได้รับการสนับสนุนบน Windows รุ่นต่อไปนี้ -

  • Windows 7 SP1
  • Windows 8.1
  • Windows 10
  • Windows Server 2008 R2 SP1 (เซิร์ฟเวอร์เต็มหรือเซิร์ฟเวอร์หลัก)
  • Windows Server 2012 SP1 (เซิร์ฟเวอร์เต็มหรือเซิร์ฟเวอร์หลัก)
  • Windows Server 2012 R2 SP1 (เซิร์ฟเวอร์เต็มหรือเซิร์ฟเวอร์หลัก)
  • Windows Server 2016 (เซิร์ฟเวอร์เต็ม, เซิร์ฟเวอร์หลักหรือเซิร์ฟเวอร์นาโน)

การพึ่งพา

  • หากคุณกำลังเรียกใช้แอปพลิเคชัน. NET Core ของคุณบน Windows เวอร์ชันก่อนหน้า Windows 10 และ Windows Server 2016 ก็จะต้องมี Visual C ++ Redistributable

  • การอ้างอิงนี้จะถูกติดตั้งโดยอัตโนมัติสำหรับคุณหากคุณใช้ตัวติดตั้ง. NET Core

  • คุณต้องติดตั้ง Visual C ++ Redistributable สำหรับ Visual Studio 2015 ด้วยตนเองหากคุณกำลังติดตั้ง. NET Core ผ่านสคริปต์ตัวติดตั้งหรือปรับใช้แอปพลิเคชัน. NET Core ในตัว

  • สำหรับเครื่อง Windows 7 และ Windows Server 2008 คุณต้องตรวจสอบให้แน่ใจว่าการติดตั้ง Windows ของคุณเป็นรุ่นล่าสุดและรวมถึงโปรแกรมแก้ไขด่วน KB2533623 ที่ติดตั้งผ่าน Windows Update

ข้อกำหนดเบื้องต้นกับ Visual Studio

  • ในการพัฒนาแอปพลิเคชัน. NET Core โดยใช้. NET Core SDK คุณสามารถใช้โปรแกรมแก้ไขใดก็ได้ตามที่คุณต้องการ

  • อย่างไรก็ตามหากคุณต้องการพัฒนาแอปพลิเคชัน. NET Core บน Windows โดยใช้ Visual Studio คุณสามารถใช้สองเวอร์ชันต่อไปนี้ -

    • Visual Studio 2015

    • Visual Studio 2017 RC

  • โปรเจ็กต์ที่สร้างด้วย Visual Studio 2015 จะใช้ project.json ตามค่าเริ่มต้นในขณะที่โปรเจ็กต์ที่สร้างด้วย Visual Studio 2017 RC จะใช้ MSBuild เสมอ

ในบทนี้เราจะพูดถึงการตั้งค่าสภาพแวดล้อมของ. NET Core เป็นการออกแบบใหม่ที่สำคัญของ. NET Framework ในการใช้. NET Core ในแอปพลิเคชันของคุณคุณสามารถใช้ได้สองเวอร์ชัน -

  • Visual Studio 2015
  • Visual Studio 2017 RC

Visual Studio 2015

ในการใช้ Visual Studio 2015 คุณต้องติดตั้งสิ่งต่อไปนี้ -

  • Microsoft Visual Studio 2015 Update 3
  • Microsoft .NET Core 1.0.1 - VS 2015 Tooling Preview 2

Microsoft มี Visual Studio เวอร์ชันฟรีซึ่งมี SQL Server และสามารถดาวน์โหลดได้จาก https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx และ Microsoft .NET Core 1.0.1 - VS 2015 Tooling Preview 2 สามารถดาวน์โหลดได้จาก https://www.visualstudio.com/downloads/

คุณยังสามารถปฏิบัติตามคำแนะนำในการติดตั้งใน URL ต่อไปนี้ https://www.microsoft.com/net/core/#windowsvs2017

การติดตั้ง Visual Studio 2015

ทำตามขั้นตอนเหล่านี้เพื่อติดตั้ง Visual Studio 2015 -

Step 1- เมื่อการดาวน์โหลดเสร็จสิ้นให้เรียกใช้โปรแกรมติดตั้ง กล่องโต้ตอบต่อไปนี้จะปรากฏขึ้น.

Step 2 - คลิก Install เพื่อเริ่มกระบวนการติดตั้ง

Step 3 - เมื่อการติดตั้งเสร็จสิ้นคุณจะเห็นกล่องโต้ตอบต่อไปนี้

Step 4 - ปิดกล่องโต้ตอบนี้และรีสตาร์ทคอมพิวเตอร์หากจำเป็น

Step 5- เปิด Visual Studio จากเมนูเริ่ม คุณจะได้รับกล่องโต้ตอบต่อไปนี้ อาจใช้เวลาโหลดสักครู่และในที่สุดก็ถูกนำมาใช้เป็นครั้งแรก

Step 6 - เมื่อโหลดแล้วคุณจะเห็นหน้าจอต่อไปนี้

Step 7 - เมื่อติดตั้ง Visual Studio เสร็จแล้วให้ปิด Visual Studio แล้วเปิด Microsoft .NET Core - VS 2015 Tooling Preview 2

Step 8 - เลือกช่องทำเครื่องหมายแล้วคลิกติดตั้ง

Step 9 - เมื่อการติดตั้งเสร็จสิ้นคุณจะเห็นกล่องโต้ตอบต่อไปนี้

ตอนนี้คุณพร้อมที่จะเริ่มแอปพลิเคชันของคุณโดยใช้. NET Core

Visual Studio 2017

ในบทช่วยสอนนี้เราจะใช้ Visual Studio 2015 แต่ถ้าคุณต้องการใช้ Visual Studio 2017 เครื่องมือ. NET Core รุ่นทดลองสำหรับ Visual Studio จะรวมอยู่ใน Visual Studio 2017 RC และคุณสามารถดูแนวทางการติดตั้งได้ที่นี่ https://www.microsoft.com/net/core/#windowsvs2017

Visual Studio 2015 มีสภาพแวดล้อมการพัฒนาแบบเต็มรูปแบบสำหรับการพัฒนาแอปพลิเคชัน. NET Core ในบทนี้เราจะสร้างโครงการใหม่ภายใน Visual Studio เมื่อคุณติดตั้งเครื่องมือ Visual Studio 2015 แล้วคุณสามารถเริ่มสร้างแอปพลิเคชัน. NET Core ใหม่ได้

ใน New Project กล่องโต้ตอบในรายการเทมเพลตขยายโหนด Visual C # และเลือก. NET Core และคุณควรเห็นเทมเพลตโครงการใหม่สามรายการต่อไปนี้

  • ไลบรารีคลาส (.NET Core)
  • แอปพลิเคชันคอนโซล (.NET Core)
  • ASP.NET Core Web Application (.NET Core)

ในบานหน้าต่างตรงกลางของกล่องโต้ตอบ New Project ให้เลือก Console Application (.NET Core) และตั้งชื่อว่า "FirstApp" จากนั้นคลิกตกลง

Visual Studio จะเปิดโปรเจ็กต์ที่สร้างขึ้นใหม่และคุณจะเห็นในหน้าต่าง Solution Explorer ไฟล์ทั้งหมดที่อยู่ในโปรเจ็กต์นี้

หากต้องการทดสอบว่าแอปพลิเคชันคอนโซลหลักของ. NET ใช้งานได้ให้เราเพิ่มบรรทัดต่อไปนี้

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!"); 
      } 
   } 
}

ตอนนี้เรียกใช้แอปพลิเคชัน คุณควรเห็นผลลัพธ์ต่อไปนี้

.NET Core สนับสนุนอนุพันธ์เลขมาตรฐานและเลขทศนิยม นอกจากนี้ยังรองรับประเภทต่อไปนี้ -

  • System.Numerics.BigInteger ซึ่งเป็นประเภทอินทิกรัลที่ไม่มีขอบเขตบนหรือล่าง

  • System.Numerics.Complex คือชนิดที่แสดงถึงจำนวนเชิงซ้อน

  • ชุดเวกเตอร์ที่เปิดใช้งาน Single Instruction Multiple Data (SIMD) ใน System.Numerics namespace

ประเภทปริพันธ์

.NET Core สนับสนุนทั้งจำนวนเต็มที่ลงนามและไม่ได้ลงนามในช่วงที่แตกต่างกันตั้งแต่ความยาวหนึ่งไบต์ถึงแปดไบต์ จำนวนเต็มทั้งหมดเป็นประเภทค่า

ตารางต่อไปนี้แสดงประเภทอินทิกรัลและขนาด

ประเภท ลงชื่อ / ไม่ได้ลงนาม ขนาด (ไบต์) มูลค่าขั้นต่ำ ค่าสูงสุด
ไบต์ ไม่ได้ลงนาม 1 0 255
Int16 ลงชื่อ 2 −32,768 32,767
Int32 ลงชื่อ 4 −2,147,483,648 2,147,483,647
Int64 ลงชื่อ 8 −9,223,372,036,854,775,808 9,223,372,036,854,775,807
SByte ลงชื่อ 1 -128 127
UInt16 ไม่ได้ลงนาม 2 0 65,535
UInt32 ไม่ได้ลงนาม 4 0 4,294,967,295
UInt64 ไม่ได้ลงนาม 8 0 18,446,744,073,709,551,615

อินทิกรัลแต่ละประเภทสนับสนุนชุดมาตรฐานของเลขคณิตการเปรียบเทียบความเท่าเทียมการแปลงอย่างชัดเจนและตัวดำเนินการแปลงโดยนัย

คุณยังสามารถทำงานกับแต่ละบิตในค่าจำนวนเต็มโดยใช้คลาส System.BitConverter

ประเภทจุดลอยตัว

.NET Core ประกอบด้วยจุดลอยตัวแบบดั้งเดิมสามประเภทซึ่งแสดงในตารางต่อไปนี้

ประเภท ขนาด (ไบต์) มูลค่าขั้นต่ำ ค่าสูงสุด
สองเท่า 8 −1.79769313486232e308 1.79769313486232e308
โสด 4 −3.402823e38 3.402823e38
ทศนิยม 16 −79,228,162,514,264,337,593,5 43,950,335 79,228,162,514,264,337,593,543,9 50,335
  • จุดลอยตัวแต่ละประเภทสนับสนุนชุดมาตรฐานของเลขคณิตการเปรียบเทียบความเท่าเทียมการแปลงอย่างชัดเจนและตัวดำเนินการแปลงโดยนัย

  • คุณยังสามารถทำงานกับแต่ละบิตในค่า Double และ Single ได้โดยใช้คลาส BitConverter

  • โครงสร้างทศนิยมมีวิธีการของตัวเองทศนิยม GetBits และ Decimal.Decimal (Int32 ()) สำหรับการทำงานกับแต่ละบิตของค่าทศนิยมรวมถึงชุดวิธีการของตัวเองสำหรับการดำเนินการทางคณิตศาสตร์เพิ่มเติม

BigInteger

  • System.Numerics.BigInteger เป็นประเภทที่ไม่เปลี่ยนรูปซึ่งแสดงถึงจำนวนเต็มขนาดใหญ่โดยพลการซึ่งค่าในทางทฤษฎีไม่มีขอบเขตบนหรือล่าง

  • วิธีการของประเภท BigInteger นั้นขนานกันอย่างใกล้ชิดกับประเภทอินทิกรัลอื่น ๆ

ซับซ้อน

  • ประเภท System.Numerics.Complex แทนจำนวนเชิงซ้อนกล่าวคือจำนวนที่มีส่วนจำนวนจริงและส่วนจำนวนจินตภาพ

  • สนับสนุนชุดมาตรฐานของเลขคณิตการเปรียบเทียบความเท่าเทียมการแปลงอย่างชัดเจนและตัวดำเนินการแปลงโดยนัยตลอดจนวิธีการทางคณิตศาสตร์พีชคณิตและตรีโกณมิติ

SIMD

  • เนมสเปซ Numerics ประกอบด้วยชุดเวกเตอร์ที่เปิดใช้งาน SIMD สำหรับ. NET Core

  • SIMD ช่วยให้การดำเนินการบางอย่างสามารถขนานกันได้ในระดับฮาร์ดแวร์ซึ่งส่งผลให้มีการปรับปรุงประสิทธิภาพอย่างมากในแอปทางคณิตศาสตร์วิทยาศาสตร์และกราฟิกที่ทำการคำนวณผ่านเวกเตอร์

  • ประเภทเวกเตอร์ที่เปิดใช้งาน SIMD ใน. NET Core มีดังต่อไปนี้ -

    • System.Numerics.Vector2, System.Numerics.Vector3 และ System.Numerics.Vector4 ประเภทซึ่งเป็นเวกเตอร์ 2, 3 และ 4 มิติประเภท Single

    • โครงสร้าง Vector <T> ที่ช่วยให้คุณสร้างเวกเตอร์ของประเภทตัวเลขดั้งเดิมใด ๆ ประเภทตัวเลขดั้งเดิมประกอบด้วยประเภทตัวเลขทั้งหมดในเนมสเปซของระบบยกเว้นทศนิยม

    • เมทริกซ์สองประเภท System.Numerics.Matrix3 × 2 ซึ่งแสดงถึงเมทริกซ์ 3 × 2 และ System.Numerics.Matrix4 × 4 ซึ่งแสดงถึงเมทริกซ์ 4 × 4

    • ชนิด System.Numerics.Plane ซึ่งแสดงถึงระนาบสามมิติและชนิด System.Numerics.Quaternion ซึ่งแสดงถึงเวกเตอร์ที่ใช้ในการเข้ารหัสการหมุนทางกายภาพสามมิติ

ในบทนี้เราจะพูดถึงแนวคิดของการรวบรวมขยะซึ่งเป็นหนึ่งในคุณสมบัติที่สำคัญที่สุดของแพลตฟอร์มรหัสที่มีการจัดการ. NET ตัวรวบรวมขยะ (GC) จัดการการจัดสรรและการปล่อยหน่วยความจำ ตัวเก็บขยะทำหน้าที่เป็นตัวจัดการหน่วยความจำอัตโนมัติ

  • คุณไม่จำเป็นต้องรู้วิธีจัดสรรและปล่อยหน่วยความจำหรือจัดการอายุการใช้งานของวัตถุที่ใช้หน่วยความจำนั้น

  • การจัดสรรจะเกิดขึ้นทุกครั้งที่คุณประกาศออบเจ็กต์ด้วยคีย์เวิร์ด“ ใหม่” หรือประเภทค่าอยู่ในกล่อง โดยทั่วไปการจัดสรรจะเร็วมาก

  • เมื่อมีหน่วยความจำไม่เพียงพอที่จะจัดสรรวัตถุ GC ต้องรวบรวมและกำจัดหน่วยความจำขยะเพื่อให้หน่วยความจำพร้อมใช้งานสำหรับการจัดสรรใหม่

  • กระบวนการนี้เรียกว่า garbage collection.

ข้อดีของการเก็บขยะ

การเก็บขยะให้ประโยชน์ดังต่อไปนี้ -

  • คุณไม่จำเป็นต้องเพิ่มหน่วยความจำด้วยตนเองในขณะที่พัฒนาแอปพลิเคชันของคุณ

  • นอกจากนี้ยังจัดสรรวัตถุบนฮีปที่มีการจัดการอย่างมีประสิทธิภาพ

  • เมื่ออ็อบเจ็กต์ไม่ได้ใช้อีกต่อไปมันจะเรียกอ็อบเจ็กต์เหล่านั้นกลับคืนมาโดยการล้างหน่วยความจำและทำให้หน่วยความจำพร้อมใช้งานสำหรับการจัดสรรในอนาคต

  • อ็อบเจ็กต์ที่ได้รับการจัดการจะได้รับเนื้อหาที่สะอาดโดยอัตโนมัติเพื่อเริ่มต้นดังนั้นตัวสร้างของพวกเขาจึงไม่จำเป็นต้องเริ่มต้นฟิลด์ข้อมูลทั้งหมด

  • นอกจากนี้ยังให้ความปลอดภัยของหน่วยความจำโดยตรวจสอบให้แน่ใจว่าวัตถุไม่สามารถใช้เนื้อหาของวัตถุอื่นได้

เงื่อนไขการเก็บขยะ

การรวบรวมขยะเกิดขึ้นเมื่อเงื่อนไขใดเงื่อนไขหนึ่งต่อไปนี้เป็นจริง

  • ระบบมีหน่วยความจำกายภาพต่ำ

  • หน่วยความจำที่ใช้โดยอ็อบเจ็กต์ที่จัดสรรบนฮีปที่มีการจัดการเกินเกณฑ์ที่ยอมรับได้ ขีด จำกัด นี้จะได้รับการปรับเปลี่ยนอย่างต่อเนื่องเมื่อกระบวนการทำงาน

  • GC.Collectเรียกวิธีการและในเกือบทุกกรณีคุณไม่จำเป็นต้องเรียกเมธอดนี้เนื่องจากตัวเก็บขยะทำงานอย่างต่อเนื่อง วิธีนี้ใช้สำหรับสถานการณ์และการทดสอบเฉพาะเป็นหลัก

รุ่น

NET Garbage Collector มี 3 รุ่นและแต่ละรุ่นมีฮีปของตัวเองที่ใช้สำหรับจัดเก็บอ็อบเจ็กต์ที่จัดสรร มีหลักการพื้นฐานว่าวัตถุส่วนใหญ่มีอายุสั้นหรือมีอายุยืนยาว

รุ่นแรก (0)

  • ใน Generation 0 วัตถุจะถูกจัดสรรก่อน

  • ในรุ่นนี้วัตถุมักจะไม่อยู่ผ่านรุ่นแรกเนื่องจากไม่ได้ใช้งานอีกต่อไป (อยู่นอกขอบเขต) เมื่อมีการรวบรวมขยะครั้งต่อไป

  • Generation 0 รวบรวมได้อย่างรวดเร็วเนื่องจากฮีปที่เกี่ยวข้องมีขนาดเล็ก

รุ่นที่สอง (1)

  • ในเจเนอเรชั่น 1 วัตถุมีช่องว่างโอกาสที่สอง

  • ออบเจ็กต์ที่มีอายุสั้น แต่อยู่รอดจากคอลเลคชัน generation 0 (มักขึ้นอยู่กับช่วงเวลาที่บังเอิญ) ไปที่รุ่น 1

  • คอลเลกชันรุ่นที่ 1 ยังรวดเร็วเนื่องจากฮีปที่เกี่ยวข้องมีขนาดเล็ก

  • สองฮีปแรกยังคงมีขนาดเล็กเนื่องจากอ็อบเจ็กต์ถูกรวบรวมหรือเลื่อนระดับเป็นฮีปรุ่นถัดไป

รุ่นที่สาม (2)

  • ในเจเนอเรชั่นที่ 2 อ็อบเจกต์ขนาดยาวทั้งหมดยังคงมีชีวิตอยู่และฮีปของมันสามารถเติบโตได้มาก

  • วัตถุในยุคนี้สามารถดำรงอยู่ได้เป็นเวลานานและไม่มีฮีปรุ่นต่อไปที่จะส่งเสริมวัตถุอีกต่อไป

  • Garbage Collector มีฮีปเพิ่มเติมสำหรับวัตถุขนาดใหญ่ที่เรียกว่า Large Object Heap (LOH)

  • สงวนไว้สำหรับวัตถุที่มีขนาด 85,000 ไบต์ขึ้นไป

  • อ็อบเจ็กต์ขนาดใหญ่ไม่ได้ถูกจัดสรรให้กับฮีปของเจเนอเรชัน แต่ถูกจัดสรรให้กับ LOH โดยตรง

  • คอลเลกชันรุ่นที่ 2 และ LOH อาจใช้เวลานานอย่างเห็นได้ชัดสำหรับโปรแกรมที่ทำงานเป็นเวลานานหรือทำงานกับข้อมูลจำนวนมาก

  • โปรแกรมเซิร์ฟเวอร์ขนาดใหญ่เป็นที่ทราบกันดีว่ามีฮีปใน 10 วินาทีของ GB

  • GC ใช้เทคนิคต่างๆเพื่อลดระยะเวลาที่บล็อกการทำงานของโปรแกรม

  • แนวทางหลักคือการดำเนินการรวบรวมขยะให้มากที่สุดเท่าที่จะทำได้บนเธรดพื้นหลังในลักษณะที่ไม่รบกวนการทำงานของโปรแกรม

  • GC ยังเปิดเผยวิธีการบางอย่างสำหรับนักพัฒนาในการมีอิทธิพลต่อพฤติกรรมของตนซึ่งจะมีประโยชน์มากในการปรับปรุงประสิทธิภาพ

ในบทนี้เราจะทำความเข้าใจกระบวนการเรียกใช้งานของ. NET Core และเปรียบเทียบกับ. NET Framework กระบวนการดำเนินการที่มีการจัดการประกอบด้วยขั้นตอนต่อไปนี้

  • การเลือกคอมไพเลอร์
  • รวบรวมรหัสของคุณเป็น MSIL
  • การรวบรวม MSIL เป็นรหัสดั้งเดิม
  • กำลังรันโค้ด

การเลือกคอมไพเลอร์

  • เป็นสภาพแวดล้อมการดำเนินการหลายภาษารันไทม์รองรับประเภทข้อมูลและคุณสมบัติภาษาที่หลากหลาย

  • เพื่อให้ได้ประโยชน์จากรันไทม์ภาษาทั่วไปคุณต้องใช้คอมไพเลอร์ภาษาอย่างน้อยหนึ่งภาษาที่กำหนดเป้าหมายรันไทม์

รวบรวมรหัสของคุณเป็น MSIL

  • การคอมไพล์แปลซอร์สโค้ดของคุณเป็น Microsoft Intermediate Language (MSIL) และสร้างข้อมูลเมตาที่จำเป็น

  • ข้อมูลเมตาอธิบายประเภทในโค้ดของคุณรวมถึงคำจำกัดความของแต่ละประเภทลายเซ็นของสมาชิกแต่ละประเภทสมาชิกที่โค้ดของคุณอ้างอิงและข้อมูลอื่น ๆ ที่รันไทม์ใช้ในเวลาดำเนินการ

  • รันไทม์ค้นหาและแยกข้อมูลเมตาจากไฟล์และจากไลบรารีคลาสเฟรมเวิร์ก (FCL) ตามต้องการในระหว่างการดำเนินการ

การคอมไพล์ MSIL เป็น Native Code

  • ในช่วงเวลาดำเนินการคอมไพเลอร์ just-in-time (JIT) จะแปล MSIL เป็นโค้ดเนทีฟ

  • ในระหว่างการรวบรวมนี้รหัสจะต้องผ่านกระบวนการตรวจสอบที่ตรวจสอบ MSIL และข้อมูลเมตาเพื่อดูว่ารหัสสามารถกำหนดให้เป็นประเภทที่ปลอดภัยได้หรือไม่

รันโค้ด

  • รันไทม์ภาษาทั่วไปจัดเตรียมโครงสร้างพื้นฐานที่ช่วยให้การดำเนินการเกิดขึ้นและบริการที่สามารถใช้ระหว่างการดำเนินการ

  • ในระหว่างการดำเนินการโค้ดที่ได้รับการจัดการจะได้รับบริการต่างๆเช่นการรวบรวมขยะการรักษาความปลอดภัยความสามารถในการทำงานร่วมกันกับรหัสที่ไม่มีการจัดการการสนับสนุนการดีบักข้ามภาษา

.NET Core Code Execution Process

ตอนนี้เรามาดูว่าโค้ดดำเนินการกับ. NET Core อย่างไรเมื่อเทียบกับ. NET Framework ใน. NET Core มีการแทนที่ส่วนประกอบเหล่านี้มากมายซึ่งเป็นส่วนหนึ่งของ. NET Framework

  • ใน. NET Core ตอนนี้เรามีคอมไพเลอร์ชุดใหม่เช่นเรามี Roslyn สำหรับ C # และ VB

  • คุณยังสามารถใช้คอมไพเลอร์ F # 4.1 ใหม่ได้หากคุณต้องการใช้ F # กับ. NET Core

  • จริงๆแล้วเครื่องมือเหล่านี้แตกต่างกันและเราสามารถใช้ Roslyn กับ. NET Framework ได้เช่นกันหากเราใช้ C # 6 หรือใหม่กว่าเนื่องจากคอมไพเลอร์ C # สามารถรองรับได้ถึง C # 5 เท่านั้น

  • ใน. NET Core เราไม่มีไลบรารีคลาสเฟรมเวิร์ก (FCL) ดังนั้นจึงใช้ไลบรารีชุดอื่นและตอนนี้เรามี CoreFx แล้ว

  • CoreFx คือการนำไลบรารีคลาสมาใช้ใหม่สำหรับ. NET Core

  • เรายังมีเวลารันใหม่กับ. NET Core ที่เรียกว่า CoreCLR และใช้ประโยชน์จาก JIT Compiler

  • ตอนนี้คำถามคือเหตุใดเราจึงนำส่วนประกอบเหล่านี้มาใช้ใหม่ทั้งหมดที่เรามีอยู่แล้วใน. NET framework

  • ดังนั้นคำตอบก็เหมือนกับสาเหตุที่ Microsoft ใช้. NET Core

เป็นอีกหนึ่งข้อพิจารณาของ. NET Core ในการสร้างและใช้งานแอปพลิเคชันที่เป็นโมดูลาร์ แทนที่จะติดตั้ง. NET Framework ทั้งหมดตอนนี้แอปพลิเคชันของคุณสามารถติดตั้งสิ่งที่จำเป็นได้ ให้เราไปที่สตูดิโอภาพและดูโมดูลาร์

นี่คือแอปพลิเคชัน. NET Core ที่เรียบง่ายของเราใน Solution Explorer ให้เราขยายการอ้างอิงและคุณจะเห็นการอ้างอิงถึง. NETCoreApp

ภายใน. NETCoreApp คุณจะเห็นการอ้างอิงแพ็คเกจไปยัง NuGet ให้เราขยายมัน

คุณจะเห็นการอ้างอิงทั้งชุดของ NuGet Package หากคุณเคยทำงานใน. NET Framework แล้วเนมสเปซเหล่านี้จำนวนมากจะดูคุ้นเคยเพราะคุณคุ้นเคยกับการใช้งานใน. NET Framework

.NET Framework ถูกแบ่งออกเป็นส่วนต่างๆมากมายและนำไปใช้กับ CoreFx อีกครั้ง ชิ้นส่วนเหล่านี้จะถูกแจกจ่ายต่อไปในแต่ละแพ็คเกจ

  • ตอนนี้ถ้าคุณขยาย NETStandard.Library คุณจะเห็นการอ้างอิงเพิ่มเติม คุณจะสังเกตเห็น System.Console ที่เราใช้ในแอปพลิเคชันนี้

  • ตอนนี้คุณไม่จำเป็นต้องนำทุกอย่างเข้ามาใน. NET Framework แต่เพียงแค่นำสิ่งที่คุณต้องการสำหรับแอปพลิเคชันของคุณ

  • มีประโยชน์อื่น ๆ เช่นกัน ตัวอย่างเช่นโมดูลเหล่านี้สามารถอัปเดตทีละรายการได้หากต้องการ

Modularity นำไปสู่ประโยชน์ด้านประสิทธิภาพและแอปพลิเคชันของคุณสามารถทำงานได้เร็วขึ้นโดยเฉพาะแอปพลิเคชัน ASP.NET Core

ในบทนี้เราจะพูดถึงไฟล์โครงการ. NET Core และวิธีเพิ่มไฟล์ที่มีอยู่ในโปรเจ็กต์ของคุณ

ให้เราเข้าใจตัวอย่างง่ายๆที่เรามีไฟล์บางไฟล์ที่สร้างไว้แล้ว เราต้องเพิ่มไฟล์เหล่านี้ในโครงการ FirstApp ของเรา

นี่คือการใช้งานไฟล์ Student.cs ไฟล์

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; } 
   } 
}

นี่คือการใช้งานไฟล์ Course.cs ไฟล์.

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; } 
   } 
}

ตอนนี้ให้เราบันทึกไฟล์ทั้งสามนี้ในดิสก์ของคุณและโฟลเดอร์ต้นทางของโครงการของคุณ

  • ตอนนี้ถ้าคุณคุ้นเคยกับ. NET และอันนี้เป็นแอปพลิเคชันคอนโซล. NET แบบดั้งเดิมสิ่งสำคัญคือต้องเข้าใจวิธีเพิ่มไฟล์เหล่านี้ในโครงการของคุณใน Visual Studio

  • ก่อนอื่นคุณต้องลากไฟล์ไปยังตัวสำรวจโซลูชันเพื่อคัดลอกไฟล์ในโฟลเดอร์โครงการของคุณเนื่องจากโครงการของคุณต้องการการอ้างอิงถึงไฟล์เหล่านี้

  • ข้อดีอย่างหนึ่งของ. NET Core คือแนวทางที่ใช้กับไฟล์โครงการ (project.json); เราสามารถวางไฟล์ลงในรูทของโปรเจ็กต์จากนั้นไฟล์เหล่านี้จะถูกรวมไว้ในโปรเจ็กต์ของเราโดยอัตโนมัติ

  • เราไม่จำเป็นต้องอ้างอิงไฟล์ด้วยตนเองเหมือนที่เคยทำมาในอดีตสำหรับแอปพลิเคชัน. NET Framework แบบดั้งเดิมใน Visual Studio

ตอนนี้ให้เราเปิดรูทของโครงการของคุณ

ตอนนี้ให้เราคัดลอกไฟล์ทั้งสามไฟล์ลงในรูทของโปรเจ็กต์ของคุณ

ตอนนี้คุณสามารถดูไฟล์ทั้งหมดที่คัดลอกไปยังโฟลเดอร์รูทได้

ตอนนี้ให้เราไปที่ Visual Studio; คุณจะได้รับกล่องโต้ตอบต่อไปนี้

คลิก Yes to All เพื่อโหลดโครงการของคุณใหม่

ตอนนี้คุณจะรวมไฟล์ไว้ในโครงการของคุณโดยอัตโนมัติ

ในบทนี้เราจะพูดถึงวิธีการเพิ่มแพ็กเกจในแอปพลิเคชัน. NET Core ของคุณและวิธีค้นหาแพ็กเกจเฉพาะ เราสามารถไปที่ NuGet ได้โดยตรงและเพิ่มแพ็คเกจ แต่ที่นี่เราจะเห็นสถานที่อื่น ๆ

ให้เราไปที่ซอร์สโค้ดของ. NET Core ซึ่งอยู่ที่นี่ - https://github.com/dotnet/corefx

ใน CoreFx repo ให้เปิดไฟล์ src โฟลเดอร์ -

และคุณจะเห็นรายการโฟลเดอร์ทั้งหมดที่สอดคล้องกับแพ็คเกจต่างๆ ให้เราค้นหา Json -

มีอีกวิธีหนึ่งในการค้นหาแพ็คเกจของคุณคุณอาจรู้จักประเภทต่างๆหากคุณคุ้นเคยกับ. NET Framework แต่การประกอบแพ็คเกจใน. NET Core นั้นแตกต่างกันโดยสิ้นเชิงและคุณจะไม่รู้ว่าแพ็คเกจนั้นอยู่ที่ไหน

หากคุณทราบประเภทคุณสามารถค้นหาเพื่อย้อนกลับการค้นหาแพ็กเกจโดยใช้ https://packagesearch.azurewebsites.net/

ที่นี่คุณสามารถป้อนแพ็คเกจประเภทใดก็ได้ที่คุณต้องการค้นหา จากนั้นไซต์นี้จะสแกน NuGet และค้นหาแพ็คเกจที่เกี่ยวข้องสำหรับคุณ

ให้เราค้นหา DataContractJson.

ตอนนี้คุณจะเห็นว่าเราได้รับแพ็คเกจเดียวกัน ให้เราคลิกที่แพ็คเกจ

ตอนนี้คุณจะเห็นหน้า NuGet คุณต้องยืนยันว่าคุณต้องการแพ็คเกจนี้ คุณสามารถเพิ่มสิ่งนี้ในแอปพลิเคชันของคุณโดยใช้วิธีการสองสามวิธี

ให้เราเปิดไฟล์ project.json

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

นี่คือรูปแบบโครงการใหม่และภายในไฟล์นี้คุณจะเห็นส่วนการอ้างอิง ให้เราเพิ่มการอ้างอิงใหม่ตามที่แสดงด้านล่าง

{ 
   "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" 
      } 
   } 
}

ตอนนี้ถ้าคุณดูข้อมูลอ้างอิงของคุณคุณจะเห็นว่า System.Runtime.Serialization.Json เพิ่มแพ็คเกจในโปรเจ็กต์ของคุณแล้ว

อีกวิธีหนึ่งคือไปที่ NuGet Manager และเรียกดูแพ็คเกจที่คุณต้องการเพิ่ม

ในบทนี้เราจะพูดถึงวิธีการสร้างแอปพลิเคชัน UWP โดยใช้. NET Core UWP เรียกอีกอย่างว่าแอปพลิเคชัน Windows 10 UWP แอปพลิเคชันนี้ไม่ทำงานบน Windows เวอร์ชันก่อนหน้า แต่จะทำงานบน Windows เวอร์ชันอนาคตเท่านั้น

ต่อไปนี้เป็นข้อยกเว้นบางประการที่ UWP จะทำงานได้อย่างราบรื่น

  • หากคุณต้องการเรียกใช้ภายในเครื่องคุณต้องมี Windows 10 คุณสามารถพัฒนาบน Windows 8 ได้จากนั้นคุณจะต้องเรียกใช้บน Emulator แต่ขอแนะนำให้ใช้ Windows 10

  • สำหรับแอปพลิเคชัน UWP คุณจะต้องมี Windows 10 SDK ด้วย ให้เราเปิดการตั้งค่า Visual Studio 2015 จากนั้นแก้ไข Visual Studio

  • ในหน้าคุณสมบัติที่เลือกให้เลื่อนลงและคุณจะเห็น Universal Windows App Development Tools ตรวจสอบตัวเลือกนั้นตามที่แสดงด้านล่าง

ที่นี่คุณสามารถดู SDK เวอร์ชันต่างๆและการอัปเดตล่าสุดเกี่ยวกับเครื่องมือได้เช่นกันคลิกถัดไป

ตอนนี้คลิกไฟล์ Install ปุ่ม.

เมื่อการติดตั้งเสร็จสิ้นคุณจะต้องรีสตาร์ทระบบของคุณ

ตอนนี้ให้เราใช้ UWP โดยทำตามขั้นตอนเหล่านี้

  • ขั้นแรกให้เปิด Visual Studio 2015

  • คลิกที่เมนูไฟล์และเลือกใหม่→โครงการ; กล่องโต้ตอบโครงการใหม่จะปรากฏขึ้น คุณสามารถดูเทมเพลตประเภทต่างๆได้ที่บานหน้าต่างด้านซ้ายของกล่องโต้ตอบ

  • ในบานหน้าต่างด้านซ้ายคุณจะเห็นมุมมองแบบต้นไม้ตอนนี้เลือกเทมเพลตสากลจากเทมเพลต→ Visual C # → Windows

  • จากบานหน้าต่างตรงกลางให้เลือกเทมเพลต Blank App (Universal Windows)

  • ตั้งชื่อโครงการโดยพิมพ์ UWPFirstApp ในฟิลด์ชื่อและคลิกตกลง

  • กล่องโต้ตอบเวอร์ชันเป้าหมาย / เวอร์ชันขั้นต่ำจะปรากฏขึ้น การตั้งค่าเริ่มต้นใช้ได้ดีสำหรับบทช่วยสอนนี้ดังนั้นให้เลือกตกลงเพื่อสร้างโครงการ

  • ที่นี่เรามีโครงการเดียวที่สามารถกำหนดเป้าหมายอุปกรณ์ Windows 10 ทั้งหมดและคุณจะสังเกตเห็นว่าทั้ง. NET Core และ UWP นั้นทำให้การกำหนดเป้าหมายหลายเป้าหมายง่ายขึ้น

  • เมื่อโปรเจ็กต์ใหม่เปิดขึ้นไฟล์จะแสดงที่ด้านขวามือของบานหน้าต่าง Solution Explorer คุณอาจต้องเลือกแท็บ Solution Explorer แทนแท็บคุณสมบัติเพื่อดูไฟล์ของคุณ

  • แม้ว่า Blank App (Universal Window) จะเป็นเทมเพลตขั้นต่ำ แต่ก็ยังมีไฟล์จำนวนมาก ไฟล์เหล่านี้จำเป็นสำหรับแอป UWP ทั้งหมดที่ใช้ C # ทุกโครงการที่คุณสร้างใน Visual Studio มีไฟล์

  • หากต้องการดูตัวอย่างการทำงานให้เราเปิด MainPage.XAML และเพิ่มรหัสต่อไปนี้

<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>

ด้านล่างนี้คือเหตุการณ์การคลิกของปุ่มใน C #

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"; 
      } 
   } 
}

ตอนนี้ให้เราเรียกใช้รหัสด้านบนบนเครื่องท้องถิ่นและคุณจะเห็นหน้าต่างต่อไปนี้ ตอนนี้พิมพ์ชื่อใดก็ได้ในกล่องข้อความแล้วกดClick Me ปุ่ม.

ในบทนี้เราจะพูดถึง MSBuild คืออะไรและทำงานอย่างไรกับ. NET Core MSBuild เป็นแพลตฟอร์มการสร้างสำหรับ Microsoft และ Visual Studio ในแอปพลิเคชัน UWP หากคุณเปิดโฟลเดอร์โปรเจ็กต์คุณจะเห็นทั้งไฟล์ project.json และ * .csproj

แต่ถ้าคุณเปิดแอป. NET Core Console ก่อนหน้าคุณจะเห็นไฟล์ project.json และ * .xproj

  • ระบบสร้าง. NET Core หรือระบบบิลด์ project.json ไม่เพียงพอสำหรับความต้องการของ UWP นี่คือเหตุผลที่ UWP ยังคงใช้ระบบสร้าง * .csproj (MSBuild)

  • แต่ project.json จะย้ายออกไปเท่าที่ระบบสร้างเกี่ยวข้อง

  • ตอนนี้หากคุณต้องการเพิ่มไฟล์ที่มีอยู่สองสามไฟล์ลงในแอปพลิเคชัน UWP ของคุณตามที่เราได้เพิ่มไว้ในแอป Console คุณจะต้องเพิ่มไฟล์เหล่านั้นในโฟลเดอร์โครงการ นอกจากนี้คุณจะต้องรวมไว้ในโครงการของคุณใน Solution Explorer ด้วย

ตอนนี้ให้เราพิจารณาไฟล์ต่อไปนี้ คัดลอกไฟล์เหล่านี้ไปยังโฟลเดอร์โครงการของคุณ

ให้เรากลับไปที่ Visual Studio และเปิด Solution Explorer

  • ตอนนี้คุณจะเห็นได้ว่าการคัดลอกไฟล์เท่านั้นไม่เพียงพอในกรณีของแอปพลิเคชัน UWP เนื่องจากใน Solution Explorer เราไม่สามารถมองเห็นไฟล์เหล่านั้นได้

  • ตอนนี้เราต้องรวมไฟล์เหล่านั้นด้วยโดยคลิกที่ไฟล์ Show All Files ไอคอนตามที่ไฮไลต์ในภาพหน้าจอด้านบนและคุณจะเห็นไฟล์ทั้งหมดในโฟลเดอร์โครงการ

ไฟล์ทั้งสองนี้ยังไม่รวมอยู่ในโครงการของเรา ในการรวมไฟล์เหล่านี้ให้เลือกไฟล์เหล่านี้และคลิกขวาที่ไฟล์ใดก็ได้จากนั้นเลือกInclude in Project.

ตอนนี้ไฟล์เหล่านี้รวมอยู่ด้วย สิ่งที่ดีอย่างหนึ่งที่สามารถมองเห็นได้คือแนวทางของ project.json ในการวางไฟล์สำหรับ * .csproj ในเครื่องมือ SKD เวอร์ชันอนาคตและไปยัง Visual Studio

ในบทนี้เราจะพูดถึงการอ้างอิงระหว่างแอปคอนโซลและแอป UWP ของเรา หากคุณดูการอ้างอิงใน Solution Explorer ของแอปพลิเคชัน Console คุณจะเห็น. NETCoreApp ดังที่แสดงด้านล่าง

.NETCoreApp เป็นกรอบงานใหม่ที่กำหนดเป้าหมายแอปพลิเคชัน. NET Core ตอนนี้ถ้าคุณดูภายใต้การอ้างอิงของแอปพลิเคชัน UWP มันจะดูแตกต่างออกไปเล็กน้อยดังที่แสดงด้านล่าง

  • สาเหตุหลักของสิ่งนี้เป็นเพราะที่นี่ใน UWP เรามี * .csproj ดังนั้นเราจึงกลับไปใช้การอ้างอิงแบบเก่าและเราสามารถกำหนดเป้าหมายได้เพียงกรอบงานเดียวกับประเภทโครงการนี้

  • การอ้างอิงมีความคล้ายคลึงกัน ตอนนี้คุณสามารถเห็นว่าในแอปพลิเคชัน UWP การอ้างอิง Miscrosoft.NETCore.UniversalWindowsPlatform NuGet Package นั้นคล้ายกับการอ้างอิง Microsoft.NETCore.App NuGet ในแอปพลิเคชัน Console

  • ทั้ง Miscrosoft.NETCore.UniversalWindowsPlatform และ Microsoft.NETCore.App เป็น meta-package ซึ่งหมายความว่าประกอบด้วยแพ็คเกจอื่น ๆ

  • ในแอปพลิเคชัน Console เราสามารถเจาะลึกและดูแพ็คเกจอื่น ๆ ใน Microsoft.NETCore.App ได้ แต่เราไม่สามารถทำ Miscrosoft.NETCore.UniversalWindowsPlatform เดียวกันใน Solution Explorer ได้

  • อย่างไรก็ตามเราสามารถใช้เครื่องมืออื่น NuGet Package Explorer เพื่อดูสิ่งนี้ได้ ให้เราเปิด url นี้ในเบราว์เซอร์ -https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application และคุณจะเห็นยูทิลิตี้ขนาดเล็กกำลังดาวน์โหลด

  • เมื่อดาวน์โหลดเสร็จแล้วให้ดับเบิลคลิกที่ไฟล์นั้น

  • คลิก Install เพื่อเริ่มการติดตั้งบน NuGet Package Explorer

  • เมื่อการติดตั้งเสร็จสิ้นคุณจะเห็นกล่องโต้ตอบต่อไปนี้

  • ให้เราคลิกที่ไฟล์ Open a package from online feed ตัวเลือก

  • โดยค่าเริ่มต้นจะค้นหาฟีด nuget.org ให้เราค้นหา Microsoft.NETCore.UniversalWindowsPlatform ในช่องค้นหาและคุณจะเห็น 1 ผลลัพธ์ดังที่แสดงด้านล่าง

  • คลิก open และมันจะเปิดการอ้างอิงระดับบนสุดของ metapackage นี้

  • ให้เราเปิดแพ็คเกจเมตา. NETCore สำหรับแอปพลิเคชัน. NETCore และ meta-package สำหรับแอปพลิเคชัน UWP เคียงข้างกัน

  • ตอนนี้คุณสามารถเห็นได้ว่า meta-package แต่ละชุดประกอบด้วยชุดแพ็คเกจที่แตกต่างกัน

  • .NET Core เป็นชุดย่อยของคลาสที่มีอยู่ใน. NET Framework อย่างน้อย ณ เวลานี้ แต่กำลังเติบโตและจะเป็นไปตามคลาสพื้นฐานของ. NET Framework

  • UWP ใช้. NET Core ซึ่งเป็นส่วนเหนือของ API ที่พร้อมใช้งานสำหรับการพัฒนา Windows Store

ขณะนี้เรามี API เพิ่มเติมสำหรับการพัฒนาเนื่องจาก. NET Core

คอมโพเนนต์ Windows Runtime เป็นอ็อบเจ็กต์ในตัวที่คุณสามารถสร้างอินสแตนซ์และใช้จากภาษาใดก็ได้รวมถึง C #, Visual Basic, JavaScript และ C ++ นอกจากเมตาแพ็กเกจ. NET Core ที่เราเห็นในบทก่อนหน้าแล้วแอป UWP ยังมีการอ้างอิงตามค่าเริ่มต้นของ Universal Windows SDK

Universal Windows คือการอ้างอิงถึง Windows Runtime และได้รับการรวมเข้าไว้ในชุดของสัญญา API

ชุดของ API ภายในกลุ่มอุปกรณ์แบ่งออกเป็นแผนกย่อยที่เรียกว่าสัญญา API คุณสามารถดูรายการสัญญา API ต่างๆได้ที่นี่https://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

API เหล่านั้นส่วนใหญ่ใน Windows runtime จะรวมอยู่ในสัญญาเดียว ให้เราค้นหาคำหลักสากลในหน้าสัญญา API

คุณสามารถดูลิงก์ไปยัง API ต่างๆได้และคุณยังเห็นว่าตระกูล Universal มีขนาดใหญ่มากจนมีเอกสารประกอบ 12 หน้า

คุณยังสามารถค้นหาสัญญา API โทรศัพท์ได้ในหน้านี้

ให้เราคลิกที่ไฟล์ Windows.Phone.PhoneContractและเลื่อนลง ตอนนี้คุณจะเห็นข้อมูลแบตเตอรี่ของโทรศัพท์หรืออุปกรณ์มือถือ

หากคุณต้องการเพิ่มข้อมูลนี้จากสิ่งที่คุณมีอยู่แล้วคุณควรเพิ่มข้อมูลอ้างอิงด้วยตนเอง ให้เราไปที่ Visual Studio แล้วคลิกขวาที่ References ใน Solution Explorer

เลือก Add References…

ตอนนี้คุณสามารถดูหมวดหมู่อ้างอิงใหม่สำหรับ Universal Windows ได้แล้ว ภายใต้หมวดหมู่นี้มี Core ซึ่งหมายถึงสัญญา Universal Windows API หลัก

  • ส่วนขยายช่วยให้เราสามารถขยายฟังก์ชันการทำงานและคุณจะเห็นข้อมูลอ้างอิงต่างๆสำหรับมือถือเดสก์ท็อปและส่วนขยายอื่น ๆ

  • มีส่วนขยาย SKD ที่แตกต่างกันและคุณสามารถเพิ่มด้านบนเพื่อรับ API เพิ่มเติมได้

  • คุณยังสามารถดูเวอร์ชันต่างๆ ดังนั้นตรวจสอบให้แน่ใจว่าคุณได้รับเวอร์ชันล่าสุดเพื่อรับ API ที่อัปเดตจากนั้นคลิกตกลง

ตอนนี้คุณสามารถดูได้แล้ว Windows Mobile Extensions for the UWP ถูกเพิ่มเป็นข้อมูลอ้างอิง

ไลบรารีคลาสกำหนดประเภทและวิธีการที่สามารถเรียกใช้จากแอปพลิเคชันใดก็ได้

  • ไลบรารีคลาสที่พัฒนาโดยใช้. NET Core สนับสนุน. NET Standard Library ซึ่งช่วยให้ไลบรารีของคุณถูกเรียกโดยแพลตฟอร์ม. NET ใด ๆ ที่สนับสนุนไลบรารีมาตรฐาน. NET เวอร์ชันนั้น

  • เมื่อคุณเสร็จสิ้นไลบรารีชั้นเรียนของคุณคุณสามารถตัดสินใจได้ว่าคุณต้องการแจกจ่ายเป็นส่วนประกอบของบุคคลที่สามหรือว่าคุณต้องการรวมไว้เป็นส่วนประกอบที่มาพร้อมกับแอปพลิเคชันตั้งแต่หนึ่งรายการขึ้นไป

ให้เราเริ่มต้นด้วยการเพิ่มโปรเจ็กต์ไลบรารีคลาสในแอปพลิเคชันคอนโซลของเรา คลิกขวาที่ไฟล์src ใน Solution Explorer และเลือก Add → New Project…

ใน Add New Project กล่องโต้ตอบเลือกโหนด. NET Core จากนั้นเลือกเทมเพลตโปรเจ็กต์ Class Library (.NET Core)

ในกล่องข้อความชื่อให้ป้อน "UtilityLibrary" เป็นชื่อของโครงการดังที่แสดงในรูปต่อไปนี้

คลิกตกลงเพื่อสร้างโปรเจ็กต์ไลบรารีคลาส เมื่อสร้างโครงการแล้วให้เราเพิ่มชั้นเรียนใหม่ คลิกขวาที่project ใน Solution Explorer และเลือก Add → Class...

เลือกคลาสในบานหน้าต่างตรงกลางแล้วป้อน StringLib.cs ในชื่อและฟิลด์จากนั้นคลิก Add. เมื่อเพิ่มคลาสแล้วให้แทนที่โค้ดต่อไปนี้ในไฟล์ StringLib.cs

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); 
      } 
   } 
}
  • ห้องสมุดชั้นเรียน UtilityLibrary.StringLibมีวิธีการบางอย่างเช่น StartsWithUpper, StartsWithLowerและ StartsWithNumber ซึ่งส่งคืนค่าบูลีนที่ระบุว่าอินสแตนซ์สตริงปัจจุบันเริ่มต้นด้วยตัวพิมพ์ใหญ่ตัวพิมพ์เล็กและตัวเลขตามลำดับหรือไม่

  • ใน. NET Core, Char.IsUpper method จะคืนค่า true ถ้าอักขระเป็นตัวพิมพ์ใหญ่เมธอด Char.IsLower จะคืนค่า true หากอักขระเป็นตัวพิมพ์เล็กและในทำนองเดียวกันวิธี Char.IsNumber จะส่งกลับค่า true หากอักขระเป็นตัวเลข

  • บนแถบเมนูเลือก Build, Build Solution โครงการควรรวบรวมโดยไม่มีข้อผิดพลาด

  • โครงการคอนโซล. NET Core ของเราไม่มีสิทธิ์เข้าถึงไลบรารีชั้นเรียนของเรา

  • ในการใช้ไลบรารีคลาสนี้เราจำเป็นต้องเพิ่มการอ้างอิงของไลบรารีคลาสนี้ในโปรเจ็กต์คอนโซลของเรา

ในการดำเนินการดังกล่าวให้ขยาย FirstApp และคลิกขวาที่การอ้างอิงและเลือก Add Reference…

ในกล่องโต้ตอบตัวจัดการการอ้างอิงเลือก UtilityLibrary โครงการไลบรารีชั้นเรียนของเราแล้วคลิก OK.

ตอนนี้ให้เราเปิดไฟล์ Program.cs ของโครงการคอนโซลและแทนที่รหัสทั้งหมดด้วยรหัสต่อไปนี้

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); 
      } 
   } 
}

ตอนนี้ให้เราเรียกใช้แอปพลิเคชันของคุณและคุณจะเห็นผลลัพธ์ต่อไปนี้

เพื่อความเข้าใจที่ดีขึ้นให้เราใช้วิธีการขยายอื่น ๆ ของไลบรารีชั้นเรียนของคุณในโครงการของคุณ

ในบทนี้เราจะพูดถึง PCL (Portable Class Library) คืออะไรและทำไมเราถึงต้องการ PCL เพื่อทำความเข้าใจแนวคิดนี้ให้เราเปิดโฟลเดอร์โปรเจ็กต์ไลบรารีคลาสซึ่งเราได้สร้างไว้ในบทที่แล้ว

ในโฟลเดอร์นี้คุณจะเห็นว่านอกจากไฟล์ project.json และ CS แล้วเรายังมีไฟล์ * .xproj ด้วยและนั่นเป็นเพราะ Visual Studio ตั้งค่า. NET Core ประเภทโครงการเป็น * .xproj แทน * .csproj

ดังที่กล่าวไว้โดย Microsoft * .xproj จะหายไป แต่ยังคงอยู่ที่นี่ในการแสดงตัวอย่างเครื่องมือ 2 ดังที่เราได้กล่าวถึงแอปพลิเคชัน UWP นั้นใช้ * .csproj

ตอนนี้มันเป็นไปไม่ได้ที่จะรับ * .csproj เพื่ออ้างอิงและ * .xproj และฟังก์ชันดังกล่าวจะไม่ถูกนำไปใช้เนื่องจาก * .xproj จะย้ายออก

ดังนั้นเราจึงต้องการไลบรารีคลาสที่สามารถใช้ร่วมกันระหว่างแอปคอนโซลและแอป UWP แทนและนี่คือ PCL

PCL. คืออะไร

ตอนนี้ให้เราเข้าใจว่า PCL คืออะไร -

  • โครงการ Portable Class Library ช่วยให้คุณสามารถเขียนและสร้างชุดประกอบที่มีการจัดการซึ่งทำงานบนแพลตฟอร์ม. NET Framework มากกว่าหนึ่งแพลตฟอร์ม

  • คุณสามารถสร้างคลาสที่มีรหัสที่คุณต้องการแชร์กับโปรเจ็กต์ต่างๆเช่นตรรกะทางธุรกิจที่ใช้ร่วมกันจากนั้นอ้างอิงคลาสเหล่านั้นจากโปรเจ็กต์ประเภทต่างๆ

  • นอกจากนี้ยังสามารถช่วยคุณสร้างแอปและไลบรารีข้ามแพลตฟอร์มสำหรับแพลตฟอร์ม Microsoft ได้อย่างรวดเร็วและง่ายดาย

  • ไลบรารีคลาสพกพาสามารถช่วยคุณลดเวลาและค่าใช้จ่ายในการพัฒนาและทดสอบโค้ด

  • ใช้ประเภทโปรเจ็กต์นี้เพื่อเขียนและสร้างแอสเซมบลี. NET Framework แบบพกพาจากนั้นอ้างอิงแอสเซมบลีเหล่านั้นจากแอพที่กำหนดเป้าหมายหลายแพลตฟอร์มเช่น Windows และ Windows Phone เป็นต้น

ตอนนี้ให้เราลบไลบรารีคลาสที่เราสร้างขึ้นจาก Solution Explorer ในเวลาเดียวกันให้ลบออกจากโฟลเดอร์โซลูชันและเพิ่มรายการโครงการใหม่เพิ่มเติม

เลือกไฟล์ Visual C# → Windows เทมเพลตในบานหน้าต่างด้านซ้ายและเลือก Class Library (Portable) ในบานหน้าต่างตรงกลาง

ป้อน StringLibrary ในช่องชื่อและคลิก OK เพื่อสร้างโครงการนี้

ตอนนี้เราต้องเลือกกรอบเป้าหมายที่จะอ้างอิง ให้เราเลือก Windows Universal และ ASP.NET Core สักครู่จากนั้นเราจะกำหนดเป้าหมายใหม่ คลิกOK.

คุณจะเห็นว่าได้สร้างโครงการใหม่ในรูปแบบ PCF ให้เราคลิกขวาที่โครงการ StringLibrary ใน Solution Explorer และเลือก Properties

คลิกที่ Target .NET Platform Standard

คลิกใช่; ตอนนี้เป็นไลบรารีคลาสเดียวกันโดยมีข้อแตกต่างเล็กน้อย ความแตกต่างคือ UWP สามารถใช้งานได้เช่นกันเนื่องจากมีไฟล์ * .csproj แทน * .xproj

ตอนนี้ให้เราเพิ่มคลาสใหม่ สำหรับสิ่งนี้คุณต้องคลิกขวาที่โครงการใน Solution Explorer แล้วเลือกAdd → Class...

เลือกชั้นเรียนในบานหน้าต่างตรงกลางแล้วป้อน StringLib.cs ในช่องชื่อจากนั้นคลิก Add. เมื่อเพิ่มคลาสแล้วให้แทนที่โค้ดต่อไปนี้ในไฟล์ StringLib.cs

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); 
      } 
   } 
}

ให้เราสร้างโปรเจ็กต์ไลบรารีคลาสพกพานี้และควรคอมไพล์โดยไม่มีข้อผิดพลาด ตอนนี้เราจำเป็นต้องเพิ่มการอ้างอิงของไลบรารีคลาสแบบพกพานี้ในโครงการคอนโซลของเรา ดังนั้นขยาย FirstApp และคลิกขวาที่การอ้างอิงและเลือกAdd Reference…

ในกล่องโต้ตอบ Reference Manager ให้เลือก StringLibrary ซึ่งเป็นโปรเจ็กต์ไลบรารีคลาสแบบพกพาของเราแล้วคลิก OK.

คุณจะเห็นว่าการอ้างอิง StringLibrary ถูกเพิ่มไปยังคอนโซลโปรเจ็กต์และสามารถเห็นได้ในไฟล์ project.json เช่นกัน

ตอนนี้คุณสามารถเรียกใช้แอปพลิเคชันได้อีกครั้งและคุณจะเห็นผลลัพธ์เดียวกัน

ตอนนี้ให้เราใช้วิธีการขยายอื่น ๆ ของไลบรารีคลาสพกพาของคุณในโครงการของคุณ ไลบรารีแบบพกพาเดียวกันจะถูกใช้ในแอปพลิเคชัน UWP ของคุณด้วย

ในบทนี้เราจะพูดถึงวิธีเพิ่มการอ้างอิงไปยังห้องสมุดของคุณ การเพิ่มการอ้างอิงไปยังไลบรารีก็เหมือนกับการเพิ่มการอ้างอิงไปยังโปรเจ็กต์อื่น ๆ ของคุณเช่นคอนโซลโปรเจ็กต์และโปรเจ็กต์ UWP

ตอนนี้คุณจะเห็นว่าโครงการ PCL มีการอ้างอิงตามค่าเริ่มต้น คุณยังสามารถเพิ่มข้อมูลอ้างอิงอื่น ๆ ตามความต้องการของแอปพลิเคชันของคุณ

ในไลบรารี PCL คุณยังสามารถดูไฟล์ project.json

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

วิธีหนึ่งในการเพิ่มการอ้างอิงไปยังไลบรารีของคุณคือการพิมพ์ลงในไฟล์ project.json โดยตรง ดังที่คุณเห็นว่าเราได้เพิ่มการอ้างอิงบางส่วนในส่วนการอ้างอิงตามที่แสดงในโค้ดต่อไปนี้

{ 
   "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": {} 
   } 
}

ตอนนี้ให้เราบันทึกไฟล์นี้และคุณจะเห็นว่ามีการเพิ่มการอ้างอิงลงในห้องสมุดของคุณแล้ว

วิธีอื่นในการเพิ่มการอ้างอิงไปยังไลบรารีของคุณคือ NuGet Package Manager ให้เราคลิกขวาที่ไฟล์StringLibrary (Portable) โครงการและเลือก Mange NuGet Packages…

บนแท็บเรียกดูคุณสามารถค้นหาแพ็คเกจ NuGet ใดก็ได้ ให้เราบอกว่าเราต้องการเพิ่มแพ็คเกจ“ System.Runtime.Serialization.Primitives”

คลิก Install ซึ่งจะแสดงหน้าจอต่อไปนี้

ตอนนี้คลิกไฟล์ OK ปุ่ม.

สุดท้ายคลิกไฟล์ I Acceptเพื่อเริ่มการติดตั้งแพ็คเกจ NuGet นี้ เมื่อติดตั้งเสร็จแล้วคุณจะเห็นว่ามีการเพิ่มแพ็คเกจ NuGet“ System.Runtime.Serialization.Primitives” ลงในไลบรารีของคุณ

ในบทนี้เราจะพูดถึงวิธีการแบ่งปันห้องสมุดของคุณเป็น NuGet Packageเพื่อให้สามารถใช้ภายในโครงการอื่นได้ การสร้างแพ็คเกจเริ่มต้นด้วยรหัสที่คุณต้องการจัดแพ็กเกจและแชร์กับผู้อื่นไม่ว่าจะผ่านแกลเลอรี nuget.org สาธารณะหรือแกลเลอรีส่วนตัวภายในองค์กรของคุณ แพคเกจยังสามารถรวมไฟล์เพิ่มเติมเช่นไฟล์readme ที่แสดงเมื่อติดตั้งแพ็กเกจและสามารถรวมการแปลงไฟล์โปรเจ็กต์บางไฟล์

ตอนนี้ให้เราพิจารณาตัวอย่างง่ายๆที่เราจะสร้างแพ็คเกจ NuGet จากห้องสมุดของเรา ในการทำเช่นนั้นให้เปิดพรอมต์คำสั่งและไปที่โฟลเดอร์ที่มีไฟล์ project.json ของโปรเจ็กต์ไลบรารีของคุณ

ให้เรารันคำสั่งต่อไปนี้

dotnet help

ในตอนท้ายคุณจะเห็นคำสั่งต่างๆเช่นใหม่เรียกคืนและสร้าง ฯลฯ

คำสั่งสุดท้ายคือ pack;สิ่งนี้จะสร้างแพ็คเกจ NuGet ตอนนี้ให้เราดำเนินการคำสั่งต่อไปนี้

dotnet pack

ตอนนี้คุณจะเห็นว่าแพ็คเกจ NuGet ถูกสร้างขึ้นในโฟลเดอร์ bin ให้เราเปิดโฟลเดอร์ bin \ Debug

คำถามคือสิ่งที่อยู่ในแพ็คเกจ NuGet เพื่อดูว่าเราสามารถใช้ NuGet Package Explorer ได้ ให้เราเปิด NuGet Package Explorer

เลือกตัวเลือกแรก Open a local package.

เลือกไฟล์ StringLibrary.1.0.0.nupkg แล้วคลิก Open.

คุณจะเห็นว่าในส่วนเนื้อหาแพ็คเกจเรามีเฉพาะ StringLibrary.dll ในส่วนข้อมูลเมตาของแพ็กเกจคุณจะเห็นข้อมูลเล็กน้อยเกี่ยวกับไลบรารีนี้เช่น Id เวอร์ชันและการอ้างอิงทั้งหมด

ให้เราเปิดไฟล์ StringLibrary.1.0.0.symbols.nupkg.

ในแพ็คเกจ NuGet นี้คุณจะเห็นไฟล์ต้นฉบับและไฟล์ *.pdbไฟล์ด้วย หากคุณดับเบิลคลิกที่ไฟล์StringLib.cs คุณจะเห็นซอร์สโค้ดด้วย

คำถามคือวิธีกำหนดค่าข้อมูลเมตาเช่นเวอร์ชันผู้เขียนและคำอธิบาย ฯลฯ

ไฟล์ project.json ใช้กับโปรเจ็กต์. NET Core เพื่อกำหนดข้อมูลเมตาของโปรเจ็กต์ข้อมูลคอมไพล์และการอ้างอิง ให้เราเปิดไฟล์ project.json และเพิ่มข้อมูลเพิ่มเติมดังต่อไปนี้

{ 
   "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": {} 
   } 
}

ตอนนี้คุณสามารถดูข้อมูลเพิ่มเติมเช่นชื่อผู้แต่งคำอธิบายและเวอร์ชันที่เพิ่มได้ที่นี่ ให้เราบันทึกไฟล์นี้สร้างโปรเจ็กต์ไลบรารีจากนั้นเรียกใช้คำสั่ง“ dotnet pack” อีกครั้ง

ภายในโฟลเดอร์ bin \ Debug คุณจะเห็นว่าแพ็กเกจ StringLibrary NuGet ถูกสร้างขึ้นด้วยเวอร์ชัน 1.0.1; ให้เราเปิดใน NuGet Package Explorer

คุณจะเห็นข้อมูลเมตาที่อัปเดต คำถามตอนนี้คือเราจะใช้มันในแพ็คเกจอื่นได้อย่างไร

เราต้องเริ่มต้นด้วยการเผยแพร่ที่ใดที่หนึ่งในฟีด NuGet จากนั้นเราสามารถใช้มันในโครงการอื่นได้

มีสองตัวเลือกในการเผยแพร่ข้อมูลเมตาที่อัปเดต -

  • เผยแพร่ไปยัง nuget.org
  • พุชข้อมูลเมตาไปยังฟีด NuGet ส่วนตัว

ที่นี่เราจะใช้ฟีด NuGet ส่วนตัวเพราะง่ายกว่าการตั้งค่าบัญชีบน nuget.org มาก หากต้องการเรียนรู้วิธีเผยแพร่แพ็คเกจของคุณไปยัง nuget.org คุณสามารถปฏิบัติตามหลักเกณฑ์ทั้งหมดที่ระบุไว้ที่นี่https://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package.

ทำตามขั้นตอนเหล่านี้เพื่อพุชข้อมูลเมตาที่อัปเดตไปยังฟีด NuGet ส่วนตัว

Step 1- ในการเริ่มต้นเราต้องมียูทิลิตี้ nuget commandline และเราต้องติดตั้ง ให้เราเปิด NuGet Package Manager แล้วค้นหา nuget.commandline

Step 2 - เลือก Nuget.Commandline แล้วคลิก Install.

Step 3 - คลิก OKเพื่อติดตั้ง Nuget.Commandline คุณยังสามารถติดตั้งด้วยตนเองได้โดยดาวน์โหลดจาก URL ต่อไปนี้https://dist.nuget.org/index.html จากนั้นตั้งค่าตัวแปรสภาพแวดล้อม

Step 4 - เมื่อการติดตั้งเสร็จสิ้นให้เราเปิดพรอมต์คำสั่งอีกครั้งและไปที่ไฟล์ bin\Debug โฟลเดอร์ที่เป็นที่ตั้งของแพ็คเกจ NuGet และระบุคำสั่งต่อไปนี้ -

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

Step 5 - ในคำสั่งด้านบนเราเพิ่มแพ็คเกจ StringLibrary.1.0.1.nupkg ลงในฟีดส่วนตัวของเราและตำแหน่งคือ D:\PrivateNugetPackages, -Source ระบุแหล่งที่มาของแพ็กเกจ

Step 6 - คุณจะเห็นว่าไฟล์ StringLibraryติดตั้ง; ที่StringLibrary สามารถเพิ่มลงในฟีดส่วนตัวได้

Step 7 - ให้เราไปที่โฟลเดอร์นั้น

Step 8 - ภายใน stringlibrary คุณจะเห็นโฟลเดอร์อื่นที่มีชื่อเวอร์ชันและนี่คือ 1.0.1

แพ็คเกจ NuGet อยู่ที่นี่

ในบทนี้เราจะพูดถึงวิธีการใช้งานแพ็คเกจ NuGet ซึ่งเราได้สร้างและเผยแพร่ไปยังฟีด NuGet ส่วนตัว ก่อนอื่นเราจะสร้างโครงการ Xamarin.Forms เราต้องเข้าใจก่อนว่า Xamarin.Forms คืออะไร

  • Xamarin.Forms เป็นเฟรมเวิร์กที่ช่วยให้นักพัฒนาสามารถสร้างอินเทอร์เฟซผู้ใช้ข้ามแพลตฟอร์มได้อย่างรวดเร็ว

  • Xamarin.Forms เป็นนามธรรมชุดเครื่องมือ UI ที่ได้รับการสนับสนุนข้ามแพลตฟอร์มซึ่งช่วยให้นักพัฒนาสามารถสร้างอินเทอร์เฟซผู้ใช้ที่สามารถแชร์บน Android, iOS, Windows และ Windows Phone ได้อย่างง่ายดาย

  • อินเทอร์เฟซผู้ใช้แสดงผลโดยใช้การควบคุมดั้งเดิมของแพลตฟอร์มเป้าหมายทำให้แอปพลิเคชัน Xamarin.Forms ยังคงรักษารูปลักษณ์ที่เหมาะสมสำหรับแต่ละแพลตฟอร์ม

ในการเริ่ม Xamarin.Forms เราจำเป็นต้องมีคุณสมบัติเพิ่มเติมบางอย่างใน Visual Studio 2015 ให้เราแก้ไข Visual Studio 2015 ของคุณและตรวจสอบให้แน่ใจว่าได้เลือกตัวเลือกการพัฒนาอุปกรณ์เคลื่อนที่ข้ามแพลตฟอร์มต่อไปนี้

เมื่อการติดตั้งเสร็จสิ้นให้เราอัปเดต Xamarin โดยเลือก Tools → Options…

เลื่อนลงและขยาย Xamarin ในบานหน้าต่างด้านซ้ายจากนั้นเลือก Other. ที่มุมขวาบนของกล่องโต้ตอบคลิกที่Check Now เพื่อดูว่ามีการอัปเดตหรือไม่

คุณจะเห็นว่ามีการอัปเดตให้เราคลิกที่ไฟล์ Downloadเพื่อเริ่มการดาวน์โหลด เมื่อดาวน์โหลดเสร็จแล้วคุณจะได้รับแจ้งให้ติดตั้งการอัปเดต

ให้เราเปิด Visual studio อีกครั้งและเลือกไฟล์ File → New → Project… ตัวเลือกเมนู

ในบานหน้าต่างด้านซ้ายเลือกไฟล์ Visual C# → Cross-Platform เทมเพลตและในบานหน้าต่างตรงกลางให้เลือก Blank Xaml App (Xamarin.Forms Portable). ป้อนชื่อในฟิลด์ชื่อและคลิกตกลง

เลือกเวอร์ชันเป้าหมายและเวอร์ชันขั้นต่ำแล้วคลิกตกลง

คุณจะเห็นโครงการต่างๆ ที่ด้านบนสุดเรามีไลบรารี PCL ซึ่งจะใช้ร่วมกันระหว่างทุกแพลตฟอร์มเช่น Android, iOS, UWP, Windows 8.1 และ Windows Phone 8.1

ในที่นี้เราจะเน้นไปที่ไลบรารี PCL และจะนำโค้ดบางส่วนมาที่นี่ ให้เราขยายโค้ด

ในเทมเพลต Xamarin.Forms นี้คุณสามารถดู App.xaml และ MainPage.xaml ทั่วไปโดยใช้เฟรมเวิร์ก Xamarin.Forms XAML ซึ่งทำงานบนแพลตฟอร์มเหล่านี้

เราจำเป็นต้องนำเข้ารหัสของเราและเราต้องการฟีด NuGet ส่วนตัวที่เราตั้งไว้ในบทสุดท้ายด้วย

ให้เราเปิด NuGet Package Manager คลิกที่วงล้อข้างรายการแบบเลื่อนลงแหล่งที่มาของแพ็คเกจ

เราจำเป็นต้องเพิ่มฟีดส่วนตัวของเราที่นี่ให้เราคลิกที่ไฟล์ plus (+) button.

คุณจะเห็นว่ามีการเพิ่มช่องทำเครื่องหมายอื่นในไฟล์ Available package sources ให้เราระบุชื่อและเส้นทางต้นทางแล้วคลิก OK.

ตอนนี้ให้เราไปที่แท็บเรียกดูแล้วเลือก PrivateSource จากรายการแบบเลื่อนลงแหล่งที่มาของแพ็คเกจและคุณจะเห็นแพ็คเกจ StringLibrary NuGet เลือก StringLibrary แล้วคลิกInstall.

คลิกตกลงและคุณจะเห็นข้อผิดพลาดหนึ่งข้อ

เราไม่สามารถใช้ไลบรารีกับ. NETPortable profile เวอร์ชัน 259 ได้เราจะแก้ไขข้อผิดพลาดนี้ในบทถัดไป

ในบทนี้เราจะแก้ไขข้อผิดพลาดที่เราได้รับขณะติดตั้งแพ็คเกจ NuGet จากฟีดส่วนตัวของเราในโครงการ Xamarin.Forms

เราจะทำความเข้าใจปัญหาโดยสังเขปต่อไป ในการเริ่มต้นให้เราคลิกขวาที่ไลบรารี PCL และเลือก Properties

ในหน้านี้คุณจะเห็นกรอบงานทั้งหมดที่กำหนดเป้าหมายไว้ จากข้อผิดพลาดคุณจะเห็นว่า. NETPortable profile 259 เข้ากันไม่ได้กับ StringLibrary 1.0.1 ของเรา อย่างไรก็ตามกำลังพยายามอ้างอิงจากไลบรารี. NET Standard 1.1

ตอนนี้ให้เราดู. NET Standard Library และระบุว่าแพลตฟอร์มใดที่เข้ากันไม่ได้กับไลบรารีของเรา

คุณจะเห็นว่า Windows Phone Silverlight 8 เข้ากันได้กับ. NET Standard 1.0 หากคุณเปิดหน้าเว็บต่อไปนี้คุณจะเห็นว่า Profile259 สามารถรองรับเฉพาะ. NET Standard 1.0

ให้เรายกเลิกการเลือก Windows Phone Silverlight 8

คลิก OK ปุ่ม.

ตอนนี้เพื่อแก้ไขปัญหานี้ให้คลิกตกลงและยกเลิกกล่องโต้ตอบ Change Targets จากนั้นเปิด Package Manager Console และดำเนินการคำสั่งต่อไปนี้

PM > Uninstall-Package Xamarin.Forms

ตอนนี้ให้เราไปที่ Properties of PCL library คลิกที่ปุ่มเปลี่ยน

ยกเลิกการเลือก Windows Phone Silverlight 8 แล้วคลิกตกลง

ตอนนี้คุณจะเห็นว่า Windows Phone Silverlight 8 ไม่มีให้ใช้งานใน Targeted framework อีกต่อไป คุณยังสามารถดูโปรไฟล์ที่เป็นเป้าหมายได้ในขณะนี้ หากต้องการดูสิ่งนี้ให้เรายกเลิกการโหลดไลบรารี PCL และแก้ไขไฟล์ XamarinApp.csproj

ตอนนี้คุณสามารถเห็นได้ว่า TargetFrameworkProfile ตอนนี้คือ Profile111

หากคุณเปิดเอกสารคุณจะเห็นว่า Profile111 รองรับ. NET Standard 1.1

ตอนนี้ให้เราโหลด PCL อีกครั้งและเปิด NuGet Package Manager และลองติดตั้งแพ็คเกจ StringLibrary จากฟีดส่วนตัว

จากรายการดรอปดาวน์พฤติกรรมการพึ่งพาให้เลือกละเว้นการพึ่งพาแล้วคลิก Install.

คุณจะเห็นว่าตอนนี้แพ็คเกจ StringLibrary ถูกติดตั้งจากฟีดส่วนตัว หากคุณขยายการอ้างอิงของ PCL คุณจะเห็นว่ามีการเพิ่มการอ้างอิง StringLibrary ดังที่แสดงด้านล่าง

เราได้ถอนการติดตั้ง Xamarin.Forms สำหรับปัญหา Windows Phone Silverlight 8 แล้ว ต้องติดตั้ง Xamarin.Forms อีกครั้ง ขอแนะนำให้ติดตั้งเวอร์ชันเดียวกัน

เมื่อการติดตั้งเสร็จสิ้นให้เราใช้ฟังก์ชัน StringLibrary ในแอปพลิเคชันของคุณ

ในบทนี้เราจะพูดถึงวิธีการสร้างโครงการทดสอบโดยใช้. NET Core การทดสอบหน่วยเป็นกระบวนการพัฒนาซอฟต์แวร์ที่มีส่วนที่เล็กที่สุดที่ทดสอบได้ของแอปพลิเคชันซึ่งเรียกว่าหน่วย พวกเขาได้รับการพิจารณาเป็นรายบุคคลและเป็นอิสระสำหรับการดำเนินการที่เหมาะสม การทดสอบหน่วยสามารถทำได้โดยอัตโนมัติหรือทำด้วยตนเองก็ได้เช่นกัน

ให้เราเปิดกล่องโต้ตอบโครงการใหม่แล้วเลือก Visual C# → .NET Core แม่แบบ

ในกล่องโต้ตอบนี้คุณจะเห็นว่าไม่มีเทมเพลตโครงการสำหรับการทดสอบหน่วย ในการสร้างโครงการทดสอบหน่วยเราควรใช้ยูทิลิตี้บรรทัดคำสั่ง ให้เราไปที่โฟลเดอร์ Solution ที่เราสร้างขึ้น สร้างโฟลเดอร์ทดสอบและภายในโฟลเดอร์ทดสอบให้สร้างโฟลเดอร์อื่นและเรียกมันStringLibraryTests.

ให้เราใช้ยูทิลิตี้ dotnet commandline เพื่อสร้างโครงการทดสอบใหม่โดยดำเนินการคำสั่งต่อไปนี้ -

dotnet new -t xunittest

ตอนนี้คุณสามารถเห็นได้ว่ามีการสร้างโครงการ C # ใหม่ ให้เราดูในโฟลเดอร์โดยเรียกใช้ไฟล์v คำสั่งและคุณจะเห็น project.json และ Tests.cs ไฟล์ดังที่แสดงด้านล่าง

นี่คือรหัสในไฟล์ project.json

{ 
   "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

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

ในการดึงข้อมูลอ้างอิงที่จำเป็นจาก NuGet ให้เราดำเนินการคำสั่งต่อไปนี้ -

dotnet restore

เราสามารถเรียกใช้การทดสอบเมื่อการอ้างอิงที่จำเป็นถูกเรียกคืน

คุณจะเห็นได้ว่าการคอมไพล์สำเร็จ เมื่อคุณลงไปคุณจะเห็นข้อมูลบางอย่างเกี่ยวกับการทดสอบที่ดำเนินการ

ขณะนี้เรามีการทดสอบ 1 ครั้งข้อผิดพลาด 0 ข้อผิดพลาด 0 ล้มเหลว 0 ข้ามไปและเวลาที่ใช้ในกระบวนการดำเนินการยังระบุไว้เป็นข้อมูล

ในบทนี้เราจะพูดถึงวิธีเรียกใช้การทดสอบใน Visual Studio NET Core ได้รับการออกแบบโดยคำนึงถึงความสามารถในการทดสอบดังนั้นการสร้างการทดสอบหน่วยสำหรับแอปพลิเคชันของคุณจึงง่ายกว่าที่เคย ในบทนี้เราจะเรียกใช้และดำเนินการโครงการทดสอบของเราใน Visual Studio

ให้เราเปิดโซลูชัน FirstApp ใน Visual Studio

คุณจะเห็นว่ามีเพียงสองโครงการและคุณจะไม่สามารถดูโครงการทดสอบได้เนื่องจากเราไม่ได้เพิ่มโครงการนั้นในโซลูชันของเรา

ให้เราเพิ่มโฟลเดอร์ก่อนแล้วเรียกมัน test.

คลิกขวาที่ไฟล์ test โฟลเดอร์

เลือก project.json ไฟล์แล้วคลิก Open.

ภาพหน้าจอต่อไปนี้แสดงรหัสใน Tests.cs ไฟล์เป็นเอาต์พุต

เป็นการใช้งานเริ่มต้นและเป็นเพียงการทดสอบว่า True เท่ากับ true เป็นกรอบการทดสอบ xUnit และคุณจะเห็นแอตทริบิวต์ Fact ที่ใส่คำอธิบายประกอบและแสดงถึงวิธีการทดสอบ

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

ต่อไปนี้คือการใช้งาน project.json ไฟล์.

{ 
   "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" 
         ] 
      } 
   } 
}

ใน project.jsonไฟล์การพึ่งพาที่สำคัญที่สุดของกรอบการทดสอบคือ xunit ซึ่งนำมาในแอตทริบิวต์ Fact มันนำมาในกรอบการทดสอบและ API สำหรับการทดสอบกับ xunit

เรายังมีไฟล์ dotnet-test-xunitนี่คือการนำไปใช้เพื่อให้ xunit สามารถทำงานกับ. NET Core โดยเฉพาะกับ dotnet testยูทิลิตี้บรรทัดคำสั่ง จากนั้นคุณจะเห็นไฟล์testRunner ซึ่งจะเรียกใช้ xunit และคุณยังสามารถเห็นไฟล์ netcoreapp1.0 กรอบ.

คุณจะเห็นการพึ่งพา. NETCore.App ด้านล่าง

ในการเรียกใช้การทดสอบใน Visual Studio ให้เราเปิด Test Explorer จากไฟล์ Test → Window → Test Explorer ตัวเลือกเมนู

และคุณจะเห็นว่า Visual Studio ตรวจพบการทดสอบโดยอัตโนมัติ ชื่อของการทดสอบประกอบด้วยnamespace.className.TestMethodName. ให้เราคลิกที่Run All button in Test Explorer.

ขั้นแรกจะสร้างรหัสและทำการทดสอบและคุณจะเห็นเวลาทั้งหมดที่ใช้ในการทดสอบ ให้เราเปลี่ยนวิธีทดสอบเพื่อให้เราเห็นผลลัพธ์เมื่อการทดสอบล้มเหลว

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

ให้เราทำการทดสอบอีกครั้งโดยคลิกที่ไฟล์ Run All ลิงค์ปุ่ม

ตอนนี้คุณสามารถดูไฟล์ test ความล้มเหลว

ในบทนี้เราจะทดสอบ StringLibrary ของเราและในการดำเนินการดังกล่าวเราจำเป็นต้องจัดเรียงโครงการของเราใหม่เพื่อให้เราสามารถปฏิบัติตามหลักการเริ่มต้นได้

ให้เราเปิดไฟล์ global.json ไฟล์.

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

ที่ด้านบนของไฟล์นี้คุณจะเห็นการตั้งค่าโปรเจ็กต์และตั้งค่าโฟลเดอร์บางโฟลเดอร์เช่น src และ test โดยค่าเริ่มต้น.

ตามแบบแผนเราต้องมีโปรเจ็กต์ในโฟลเดอร์เหล่านี้นี่คืออนุสัญญาใหม่และจะใช้เป็นส่วนหนึ่งของ. NET Core

ในโซลูชัน Explorer คุณจะเห็นว่าทั้งโครงการคอนโซลและโครงการไลบรารีอยู่ในไฟล์ src โฟลเดอร์ในขณะที่โครงการทดสอบอยู่ภายใน test โฟลเดอร์

และโครงสร้างโปรเจ็กต์ใน Solution Explorer ไม่ได้แสดงถึงตำแหน่งที่โปรเจ็กต์มีอยู่จริงบนดิสก์ ตอนนี้ให้เราเปิดโฟลเดอร์โซลูชันและคุณจะเห็นว่าStringLibrary โครงการไม่ได้อยู่ใน src โฟลเดอร์

คุณจะเห็นว่าทั้งสองอย่าง src และ test โฟลเดอร์แม็พกับแบบแผนที่ระบุในไฟล์ global.jsonไฟล์. อย่างไรก็ตามเรามี StringLibrary โครงการหนึ่งซึ่งไม่อยู่ในรูปแบบ ให้เราเพิ่มไฟล์StringLibrary โครงการภายใน src โฟลเดอร์

ในโฟลเดอร์ src เรามีสองโปรเจ็กต์และเราต้องแก้ไขปัญหาเพื่อให้เราสามารถใช้โปรเจ็กต์ทั้งหมดได้อย่างถูกต้อง ให้เรากลับไปที่ Visual Studio แล้วคลิกขวาที่โครงการ StringLibrary แล้วเลือกตัวเลือกเอาออก จะไม่ลบออก แต่จะลบเฉพาะโปรเจ็กต์เท่านั้น

ตอนนี้คลิกขวาที่โฟลเดอร์ src แล้วเลือก Add → Existing Project…

เรียกดูโครงการ StringLibrary ซึ่งตอนนี้อยู่ในไฟล์ src เลือกโฟลเดอร์ StringLibrary.csproj ไฟล์แล้วคลิก Open.

ตอนนี้เราต้องลบการอ้างอิงของ StringLibrary จาก project.json ไฟล์ของแอปคอนโซล

{ 
   "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" 
      } 
   } 
}

บันทึกการเปลี่ยนแปลงแล้วเพิ่มข้อมูลอ้างอิงของ StringLibrary อีกครั้งในโครงการคอนโซลของคุณ

{ 
   "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" 
      } 
   } 
}

ตอนนี้ทุกอย่างควรจะกลับมาทำงานอีกครั้งและคุณสามารถสร้างได้ StringLibrary แล้ว FirstApp(โครงการคอนโซล) โดยไม่มีข้อผิดพลาดใด ๆ ตอนนี้ให้เราทดสอบการทำงานของ StringLibrary โดยใช้ xunit เราจำเป็นต้องเพิ่มการอ้างอิงของ StringLibrary ในโครงการทดสอบของเรา คลิกขวาที่โครงการ References of StringLibraryTests และเลือก Add Reference …

คลิก OK ซึ่งจะเพิ่มการอ้างอิงของ StringLibraryไปยังโครงการทดสอบของเรา ให้เราแทนที่รหัสต่อไปนี้ในไฟล์Tests.cs ไฟล์.

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 ให้เราคลิกที่ไฟล์Run All และคุณจะเห็นผลลัพธ์ต่อไปนี้ใน Test Explorer

คุณยังสามารถเรียกใช้การทดสอบจากบรรทัดคำสั่ง ให้เราเปิดพรอมต์คำสั่งและเรียกใช้ไฟล์dotnet test คำสั่ง

ในบทนี้เราจะพูดถึง Managed Extensibility Framework (MEF) MEF สามารถใช้สำหรับความสามารถในการขยายปลั๊กอินของบุคคลที่สามหรือสามารถนำประโยชน์ของสถาปัตยกรรมคล้ายปลั๊กอินที่เชื่อมต่อกันแบบหลวม ๆ มาใช้กับแอปพลิเคชันทั่วไป

  • MEF เป็นไลบรารีสำหรับสร้างแอปพลิเคชันที่มีน้ำหนักเบาและขยายได้

  • ช่วยให้นักพัฒนาแอปพลิเคชันสามารถค้นพบและใช้ส่วนขยายได้โดยไม่ต้องกำหนดค่าใด ๆ

  • MEF เป็นส่วนหนึ่งของ. NET Framework 4 และสามารถใช้ได้ทุกที่ที่ใช้. NET Framework ซึ่งช่วยเพิ่มความยืดหยุ่นความสามารถในการบำรุงรักษาและความสามารถในการทดสอบของแอปพลิเคชันขนาดใหญ่

  • คุณสามารถใช้ MEF ในแอปพลิเคชันไคลเอนต์ของคุณไม่ว่าจะใช้ Windows Forms, WPF หรือเทคโนโลยีอื่น ๆ หรือในแอปพลิเคชันเซิร์ฟเวอร์ที่ใช้ ASP.NET

  • MEF ได้รับการแปลงเป็นไฟล์ Microsoft.Composition เป็น. NET Core เช่นกัน แต่บางส่วน

  • เท่านั้น System.Composition ถูกย้ายและ System.ComponentModel.Compositionยังไม่พร้อมใช้งาน ซึ่งหมายความว่าเราไม่มีแคตตาล็อกที่สามารถโหลดประเภทจากแอสเซมบลีในไดเร็กทอรี

ในบทนี้เราจะเรียนรู้วิธีใช้ MEF ในแอปพลิเคชัน. NET Core เท่านั้น

ให้เราเข้าใจตัวอย่างง่ายๆที่เราจะใช้ MEF ในแอปพลิเคชันคอนโซล. NET Core ให้เราสร้างโปรเจ็กต์คอนโซล. NET Core ใหม่

ในบานหน้าต่างด้านซ้ายเลือก Templates → Visual C# → .NET Core จากนั้นในบานหน้าต่างตรงกลางให้เลือก Console Application (.NET Core)

ป้อนชื่อของโครงการในฟิลด์ชื่อและคลิกตกลง

เมื่อสร้างโครงการแล้วเราจำเป็นต้องเพิ่มการอ้างอิงของ Microsoft.Composition เพื่อให้เราสามารถใช้ MEF ได้ ในการทำเช่นนั้นให้เราคลิกขวาที่โครงการใน Solution Explorer และManage NuGet Packages…

ค้นหา Microsoft.Composition แล้วคลิก Install.

คลิก OK ปุ่ม.

คลิก I Accept ปุ่ม.

เมื่อการติดตั้งเสร็จสมบูรณ์คุณจะพบข้อผิดพลาดในการอ้างอิง

ให้เราเปิดไฟล์ project.json ไฟล์.

{ 
   "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" 
      } 
   } 
}

คุณจะเห็นว่าไฟล์ Microsoft.Composition มีการเพิ่มการพึ่งพา แต่ปัญหาคือแพคเกจนี้เข้ากันไม่ได้กับไฟล์ dnxcore50. ดังนั้นเราจึงต้องนำเข้าportablenet45+win8+wp8+wpa81. ให้เราแทนที่ไฟล์project.json ไฟล์ด้วยรหัสต่อไปนี้

{ 
   "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" 
      } 
   } 
}

บันทึกไฟล์นี้และคุณจะเห็นว่าข้อผิดพลาดได้รับการแก้ไขแล้ว

หากคุณขยายการอ้างอิงคุณจะเห็นข้อมูลอ้างอิงของ Microsoft.Composition.

ก่อนอื่นเราต้องสร้างอินเทอร์เฟซที่จะส่งออกและใช้งานอินเทอร์เฟซและตกแต่งคลาสด้วยแอตทริบิวต์การส่งออก ให้เราเพิ่มคลาสใหม่

ป้อนชื่อชั้นเรียนของคุณในช่องชื่อแล้วคลิก Add.

ให้เราเพิ่มรหัสต่อไปนี้ในไฟล์ PrintData.cs ไฟล์.

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); 
      } 
   } 
}

ดังที่กล่าวไว้ข้างต้นแคตตาล็อกไม่มีให้บริการในเนมสเปซของ Microsoft.Composition ดังนั้นมันจะโหลดทุกประเภทจากแอสเซมบลีที่มีแอตทริบิวต์การส่งออกและแนบไปกับแอตทริบิวต์การนำเข้าดังที่แสดงในวิธีการเขียนในไฟล์ Program.cs

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>(); 
         } 
      } 
   } 
}

ตอนนี้ให้เราเรียกใช้แอปพลิเคชันของคุณและคุณจะเห็นว่ากำลังทำงานโดยการสร้างอินสแตนซ์ไฟล์ PrintData ชั้นเรียน.

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ MEF โปรดไปที่ URL ต่อไปนี้ https://msdn.microsoft.com/en-us/library/dd460648%28v=vs.110%29.aspx สำหรับรายละเอียดเพิ่มเติม

ในบทนี้เราจะทำความเข้าใจกับคุณสมบัติที่จะเกิดขึ้นใน. NET Core เราจะเริ่มต้นด้วยเครื่องมือบรรทัดคำสั่ง. NET โดยเปิด Url ต่อไปนี้ในเบราว์เซอร์https://github.com/dotnet/cli

หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับความคืบหน้าคุณสามารถดาวน์โหลด. NET Core SDK เวอร์ชันล่าสุดได้โดยเลื่อนลงและคุณจะเห็นส่วนโปรแกรมติดตั้งและไบนารี

คุณสามารถดูเครื่องมือแสดงตัวอย่างเวอร์ชันล่าสุดสำหรับระบบปฏิบัติการต่างๆให้เราเลือกโปรแกรมติดตั้งตามระบบปฏิบัติการของคุณ

เรากำลังดำเนินการกับตัวอย่าง 1 ของ. NET Core 2.0

ตอนนี้ให้เราดูเครื่องมือปัจจุบันของเราโดยเปิดพรอมต์คำสั่งและดำเนินการคำสั่งต่อไปนี้

dotnet --info

คุณจะเห็นข้อมูลเกี่ยวกับ. NET Command Line Tools เวอร์ชันที่ติดตั้งในปัจจุบันในระบบของคุณดังที่แสดงด้านล่าง

คุณจะเห็นได้ว่าขณะนี้เรามีการแสดงตัวอย่างเครื่องมือ 2 ตอนนี้ให้เรารันคำสั่งต่อไปนี้เพื่อดูเกี่ยวกับไฟล์new คำสั่ง

dotnet help new

สำหรับภาษาคำสั่งใหม่ของโปรเจ็กต์คุณสามารถเลือกเช่น C # และ F # และประเภทของโปรเจ็กต์เป็นต้น

ตอนนี้ให้เราเห็นการเปลี่ยนแปลงใน. NET Core เวอร์ชันล่าสุด เมื่อดาวน์โหลดโปรแกรมติดตั้งแล้วให้ดับเบิลคลิกเพื่อติดตั้ง คลิกที่ติดตั้ง

ภาพหน้าจอต่อไปนี้แสดงขั้นตอนการติดตั้ง

มันจะเริ่มกระบวนการติดตั้ง หนึ่งการติดตั้งเสร็จสิ้นปิดกล่องโต้ตอบนี้

เปิดพรอมต์คำสั่งและดำเนินการคำสั่งต่อไปนี้

dotnet --info

คุณจะเห็นข้อมูลของ. NET Command Line Tools เวอร์ชันที่ติดตั้งในปัจจุบันในระบบของคุณดังที่แสดงด้านล่าง

ตอนนี้คุณจะเห็นว่าเรามีเครื่องมือ Preview1 ของ. NET Core 2 ตอนนี้ให้เรารันโค้ดต่อไปนี้ในพรอมต์คำสั่งเพื่อดูคำสั่งใหม่ใน. NET Core 2 preview1

dotnet help new

คำสั่งนี้ช่วยให้คุณดาวน์โหลดแพ็กเกจรวมถึงแคชแพ็กเกจ

คำสั่งจะเปิดเว็บเพจต่อไปนี้ซึ่งมีข้อมูลเกี่ยวกับคำสั่งใหม่ใน. NET Core 2 preview1

ให้เราเลื่อนลงตอนนี้คุณจะเห็นว่าเราสามารถสร้างแอปพลิเคชัน. NET Core พร้อมเทมเพลตเพิ่มเติมได้แล้ว

ตอนนี้เราสามารถสร้าง mstest, web, mvc และ webapi โครงการเช่นกันโดยใช้บรรทัดคำสั่ง

NET Core ได้ตัดสินใจที่จะยกเลิก project.json และกลับไปที่ MSBuild และ * .csproj นี่คือสิ่งที่เกิดขึ้นแล้วในเครื่องมือ. Net Core 2.0 preview1 ที่เพิ่งเปิดตัว นี่เป็นเรื่องที่น่าผิดหวังพอสมควรเพราะ project.json นั้นได้สูดอากาศบริสุทธิ์ อย่างไรก็ตามเป็นเรื่องที่เข้าใจได้และมีข้อดีหลายประการเช่นกัน

ตอนนี้ให้เราพูดถึงข้อดีที่นำมาซึ่งการเปลี่ยนแปลง -

  • มันจะทำให้การเปลี่ยนโซลูชัน Visual Studio ที่มีอยู่เป็น. NET Core นั้นตรงไปตรงมา

  • ถือเป็นการเปลี่ยนแปลงครั้งใหญ่และยังช่วยให้สามารถใช้ประโยชน์จากการลงทุนที่มีอยู่ใน CI / RM โดยอ้างอิงจาก MSBuild

  • ในระหว่างการสร้างใน MSBuild เราสามารถนึกถึงการคอมไพล์ที่เพิ่มขึ้นการแก้ไขการอ้างอิง buildtime การจัดการการกำหนดค่า ฯลฯ

  • จำเป็นต้องมีงานจำนวนมากในการจัดส่ง dotnet cli ให้ตรงเวลาเนื่องจากไม่ได้เป็นเพียงแค่ ASP.NET Core อีกต่อไป แต่ยังรวมถึงแอปคอนโซลแอป UWP เป็นต้น

ต่อไปนี้คือการเปลี่ยนแปลงใน MSBuild และ * .csproj -

  • ไฟล์ Project.json (* .xproj) จะถูกแทนที่ด้วย MSBuild (* .csproj)

  • ฟีเจอร์ใน project.json จะเริ่มรวมกลับเข้าไปใน * .csproj

  • ยังไม่ชัดเจนว่าพวกเขาจะทำอะไรเกี่ยวกับรายการแพ็คเกจ แต่มีการกล่าวถึงว่าพวกเขาอาจเก็บไว้เป็น json ภายใต้ nuget.json หรือรวมเข้ากับไฟล์ *.csproj.

  • สมมติว่าการเปลี่ยนแปลงควรราบรื่นและอาจเป็นไปโดยอัตโนมัติหากใช้ Visual Studio

ข้อดีของ MSBuild

  • MSBuild เป็นโอเพ่นซอร์สและพร้อมใช้งานบน GitHub และมีความผูกพันที่จะกลายเป็นข้ามแพลตฟอร์มอย่างสมบูรณ์

  • MSBuild จะลดความซับซ้อนและตัดทอนโครงสร้างของไฟล์ *.csproj.

  • Microsoft ยังแนะนำระบบโครงการใหม่ซึ่งจะช่วยให้สามารถใช้งานได้หลายสถานการณ์โดยไม่ต้องใช้ Visual Studio และรายละเอียดจะได้รับใน URL นี้ https://github.com/dotnet/roslyn-project-system/.

  • เป้าหมายคือแม้จะมีการตั้งค่า MSBuild แต่การทำงานกับบิวด์และโปรเจ็กต์ก็จะราบรื่นใน Visual Studio IDE เช่นเดียวกับภายนอก

MSBuild กับ project.json

ตอนนี้ให้เราสร้างโครงการคอนโซลใหม่ด้วยเครื่องมือ. NET Core preview2 โดยดำเนินการคำสั่งต่อไปนี้

dotnet new -t console

หากต้องการดูไฟล์ทั้งหมดที่สร้างขึ้นภายในโปรเจ็กต์นี้ให้เรียกใช้ไฟล์ dir คำสั่ง

คุณจะเห็นว่าไฟล์สองไฟล์ถูกสร้างขึ้น Program.cs และ project.json ไฟล์.

ตอนนี้ให้เราสร้างแอปคอนโซลด้วยเครื่องมือ. NET Core 2 preview1 โดยดำเนินการคำสั่งต่อไปนี้

dotnet new console

หากต้องการดูไฟล์ทั้งหมดที่สร้างขึ้นภายในโปรเจ็กต์นี้ให้เรียกใช้ไฟล์ dirคำสั่ง คุณจะเห็นว่าไฟล์สามไฟล์ถูกสร้างขึ้นProgram.cs, NuGet.config และ MSBuild.csproj แทนไฟล์ project.json

ตอนนี้ให้เราเปรียบเทียบ project.json และ MSBuild.csproj ไฟล์เคียงข้างกัน

ทางด้านซ้ายเรามีไฟล์ในรูปแบบ json ในขณะที่ทางด้านขวาไฟล์อยู่ในรูปแบบ XML คุณจะเห็นว่าในไฟล์ project.json ภายในส่วนการอ้างอิงมีไฟล์netcoreapp1.0ในขณะที่อยู่ในไฟล์ MSBuild.csproj คุณจะเห็นไฟล์ netcoreapp2.0.

ในบทนี้เราจะพูดถึงวิธีการกู้คืนและสร้างไฟล์ MSBuild (* .csproj) ของคุณโดยใช้ยูทิลิตี้บรรทัดคำสั่ง หากต้องการดูว่ามีคำสั่งใดบ้างใน. NET Core 2.0 preview 1 ให้เรารันคำสั่งต่อไปนี้

dotnet help

คุณจะเห็นคำสั่งทั้งหมดเช่นใหม่คืนค่าสร้าง ฯลฯ

ต่อไปนี้เป็นการใช้งานเริ่มต้นใน Program.cs ไฟล์.

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

ตอนนี้ให้เราดำเนินการคำสั่งต่อไปนี้เพื่อดูความคืบหน้า

dotnet build

คุณจะเห็นข้อผิดพลาดมากมาย ข้อผิดพลาดเหล่านี้จำเป็นต้องได้รับการแก้ไข

ให้เรารันคำสั่งต่อไปนี้

dotnet restore

คุณจะเห็นว่าแพ็คเกจทั้งหมดถูกกู้คืน มีการสร้างโฟลเดอร์และไฟล์ใหม่ ๆ

หากต้องการดูโครงสร้างไดเร็กทอรีให้เรารันคำสั่งต่อไปนี้

tree /f

ต่อไปนี้เป็นโครงสร้างไดเร็กทอรี -

ให้เราสร้างโครงการใหม่โดยใช้คำสั่งต่อไปนี้อีกครั้ง

dotnet build

ตอนนี้คุณจะสร้างโครงการได้สำเร็จโดยไม่มีข้อผิดพลาดใด ๆ และยังสร้าง MSBuild.dll

หากต้องการดูผลลัพธ์ให้เรารันคำสั่งต่อไปนี้ -

dotnet run

คุณสามารถดูผลลัพธ์ต่อไปนี้บนคอนโซลของคุณ

ในบทนี้เราจะย้ายแอปพลิเคชันคอนโซลซึ่งมีไฟล์ project.json ระบบสร้างไฟล์แทน MSBuild (*.csproj). ดังนั้นเราจึงมีโครงการเก่าที่มีไฟล์ต่อไปนี้

ตอนนี้คำถามคือทำไมเราถึงต้องการการโยกย้าย? โครงการนี้สร้างขึ้นโดยใช้เครื่องมือ. NET Core 1.0 ดูตัวอย่าง 2 และตอนนี้เราได้ติดตั้งเครื่องมือ. NET Core 2.0 ดูตัวอย่าง 1 แล้ว ตอนนี้เมื่อคุณสร้างแอปพลิเคชันนี้โดยใช้ยูทิลิตี้บรรทัดคำสั่ง. NET Core 2.0 คุณจะเห็นข้อผิดพลาดต่อไปนี้

เนื่องจากไฟล์ project.jsonระบบการสร้างไม่สามารถใช้งานได้ใน. NET Core 2.0 อีกต่อไปดังนั้นเราจึงจำเป็นต้องมีการโยกย้ายเพื่อให้สามารถทำงานได้อย่างถูกต้อง หากต้องการดูคำสั่งที่มีให้เรารันคำสั่งต่อไปนี้

dotnet help

ในส่วนคำสั่งคุณจะเห็นคำสั่งต่างๆและคุณยังสามารถดูไฟล์ migrate คำสั่งซึ่งจะโอนย้ายโปรเจ็กต์ที่ใช้ project.json ไปยังโปรเจ็กต์ที่ใช้ MSBuild

ให้เรารันคำสั่งต่อไปนี้

dotnet migrate

คุณจะเห็นข้อมูลสรุปของกระบวนการย้ายข้อมูลและที่นี่คุณจะเห็นว่ามีการย้ายโปรเจ็กต์สำเร็จแล้ว

ตอนนี้ให้เราดูโครงสร้างไดเร็กทอรีโดยใช้คำสั่งต่อไปนี้

tree /f

ตอนนี้คุณจะเห็นไฟล์ * .csproj พร้อมกับไฟล์ Program.cs ในไดเร็กทอรี root ของโปรเจ็กต์และ project.json ถูกย้ายไปยังโฟลเดอร์สำรอง

ให้เราเปิดไฟล์ console.csprojไฟล์. ตอนนี้คุณสามารถกู้คืนและสร้างโครงการนี้โดยใช้ระบบ MSBuild โดยเรียกใช้คำสั่งต่อไปนี้

dotnet restore

ตอนนี้คุณสามารถเห็นได้ว่าแพ็คเกจทั้งหมดถูกกู้คืน

ตอนนี้คุณสามารถสร้างโครงการของคุณด้วยคำสั่งต่อไปนี้

dotnet build

ตอนนี้คุณสามารถเห็นได้ว่าโครงการสร้างสำเร็จโดยใช้ MSBuild และ console.dll ก็ถูกสร้างขึ้นในไฟล์ ..\bin\Debug\netcoreapp1.0 โฟลเดอร์

ภาพหน้าจอต่อไปนี้แสดงโครงสร้างไดเร็กทอรีและไฟล์