Часто приходится слышать как люди, увидев код PascalАВС.NЕТ в точечной нотации, говорят: "А, тут LINQ используется...". И это зачастую совершенно неверно. Вот пример кода с точечной нотацией, который не имеет к LINQ никакого отношения:

##
function Sum(Self: array of integer): integer; extensionmethod;
begin
  Result := 0;
  foreach var n in Self do
    Result += n
end;

function Println(Self: array of integer): array of integer; extensionmethod;
begin
  var n := Self.Length;
  Result := new integer[n];
  for var i := 0 to n - 2 do
  begin  
    Result[i] := Self[i];
    Write(Self[i], ' ')
  end;
  Result[n - 1] := Self[n - 1];
  Writeln(Self[n - 1])
end;

var n := ReadInteger;
var a := new integer[n];
a[0] := 1;
a[1] := 3;
for var i := 2 to n - 1 do
  a[i] := 3 * a[i - 2] + 5 * a[i - 1] - 4;
Write(a.Println.Sum)
{
Результат работы программы:
10
1 3 14 75 413 2286 12665 70179 388886 2154963
2629485
}

Так что же такое LINQ на самом деле?

LINQ - сокращенное название технологии Microsoft LINQ to Objects библиотек .NET Framework. для доступа к данным, расположенным в памяти компьютера. Сам термин LINQ - аббревиатура Language INtegrated Query (интегрированный язык запросов). Используя LINQ, можно обращаться к последовательностям, а также к коллекциям данных, например, к спискам List, как к таблицам базы данных.

Традиционно данные из последовательностей извлекались путем перебора всех элементов в цикле foreach. Использование LINQ предполагает создание запросов - фрагментов кода, описывающих данные, которые требуется извлечь без указания того, как это сделать.

Использование запросов LINQ дает следующие преимущества:

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

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

Технология LINQ включает около полусотни операций, разделяющихся на две группы - отложенные ("ленивые") операции и не отложенные операции (исполняются сразу). К группе не отложенных операций относятся получение свёрток (приведение данных к единственному значению - сумме, произведению, количеству и т.п.), выборка единственного элемента, преобразование к другому типу данных (последовательности в список List, массив или словарь), а также установление эквивалентности двух наборов данных.

Чтобы получить непосредственный доступ к методам LINQ, нужно либо подключить пространство имён System.Linq, либо указывать его при каждом вызове метода. Для последовательностей в .NET нужно обращаться к классу Enumerable.

## uses System.Linq;
var s := Enumerable.Range(-3, 8);
s.Println;                                // -3 -2 -1 0 1 2 3 4
s := Enumerable.Reverse(s);
s.Print                                   // 4 3 2 1 0 -1 -2 -3

##
var s := System.Linq.Enumerable.Range(-3, 8);
s.Println;                                // -3 -2 -1 0 1 2 3 4
s := System.Linq.Enumerable.Reverse(s);
s.Print                                   // 4 3 2 1 0 -1 -2 -3

Вызовы подобной длины приходится писать, например, в языке C#. Разработчики PascalАВС.NЕТ ввели множество дополнительных функций и методов расширения, позволяющих сделать работу с LINQ существенно удобнее.

##
var s := Range(-3, 4);
s.Println;                                // -3 -2 -1 0 1 2 3 4
s := s.Reverse;
s.Print                                   // 4 3 2 1 0 -1 -2 -3

Здесь Range - уже не метод из LINQ, а функция PascalАВС.NЕТ. Если в .NET-методе второй параметр обозначал длину генерируемой последовательности, то в функции это верхняя граница диапазона данных. Сама же функция находится в системной библиотеке PABCSystem и является "обёрткой" для вызова метода .NET:

function Range(a, b: integer): sequence of integer;
begin
  if b < a then 
    Result := System.Linq.Enumerable.Empty&<integer>
  else Result := System.Linq.Enumerable.Range(a, b - a + 1);
end;

В состав .NET LINQ входят 14 типов операций: агрегация, преобразование, конкатенация, элемент, множество, генерация, группирование, соединение, упорядочивание, проекция, разбиение, ограничение, квантификатор и эквивалентность.

Решим с помощью калькулятора практическую задачу по созданию подсетей.

В некоторой организации сетевому администратору поручили организовать на базе выданного организации ip-адреса 89.16.105.0/24 три подсети емкостью 120, 58 и 15 узлов. С этой целью ему нужно подготовить задание для инженеров и указать в нем диапазоны адресов для каждой подсети.

Проверяем, имеет ли сеть достаточную емкость. Учитываем, что для подсети с n узлами потребуется емкость, равная n+2 (добавляется адрес самой подсети и широковещательный адрес). Потребное количество адресов составляет

(120+2)+(58+2)+(15+2) = 122+ 60 + 17 = 199.

Маска сети /24 означает, что 24 из 32 бит адреса заняты адресом сети, а на долю узлов (они же - хосты) остается 32-24 = 8 бит. Эти 8 бит позволяют завести 2^8 = 256 узлов, так что часть адресов попадут в запас.

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

1. 2^6 < 122 < 2^7, поэтому для подсети потребуется маска хоста с префиксом /25. 7 бит отводим на узлы подсети, остаются 32-7 = 25 бит для маски адреса. Теперь мы можем с помощью калькулятора рассчитать параметры первой подсети.

## uses School;
Print(new CalcIP('89.16.105.0', 25));

Первая подсеть будет иметь сетевой адрес 89.16.105.0/25, ее широковещательный адрес 89.16.105.127 и диапазон адресов узлов 89.16.105.1 - 89.16.105.120.

2. 2^5 < 60 < 2^6, поэтому для подсети потребуется маска длиной 6 бит; ее префикс /26. Адрес этой подсети на единицу превышает широковещательный адрес предыдущей подсети, т.е. он равен 89.16.105.128.

Print(new CalcIP('89.16.105.128', 26));

Вторая подсеть будет иметь сетевой адрес 89.16.105.128/26, ее широковещательный адрес 89.16.105.191 и диапазон адресов узлов 89.16.105.129 - 89.16.105.188.

2^4 < 17 < 2^5, поэтому для подсети потребуется маска длиной 5 бит; ее префикс /27. Адрес этой подсети на единицу превышает широковещательный адрес предыдущей подсети, т.е. он равен 89.16.105.192.

Print(new CalcIP('89.16.105.192', 27));

Третья подсеть будет иметь сетевой адрес 89.16.105.192/27, ее широковещательный адрес 89.16.105.223 и диапазон адресов узлов 89.16.105.193 - 89.16.105.207.

Конечно, этот же расчет можно было провести и "на бумаге", и с помощью калькулятора из сети Интернет, но целью этого материала было показать, что калькулятор в PascalАВС.NЕТ отлично подходит для решения подобных задач.

В библиотеке School начиная с версии PascalАВС.NЕТ 3.9.0.3360 от 21.09.23 доступен калькулятор сетей TCP/IP, реализованный на базе двух классов: собственно калькулятора CalcIP и класса 32-битных адресов Addr32, обеспечивающего работу калькулятора, а также предоставляющего удобную работу с адресами IPv4 при самостоятельном использовании.

Класс Addr32

В классе доступны на чтение три свойства (приведен пример для 192.168.0.1):

• value: string - адрес в десятичном представлении с октетами, 192.168.0.1;
• value2: string - дополненное (при необходимости) слева нулями до длины 32 бита двоичное представление адреса, 11000000101010000000000000000001;
• value10: longword - беззнаковое целое значение адреса, 3232235521.

Метод AddrFormat(addr: string): string форматирует параметр addr, разделяя точкой каждые 8 бит: 11000000.10101000.00000000.00000001.

Перегруженный метод .ToString: string служит для простого и наглядного вывода значений адресов созданного объекта:

## uses School;

var a := new Addr32('192.168.0.1');
Print(a)
{
192.168.0.1,   11000000.10101000.00000000.00000001
}

В классе перегружены три логические побитовые операции: and; or, not. Они могут быть полезны для операций с маской. Применяются в коде программы, естественно, к самим объектам, а не к их свойствам. Например, наложим на сетевой адрес 135.12.171.214 маску 255.255.248 и получим адрес сети:

## uses School;

var ip := new Addr32('135.12.171.214');
var mask := new Addr32('255.255.248.0');
var net_addr := ip and mask;
Print(net_addr)
{
135.12.168.0,  10000111.00001100.10101000.00000000
}

Перегрузка операции сложения (+) позволяет складывать с адресом целое число n: lobgword, тем самым получая новый адрес, отстоящий от имеющегося на n. Такая операция полезна при переборе адресов.

## uses School;

var ip := new Addr32('135.12.171.214');
for var i := 0 to 5 do
  Println(ip + i)
{
135.12.171.214,10000111.00001100.10101011.11010110 
135.12.171.215,10000111.00001100.10101011.11010111 
135.12.171.216,10000111.00001100.10101011.11011000 
135.12.171.217,10000111.00001100.10101011.11011001 
135.12.171.218,10000111.00001100.10101011.11011010 
135.12.171.219,10000111.00001100.10101011.11011011 
}

Класс содержит два конструктора. Аргумент первого из них - адрес в десятичной записи с октетами. В приведенных примерах вызывался именно этот конструктор. Второй конструктор используется для построения маски сети по префиксу - количеству единичных бит в левой части маски. Например, для сетевого адреса a.b.c.d/19 маску можно создать вызовом Addr32(19).

## uses School;

var mask := new Addr32(19);
Print(mask)
{
255.255.224.0, 11111111.11111111.11100000.00000000 
}

Класс CalcIP

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

• Address: Addr32 - IP-адрес;
• Netmask: Addr32 - маска сетевого адреса;
• Bitmask: byte - количество единиц в маске адреса сети;
• Hosts: integer- количество хостов в сети (исключая адрес сети и широковещательный адрес)
• Wildcard: Addr32- маска хостов (инверсия Bitmask);
• Network: Addr32- адрес сети;
• Broadcast: Addr32- широковещательный адрес;
• Hostmin: Addr32- адрес первого хоста;
• Hostmax: Addr32- адрес последнего хоста.

Перегруженный метод .ToString: string служит для вывода всех свойств объекта в отформатированном виде:

Класс содержит два конструктора. Первый требует задать в виде десятичных адресов с октетами ip-адрес и маску сети. Пример вызова такого конструктора приведен на рисунке выше. Этот же калькулятор можно было создать, задав в качестве второго параметра префикс маски подсети, т.е. /28:

var calc := new CalcIP('202.75.38.176', 28);

Генератор адресов GenAddrBin: sequence of string позволяет создавать последовательность двоичных адресов хостов, включая адрес сети и широковещательный адрес. Формат адреса - Addr32.value2.

Еще один генератор адресов GenAddr: sequence of Addr32 может быть использован для более сложной работы с адресными объектами.

Пример. Решение задачи с сайта К. Полякова

(№ 6844) (К. Багдасарян) В терминологии сетей TCP/IP маской сети называют двоичное число, которое показывает, какая часть IP-адреса узла сети относится к адресу сети, а какая - к адресу узла в этой сети. Адрес сети получается в результате применения поразрядной конъюнкции к заданному адресу узла и маске сети. Сеть задана IP-адресом 202.75.38.176 и маской сети 255.255.255.240.
Сколько в этой сети IP-адресов, у которых в двоичной записи IP-адреса никакие три единицы или три нуля не стоят рядом?
В ответе укажите только число.

## uses School;

var calc6844 := new CalcIP('202.75.38.176', '255.255.255.240');
calc6844.GenAddrBin.Count(addr -> not addr.IsMatch('000|111')).Println;

Ответ: 5.

Назначение и основные возможности

Калькулятор сетей доступен в PascalАВС.NЕТ версии не ниже 3.9.0.3360 от 21.09.2023. Он дает возможность в наглядном виде получить основную информацию о подсетях TCP/IP, задав адрес сети и маску подсети.

Реализация

Калькулятор реализован на базе двух классов.

Класс с именем Addr32 позволяет создавать объекты, моделирующие 32-битные сетевые адреса IPv4 и маски. Пользователю доступны три свойства адреса: value (десятичный адрес в формате с октетами, например, 15.218.42.12), value2 (адрес в виде беззнакового двоичного числа длиной 32 бита) и value10 (адрес, переведенный из двоичной системы счисления в десятичную). Для объектов этого класса перегружены побитовые логические операции and, or, not, а также операция + для сложения адреса с целочисленным значением (инкремент). Это дает простоту и удобство при работе с масками.

Другой класс с именем CalcIP - это сам калькулятор на основе заданного сетевого адреса и маски. Маску можно задавать в формате десятичного адреса, префикса или непосредственно в виде 32-битной строки. У калькулятора девять свойств и их имена перечислены в круглых скобках на приведенном выше рисунке. Свойство Bitmask имеет тип byte, свойство Hosts - тип integer, а остальные семь являются объектами класса Addr32. Таким образом, если создать калькулятор с именем MyCalc, двоичный адрес первого хоста в коде программы будет доступен под именем MyCalc.Hostmin.value2.

Что еще можно получить с помощью калькулятора

Создав объект класса Addr32 на основе того или иного формата адреса, можно получить отображение этого адреса. Перегруженный метод .ToString позволяет сформировать строку, содержащую адрес в удобном для восприятия виде. Например, оператор Print(new Addr32('34.118.53.125')); выведет:
34.118.53.125, 00100010.01110110.00110101.01111101

Метод калькулятора GenAddr - генератор адресов хостов. Он возвращает последовательность адресов в виде объектов класса Addr32.

Еще один генератор, GenAddrBin, возвращает последовательность двоичных 32-битных адресов - это удобно для операций с битовой маской. Поскольку 32-битное отображение - это строка, применение к нему регулярных выражений открывает широчайшие возможности.

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

1. Вот так можно получить сетевую информацию, задав ip-адрес и маску.

2. Решение варианта задания 13 с сайта К. Полякова.

(№ 6842) (К. Багдасарян) В терминологии сетей TCP/IP маской сети называют двоичное число, которое показывает, какая часть IP-адреса узла сети относится к адресу сети, а какая - к адресу узла в этой сети. Адрес сети получается в результате применения поразрядной конъюнкции к заданному адресу узла и маске сети. Сеть задана IP-адресом 158.132.161.128 и маской сети 255.255.255.128.
Сколько в этой сети IP-адресов, которые в двоичной записи IP-адреса оканчиваются единицей?
В ответе укажите только число.

## uses School;

var x := new CalcIP('58.132.161.128', '255.255.255.128');
x.GenAddrBin.Count(addr -> addr[^1] = '1').Println;     // 64

Что дальше?

Следующий материал на эту тему будет посвящен деталям работы с калькулятором сетей TCP/IP.

1. Немного теории

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

Среда .NET предоставляет несколько типов коллекций, но мы остановимся только на одном: обобщенных коллекциях, которые часто также называют дженéриками (англ. generic). Все элементы в обобщенной коллекции имеют единый тип T, который указывается в программе, что позволяет создавать компилятору быстрый и надежный код. Подстановка конкретного типа на место T, которую выполняет компилятор, называется инстанцированием. Так, для коллекции List<T> мы должны указывать известный компилятору тип, например, List<integer>.

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

2. Как, ничего не зная об ООП, построить свой список List<T>

Термин list (англ. список) в информатике обозначает структуру, в которой данные упорядочены некоторым образом и могут повторяться. В таком определении список является моделью конечной математической последовательности. От массива список отличается возможностью удалять и добавлять элементы в любом месте. Сразу же отметьте, что реализация коллекции List<T> наиболее эффективно выполняет добавление и удаление элементов в конце списка, наименее эффективно - внутри него. Коллекция реализована на базе обыкновенного динамического массива, для которого добавлены методы вставки и удаления элементов.

type
  TList = array of integer;

function Add(Self: TList; elem: integer): Tlist; extensionmethod;
// добавление элемента elem в конец списка
begin
  Result := Self + |elem|;
end;

function Remove(Self: TList; elem: integer):TList; extensionmethod;
// удаление первого найденного элемента со значением elem
begin
  var i := Self.FindIndex(t -> t = elem);
  if i > -1 then Result := Self[:i] + Self?[i + 1:]
  else Result := Self
end;

begin
  var a: Tlist := |5, -2, 1, 4, 0, 4, 2|;
  a.Println;                              // 5 -2 1 4 0 4 2 
  a := a.Add(7);
  a.Println;                              // 5 -2 1 4 0 4 2 7
  a := a.Remove(0);
  a.Print                                 // 5 -2 1 4 4 2 7
end.

Конечно, если вам известны методы Add и Remove для списка List<T>, вы помните, что они работают, как процедуры, т.е. изменяют значение переданного им экземпляра коллекции, а не возвращают ее новый экземпляр. Здесь так написать нельзя, поскольку параметр Self не может указываться с var за исключением случая, когда он является строкой string. Но если освоите ООП, сможете создавать свои классы и там делать все "по-настоящему".

Нужно понимать, что приведенный выше код - лишь модель, поясняющая суть устройства списка List<T>.Она реализована на базе обыкновенного динамического массива, для которого добавлены методы вставки и удаления элементов.

В языке PascalАВС.NЕТ при описании формальных параметров подпрограммы в качестве типа можно указать интерфейс. В самом деле, и класс, и интерфейс - это типы данных, так что ничего необычайного тут нет. Но, указав интерфейс, мы можем придать подпрограмме некоторую универсальность. Хотим работать с индексами (массивы, списки) - указываем интерфейс IList, не хотим (но при этом еще и с последовательностями можно работать) - указываем IEnumerable.

function Exotic(x: IEnumerable<integer>): real;
begin
  Result := 0.0;
  foreach var a in x do
    Result += a ** 2;
  Result := Sqrt(Result)
end;

begin
  var s := Seq(3, 4, 5);
  Println(Exotic(s));
  var a := |3, 4, 5|;
  Println(Exotic(a));
  var L := Lst(3, 4, 5);
  Println(Exotic(L));
end.
{
7.07106781186548 
7.07106781186548 
7.07106781186548 
}

Посмотрите: наша функция охотно принимает в качестве параметра и последовательность, и массив, и список!

А нельзя ли написать такую же функцию, которая еще и тип T будет обрабатывать с тем, чтобы при конкретном обращении к ней происходило инстанцирование типа? С параметром IEnumerable<T>. Можно. Но оставим такую задачу для модуля с ООП. В конце-концов, должна же быть в курсе какая-то интрига?

В курсе рассматриваются возможности языка, не вошедшие ни в один из ранее вышедших курсов. Большая часть этого материала имеется в книге "PascalАВС.NЕТ: введение в современное программирование", но на момент начала создания этого курса книга готовилась праздновать свой трехлетний юбилей, а язык развивается непрерывно...

Если ознакомиться с пятью ранее написанными мной учебными курсами, может возникнуть глубоко неверное впечатление, что PascalАВС.NЕТ создавался для школьных нужд, включая сдачу ЕГЭ. На самом деле, это полноценный универсальный .NET-язык, позволяющий решать широчайший круг задач. Другое дело, что учебных часов в школе недостаточно для сколь-нибудь глубокого изучения этого замечательного языка. К тому же, школьные задачи совершенно не требуют знания и умения применять обработку ошибок, серьезную работу с файлами, подключения внешних библиотек и объектно-ориентированного программирования на уровне написания собственных классов. "За бортом" школы остаются и многие другие знания, навыки и умения, с которыми вы познакомитесь в этом курсе.

Для кого предназначен курс

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

Программа курса

1. Введение
2. Типы данных в PascalАВС.NЕТ
3. Подпрограммы
4. Последовательности и обобщенные коллекции
5. Строки. Регулярные выражения
6. Текстовые файлы
7. Модули и библиотеки
8. Обработка ошибок
9. Объектно-ориентированное программирование (ООП)

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

Функция Digits(n) и расширение n.Digits позволяют получить список List<integer>, содержащий цифры десятичного числа n. Теперь у Digits появился необязательный целочисленный параметр base, позволяющий указать основание системы счисления, в которой требуется получить цифры числа. При основании, превышающем 10, каждая "цифра" числа представляется соответствующим десятичным числом. Поскольку основание может быть многоразрядным числом, такие "цифры" тоже могут оказаться многоразрядными. Например, рассмотрим представление числа 1234567890 в системе счисления по основанию 2023. Очевидно, что каждая "цифра" представления может находиться в интервале [0;2022].

Понятно, что в данном случае бессмысленно говорить о каком-то специальном алфавите, позволяющий одним символом представить любую из 2023 "цифр". Поэтому было принято решение оставить числа "как есть" и записывать представление числа 1234567890 по основанию 2023 как [301, 1342, 1795]. Но ведь в таком виде это коэффициенты полинома P(2023), представленные в порядке убывания степеней числа 2023. Отсюда возникла идея ввести функцию, выполняющую обратную операцию: по списку коэффициентов полинома получить числовое значение полинома. А это равнозначно переводу числа из системы счисления по заданному основанию в десятичную систему. Так в библиотеке School появились функция и расширение DigitsToInt64.

2. DigitsToInt64

Функция DigitsToInt64(L, base) и расширение L.Digits(base) позволяют перевести число из расширенной формы представления в системе счисления по основанию base в десятичную систему счисления. Здесь L - список типа List<integer>, полученный в результате использования Digits или созданный иным способом. По умолчанию base = 10 и в этом случае параметр можно опускать.

Эту же функцию можно использовать для вычисления значения полинома по упорядоченному списку коэффициентов.

3. Практическое применение

Перевести число 105516 в шестнадцатиричную систему счисления и сделать проверку обратным переводом в десятичную систему.

## uses School;
var q := 105516.Digits(16);
q.Println; // 1 9 12 2 12
q.DigitsToInt64(16).Print // 105516

Найти сумму "цифр" десятичного числа 7456330, представленного в системе счисления по основанию 43.

## uses School;
7456330.Digits(43).Sum.Print // 70

Решить задачу №5823 из задания 14 с сайта К.Ю. Полякова.

(А. Богданов) Операнды арифметического выражения записаны в системе счисления с некоторым частично заданным основанием (основания указаны в скобках - замечание моё):

13(132х4) - 13х42(22)

В записи чисел переменной x обозначена неизвестная цифра. Определите наибольшее значение x, при котором абсолютное значение данного арифметического выражения при делении на 100 даёт остаток 53. Для найденного значения x вычислите целое частное от деления абсолютного значения арифметического выражения на 100 и укажите его в ответе в десятичной системе счисления. Основание системы счисления в ответе указывать не нужно.

## uses School;
for var x := 9 downto 0 do
begin
var v := Abs(Lst(1, 3).DigitsToInt64(13200 + 10 * x + 4) -
Lst(1, 3, x, 4, 2).DigitsToInt64(22));
if v mod 100 = 53 then
begin
Print(v div 100); // 2554
break
end
end

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

Запись стала короче. Но всегда ли можно так просто использовать Print вместо Write? Оказывается, не всегда. В Print нельзя указывать формат вывода данных - общую ширину поля и количество знаков в дробной части для вещественного типа. А что же делать? И тут два выхода: либо все же использовать Write (в этом случае "Здоровье кода" очки не снимает), либо использовать форматирование средствами .NET.

Самый простой вариант вывода средствами .NET - использовать интерполированную строку. Она начинается с символа $, указываемого перед собственно строкой, заключенной в одинарные кавычки: $' ... '.

Фактически, мы пишем строку так, как она должна выглядеть на экране, а выводимые значения заключаем в фигурные скобки. Самое сложное тут - заучить форматы представления данных. Но на первое время достаточно следующего:

• если нужно указать ширину поля вывода, ее отделяют от выводимой переменной (или выражения) запятой, за которой следует выражение, значение которого задает ширину. В случае, когда значение отрицательное, выводимое значение прижимается к левому краю, в противном случае - к правому;
• далее можно указать символ, определяющий тип выводимого значения, например D - целочисленное, F - вещественное, S - строковое, B - логическое. Этому символу предшествует двоеточие.
• для вещественных чисел после F можно указать количество выводимых цифр в дробной части. По умолчанию используется формат F2.

Этого на первое время более чем достаточно для оформления вывода. Хотите знать больше - ищите материал про интерполяцию строк в .NET или в материалах по языку C#.

##
var (a, b, c, d) := (8, -4.63, 'Приветик', 5 > 3);
Println($'{a} {b} {c} {d}');                    // 8 -4.63 Приветик True
Println($'a={a}, b={b}, c={c}, d={d}');         // a=8, b=-4.63, c=Приветик, d=True
Println($'{a,5} {b,8} {c,-9}{d}');              //     8    -4.63 Приветик True
Println($'{a,5:D}{b,8:F3} {c} {d}');            //     8  -4.630 Приветик True
Println($'{a,5:D3}{b,8:F3} {c} {d}');           //   008  -4.630 Приветик True 
Println($'{a,5:D3}{b,8:F3}{c,10:S} {d}');       //   008  -4.630  Приветик True
Println($'{a,5:D3}{b,8:F3}{c,10:S} {d,6:B}');   //   008  -4.630  Приветик   True
Println($'{a,5:D3}{b,8:F3} {c,-11:S}{d}');      //   008  -4.630 Приветик   True
Println($'{a,5:D2}  {b,-6:F0} {c,-9:S}{d}');    //    08  -5     Приветик True

Немного теории

В диапазоне от 2 до 2 147 483 647 содержится 105 097 565 простых чисел. На выяснение этого факта мой компьютер потратил 13,2 с (с учетом того, что был получен список всех этих 105 миллионов чисел). Понятно, что никакое обычное "решето" не сможет просеять два с лишним миллиарда чисел по той простой причине, что в программе не получится объявить массив подобного размера. Поэтому приходится использовать алгоритм "Модифицированное решето Эратосфена". Его суть в том, что весь диапазон чисел разбивается на поддиапазоны (сегменты) и каждом из них используются простые числа, полученные в предшествующем диапазоне. Конечно, это несколько увеличивает время работы.

Алгоритм проверки числа на простоту предусматривает перебор его возможных делителей. Понятно, что проверив делимость на 2, далее нужно проверять только нечетные делители. И понятно, что проверять нужно делители, квадрат которых не превышает самого числа. Это означает, что делители числа типа integer не могут превышать квадратного корня из числа 2 147 483 647, т.е. значения 46 340. А этому интервалу принадлежат всего-то 4 704 простых числа. Так почему бы не потратить смехотворное время и заранее не просеять эти 46340 чисел, получив массив простых чисел размером 4 704 элемента?

Но... ох уж это маленькое "но"! Квадрат числа 46340 равен 2 147 395 600 и числа из диапазона [2 147 395 601; 2 147 483 647] из проверки выпадают. А там находятся еще 4 085 простых чисел! Посему придется увеличить 46 340 на единицу и смириться с тем, что квадрат 46 341 требует для размещения тип int64.

И тут мы обнаруживаем, что модифицированное решето Эратосфена требует, чтобы длина сегмента была простым числом. А ближайшее простое, большее или равное 46 341 - это 46 349. Вот таков окончательный размер решета.

Реализация

Если заглянуть в исходный код библиотеки School, можно обнаружить три "магические" переменные и список LPrimes.

LPrimes: List<integer>; // на отрезке [2;46348]
ubPrimeDivs := 46349;
nPrimeDivs: integer; // 4792
MaxPrimeDiv: integer; // 46349

Вы уже увидели в этой "магии" то самое значение 46 349? Но что такое 4 792? А это количество простых чисел на интервале длиной 46 349, т.е. [0; 46 348] и там их ровно 4 792.

При запуске программы, использующей библиотеку School, всегда "на всякий случай" заполняется список LPrimes, содержащий 4792 первых простых числа - делителей из нулевого сегмента "решета". Это всего-то менее 20К памяти, а процесс увеличивает время запуска на совершенно смехотворную величину.

Что это даёт

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