.NET Core — Обзор

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

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

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

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

Открытый исходный код

.NET Core — это реализация с открытым исходным кодом, использующая лицензии MIT и Apache 2.
.NET Core является проектом .NET Foundation и доступен на GitHub.
Как проект с открытым исходным кодом, он способствует более прозрачному процессу разработки и способствует активному и заинтересованному сообществу.

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

.NET Core является проектом .NET Foundation и доступен на GitHub.

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

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

Приложение, реализованное в .NET Core, может быть запущено, и его код может быть повторно использован независимо от цели вашей платформы.
В настоящее время он поддерживает три основные операционные системы (ОС)
- Windows
- Linux
- MacOS
Поддерживаемые операционные системы (ОС), ЦП и сценарии приложений со временем будут расширяться, предоставленные Microsoft, другими компаниями и частными лицами.

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

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

Windows

Linux

MacOS

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

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

Для приложений .NET Core может быть два типа развертываний:
- Зависит от платформы
- Автономное развертывание
При развертывании, зависящем от инфраструктуры, ваше приложение зависит от общесистемной версии .NET Core, на которой установлены ваше приложение и сторонние зависимости.
При автономном развертывании версия .NET Core, используемая для создания приложения, также развертывается вместе с вашим приложением и сторонними зависимостями и может работать параллельно с другими версиями.

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

Зависит от платформы

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

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

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

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

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

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

совместимый

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

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

модульная

.NET Core выпускается через NuGet в небольших сборочных пакетах.
.NET Framework — это одна большая сборка, которая содержит большинство основных функций.
.NET Core доступен в виде небольших функционально-ориентированных пакетов.
Такой модульный подход позволяет разработчикам оптимизировать свое приложение, включая в него только те пакеты NuGet, которые им необходимы.
Преимущества меньшей площади приложения включают более строгую безопасность, снижение уровня обслуживания, повышение производительности и снижение затрат в модели с платой за использование.

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

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

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

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

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

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

.NET Core Platform содержит следующие основные части —

.NET Runtime — предоставляет систему типов, загрузку сборок, сборщик мусора, встроенное взаимодействие и другие базовые сервисы.
Фундаментальные библиотеки — набор библиотек фреймворков, которые предоставляют примитивные типы данных, типы композиций приложений и фундаментальные утилиты.
SDK & Compiler — набор инструментов SDK и языковых компиляторов, которые обеспечивают базовый опыт разработчика, доступны в .NET Core SDK.
Хост приложения ‘dotnet’ — используется для запуска приложений .NET Core. Он выбирает среду выполнения и размещает среду выполнения, предоставляет политику загрузки сборок и запускает приложение. Этот же хост также используется для запуска инструментов SDK практически таким же образом.

.NET Runtime — предоставляет систему типов, загрузку сборок, сборщик мусора, встроенное взаимодействие и другие базовые сервисы.

Фундаментальные библиотеки — набор библиотек фреймворков, которые предоставляют примитивные типы данных, типы композиций приложений и фундаментальные утилиты.

SDK & Compiler — набор инструментов SDK и языковых компиляторов, которые обеспечивают базовый опыт разработчика, доступны в .NET Core SDK.

Хост приложения ‘dotnet’ — используется для запуска приложений .NET Core. Он выбирает среду выполнения и размещает среду выполнения, предоставляет политику загрузки сборок и запускает приложение. Этот же хост также используется для запуска инструментов SDK практически таким же образом.

.NET Core — Необходимые условия

В этой главе мы обсудим различные зависимости, которые вам нужно развернуть и запустить. К ним относятся приложения .NET Core на компьютерах с Windows, разработанные с использованием Visual Studio.

Поддерживаемые версии Windows

.NET Core поддерживается в следующих версиях Windows —

Windows 7 SP1
Windows 8.1
Windows 10
Windows Server 2008 R2 SP1 (полный сервер или ядро сервера)
Windows Server 2012 SP1 (полный сервер или серверное ядро)
Windows Server 2012 R2 SP1 (полный сервер или ядро сервера)
Windows Server 2016 (полный сервер, серверное ядро или нано-сервер)

зависимости

Если вы запускаете приложение .NET Core в версиях Windows, более ранних, чем Windows 10 и Windows Server 2016, то для него также потребуется распространяемый Visual C ++.
Эта зависимость автоматически устанавливается для вас, если вы используете установщик .NET Core.
Вам необходимо вручную установить распространяемый пакет Visual C ++ для Visual Studio 2015, если вы устанавливаете .NET Core с помощью сценария установщика или развертываете автономное приложение .NET Core.
На компьютерах с Windows 7 и Windows Server 2008 необходимо убедиться, что ваша установка Windows обновлена и также содержит исправление KB2533623, установленное через Центр обновления Windows.

Если вы запускаете приложение .NET Core в версиях Windows, более ранних, чем Windows 10 и Windows Server 2016, то для него также потребуется распространяемый Visual C ++.

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

Вам необходимо вручную установить распространяемый пакет Visual C ++ для 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 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 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 —

Шаг 1 — После завершения загрузки запустите установщик. Появится следующее диалоговое окно.

Шаг 2 — Нажмите « Установить», чтобы начать процесс установки.

Шаг 3 — После завершения установки вы увидите следующее диалоговое окно.

Шаг 4 — Закройте это диалоговое окно и перезагрузите компьютер, если это необходимо.

Шаг 5 — Откройте Visual Studio из меню «Пуск»; Вы получите следующее диалоговое окно. Это может занять несколько минут, чтобы загрузить и, наконец, использовать в первый раз.

Шаг 6 — После загрузки вы увидите следующий экран.

Шаг 7. После завершения установки Visual Studio закройте Visual Studio и запустите Microsoft .NET Core — VS 2015 Tooling Preview 2.

Шаг 8 — Установите флажок и нажмите «Установить».

Шаг 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

.NET Core — Начало работы

Visual Studio 2015 предоставляет полнофункциональную среду разработки для разработки приложений .NET Core. В этой главе мы будем создавать новый проект в Visual Studio. После установки инструментария Visual Studio 2015 вы можете приступить к созданию нового приложения .NET Core.

В диалоговом окне « Новый проект » в списке «Шаблоны» разверните узел Visual C # и выберите .NET Core, и вы должны увидеть следующие три новых шаблона проекта.

Библиотека классов (.NET Core)
Консольное приложение (.NET Core)
Веб-приложение ASP.NET Core (.NET Core)

В средней панели диалогового окна «Новый проект» выберите «Консольное приложение» (.NET Core) и назовите его «FirstApp», затем нажмите «ОК».

Visual Studio откроет вновь созданный проект, и вы увидите в окне обозревателя решений все файлы, которые находятся в этом проекте.

Чтобы проверить, работает ли консольное приложение ядра .NET, добавим следующую строку.

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

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

.NET Core — Числовые

.NET Core поддерживает стандартные числовые интегральные и примитивы с плавающей точкой. Он также поддерживает следующие типы —

System.Numerics.BigInteger, который является целочисленным типом без верхней или нижней границы.
System.Numerics.Complex — это тип, представляющий комплексные числа.
Набор векторных типов с поддержкой нескольких инструкций (SIMD) в пространстве имен System.Numerics.

System.Numerics.BigInteger, который является целочисленным типом без верхней или нижней границы.

System.Numerics.Complex — это тип, представляющий комплексные числа.

Набор векторных типов с поддержкой нескольких инструкций (SIMD) в пространстве имен System.Numerics.

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

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

В следующей таблице представлены целочисленные типы и их размеры;

Тип	Подпись / Без подписи	Размер (в байтах)	Минимальное значение	Максимальное значение
Байт	неподписанный	1	0	255
Int16	подписанный	2	-32768	32767
Int32	подписанный	4	-2147483648	2147483647
Int64	подписанный	8	-9.223.372.036.854.775.808	9.223.372.036.854.775.807
SByte	подписанный	1	-128	127
UInt16	неподписанный	2	0	65535
UInt32	неподписанный	4	0	4294967295
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 ()), для работы с отдельными битами десятичного значения, а также свой собственный набор методов для выполнения некоторых дополнительных математических операций.

Каждый тип с плавающей точкой поддерживает стандартный набор операторов арифметики, сравнения, равенства, явного преобразования и неявного преобразования.

Вы также можете работать с отдельными битами в значениях Double и Single с помощью класса BitConverter.

Структура Decimal имеет свои собственные методы, Decimal.GetBits и Decimal.Decimal (Int32 ()), для работы с отдельными битами десятичного значения, а также свой собственный набор методов для выполнения некоторых дополнительных математических операций.

BigInteger

System.Numerics.BigInteger — неизменный тип, представляющий произвольно большое целое число, значение которого в теории не имеет верхних или нижних границ.
Методы типа BigInteger тесно параллельны методам других целочисленных типов.

System.Numerics.BigInteger — неизменный тип, представляющий произвольно большое целое число, значение которого в теории не имеет верхних или нижних границ.

Методы типа BigInteger тесно параллельны методам других целочисленных типов.

Сложный

Тип System.Numerics.Complex представляет собой комплексное число, то есть число с частью действительного числа и частью мнимого числа
Он поддерживает стандартный набор операторов арифметики, сравнения, равенства, явного преобразования и неявного преобразования, а также математических, алгебраических и тригонометрических методов.

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

Пространство имен 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 Core — Сборка мусора

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

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

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

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

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

Этот процесс известен как сборка мусора .

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

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

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

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

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

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

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

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

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

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

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

Система имеет низкую физическую память.

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

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

Поколения

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

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

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

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

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

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

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

В Поколении 1 у объектов есть второй шанс.
Объекты, которые являются недолговечными, но сохраняют коллекцию поколения 0 (часто основанную на совпадении времени), переходят к поколению 1.
Коллекции поколения 1 также быстрые, потому что связанная с ними куча также мала.
Первые две кучи остаются маленькими, потому что объекты либо собираются, либо перемещаются в кучу следующего поколения.

В Поколении 1 у объектов есть второй шанс.

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

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

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

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

Во втором поколении все длинные объекты живут, и их куча может стать очень большой.
Объекты в этом поколении могут выжить в течение длительного времени, и нет никакого кучи следующего поколения для дальнейшего продвижения объектов.
Сборщик мусора имеет дополнительную кучу для больших объектов, известную как куча больших объектов (LOH).
Он зарезервирован для объектов размером 85 000 байт или более.
Большие объекты не распределяются между кучами поколений, а выделяются непосредственно в LOH
Коллекции второго поколения и LOH могут занять заметное время для программ, которые выполняются в течение длительного времени или работают с большими объемами данных.
Известно, что большие серверные программы имеют кучи в 10 ГБ.
GC использует различные методы, чтобы уменьшить время, которое он блокирует выполнение программы.
Основной подход заключается в том, чтобы выполнять как можно больше работы по сбору мусора в фоновом потоке таким образом, чтобы это не мешало выполнению программы.
GC также предоставляет разработчикам несколько способов повлиять на его поведение, что может быть весьма полезно для повышения производительности.

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

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

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

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

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

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

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

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

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

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

.NET Core — выполнение кода

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

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

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

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

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

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

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

Компиляция переводит ваш исходный код на язык Microsoft Intermediate Language (MSIL) и генерирует необходимые метаданные.
Метаданные описывают типы в вашем коде, включая определение каждого типа, подписи членов каждого типа, членов, на которые ссылается ваш код, и другие данные, которые среда выполнения использует во время выполнения.
Среда выполнения находит и извлекает метаданные из файла, а также из библиотек классов инфраструктуры (FCL) по мере необходимости во время выполнения.

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

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

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

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

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

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

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

Запуск кода

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

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

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

Процесс выполнения кода .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 появилась новая серия компиляторов, как у 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 Core для создания и реализации модульного приложения. Вместо установки всего .NET Framework ваше приложение теперь может просто установить то, что требуется. Давайте пойдем в визуальную студию и посмотрим модульность.

Вот наше простое .NET Core приложение в Solution Explorer. Позвольте нам расширить ссылки, и вы увидите ссылку на .NETCoreApp

Внутри .NETCoreApp вы увидите ссылку на пакет для NuGet; давайте расширим это.

NuGet

Вы увидите всю серию ссылок на NuGet Package. Если вы работали в .NET Framework, то многие из этих пространств имен будут выглядеть знакомо, потому что вы привыкли к этому при использовании .NET Framework.

.NET Framework разделен на множество частей и повторно реализован с помощью CoreFx; эти части далее распространяются как отдельные пакеты.

Теперь, если вы развернете библиотеку NETStandard.Library, вы увидите дополнительные ссылки. Вы даже заметите System.Console, который мы используем в этом приложении.
Теперь вам не нужно вводить все в .NET Framework, а просто вводить то, что вам нужно для вашего приложения.
Есть и другие преимущества; например, эти модули могут обновляться индивидуально при желании.

Теперь, если вы развернете библиотеку NETStandard.Library, вы увидите дополнительные ссылки. Вы даже заметите System.Console, который мы используем в этом приложении.

Теперь вам не нужно вводить все в .NET Framework, а просто вводить то, что вам нужно для вашего приложения.

Есть и другие преимущества; например, эти модули могут обновляться индивидуально при желании.

Модульность приводит к повышению производительности, и ваше приложение может работать быстрее, особенно приложение ASP.NET Core.

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

Теперь, если вы знакомы с .NET, и это было традиционное консольное приложение .NET Framework, важно понять, как добавить эти файлы в ваш проект в Visual Studio.

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

Одним из преимуществ .NET Core является подход, используемый с файлом проекта (project.json); мы можем просто поместить файлы в корень нашего проекта, и тогда они будут автоматически включены в наш проект.

Нам не нужно вручную ссылаться на файлы, как мы делали это раньше для традиционных приложений .NET Framework в Visual Studio.

Давайте теперь откроем корень вашего проекта.

Теперь давайте скопируем все три файла в корень вашего проекта.

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

Давайте теперь пойдем в Visual Studio; Вы получите следующее диалоговое окно.

Нажмите Yes to All, чтобы перезагрузить ваш проект.

Теперь вы увидите, что файлы автоматически включаются в ваш проект.

.NET Core — ссылки на пакеты

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

Давайте теперь перейдем к исходному коду .NET Core, который находится здесь — https://github.com/dotnet/corefx

В репозитории CoreFx откройте папку src —

CoreFx

И вы увидите весь список папок, которые соответствуют разным пакетам. Давайте теперь искать Json —

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 с использованием .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, отметьте эту опцию, как показано ниже.

Если вы хотите запустить его локально, у вас должна быть Windows 10, вы также можете разрабатывать на Windows 8, а затем вам нужно будет запустить его на эмуляторе, но рекомендуется использовать Windows 10.

Для приложения UWP вам также понадобится Windows 10 SDK. Давайте откроем установку Visual Studio 2015, а затем изменим Visual Studio.

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

Здесь вы можете увидеть различные версии SDK и последние обновления инструментов, нажмите кнопку Далее.

Теперь нажмите кнопку Установить .

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

Теперь давайте реализуем UWP, выполнив следующие действия.

Сначала запустите Visual Studio 2015.
Нажмите на меню Файл и выберите Создать → Проект; Откроется диалоговое окно «Новый проект». Вы можете увидеть различные типы шаблонов на левой панели диалогового окна.

Сначала запустите Visual Studio 2015.

Нажмите на меню Файл и выберите Создать → Проект; Откроется диалоговое окно «Новый проект». Вы можете увидеть различные типы шаблонов на левой панели диалогового окна.

На левой панели вы можете увидеть древовидное представление, теперь выберите Универсальный шаблон из Шаблонов → Visual C # → Windows.
На центральной панели выберите шаблон «Пустое приложение (универсальная Windows)».
Присвойте имя проекту, введя UWPFirstApp в поле «Имя» и нажмите «ОК».

На левой панели вы можете увидеть древовидное представление, теперь выберите Универсальный шаблон из Шаблонов → Visual C # → Windows.

На центральной панели выберите шаблон «Пустое приложение (универсальная Windows)».

Присвойте имя проекту, введя UWPFirstApp в поле «Имя» и нажмите «ОК».

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

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

Здесь у нас есть один проект, который может быть нацелен на все устройства Windows 10, и вы заметите, что и .NET Core, и UWP упрощают многоцелевой таргетинг.
Когда открывается новый проект, его файлы отображаются в правой части панели Solution Explorer. Возможно, вам придется выбрать вкладку Solution Explorer вместо вкладки Properties, чтобы увидеть ваши файлы.
Хотя приложение Blank (универсальное окно) является минимальным шаблоном, оно по-прежнему содержит много файлов. Эти файлы необходимы для всех приложений UWP, использующих C #. Каждый проект, который вы создаете в Visual Studio, содержит файлы.
Чтобы увидеть работающий пример, давайте откроем MainPage.XAML и добавим следующий код.

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

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

Хотя приложение Blank (универсальное окно) является минимальным шаблоном, оно по-прежнему содержит много файлов. Эти файлы необходимы для всех приложений 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"; 
      } 
   } 
}

Давайте теперь запустим приведенный выше код на локальном компьютере, и вы увидите следующее окно. Теперь введите любое имя в текстовое поле и нажмите кнопку « Нажмите меня» .

.NET Core — MSBuild

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

Система сборки .NET Core или система сборки project.json недостаточна для нужд UWP; Вот почему UWP все еще использует систему сборки * .csproj (MSBuild).

Но project.json выйдет из системы сборки.

Теперь, если вы хотите добавить несколько существующих файлов в ваше приложение UWP, как мы добавили в консольное приложение, вам нужно добавить эти файлы в папку проекта. Кроме того, вам также необходимо включить в ваш проект в Solution Explorer.

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

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

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

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

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

Эти два файла до сих пор не включены в наш проект. Чтобы включить эти файлы, выберите эти файлы и щелкните правой кнопкой мыши любой файл, а затем выберите « Включить в проект» .

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

.NET Core — метапакет

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

.NETCoreApp — это новая платформа, предназначенная для приложений .NET Core. Теперь, если вы посмотрите под приложением References of 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, и вы увидите, как загружается небольшая утилита.
После завершения загрузки дважды щелкните этот файл.

Основная причина этого в том, что здесь, в 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, и вы увидите, как загружается небольшая утилита.

После завершения загрузки дважды щелкните этот файл.

Нажмите « Установить», чтобы начать установку в проводнике пакетов NuGet.

Нажмите « Установить», чтобы начать установку в проводнике пакетов NuGet.

Когда установка будет завершена, вы увидите следующее диалоговое окно.

Когда установка будет завершена, вы увидите следующее диалоговое окно.

Теперь давайте нажмем на опцию Открыть пакет из онлайн-фида .

Теперь давайте нажмем на опцию Открыть пакет из онлайн-фида .

По умолчанию он будет искать канал nuget.org. Теперь давайте поищем Microsoft.NETCore.UniversalWindowsPlatform в окне поиска, и вы увидите 1 результат, как показано ниже.

По умолчанию он будет искать канал nuget.org. Теперь давайте поищем Microsoft.NETCore.UniversalWindowsPlatform в окне поиска, и вы увидите 1 результат, как показано ниже.

Нажмите на ссылку Открыть, и она откроет зависимости верхнего уровня этого метапакета.

Нажмите на ссылку Открыть, и она откроет зависимости верхнего уровня этого метапакета.

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

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

Теперь вы можете видеть, что каждый метапакет состоит из разного набора пакетов.
.NET Core — это подмножество классов, доступных в .NET Framework, по крайней мере, на данный момент, но оно растет и будет соответствовать базовым классам .NET Framework.
UWP основан на .NET Core, это расширенный набор API, доступных для разработки в Магазине Windows.

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

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

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

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

Windows Runtime и расширение SDK

Компоненты среды выполнения Windows — это автономные объекты, которые вы можете создавать и использовать на любом языке, включая C #, Visual Basic, JavaScript и C ++. В дополнение к метапакету .NET Core, который мы видели в предыдущей главе, приложение UWP по умолчанию имеет ссылку на Universal Windows SDK.

Универсальная Windows — это ссылка на среду выполнения Windows, которая была включена в серию API-контрактов.

Набор API в семействе устройств разбит на подразделения, известные как контракты API. Вы можете найти список различных контрактов API здесь https://msdn.microsoft.com/en-us/library/windows/apps/dn706135.aspx

API

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

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

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

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

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

Выберите Добавить ссылки …

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

Расширения позволяют нам расширять функциональность, и вы увидите различные ссылки Mobile, Desktop и другие расширения.
Существуют различные расширения SKD, и вы можете добавить их сверху, чтобы получить больше API.
Вы также можете увидеть разные версии. Итак, убедитесь, что вы получили последнюю версию, чтобы получить обновленные API, а затем нажмите OK.

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

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

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

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

.NET Core — Создание стандартной библиотеки .NET

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

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

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

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

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

В диалоговом окне « Добавить новый проект » выберите узел .NET Core, затем выберите шаблон проекта библиотеки классов (.NET Core).

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

Нажмите OK, чтобы создать проект библиотеки классов. Как только проект будет создан, давайте добавим новый класс. Щелкните правой кнопкой мыши проект в обозревателе решений и выберите Добавить → Класс …

Выберите класс в средней панели и введите StringLib.cs в имя и поле, а затем нажмите « Добавить» . После добавления класса замените следующий код в файле 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, если символ является числовым.
В строке меню выберите Build, Build Solution. Проект должен скомпилироваться без ошибок.
Наш консольный проект .NET Core не имеет доступа к нашей библиотеке классов.
Теперь, чтобы использовать эту библиотеку классов, нам нужно добавить ссылку на эту библиотеку классов в наш консольный проект.

Библиотека классов, UtilityLibrary.StringLib , содержит некоторые методы, такие как, StartsWithUpper , StartsWithLower и StartsWithNumber, которые возвращают логическое значение, которое указывает, начинается ли текущий экземпляр строки с верхнего регистра, нижнего регистра и числа соответственно.

В .NET Core метод Char.IsUpper возвращает true, если символ находится в верхнем регистре, метод Char.IsLower возвращает true, если символ в нижнем регистре, и аналогичным образом метод Char.IsNumber возвращает true, если символ является числовым.

В строке меню выберите Build, Build Solution. Проект должен скомпилироваться без ошибок.

Наш консольный проект .NET Core не имеет доступа к нашей библиотеке классов.

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

Для этого разверните FirstApp, щелкните правой кнопкой мыши на References и выберите Add Reference…

В диалоговом окне «Диспетчер ссылок» выберите UtilityLibrary, проект нашей библиотеки классов, а затем нажмите » ОК» .

Теперь давайте откроем файл 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); 
      } 
   } 
}

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

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

.NET Core — Портативная библиотека классов

В этой главе мы обсудим, что такое PCL (Portable Class Library), а также зачем нам нужен PCL. Чтобы понять эту концепцию, давайте откроем папку проекта библиотеки классов, которую мы создали в предыдущей главе.

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 и т. Д.

Проект Portable Class Library позволяет создавать и создавать управляемые сборки, которые работают на нескольких платформах .NET Framework.

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

Он также может помочь вам быстро и легко создавать кроссплатформенные приложения и библиотеки для платформ Microsoft.

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

Используйте этот тип проекта для написания и сборки переносимых сборок .NET Framework, а затем ссылайтесь на эти сборки из приложений, предназначенных для нескольких платформ, таких как Windows и Windows Phone и т. Д.

Теперь давайте удалим созданную нами библиотеку классов из обозревателя решений. Одновременно удалите его из папки Solution и добавьте новый элемент проекта.

Выберите шаблон Visual C # → Windows на левой панели и выберите Class Library (Portable) на средней панели.

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

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

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

Нажмите на Target .NET Platform Standard.

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

Давайте теперь добавим новый класс; для этого вам нужно щелкнуть правой кнопкой мыши проект в обозревателе решений и выбрать Добавить → Класс …

Выберите класс в средней панели и введите StringLib.cs в поле имени, а затем нажмите кнопку « Добавить» . После добавления класса замените следующий код в файле 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», который представляет собой проект переносимой библиотеки классов, и нажмите « ОК» .

Вы можете видеть, что ссылка на StringLibrary добавлена в консольный проект, и это также можно увидеть в файле project.json.

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

Позвольте нам теперь использовать другие методы расширения вашей переносимой библиотеки классов в вашем проекте. Та же портативная библиотека будет использоваться и в вашем приложении UWP.

.NET Core — Добавление ссылок на библиотеку

В этой главе мы обсудим, как добавить ссылки в вашу библиотеку. Добавление ссылок на библиотеку похоже на добавление ссылок на другие ваши проекты, такие как консольный проект и проект 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».

Нажмите кнопку Установить , чтобы отобразить следующий экран.

Теперь нажмите кнопку ОК .

Наконец, нажмите кнопку « Я принимаю» , чтобы начать установку этого пакета NuGet. После завершения установки вы увидите, что пакет NuGet «System.Runtime.Serialization.Primitives» добавлен в вашу библиотеку.

.NET Core — совместное использование библиотек

В этой главе мы обсудим, как использовать вашу библиотеку как пакет NuGet, чтобы ее можно было использовать в другом проекте. Создание пакета начинается с кода, который вы хотите упаковать и поделиться с другими, через общедоступную галерею nuget.org или частную галерею в вашей организации. Пакет может также включать дополнительные файлы, такие как файл readme, который отображается при установке пакета, и может включать преобразования в определенные файлы проекта.

Давайте теперь рассмотрим простой пример, в котором мы создадим пакет NuGet из нашей библиотеки. Для этого откройте командную строку и перейдите в папку, где находится файл project.json вашего библиотечного проекта.

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

dotnet help

В конце вы можете увидеть различные команды, такие как new, restore и build и т. Д.

Последняя команда — pack; это создаст пакет NuGet. Давайте теперь выполним следующую команду.

dotnet pack

Теперь вы можете видеть, что пакеты NuGet создаются в папке bin; давайте откроем папку bin \ Debug.

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

Выберите первый вариант Открыть локальный пакет .

Выберите StringLibrary.1.0.0.nupkg и нажмите Открыть .

Вы можете видеть, что в разделе Содержимое пакета у нас есть только StringLibrary.dll. В разделе метаданных пакета вы увидите немного информации об этой библиотеке, такой как Id, версии и все зависимости.

Давайте теперь откроем StringLibrary.1.0.0.symbols.nupkg .

В этом пакете NuGet вы увидите исходные файлы и файл * .pdb . Если дважды щелкнуть файл StringLib.cs , вы также увидите исходный код.

Здесь вопрос заключается в том, как настроить метаданные, такие как версия, авторы и описание и т. Д.

Файл project.json используется в проектах .NET Core для определения метаданных проекта, информации о компиляции и зависимостей. Теперь давайте откроем файл project.json и добавим следующую дополнительную информацию.

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

Теперь вы можете увидеть дополнительную информацию, такую как имя автора, описание и версия, добавленные здесь. Давайте сохраним этот файл, создадим проект библиотеки, затем снова выполним команду «dotnet pack».

Внутри папки bin \ Debug вы можете видеть, что пакеты StringLibrary NuGet производятся с версией 1.0.1; давайте откроем его в NuGet Package Explorer.

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

Нам нужно начать с публикации где-нибудь в фиде NuGet, а затем использовать его в другом проекте.

Существует два варианта публикации обновленных метаданных:

Опубликуйте его на nuget.org
Передача метаданных в частный канал NuGet

Здесь мы будем использовать приватный канал NuGet, потому что это намного проще, чем настроить учетную запись на nuget.org. Чтобы узнать, как опубликовать ваш пакет на nuget.org, вы можете следовать всем рекомендациям, указанным здесь https://docs.microsoft.com/en-us/nuget/create-packages/publish-a-package .

Выполните следующие действия, чтобы отправить обновленные метаданные в частный канал NuGet.

Шаг 1 — Для начала нам нужна утилита командной строки nuget, и мы должны установить ее. Теперь давайте откроем менеджер пакетов NuGet и поищем nuget.commandline.

Шаг 2 — Выберите Nuget.Commandline и нажмите Установить .

Шаг 3 — Нажмите OK, чтобы установить Nuget.Commandline. Вы также можете установить его вручную, загрузив его со следующего URL-адреса https://dist.nuget.org/index.html и затем установив переменную среды.

Шаг 4 — После завершения установки, давайте снова откроем командную строку и перейдем в папку bin \ Debug, в которой находятся пакеты NuGet, и укажите следующую команду:

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

Шаг 5 — В приведенной выше команде мы добавляем пакет StringLibrary.1.0.1.nupkg в наш частный канал, и его местоположение — D: \ PrivateNugetPackages , -Source указывает источник пакета.

Шаг 6 — Вы можете видеть, что StringLibrary установлен; StringLibrary может быть дополнительно добавлен в приватный канал.

Шаг 7 — Давайте перейдем к этой папке.

Шаг 8 — Внутри папки stringlibrary вы увидите другую папку с именем версии и здесь она 1.0.1.

Пакет NuGet находится здесь.

Создание проекта Xamarin.Forms

В этой главе мы обсудим, как использовать пакет NuGet, который мы создали и опубликовали в частном фиде NuGet. Итак, сначала мы создадим проект Xamarin.Forms. Нам нужно сначала понять, что такое Xamarin.Forms.

Xamarin.Forms — это платформа, которая позволяет разработчикам быстро создавать кроссплатформенные пользовательские интерфейсы.
Xamarin.Forms — это кроссплатформенная абстракция инструментария пользовательского интерфейса с собственной поддержкой, которая позволяет разработчикам легко создавать пользовательские интерфейсы, которые могут использоваться в Android, iOS, Windows и Windows Phone.
Пользовательские интерфейсы отображаются с использованием встроенных элементов управления целевой платформы, что позволяет приложениям Xamarin.Forms сохранять соответствующий внешний вид для каждой платформы.

Xamarin.Forms — это платформа, которая позволяет разработчикам быстро создавать кроссплатформенные пользовательские интерфейсы.

Xamarin.Forms — это кроссплатформенная абстракция инструментария пользовательского интерфейса с собственной поддержкой, которая позволяет разработчикам легко создавать пользовательские интерфейсы, которые могут использоваться в Android, iOS, Windows и Windows Phone.

Пользовательские интерфейсы отображаются с использованием встроенных элементов управления целевой платформы, что позволяет приложениям Xamarin.Forms сохранять соответствующий внешний вид для каждой платформы.

Для запуска Xamarin.Forms нам понадобятся некоторые дополнительные функции в Visual Studio 2015. Давайте изменим вашу Visual Studio 2015 и убедимся, что выбран следующий вариант межплатформенной мобильной разработки.

После завершения установки давайте обновим Xamarin, выбрав Инструменты → Параметры …

Прокрутите вниз и разверните Xamarin на левой панели, а затем выберите Other . В правом верхнем углу диалогового окна нажмите « Проверить сейчас», чтобы узнать, доступны ли обновления.

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

Теперь давайте снова откроем Visual Studio и выберите пункт меню Файл → Создать → Проект… .

На левой панели выберите шаблон Visual C # → кроссплатформенный, а на средней панели выберите Пустое приложение Xaml (Xamarin.Forms Portable) . Введите имя в поле «Имя» и нажмите «ОК».

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

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

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

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

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

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

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

Вы увидите, что в разделе « Доступные источники пакетов» добавлен еще один флажок, давайте укажите имя и путь к источнику и нажмите « ОК» .

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

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

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

.NET Core — Устранение неполадок PCL

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

Мы в дальнейшем поймем проблему вкратце. Для начала, давайте щелкните правой кнопкой мыши на библиотеке PCL и выберите Свойства.

На этой странице вы увидите целую серию фреймворков. Из ошибки видно, что профиль .NETPortable 259 несовместим с нашей StringLibrary 1.0.1. Тем не менее, он пытается взять ссылку из библиотеки .NET Standard 1.1.

Давайте теперь посмотрим .NET Standard Library и определим, какая платформа не совместима с нашей библиотекой.

Вы можете видеть, что Windows Phone Silverlight 8 совместим с .NET Standard 1.0. Если вы откроете следующую веб-страницу, то увидите, что Profile259 может поддерживать только .NET Standard 1.0.

Давайте теперь снимем флажок Windows Phone Silverlight 8.

Нажмите кнопку ОК .

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

PM > Uninstall-Package Xamarin.Forms

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

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

Uncheck

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

Теперь вы можете видеть, что TargetFrameworkProfile теперь является Profile111.

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

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

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

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

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

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

.NET Core — создайте тестовый проект

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

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

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

.NET Core — выполнение тестов в Visual Studio

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

Давайте откроем решение FirstApp в Visual Studio.

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

Давайте сначала добавим папку и назовем ее тестовой .

Щелкните правой кнопкой мыши на тестовой папке.

Выберите файл project.json и нажмите « Открыть» .

На следующем снимке экрана показан код в файле 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 . Затем вы увидите testRunner, который запустит xunit, и вы также увидите среду netcoreapp1.0 .

Вы увидите зависимость .NETCore.App ниже.

Чтобы запустить тестирование в Visual Studio, давайте откроем Test Explorer из пункта меню Test → Window → Test Explorer .

И вы можете видеть, что Visual Studio автоматически обнаруживает тест. Имя теста состоит из namespace.className.TestMethodName . Теперь давайте нажмем кнопку « Запустить все» в Test Explorer .

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

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

Давайте выполним тест еще раз, нажав на ссылку Run All .

Теперь вы можете увидеть провал теста .

.NET Core — Библиотека тестирования

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

Давайте откроем файл global.json .

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

В верхней части этого файла вы увидите настройки проекта, и он по умолчанию настраивает некоторые папки, такие как src и test .

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

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

И структура проектов в обозревателе решений не показывает, где проекты физически существуют на диске. Давайте теперь откроем папку Solution и вы увидите, что проект StringLibrary не находится в папке src .

Вы можете видеть, что папки src и test отображаются в соответствии с соглашением, указанным в файле global.json . Тем не менее, у нас есть один проект StringLibrary, который выходит за рамки соглашения. Давайте теперь добавим проект StringLibrary внутри папки src .

В папке src у нас есть два проекта, и нам нужно исправить проблему, чтобы мы могли правильно использовать все проекты. Вернемся к Visual Studio, щелкните правой кнопкой мыши проект StringLibrary и выберите параметр «Удалить». Он не удалит его, но удалит только проект.

Теперь щелкните правой кнопкой мыши на папке src и выберите « Добавить» → «Существующий проект».

SRC

Перейдите к проекту StringLibrary, который сейчас находится в папке src , выберите файл StringLibrary.csproj и нажмите кнопку « Открыть» .

Теперь нам нужно удалить ссылку на StringLibrary из файла project.json консольного приложения.

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

Сохраните изменения и затем снова добавьте ссылку на StringLibrary в ваш консольный проект.

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

Теперь все должно работать снова, и вы можете собрать StringLibrary, а затем FirstApp (консольный проект) без каких-либо ошибок. Теперь давайте проверим функциональность StringLibrary с помощью xunit. Нам нужно добавить ссылку на StringLibrary в наш тестовый проект. Щелкните правой кнопкой мыши на проекте References of StringLibraryTests и выберите Add Reference…

Нажмите OK, чтобы добавить ссылку на StringLibrary в наш тестовый проект. Давайте теперь заменим следующий код в файле Tests.cs .

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

Вы можете видеть, что у нас есть три метода тестирования, которые будут проверять функциональность StringLibrary. Давайте перейдем по ссылке Run All, и вы увидите следующий вывод в Test Explorer.

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

Структура управляемой расширяемости

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

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

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.

На левой панели выберите Шаблоны → Visual C # → .NET Core, а затем на средней панели выберите Консольное приложение (.NET Core).

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

Как только проект создан, нам нужно добавить ссылку на Microsoft.Composition, чтобы мы могли использовать MEF. Для этого щелкните правой кнопкой мыши проект в Обозревателе решений и выберите Управление пакетами NuGet…

Найдите Microsoft.Composition и нажмите « Установить» .

Нажмите кнопку ОК .

Нажмите кнопку Я принимаю .

Когда установка завершится, вы найдете ошибку в списке литературы.

Давайте откроем файл 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 .

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

Введите имя для вашего класса в поле Имя и нажмите Добавить .

Давайте добавим следующий код в файл 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 — SDK

В этой главе мы поймем будущие возможности .NET Core. Мы начнем с инструментов командной строки .NET, открыв следующий URL в браузере https://github.com/dotnet/cli

Чтобы узнать больше о прогрессе, вы можете скачать последнюю версию .NET Core SDK, прокрутив вниз, и вы увидите раздел «Установщик и двоичные файлы».

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

Мы работаем над предварительным просмотром 1 .NET Core 2.0.

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

dotnet --info

Вы увидите информацию об установленной на данный момент версии .NET Command Line Tools в вашей системе, как показано ниже.

Вы можете видеть, что в настоящее время у нас есть предварительный просмотр 2 инструментов. Теперь давайте запустим следующую команду, чтобы узнать о новой команде.

dotnet help new

Для нового командного языка проекта, вы можете выбрать как C # и F # и тип проекта и т. Д.

Давайте теперь посмотрим на изменения в последней версии .NET Core. После загрузки установщика дважды щелкните его, чтобы установить. Нажмите на Установить.

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

Начнется процесс установки. После завершения установки закройте это диалоговое окно.

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

dotnet --info

Теперь вы можете видеть, что у нас есть предварительный инструментарий .NET Core 2. Теперь давайте запустим следующий код в командной строке, чтобы узнать о новой команде в .NET Core 2 preview1.

dotnet help new

Команда также помогает вам загружать пакеты в кеш пакетов.

Команда открывает следующую веб-страницу, которая содержит информацию о новой команде в .NET Core 2 preview1.

Давайте прокрутим вниз, теперь вы можете видеть, что мы можем создать приложение .NET Core с большим количеством шаблонов.

Теперь мы можем создавать проекты mstest, web, mvc и webapi, а также с помощью командной строки.

.NET Core — MSBuild и project.json

.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 и т. Д.

Это сделает переход существующих решений 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.

Файл 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 имеет открытый исходный код и доступен на GitHub и обязательно станет полностью кроссплатформенным.

MSBuild значительно упростит и урезает структуру * .csproj .

Microsoft также представляет новую систему проектов, которая позволит реализовать множество сценариев без необходимости использования Visual Studio, а подробности приведены по этому URL- адресу https://github.com/dotnet/roslyn-project-system/ .

Цель состоит в том, чтобы даже с установкой MSBuild работа со сборками и проектом в Visual Studio IDE была такой же эффективной, как и вне ее.

MSBuild vs project.json

Теперь давайте создадим новый консольный проект с инструментарием .NET Core preview2, выполнив следующую команду.

dotnet new -t console

Чтобы увидеть все файлы, созданные в этом проекте, выполните команду dir .

Run Dir

Вы можете видеть, что созданы два файла, Program.cs и файл project.json .

Теперь давайте создадим консольное приложение с инструментарием .NET Core 2 preview1, выполнив следующую команду.

dotnet new console

Чтобы увидеть все файлы, созданные в этом проекте, выполните команду dir . Вы можете видеть, что вместо файла project.json создаются три файла: Program.cs, NuGet.config и MSBuild.csproj .

Давайте теперь сравним файлы project.json и MSBuild.csproj рядом друг с другом.

Слева у нас есть файл в формате json, а справа — в формате XML. Вы можете видеть, что в файле project.json внутри раздела зависимостей есть netcoreapp1.0 , а в файле MSBuild.csproj вы увидите netcoreapp2.0 .

Восстановление и сборка с MSBuild

В этой главе мы обсудим, как восстановить и собрать файл MSBuild (* .csproj) с помощью утилиты командной строки. Чтобы увидеть, какие команды доступны в .NET Core 2.0 preview 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

Вы можете увидеть следующий вывод на вашей консоли.

.NET Core — Миграции

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

MSBuild

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

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

.NET Core — Обзор

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

Открытый исходный код

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

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

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

совместимый

модульная

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

.NET Core — Необходимые условия

Поддерживаемые версии Windows

зависимости

Предварительные условия с Visual Studio

.NET Core — Настройка среды

Visual Studio 2015

Установка Visual Studio 2015

Visual Studio 2017

.NET Core — Начало работы

.NET Core — Числовые

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

Типы с плавающей точкой

BigInteger

Сложный

SIMD

.NET Core — Сборка мусора

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

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

Поколения

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

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

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

.NET Core — выполнение кода

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

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

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

Запуск кода

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

.NET Core — Модульность

.NET Core — Файлы проекта

.NET Core — ссылки на пакеты

.NET Core — создание приложения UWP

.NET Core — MSBuild

.NET Core — метапакет

Windows Runtime и расширение SDK

.NET Core — Создание стандартной библиотеки .NET

.NET Core — Портативная библиотека классов

Что такое PCL

.NET Core — Добавление ссылок на библиотеку

.NET Core — совместное использование библиотек

Создание проекта Xamarin.Forms

.NET Core — Устранение неполадок PCL

.NET Core — создайте тестовый проект

.NET Core — выполнение тестов в Visual Studio

.NET Core — Библиотека тестирования

Структура управляемой расширяемости

.NET Core — SDK

.NET Core — MSBuild и project.json

Преимущества MSBuild

MSBuild vs project.json

Восстановление и сборка с MSBuild

.NET Core — Миграции

Популярные уроки и статьи

Инициализаторы экземпляра в Java объяснены

AJAX - Краткое руководство

TempDB для производительности