.NET Core теперь доступен для Raspberry Pi

Оглавление (нажмите, чтобы открыть):

Using .NET Core on a Raspberry Pi

By seb , in Programming, april 26,2020.

A few weeks ago, in our post on .NET Core and NuGet, we promised you a post on how to use these two technologies on a Raspberry Pi. So we keep our promise and this week we look at how to write a .NET Core application under Windows and how to deploy it on a Raspberry Pi.

The application we are implementing is rather simple. We display the current value of a Yoctopuce sensor on a Yocto-MaxiDisplay. We start by developing and testing this application under Windows, and then we install this application on a Raspberry Pi.

Visual Studio 2020

As Microsoft has just released version 2020 of Visual Studio, we are using this version, but the process in the same for versions 2020 and 2015.

So we start by creating a new Console APP (.NET Core) project.

We must create a Console APP (.NET Core) project

Then, we must add a dependency to our NuGet package.

We must add a dependency to our Nuget package

The code

We are not going to linger on the application code as it is trivial, and we already have several posts explaining in details the functions that we use.

When starting, the code checks that there is a Yoctopuce sensor. The code checks for the presence of a Yocto-Display, a Yocto-MaxiDisplay, or a Yocto-MiniDisplay as well. Then, as long as these two modules are connected, we retrieve the value and the name of the sensor, and we display these two pieces of information on the Yocto-MaxiDisplay.

static void Main ( string [ ] args )
Console . WriteLine ( «Using Yoctopuce lib » + YAPI . GetAPIVersion ( ) ) ;
string errsmg = «» ;
if ( YAPI . RegisterHub ( «usb» , ref errsmg ) != YAPI . SUCCESS )
Console . WriteLine ( «Unable to register the USB port :» + errsmg ) ;
return ;

YSensor sensor = YSensor . FirstSensor ( ) ;
if ( sensor == null )
Console . WriteLine ( «No Yoctopuce sensor find on USB.» ) ;
return ;

YDisplay display = YDisplay . FirstDisplay ( ) ;
if ( display == null )
Console . WriteLine ( «No Yoctopuce display find on USB.» ) ;
return ;

// display clean up
display . resetAll ( ) ;

YDisplayLayer l1 = display . get_displayLayer ( 1 ) ;
l1 . hide ( ) ; // L1 is hidden, l2 stay visible
int w = display . get_displayWidth ( ) ;
int h = display . get_displayHeight ( ) ;

while ( sensor . isOnline ( ) && display . isOnline ( ) )
string value = sensor . get_currentValue ( ) + » » + sensor . get_unit ( ) ;
string name = sensor . get_friendlyName ( ) ;
// display a text in the middle of the screen
l1 . clear ( ) ;
l1 . selectFont ( «Large.yfm» ) ;
l1 . drawText ( w / 2 , h / 2 , YDisplayLayer . ALIGN . CENTER , value ) ;
l1 . selectFont ( «Small.yfm» ) ;
l1 . drawText ( w — 1 , h — 1 , YDisplayLayer . ALIGN . BOTTOM_RIGHT , name ) ;
display . swapLayerContent ( 0 , 1 ) ;
Console . WriteLine ( name + » ->» + value ) ;
YAPI . Sleep ( 500 , ref errsmg ) ;
YAPI . FreeAPI ( ) ;

This example is rather primitive but it illustrates quite well how to use our library. The complete project is available on GitHub: https://github.com/yoctopuce-examples/YoctoDotNetCore

Now that our project is ready, we can test our application under Windows. To do so, we naturally need to connect a Yocto-Display and a Yoctopuce sensor. In this instance, we used a Yocto-Light-V3 and a Yocto-MaxiDisplay-G.

Now that we tested that our code works under Windows, let’s see how to run the same application on a Raspberry Pi.

Generating a version for Raspberry Pi

Since version 2.1 of .NET Core, we can generate an «executable» which works under Linux ARM. We can even generate a «self-contained» executable containing our application and the .NET virtual machine.

The advantage of this latter option is that it allows us to include everything that is required for the application to work, which makes its installation easier.

To generate the «Raspberry Pi» version, we must «publish» our application. We can access the wizard from the «build» menu in Visual Studio.

The build menu enables us to publish the application

This menu allows us to configure the type of package that we are publishing. In our case, we must create a profile of type «Folder». Then, we must edit this profile to select the following options:

  • Target Framework: minimally netcoreapp2.1
  • Deployment Mode: Self-contained
  • Target Runtime: linux-arm

The publication parameters of the application

We then only need to click on the Publish button for Visual Studio to compile the application and copy all the required files in the output directory.

When the compilation is done, we can copy the whole content of the directory on the Raspberry Pi 3. We can use SSH, FTP, or a simple USB key.

Running the application on Raspberry Pi

When the directory has been copied on the Raspberry Pi, there is one last operation which needs to be performed: adding execution privileges to the application. We must perform this last operation directly on the Raspberry Pi.

We simply use the chmod command with +x and the executable as parameter.

/publish $ chmod +x YoctoCoreDemo

Then, we can directly run the application without having the install anything else.

/publish $ sudo ./YoctoCoreDemo .

We don’t need a Mono package or Runtime .NET, everything is included in the application. We can use the application directly on a Raspbian image.

Here we are, we have our application working under Raspberry Pi.

The same application running on a Raspberry Pi


As we just saw it, it is very easy to port a .NET Core application on Raspberry Pi. To be able to develop the application under Windows and then to deploy it on Raspberry Pi standard image is very convenient. It makes it as easy, if not easier, than to write a Python script.

We must however remember a few things.

Only Raspberry Pi 2, 3, and 3+ are supported by .NET Core. Currently, using a Raspberry Pi Zero is not possible.

At the time of writing, you can’t create portable graphical application with .NET Core. If you need to implement a graphical application, it’s possible but you must necessarily use Mono. By the way, we have a post on this topic: Using the C# library on Linux and macOS with Mono.

We used Visual Studio to implement this example, but you could also create and compile the same application under Linux and macOS by installing the .NET Core SDK on these OSes. You must then use the dotnet tool.

Finally, if you are not familiar with Linux, we published a few posts which might interest you:

Carlos Mendible

After reading .NET Core on Raspberry Pi and successfully running a console application on Windows 10 IoT Core on my Raspberry Pi 3 I decided to write: Step by step: Running ASP.NET Core on Raspberry Pi.

First be aware of the following prerequisites:

  • Windows 10 IoT Core I’m running Insider Preview v.10.0.15058.0
  • .NET Core 2.0 SDK

1. Create a folder for your new project

Open a command prompt an run

2. Create a global.json file

To specify the correct sdk create a global.json with the following contents

3. Create the ASP.NET Core project

Create the ASP.NET Core project with the following command:

4. Modify the project file

Modify the aspnet.on.rpi.csproj to add the correct OutputType, TargetFramework, RuntimeFrameworkVersionand Runtime >

5. Add a Nuget.config file and restore packages

Create a Nuget.config file with the following contents:

Now restore the packages:

6. Modify Program.cs

Replace the contents of the Program.cs file with the following code

7. Publish the application

Publish the application with the following commands

We need to publish for win7-arm as a workaround to copy the correct libuv.dll in the next step.

Copy libuv.dll

Copy libuv.dll from \aspnet.on.rpi\bin\Debug\netcoreapp2.0\win7-arm\publish to \aspnet.on.rpi\bin\Debug\netcoreapp2.0\win8-arm\publish

This step is no longer needed cause we added libuv as a dependency in the csproj file

9. Copy the files to your Raspberry

Connect to Raspberry using PowerShell, start the ftp server and open port 5000 on the Raspberry

Open the File Explorer ftp:// and copy the contents of **\aspnet.on.rpi\bin\Debug\netcoreapp2.0\win8-arm\publish** to a folder on your Raspberry (i.e. c:\publish).

10. Run the application

Connect to Raspberry using PowerShell and run

You should be good to go and be able to browse on port 5000 of you RPi.

Можно ли запустить .NET Core на Raspberry PI?

Я слышал, что .NET Core может работать на Linux и Mac. В настоящее время я использую Mono на Raspberry PI. Возможно ли или будет возможно запустить .NET Core на Raspberry PI?

6 ответов

Мне удалось запустить приложение .NET Core 2 на Raspberry PI 3 с помощью Raspbian.

На моем ноутбуке:

На Raspberry PI 3 с Raspbian:

Запустите sudo apt-get install libc6 libcurl3 libgcc1 libgssapi-krb5-2 libicu52 liblttng-ust0 libssl1.0.0 libstdc++6 libunwind8 libuuid1 zlib1g

Затем скопируйте ./bin/Debug/netcoreapp2.0/linux-arm/publish с моего ноутбука

[ helloworld разрешения helloworld ]

Теперь вы можете запустить ядро dotnet на Raspberry PI. Для этого вам необходимо:

  1. Кросс-компиляция coreclr & corefx (возможно на Linux x64)
  2. Извлеките dll без закрытых и предварительно скомпилированных файлов в PI
  3. Скопируйте управляемые dll вашего приложения на PI
  4. Используйте исполняемый файл corerun для запуска вашего приложения

Если вы хотите пропустить вышеизложенное и получить готовые двоичные файлы для Raspberry PI 3 (или даже всего образа), вы можете использовать мою скомпилированную сборку по адресу:

Примечание: я смог сделать это на Raspberry PI 3, используя Headless Ubuntu Server 16.04 и Ubuntu Mate 16.04. Я предполагаю, что дополнительные шаги (то есть установка дополнительных пакетов) необходимо выполнить на Raspbian OS и PI 2.

Ссылки для кросс-компиляции (на машине с Ubuntu 16.04 x64):

Видео, которое я сделал с «как» получить двоичные файлы (включая наше приложение):

Сейчас или скоро это станет возможным, потому что Microsoft анонсировала CoreCLR на GitHub .

Сегодня .NET Core собирается и работает на Windows. В течение следующих нескольких месяцев мы будем добавлять реализации для компонентов платформы для Linux и Mac. У нас уже есть некоторый специфичный для Linux код в .NET Core, но мы действительно только начинаем работать с нашими портами. Сначала мы хотели открыть код, чтобы мы могли с самого начала наслаждаться кросс-платформенным путешествием.

.NET Core теперь доступен для Raspberry Pi

14817 просмотра

6 ответа

9574 Репутация автора

Я слышал, что .NET Core может работать на Linux и Mac. В настоящее время я использую Mono на Raspberry PI. Возможно ли или будет возможно запустить .NET Core на Raspberry PI?

Ответы (6)

3 плюса

7028 Репутация автора

Microsoft сделала доступным исходный код для .NET Core. Для реальной реализации Linux или других версий, отличных от Windows, вы, скорее всего, по-прежнему будете использовать Mono или один из продуктов Xamarin. Поскольку они содержат более широкую поддержку, чем просто основные функции. Xamarin берет основной источник .NET и использует его для исправления дыр и ошибок в своей реализации .NET. Microsoft также делает Visual Studio Mono / Xamarin дружественной, и она будет поставляться с пробным / базовым продуктом Xamarin для мобильной разработки в еще не выпущенной версии VS.

Edit -> Кроме того, похоже, что Microsoft делает бесплатную версию Windows 10 для платы. который также запустит .Net.

7 плюса

494 Репутация автора

Сейчас или скоро это станет возможным, потому что Microsoft анонсировала CoreCLR на GitHub .

Сегодня .NET Core собирается и работает на Windows. Мы добавим в Linux и Mac реализации платформенных компонентов в течение следующих нескольких месяцев. У нас уже есть некоторый специфичный для Linux код в .NET Core, но мы действительно только начинаем работать с нашими портами. Сначала мы хотели открыть код, чтобы мы могли с самого начала наслаждаться кроссплатформенным путешествием.

1 плюс

40121 Репутация автора

Возможно ли или будет возможно запустить .NET Core на Raspberry PI?

Еще не AFAIK, но в CoreCLR есть код, по крайней мере, для некоторых версий архитектуры ARM. Raspberry Pi 2 была бы лучшей ставкой.

6 плюса

73 Репутация автора

Я сделал бы комментарий, но так как я не могу, я публикую в качестве ответа, и я думаю, что принятый ответ должен быть обновлен. Как это возможно сейчас, так как это проверено в coreclr https://github.com/dotnet/coreclr/pull / 1210

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

8 плюса

365 Репутация автора

Теперь вы можете запустить ядро ​​dotnet на Raspberry PI. Для этого вам необходимо:

  1. Кросс-компиляция coreclr & corefx (возможно на Linux x64)
  2. Распакуйте dll без приватных и предварительно скомпилированных файлов на PI
  3. Скопируйте управляемые dll вашего приложения на PI
  4. Используйте исполняемый файл corerun для запуска вашего приложения

Если вы хотите пропустить вышеизложенное и получить готовые двоичные файлы для Raspberry PI 3 (или даже всего образа), вы можете использовать мою скомпилированную сборку по адресу:

Примечание: я смог сделать это на Raspberry PI 3, используя Headless Ubuntu Server 16.04 и Ubuntu Mate 16.04. Я предполагаю, что дополнительные шаги (т.е. установка дополнительных пакетов) необходимо выполнить в Raspbian OS и PI 2.

Ссылки для кросс-компиляции (на машине с Ubuntu 16.04 x64):

Видео, которое я сделал с «как» получить двоичные файлы (включая наше приложение):

Автор: Adi Размещён: 11.12.2020 11:35

14 плюса

9574 Репутация автора

Мне удалось запустить приложение .NET Core 2 на Raspberry PI 3 с помощью Raspbian.

На моем ноутбуке:

На Raspberry PI 3 с Raspbian:

Бежать sudo apt-get install libc6 libcurl3 libgcc1 libgssapi-krb5-2 libicu52 liblttng-ust0 libssl1.0.0 libstdc++6 libunwind8 libuuid1 zlib1g

Затем скопируйте ./bin/Debug/netcoreapp2.0/linux-arm/publish с моего ноутбука

Installing .Netcore on a Raspberry Pi 3

I wanted to use my Raspberry Pi 3 to host a .Netcore WebApi as now Microsoft turned their framework open-source. But my journey to a .netcore Pi was not as straightforward as what I first thought… So here is a small “how to” that you can use if you want to achieve the same in less time.

Install Raspbian

This step is pretty easy and that’s why I will lead you directly to the official documentation which contains everything you would need to install you PI https://www.raspberrypi.org/downloads/raspbian/

Install .netcore

First, we’ll need to find the build of dotnet core we want to install. You’ll find on the following github page a table of release and OS : https://github.com/dotnet/core-setup#daily-builds

Choose the one you need, and copy the link of the tar.gz release for the next step.

Hint : The Raspberry Pi 3 was built with a x64 processor but still has a 32bit architecture. You’ll then want to use the “Linux (armhf)(for glibc based OS)” version of the package.

Now that we have the package, we’ll need to download it. Open your terminal and fetch the package via curl with this single command :

Now we need to create the destination folder where you will copy the dotnet runtime :

sudo mkdir -p /opt/dotnet

The previously downloaded package should now be extracted to this new folder:

sudo tar zxf dotnet.tar.gz -C /opt/dotnet

Nice, we have now the dotnet runtime on our Pi. But as you may have noticed, we still don’t have any dotnet cmd recognized by the system. What is missing is a link to the dotnet cli in the local/bin folder to be able to access it from every folder:

sudo ln -s /opt/dotnet/dotnet /usr/local/bin

Now you should be able to run a simple command to test the installed runtime :

If you get an error there, it’s probably because you choosed a wrong architecture. In that case, delete the /opt/dotnet folder, and start again this chapter.

Note: As we’ve installed the runtime and not the sdk, you’ll only have access to some commands and not to all the development features like :

As of today the development tools are not available yet. You will need to develop and build on your Windows|MacOS machine, and then install the builded application on your Pi.

Now you have dotnetcore on your Pi. If you want to run console application, go on. But if you wan’t to expose a WebApi, you’ll need some other stuff. This will be covered in a next article.

Creating an ASP.NET Core application for Raspberry Pi

As a part of the Wren Hyperion solution, an ASP.NET Core application will run on an ARM based Linux OS (we are building a POC for the Raspberry Pi and Raspian). Here are the steps on how you can get started with ASP.NET Core on Raspian:

  • Setup a Raspberry Pi with Raspian
  • Install .NET Core
  • Create your ASP.NET Core solution
  • Publish to the Raspberry Pi
  • Install .NET Core to the Raspberry Pi
  • Run your application on the Raspberry Pi

Setup a Raspberry Pi with Raspian

Follow the guides on the Raspberry Pi website to install Raspian on your Pi.

Install .NET Core

Download and Install

To start building .NET apps you just need to download and install the .NET SDK (Software Development Kit) for Windows.

Video: Creating a Simple .NET Application on Windows

Get an editor

Visual Studio is a fully-featured integrated development environment (IDE) for developing .NET apps on Windows.

Select the .NET Core cross-platform development workload during installation:

More info

While you wait for Visual Studio to install, you can keep learning with the .NET Quick Starts. In the first Quick Start you’ll learn about collections.

Once Visual Studio is installed, come back and build your first .NET app using Visual Studio.

Create your ASP.NET Core Solution

Create a new .NET Core project.

On macOS and Linux, open a terminal window. On Windows, open a command prompt.

Browse to http://localhost:5000/About and verify the changes.

Publish to the Raspberry Pi

Install .NET Core to the Raspberry Pi

The following commands need to be run on the Raspberry Pi whilst connected over an SSH session or via a terminal in the PIXEL desktop environment.

  • Run sudo apt-get install curl libunwind8 gettext. This will use the apt-get package manager to install three prerequiste packages.
  • Run curl -sSL -o dotnet.tar.gz https://dotnetcli.blob.core.windows.net/dotnet/Runtime/release/2.0.0/dotnet-runtime-latest-linux-arm.tar.gz to download the latest .NET Core Runtime for ARM32. This is refereed to as armhf on the Daily Builds page.
  • Run sudo mkdir -p /opt/dotnet && sudo tar zxf dotnet.tar.gz -C /opt/dotnet to create a destination folder and extract the downloaded package into it.
  • Run sudo ln -s /opt/dotnet/dotnet /usr/local/bin` to set up a symbolic link…a shortcut to you Windows folks �� to the dotnet executable.
  • Test the installation by typing dotnet –help.
  • Try to create a new .NET Core project by typing dotnet new console. Note this will prompt you to install the .NET Core SDK however this link won’t work for Raspian on ARM32. This is expected behaviour.

Run your application on the Raspberry Pi

Finally to run your application on the Raspberry Pi, navigate to the folder where the application was published and run the following command:

Новые возможности .NET Core 3.0 What’s new in .NET Core 3.0

В этой статье описываются новые возможности в .NET Core 3.0. This article describes what is new in .NET Core 3.0. Одно из основных усовершенствований — это поддержка классических приложений Windows (только Windows). One of the biggest enhancements is support for Windows desktop applications (Windows only). С помощью пакета SDK для .NET Core 3.0 под названием Windows Desktop можно переносить приложения Windows Forms и Windows Presentation Foundation (WPF). By using the .NET Core 3.0 SDK component Windows Desktop, you can port your Windows Forms and Windows Presentation Foundation (WPF) applications. Следует уточнить, что компонент Windows Desktop поддерживается и включен только в Windows. To be clear, the Windows Desktop component is only supported and included on Windows. Дополнительные сведения см. далее в этой статье, в разделе Рабочий стол Windows. For more information, see the Windows desktop section later in this article.

Мастер Йода рекомендует:  Законопроекты о штрафах за фейковые новости и оскорбление властей в Сети прошли первое чтение

В .NET Core 3.0 добавлена поддержка C# 8.0. .NET Core 3.0 adds support for C# 8.0. Настоятельно рекомендуется использовать Visual Studio 2020 версии 16.3 или более поздней, Visual Studio для Mac 8.3 или более поздней или Visual Studio Code с последним расширением C# . It’s highly recommended that you use Visual Studio 2020 version 16.3 or newer, Visual Studio for Mac 8.3 or newer, or Visual Studio Code with the latest C# extension.

Скачайте .NET Core 3.0 и начните работу прямо сейчас в Windows, macOS или Linux. Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Дополнительные сведения см. в объявлении о выпуске .NET Core 3.0. For more information about the release, see the .NET Core 3.0 announcement.

Релиз-кандидат 1 .NET Core считался корпорацией Майкрософт готовым к эксплуатации и полностью поддерживался. .NET Core RC1 was considered production ready by Microsoft and was fully supported. Если вы используете предварительную версию, необходимо перейти на версию RTM, чтобы продолжать получать поддержку. If you’re using a preview release, you must move to the RTM version for continued support.

Установщик пакета SDK Windows для .NET Core .NET Core SDK Windows Installer

Начиная с .NET Core 3.0, установщик MSI для Windows был изменен. The MSI installer for Windows has changed starting with .NET Core 3.0. Установщики пакетов SDK теперь обновляют дополнительные пакеты функций SDK на месте. The SDK installers will now upgrade SDK feature-band releases in place. Пакеты функций определяют сотни в обозначении исправления в номере версии. Feature bands are defined in the hundreds groups in the patch section of the version number. Например, в версиях 3.0.101 и 3.0.201 пакеты функций различаются, а в версиях 3.0.101 и 3.0.199 — одинаковы. For example, 3.0.101 and 3.0.201 are versions in two different feature bands while 3.0.101 and 3.0.199 are in the same feature band. При установке пакета SDK для .NET Core 3.0.101 пакет SDK для .NET Core 3.0.100 , если он есть на компьютере, удаляется. And, when .NET Core SDK 3.0.101 is installed, .NET Core SDK 3.0.100 will be removed from the machine if it exists. Когда на тот же компьютер устанавливается пакет SDK для .NET Core 3.0.200 , пакет SDK для .NET Core 3.0.101 удаляться не будет. When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won’t be removed.

Дополнительные сведения об управлении версиями см. в разделе Общие сведения об управлении версиями в .NET Core. For more information about versioning, see Overview of how .NET Core is versioned.

C# 8.0 C# 8.0

В этот выпуск также входит версия языка C# 8.0, в которой появились ссылочные типы, допускающие значение NULL, асинхронные потоки и другие возможности. C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Дополнительные сведения о функциях C# 8.0 см. в разделе Новые возможности C# 8.0. For more information about C# 8.0 features, see What’s new in C# 8.0.

.NET Standard 2.1 .NET Standard 2.1

Несмотря на то что .NET Core 3.0 поддерживает .NET Standard 2.1, шаблон dotnet new classlib по умолчанию по-прежнему создает проект, предназначенный для .NET Standard 2.0. Even though .NET Core 3.0 supports .NET Standard 2.1, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Чтобы создать проект для .NET Standard 2.1, откройте файл проекта и измените значение свойства TargetFramework на netstandard2.1 : To target .NET Standard 2.1, edit your project file and change the TargetFramework property to netstandard2.1 :

Если вы используете Visual Studio, у вас должна быть версия Visual Studio 2020, так как Visual Studio 2020 не поддерживает .NET Standard 2.1 или .NET Core 3.0. If you’re using Visual Studio, you need Visual Studio 2020, as Visual Studio 2020 doesn’t support .NET Standard 2.1 or .NET Core 3.0.

Улучшенные API версий .NET Core Improved .NET Core Version APIs

Начиная с .NET Core 3.0, API версий, предоставляемые с .NET Core, возвращают те данные, которые должны. Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Например: For example:

Критическое изменение. Breaking change. С технической точки зрения это изменение является критическим, поскольку изменилась схема управления версиями. This is technically a breaking change because the versioning scheme has changed.

Встроенные объекты, зависимые от платформы .NET .NET Platform-Dependent Intrinsics

Были добавлены API-интерфейсы, которые разрешают доступ к определенным инструкциям ЦП, ориентированным на производительность, например SIMD или наборы инструкций побитовой обработки. APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Эти инструкции помогут значительно улучшить производительность в некоторых сценариях, таких как эффективная параллельная обработка данных. These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

Там, где это возможно, библиотеки .NET начали использовать эти инструкции для повышения производительности. Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Исполняемые файлы по умолчанию Default executables

.NET Core теперь по умолчанию собирает исполняемые файлы, зависимые от платформы. .NET Core now builds framework-dependent executables by default. Такое поведение ново для приложений, которые используют глобально установленную версию .NET Core. This behavior is new for applications that use a globally installed version of .NET Core. Раньше исполняемые файлы создавались только в автономных развертываниях. Previously, only self-contained deployments would produce an executable.

Во время выполнения команды dotnet build или dotnet publish создается исполняемый файл, который соответствует среде и платформе используемого пакета SDK. During dotnet build or dotnet publish , an executable is created that matches the environment and platform of the SDK you’re using. Предполагается, что с этими исполняемыми файлами можно выполнять те же действия, что и с другими исполняемыми файлами в машинном коде, например: You can expect the same things with these executables as you would other native executables, such as:

  • исполняемый файл можно дважды щелкнуть; You can double-click on the executable.
  • приложение можно запустить из командной строки напрямую, например myapp.exe в Windows и ./myapp в Linux и macOS. You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Однофайловые исполняемые файлы Single-file executables

Команда dotnet publish поддерживает упаковку приложения в однофайловый исполняемый файл для конкретной платформы. The dotnet publish command supports packaging your app into a platform-specific single-file executable. Исполняемый файл является самоизвлекаемым и содержит все зависимости (включая машинные), необходимые для запуска приложения. The executable is self-extracting and contains all dependencies (including native) that are required to run your app. При первом запуске приложение извлекается в каталог, который зависит от имени и идентификатора сборки приложения. When the app is first run, the application is extracted to a directory based on the app name and build identifier. Впоследствии запуск происходит быстрее. Startup is faster when the application is run again. Если версия не изменилась, приложению не нужно извлекать себя заново. The application doesn’t need to extract itself a second time unless a new version was used.

Чтобы опубликовать однофайловый исполняемый файл, задайте PublishSingleFile в своем проекте или в командной строке с помощью команды dotnet publish : To publish a single-file executable, set the PublishSingleFile in your project or on the command line with the dotnet publish command:

Дополнительные сведения о публикации однофайловых исполняемых файлов см. в документе о разработке однофайловых пакетных установщиков. For more information about single-file publishing, see the single-file bundler design document.

Связывание сборок Assembly linking

Пакет SDK для .NET Core 3.0 содержит инструмент, который позволяет уменьшить размер приложения, анализируя промежуточный язык и устраняя неиспользуемые сборки. The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Автономные приложения включают все необходимое для выполнения кода. Это позволяет не устанавливать .NET на соответствующем компьютере. Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Но во многих случаях для работы приложения достаточно небольшого набора функций платформы, а все неиспользуемые библиотеки можно удалить. However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

Теперь .NET Core предоставляет параметр, который позволяет использовать компоновщик IL для сканирования кода приложения на промежуточном языке. .NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Это средство отслеживает необходимый код, а затем удаляет все неиспользуемые библиотеки. This tool detects what code is required, and then trims unused libraries. Это позволяет значительно снизить размер развертывания для некоторых приложений. This tool can significantly reduce the deployment size of some apps.

Чтобы включить этот инструмент, укажите в проекте параметр

и опубликуйте автономное приложение: To enable this tool, add the

setting in your project and publish a self-contained app:

Например, простейший шаблон консольного приложения hello world, который входит в стандартную поставку, при публикации достигает размера около 70 МБ. As an example, the basic «hello world» new console project template that is included, when published, hits about 70 MB in size. С помощью

этот размер можно снизить до 30 МБ. By using

, that size is reduced to about 30 MB.

Важно учитывать, что приложения и платформы (в том числе ASP.NET Core и WPF), которые используют отражение или связанные динамические функции, могут стать неработоспособными после обрезки. It’s important to consider that applications or frameworks (including ASP.NET Core and WPF) that use reflection or related dynamic features, will often break when trimmed. Такие нарушения возникают потому, что компоновщик ничего не знает о динамическом поведении и не может определить, какие типы платформы потребуются для отражения. This breakage occurs because the linker doesn’t know about this dynamic behavior and can’t determine which framework types are required for reflection. Но вы можете настроить компоновщик IL так, чтобы он учитывал этот сценарий. The IL Linker tool can be configured to be aware of this scenario.

В любом случае обязательно протестируйте приложение после обрезки. Above all else, be sure to test your app after trimming.

Дополнительные сведения о компоновщике IL вы найдете в этой документации или на страницах репозитория mono/linker. For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Многоуровневая компиляция Tiered compilation

Многоуровневая компиляция (МК) по умолчанию входит только в .NET Core 3.0. Tiered compilation (TC) is on by default with .NET Core 3.0. Эта функция позволяет среде выполнения более адаптивно использовать компилятор JIT для повышения производительности. This feature enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance.

Основное преимущество МК состоит в том, что с ее помощью можно использовать методы JIT и выбирать более простой и при этом более медленный код или более сложный код, который лучше работает. The main benefit of TC is to enable (re-)jitting methods with a lower-quality-but-faster tier or a higher-quality-but-slower tier. Это позволяет повысить производительность приложения на разных этапах его выполнения, с первого запуска и до достижения стабильной работы. This helps increase performance of an application as it goes through various stages of execution, from startup through steady-state. Если же МК не используется, каждый метод компилируется одним и тем же способом (как уровень высокого качества), который опирается на стабильную работу после запуска. This contrasts with the non-TC approach, where every method is compiled a single way (the same as the high-quality tier), which is biased to steady-state over startup performance.

Чтобы включить быстрый JIT (код JIT уровня 0), добавьте в файл проекта следующий параметр: To enable Quick JIT (tier 0 jitted code), use this setting in your project file:

Чтобы полностью отключить МК, добавьте в файл проекта следующий параметр: To disable TC completely, use this setting in your project file:

Образы ReadyToRun ReadyToRun images

Вы можете снизить время запуска приложения .NET Core, скомпилировав все сборки приложения в формат ReadyToRun (R2R). You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R является разновидностью компиляции AOT. R2R is a form of ahead-of-time (AOT) compilation.

Бинарные файлы R2R повышают производительность при запуске, снижая объем работы, выполняемой на этом этапе компилятором JIT. R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Бинарные файлы содержат такой же машинный код, который создается компилятором JIT. The binaries contain similar native code compared to what the JIT would produce. Но бинарные файлы R2R имеют больший размер, так как содержат не только код на промежуточном языке (IL), который по-прежнему необходим для некоторых сценариев, но и версию того же кода на машинном языке. However, R2R binaries are larger because they contain both intermediate language (IL) code, which is still needed for some scenarios, and the native version of the same code. Функция R2R доступна только при публикации автономного приложения, предназначенного для конкретной среды выполнения (RID), например для Windows x64 или Linux x64. R2R is only available when you publish a self-contained app that targets specific runtime environments (RID) such as Linux x64 or Windows x64.

Чтобы скомпилировать проект как ReadyToRun, выполните следующие действия: To compile your project as ReadyToRun, do the following:

Добавьте в проект параметр

setting to your project

Опубликуйте автономное приложение. Publish a self-contained app. Например, такая команда создает автономное приложение для 64-разрядной версии Windows: For example, this command creates a self-contained app for the 64-bit version of Windows:

Ограничения при работе с несколькими платформами и архитектурами Cross platform/architecture restrictions

Компилятор ReadyToRun пока не поддерживает перекрестное нацеливание. The ReadyToRun compiler doesn’t currently support cross-targeting. Компиляцию необходимо выполнять в конкретной целевой среде. You must compile on a given target. Например, если вам нужен образ R2R для 64-разрядной ОС Windows, команду публикации следует выполнять именно в этой среде. For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Исключения для кроссплатформенного таргетирования: Exceptions to cross-targeting:

  • можно использовать Windows x64 для компиляции образов Windows ARM32, ARM64 и x86; Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • можно использовать Windows x86 для компиляции образов Windows ARM32; Windows x86 can be used to compile Windows ARM32 images.
  • можно использовать Linux x64 для компиляции образов Linux ARM32 и ARM64. Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Сборка копирует зависимости Build copies dependencies

Команда dotnet build копирует зависимости NuGet для вашего приложения из кэша NuGet в выходную папку сборки. The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Ранее зависимости копировались только в рамках выполнения команды dotnet publish . Previously, dependencies were only copied as part of dotnet publish .

Для некоторых операций, таких как связывание и публикация страницы Razor, по-прежнему будет требоваться публикация. There are some operations, like linking and razor page publishing that will still require publishing.

Локальные средства Local tools

В .NET Core 3.0 появились локальные средства. .NET Core 3.0 introduces local tools. Локальные средства похожи на глобальные средства, но связаны с определенным расположением на диске. Local tools are similar to global tools but are associated with a particular location on disk. Локальные средства недоступны глобально и распространяются в виде пакетов NuGet. Local tools aren’t available globally and are distributed as NuGet packages.

Если вы пробовали использовать локальные средства в предварительной версии 1 .NET Core 3.0, например запуск dotnet tool restore или dotnet tool install , удалите папку кэша локальных средств. If you tried local tools in .NET Core 3.0 Preview 1, such as running dotnet tool restore or dotnet tool install , delete the local tools cache folder. В противном случае локальные средства не будут работать ни в одной более новой версии. Otherwise, local tools won’t work on any newer release. Эта папка находится по адресу: This folder is located at:

В macOS, Linux: rm -r $HOME/.dotnet/toolResolverCache On macOS, Linux: rm -r $HOME/.dotnet/toolResolverCache

В Windows: rmdir /s %USERPROFILE%\.dotnet\toolResolverCache On Windows: rmdir /s %USERPROFILE%\.dotnet\toolResolverCache

Локальные средства используют имя файла манифеста dotnet-tools.json в текущем каталоге. Local tools rely on a manifest file name dotnet-tools.json in your current directory. Этот файл манифеста определяет, какие средства доступны в этой папке и далее. This manifest file defines the tools to be available at that folder and below. Файл манифеста можно распространять вместе с кодом, чтобы те же средства мог восстановить и использовать любой, кто работает с вашим кодом. You can distribute the manifest file with your code to ensure that anyone who works with your code can restore and use the same tools.

Для глобальных и локальных средств требуется совместимая версия среды выполнения. For both global and local tools, a compatible version of the runtime is required. Сейчас на сайте NuGet.org многие средства предназначены для среды выполнения .NET Core 2.1. Many tools currently on NuGet.org target .NET Core Runtime 2.1. Чтобы установить эти средства глобально или локально, нужно, как и раньше, установить среду выполнения NET Core 2.1. To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Накат основной версии Major-version Roll Forward

В .NET Core 3.0 появилась функция согласия, которая позволяет приложению выполнять накат до последней основной версии .NET Core. .NET Core 3.0 introduces an opt-in feature that allows your app to roll forward to the latest major version of .NET Core. Кроме того, добавлен новый параметр для управления тем, как накат применяется к приложению. Additionally, a new setting has been added to control how roll forward is applied to your app. Его можно настроить одним из следующих способов: This can be configured in the following ways:

  • Свойство файла проекта: RollForward Project file property: RollForward
  • Свойство файла конфигурации среды выполнения: rollForward Runtime configuration file property: rollForward
  • Переменная среды: DOTNET_ROLL_FORWARD Environment variable: DOTNET_ROLL_FORWARD
  • Аргумент командной строки: —roll-forward Command-line argument: —roll-forward

Необходимо указать одно из следующих значений. One of the following values must be specified. Если параметр не указан, ему по умолчанию присваивается значение Minor. If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Накат до версии с наибольшим номером исправления. Roll forward to the highest patch version. Отключает накат дополнительных версий. This disables minor version roll forward.
  • MinorMinor
    Накат до дополнительной версии со следующим по порядку возрастания номером, если запрошенная дополнительная версия отсутствует. Roll forward to the lowest higher minor version, if requested minor version is missing. Если запрошенная дополнительная версия присутствует, используется политика LatestPatch. If the requested minor version is present, then the LatestPatch policy is used.
  • MajorMajor
    Накат до основной версии со следующим по порядку возрастания или дополнительной версии с наименьшим номером, если запрошенная дополнительная версия отсутствует. Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Если запрошенная основная версия присутствует, используется политика Minor. If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Накат до дополнительной версии с наибольшим номером, даже если запрошенная дополнительная версия присутствует. Roll forward to highest minor version, even if requested minor version is present. Предназначен для сценариев размещения компонентов. Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Накат до основной версии с наибольшим номером и дополнительной версии с наибольшим номером, даже если запрошенная основная версия присутствует. Roll forward to highest major and highest minor version, even if requested major is present. Предназначен для сценариев размещения компонентов. Intended for component hosting scenarios.
  • DisableDisable
    Накат не выполняется. Don’t roll forward. Привязка только к указанной версии. Only bind to specified version. Эта политика не рекомендуется для общего использования, поскольку отключает возможность наката до последних исправлений. This policy isn’t recommended for general use because it disables the ability to roll forward to the latest patches. Это значение рекомендуется использовать только для тестирования. This value is only recommended for testing.

Все параметры, кроме параметра Disable, будут использовать версию с последним доступным исправлением. Besides the Disable setting, all settings will use the highest available patch version.

Классические приложения Windows Windows desktop

.NET Core 3.0 поддерживает классические приложения Windows с помощью Windows Presentation Foundation (WPF) и Windows Forms. .NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Эти платформы также поддерживают использование современных элементов управления и стилей Fluent из библиотеки XAML пользовательского интерфейса Windows (WinUI) через острова XAML. These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

Компонент Windows Desktop является частью пакета SDK .NET Core 3.0 для Windows. The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

Вы можете создать приложение WPF или Windows Forms с помощью следующих команд dotnet : You can create a new WPF or Windows Forms app with the following dotnet commands:

Мастер Йода рекомендует:  Бот ВКонтакте руководство и полезные инструменты разработки

Visual Studio 2020 добавляет шаблоны Новый проект для .NET Core 3.0 Windows Forms и WPF. Visual Studio 2020 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Дополнительные сведения о переносе существующего приложения .NET Framework см. в разделах Перенос проектов WPF и Перенос проектов Windows Forms. For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

Компоненты, вызываемые COM — Windows Desktop COM-callable components — Windows Desktop

Теперь в Windows можно создавать управляемые компоненты, вызываемые COM. On Windows, you can now create COM-callable managed components. Эта возможность необходима для использования .NET Core с моделями надстроек COM и обеспечивает соответствие с платформой .NET Framework. This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

В отличие от .NET Framework, где в качестве сервера использовалась библиотека mscoree.dll, .NET Core при сборке вашего COM-компонента добавляет в каталог bin dll собственного средства запуска. Unlike .NET Framework where the mscoree.dll was used as the COM server, .NET Core will add a native launcher dll to the bin directory when you build your COM component.

Пример того, как создать и использовать компонент COM, см. в разделе Демонстрация COM. For an example of how to create a COM component and consume it, see the COM Demo.

Развертывание MSIX — Windows Desktop MSIX Deployment — Windows Desktop

MSIX — это новый формат пакета приложения Windows. MSIX is a new Windows application package format. Его можно использовать для развертывания классических приложений .NET Core 3.0 для Windows 10. It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

Проект упаковки приложений Windows, доступный в Visual Studio 2020, позволяет создавать пакеты MSIX с автономными приложениями .NET Core. The Windows Application Packaging Project, available in Visual Studio 2020, allows you to create MSIX packages with self-contained .NET Core applications.

Файл проекта .NET Core должен указывать поддерживаемые среды выполнения в свойстве : The .NET Core project file must specify the supported runtimes in the property:

Высокое разрешение для WinForms WinForms high DPI

Приложения .NET Core Windows Forms могут устанавливать режим высокого разрешения экрана с помощью Application.SetHighDpiMode(HighDpiMode). .NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). Метод SetHighDpiMode задает соответствующий режим высокого разрешения, если параметр не задан другими способами, например с помощью App.Manifest или P/Invoke перед Application.Run . The SetHighDpiMode method sets the corresponding high DPI mode unless the setting has been set by other means like App.Manifest or P/Invoke before Application.Run .

Возможны следующие значения highDpiMode , выраженные перечислением System.Windows.Forms.HighDpiMode: The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Диапазоны и индексы Ranges and indices

Новый тип System.Index можно использовать для индексирования. The new System.Index type can be used for indexing. Вы можете создать с помощью int индекс, который отсчитывается с начала, а с помощью оператора ^ префикса (C#) индекс, который отсчитывается с конца: You can create one from an int that counts from the beginning, or with a prefix ^ operator (C#) that counts from the end:

Кроме того, есть тип System.Range, который состоит из двух значений Index (одно для начала и одно для конца) и который можно написать с помощью выражения диапазона x..y (C#). There’s also the System.Range type, which consists of two Index values, one for the start and one for the end, and can be written with a x..y range expression (C#). После этого можно выполнить индексацию с помощью команды Range , которая создает срез: You can then index with a Range , which produces a slice:

Дополнительные сведения см. в руководстве по диапазонам и индексам. For more information, see the ranges and indices tutorial.

Асинхронные потоки Async streams

Тип IAsyncEnumerable — это новая асинхронная версия IEnumerable . The IAsyncEnumerable type is a new asynchronous version of IEnumerable . Язык позволяет выполнить действие await foreach с этими объектами IAsyncEnumerable , чтобы использовать их элементы, и действие yield return по отношению к ним, чтобы создать элементы. The language lets you await foreach over IAsyncEnumerable to consume their elements, and use yield return to them to produce elements.

В приведенном ниже примере демонстрируется создание и применение асинхронных потоков. The following example demonstrates both production and consumption of async streams. Инструкция foreach является асинхронной и использует yield return , чтобы создать асинхронные потоки для вызывающих объектов. The foreach statement is async and itself uses yield return to produce an async stream for callers. Этот шаблон (с использованием yield return ) является рекомендуемой моделью для создания асинхронных потоков. This pattern (using yield return ) is the recommended model for producing async streams.

Помимо возможности await foreach вы также можете создать асинхронные итераторы, например, итератор, который возвращает IAsyncEnumerable/IAsyncEnumerator , для которого можно применить await и yield . In addition to being able to await foreach , you can also create async iterators, for example, an iterator that returns an IAsyncEnumerable/IAsyncEnumerator that you can both await and yield in. Для объектов, которые необходимо удалить, можно использовать IAsyncDisposable , который реализовывают различные типы BCL, такие как Stream и Timer . For objects that need to be disposed, you can use IAsyncDisposable , which various BCL types implement, such as Stream and Timer .

Дополнительные сведения см. в руководстве по асинхронным потокам. For more information, see the async streams tutorial.

Усовершенствования чисел с плавающей запятой по IEEE IEEE Floating-point improvements

API плавающей запятой сейчас обновляются, чтобы соответствовать редакции IEEE 754-2008. Floating point APIs are being updated to comply with IEEE 754-2008 revision. Цель этих изменений — предоставлять все обязательные операции и гарантировать, что их поведение будет соответствовать спецификации IEEE. Дополнительные сведения об улучшениях, связанных с плавающей запятой, см. в записи блога Улучшения в синтаксическом анализе и форматировании плавающей запятой в .NET Core 3.0. The goal of these changes is to expose all required operations and ensure that they’re behaviorally compliant with the IEEE spec. For more information about floating-point improvements, see the Floating-Point Parsing and Formatting improvements in .NET Core 3.0 blog post.

Исправления синтаксического анализа и форматирования включают: Parsing and formatting fixes include:

  • Правильный анализ и округление входных данных любой длины. Correctly parse and round inputs of any length.
  • Правильный анализ и форматирование отрицательного нуля. Correctly parse and format negative zero.
  • Правильный анализ Infinity и NaN с помощью проверки без учета регистра и допущения необязательного + в начале, где это применимо. Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Новый API System.Math включают: New System.Math APIs include:

BitIncrement(Double) и BitDecrement(Double) BitIncrement(Double) and BitDecrement(Double)
Соответствует операциям IEEE nextUp и nextDown . Corresponds to the nextUp and nextDown IEEE operations. Они возвращают наименьшее число с плавающей запятой, которое может быть больше или меньше входных данных (соответственно). They return the smallest floating-point number that compares greater or lesser than the input (respectively). Например, Math.BitIncrement(0.0) вернет double.Epsilon . For example, Math.BitIncrement(0.0) would return double.Epsilon .

MaxMagnitude(Double, Double) и MinMagnitude(Double, Double) MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
Соответствуют операциям IEEE maxNumMag и minNumMag . Они возвращают значение, которое будет больше или меньше из двух величин (соответственно). Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Например, Math.MaxMagnitude(2.0, -3.0) вернет -3.0 . For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0 .

Соответствует операции IEEE logB , которая возвращает целочисленное значение. Она возвращает целочисленный логарифм по основанию 2 входного параметра. Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Этот метод действует практически так же, как floor(log2(x)) , но с минимальными погрешностями округления. This method is effectively the same as floor(log2(x)) , but done with minimal rounding error.

ScaleB(Double, Int32)
Соответствует операции IEEE scaleB , которая принимает целочисленное значение. Возвращает x * pow(2, n) , но выполняется с минимальными погрешностями округления. Corresponds to the scaleB IEEE operation that takes an integral value, it returns effectively x * pow(2, n) , but is done with minimal rounding error.

Соответствует операции IEEE log2 . Возвращает логарифм по основанию 2. Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Сводит к минимуму погрешность округления. It minimizes rounding error.

FusedMultiplyAdd(Double, Double, Double)
Соответствует операции IEEE fma . Выполняет умножение и сложение. Corresponds to the fma IEEE operation, it performs a fused multiply add. То есть он выполняет (x * y) + z как одну операцию, тем самым сводя к минимуму погрешность округления. That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Пример — FusedMultiplyAdd(1e308, 2.0, -1e308) , возвращающий 1e308 . An example would be FusedMultiplyAdd(1e308, 2.0, -1e308) which returns 1e308 . Стандартный (1e308 * 2.0) — 1e308 возвращает double.PositiveInfinity . The regular (1e308 * 2.0) — 1e308 returns double.PositiveInfinity .

CopySign(Double, Double)
Соответствует операции IEEE copySign . Возвращает значение x , но со знаком y . Corresponds to the copySign IEEE operation, it returns the value of x , but with the sign of y .

Быстрая встроенная поддержка JSON Fast built-in JSON support

Пользователи .NET в основном полагались на Json.NET и другие популярные библиотеки JSON, которые по-прежнему остаются хорошими вариантами. .NET users have largely relied on Json.NET and other popular JSON libraries, which continue to be good choices. Json.NET использует в качестве базового типа данных строки .NET, которые обладают внутренней структурой UTF-16. Json.NET uses .NET strings as its base datatype, which is UTF-16 under the hood.

Новая встроенная поддержка JSON отличается высокой производительностью и малым распределением и основана на Span . The new built-in JSON support is high-performance, low allocation, and based on Span . Были добавлены три новых основных типа, связанных с JSON, в пространство имен System.Text.Json в .NET Core 3.0. Three new main JSON-related types have been added to .NET Core 3.0 the System.Text.Json namespace. Эти типы пока не поддерживают сериализацию и десериализацию POCO CLR. These types don’t yet support plain old CLR object (POCO) serialization and deserialization.

Utf8JsonReader Utf8JsonReader

System.Text.Json.Utf8JsonReader — это однопроходный модуль чтения текста JSON в кодировке UTF-8 из ReadOnlySpan с высокой производительностью и низким уровнем распределения. System.Text.Json.Utf8JsonReader is a high-performance, low allocation, forward-only reader for UTF-8 encoded JSON text, read from a ReadOnlySpan . Utf8JsonReader — это основной тип низкого уровня, с помощью которого можно создавать пользовательские средства синтаксического анализа и десериализаторы. The Utf8JsonReader is a foundational, low-level type, that can be used to build custom parsers and deserializers. Чтение полезных данных JSON с помощью нового Utf8JsonReader осуществляется в два раза быстрее, чем при использовании модуля чтения от JSON.NET. Reading through a JSON payload using the new Utf8JsonReader is 2x faster than using the reader from Json.NET. Распределение не осуществляется, пока не понадобится актуализировать токены JSON в виде строк (UTF-16). It doesn’t allocate until you need to actualize JSON tokens as (UTF-16) strings.

Ниже приведен пример чтения с помощью файла launch.json, созданного Visual Studio Code. Here is an example of reading through the launch.json file created by Visual Studio Code:

Utf8JsonWriter Utf8JsonWriter

System.Text.Json.Utf8JsonWriter предоставляет высокопроизводительный, не использующий кэширование и однонаправленный способ записи текста JSON в кодировке UTF-8 из распространенных типов .NET, например String , Int32 и DateTime . System.Text.Json.Utf8JsonWriter provides a high-performance, non-cached, forward-only way to write UTF-8 encoded JSON text from common .NET types like String , Int32 , and DateTime . Как и средство чтения, средство записи — это основной тип низкого уровня, с помощью которого можно создавать пользовательские сериализаторы. Like the reader, the writer is a foundational, low-level type, that can be used to build custom serializers. Запись полезных данных JSON с помощью нового Utf8JsonWriter выполняется на 30–80 % быстрее, чем с помощью средства записи из Json.NET, и не требует выделения. Writing a JSON payload using the new Utf8JsonWriter is 30-80% faster than using the writer from Json.NET and doesn’t allocate.

JsonDocument JsonDocument

System.Text.Json.JsonDocument создается на основе Utf8JsonReader . System.Text.Json.JsonDocument is built on top of the Utf8JsonReader . JsonDocument предоставляет возможность анализировать данные JSON и создавать модель DOM только для чтения, которая может запрашиваться для поддержки случайного доступа и перечисления. The JsonDocument provides the ability to parse JSON data and build a read-only Document Object Model (DOM) that can be queried to support random access and enumeration. Доступ к элементам JSON, составляющим данные, может осуществляться через тип JsonElement, который JsonDocument предоставляет как свойство с именем RootElement . The JSON elements that compose the data can be accessed via the JsonElement type that is exposed by the JsonDocument as a property called RootElement . JsonElement содержит перечислители массива и объекта JSON вместе с API-интерфейсами для преобразования текста JSON в стандартные типы .NET. The JsonElement contains the JSON array and object enumerators along with APIs to convert JSON text to common .NET types. Синтаксический анализ типичных полезных данных JSON и доступ ко всем членам с помощью JsonDocument выполняется в 2–3 раза быстрее, чем Json.NET, с небольшим количеством распределений данных приемлемого размера (т. е. Parsing a typical JSON payload and accessing all its members using the JsonDocument is 2-3x faster than Json.NET with little allocations for data that is reasonably sized (that is,

Ниже приведен пример использования JsonDocument и JsonElement , который может использоваться в качестве отправной точки: Here is a sample usage of the JsonDocument and JsonElement that can be used as a starting point:

Ниже приведен пример чтения в C# 8.0 с помощью файла launch.json, созданного Visual Studio Code: Here is a C# 8.0 example of reading through the launch.json file created by Visual Studio Code:

JsonSerializer JsonSerializer

System.Text.Json.JsonSerializer создается на основе Utf8JsonReader и Utf8JsonWriter, а также позволяет при работе с JSON-документами и фрагментами выполнять быструю сериализацию с минимальной нагрузкой на ресурсы памяти. System.Text.Json.JsonSerializer is built on top of Utf8JsonReader and Utf8JsonWriter to provide a fast, low-memory serialization option when working with JSON documents and fragments.

Пример сериализации объекта в JSON: Here is an example of serializing an object to JSON:

Ниже приведен пример десериализации строки JSON в объект. Here is an example of deserializing a JSON string to an object. Можно использовать строку JSON, созданную в предыдущем примере: You can use the JSON string produced by the previous example:

Улучшения в совместимости Interop improvements

В .NET Core 3.0 улучшена совместимость собственного API. .NET Core 3.0 improves native API interop.

Тип: NativeLibrary Type: NativeLibrary

System.Runtime.InteropServices.NativeLibrary обеспечивает инкапсуляцию для загрузки собственной библиотеки (используя ту же логику загрузки, что и .NET Core P/Invoke) и предоставления соответствующих вспомогательных функций, таких как getSymbol . System.Runtime.InteropServices.NativeLibrary provides an encapsulation for loading a native library (using the same load logic as .NET Core P/Invoke) and providing the relevant helper functions such as getSymbol . Пример кода см. в разделе Демонстрация DLLMap. For a code example, see the DLLMap Demo.

Собственное взаимодействие Windows Windows Native Interop

Windows предоставляет собственный API с широкими возможностями в виде API C, COM и WinRT. Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. При том что .NET Core поддерживает P/Invoke, в .NET Core 3.0 добавлена возможность воссоздавать API COM и активировать API WinRT. While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Пример кода см. в разделе Демонстрация Excel. For a code example, see the Excel Demo.

Поддержка HTTP/2 HTTP/2 support

Тип System.Net.Http.HttpClient поддерживает протокол HTTP/2. The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Если протокол HTTP/2 включен, версия протокола HTTP согласуется через TLS/ALPN, а HTTP/2 используется, только если его выбрал сервер. If HTTP/2 is enabled, the HTTP protocol version is negotiated via TLS/ALPN, and HTTP/2 is used if the server elects to use it.

Протоколом по умолчанию остается HTTP/1.1, но у вас есть два способа включить HTTP/2. The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. Во-первых, можно указать использование HTTP/2 в заголовке запроса: First, you can set the HTTP request message to use HTTP/2:

Во-вторых, можно изменить HttpClient для использования HTTP/2 по умолчанию: Second, you can change HttpClient to use HTTP/2 by default:

При разработке приложений часто требуется подключение без шифрования. Many times when you’re developing an application, you want to use an unencrypted connection. Если вы знаете, что целевая конечная точка использует протокол HTTP/2, вы можете включить незашифрованные подключения для HTTP/2. If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Для этого задайте переменной среды DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT значение 1 или включите этот параметр в контексте приложения: You can turn it on by setting the DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT environment variable to 1 or by enabling it in the app context:

TLS 1.3 и OpenSSL 1.1.1 в Linux TLS 1.3 & OpenSSL 1.1.1 on Linux

Теперь .NET Core использует преимущества поддержки TLS 1.3 в OpenSSL 1.1.1, когда она доступна в данной среде. .NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it’s available in a given environment. В TLS 1.3: With TLS 1.3:

  • За счет уменьшения количества круговых путей между клиентом и сервером уменьшено время соединения. Connection times are improved with reduced round trips required between the client and server.
  • За счет удаления различных устаревших и небезопасных алгоритмов шифрования повышена безопасность. Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

В системе Linux .NET Core 3.0 по возможности использует OpenSSL 1.1.1, OpenSSL 1.1.0 или OpenSSL 1.0.2. When available, .NET Core 3.0 uses OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 on a Linux system. Если есть доступ к OpenSSL 1.1.1, оба типа, System.Net.Security.SslStream и System.Net.Http.HttpClient, используют TLS 1.3 (при условии что клиент и сервер поддерживают TLS 1.3). When OpenSSL 1.1.1 is available, both System.Net.Security.SslStream and System.Net.Http.HttpClient types will use TLS 1.3 (assuming both the client and server support TLS 1.3).

Windows и macOS еще не поддерживают TLS 1.3. Windows and macOS do not yet support TLS 1.3. .NET Core 3.0 будет поддерживать TLS 1.3 в этих операционных системах, когда поддержка станет доступной. .NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

В следующем примере C# 8.0 показано, как .NET Core 3.0 в Ubuntu 18.10 подключается к https://www.cloudflare.com: The following C# 8.0 example demonstrates .NET Core 3.0 on Ubuntu 18.10 connecting to https://www.cloudflare.com:

Шифры криптографии Cryptography ciphers

В .NET 3.0 добавлена поддержка шифров AES-GCM и AES-CCM, реализованных с помощью System.Security.Cryptography.AesGcm и System.Security.Cryptography.AesCcm соответственно. .NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Оба этих алгоритма представляют собой алгоритмы AEAD (аутентифицированного шифрования с присоединенными данными). These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

В следующем коде показано использование шифра AesGcm для шифрования и расшифровки случайных данных. The following code demonstrates using AesGcm cipher to encrypt and decrypt random data.

Импорт и экспорт криптографических ключей Cryptographic Key Import/Export

.NET Core 3.0 поддерживает импорт и экспорт асимметричных открытых и закрытых ключей из стандартных форматов. .NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Сертификат X.509 использовать не нужно. You don’t need to use an X.509 certificate.

Все типы ключей, включая RSA, DSA, ECDsa и ECDiffieHellman, поддерживают следующие форматы: All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

Открытый ключ Public Key

  • X.509 SubjectPublicKeyInfo X.509 SubjectPublicKeyInfo

Закрытый ключ Private key

  • PKCS#8 PrivateKeyInfo PKCS#8 PrivateKeyInfo
  • PKCS#8 EncryptedPrivateKeyInfo PKCS#8 EncryptedPrivateKeyInfo

Ключи RSA также поддерживают: RSA keys also support:

Открытый ключ Public Key

  • PKCS#1 RSAPublicKey PKCS#1 RSAPublicKey

Закрытый ключ Private key

  • PKCS#1 RSAPrivateKey PKCS#1 RSAPrivateKey

Методы экспорта создают двоичные данные в кодировке DER, а методы импорта выполняют то же самое. The export methods produce DER-encoded binary data, and the import methods expect the same. Если ключ хранится в формате PEM в виде текста, вызывающему объекту потребуется выполнить декодирование содержимого в формате base64, прежде чем вызывать метод импорта. If a key is stored in the text-friendly PEM format, the caller will need to base64-decode the content before calling an import method.

Файлы PKCS 8 можно проверять с помощью System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo, а файлы PFX/PKCS #12 — с помощью System.Security.Cryptography.Pkcs.Pkcs12Info. PKCS#8 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo and PFX/PKCS#12 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs12Info. Для манипуляций с файлами PFX/PKCS #12 можно использовать System.Security.Cryptography.Pkcs.Pkcs12Builder. PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

SerialPort для Linux SerialPort for Linux

.NET Core 3.0 обеспечивает базовую поддержку System.IO.Ports.SerialPort в Linux. .NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

Раньше среда .NET Core поддерживала SerialPort только в Windows. Previously, .NET Core only supported using SerialPort on Windows.

Дополнительные сведения об ограниченной поддержке последовательного порта в Linux см. в описании проблемы № 33146 на сайте GitHub. For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Ограничения памяти в Docker и cgroup Docker and cgroup memory Limits

Запуск .NET Core 3.0 на платформе Linux с помощью Docker лучше работает с ограничениями памяти в cgroup. Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. Запуск контейнера Docker с ограничениями памяти, например с docker run -m , изменяет поведение .NET Core. Running a Docker container with memory limits, such as with docker run -m , changes how .NET Core behaves.

  • Размер кучи сборщика мусора (GC) по умолчанию составляет не более 20 МБ или 75 % от ограничения памяти для контейнера. Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • Конкретный размер можно указать абсолютным числом или в виде процента от ограничения cgroup. Explicit size can be set as an absolute number or percentage of cgroup limit.
  • Минимальный зарезервированный размер сегмента в куче GC составляет 16 МБ. Minimum reserved segment size per GC heap is 16 mb. При использовании такого размера количество создаваемых на компьютерах куч будет меньше. This size reduces the number of heaps that are created on machines.
Мастер Йода рекомендует:  Бизнес и Минкомсвязь выступили против проекта о «значимых IT-компаниях»

Уменьшенные размеры куч сборки мусора Smaller Garbage Collection heap sizes

Размер кучи сборщика мусора по умолчанию был уменьшен, так что теперь .NET Core использует меньше памяти. The Garbage Collector’s default heap size has been reduced resulting in .NET Core using less memory. Это изменение лучше соответствует выделению бюджета нулевого поколения и размерам кэша современных процессоров. This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Поддержка больших страниц сборки мусора Garbage Collection Large Page support

Большие страницы (также известные как огромные страницы в Linux) — это функция, благодаря которой операционная система может задавать области памяти больше, чем размер нативной страницы (часто 4K), чтобы повысить производительность приложения, запрашивающего такие страницы. Large Pages (also known as Huge Pages on Linux) is a feature where the operating system is able to establish memory regions larger than the native page size (often 4K) to improve performance of the application requesting these large pages.

Сборщик мусора теперь можно настраивать с помощью параметра GCLargePages как дополнительной функции, позволяющей выделять большие страницы в Windows. The Garbage Collector can now be configured with the GCLargePages setting as an opt-in feature to choose to allocate large pages on Windows.

Поддержка GPIO для Raspberry Pi GPIO Support for Raspberry Pi

В NuGet выпущено два новых пакета, которые можно использовать для программирования GPIO: Two packages have been released to NuGet that you can use for GPIO programming:

Пакеты GPIO содержат API для устройств GPIO, SPI, I2C и PWM. The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. Пакет привязок Интернета вещей содержит привязки устройств. The IoT bindings package includes device bindings. Дополнительные сведения см. в репозитории GitHub устройств. For more information, see the devices GitHub repo.

Поддержка ARM64 Linux ARM64 Linux support

В .NET Core 3.0 добавлена поддержка ARM64 для Linux. .NET Core 3.0 adds support for ARM64 for Linux. Основной вариант использования для ARM64 в данный момент — это сценарии Интернета вещей. The primary use case for ARM64 is currently with IoT scenarios. Дополнительные сведения см. в статье Состояние .NET Core в ARM64. For more information, see .NET Core ARM64 Status.

Образы Docker для .NET Core в ARM64 доступны для Alpine, Debian и Ubuntu. Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Поддержка ARM64 в Windows еще недоступна. ARM64 Windows support isn’t yet available.

Setting up Raspian and .NET Core 2.0 on a Raspberry Pi

Here’s a little something I wrote for a customer who wants to use .Net Core on a Raspberry Pi. You might find it useful as well.

Raspbian Linux is the Raspberry Pi Foundation’s officially supported operating system for running the Raspberry Pi.
.NET Core is Microsoft’s new modular open source implementation of .NET for creating web applications and services that run on Windows, Linux and Mac.

Don’t worry if you’ve never used either of these technologies before, this post will take you though the steps to get Raspian and .NET Core installed and working on a Raspberry Pi device.

Both these technologies are well maintained and supported by their creators and each has excellent documentation which is always up to date. To keep this post as small as possible it will act as a guide, describing each task to be carried out in brief but providing references to external documentation when more details are required.

Step 1 — Prepare a Raspian Linux SD card.

In order to start-up a Raspberry Pi, it must have an operating system installed onto an SD card which has been inserted into the device. Raspian Linux is one of the officially supported operating systems along with 3rd party options such as Windows 10 IoT Core.

The process of installing an operating system onto an SD card is known as flashing the card. Flashing is carried out using a tool or utility which is capable of reading an image file which has been downloaded from an O/S vendor. The image file is typically a binary file and the utility is capable of reading the image and writing it to the SD card.

Task: Install Raspian Linux onto an SD card.

  1. Download the latest Raspbian Jessie with desktop Linux image to your local machine. Other download options are available at Download Raspian.
  2. Download the Etcher image writing utility and install it.
  3. Insert the SD card into your computer.
  4. Open Etcher and select from your hard drive the .zip file you downloaded in step 1.
  5. Select the SD card you wish to write your image to.
  6. Review your selections and click ‘Flash!’ to begin writing data to the SD card.
  7. Once flashing is complete, create a new empty file named ssh (with no extension) in the root of the drive that holds the SD card. This will ensure that the SSH daemon is enabled once the Raspberry Pi has started and you can logon over the network.

Step 2 — Boot the Raspberry Pi and connect over the network.

Ensure your Raspberry Pi has the following cables connected:

  • HDMI — so you can watch the boot process from a screen.
  • Ethernet cable — avoid connecting to corporate networks as firewalls and proxies/proxy authentication problems can waste setup time.
  • Keyboard and mouse.

Task: Power up the Raspberry Pi and obtain its IP address.

  • Insert the SD card into the base of the Raspberry Pi. Ensure the electric contacts are facing upwards.
  • Power-up the RPi by plugging in the micro-USB power supply. Wait until it reaches the desktop.
  • Click on the Terminal icon on the top menu to open a prompt and type ifconfig to obtain the IP address which has been assigned by your DHCP server to the Raspberry Pi.
  • Download the PuTTY SSH and Telnet client and launch it.
  • Enter the IP address of the Raspberry Pi and click Open. Accept the message about keys.
  • Enter pi as the logon name, and raspberry as the password.
  • Once you have reached the command line, change the default password for the pi user.

Step 3 — Install the .NET Core Runtime.

Three components are typically required to create and run a .NET Core application:-

  1. .NET Core Runtime.Needs to be installed on any machine where a .NET Core application will run.
  2. .NET Core SDK. Needs to be installed on any machine used to develop .NET Core applications.
  3. IDE Tools.Adds-on for your chosen IDE to automate the development process.

The .NET Core Runtime is available for Windows, MacOS and various flavours of Linux however only the most recent version; .NET Core Runtime 2.0 is supported for running on Raspian Linux on the ARM32 processor architecture. This means it is possible to run .NET Core applications on the Raspberry Pi.

However there is currently no .NET Core SDK available for Raspian Linux running on the Raspberry Pi (i.e. ARM32).

The end result? It is not as yet possible to develop a .NET Core application *directly* on the RPi itself. Instead an application must be developed on a supported platform (i.e. another machine running Windows, MacOS or one of the various flavours of Linux running on x86 or x64) then deployed to the Raspberry Pi.

See the dotnet/Core repository for an official statement.

Task: Install the .NET Core Runtime on the Raspberry Pi.

The following commands need to be run on the Raspberry Pi whilst connected over an SSH session or via a terminal in the PIXEL desktop environment.

  • Run sudo apt-get install curl libunwind8 gettext. This will use the apt-get package manager to install three prerequiste packages.
  • Run curl -sSL -o dotnet.tar.gz https://dotnetcli.blob.core.windows.net/dotnet/Runtime/release/2.0.0/dotnet-runtime-latest-linux-arm.tar.gz to download the latest .NET Core Runtime for ARM32. This is refereed to as armhf on the Daily Builds page.
  • Run sudo mkdir -p /opt/dotnet && sudo tar zxf dotnet.tar.gz -C /opt/dotnet to create a destination folder and extract the downloaded package into it.
  • Run sudo ln -s /opt/dotnet/dotnet /usr/local/bin` to set up a symbolic link. a shortcut to you Windows folks �� to the dotnet executable.
  • Test the installation by typing dotnet —help.
  • Try to create a new .NET Core project by typing dotnet new console. Note this will prompt you to install the .NET Core SDK however this link won’t work for Raspian on ARM32. This is expected behaviour.
  • Optional: Follow the steps outlined in the .NET Core on Raspberry Pi guide to create a test console application on your local development machine then run it on the RPi. The key action here is that you will create an application then publish the it using the dotnet publish -r linux-arm command.

Как сделать Raspberry Pi доступным из любой точки мира

В прошлой статье я рассказал о том, как развернуть домашнее облачное хранилище на базе подготовленного командой cusdeb.com образа для Raspberry Pi 2 и 3 с предустановленным Nextcloud 11 (кстати, совсем недавно мы обновили образ до 12-й версии), а прямо сейчас я расскажу о том, как делать сервисы наподобие Nextcloud доступными извне. Несмотря на то, что на протяжении всей статьи упоминается Raspberry Pi, ничего из сказанного здесь не ограничивает вас в использовании любого другого устройства.

«Белые» динамические и статические IP-адреса

Все IP-адреса протокола IPv4 делятся на «белые» (более формально – публичные, глобальные или внешние) и «серые» (более формально – частные, локальные или внутренние). К устройству с «белым» IP-адресом можно получить доступ из любой точки мира, т.к. «белые» IP-адреса маршрутизируются в Интернете, в отличие от «серых» IP-адресов.

«Белые» IP-адреса, в свою очередь, делятся на динамические и статические. Динамические «белые» IP-адреса являются сегодня большой редкостью, но если вам все-таки повезло, то у вас есть возможность с небольшими трудозатратами абсолютно бесплатно сделать свой RPi (или любую другую машину) доступным через Интернет. Дело в том, что сервис NO-IP позволяет зарегистрировать домен третьего уровня и посредством специального клиентского ПО в фоновом режиме отслеживать изменение вашего динамического IP-адреса и при необходимости обновлять DNS, чтобы ваша машина была всегда доступна по зарегистрированному вами домену.

Если у вас по той или иной причине нет динамического «белого» IP-адреса, то почти наверняка у вас есть возможность купить у вашего провайдера «белый» статический IP-адрес. На самом деле это является наиболее надежным и наименее трудозатратным решением. Вот расценки трех провайдеров, которые у меня всегда на слуху.

* ТТК – 250 руб. в месяц

* Ростелеком – 50 руб. активация и 100 руб. в месяц

* Дом.ru – 450 руб. активация и 20 руб. в месяц

Если вы являетесь клиентом провайдера Дом.ru, то не спешите покупать у него статический «белый» IP-адрес, т.к. у вас определенно есть возможность получить динамический «белый» IP-адрес абсолютно бесплатно. Для этого убедитесь в своем личном кабинете, что у вас выключен NAT.

Этот этап необходимо пройти в том случае, если у вас есть «белый» IP-адрес (вне зависимости от того, динамический он или статический). Основная идея здесь заключается в том, чтобы маршрутизатор, который стоит перед вашим RPi, принимал все запросы, а затем передавал их одноплатнику. Для каждого маршрутизатора эта процедура выглядит по-разному, и в Сети можно легко найти описание той, которая будет применима именно для вашего маршрутизатора. Вот как она выглядит для моего ZyXEL Keenetic DSL.

Для начала нужно назначить RPi статический адрес в локальной сети, чтобы при перезагрузке устройства маршрутизатор случайно не дал ему IP-адрес отличный от предыдущего. Для этого переходим на страницу «Домашняя сеть» и на вкладке «Устройства» выбираем свой RPi, подключенный к локальной сети. В появившемся диалоговом окне ставим галочку напротив «Постоянный IP-адрес».

Для начала работы с NO-IP перейдите на страницу регистрации, создайте Free’шную учетную запись, зарегистрируйте там же домен третьего уровня и активируйте вашу учетную запись. В качестве доменного имени я выбрал denismosolov.ddns.net. Также рассмотрите апгрейд вашего аккаунта с Free до Enhanced, иначе вам потребуется подтверждать ваш домен каждый месяц. (Тем не менее, лично мне цена $24.95 в год за эту услугу показалась слегка завышенной.) После этого я могу получать доступ к сервису, который крутится на моем устройстве, через denismosolov.ddns.net, но проблема с динамическим IP-адресом все еще остается актуальной. Для того чтобы RPi всегда был доступен по зарегистрированному домену, на него необходимо поставить специальное клиентское ПО. Если вы используете Raspbian, Debian, Ubuntu или любой другой дистрибутив GNU/Linux на своем одноплатнике, то я не рекомендую тратить время на официальный клиент от NO-IP под названием DUC (DNS Update Client). Во-первых, он не обновлялся с 2008-го года, а во-вторых, есть универсальное решение – inadyn, которое на данный момент поддерживает 25 сервисов, предоставляющих услуги динамического DNS, в числе которых NO-IP. К сожалению, несмотря на то, что пакет с inadyn есть в Debian и Ubuntu, он недостаточно актуален, хотя и поддерживает NO-IP в полной мере. Я предлагаю воспользоваться подготовленным мною Docker-контейнером с самой свежей версией inadyn или собрать контейнер самостоятельно, воспользовавшись проектом cusdeb-services.

Для того чтобы воспользоваться готовым контейнером, клонируйте проект, перейдите в поддиректорию inadyn этого проекта, раскомментируйте блок default@no-ip.com в конфигурационном файле inadyn.conf, добавьте в него параметры своей учетной записи и выполните docker-compose up.

После того как вы убедитесь в том, что клиент нормально стартовал и не жалуется на конфигурационный файл, который вы ему подсунули, убейте текущий интерактивный процесс и перезапустите контейнер командой docker-compose up -d. Теперь ваше устройство будет доступно из любой точки мира через Интернет.

Я попытался сделать статью как можно более универсальной и на любой вкус, поэтому решил не останавливаться на паре описанных выше способах решить проблему доступности устройства через Интернет. Дело в том, что есть еще один способ – сделать свой сервер IPv6-only, но в этом случае у клиентов почти наверняка возникнут проблемы с доступом к нему, т. к. их провайдер до сих пор не сделал и шагу в сторону IPv6. Тем не менее, я расскажу об этом подходе, т. к. считаю, что в некоторых случаях он может оказаться очень полезным. К примеру, если вы поднимаете не массовый сервер и знаете своих клиентов в лицо. В этом случае вы можете раздать им простую инструкцию, которая бы рассказывала, как (бесплатно) воспользоваться услугами туннельного брокера для доступа к вашему и другим IPv6-only сервисам.

Для начала предлагаю убедиться в том, что вы все-таки не можете обращаться к IPv6-only сервисам, иначе все описанное далее будет для вас абсолютно бесполезным. Выполните на своем устройстве ping6 ipv6.test-ipv6.com. Если ответом стало «connect: Network is unreachable», то придется читать дальше. Если ipv6.test-ipv6.com все-таки пингуется, то поздравляю – или ваш провайдер поддерживает IPv6, или вы уже настроили работу с IPv6-only сервисами через туннельного брокера.

Teredo – это один из способов настройки поддержки IPv6 на компьютере, имеющем адрес IPv4. Teredo позволяет получить IPv6-туннель даже тем клиентам, которые выходят в Интернет через провайдерский NAT (т. е. имеют «серый» IP-адрес). Несмотря на то, что Teredo разрабатывался Microsoft только для Windows, существует реализация клиента под названием Miredo для Linux и других Unix-подобных операционных систем. Если вы используете на своем одноплатнике Raspbian, Ubuntu или любой другой Debian-подобный дистрибутив GNU/Linux, то установите Miredo следующей командой.

$ sudo apt-get install miredo

Теперь ping6 ipv6.test-ipv6.com должен возвращать ожидаемый результат. Вот так все просто. IP-адрес, который вы получили, является по определению «белым». Теперь вместо проброса портов нужно только открыть UDP-порт 3544. Дело в том, что Teredo инкапсулирует пакеты IPv6 в заголовках IPv4 и использует UDP-порт 3544 для передачи этих пакетов. Процедура открытия того или иного порта варьируется от маршрутизатора к маршрутизаторы. Вот как она выглядит для моего ZyXEL Keenetic DSL. Сначала переходим на страницу «Безопасность», а затем на вкладке «Межсетевой экран» добавляем новое правило, открывающее UDP-порт 3544.

Для того чтобы достучаться до вашего устройства, ваши клиенты могут также установить Miredo в любой Unix-подобной операционной системе (включая macOS) или настроить Teredo в Windows, но сейчас остаются нерешенными две проблемы:

* в данном конкретном случае IPv6-адрес зависит от IPv4-адреса, поэтому является динамическим (если конечно IPv4-адрес динамический)

* IPv6-адреса достаточно трудно запоминать.

Эти две проблемы легко решить посредством сервиса, предоставляющего услуги динамического DNS. Для этих целей предлагаю в этот раз воспользоваться dynv6, который, как и NO-IP, позволяет зарегистрировать домен третьего уровня и привязать его к динамическому IP-адресу. В качестве клиента, который в фоновом режиме будет отслеживать изменение вашего динамического IP-адреса и при необходимости обновлять DNS, предлагаю использовать inadyn, который также упомянуть упомянался в предыдущем разделе. Для того чтобы воспользоваться готовым контейнером с клиентом, клонируйте проект cusdeb-services, перейдите в поддиректорию inadyn этого проекта, раскомментируйте блок default@dynv6.com в конфигурационном файле inadyn.conf и измените в нем параметры username и hostname. Обратите внимание, что в качестве значения username необходимо использовать токен, который можно найти в настройках вашего домена на вкладке Instructions. Для параметра password нужно оставить значение «n/a».

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

В этой статье я рассказал как сделать свое устройство, будь то одноплатник, ноутбук или стационарный компьютер, доступным из любой точки мира через Интернет. Также я рассмотрел как решить эту задачу посредством «белого» статического и динамического IP-адреса, и рассказал как сделать сервисы на своем устройстве IPv6-only через туннельного брокера. Не прошли незамеченными и сервисы, предоставляющие услуги динамического DNS, которые предлагаю абсолютно бесплатно регистрировать домены третьего уровня, привязывать их к своему IP-адресу и сохранять устройство доступным по этому домену несмотря на то, что IP-адрес может в любое время измениться.

К сожалению, за бортом осталась важная тема получения сертификата через сервис Let’s Encrypt для того, чтобы устанавливать защищенное соединение между вашим сервером и клиентами. Дайте знать в комментариях, если эта тема нуждается в том, чтобы я о ней также написал на Пикабу.

.NET Core теперь доступен для Raspberry Pi

Обсуждение устройств, не относящихся к данной теме, запрещено. Если нужной вам темы по конкретной модели не существует — создайте её.

Вместо слов «Спасибо!» используйте . Если у Вас меньше 15 постов — нажмите на кнопку под тем сообщением, где Вам помогли, и напишите благодарность.

На форуме принято размещать изображения под спойлером

Raspberry Pi — одноплатный компьютер размером с банковскую карту, изначально разработанный как бюджетная система для обучения информатике, впоследствии получивший намного более широкое применение и популярность, чем ожидали его авторы. Разрабатывается Raspberry Pi Foundation. Всего за три года было продано более 4,5 миллионов устройств Raspberry Pi.

Raspberry Pi выпускается в нескольких комплектациях: модель «A», «B», «B+»,«2B», «Zero», «Zero W», «3B», «3B+», «3A+» и «4B».

Отличия между версиями в следующем:

Добавить комментарий