Jak zrobić PDF na Raspberry PI z .NET Core

Raspberry PI to minikomputer z pojedynczym obwodem drukowanym z procesorem ARM. Ten minikomputer jest często używany do nauki podstaw informatyki.

Do naszych eksperymentów użyjemy płyty Raspberry PI 3B z 1GB pamięci RAM i zainstalowanego Linux Raspbian Buster z systemem operacyjnym desktop. Ominiemy instalację i konfigurację systemu - założymy, że wszystko jest już zainstalowane i działa.

Pomimo niewielkich rozmiarów, używamy komputera o potężnych możliwościach. Spróbujmy zainstalować na nim framework .NET Core i napisać prostą aplikację C #, która wygeneruje dokument PDF.

Po pierwsze, musimy połączyć się z Raspberry za pośrednictwem SSH lub otworzyć aplikację terminala na pulpicie, jeśli podłączymy płytę do monitorów i klawiatury. Oczywiście, płyta musi być podłączona do Internetu, aby zainstalować komponenty, których potrzebujemy.

System operacyjny Raspbian obsługuje aplikacje .NET Core dla architektury ARM32. Link do .NET Core SDK można znaleźć na oficjalnej stronie do pobrania.

Pobierz i rozpakuj archiwum:

1
2

$ sudo wget https://download.visualstudio.microsoft.com/download/pr/f2e1cb4a-0c70-49b6-871c-ebdea5ebf09d/acb1ea0c0dbaface9e19796083fe1a6b/dotnet-sdk-3.1.300-linux-arm.tar.gz
$ mkdir -p $HOME/dotnet && tar zxf dotnet-sdk-3.1.300-linux-arm.tar.gz -C $HOME/dotnet

Następnie musimy dodać ścieżkę do folderu .NET Core w PATH, a także utworzyć zmienną DOTNET_ROOT:

1
2

$ export DOTNET_ROOT=$HOME/dotnet
$ export PATH=$PATH:$HOME/dotnet

Ostatnie wiersze najlepiej dodać do pliku konfiguracyjnego profilu użytkownika: ~/.bash_profile, ~/.bashrc, ~/.kshrc, ~/.profile, ~/.zshrc, ~/.zprofile.

Prawidłową instalację zestawu SDK .NET Core można zweryfikować za pomocą następującego polecenia:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

$ dotnet --info
.NET Core SDK (reflecting any global.json):
 Version: 3.1.300
 Commit: b2475c1295
 
Runtime Environment:
 OS Name: raspbian
 OS Version: 10
 OS Platform: Linux
 RID: linux-arm
 Base Path: /home/pi/dotnet/sdk/3.1.300/
 
Host (useful for support):
 Version: 3.1.4
 Commit: 0c2e69caa6
 
.NET Core SDKs installed:
 3.1.300 [/home/pi/dotnet/sdk]
 
.NET Core runtimes installed:
 Microsoft.AspNetCore.App 3.1.4 [/home/pi/dotnet/shared/Microsoft.AspNetCore.App]
 Microsoft.NETCore.App 3.1.4 [/home/pi/dotnet/shared/Microsoft.NETCore.App]
 
To install additional .NET Core runtimes or SDKs:
 https://aka.ms/dotnet-download

Do dalszej pracy należy zainstalować dodatkowe pakiety (cała reszta jest już zainstalowana z Linuksem Raspbian Buster z desctopem):

1
2
3

$ sudo apt-get install libgdiplus
$ sudo wget http://ftp.de.debian.org/debian/pool/contrib/m/msttcorefonts/ttf-mscorefonts-installer_3.6_all.deb
$ sudo apt-get install -y ttf-mscorefonts-installer_3.6_all.deb

Zainstalowany został również zestaw czcionek, który jest dostarczany z systemem Windows, więc aplikacje będą wyglądać podobnie zarówno w systemie Windows, jak i Linux.

Now możesz stworzyć naszą aplikację. Czas uruchomić polecenie:

1

$ dotnet new console -o testpdf

Widzimy szablon aplikacji konsoli z plikami testpdf.csproj i Program.cs w folderze testpdf.

Zastąp kod pliku testpdf.csproj:

1
2
3
4
5
6
7
8
9
10
11
12

<Project Sdk="Microsoft.NET.Sdk">
 <PropertyGroup>
 <OutputType>Exe</OutputType>
 <TargetFramework>netcoreapp3.1</TargetFramework>
 </PropertyGroup>
 
 <ItemGroup>
 <PackageReference Include="FastReport.Compat" Version="2020.3.2" />
 <PackageReference Include="FastReport.Core" Version="2020.3.1-demo" />
 </ItemGroup>
 
</Project>

Plik zawiera linki do pakietów Nuget FastReport.Core i FastReport.Compat. Zostaną one pobrane podczas procesu kompilacji i umieszczone w ~/.nuget/packages.

Plik programu.cs powinien zostać zastąpiony następującym kodem:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

using System;
using FastReport;
using FastReport.Export.Pdf;
using FastReport.Utils;
 
namespace testpdf
{
class Program
 {
 static void Main()
 {
 Console.WriteLine("Test FastReport Core"); 
 // create report object
 using Report report = new Report();
 // create page
 using ReportPage page = new ReportPage();
 // add page in report
 report.Pages.Add(page);
 // create band
 page.ReportTitle = new ReportTitleBand()
 {
 Height = Units.Centimeters * 10
 };
 // create text object placed on band
 using TextObject text = new TextObject()
 {
 Left = Units.Centimeters * 7,
 Top = Units.Centimeters * 5,
 Font = new System.Drawing.Font("Arial", 24),
 CanGrow = true,
 AutoWidth = true,
 Text = "Hello Raspberry!",
 Parent = page.ReportTitle
 };
 
 // make the document
 report.Prepare();
 // save the document as PDF file
 using PDFExport pdf = new PDFExport();
 report.Export(pdf, "file.pdf");
 }
 }
}

Kod tworzy instancję raportu, dodaje do niego stronę i pasek. Następnie obiekt tekstowy jest tworzony na współrzędnych Lewej i Górnej. Właściwości CanGrow i AutoWidth umożliwiają obiektowi automatyczne obliczanie wysokości i szerokości w zależności od rozmiaru tekstu. Tworzenie obiektów w kodzie programu nie jest jedynym sposobem generowania dokumentów.

Można użyć edytora szablonów projektanta.exe w pakiecie z programem FastReport .NET. Plik z rozszerzeniem *.frx wygenerowanym przez edytor można następnie załadować za pomocą Report.Load. W szablonie xml można określić powiązania z danymi użytkownika, zmiennymi, używać wbudowanych i zdefiniowanych przez użytkownika funkcji.

Więcej o możliwościach FastReport .NET możesz dowiedzieć się na oficjalnej stronie internetowej. Po przygotowaniu dokumentu zapisujemy go w pliku PDF.

Wszystkie obiekty używane w kodzie zawierają wiele właściwości, które wpływają na ich zachowanie w dokumencie. Więcej szczegółów można znaleźć w dokumentacji produktu FastReport .NET.

Uruchomiamy program:

1

$ dotnet run

Jeśli wszystko zostanie zrobione jak należy i wszystkie niezbędne pakiety są zainstalowane, otrzymamy plik.pdf. W przeciwnym razie musisz przeczytać tekst błędów i wyeliminować je. Wynikowy plik PDF jest w pełni zgodny ze standardem, zawiera tekst i osadzoną czcionkę.

Tekst można zaznaczyć i skopiować do innego dokumentu.

W lewym górnym rogu strony znajduje się tekst wskazujący, że użyliśmy wersji demo Fastreport .NET Core. Maksymalna liczba stron w wersji demonstracyjnej jest ograniczona do pięciu.
Komercyjna wersja fastreport .NET nie zawiera tych ograniczeń. Licencje można kup w sklepie Fast Reports Home Site.

Jest jednak sposób, aby uzyskać podobny plik PDF bez etykiety DEMO VERSION całkowicie za darmo. Do tego należy użyć FastReport Open Source product.

Zmieńmy plik csproj i sekcję ItemGroup:

1
2
3
4
5

 <ItemGroup>
 <PackageReference Include="FastReport.Compat" Version="2020.3.2" />
 <PackageReference Include="FastReport.OpenSource" Version="2020.3.1" />
 <PackageReference Include="FastReport.OpenSource.Export.PdfSimple" Version="2020.3.1" />
 </ItemGroup>

Plik Program.cs musi zostać zmieniony w następujący sposób:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

using System;
using FastReport;
using FastReport.Export.PdfSimple;
using FastReport.Utils;
 
namespace testpdf
{
 class Program
 {
 static void Main()
 {
 Console.WriteLine("Test FastReport Open Source");
 
 // ...
 // same code here ...
 // ...
 
 // save the document as PDF file
 using PDFSimpleExport pdf = new PDFSimpleExport();
 report.Export(pdf, "file.pdf");
 }
 }
}

Następnie uruchamiamy program za pomocą polecenia dotnet run i otrzymujemy plik PDF bez znaku "wersja demo" i wszelkich ograniczeń dotyczących liczby stron.

Niestety, istnieje znaczna wada wersji Open Source: wewnątrz plików PDF są obrazy zamiast tekstu. Kopiowanie takiego tekstu nie jest możliwe, a rozmiar pliku będzie znacznie większy. W przypadku prostych aplikacji powinno to wystarczyć. Podczas tworzenia pliku PDF przy użyciu Fastreport Open Source może wystąpić problem renderowania znaków jako pustych kwadratów. Ten błąd .NET Core został już dawno naprawiony dla platform x86 i x64.

W naszym przypadku musisz poczekać na poprawkę w najnowszych kompilacjach .NET Core lub użyć .NET Core SDK 2.2.

Jestem bardzo zadowolony z możliwości uruchamiania aplikacji .NET Core na platformach ARM32 / ARM64. Producenci serwerów rozpoczęli już sprzedaż platform sprzętowych na procesorach ARM. Możliwe, że w niedalekiej przyszłości zobaczymy wzrost popularności ofert ARM Bare-Metal wśród dostawców hostingu.

Cóż, teraz masz okazję ćwiczyć na Raspberry PI z myślą o serwerze.

Przykłady opisane w artykule można znaleźć na moim profilu na GitHub.