.NET Core - Краткое руководство

.NET Core - это новейшая платформа разработки общего назначения, поддерживаемая Microsoft. Он работает на разных платформах и был переработан таким образом, чтобы .NET стал быстрым, гибким и современным. Это один из основных вкладов Microsoft. Теперь разработчики могут создавать приложения для Android, iOS, Linux, Mac и Windows с помощью .NET с открытым исходным кодом.

В этом руководстве мы рассмотрим .NET Core и несколько новых инноваций, включая обновления .NET Framework, .NET Standard, обновления универсальной платформы Windows и т. Д.

Характеристики .NET Core

Ниже приведены основные характеристики .NET Core:

Открытый источник

• .NET Core - это реализация с открытым исходным кодом, использующая лицензии MIT и Apache 2.

• .NET Core - это проект .NET Foundation, доступный на GitHub.

• Как проект с открытым исходным кодом, он способствует более прозрачному процессу разработки и способствует активному и заинтересованному сообществу.

Кроссплатформенность

• Приложение, реализованное в .NET Core, можно запускать, а его код можно повторно использовать независимо от целевой платформы.

• В настоящее время он поддерживает три основные операционные системы (ОС)

  • Windows

  • Linux

  • MacOS

• Поддерживаемые операционные системы (ОС), процессоры и сценарии приложений будут со временем расти, предоставляемые Microsoft, другими компаниями и отдельными лицами.

Гибкое развертывание

• Для приложений .NET Core может быть два типа развертывания:

  • Развертывание в зависимости от платформы

  • Автономное развертывание

• При развертывании, зависящем от платформы, ваше приложение зависит от общесистемной версии .NET Core, на которой установлено ваше приложение и сторонние зависимости.

• При автономном развертывании версия .NET Core, используемая для создания вашего приложения, также развертывается вместе с вашим приложением и сторонними зависимостями и может работать бок о бок с другими версиями.

Инструменты командной строки

• Все сценарии продукта могут быть реализованы из командной строки.

Совместимый

• .NET Core совместим с .NET Framework, Xamarin и Mono через стандартную библиотеку .NET.

Модульный

• .NET Core выпускается через NuGet небольшими сборочными пакетами.

• .NET Framework - это одна большая сборка, которая содержит большинство основных функций.

• .NET Core доступен в виде небольших функционально-ориентированных пакетов.

• Этот модульный подход позволяет разработчикам оптимизировать свое приложение, включая в свое приложение только те пакеты NuGet, которые им нужны.

• Преимущества меньшей площади приложения включают более строгую безопасность, сокращенное обслуживание, улучшенную производительность и снижение затрат в модели с оплатой за то, что вы используете.

Платформа .NET Core

Платформа .NET Core содержит следующие основные части -

• .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 с пакетом обновления 1 (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 ++.

• Эта зависимость устанавливается автоматически, если вы используете установщик .NET Core.

• Вам необходимо вручную установить Visual C ++ Redistributable для Visual Studio 2015, если вы устанавливаете .NET Core с помощью скрипта установщика или развертываете автономное приложение .NET Core.

• Для компьютеров под управлением Windows 7 и Windows Server 2008 необходимо убедиться, что ваша установка Windows обновлена, а также включает исправление KB2533623, установленное через Центр обновления Windows.

Предварительные требования с 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 с обновлением 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 (.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 - это тип, представляющий комплексные числа.

• Набор векторных типов с поддержкой Single Instruction Multiple Data (SIMD) в пространстве имен System.Numerics.

Интегральные типы

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

• Структура Decimal имеет собственные методы Decimal.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, кроме Decimal.

  • Два типа матриц: System.Numerics.Matrix3 × 2, которые представляют матрицу 3 × 2; и System.Numerics.Matrix4 × 4, который представляет матрицу 4 × 4.

  • Тип System.Numerics.Plane, представляющий трехмерную плоскость, и тип System.Numerics.Quaternion, представляющий вектор, который используется для кодирования трехмерных физических вращений.

В этой главе мы рассмотрим концепцию сборки мусора, которая является одной из наиболее важных функций платформы управляемого кода .NET. Сборщик мусора (GC) управляет выделением и освобождением памяти. Сборщик мусора служит автоматическим диспетчером памяти.

• Вам не нужно знать, как выделять и освобождать память или управлять временем жизни объектов, которые используют эту память.

• Выделение выполняется каждый раз, когда вы объявляете объект с помощью «нового» ключевого слова или когда тип значения помещается в рамку. Распределение обычно происходит очень быстро

• Когда недостаточно памяти для выделения объекта, сборщик мусора должен собрать и удалить мусорную память, чтобы сделать память доступной для новых выделений.

• Этот процесс известен как garbage collection.

Преимущества сборки мусора

Сборка мусора дает следующие преимущества:

• Вам не нужно освобождать память вручную при разработке приложения.

• Он также эффективно выделяет объекты в управляемой куче.

• Когда объекты больше не используются, он восстанавливает эти объекты, очищая их память, и сохраняет память доступной для будущих распределений.

• Управляемые объекты автоматически получают чистый контент для начала, поэтому их конструкторам не нужно инициализировать каждое поле данных.

• Он также обеспечивает безопасность памяти, гарантируя, что объект не может использовать содержимое другого объекта.

Условия для сборки мусора

Сборка мусора происходит, если выполняется одно из следующих условий.

• В системе мало физической памяти.

• Объем памяти, который используется выделенными объектами в управляемой куче, превышает допустимый порог. Этот порог постоянно корректируется по мере выполнения процесса.

• В GC.Collectвызывается метод, и почти во всех случаях вам не нужно вызывать этот метод, потому что сборщик мусора работает постоянно. Этот метод в основном используется для уникальных ситуаций и тестирования.

Поколения

Сборщик мусора .NET имеет 3 поколения, и каждое поколение имеет свою собственную кучу, которая используется для хранения выделенных объектов. Существует основной принцип, что большинство объектов либо недолговечны, либо долгоживущи.

Первое поколение (0)

• В поколении 0 сначала выделяются объекты.

• В этом поколении объекты часто не живут после первого поколения, так как они больше не используются (вне области видимости) к моменту следующей сборки мусора.

• Генерация 0 собирается быстро, поскольку связанная с ней куча мала.

Второе поколение (1)

• В первом поколении у объектов есть второй шанс.

• Объекты, которые недолговечны, но выживают в коллекции поколения 0 (часто основанной на совпадении по времени), переходят в поколение 1.

• Коллекции поколения 1 также быстрые, потому что связанная с ними куча также мала.

• Первые две кучи остаются небольшими, поскольку объекты либо собираются, либо перемещаются в кучу следующего поколения.

Третье поколение (2)

• В поколении 2 все длинные объекты «живы», и их куча может увеличиваться до очень больших размеров.

• Объекты в этом поколении могут существовать долгое время, и не существует кучи следующего поколения для дальнейшего продвижения объектов.

• Сборщик мусора имеет дополнительную кучу для больших объектов, известную как куча больших объектов (LOH).

• Он зарезервирован для объектов размером 85 000 байт и более.

• Большие объекты не выделяются в кучах поколений, а выделяются непосредственно в LOH.

• Коллекции поколения 2 и LOH могут занять заметное время для программ, которые выполняются в течение длительного времени или работают с большими объемами данных.

• Известно, что большие серверные программы имеют кучи размером в 10 ГБ.

• Сборщик мусора использует различные методы, чтобы сократить время, в течение которого он блокирует выполнение программы.

• Основной подход состоит в том, чтобы выполнить как можно больше работы по сборке мусора в фоновом потоке таким образом, чтобы это не мешало выполнению программы.

• GC также предоставляет разработчикам несколько способов повлиять на его поведение, что может быть весьма полезно для повышения производительности.

В этой главе мы поймем процесс выполнения .NET Core и сравним его с .NET Framework. Процесс управляемого выполнения включает следующие шаги.

• Выбор компилятора
• Компиляция вашего кода в MSIL
• Компиляция MSIL в собственный код
• Запуск кода

Выбор компилятора

• Это многоязычная среда выполнения, среда выполнения поддерживает широкий спектр типов данных и языковых функций.

• Чтобы получить преимущества, предоставляемые общеязыковой средой выполнения, необходимо использовать один или несколько языковых компиляторов, ориентированных на среду выполнения.

Компиляция вашего кода в MSIL

• Компиляция переводит ваш исходный код на Microsoft Intermediate Language (MSIL) и генерирует необходимые метаданные.

• Метаданные описывают типы в вашем коде, включая определение каждого типа, подписи членов каждого типа, члены, на которые ссылается ваш код, и другие данные, которые среда выполнения использует во время выполнения.

• Среда выполнения находит и извлекает метаданные из файла, а также из библиотек классов инфраструктуры (FCL) по мере необходимости во время выполнения.

Компиляция MSIL в собственный код

• Во время выполнения JIT-компилятор переводит MSIL в собственный код.

• Во время этой компиляции код должен пройти процесс проверки, который исследует MSIL и метаданные, чтобы выяснить, можно ли определить типобезопасный код.

Запуск кода

• Среда CLR предоставляет инфраструктуру, которая позволяет выполнять выполнение, и службы, которые можно использовать во время выполнения.

• Во время выполнения управляемый код получает такие службы, как сборка мусора, безопасность, взаимодействие с неуправляемым кодом, поддержка межъязыковой отладки и расширенная поддержка развертывания и управления версиями.

Процесс выполнения кода .NET Core

Теперь давайте посмотрим, как код выполняется в .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-компилятор.

• Теперь вопрос в том, почему у нас есть повторная реализация всех этих компонентов, которые у нас уже есть в .NET framework.

• Итак, ответ такой же, как и почему 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 framework, важно понимать, как добавить эти файлы в свой проект в 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 откройте 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 и просмотреть пакет, который вы хотите добавить.

В этой главе мы обсудим, как создать приложение UWP с помощью .NET Core. 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 в поле Имя и нажмите ОК.

• Появится диалоговое окно целевой версии / минимальной версии. Настройки по умолчанию подходят для этого руководства, поэтому нажмите OK, чтобы создать проект.

• Здесь у нас есть один проект, который может быть нацелен на все устройства с Windows 10, и вы заметите, что и .NET Core, и UWP упрощают множественный нацеливание.

• Когда открывается новый проект, его файлы отображаются в правой части панели обозревателя решений. Для просмотра файлов вам может потребоваться выбрать вкладку Обозреватель решений вместо вкладки Свойства.

• Хотя пустое приложение (универсальное окно) является минимальным шаблоном, оно по-прежнему содержит много файлов. Эти файлы необходимы для всех приложений 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, вам необходимо добавить эти файлы в папку проекта. Кроме того, вам также нужно будет включить в свой проект в обозреватель решений.

Давайте теперь рассмотрим следующие файлы; скопируйте эти файлы в папку вашего проекта.

Вернемся в Visual Studio и откроем обозреватель решений.

• Теперь вы можете видеть, что только копирования файлов недостаточно в случае приложений UWP, потому что в обозревателе решений мы не можем видеть эти файлы.

• Теперь мы должны включить эти файлы, нажав на Show All Files как выделено на скриншоте выше, и теперь вы увидите все файлы в папке проекта.

Эти два файла еще не включены в наш проект. Чтобы включить эти файлы, выберите эти файлы и щелкните любой файл правой кнопкой мыши, а затем выберитеInclude in Project.

Теперь эти файлы тоже включены. Одна хорошая вещь, которую можно предвидеть, - это подход project.json для удаления файлов для * .csproj в будущей версии инструментов SKD, а также в Visual Studio.

В этой главе мы обсудим ссылки между нашим консольным приложением и нашим приложением UWP. Если вы посмотрите на ссылки в обозревателе решений своего консольного приложения, вы увидите .NETCoreApp, как показано ниже.

.NETCoreApp - это новая платформа, ориентированная на приложение .NET Core. Теперь, если вы посмотрите в разделе «Ссылки на приложение UWP», оно будет выглядеть немного иначе, как показано ниже.

• Основная причина этого заключается в том, что здесь, в UWP, у нас есть * .csproj, поэтому мы вернулись к старому стилю ссылок и можем настроить таргетинг только на одну структуру с этим типом проекта.

• Хотя ссылки похожи. Теперь вы можете видеть, что в приложении UWP ссылка на пакет NuGet Miscrosoft.NETCore.UniversalWindowsPlatform аналогична ссылке на NuGet Microsoft.NETCore.App в консольном приложении.

• И Miscrosoft.NETCore.UniversalWindowsPlatform, и Microsoft.NETCore.App являются метапакетами, что означает, что они состоят из других пакетов.

• В консольном приложении мы можем детализировать и увидеть другие пакеты внутри Microsoft.NETCore.App, но мы не можем сделать то же самое, что и Miscrosoft.NETCore.UniversalWindowsPlatform в обозревателе решений.

• Однако мы можем использовать другой инструмент, NuGet Package Explorer, чтобы посмотреть на это. Давайте теперь откроем этот 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 link, и он откроет зависимости верхнего уровня этого метапакета.

• Давайте теперь откроем метапакет .NETCore для приложения .NETCore и метапакет для приложения UWP бок о бок.

• Теперь вы можете видеть, что каждый мета-пакет состоит из разных наборов пакетов.

• .NET Core - это подмножество классов, доступных в .NET Framework, по крайней мере, на данный момент, но оно растет и будет соответствовать базовым классам .NET Framework.

• UWP основан на .NET Core, это расширенный набор API, доступных для разработки Windows Store.

Теперь у нас есть больше API, доступных для разработки благодаря .NET Core.

Компоненты среды выполнения 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

Большинство этих API-интерфейсов в среде выполнения Windows объединены в один контракт. Давайте теперь поищем универсальное ключевое слово на странице контрактов API.

Вы можете видеть ссылки на различные API-интерфейсы, а также видеть, что семейство Universal настолько велико, что содержит 12 страниц документации.

Вы также можете найти контракт на API телефона на этой странице.

Давайте теперь щелкнем по Windows.Phone.PhoneContractи прокрутите вниз; Теперь вы увидите информацию о батарее телефона или мобильного устройства.

Если вы хотите добавить эту информацию поверх того, что у вас уже есть, вам следует добавить ссылки вручную. Теперь давайте перейдем в Visual Studio и щелкните правой кнопкой мыши ссылки в обозревателе решений.

Выбрать Add References…

Теперь вы можете увидеть новую справочную категорию для универсальной Windows; в этой категории есть Core, который относится к основным контрактам Universal Windows API.

• Расширения позволяют нам расширять функциональность, и вы увидите различные ссылки на мобильные, настольные и другие расширения.

• Существуют различные расширения SKD, и вы можете добавить их поверх, чтобы получить больше API.

• Вы также можете увидеть разные версии. Итак, убедитесь, что у вас установлена ​​последняя версия, чтобы получить обновленные API, а затем нажмите OK.

Теперь вы можете видеть, что Windows Mobile Extensions for the UWP добавлен как ссылка.

Библиотека классов определяет типы и методы, которые можно вызывать из любого приложения.

• Библиотека классов, разработанная с использованием .NET Core, поддерживает стандартную библиотеку .NET, которая позволяет вызывать вашу библиотеку с любой платформы .NET, которая поддерживает эту версию стандартной библиотеки .NET.

• Когда вы закончите свою библиотеку классов, вы можете решить, хотите ли вы распространять ее как сторонний компонент или хотите ли вы включить ее как компонент, связанный с одним или несколькими приложениями.

Начнем с добавления проекта библиотеки классов в наше консольное приложение; щелкните правой кнопкой мыши наsrc папку в обозревателе решений и выберите Add → New Project…

в Add New Project В диалоговом окне выберите узел .NET Core, затем выберите шаблон проекта библиотеки классов (.NET Core).

В текстовом поле «Имя» введите «UtilityLibrary» в качестве имени проекта, как показано на следующем рисунке.

Нажмите OK, чтобы создать проект библиотеки классов. Как только проект будет создан, давайте добавим новый класс. Щелкните правой кнопкой мыши на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 метод возвращает истину, если символ в верхнем регистре, метод Char.IsLower возвращает истину, если символ в нижнем регистре, и аналогично метод Char.IsNumber возвращает истину, если символ является числовым.

• В строке меню выберите 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 и далее добавьте новый элемент проекта.

Выберите Visual C# → Windows на левой панели и выберите Библиотека классов (переносимая) в средней панели.

Введите StringLibrary в поле имени и нажмите OK создать этот проект.

Теперь нам нужно выбрать целевые платформы для ссылки. Давайте на мгновение выберем Windows Universal и ASP.NET Core, а затем перенацелим. НажмитеOK.

Вы можете видеть, что он создал новый проект в формате PCF. Давайте теперь щелкнем правой кнопкой мыши проект StringLibrary в обозревателе решений и выберите «Свойства».

Щелкните Target .NET Platform Standard.

Щелкните Да; теперь это та же библиотека классов с одним незначительным отличием. Разница в том, что он также может использоваться UWP, поскольку он содержит файл * .csproj вместо * .xproj.

Давайте теперь добавим новый класс; для этого вам нужно щелкнуть правой кнопкой мыши проект в обозревателе решений и выбрать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…

В диалоговом окне «Диспетчер ссылок» выберите 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. После завершения установки вы увидите, что пакет NuGet «System.Runtime.Serialization.Primitives» добавлен в вашу библиотеку.

В этой главе мы обсудим, как поделиться своей библиотекой как 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. В разделе метаданных пакета вы увидите небольшую информацию об этой библиотеке, такую ​​как идентификатор, версии и все зависимости.

Давайте теперь откроем 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, потому что это намного проще, чем создавать учетную запись на nuget.org. Чтобы узнать, как опубликовать свой пакет на 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 - Щелкните 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 - это кроссплатформенная абстракция набора инструментов пользовательского интерфейса с исходной поддержкой, которая позволяет разработчикам легко создавать пользовательские интерфейсы, которые можно использовать в 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). Введите имя в поле «Имя» и нажмите «ОК».

Выберите целевую версию и минимальную версию и нажмите OK.

Вы увидите серию проектов; наверху у нас есть библиотека PCL, которая будет использоваться всеми платформами, такими как Android, iOS, UWP, Windows 8.1 и Windows Phone 8.1.

Здесь мы сосредоточимся на библиотеке PCL и приведем здесь код. Давайте расширим код.

В этом шаблоне Xamarin.Forms вы можете увидеть общие App.xaml и MainPage.xaml, использующие XAML-фреймворк Xamarin.Forms, который работает на этих платформах.

Нам нужно импортировать наши коды, а также нам нужен частный канал NuGet, который мы настроили в предыдущей главе.

Давайте теперь откроем диспетчер пакетов NuGet. Щелкните колесо рядом с раскрывающимся списком Источник пакета.

Нам нужно добавить сюда нашу личную ленту, давайте нажмем на plus (+) button.

Вы увидите, что в Available package sources раздел, укажите имя и исходный путь и нажмите OK.

Давайте теперь перейдем на вкладку Обзор и выберите PrivateSource из раскрывающегося списка Источник пакета, и вы увидите пакет StringLibrary NuGet. Выберите StringLibrary и щелкнитеInstall.

Нажмите ОК, и вы увидите одну ошибку.

Мы не можем использовать библиотеку с .NETPortable Profile версии 259, мы исправим эту ошибку в следующей главе.

В этой главе мы исправим ошибку, возникшую при установке пакета NuGet из нашего частного канала в проекте Xamarin.Forms.

Далее мы вкратце разберемся с проблемой. Для начала щелкните правой кнопкой мыши библиотеку 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 кнопка.

Теперь, чтобы исправить эту проблему, нажмите OK и закройте диалоговое окно «Изменить цели», затем откройте консоль диспетчера пакетов и выполните следующую команду.

PM > Uninstall-Package Xamarin.Forms

Теперь перейдем к свойствам библиотеки PCL. Щелкните по кнопке Изменить.

Снимите флажок Windows Phone Silverlight 8 и нажмите ОК.

Теперь вы можете видеть, что Windows Phone Silverlight 8 больше не доступен в целевой платформе. Вы также можете увидеть профиль, который сейчас является целью. Чтобы убедиться в этом, давайте выгрузим библиотеку PCL и отредактируем файл XamarinApp.csproj.

Теперь вы видите, что TargetFrameworkProfile теперь Profile111.

Если вы откроете документацию, то увидите, что Profile111 поддерживает .NET Standard 1.1.

Давайте теперь перезагрузим PCL, откроем диспетчер пакетов NuGet и попытаемся установить пакет StringLibrary из частного канала.

В раскрывающемся списке поведения зависимости выберите Игнорировать зависимости и нажмите Install.

Вы можете видеть, что пакет StringLibrary теперь установлен из закрытого канала. Если вы развернете Ссылки PCL, вы увидите, что ссылка на StringLibrary также добавлена, как показано ниже.

Мы удалили Xamarin.Forms для проблемы Windows Phone Silverlight 8. Xamarin.Forms необходимо установить снова. Рекомендуется установить ту же версию.

После завершения установки позвольте нам использовать функцию StringLibrary в вашем приложении.

В этой главе мы обсудим, как создать проект тестирования с помощью .NET Core. Модульное тестирование - это процесс разработки программного обеспечения, в котором есть самые маленькие тестируемые части приложения, которые называются модулями. Они проходят индивидуальную и независимую проверку на предмет надлежащей работы. Модульное тестирование может быть автоматизировано или выполнено вручную.

Давайте теперь откроем диалоговое окно New Project и выберем Visual C# → .NET Core шаблон.

В этом диалоговом окне вы можете увидеть, что нет шаблона проекта для модульного тестирования. Чтобы создать проект модульного теста, мы должны использовать утилиту командной строки. Перейдем в созданную нами папку Solution; создайте тестовую папку и внутри тестовой папки создайте другую папку и назовите ееStringLibraryTests.

Давайте теперь воспользуемся служебной программой командной строки dotnet для создания нового тестового проекта, выполнив следующую команду -

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

В обозревателе решений вы можете видеть, что проект консоли и проект библиотеки находятся внутри src папка, пока проект тестирования находится внутри test папка.

И структура проектов в обозревателе решений не отражает их физическое расположение на диске. Давайте теперь откроем папку Solution, и вы увидите, что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 в наш тестовый проект. Щелкните правой кнопкой мыши проект "Ссылки проекта 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). 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, а затем на средней панели выберите Консольное приложение (.NET Core).

Введите название проекта в поле «Имя» и нажмите «ОК».

После создания проекта нам нужно добавить ссылку на Microsoft.Composition, чтобы мы могли использовать MEF. Для этого щелкните правой кнопкой мыши проект в обозревателе решений и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. Таким образом, он загрузит все типы из сборки с атрибутом экспорта и присоединится к атрибуту импорта, как показано в методе Compose в файле 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 мы можем думать об инкрементной компиляции, разрешении зависимостей времени сборки, управлении конфигурацией и т. Д.

• Для своевременной поставки 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 preview 2, и теперь мы установили инструменты .NET Core 2.0 preview 1. Теперь, когда вы создаете это приложение с помощью утилиты командной строки .NET Core 2.0, вы увидите следующую ошибку.

Это потому, что project.jsonСистема сборки больше не доступна в .NET Core 2.0, поэтому нам нужна миграция, чтобы она работала правильно. Чтобы увидеть доступные команды, давайте запустим следующую команду.

dotnet help

В разделе команд вы можете увидеть различные команды, а также migrate команда, которая перенесет проект на основе project.json в проект на основе MSBuild.

Давайте теперь выполним следующую команду.

dotnet migrate

Вы увидите сводку процесса миграции, а также увидите, что проект успешно перенесен.

Давайте теперь посмотрим на структуру каталогов, используя следующую команду.

tree /f

Теперь вы увидите файл * .csproj вместе с файлом Program.cs в корневом каталоге проекта, а project.json перемещен в папку резервного копирования.

Давайте откроем console.csprojфайл. Теперь вы можете восстановить и собрать этот проект с помощью системы MSBuild, выполнив следующую команду.

dotnet restore

Теперь вы можете видеть, что все пакеты восстановлены.

Теперь вы можете создать свой проект с помощью следующей команды.

dotnet build

Теперь вы можете видеть, что проект успешно построен с использованием MSBuild, а console.dll также создается в ..\bin\Debug\netcoreapp1.0 папка.

На следующем снимке экрана показана структура каталогов и файлы.