Понадобилось тут перекодировать URL с русскими буквами в нормальный текст, т.е. нечто вида https://ru.wikipedia.org/wiki/URL#%D0%9A%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_URL в читабельный вид https://ru.wikipedia.org/wiki/URL#Кодирование_URL

В MSDN сходу нашлось решение для .NET Framework 4, а вот для 2.0 так сразу не нашлось, но оказалось, что все-таки решение есть.

string text = https://ru.wikipedia.org/wiki/URL#%D0%9A%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_URL
text = text.Replace("+", " ");
text = System.Uri.UnescapeDataString(text);

string text = https://ru.wikipedia.org/wiki/URL#Кодирование_URL
text = System.Uri.EscapeDataString(text);

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

1. https://ru.wikipedia.org/wiki/URL#Кодирование_URL

2. Сам способ нашел здесь, у няшного серфера и программера.
Html and Uri String Encoding without System.Web
Там еще есть и способ кодирования эскейп-последовательностей HTML.

Ну чтоб не потерять, еще и класс на PasteBin и Mega.NZ

Известно, что любые данные хранятся в памяти компьютера в виде последовательности байт, байт обычно равен 8 битам (но бывают и исключения, о которых сейчас не будем). Числа не исключение, например, когда мы определяем переменную int, фактически мы говорим компилятору «выдай нам 4 байта по такому-то адресу в памяти, для записи числа от -2147483648 до 2147483647». Конкретный адрес, конечно, заботливо выбирает для нас среда .NET, и обычно, лезть туда руками не нужно, среда все прекрасно за нас сделает. Пока не случается какой-нибудь хитрый случай, и тут уже приходится думать самому. Когда работаешь с однобайтовыми числами, обычно никаких чудес не происходит — байт он и на десктопной машине с Windows или Linux байт, и на сервере байт, и даже на роутере, телефоне и утюге, скорее всего будет тем же самым байтом. Но все было бы хорошо, если бы одного байта хватало всем 🙂
Как уже сказано выше, тот же int, это не один байт, а 4, и вот тут кроется проблема. Эти самые байты можно хранить в памяти как угодно, хоть через один, хоть в шахматном порядке.
На наше счастье, такие извращения, если и встречаются, то очень редко. В большинстве вычислительных устройств байты (одного числа, например типа int), хранятся либо в последовательности от старшего к младшему big-endian, либо от младшего к старшему little-endian. В случае big-endian первым идет старший разряд числа, а остальные по ранжиру за ним, в случае ltiite-endian — наоборот, первым идет самый младший, последним — самый старший.

Чтобы было проще представить, предположим, что в 1 байт влезает не десятичное число от 0 до 255 (256 значений), а всего 10 значений, т.е. числа от 0 до 9.
В таком случае число 1234 будет «четырехбайтовым», и в случае, если оно записывается в порядке big—endian, то в памяти оно будет храниться в обычном для нас виде, как последовательность 1 2 3 4, поэтому, порядок big-endian еще называют прямым порядком байт. Если же число хранится в порядке little-endian, то в памяти оно будет выглядеть, как последовательность 4 3 2 1, поэтому порядок little-endian называют обратным порядком байт.

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

Итак:
Big-endian — «от старшего к младшему», он же прямой, сетевой (поскольку принят в качестве стандартного порядка байт при передаче данных по сети), Motorola byte order (использовался в процессорах Motorola, а не в честь уехавшего на социальном лифте деятеля).
В big-endian формате хранятся IP-адреса.
Little-endian — «От младшего к старшему», обратный, интеловский (используется в процессорах Intel), VAX (использовался на платформе VAX).

int Constant = 16909060;
byte[] LittleEndian = new byte[] {4, 3, 2, 1};
byte[] BigEndian = new byte[] {1, 2, 3, 4 };

Да, число подобрано специально, чтобы было красивое представление его в массиве байт. 🙂

Попробуем провести обратное преобразование с помощью класса BitConverter, который как раз и предназначен для получения из последовательности байт чисел соответствующих типов:

BitConverter.ToInt32(LittleEndian,0); //результат - 16909060
BitConverter.ToInt32(BigEndian, 0); //результат - 67305985

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

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

Для того, чтобы средствами .NET узнать, какой порядок байт используется на машине, где выполняется ваша программа, можно посмотреть в переменную IsLittleEndian класса BitConverter. Если она принимает значение true, то используется, соответственно, порядок little-endian (обратный):

if (BitConverter.IsLittleEndian)
{
    Console.WriteLine("little-endian");
}
else
{
    Console.WriteLine("most likely big-endian");
}

Создадим перечисление ByteOrder(для красоты :):

private enum ByteOrder
{
    BigEndian = 0,
    LittleEndian = 1,
    Unknow = 3
}

И напишем функцию:

ByteOrder DetectBO()
{    
    int Constant = 16909060;
    byte[] LittleEndian = new byte[] { 4, 3, 2, 1 };
    byte[] BigEndian = new byte[] { 1, 2, 3, 4 };

    if (BitConverter.ToInt32(BigEndian, 0) == Constant) 
        return ByteOrder.BigEndian;
    if (BitConverter.ToInt32(LittleEndian, 0) == Constant) 
        return ByteOrder.LittleEndian;
    
    return ByteOrder.Unknow;
}

Примечание: в тексте в кодировке UTF-16 можно определить UTF-16LE или UTF-16BE при помощи BOM, при его наличии

А вот тут у .NET Framework’а все как-то печально, частично могут помочь статические функции класса System.Net.IPAddress NetworkToHostOrder() и HostToNetworkOrder(), преобразующие, соответственно, число, полученное в big-endian в формат, используемый на данной машине и наоборот, но они довольно ограничены, поддерживают только long, int и short значения, не поддерживают работу с беззнаковыми числами и числами с плавающей запятой, а также с массивами байт. Вот способ преобразования порядка байт:

1. Преобразовать исходное число в массив байт с помощью BitConverter.GetBytes() или взять готовый массив, если он есть.
2. Перевернуть массив функцией Array.Reverse()
3. Преобразовать развернутый массив обратно, с помощью одной из функций класса BitConverter:

byte [] ConvArray = BitConverter.GetBytes(BigEndianValue);
Array.Reverse(ConvArray);
ushort LittleEndianValue = BitConverter.ToUInt16(ConvArray,0);

Минус — относительно медленная функция Array.Reverse. И BitConverter тоже не самый быстрый класс, зато довольно наглядно.

Внимание! Функция Array.Reverse() не создает копии массива, а работает с указанным массивом прямо в памяти. Если в функцию, в которой используется Array.Reverse() будет передан массив из вызывающей подпрограммы, и функция Array.Reverse() будет к массиву применена, то массив изменится. Такое поведение может породить труднообнаруживаемую ошибку, поэтому, если массив в оригинальном виде планируется еще где-либо использовать, то перед Array.Reverse() надо сделать его копию с помощью Array.Copy().

1. Порядок байтов
2. Разбираемся с прямым и обратным порядком байтов
3. MSDN

Пример к заметке на GitHub

Unix-time — способ хранения времени, используемый обычно в POSIX-совместимых системах. Определяется, как количество секунд, прошедших с 01.01.1970 00:00:00, может встречаться в логах, базах данных, и т.д., как отметка времени (timestamp). Следующий алгоритм поможет преобразовать Unix-время в DateTime:

1. Заводим переменную DateTime и инициализируем ее точкой отсчета Unix-time, т.е. полночью 1 января 1970 года:
DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0);
2. Используем метод AddSecounds(), чтобы добавить количество секунд, в качестве аргумента передаем переменную, содержащую Unix-time:
origin.AddSeconds(UnixTime);

Вся функция:

private DateTime UnixTimeToDateTime(double UnixTime)
{
    DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0);
    return origin.AddSeconds(UnixTime);
}

На PasteBin

Если Unix-time хранится в целочисленной переменной, меняем double на нужный тип, компилятор сам преобразует ее в тип double, нужный AddSecounds.

Простая задачка, решаемая в две строки.

1. Получаем значение переменной окружения PATH:
string path_var=Environment.GetEnvironmentVariable("PATH");
2. Пути в PATH разделяются символом ; (точка с запятой), соответственно, можно получить массив со списком директорий с помощью функции Split():
string[] dirs = path_var.Split(';');

Единственное что нужно не забыть перед использованием — последний элемент массива может оказаться пустым, если PATH заканчивается точкой с запятой, и между элементами в переменной PATH могут быть пробелы, надо не забыть сделать Trim()перед использованием значения из массива.

Спрашивают, а возможно ли совместить пример с динамически обновляемой NotifyIcon Копия с примером про наложение изображения Копия, чтобы получить что-то типа такого же эффекта, который делает иконка сетевого соединения в Windows 7 при разрыве соединения?

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

Но если очень хочется, то можно.

Для разнообразия будем считать, что основное изображение у нас уже в формате ICO:

А накладываемое должно быть PNG с прозрачностью. Накладывать будем желтый треугольник с красным восклицательным знаком:

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

— Заводим необходимые переменные:

Icon TargetIcon = Properties.Resources.target;
Bitmap TargetBitmap = null;
Bitmap ResultBitmap = null;
Bitmap OverlayBitmap = null;
IconConverter icconv = null;

И не забываем экспортировать функцию DestroyIcon из user32.dll [1]:

[System.Runtime.InteropServices.DllImport("user32.dll",
            CharSet = System.Runtime.InteropServices.CharSet.Auto)]
extern static bool DestroyIcon(IntPtr handle);

— Конвертируем иконку TargetIcon в Bitmap. Делается это при помощи класса IconConverter:

//convert icon to bitmap (target)
icconv = new IconConverter();
TargetBitmap = (Bitmap)icconv.ConvertTo(TargetIcon, typeof(Bitmap));

— Достаем из ресурсов накладываемое изображение и далее поступаем, как в [2]:

//overlay bitmap
OverlayBitmap = Properties.Resources.overlay;

//create result bitmap
ResultBitmap = new Bitmap(TargetBitmap.Width, TargetBitmap.Height,
    PixelFormat.Format32bppArgb);

//create Graphics
Graphics graph = Graphics.FromImage(ResultBitmap);
graph.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver;

//Draw overlay images
graph.DrawImage(TargetBitmap, 0, 0);
graph.DrawImage(OverlayBitmap, 0, TargetBitmap.Height-OverlayBitmap.Height);            

//result =)
pbTarget.Image = TargetBitmap;
pbOverlay.Image = OverlayBitmap;
pbResult.Image = ResultBitmap;

Когда надо, преобразуем ResultBitmap, где хранится иконка с наложенным изображением, обратно в Icon, и присваиваем ее соответствующему свойству компонента NotifyIcon:

IntPtr hIcon = ResultBitmap.GetHicon();
System.Drawing.Icon niicon = System.Drawing.Icon.FromHandle(hIcon);
niTest.Icon = niicon;

DestroyIcon(niicon.Handle);

Вот что получилось:

1. C#, динамическая NotifyIcon, иконка в области уведомления Копия
2. C#, WindowsForms, наложение изображений, изменение размеров изображения. Копия

Код примера на GitHub

Задали вопрос, а можно ли в C# программными средствами наложить 2 изображения друг на друга. И даже сами потом предложили какое-то жуткое решение с привлечением WinAPI, и чуть ли не ассемблера со злыми духами.

На самом деле, задача вполне себе решается стандартными средствами.

Итак, предположим, что у нас есть 2 изображения, оба они PNG с прозрачностью, и лежат в ресурсах нашего приложения. Например, флаг:

и герб:

под именами, соответственно Properties.Resources.flag и Properties.Resources.trizub_small

Сначала сделаем из изображений два объекта Bitmap:

//Берем целевое изображение
Bitmap TargetBitmap = Properties.Resources.flag;

//Берем накладываемое изображение
Bitmap OverlayBitmap = Properties.Resources.trizub_small;

Теперь надо создать результирующее изображение (оно будет пока пустым) нужного размера:

//Создаем результирующее изображение (пока пустое)
Bitmap ResultBitmap = new Bitmap(TargetBitmap.Width, TargetBitmap.Height,
            PixelFormat.Format32bppArgb);

Откуда взяли высоту и ширину — понятно, третий параметр PixelFormat берется в зависимости от исходных изображений. Желательно, чтоб они совпадали по глубине цвета, иначе получится некрасиво, может потеряться прозрачность или произойти еще какая-нибудь бяка. Я сделал 2 изображения с прозрачностью (ARGB) и глубиной цвета 32 бита.

Теперь нужно создать объект Graphics, который и будет заниматься совмещением изображений. Раз мы будем рисовать в пустом Bitmap ResultBitmap, то и объект Graphics создаем из него, воспользовавшись методом Graphics.FromImage():

//Создаем объект Graphics из результирующего изображения
Graphics graph = Graphics.FromImage(ResultBitmap);

Далее объект graph надо настроить:

//настраиваем метод совмещения изображений
graph.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver;

Если вместо SourceOver установить SourceCopy, то потеряется вся прозрачность у накладываемого изображения, и будет некрасиво:

Далее, производим отрисовку:

//рисуем основное изображение
graph.DrawImage(TargetBitmap, 0, 0);

//рисуем накладываемое изображение
graph.DrawImage(OverlayBitmap, (TargetBitmap.Width-OverlayBitmap.Width)/2,
(TargetBitmap.Height-OverlayBitmap.Height)/2,
OverlayBitmap.Width,OverlayBitmap.Height);

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

Осталось только присвоить Bitmap'ы PictureBox'ам

Тут тоже ничего сложного и сверхъестественного нет.

Чтоб два раза не вставать, возьмем полученное выше изображение и уменьшим его:

//задаем новые размеры
int NewWidth = ResultBitmap.Width / 2;
int NewHeight = ResultBitmap.Height / 2;
//Настраиваем PictureBox для вывода уменьшенного изображения
pbResize.Size = new Size(NewWidth, NewHeight);

Создадим новый Bitmap для будущего уменьшенного изображения:

//создаем новый Bitmap для измененного изображения
Bitmap ResizeBitmap = new Bitmap(NewWidth,
NewHeight);

Опять создадим объект Graphics, который будет заниматься отрисовкой:

//создаем объект Graphics, который будет изменять размер
Graphics ResizeGraph = Graphics.FromImage(ResizeBitmap);

Поставим повыше качество изображения:

//ставим высокое качество
ResizeGraph.InterpolationMode =
System.Drawing.Drawing2D.InterpolationMode.High;

И делаем отрисовку:

//рисуем изображение с измененным размером
ResizeGraph.DrawImage(ResultBitmap, 0, 0, NewWidth, NewHeight);

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

Вот, что получилось:

Исходник примера на GitHub

Решил побороть еще одно узкое место в коде, которое приводит к невероятному количеству ручного кодинга, а именно — загрузка данных из записи DataSet или произвольного объекта в форму, для изменения/ввода данных пользователем, а потом обратная выгрузка.

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

Оказывается, можно. Все инструменты для этого есть — есть System.Reflection, через инструменты данного пространства имен можно получать имена свойств или полей нужного класса, а также тип данных, и есть методы для поиска нужных контролов на форме, чтобы загрузить или сохранить данные в/из объекта.

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

Опять же, тут будет краткое рассуждение, а пример кода в конце.

Основные компоненты это:
— текстовые поля, куда можно ввести либо строку, либо число (фильтрацию ввода оставим форме)
— checkbox’ы, хранящие булево значение
— radiobutton’ы/переключатели — ограниченный выбор из определенного набора вариантов.

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

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

public enum NetConnectionType
{
    NoProxy = 0,
    SystemProxy = 1,
    ManualProxy = 2
}

Для радиокнопок (переключателей) имя формируется по следующему принципу: префикс rb+НазваниеСвойства+ЗначениеВEnum, т.е., например, радиокнопка, указывающая на прямое соединение, будет называться rbConnectionNoProxy

Думаете, сложно и длинно? Ну, может быть, только сталкиваешься с этим потом один раз, когда моделируешь форму.

Получение списка радиокнопок и поиск контрола на форме Копия

Получение значения Enum из состояния RadioButton:

private string GetEnumValFromRb(string PropName)
{
    string EnumVal = string.Empty;
    string rbName = "rb"+PropName;            
    
    foreach (RadioButton rb in RadioButtons)
    {                
        if (rb.Checked)
        {
            if (rb.Name.StartsWith(rbName))
            {
                EnumVal = rb.Name.Substring(rbName.Length);
            }
        }
    }

    return EnumVal;
}

На GitHub

Если нам нужно найти контрол на форме, зная его имя, то все решается довольно просто — у массива контролов Controls есть метод Find, который найдет нам что нужно, если указать правильное имя контрола:

private Control FindControl(string ControlName, Form form)
{
    Control ctrl = null;

    Control[] buf = form.Controls.Find(ControlName, true);
    if (buf.Length == 0) return null;
    if (buf.Length > 1) return null;

    ctrl = buf[0];

    return ctrl;
}

Вот тут уже сложнее, особенно с переключателями. Они обычно сидят на форме в контейнерах, например в GroupBox'ах, и функция Find тут не поможет. Необходим другой подход, если мы хотим получить список контролов определенного типа. А именно — надо сделать рекурсивную функцию поиска. Кто боится рекурсии и связанных с ней переполнений, скажу, что ничего страшного нет.
Мне удалось уронить студию на 5 000 однотипных компонентов, а подобное число компонентов вряд ли может быть в реальности, только если вы не радиокнопочный маньяк 🙂

Функция такая вот:

private List FindAllRadiobuttons(Control.ControlCollection collection)
{
    List  result = new List();
    foreach (Control ctrl in collection)
    {
        if (ctrl.HasChildren)
        {
            result.AddRange(this.FindAllRadiobuttons(ctrl.Controls));
        }
        if (ctrl is RadioButton)
        {
            result.Add((RadioButton)ctrl);
        }
    }

    return result;
}

Т.е. если мы просто наткнулись на переключатель, при переборе контролов из массива Controls, то добавляем переключатель в массив, если же, мы наткнулись на контрол-контейнер (ctrl.HasChildren == true), то вызываем функцию перебора массива уже для массива Controls контейнера.

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

Есть способ еще более уменьшить количество кода, воспользовавшись стандартным механизмом .NET Framework — сериализацией. Сериализация, это, по рабоче-крестьянски говоря, именно что сохранение состояния объекта (он же пафосно называется «экземпляром класса») в некий передаваемый формат. Доскональное объяснение, что это такое, в статью не влезет, потому оставим.

Итак, переходим к сериализации.

В .NET Framework сам себя класс сериализовать не может, точнее, сериализовать-то может, а вот десериализовать — нифига. Класс и его экземпляр, получается, как Штирлиц с раненой радисткой Кэт, передать могут, а обратно нет, без дружественной помощи.

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

Итак, создадим класс-хранилище, вот такой вот, например:

[Serializable]
public class AppSettings
{
    public string DataUrl { get; set; }
    public FormatType DataFormat { get; set; }
    public string IPColumn { get; set; }
    public string FieldSeparator { get; set; }
    public string FlagColumn { get; set; }
    public string TrueValue { get; set; }
    public string FalseValue { get; set; }
    public bool LoadUpdate { get; set; }

    public AppSettings()
    {
    }
}

Если нужно, чтобы класс сериализовался, то перед описанием класса нужно обязательно установить атрибут «сериализуемый»:

[Serializable]

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

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

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

Если какое-то публичное свойство не надо сериализировать, т.е. в нашем случае, сохранять в конфиг, то такому свойству надо установить атрибут [XmlIgnore], для публичных полей устанавливается атрибут [NonSerialized].

Например:

[XmlIgnore]
public string DataUrl { get; set; }

Последняя особенность сериализации в XML — сериализируемому классу необходим конструктор без параметров, причем, практически выявлено, в этом конструкторе лучше вообще ничего не делать, особенно того, что может привести к ошибкам времени выполнения. Иначе получите гадскую невыявляемую ошибку, поскольку в отладке у вас будет всякая фигня, кроме того, чего нужно.
Я так понимаю, конструктор без параметров вызывается во время XML-сериализации, и наверняка, в нем что-то можно и нужно делать, но пока я не нашел, как и где это подробно расписать.

Само дерево жужжать не может
Значит, кто-то тут жужжит
(Вини-Пух)

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

this = (Data)readerRr.Deserialize(fileRr);
this - переменная только для чтения, по крайней мере до .NET 4.0 включительно.

И такой подход считается «плохим дизайном», хотя на мой нескромный взгляд, плохой дизайн — это разносить части одного и того же по разным классам.

Но раз уж надо, значит надо. Делаем класс-менеджер:

Далее такой условный класс-менеджер с возможностью сохранения и загрузки:
Читать далее

AppSettings.cs

Киберфорум
Сериализация в XML. XmlSerializer

Навел на мысль steinkrauz@ljr

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

На самом деле, форма была устроена ужасно, написана совсем другими людьми для другого проекта, а у нас кочевала из программы в программу без особых изменений, строки добавлялись в 3 ArrayList в коде формы, в функции рисования были какие-то непонятные жестко заданные поправочные коэффициенты, подобранные на глаз, и т.д.
Решили немного поправить и все переделать. Не знаю, насколько получилось лучше, но понятнее и универсальней точно. Далее будет не столько код с пояснениями, сколько попытка показать, как мы рассуждали, переделывая форму.

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

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

Параметры шрифта это FontFamily (Arial, Times New Roman и т.д.), размер и начертание или стиль (жирный, курсив, подчеркнутый, зачеркнутый, или все вместе). Для того, чтобы связать шрифт со строкой, пришлось добавить еще один параметр внутреннее имя, по которому программа будет узнавать, какой шрифт к какой строке применить.

Последняя сущность это группа строк, или сцена, поскольку строки выводятся группами (см. анимацию). К сцене мы приписали следующие параметры: цвет фона, скорость прокрутки строк (технически задается как таймаут таймера прорисовки) и время паузы (для эффекта остановки группы строк посередине формы, см. анимацию). Неявным параметром будет номер, его зададим позже автоматически, а также высота всех строк сцены и их количество.

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

...
команда;параметр1;параметр2;параметр3 [...]
команда;параметр1;параметр2;параметр3 [...]
команда;параметр1;параметр2;параметр3 [...]
...

Формат команд следующий (в квадратных скобках необязательные параметры):

Шрифт:
addfont; FontFamily; Размер (pt, float); [Стиль]; Внутреннее_имя
Например:
addfont; Arial;9;Bold;Group;
addfont; Microsoft Sans Serif;8;;Names;
addfont; Arial;14;Bold italic;Slogan;

Строка:
addstring; Строка; [Имя_шрифта]; [цвет_текста];
Например:
addstring;Make code, not war! C# like you.;Slogan;FF FF 00;

Сцена:
scene; [цвет_фона];[скорость_таймера_прорисовки ms];[пауза ms]
Например:
scene;20;3000;

Цвет текста задается в шестнадцатеричном формате через пробел(ы): R G B [Alpha]
Например:
FF FF 00 — желтый
FF 00 00 80 — красный с прозрачностью

Начертания (стили) шрифта перечисляются через пробел(ы), от регистра не зависят.

Шрифты:
Генерируются при анализе «скрипта», и помещаются в приватный Dictionary, где строковый ключ — заданное «внутреннее имя» шрифта.

Строка:
Текст и параметры хранятся в специальной структуре:

private struct AboutString
{
    public string Text;
    public string FontName;
    public Color TextColor;
    public int SceneNumber;
}

А все строки в private List Strings

Сцена:
Для описания сцены так же создана структура:

private struct AboutScene
{
    public int PauseTimeout;
    public int StringsHeight;
    public int StringsCount;
    public Color BackColor;
    public int DrawTimeout;
}

И описания сцен так же хранятся в private List Scenes

— последняя точка с запятой является необязательной
— пустые строки, или строки, содержащие только пробельные символы, пропускаются
— команды приводятся к нижнему регистру (т.е. они регистронезависимы)
— есть возможность оставить однострочный комментарий, начинающейся с ~ (тильды). Все, что после знака ~ считается комментарием и пропускается при анализе «скрипта».
— если первая (нулевая) сцена явно не определена, то создается сцена с параметрами по умолчанию

Команды, благо их немного, последовательно анализируются с помощью конструкции switch/case и передаются в функции добавления шрифта, строк, или сцены, где анализируются далее.
Параметры и команда разбираются с помощью string.split(';');

Размер шрифта должен быть float, поэтому надо сделать функцию-обертку над Convert, так, как я писал об этом ранее:

private float ConvertToFloat(string Number)
{
    NumberFormatInfo format = new NumberFormatInfo();
    format.NumberDecimalSeparator = ".";
    return (float)Convert.ToDouble(Number, format);
}

Некоторые параметры передаются через пробел (значения RGBA цвета, или стили шрифта). Нужна функция, которая будет избавляться от дублирующих пробелов, поскольку лишний пробел поставить легко, а вот вылавливать его потом неприятно:

private string RemoveDupSpaces(string s)
{
    while (s.Contains("  "))
    {
        s = s.Replace("  ", "");
    }

    return s;
}

Естественно, весь функционал не стоит реализовывать прямо на форме, потому вся работа вынесена в отдельный класс AboutDrawer, который парсит переданный скрипт и занимается отрисовкой строк на форме.
На форме строки отображаются в компоненте PictureBox, который передается в конструктор класса. Конструктор также устанавливает некоторые параметры по умолчанию.
Поскольку, класс все равно работает с компонентами формы, то спокойно подключаем пространство имен System.Windows.Forms, и пользуемся всеми его возможностями. Например, в классе создаются два таймера (Timer). Внутри обработчика события Tick одного из них, происходит отрисовка, а другой используется для эффекта паузы.
В классе созданы открытые свойства для установки цвета фона, цвета текста по умолчанию, и размера расстояния между строк.

Подробнее ознакомиться с кодом примера можно на Github:

Код на GitHub