.NET Core-빠른 가이드

.NET Core는 Microsoft에서 유지 관리하는 최신 범용 개발 플랫폼입니다. 다양한 플랫폼에서 작동하며 .NET을 빠르고 유연하며 현대적으로 만드는 방식으로 재 설계되었습니다. 이것은 Microsoft의 주요 공헌 중 하나입니다. 개발자는 이제 .NET을 사용하여 Android, iOS, Linux, Mac 및 Windows 애플리케이션을 모두 오픈 소스로 빌드 할 수 있습니다.

이 자습서에서는 .NET Core 및 .NET Framework 업데이트, .NET Standard 및 유니버설 Windows 플랫폼 업데이트 등을 포함한 몇 가지 새로운 혁신을 다룹니다.

.NET Core의 특성

다음은 .NET Core의 주요 특징입니다-

오픈 소스

  • .NET Core는 MIT 및 Apache 2 라이선스를 사용하는 오픈 소스 구현입니다.

  • .NET Core는 .NET Foundation 프로젝트이며 GitHub에서 사용할 수 있습니다.

  • 오픈 소스 프로젝트로서보다 투명한 개발 프로세스를 장려하고 적극적이고 참여하는 커뮤니티를 장려합니다.

크로스 플랫폼

  • .NET Core에서 구현 된 애플리케이션을 실행할 수 있으며 플랫폼 대상에 관계없이 해당 코드를 재사용 할 수 있습니다.

  • 현재 세 가지 주요 운영 체제 (OS)를 지원합니다.

    • Windows

    • Linux

    • MacOS

  • 지원되는 운영 체제 (OS), CPU 및 응용 프로그램 시나리오는 Microsoft, 다른 회사 및 개인이 제공하는 시간이 지남에 따라 증가 할 것입니다.

유연한 배포

  • .NET Core 애플리케이션에는 두 가지 유형의 배포가있을 수 있습니다.

    • 프레임 워크 종속 배포

    • 자체 포함 된 배포

  • 프레임 워크 종속 배포를 사용하는 경우 앱은 앱 및 타사 종속성이 설치된 시스템 전체 버전의 .NET Core에 의존합니다.

  • 자체 포함 배포를 사용하면 애플리케이션을 빌드하는 데 사용되는 .NET Core 버전도 앱 및 타사 종속성과 함께 배포되며 다른 버전과 나란히 실행할 수 있습니다.

명령 줄 도구

  • 모든 제품 시나리오는 명령 줄에서 실행할 수 있습니다.

호환 가능

  • .NET Core는 .NET Standard Library를 통해 .NET Framework, Xamarin 및 Mono와 호환됩니다.

모듈 식

  • .NET Core는 NuGet을 통해 더 작은 어셈블리 패키지로 출시됩니다.

  • .NET Framework는 대부분의 핵심 기능을 포함하는 하나의 큰 어셈블리입니다.

  • .NET Core는 더 작은 기능 중심 패키지로 제공됩니다.

  • 이 모듈 식 접근 방식을 통해 개발자는 앱에 필요한 NuGet 패키지 만 포함하여 앱을 최적화 할 수 있습니다.

  • 더 작은 앱 노출 영역의 이점으로는 더 엄격한 보안, 서비스 감소, 성능 향상, 종량제 모델의 비용 감소 등이 있습니다.

.NET Core 플랫폼

.NET Core 플랫폼에는 다음과 같은 주요 부분이 포함되어 있습니다.

  • .NET Runtime − 유형 시스템, 어셈블리 로딩, 가비지 수집기, 네이티브 interop 및 기타 기본 서비스를 제공합니다.

  • Fundamental Libraries − 기본 데이터 유형, 앱 구성 유형 및 기본 유틸리티를 제공하는 프레임 워크 라이브러리 세트.

  • SDK & Compiler − .NET Core SDK에서 사용할 수있는 기본 개발자 경험을 가능하게하는 SDK 도구 및 언어 컴파일러 세트.

  • ‘dotnet’ app host− .NET Core 앱을 시작하는 데 사용됩니다. 런타임을 선택하고 런타임을 호스팅하고 어셈블리로드 정책을 제공하고 앱을 시작합니다. 동일한 호스트를 사용하여 거의 동일한 방식으로 SDK 도구를 시작합니다.

이 장에서는 배포 및 실행에 필요한 다양한 종속성에 대해 설명합니다. 여기에는 Visual Studio를 사용하여 개발 된 Windows 머신의 .NET Core 애플리케이션이 포함됩니다.

지원되는 Windows 버전

.NET Core는 다음 버전의 Windows에서 지원됩니다.

  • Windows 7 SP1
  • 윈도우 8.1
  • 윈도우 10
  • Windows Server 2008 R2 SP1 (전체 서버 또는 Server Core)
  • Windows Server 2012 SP1 (전체 서버 또는 Server Core)
  • Windows Server 2012 R2 SP1 (전체 서버 또는 Server Core)
  • Windows Server 2016 (전체 서버, Server Core 또는 Nano 서버)

의존성

  • Windows 10 및 Windows Server 2016 이전의 Windows 버전에서 .NET Core 애플리케이션을 실행하는 경우 Visual C ++ 재배포 가능 패키지도 필요합니다.

  • 이 종속성은 .NET Core 설치 관리자를 사용하는 경우 자동으로 설치됩니다.

  • 설치 관리자 스크립트를 통해 .NET Core를 설치하거나 자체 포함 된 .NET Core 애플리케이션을 배포하는 경우 Visual Studio 2015 용 Visual C ++ 재배포 가능 패키지를 수동으로 설치해야합니다.

  • Windows 7 및 Windows Server 2008 컴퓨터의 경우 Windows 설치가 최신 상태이고 Windows Update를 통해 설치된 핫픽스 KB2533623도 포함되어 있는지 확인해야합니다.

Visual Studio의 필수 구성 요소

  • .NET Core SDK를 사용하여 .NET Core 애플리케이션을 개발하려면 원하는 편집기를 사용할 수 있습니다.

  • 그러나 Visual Studio를 사용하여 Windows에서 .NET Core 애플리케이션을 개발하려는 경우 다음 두 버전을 사용할 수 있습니다.

    • 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 업데이트 3
  • Microsoft .NET Core 1.0.1-VS 2015 도구 미리보기 2

Microsoft는 SQL Server가 포함 된 무료 버전의 Visual Studio를 제공하며 다음 사이트에서 다운로드 할 수 있습니다. 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를 사용하여 애플리케이션을 시작할 준비가되었습니다.

비주얼 스튜디오 2017

이 자습서에서는 Visual Studio 2015를 사용하지만 Visual Studio 2017을 사용하려는 경우 Visual Studio 용 .NET Core 도구의 실험적 릴리스가 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 웹 애플리케이션 (.NET Core)

새 프로젝트 대화 상자의 중간 창에서 콘솔 애플리케이션 (.NET Core)을 선택하고 이름을 "FirstApp"으로 지정한 다음 확인을 클릭합니다.

Visual Studio에서 새로 생성 된 프로젝트가 열리고이 프로젝트에있는 모든 파일이 솔루션 탐색기 창에 표시됩니다.

.NET core 콘솔 애플리케이션이 작동하는지 테스트하기 위해 다음 줄을 추가하겠습니다.

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는 복소수를 나타내는 형식입니다.

  • System.Numerics 네임 스페이스의 SIMD (Single Instruction Multiple Data) 사용 벡터 유형 집합입니다.

일체형

.NET Core는 길이가 1 바이트에서 8 바이트까지 다른 범위의 부호있는 정수와 부호없는 정수를 모두 지원합니다. 모든 정수는 값 유형입니다.

다음 표는 정수 유형과 크기를 나타냅니다.

유형 서명 됨 / 서명되지 않음 크기 (바이트) 최소값 최대 가치
바이트 서명되지 않음 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
  • 각 부동 소수점 유형은 산술, 비교, 같음, 명시 적 변환 및 암시 적 변환 연산자의 표준 집합을 지원합니다.

  • BitConverter 클래스를 사용하여 Double 및 Single 값의 개별 비트로 작업 할 수도 있습니다.

  • Decimal 구조체에는 10 진수 값의 개별 비트로 작업하기위한 자체 메서드 인 Decimal.GetBits 및 Decimal.Decimal (Int32 ())과 몇 가지 추가 수학 연산을 수행하기위한 자체 메서드 집합이 있습니다.

BigInteger

  • System.Numerics.BigInteger는 이론상 값에 상한 또는 하한이없는 임의의 큰 정수를 나타내는 변경 불가능한 형식입니다.

  • BigInteger 유형의 메소드는 다른 정수 유형의 메소드와 거의 유사합니다.

복잡한

  • System.Numerics.Complex 유형은 복소수, 즉 실수 부분과 허수 부분이있는 숫자를 나타냅니다.

  • 산술, 비교, 같음, 명시 적 변환 및 암시 적 변환 연산자의 표준 세트와 수학, 대수 및 삼각법을 지원합니다.

SIMD

  • Numerics 네임 스페이스에는 .NET Core 용 SIMD 사용 벡터 형식 집합이 포함됩니다.

  • SIMD를 사용하면 일부 작업을 하드웨어 수준에서 병렬화 할 수 있으므로 벡터를 통해 계산을 수행하는 수학적, 과학 및 그래픽 앱의 성능이 크게 향상됩니다.

  • .NET Core의 SIMD 지원 벡터 유형에는 다음이 포함됩니다.

    • System.Numerics.Vector2, System.Numerics.Vector3 및 System.Numerics.Vector4 유형은 Single 유형의 2, 3 및 4 차원 벡터입니다.

    • 모든 기본 숫자 유형의 벡터를 생성 할 수있는 Vector <T> 구조입니다. 기본 숫자 유형에는 Decimal을 제외한 시스템 네임 스페이스의 모든 숫자 유형이 포함됩니다.

    • 2 개의 매트릭스 유형, System.Numerics.Matrix3x2는 3x2 매트릭스를 나타냅니다. 및 System.Numerics.Matrix4x4는 4x4 행렬을 나타냅니다.

    • 3 차원 평면을 나타내는 System.Numerics.Plane 형식과 3 차원 물리적 회전을 인코딩하는 데 사용되는 벡터를 나타내는 System.Numerics.Quaternion 형식입니다.

이 장에서는 .NET 관리 코드 플랫폼의 가장 중요한 기능 중 하나 인 가비지 수집의 개념을 다룰 것입니다. GC (가비지 수집기)는 메모리 할당 및 해제를 관리합니다. 가비지 수집기는 자동 메모리 관리자 역할을합니다.

  • 메모리를 할당 및 해제하거나 해당 메모리를 사용하는 개체의 수명을 관리하는 방법을 알 필요가 없습니다.

  • "new"키워드로 개체를 선언하거나 값 유형이 boxing 될 때마다 할당이 이루어집니다. 할당은 일반적으로 매우 빠릅니다.

  • 객체를 할당 할 메모리가 충분하지 않은 경우 GC는 가비지 메모리를 수집하고 폐기하여 메모리를 새 할당에 사용할 수 있도록해야합니다.

  • 이 프로세스는 garbage collection.

가비지 컬렉션의 장점

가비지 컬렉션은 다음과 같은 이점을 제공합니다.

  • 응용 프로그램을 개발하는 동안 메모리를 수동으로 해제 할 필요가 없습니다.

  • 또한 관리되는 힙에 개체를 효율적으로 할당합니다.

  • 개체가 더 이상 사용되지 않으면 메모리를 지워 해당 개체를 회수하고 향후 할당에 사용할 수있는 메모리를 유지합니다.

  • 관리되는 개체는 자동으로 깨끗한 콘텐츠를 가져 오므로 생성자가 모든 데이터 필드를 초기화 할 필요가 없습니다.

  • 또한 개체가 다른 개체의 내용을 사용할 수 없도록하여 메모리 안전을 제공합니다.

가비지 수집 조건

가비지 수집은 다음 조건 중 하나가 참일 때 발생합니다.

  • 시스템의 실제 메모리가 부족합니다.

  • 관리되는 힙의 할당 된 개체가 사용하는 메모리가 허용 가능한 임계 값을 초과합니다. 이 임계 값은 프로세스가 실행됨에 따라 지속적으로 조정됩니다.

  • 그만큼 GC.Collect메서드가 호출되고 거의 모든 경우 가비지 수집기가 계속 실행되기 때문에이 메서드를 호출 할 필요가 없습니다. 이 방법은 주로 고유 한 상황 및 테스트에 사용됩니다.

세대

.NET 가비지 콜렉터에는 3 세대가 있으며 각 세대에는 할당 된 오브젝트의 스토리지에 사용되는 자체 힙이 있습니다. 대부분의 개체는 수명이 짧거나 수명이 긴 기본 원칙이 있습니다.

1 세대 (0)

  • 0 세대에서는 개체가 먼저 할당됩니다.

  • 이 세대에서 개체는 다음 가비지 수집이 발생할 때까지 더 이상 사용되지 않기 때문에 (범위를 벗어남) 1 세대 이후에는 살지 않는 경우가 많습니다.

  • 0 세대는 연관된 힙이 작기 때문에 빠르게 수집합니다.

2 세대 (1)

  • 1 세대에서는 개체에 두 번째 기회 공간이 있습니다.

  • 수명이 짧지 만 0 세대 컬렉션에서 살아남은 개체 (종종 우연한 타이밍에 기반 함)는 1 세대로 이동합니다.

  • 1 세대 컬렉션도 관련 힙도 작기 때문에 빠릅니다.

  • 개체가 수집되거나 차세대 힙으로 승격되기 때문에 처음 두 힙은 작게 유지됩니다.

3 세대 (2)

  • 2 세대에서는 모든 긴 개체가 유지되고 힙이 매우 커질 수 있습니다.

  • 이 세대의 개체는 오래 지속될 수 있으며 개체를 추가로 승격 할 차세대 힙이 없습니다.

  • Garbage Collector에는 LOH (Large Object Heap)라고하는 대형 개체에 대한 추가 힙이 있습니다.

  • 85,000 바이트 이상의 개체를 위해 예약되어 있습니다.

  • 대형 오브젝트는 세대 별 힙에 할당되지 않지만 LOH에 직접 할당됩니다.

  • 2 세대 및 LOH 콜렉션은 장시간 실행되거나 많은 양의 데이터에 대해 작동하는 프로그램의 경우 눈에 띄는 시간이 걸릴 수 있습니다.

  • 대형 서버 프로그램은 수십 GB의 힙을 가지고있는 것으로 알려져 있습니다.

  • GC는 프로그램 실행을 차단하는 시간을 줄이기 위해 다양한 기술을 사용합니다.

  • 기본 접근 방식은 프로그램 실행을 방해하지 않는 방식으로 백그라운드 스레드에서 가능한 한 많은 가비지 수집 작업을 수행하는 것입니다.

  • GC는 또한 개발자가 동작에 영향을 미칠 수있는 몇 가지 방법을 제공하므로 성능을 향상시키는 데 매우 유용 할 수 있습니다.

이 장에서는 .NET Core의 실행 프로세스를 이해하고 .NET Framework와 비교합니다. 관리되는 실행 프로세스에는 다음 단계가 포함됩니다.

  • 컴파일러 선택
  • MSIL로 코드 컴파일
  • MSIL을 네이티브 코드로 컴파일
  • 코드 실행

컴파일러 선택

  • 다국어 실행 환경이며 런타임은 다양한 데이터 유형 및 언어 기능을 지원합니다.

  • 공용 언어 런타임에서 제공하는 이점을 얻으려면 런타임을 대상으로하는 하나 이상의 언어 컴파일러를 사용해야합니다.

MSIL로 코드 컴파일

  • 컴파일은 소스 코드를 MSIL (Microsoft Intermediate Language)로 변환하고 필요한 메타 데이터를 생성합니다.

  • 메타 데이터는 각 유형의 정의, 각 유형 멤버의 서명, 코드가 참조하는 멤버 및 런타임에서 실행 시간에 사용하는 기타 데이터를 포함하여 코드의 유형을 설명합니다.

  • 런타임은 실행 중에 필요에 따라 파일 및 프레임 워크 클래스 라이브러리 (FCL)에서 메타 데이터를 찾아 추출합니다.

MSIL을 네이티브 코드로 컴파일

  • 실행 시간에 JIT (Just-In-Time) 컴파일러는 MSIL을 네이티브 코드로 변환합니다.

  • 이 컴파일 중에 코드는 MSIL 및 메타 데이터를 검사하는 확인 프로세스를 통과하여 코드가 형식에 안전한지 여부를 확인해야합니다.

코드 실행

  • 공용 언어 런타임은 실행을 수행 할 수있는 인프라와 실행 중에 사용할 수있는 서비스를 제공합니다.

  • 실행 중에 관리 코드는 가비지 수집, 보안, 비 관리 코드와의 상호 운용성, 언어 간 디버깅 지원, 향상된 배포 및 버전 관리 지원과 같은 서비스를받습니다.

.NET Core 코드 실행 프로세스

이제 .NET Framework와 비교하여 .NET Core에서 코드가 실행되는 방식을 살펴 보겠습니다. .NET Core에는 .NET Framework의 일부인 이러한 구성 요소가 많이 대체됩니다.

  • 이제 .NET Core에는 C # 및 VB 용 Roslyn과 같은 새로운 일련의 컴파일러가 있습니다.

  • .NET Core에서 F #을 사용하려는 경우 새로운 F # 4.1 컴파일러를 사용할 수도 있습니다.

  • 실제로 이러한 도구는 다르며 C # 컴파일러는 최대 C # 5 만 지원할 수 있으므로 C # 6 이상을 사용하는 경우 .NET Framework에서도 Roslyn을 사용할 수 있습니다.

  • .NET Core에는 FCL (프레임 워크 클래스 라이브러리)이 없으므로 다른 라이브러리 집합이 사용되며 이제 CoreFx가 있습니다.

  • CoreFx는 .NET Core 용 클래스 라이브러리를 다시 구현 한 것입니다.

  • 또한 CoreCLR로 알려진 .NET Core의 새로운 런타임이 있으며 JIT 컴파일러를 활용합니다.

  • 이제 질문은 우리가 이미 .NET 프레임 워크에있는 이러한 모든 구성 요소를 다시 구현하는 이유입니다.

  • 따라서 대답은 Microsoft가 .NET Core를 구현 한 이유와 동일합니다.

모듈 식 애플리케이션을 빌드하고 구현하기위한 .NET Core의 또 다른 고려 사항입니다. 전체 .NET Framework를 설치하는 대신 이제 응용 프로그램에서 필요한 것만 설치할 수 있습니다. 비주얼 스튜디오로 가서 모듈성을 살펴 보겠습니다.

다음은 솔루션 탐색기의 간단한 .NET Core 애플리케이션입니다. 참조를 확장하면 .NETCoreApp에 대한 참조가 표시됩니다.

.NETCoreApp 내부에 NuGet에 대한 패키지 참조가 표시됩니다. 확장하겠습니다.

전체 NuGet 패키지 참조 시리즈가 표시됩니다. .NET Framework에서 작업 한 적이 있다면 .NET Framework에서 사용하는 데 익숙하기 때문에 이러한 네임 스페이스 중 상당수가 익숙해 보일 것입니다.

.NET Framework는 여러 부분으로 분할되고 CoreFx로 다시 구현됩니다. 이 조각들은 개별 패키지로 추가 배포됩니다.

  • 이제 NETStandard.Library를 확장하면 추가 참조가 표시됩니다. 이 응용 프로그램에서 사용하는 System.Console도 알 수 있습니다.

  • 이제 .NET Framework 내부에 모든 것을 가져올 필요는 없지만 응용 프로그램에 필요한 것만 가져옵니다.

  • 다른 이점도 있습니다. 예를 들어, 이러한 모듈은 원하는 경우 개별적으로 업데이트 할 수 있습니다.

모듈화는 성능 이점으로 이어지며 애플리케이션, 특히 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)을 사용한 접근 방식입니다. 프로젝트의 루트에 파일을 드롭하면 자동으로 프로젝트에 포함됩니다.

  • Visual Studio의 기존 .NET Framework 응용 프로그램에 대해 과거와 같이 파일을 수동으로 참조 할 필요가 없습니다.

이제 프로젝트의 루트를 열겠습니다.

이제 세 파일을 모두 프로젝트의 루트에 복사하겠습니다.

이제 루트 폴더에 복사 된 모든 파일을 볼 수 있습니다.

이제 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 관리자로 이동하여 추가 할 패키지를 찾아 보는 것입니다.

이 장에서는 .NET Core를 사용하여 UWP 애플리케이션을 만드는 방법에 대해 설명합니다. UWP는 Windows 10 UWP 애플리케이션이라고도합니다. 이 응용 프로그램은 이전 버전의 Windows에서 실행되지 않지만 향후 버전의 Windows에서만 실행됩니다.

다음은 UWP가 원활하게 실행되는 몇 가지 예외입니다.

  • 로컬에서 실행하려면 Windows 10이 있어야하며 Windows 8에서도 개발 한 다음 에뮬레이터에서 실행해야하지만 Windows 10을 사용하는 것이 좋습니다.

  • UWP 애플리케이션의 경우 Windows 10 SDK도 필요합니다. Visual Studio 2015 설치 프로그램을 열고 Visual Studio를 수정하겠습니다.

  • 일부 기능 페이지에서 아래로 스크롤하면 유니버설 Windows 앱 개발 도구가 표시됩니다. 아래 표시된 옵션을 선택합니다.

여기에서 다양한 버전의 SDK 및 도구의 최신 업데이트를 볼 수 있습니다. 다음을 클릭합니다.

이제 Install 단추.

설치가 완료되면 시스템을 다시 시작해야합니다.

이제 다음 단계에 따라 UWP를 구현해 보겠습니다.

  • 먼저 Visual Studio 2015를 시작합니다.

  • 파일 메뉴를 클릭하고 새로 만들기 → 프로젝트를 선택합니다. 새 프로젝트 대화 상자가 나타납니다. 대화 상자의 왼쪽 창에서 다양한 유형의 템플릿을 볼 수 있습니다.

  • 왼쪽 창에서 트리보기를 볼 수 있습니다. 이제 템플릿 → Visual C # → Windows에서 유니버설 템플릿을 선택합니다.

  • 가운데 창에서 빈 앱 (유니버설 Windows) 템플릿을 선택합니다.

  • 입력하여 프로젝트에 이름을 지정하십시오. UWPFirstApp 이름 필드에서 확인을 클릭합니다.

  • 대상 버전 / 최소 버전 대화 상자가 나타납니다. 이 자습서에는 기본 설정이 적합하므로 확인을 선택하여 프로젝트를 만듭니다.

  • 여기에는 모든 Windows 10 장치를 대상으로 할 수있는 단일 프로젝트가 있으며 .NET Core와 UWP가 모두 다중 대상 지정의 단순화라는 것을 알 수 있습니다.

  • 새 프로젝트가 열리면 해당 파일이 솔루션 탐색기 창의 오른쪽에 표시됩니다. 파일을 보려면 속성 탭 대신 솔루션 탐색기 탭을 선택해야 할 수 있습니다.

  • 빈 앱 (범용 창)은 최소한의 템플릿이지만 여전히 많은 파일이 포함되어 있습니다. 이러한 파일은 C #을 사용하는 모든 UWP 앱에 필수적입니다. 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 콘솔 앱을 열면 project.json 및 * .xproj 파일이 표시됩니다.

  • .NET Core 빌드 시스템 또는 project.json 빌드 시스템은 UWP 요구 사항에 충분하지 않습니다. 이것이 UWP가 여전히 * .csproj (MSBuild) 빌드 시스템을 사용하는 이유입니다.

  • 그러나 project.json은 빌드 시스템에 관한 한 밖으로 이동할 것입니다.

  • 이제 콘솔 앱에 추가 한대로 UWP 애플리케이션에 기존 파일 몇 개를 추가하려면 해당 파일을 프로젝트 폴더에 추가해야합니다. 또한 솔루션 탐색기의 프로젝트에도 포함해야합니다.

이제 다음 파일을 고려해 보겠습니다. 이 파일을 프로젝트 폴더에 복사하십시오.

Visual Studio로 돌아가 솔루션 탐색기를 엽니 다.

  • 이제 UWP 응용 프로그램의 경우 파일 복사만으로는 충분하지 않다는 것을 알 수 있습니다. 솔루션 탐색기에서는 해당 파일을 볼 수 없기 때문입니다.

  • 이제 클릭하여 해당 파일도 포함해야합니다. Show All Files 위의 스크린 샷에서 강조 표시된 아이콘을 클릭하면 이제 프로젝트 폴더의 모든 파일을 볼 수 있습니다.

이 두 파일은 여전히 ​​프로젝트에 포함되어 있지 않습니다. 이러한 파일을 포함하려면 해당 파일을 선택하고 파일을 마우스 오른쪽 버튼으로 클릭 한 다음Include in Project.

이제 이러한 파일도 포함됩니다. 예상 할 수있는 한 가지 좋은 점은 향후 버전의 SKD 도구 및 Visual Studio에서 * .csproj에 대한 파일을 삭제하는 project.json 접근 방식입니다.

이 장에서는 콘솔 앱과 UWP 앱 간의 참조에 대해 설명합니다. 콘솔 응용 프로그램의 솔루션 탐색기에서 참조를 보면 아래와 같이 .NETCoreApp이 표시됩니다.

.NETCoreApp은 .NET Core 애플리케이션을 대상으로하는 새로운 프레임 워크입니다. 이제 UWP 응용 프로그램의 참조 아래를 보면 아래와 같이 약간 다르게 보입니다.

  • 그 주된 이유는 여기 UWP에 * .csproj가 있으므로 이전 스타일의 참조로 돌아가서이 프로젝트 유형으로 하나의 프레임 워크 만 대상으로 할 수 있기 때문입니다.

  • 참고 문헌은 비슷합니다. 이제 UWP 애플리케이션에서 Miscrosoft.NETCore.UniversalWindowsPlatform NuGet 패키지 참조가 콘솔 애플리케이션의 Microsoft.NETCore.App NuGet 참조와 유사하다는 것을 알 수 있습니다.

  • Miscrosoft.NETCore.UniversalWindowsPlatform 및 Microsoft.NETCore.App은 모두 메타 패키지이므로 다른 패키지로 구성됩니다.

  • 콘솔 응용 프로그램에서 Microsoft.NETCore.App 내의 다른 패키지를 드릴 인하고 볼 수 있지만 솔루션 탐색기에서 동일한 Miscrosoft.NETCore.UniversalWindowsPlatform을 수행 할 수는 없습니다.

  • 그러나 다른 도구 인 NuGet 패키지 탐색기를 사용하여이를 확인할 수 있습니다. 이제 브라우저에서이 URL을 열어 보겠습니다.https://npe.codeplex.com/downloads/get/clickOnce/NuGetPackageExplorer.application 작은 유틸리티가 다운로드되는 것을 볼 수 있습니다.

  • 다운로드가 완료되면 해당 파일을 두 번 클릭합니다.

  • 딸깍 하는 소리 Install NuGet 패키지 탐색기에서 설치를 시작합니다.

  • 설치가 완료되면 다음과 같은 대화 상자가 나타납니다.

  • 이제 Open a package from online feed 선택권.

  • 기본적으로 nuget.org 피드를 검색합니다. 이제 검색 상자에서 Microsoft.NETCore.UniversalWindowsPlatform을 검색하면 아래와 같이 1 개의 결과가 표시됩니다.

  • 클릭 open 링크를 클릭하면이 메타 패키지의 최상위 종속성이 열립니다.

  • 이제 .NETCore 애플리케이션 용 .NETCore 메타 패키지와 UWP 애플리케이션 용 메타 패키지를 나란히 열어 보겠습니다.

  • 이제 각 메타 패키지가 서로 다른 패키지 세트로 구성되어 있음을 알 수 있습니다.

  • .NET Core는 적어도 현재 시점에서 .NET Framework에서 사용할 수있는 클래스의 하위 집합이지만 .NET Framework의 기본 클래스에 따라 증가하고있을 것입니다.

  • UWP는 .NET Core를 기반으로하며 Windows 스토어 개발에 사용할 수있는 API의 상위 집합입니다.

이제 .NET Core로 인해 개발에 더 많은 API를 사용할 수 있습니다.

Windows 런타임 구성 요소는 C #, Visual Basic, JavaScript 및 C ++를 비롯한 모든 언어에서 인스턴스화하고 사용할 수있는 자체 포함 된 개체입니다. 이전 장에서 본 .NET Core 메타 패키지 외에도 UWP 앱에는 기본적으로 유니버설 Windows SDK에 대한 참조도 있습니다.

유니버설 Windows는 Windows 런타임에 대한 참조이며 일련의 API 계약에 포함되었습니다.

디바이스 제품군 내의 API 세트는 API 계약이라고하는 세분화로 분류됩니다. 여기에서 다양한 API 계약 목록을 찾을 수 있습니다.https://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

Windows 런타임 내부의 대부분의 API는 단일 계약에 포함됩니다. 이제 API 계약 페이지에서 Universal 키워드를 검색해 보겠습니다.

다양한 API에 대한 링크를 볼 수 있으며 Universal 제품군이 너무 커서 12 페이지의 문서가 있음을 알 수 있습니다.

이 페이지에서 전화 API 계약을 검색 할 수도 있습니다.

이제 Windows.Phone.PhoneContract아래로 스크롤하십시오. 이제 휴대폰 또는 모바일 장치의 배터리 정보를 볼 수 있습니다.

이미 가지고있는 정보 위에이 정보를 추가하려면 참조를 수동으로 추가해야합니다. 이제 Visual Studio로 이동하여 솔루션 탐색기에서 참조를 마우스 오른쪽 단추로 클릭합니다.

고르다 Add References…

이제 Universal Windows에 대한 새 참조 범주를 볼 수 있습니다. 이 범주에는 핵심 Universal Windows API 계약을 나타내는 Core가 있습니다.

  • 확장을 통해 기능을 확장 할 수 있으며 모바일, 데스크톱 및 기타 확장에 대한 다양한 참조를 볼 수 있습니다.

  • 다양한 SKD 확장이 있으며 더 많은 API를 얻기 위해 추가 할 수 있습니다.

  • 다른 버전도 볼 수 있습니다. 따라서 업데이트 된 API를 가져 오기 위해 최신 버전을 가져 왔는지 확인한 다음 확인을 클릭합니다.

이제 볼 수 있습니다 Windows Mobile Extensions for the UWP 참조로 추가됩니다.

클래스 라이브러리는 모든 응용 프로그램에서 호출 할 수있는 유형과 메서드를 정의합니다.

  • .NET Core를 사용하여 개발 된 클래스 라이브러리는 .NET Standard Library를 지원하므로 해당 버전의 .NET Standard Library를 지원하는 모든 .NET 플랫폼에서 라이브러리를 호출 할 수 있습니다.

  • 클래스 라이브러리를 완료하면 타사 구성 요소로 배포할지 또는 하나 이상의 응용 프로그램과 함께 번들로 제공되는 구성 요소로 포함할지 여부를 결정할 수 있습니다.

콘솔 애플리케이션에 클래스 라이브러리 프로젝트를 추가하여 시작하겠습니다. 마우스 오른쪽 버튼으로src 솔루션 탐색기에서 폴더를 선택하고 Add → New Project…

에서 Add New Project 대화 상자에서 .NET Core 노드를 선택한 다음 클래스 라이브러리 (.NET Core) 프로젝트 템플릿을 선택합니다.

이름 텍스트 상자에 다음 그림과 같이 프로젝트 이름으로 "UtilityLibrary"를 입력합니다.

확인을 클릭하여 클래스 라이브러리 프로젝트를 만듭니다. 프로젝트가 생성되면 새 클래스를 추가하겠습니다. 오른쪽 클릭project 솔루션 탐색기에서 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 메서드는 문자가 대문자이면 true를 반환하고, Char.IsLower 메서드는 문자가 소문자이면 true를 반환하고, 마찬가지로 Char.IsNumber 메서드는 문자가 숫자이면 true를 반환합니다.

  • 메뉴 모음에서 빌드, 솔루션 빌드를 선택합니다. 프로젝트는 오류없이 컴파일되어야합니다.

  • .NET Core 콘솔 프로젝트는 클래스 라이브러리에 액세스 할 수 없습니다.

  • 이제이 클래스 라이브러리를 사용하려면 콘솔 프로젝트에이 클래스 라이브러리의 참조를 추가해야합니다.

이렇게하려면 FirstApp을 확장하고 References를 마우스 오른쪽 단추로 클릭하고 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 프로젝트 유형을 * .csproj 대신 * .xproj로 설정했기 때문입니다.

Microsoft에서 언급했듯이 * .xproj는 사라질 것이지만 여전히 미리보기 2 도구에 있습니다. UWP 응용 프로그램에서 * .csproj를 사용한다는 것을 살펴 보았습니다.

이제 실제로 * .csproj를 참조하고 * .xproj로 가져 오는 것은 불가능하며 * .xproj가 제거 될 것이기 때문에 해당 기능이 구현되지 않을 것입니다.

따라서 대신 콘솔 앱과 UWP 앱간에 공유 할 수있는 클래스 라이브러리가 필요하며 여기에는 PCL이 있습니다.

PCL이란?

이제 PCL이 무엇인지 이해하겠습니다.

  • 이식 가능한 클래스 라이브러리 프로젝트를 사용하면 둘 이상의 .NET Framework 플랫폼에서 작동하는 관리되는 어셈블리를 작성하고 빌드 할 수 있습니다.

  • 공유 비즈니스 로직과 같이 여러 프로젝트에서 공유하려는 코드가 포함 된 클래스를 만든 다음 다른 유형의 프로젝트에서 해당 클래스를 참조 할 수 있습니다.

  • 또한 Microsoft 플랫폼 용 크로스 플랫폼 앱 및 라이브러리를 빠르고 쉽게 구축 할 수 있습니다.

  • 이식 가능한 클래스 라이브러리는 코드 개발 및 테스트에 드는 시간과 비용을 줄이는 데 도움이됩니다.

  • 이 프로젝트 유형을 사용하여 이식 가능한 .NET Framework 어셈블리를 작성하고 빌드 한 다음 Windows 및 Windows Phone 등과 같은 여러 플랫폼을 대상으로하는 앱에서 해당 어셈블리를 참조합니다.

이제 솔루션 탐색기에서 만든 클래스 라이브러리를 제거하겠습니다. 동시에 솔루션 폴더에서 삭제하고 새 프로젝트 항목을 추가로 추가하십시오.

선택 Visual C# → Windows 왼쪽 창에서 템플릿을 선택하고 가운데 창에서 Class Library (Portable)를 선택합니다.

이름 필드에 StringLibrary를 입력하고 OK 이 프로젝트를 만듭니다.

이제 참조 할 대상 프레임 워크를 선택해야합니다. 잠시 동안 Windows Universal 및 ASP.NET Core를 선택한 다음 대상을 다시 지정하겠습니다. 딸깍 하는 소리OK.

PCF 형식으로 새 프로젝트를 생성했음을 알 수 있습니다. 이제 솔루션 탐색기에서 StringLibrary 프로젝트를 마우스 오른쪽 단추로 클릭하고 속성을 선택하겠습니다.

Target .NET Platform Standard를 클릭합니다.

예를 클릭하십시오. 이제 하나의 사소한 차이가있는 동일한 클래스 라이브러리입니다. 차이점은 * .xproj 대신 * .csproj 파일이 포함되어 있기 때문에 UWP에서도 사용할 수 있다는 것입니다.

이제 새 클래스를 추가하겠습니다. 이를 위해 솔루션 탐색기에서 프로젝트를 마우스 오른쪽 버튼으로 클릭하고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을 확장하고 References를 마우스 오른쪽 버튼으로 클릭하고Add Reference…

참조 관리자 대화 상자에서 이식 가능한 클래스 라이브러리 프로젝트 인 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 패키지 관리자입니다. 이제 마우스 오른쪽 버튼으로StringLibrary (Portable) 프로젝트 및 선택 Mange NuGet Packages…

찾아보기 탭에서 NuGet 패키지를 검색 할 수 있습니다. "System.Runtime.Serialization.Primitives"패키지를 추가하고 싶다고 가정하겠습니다.

클릭 Install 버튼을 누르면 다음 화면이 표시됩니다.

이제 OK 단추.

마지막으로 I Accept버튼을 클릭하여이 NuGet 패키지 설치를 시작합니다. 설치가 완료되면 "System.Runtime.Serialization.Primitives"NuGet 패키지가 라이브러리에 추가 된 것을 볼 수 있습니다.

이 장에서는 라이브러리를 다음과 같이 공유하는 방법에 대해 설명합니다. NuGet Package다른 프로젝트 내에서 사용할 수 있습니다. 패키지 만들기는 공용 nuget.org 갤러리 또는 조직 내의 개인 갤러리를 통해 패키지화하고 다른 사용자와 공유하려는 코드로 시작됩니다. 패키지에는 다음과 같은 추가 파일도 포함될 수 있습니다.readme 패키지를 설치할 때 표시되며 특정 프로젝트 파일에 대한 변환을 포함 할 수 있습니다.

이제 라이브러리에서 NuGet 패키지를 만드는 간단한 예제를 고려해 보겠습니다. 이렇게하려면 명령 프롬프트를 열고 라이브러리 프로젝트의 project.json 파일이있는 폴더로 이동합니다.

이제 다음 명령을 실행하겠습니다.

dotnet help

마지막에는 new, restore 및 build 등과 같은 다양한 명령을 볼 수 있습니다.

마지막 명령은 pack;NuGet 패키지가 생성됩니다. 이제 다음 명령을 실행하겠습니다.

dotnet pack

이제 NuGet 패키지가 bin 폴더에서 생성되는 것을 볼 수 있습니다. bin \ Debug 폴더를 열어 보겠습니다.

이제 NuGet 패키지 탐색기를 사용할 수 있는지 확인하기 위해 NuGet 패키지 내부에 무엇이 있는지가 문제입니다. 이제 NuGet 패키지 탐색기를 열어 보겠습니다.

첫 번째 옵션 선택 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 패키지 탐색기에서 열어 보겠습니다.

업데이트 된 메타 데이터가 표시됩니다. 이제 문제는 다른 패키지에서 어떻게 사용할 수 있는지입니다.

NuGet 피드의 어딘가에 게시하여 시작한 다음 다른 프로젝트에서 사용할 수 있습니다.

업데이트 된 메타 데이터를 게시하는 두 가지 옵션이 있습니다.

  • nuget.org에 게시
  • 메타 데이터를 비공개 NuGet 피드로 푸시

여기에서는 nuget.org에서 계정을 설정하는 것보다 훨씬 쉽기 때문에 비공개 NuGet 피드를 사용합니다. 패키지를 nuget.org에 게시하는 방법을 알아 보려면 여기에 지정된 모든 지침을 따를 수 있습니다.https://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package.

업데이트 된 메타 데이터를 비공개 NuGet 피드에 푸시하려면 다음 단계를 따르세요.

Step 1− 시작하려면 nuget 명령 줄 유틸리티가 필요하며이를 설치해야합니다. 이제 NuGet 패키지 관리자를 열고 nuget.commandline을 검색하겠습니다.

Step 2 − Nuget.Commandline을 선택하고 Install.

Step 3 − 클릭 OKNuget.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는 개발자가 Android, iOS, Windows 및 Windows Phone에서 공유 할 수있는 사용자 인터페이스를 쉽게 만들 수 있도록하는 플랫폼 간 기본 지원 UI 도구 키트 추상화입니다.

  • 사용자 인터페이스는 대상 플랫폼의 네이티브 컨트롤을 사용하여 렌더링되므로 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). 이름 필드에 이름을 입력하고 확인을 클릭하십시오.

대상 버전 및 최소 버전을 선택하고 확인을 클릭하십시오.

일련의 프로젝트가 표시됩니다. 맨 위에는 Android, iOS, UWP, Windows 8.1 및 Windows Phone 8.1과 같은 모든 플랫폼간에 공유되는 PCL 라이브러리가 있습니다.

여기서는 PCL 라이브러리에 초점을 맞추고 여기에 몇 가지 코드를 가져올 것입니다. 코드를 확장 해 보겠습니다.

이 Xamarin.Forms 템플릿에서는 이러한 플랫폼에서 작동하는 Xamarin.Forms XAML 프레임 워크를 사용하는 일반 App.xaml 및 MainPage.xaml을 볼 수 있습니다.

코드를 가져와야하며 마지막 장에서 설정 한 비공개 NuGet 피드도 필요합니다.

이제 NuGet 패키지 관리자를 열겠습니다. 패키지 소스 드롭 다운 목록 옆에있는 휠을 클릭합니다.

여기에 비공개 피드를 추가해야합니다. plus (+) button.

다른 확인란이 추가 된 것을 볼 수 있습니다. Available package sources 섹션에서 이름과 소스 경로를 지정하고 OK.

이제 찾아보기 탭으로 이동하여 패키지 소스 드롭 다운 목록에서 PrivateSource를 선택하면 StringLibrary NuGet 패키지가 표시됩니다. StringLibrary를 선택하고Install.

확인을 클릭하면 하나의 오류가 표시됩니다.

.NETPortable 프로필 버전 259에서는 라이브러리를 사용할 수 없습니다. 다음 장에서이 오류를 수정할 것입니다.

이 장에서는 Xamarin.Forms 프로젝트의 개인 피드에서 NuGet 패키지를 설치하는 동안 발생한 오류를 수정합니다.

우리는 문제를 간단히 이해할 것입니다. 시작하려면 PCL 라이브러리를 마우스 오른쪽 버튼으로 클릭하고 속성을 선택합니다.

이 페이지에서는 대상으로하는 전체 프레임 워크 시리즈를 볼 수 있습니다. 오류에서 .NETPortable 프로필 259가 StringLibrary 1.0.1과 호환되지 않음을 알 수 있습니다. 그러나 .NET Standard 1.1 라이브러리에서 참조를 가져 오려고합니다.

이제 .NET 표준 라이브러리를보고 라이브러리와 호환되지 않는 플랫폼을 확인하겠습니다.

Windows Phone Silverlight 8이 .NET Standard 1.0과 호환된다는 것을 알 수 있습니다. 다음 웹 페이지를 열면 Profile259가 .NET Standard 1.0 만 지원할 수 있음을 알 수 있습니다.

이제 Windows Phone Silverlight 8의 선택을 취소하겠습니다.

클릭 OK 단추.

이제이 문제를 해결하려면 확인을 클릭하고 대상 변경 대화 상자를 취소 한 다음 패키지 관리자 콘솔을 열고 다음 명령을 실행하십시오.

PM > Uninstall-Package Xamarin.Forms

이제 PCL 라이브러리의 속성으로 이동하겠습니다. 변경 버튼을 클릭합니다.

Windows Phone Silverlight 8의 선택을 취소하고 확인을 클릭합니다.

이제 Windows Phone Silverlight 8이 Targeted 프레임 워크에서 더 이상 사용할 수 없음을 알 수 있습니다. 이제 대상인 프로필도 볼 수 있습니다. 이를 확인하기 위해 PCL 라이브러리를 언로드하고 XamarinApp.csproj 파일을 편집하겠습니다.

이제 TargetFrameworkProfile이 Profile111임을 알 수 있습니다.

문서를 열면 Profile111이 .NET Standard 1.1을 지원하고 있음을 알 수 있습니다.

이제 PCL을 다시로드하고 NuGet 패키지 관리자를 열고 비공개 피드에서 StringLibrary 패키지를 설치해 보겠습니다.

종속성 동작 드롭 다운 목록에서 종속성 무시를 선택한 다음 Install.

이제 StringLibrary 패키지가 개인 피드에서 설치되었음을 알 수 있습니다. PCL의 참조를 확장하면 아래와 같이 StringLibrary 참조도 추가 된 것을 볼 수 있습니다.

Windows Phone Silverlight 8 문제에 대한 Xamarin.Forms를 제거했습니다. Xamarin.Forms를 다시 설치해야합니다. 동일한 버전을 설치하는 것이 좋습니다.

설치가 완료되면 애플리케이션에서 StringLibrary 기능을 사용하겠습니다.

이 장에서는 .NET Core를 사용하여 테스트 프로젝트를 만드는 방법에 대해 설명합니다. 단위 테스트는 단위라고하는 응용 프로그램에서 테스트 할 수있는 가장 작은 부분이있는 소프트웨어의 개발 프로세스입니다. 적절한 작동을 위해 개별적으로 그리고 독립적으로 면밀히 조사됩니다. 단위 테스트는 자동화되거나 수동으로 수행 될 수도 있습니다.

이제 New Project 대화 상자를 열고 Visual C# → .NET Core 주형.

이 대화 상자에서 단위 테스트를위한 프로젝트 템플릿이 없음을 알 수 있습니다. 단위 테스트 프로젝트를 만들려면 명령 줄 유틸리티를 사용해야합니다. 우리가 만든 솔루션 폴더로 이동합니다. 테스트 폴더를 만들고 테스트 폴더 안에 다른 폴더를 만들고 이름을StringLibraryTests.

이제 dotnet 명령 줄 유틸리티를 사용하여 다음 명령을 실행하여 새 테스트 프로젝트를 만듭니다.

dotnet new -t xunittest

이제 새 C # 프로젝트가 생성 된 것을 볼 수 있습니다. 다음을 실행하여 폴더를 살펴 보겠습니다.v 명령하면 볼 수 있습니다 project.jsonTests.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에서 테스트 프로젝트를 실행하고 실행합니다.

Visual Studio에서 FirstApp 솔루션을 열어 보겠습니다.

두 개의 프로젝트 만있는 것을 알 수 있으며 해당 프로젝트를 솔루션에 추가하지 않았기 때문에 테스트 프로젝트를 볼 수 없습니다.

먼저 폴더를 추가하고 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파일에서 테스트 프레임 워크에 대한 가장 중요한 종속성은 Fact 속성을 가져 오는 xunit입니다. xunit으로 테스트하기위한 테스트 프레임 워크와 API를 가져옵니다.

우리는 또한 dotnet-test-xunit, 이것은 xunit이 .NET Core, 특히 dotnet test명령 줄 유틸리티. 그러면 당신은testRunner xunit을 실행할 것이고 당신은 또한 볼 수 있습니다 netcoreapp1.0 뼈대.

아래에 .NETCore.App 종속성이 표시됩니다.

Visual Studio에서 테스트를 실행하려면 다음에서 테스트 탐색기를 열어 보겠습니다. 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" 
   } 
}

이 파일의 맨 위에 프로젝트 설정이 표시되며 다음과 같은 일부 폴더를 설정합니다. srctest 기본적으로.

관례에 따라 이러한 폴더에 프로젝트가 있어야합니다. 이것은 새로운 규칙이며 .NET Core의 일부로 사용될 것입니다.

솔루션 탐색기에서 콘솔 프로젝트와 라이브러리 프로젝트가 모두 내부에 있음을 알 수 있습니다. src 테스트 프로젝트가 내부에있는 동안 폴더 test 폴더.

그리고 솔루션 탐색기의 프로젝트 구조는 프로젝트가 디스크에서 실제로 존재하는 위치를 나타내지 않습니다. 이제 솔루션 폴더를 열면StringLibrary 프로젝트는 내부에 없습니다 src 폴더.

둘 다 볼 수 있습니다 srctest 폴더는에 지정된 규칙에 매핑됩니다. 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(콘솔 프로젝트) 오류없이. 이제 xunit을 사용하여 StringLibrary 기능을 테스트 해 보겠습니다. 테스트 프로젝트에 StringLibrary의 참조를 추가해야합니다. References of StringLibraryTests 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 참조 추가…를 선택합니다.

딸깍 하는 소리 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 링크를 클릭하면 테스트 탐색기에 다음 출력이 표시됩니다.

명령 줄에서 테스트를 실행할 수도 있습니다. 명령 프롬프트를 열고dotnet test 명령.

이 장에서는 MEF (Managed Extensibility Framework)에 대해 설명합니다. MEF는 타사 플러그인 확장 성을 위해 사용되거나 느슨하게 결합 된 플러그인 유사 아키텍처의 이점을 일반 애플리케이션에 가져올 수 있습니다.

  • MEF는 가볍고 확장 가능한 응용 프로그램을 만들기위한 라이브러리입니다.

  • 이를 통해 응용 프로그램 개발자는 구성없이 확장을 검색하고 사용할 수 있습니다.

  • MEF는 .NET Framework 4의 필수 부분이며 대규모 응용 프로그램의 유연성, 유지 관리 및 테스트 가능성을 향상시키는 .NET Framework가 사용되는 모든 곳에서 사용할 수 있습니다.

  • Windows Forms, WPF 또는 기타 기술을 사용하는 클라이언트 응용 프로그램이나 ASP.NET을 사용하는 서버 응용 프로그램에서 MEF를 사용할 수 있습니다.

  • MEF는 다음과 같이 이식되었습니다. Microsoft.Composition .NET Core에도 부분적으로.

  • System.Composition 이식되고 System.ComponentModel.Composition아직 사용할 수 없습니다. 즉, 디렉터리의 어셈블리에서 형식을로드 할 수있는 카탈로그가 없습니다.

이 장에서는 .NET Core 애플리케이션에서 MEF를 사용하는 방법 만 알아 봅니다.

.NET Core 콘솔 애플리케이션에서 MEF를 사용하는 간단한 예제를 이해하겠습니다. 이제 새 .NET Core 콘솔 프로젝트를 만들어 보겠습니다.

왼쪽 창에서 Templates → Visual C# → .NET Core를 클릭 한 다음 가운데 창에서 콘솔 애플리케이션 (.NET Core)을 선택합니다.

이름 필드에 프로젝트 이름을 입력하고 확인을 클릭합니다.

프로젝트가 생성되면 MEF를 사용할 수 있도록 Microsoft.Composition의 참조를 추가해야합니다. 이렇게하려면 솔루션 탐색기에서 프로젝트를 마우스 오른쪽 단추로 클릭하고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 파일의 Compose 메서드에 표시된대로 내보내기 특성을 사용하여 어셈블리에서 모든 유형을로드하고 가져 오기 특성에 연결합니다.

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의 예정된 기능을 이해합니다. 브라우저에서 다음 Url을 열어 .NET 명령 줄 도구로 시작하겠습니다.https://github.com/dotnet/cli

진행 상황에 대해 자세히 알아 보려면 아래로 스크롤하여 최신 버전의 .NET Core SDK를 다운로드하면 설치 관리자 및 바이너리 섹션이 표시됩니다.

다른 운영 체제에 대한 최신 버전의 미리보기 도구를 볼 수 있으며 운영 체제에 따라 설치 프로그램을 선택하겠습니다.

.NET Core 2.0의 미리보기 1에서 작업 중입니다.

이제 명령 프롬프트를 열고 다음 명령을 실행하여 현재 도구를 살펴 보겠습니다.

dotnet --info

아래와 같이 시스템에 현재 설치된 .NET 명령 줄 도구 버전에 대한 정보가 표시됩니다.

현재 미리보기 2 도구가 있음을 알 수 있습니다. 이제 다음 명령을 실행하여new 명령.

dotnet help new

프로젝트의 새 명령어는 C #, F #, 프로젝트 종류 등을 선택할 수 있습니다.

이제 .NET Core 최신 버전의 변경 사항을 살펴 보겠습니다. 설치 프로그램이 다운로드되면 두 번 클릭하여 설치합니다. 설치를 클릭하십시오.

다음 스크린 샷은 설치 프로세스를 보여줍니다.

설치 프로세스가 시작됩니다. 설치가 완료되면이 대화 상자를 닫습니다.

명령 프롬프트를 열고 다음 명령을 실행하십시오.

dotnet --info

아래와 같이 시스템에 현재 설치된 .NET 명령 줄 도구 버전 정보가 표시됩니다.

이제 .NET Core 2의 preview1 도구가 있음을 확인할 수 있습니다. 이제 명령 프롬프트에서 다음 코드를 실행하여 .NET Core 2 preview1의 새 명령에 대해 살펴 보겠습니다.

dotnet help new

이 명령은 패키지를 패키지 캐시로 다운로드하는 데 도움이됩니다.

이 명령은 .NET Core 2 preview1의 새 명령에 대한 정보가 포함 된 다음 웹 페이지를 엽니 다.

아래로 스크롤하면 더 많은 템플릿을 사용하여 .NET Core 애플리케이션을 만들 수 있음을 알 수 있습니다.

이제 우리는 mstest, web, mvcwebapi 프로젝트뿐만 아니라 명령 줄을 사용합니다.

.NET Core는 project.json을 삭제하고 MSBuild 및 * .csproj로 돌아 가기로 결정했습니다. 이것은 방금 출시 된 .Net Core 2.0 미리보기 1 도구에서 이미 발생한 것입니다. project.json이 신선한 공기를 마 셨기 때문에 이것은 상당히 실망 스럽습니다. 그러나 이해할 수 있고 많은 장점도 있습니다.

이제 변화가 가져 오는 이점에 대해 논의하겠습니다.

  • 기존 Visual Studio 솔루션을 .NET Core로 간단하게 전환 할 수 있습니다.

  • 이는 큰 변화이며 MSBuild를 기반으로하는 CI / RM에 대한 기존 투자를 활용할 수도 있습니다.

  • MSBuild에서 빌드하는 동안 증분 컴파일, 빌드 시간 종속성 해결, 구성 관리 등을 생각할 수 있습니다.

  • dotnet cli는 더 이상 ASP.NET Core뿐만 아니라 콘솔 앱, UWP 앱 등에 관한 것이기 때문에 적시에 dotnet cli를 제공하려면 많은 작업이 필요합니다.

다음은 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.csproject.json 파일.

이제 다음 명령을 실행하여 .NET Core 2 preview1 도구로 콘솔 앱을 만들겠습니다.

dotnet new console

이 프로젝트 내에서 생성 된 모든 파일을 보려면 dir명령. 세 개의 파일이 생성 된 것을 볼 수 있습니다.Program.cs, NuGet.configMSBuild.csproj project.json 파일 대신.

이제 비교해 봅시다 project.jsonMSBuild.csproj 나란히 파일.

왼쪽에는 json 형식의 파일이 있고 오른쪽에는 XML 형식의 파일이 있습니다. project.json 파일에서 종속성 섹션 내에netcoreapp1.0, MSBuild.csproj 파일에있는 동안 netcoreapp2.0.

이 장에서는 명령 줄 유틸리티를 사용하여 MSBuild (*. csproj) 파일을 복원하고 빌드하는 방법에 대해 설명합니다. .NET Core 2.0 미리보기 1에서 사용할 수있는 명령을 확인하려면 다음 명령을 실행하겠습니다.

dotnet help

new, restore, build 등과 같은 모든 명령이 표시됩니다.

다음은 기본 구현입니다. 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

이제 프로젝트 루트 디렉터리에 Program.cs 파일과 함께 * .csproj 파일이 표시되고 project.json이 백업 폴더로 이동됩니다.

열어 보자 console.csproj파일. 이제 다음 명령을 실행하여 MSBuild 시스템을 사용하여이 프로젝트를 복원하고 빌드 할 수 있습니다.

dotnet restore

이제 모든 패키지가 복원 된 것을 볼 수 있습니다.

이제 다음 명령을 사용하여 프로젝트를 빌드 할 수 있습니다.

dotnet build

이제 MSBuild를 사용하여 프로젝트가 성공적으로 빌드되고 console.dll도 ..\bin\Debug\netcoreapp1.0 폴더.

다음 스크린 샷은 디렉토리 구조와 파일을 보여줍니다.