Проблема, которую мы сегодня разберём

У нас есть класс MyClass с полем Value типа int. С этим полем мы можем сделать всё, что захотим: присваивать как угодно, когда угодно и менять на что угодно.

Давайте представим, что этот класс может хранит только отрицательное значение Value.

Я вам сегодня покажу два решения данной проблемы и ещё один кейс с более продвинутым решением.

Способ 1: Через свойства

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

Какие изменения я внёс:

Теперь Value не поле, а свойство, возвращающее приватное поле value. Здесь инкапсуляцией выступает сеттер (set {...}):

В сеттере мы обрабатываем поступающее значение: если оно меньше нуля, то мы приватному полю value оно присваивается, а иначе вызывается ошибка.

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

Способ 2: Через методы

Данный подход является самым часто-используемым и универсальным в ООП.

Какие изменения я внёс:

Я удалил свойство Value, заменив его методом. Теперь я могу добавить любой параметр в метод, например, множитель, но в данном кейсе это не нуждается. Использование класса я тоже изменил.

Теперь разберём второй кейс:

Допустим у нас есть тот же класс MyClass и у него есть экземпляр класса MyClassData. Этот класс хранит в себе переменные Name (имя) и Age (возраст).

Но у нас есть проблема: мы можем изменять всё, что захотим и когда захотим. Тогда нам на помощь приходит инкапсуляция:

Какие изменения я внёс:

Сначала я сделал MyClassData структурой, ведь он просто хранит данные, а не проводит над ними операции. В класса MyClass я сделал экземпляр приватным, а его данные передаются через свойства только для чтения. На самом деле можно и сразу структуру передавать, или если данных слишком много, а передавать надо только некоторые, можно создать новую структуру, заполнять нужными данными и так передавать.

Инкапсуляция при работе с массивами и листами

Массивы и листы являются ссылочными типами, сейчас я вам докажу:

Новый кейс: у нас есть класс MyClass с массивом myArray, защищённым от присваивания, но вот в чём проблема: мы как бы не можем присвоить, но мы можем изменить, ведь это ссылочный тип. А если дело доходит до листов (List<T>), то вообще можно всё менять методами.

Сейчас я вам покажу, как исправить такую ситуацию:

Теперь наше свойство превращается в приватное поле, а получать доступ дял чтения мы будем через метод GetElement(int index), где index обозначает... ну вы поняли.

А давайте теперь добавим возможность "инвертировать значения":

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

Что когда использовать?

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

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

Spire.Doc для .NET — это лёгкая, высокопроизводительная сторонняя библиотека для обработки документов Word. Её главное преимущество — независимая работа без опоры на локальную среду Microsoft Office. Она поддерживает полный жизненный цикл операций с файлами Word, включая создание, чтение, редактирование, преобразование форматов, экспорт и сравнение версий.

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

2. Настройка окружения: установка компонента

Все функции сравнения в этой статье основаны на Spire.Doc для .NET. Перед написанием кода установите библиотеку через NuGet. Вы можете быстро выполнить установку через консоль диспетчера пакетов Visual Studio с помощью следующей команды:

Install-Package Spire.Doc

3. Базовое использование: создание визуальных документов с правками

Наиболее востребованный сценарий сравнения — это сопоставление исходного документа с исправленной версией и создание нового файла с полными отметками о правках. Все изменения отображаются интуитивно через встроенный в Word режим отслеживания изменений. Ниже приведён полный рабочий код на C#:

using Spire.Doc;
namespace CompareDocuments
{
class Program
{
static void Main(string[] args)
{
// Загрузка исходного базового документа
Document originalDoc = new Document("original.docx");
// Загрузка изменённого документа для сравнения
Document revisedDoc = new Document("revised.docx");
// Сравнение документов и указание автора правок
originalDoc.Compare(revisedDoc, "John");
// Сохранение результата сравнения с отметками о правках в новый файл
originalDoc.SaveToFile("Differences.docx", FileFormat.Docx2013);
// Освобождение ресурсов во избежание занятости памяти
originalDoc.Dispose();
}
}
}

Ядро кода — метод Compare(). Он автоматически анализирует различия в содержании и форматировании между двумя файлами и отмечает в исходном документе три типа изменений: вставленный текст, удалённый текст и корректировки форматирования.

Созданный файл Differences.docx можно открыть непосредственно в Microsoft Word. Он использует стандартный режим отслеживания изменений с такой же точностью, как и встроенный профессиональный инструмент сравнения документов Office.

4. Расширенное использование: извлечение структурированных деталей различий

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

Spire.Doc предоставляет класс DifferRevisions для отдельного извлечения всего вставленного и удалённого текстового содержимого, что позволяет структурированно анализировать результаты сравнения. Полный код реализации выглядит так:

using Spire.Doc;
using Spire.Doc.Fields;
using System;
namespace GetDifferencesInList
{
class Program
{
static void Main(string[] args)
{
// Загрузка исходного и изменённого документов
Document originalDoc = new Document("original.docx");
Document revisedDoc = new Document("revised.docx");
// Выполнение сравнения для генерации данных о правках
originalDoc.Compare(revisedDoc, "Author");
// Разбор всех записей о правках
DifferRevisions revisions = new DifferRevisions(originalDoc);
// Получение коллекций правок вставки и удаления
var insertRevisions = revisions.InsertRevisions;
var deleteRevisions = revisions.DeleteRevisions;
int insertCount = 0;
int deleteCount = 0;
// Обход и вывод всего добавленного содержимого
Console.WriteLine("Список добавленного содержимого");
for (int i = 0; i < insertRevisions.Count; i++)
{
if (insertRevisions[i] is TextRange textRange)
{
insertCount++;
Console.WriteLine($"Вставка #{insertCount}: {textRange.Text.Trim()}");
}
}
Console.WriteLine("=====================");
// Обход и вывод всего удалённого содержимого
Console.WriteLine("Список удалённого содержимого");
for (int i = 0; i < deleteRevisions.Count; i++)
{
if (deleteRevisions[i] is TextRange textRange)
{
deleteCount++;
Console.WriteLine($"Удаление #{deleteCount}: {textRange.Text.Trim()}");
}
}
Console.ReadKey();
}
}
}

Этот код точно отфильтровывает значимые текстовые изменения и исключает влияние незначащего форматирования. Разработчики могут выполнять вторичную обработку извлечённых данных о различиях — это основа для создания автоматизированных систем проверки документов и интеллектуального сравнения.

5. Основные сценарии применения и преимущества

Автоматизированная функция сравнения документов Word на основе Spire.Doc способна заменить неэффективное ручное сравнение, значительно повышая эффективность офисной работы и разработки, и применима в различных отраслях и бизнес-сценариях:

5.1 Проверка юридических контрактов

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

5.2 Совместная работа над технической документацией в команде

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

5.3 Управление итерациями версий документов

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

5.4 Отраслевой комплаенс-аудит

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

6. Советы по разработке и оптимизация производительности

Spire.Doc обеспечивает стабильную совместимость и производительность обработки даже для больших файлов Word. Для обеспечения стабильности программы обратите внимание на следующие ключевые моменты при разработке:

6.1 Стандартизация управления памятью

Сравнение документов потребляет определённые системные ресурсы, особенно при пакетной обработке файлов или больших документов. Рекомендуется активно вызывать метод Dispose() после каждой операции для освобождения ресурсов и избежания накопления памяти, которое может привести к зависанию или сбоям программы.

6.2 Унификация форматов документов

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

6.3 Стандартизация информации об авторе правок

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

7. Заключение

С помощью Spire.Doc для .NET разработчики могут реализовать полностью автоматизированное сравнение документов Word с минимальным объёмом кода. Поддерживается как создание интуитивно понятных визуальных файлов правок, так и детализированное структурированное извлечение данных о различиях, что полностью решает проблему низкой эффективности и высокой вероятности ошибок при ручном сравнении.

Эта возможность сравнения может не только удовлетворять базовые потребности в сопоставлении документов, но и служить основой для разработки интеллектуальных платформ управления документами, автоматизированных офисных систем и систем комплаенс-аудита. Помимо сравнения документов, Spire.Doc также поддерживает редактирование документов, преобразование форматов, объединение, разделение, добавление водяных знаков и множество других функций, охватывая большинство потребностей в доработке документов Word.

Ужасы познания

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

Спросите ради интереса знакомого программиста, возможно ли программировать на «чистой» пользовательской Windows без установки Visual Studio — удивитесь ответам.

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

Поэтому описанное ниже наверное вызовет определенный ужас как у обычных пользователей так и некоторых программистов — особенно если они обучались по видеокурсам ничего не знают об истории ОС Windows.

Начну с цитаты из одной интересной статьи:

Over the past few months, I've received several variations on this question for other operating systems and all of the released versions of the .NET Framework. When the .NET Framework is installed as a part of the OS, it does not appear in the Programs and Features (or Add/Remove Programs) control panel. The following is a complete list of which version of the .NET Framework is included in which version of the OS

И ниже длинный такой список с версиями. А вот еще один если вдруг первого оказалось недостаточно.

Ну казалось бы и.. что? Чего тут такого?

Про .NET SDK все и так знают, временами его необходимо установить «для запуска игор», временами он сам ставится в виде зависимой библиотеки и никому не мешает.

Все так, да.

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

А я представляю и сейчас расскажу.

Заходите в папку Windows на вашем компьютере, вот сюда:

Файлт csc.exe — самый настоящий компилятор, фактически портал в ад на вашем обычном домашнем компьютере.

Почему все так страшно?

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

Шучу.

А если серьезно:

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

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

Так что веселье начинается.

Простой пример

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

Весь процесс от кода до запуска я записал на видео:

Исходный код тут казалось бы максимально простой, но с одним интересным нюансом про который ниже:

using System;
using System.Runtime.InteropServices;

namespace yoba
{
class Program
{
// импортирование нативной WinAPI функции MessageBox.
[DllImport("user32.dll")]
public static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);

static void Main(string[] args)
{
//вызываем и показываем диалог
MessageBox(IntPtr.Zero, "Йоу!", "Добро пожаловать в разработку!", 0);
}
}
}

Сохраняете этот текст обычным «блокнотом» в файл yoba.cs и запускаете сборку:

c:\Windows\Microsoft.NET\Framework\v3.5\csc.exe yoba.cs

Таким образом я запускал сборку на Windows 10, но имейте ввиду что версия системного .NET SDK может отличаться и например в Windows 11 уже будет:

c:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe yoba.cs

После сборки рядом с исходным файлом yoba.cs появится бинарник yoba.exe, который вы сможете запустить.

А теперь про нюанс.

Нюанс

Существует определенное предубеждение по отношению к managed‑языкам вроде Java и С# — они не подходят для серьезных дел вроде написания эксплоитов, использования 0day‑уязвимостей и пенетрации ядра.

Что все подобные вещи творят в глубокой тайне на чистом Си, в крайнем случае на C++ а все эти ваши Java/C# не более чем «погремушки для детей», не достойные даже косого взгляда серьезного профессионала.

Вот тут и начинается нюанс, посмотрите на эту радость:

[DllImport("user32.dll")]
public static extern int MessageBox(IntPtr hWnd,
string lpText, string lpCaption, uint uType);

Это мои дорогие читатели, ни что иное как вызов нативного WinAPI, с помощью которого творили всякое нехорошее в далекие 90е.

C# и .NET имеет оооочень глубокую интеграцию с Windows, несмотря на всю свою «безопасность» и управляемость, поэтому легко и просто может заменить собой и Си и С++ в качестве инструмента для нехороших дел.

И оно живет на вашем компьютере, дома и в офисе, с постоянной пропиской и регистрацией.

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

Сложный пример: выключаем Windows

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

Просто так, внезапно.

Последствия думаю каждый из читателей сможет оценить для себя сам.

Весь процесс на видео (разумеется это виртуальная машина):

А теперь код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security;
using System.Diagnostics;
using System.Management;
using System.Security.Permissions;
using System.Runtime.InteropServices;

namespace yoba
{
// See http://www.developmentnow.com/g/33_2004_12_0_0_33290/Access-...
// Calling this code on backup/restore seems to enable BCD
public class TokenHelper
{
// PInvoke stuff required to set/enable security privileges
[DllImport("advapi32", SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern int OpenProcessToken(
System.IntPtr ProcessHandle, // handle to process
int DesiredAccess, // desired access to process
ref IntPtr TokenHandle // handle to open access token
);

[DllImport("kernel32", SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern bool CloseHandle(IntPtr handle);

[DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern int AdjustTokenPrivileges(
IntPtr TokenHandle,
int DisableAllPrivileges,
IntPtr NewState,
int BufferLength,
IntPtr PreviousState,
ref int ReturnLength);

[DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern bool LookupPrivilegeValue(
string lpSystemName,
string lpName,
ref LUID lpLuid);

[StructLayout(LayoutKind.Sequential)]
internal struct LUID
{
internal int LowPart;
internal int HighPart;
}

[StructLayout(LayoutKind.Sequential)]
struct LUID_AND_ATTRIBUTES
{
LUID Luid;
int Attributes;
}

[StructLayout(LayoutKind.Sequential)]
struct _PRIVILEGE_SET
{
int PrivilegeCount;
int Control;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=1)] // ANYSIZE_ARRAY = 1
LUID_AND_ATTRIBUTES [] Privileges;
}

[StructLayout(LayoutKind.Sequential)]
internal struct TOKEN_PRIVILEGES
{
internal int PrivilegeCount;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=3)]
internal int[] Privileges;
}
const int SE_PRIVILEGE_ENABLED = 0x00000002;
const int TOKEN_ADJUST_PRIVILEGES = 0X00000020;
const int TOKEN_QUERY = 0X00000008;
const int TOKEN_ALL_ACCESS = 0X001f01ff;
const int PROCESS_QUERY_INFORMATION = 0X00000400;

public static bool SetPrivilege (string lpszPrivilege, bool
bEnablePrivilege )
{
bool retval = false;
int ltkpOld = 0;
IntPtr hToken = IntPtr.Zero;
TOKEN_PRIVILEGES tkp = new TOKEN_PRIVILEGES();
tkp.Privileges = new int[3];
TOKEN_PRIVILEGES tkpOld = new TOKEN_PRIVILEGES();
tkpOld.Privileges = new int[3];
LUID tLUID = new LUID();
tkp.PrivilegeCount = 1;
if (bEnablePrivilege)
tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
else
tkp.Privileges[2] = 0;
if(LookupPrivilegeValue(null , lpszPrivilege , ref tLUID))
{
Process proc = Process.GetCurrentProcess();
if(proc.Handle != IntPtr.Zero)
{
if (OpenProcessToken(proc.Handle, TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,
ref hToken) != 0)
{
tkp.PrivilegeCount = 1;
tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
tkp.Privileges[1] = tLUID.HighPart;
tkp.Privileges[0] = tLUID.LowPart;
const int bufLength = 256;
IntPtr tu = Marshal.AllocHGlobal( bufLength );
Marshal.StructureToPtr(tkp, tu, true);
if(AdjustTokenPrivileges(hToken, 0, tu, bufLength, IntPtr.Zero, ref
ltkpOld) != 0)
{
// successful AdjustTokenPrivileges doesn't mean privilege could be changed
if (Marshal.GetLastWin32Error() == 0)
{
retval = true; // Token changed
}
}
TOKEN_PRIVILEGES tokp = (TOKEN_PRIVILEGES) Marshal.PtrToStructure(tu,
typeof(TOKEN_PRIVILEGES) );
Marshal.FreeHGlobal( tu );
}
}
}
if (hToken != IntPtr.Zero)
{
CloseHandle(hToken);
}
return retval;
}
}

class ShutDown
{

[DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool ExitWindowsEx(int flg, int rea);

internal const int EWX_FORCE = 0x00000004;
internal const int EWX_POWEROFF = 0x00000008;

static void Main(string[] args)
{
TokenHelper.SetPrivilege("SeShutdownPrivilege",true);
ExitWindowsEx(EWX_FORCE | EWX_POWEROFF, 0);
}
}
}

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

Собирается по аналогии с предыдущим примером:

c:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Shutdown.cs

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

проверено и в виртуальной машине и на железе, на 10й и 11й Windows.

Рассказываю как это работает.

Ключевая функция — ExitWindowsEx, которая и отвечает за завершение работы ОС. Эта функция очень старая и известная, существует еще со времен Windows 95.

Но для ее вызова нужны «привилегии», которые и выставляет программно класс TokenHelper.

Константы ниже:

internal const int EWX_FORCE = 0x00000004;
internal const int EWX_POWEROFF = 0x00000008;

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

Вот еще допустимые варианты:

internal const int EWX_LOGOFF = 0x00000000;
internal const int EWX_SHUTDOWN = 0x00000001;
internal const int EWX_REBOOT = 0x00000002;
internal const int EWX_FORCEIFHUNG = 0x00000010;

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

Теперь давайте разбираться как же работает столь жесткое забивание на систему защиты еще и стандартными средствами:

TokenHelper.SetPrivilege("SeShutdownPrivilege",true);

И начнем мы с импортов.

Первое что импортируется это функция OpenProcessToken:

[DllImport("advapi32", SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern int OpenProcessToken(
System.IntPtr ProcessHandle, // handle to process
int DesiredAccess, // desired access to process
ref IntPtr TokenHandle // handle to open access token
);

Функция отвечает за получение данных о наборе «привилегий», связанных с конкретным процессом. Собственно набор таких привилегий и называется «токеном».

Вот как эта функция вызывается:

if (OpenProcessToken(proc.Handle, TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,
ref hToken) != 0)
{
..

Тут надо отметить передачу по ссылке в стиле Си (ref hToken), когда в функцию передается ссылка на объект C#, дальше функция этот объект заполняет данными. А возвращает она просто true или false — статус выполнения, отработала функция или нет.

Дальше импортируется простая и банальная функция освобождения ресурсов:

[DllImport("kernel32", SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern bool CloseHandle(IntPtr handle);

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

if (hToken != IntPtr.Zero)
{
CloseHandle(hToken);
}

Наконец главная функция, непосредственно отвечающая за переключение привилегий:

[DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern int AdjustTokenPrivileges(
IntPtr TokenHandle,
int DisableAllPrivileges,
IntPtr NewState,
int BufferLength,
IntPtr PreviousState,
ref int ReturnLength);

Вот весь ключевой блок логики смены привилегий:

if (OpenProcessToken(proc.Handle, TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,
ref hToken) != 0)
{
tkp.PrivilegeCount = 1;
tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
tkp.Privileges[1] = tLUID.HighPart;
tkp.Privileges[0] = tLUID.LowPart;
const int bufLength = 256;
IntPtr tu = Marshal.AllocHGlobal( bufLength );
Marshal.StructureToPtr(tkp, tu, true);
if(AdjustTokenPrivileges(hToken, 0, tu, bufLength, IntPtr.Zero, ref
ltkpOld) != 0)
{
// successful AdjustTokenPrivileges doesn't mean privilege could be changed
if (Marshal.GetLastWin32Error() == 0)
{
retval = true; // Token changed
}
}
TOKEN_PRIVILEGES tokp = (TOKEN_PRIVILEGES) Marshal.PtrToStructure(tu,
typeof(TOKEN_PRIVILEGES) );
Marshal.FreeHGlobal( tu );
}

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

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

if (Marshal.GetLastWin32Error() == 0)
{
retval = true; // Token changed
}

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

Наконец последняя функция, про которую стоит рассказать:

[DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true),
SuppressUnmanagedCodeSecurityAttribute]
static extern bool LookupPrivilegeValue(
string lpSystemName,
string lpName,
ref LUID lpLuid);

Она отвечает за поиск привилегии по имени, полагаю ведь заметили что мы передаем некое кодовое наименование при вызове TokenHelper:

TokenHelper.SetPrivilege("SeShutdownPrivilege",true);

Именно эта функция отвечает за поиск конкретной привилегии по названию «SeShutdownPrivilege», вот так выглядит ее вызов:

if (bEnablePrivilege)
tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
else
tkp.Privileges[2] = 0;

if(LookupPrivilegeValue(null , lpszPrivilege , ref tLUID))
{
..

Переменная bEnablePrivilege булевая, это и есть то самое true передаваемое в качестве второго аргумента, а блок:

if (bEnablePrivilege)
tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
else
tkp.Privileges[2] = 0;

Отвечает за формирование правильного вызова с использованием системных констант (SE_PRIVILEGE_ENABLED).

При вызове также передается ссылка (ref tLUID) на объект LUID, который будет содержать после вызова указание на найденную привилегию.

Вот такие интересные дела.

Итого

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

Задумайтесь, если увидите любимую "венду" на атомной станции или военном объекте — без всяких ЦРУ и хакеров в ОС Windows адова гора функционала, который легко и просто можно использовать во вред.

P.S.

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

Spire.Doc for .NET предлагает мощный и простой в использовании API, позволяющий создавать, редактировать и конвертировать документы без установки Microsoft Office на сервере. Он обеспечивает высокое качество преобразования:

• Сохранение стилей: полная поддержка текстовых форматов, цветов, выравнивания и других CSS-стилей из HTML.

• Обработка изображений: автоматическое распознавание и встраивание изображений из тегов <img> в HTML.

• Табличная структура: сохранение исходной вёрстки HTML-таблиц без искажений.

• Простота разработки: лаконичный API и низкий порог вхождения.

Подготовка: установка Spire.Doc

Перед началом кодирования необходимо добавить ссылку на Spire.Doc в проект. Рекомендуется выполнить установку через консоль диспетчера пакетов NuGet с помощью следующей команды:

Install-Package Spire.Doc

Сценарий 1: преобразование HTML-строки в Word

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

В приведённом ниже коде показано, как прочитать содержимое HTML-файла (в виде строки) и преобразовать его в файл .docx:

using Spire.Doc;

using Spire.Doc.Documents;

using System.IO;

namespace ConvertHtmlStringToWord

{

class Program

{

static void Main(string[] args)

{

// 1. Создание объекта Document

Document document = new Document();

// 2. Добавление раздела (Section)

Section section = document.AddSection();

// Опционально: установка полей страницы

section.PageSetup.Margins.All = 2;

// 3. Добавление абзаца (Paragraph)

Paragraph paragraph = section.AddParagraph();

// 4. Чтение HTML-строки из файла

string htmlFilePath = @"C:\Users\Administrator\Desktop\Html.html";

string htmlString = File.ReadAllText(htmlFilePath, System.Text.Encoding.UTF8);

// 5. Вставка HTML-строки в абзац

paragraph.AppendHTML(htmlString);

// 6. Сохранение в документ Word

document.SaveToFile("AddHtmlStringToWord.docx", FileFormat.Docx);

// 7. Освобождение ресурсов

document.Dispose();

}

}

}

Описание ключевых методов :

• Paragraph.AppendHTML(htmlString) — это основной метод преобразования. Он анализирует переданную HTML-строку и полностью преобразует её форматирование, изображения и структуру в содержимое абзаца Word.

• С помощью document.SaveToFile() можно указать формат вывода FileFormat.Docx.

Сценарий 2: прямое преобразование HTML-файла в Word

Если у вас уже есть готовый HTML-файл, который вы хотите напрямую преобразовать в документ Word, код будет ещё более лаконичным:

using Spire.Doc;

namespace ConvertHtmlToWord

{

class Program

{

static void Main(string[] args)

{

// 1. Создание объекта Document

Document document = new Document();

// 2. Непосредственная загрузка HTML-файла

document.LoadFromFile(@"C:\Users\Administrator\Desktop\MyHtml.html", FileFormat.Html);

// 3. Сохранение в документ Word

document.SaveToFile("HtmlToWord.docx", FileFormat.Docx);

// 4. Освобождение ресурсов

document.Dispose();

}

}

}

Этот способ позволяет выполнить преобразование за один шаг — метод Document.LoadFromFile() напрямую поддерживает загрузку файлов в формате FileFormat.Html, избавляя от необходимости вручную считывать содержимое файла.

Важные замечания

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

1. Поддержка CSS-стилей : Spire.Doc поддерживает большинство распространённых CSS-свойств, таких как font-size, color, text-align и др. Однако для очень сложных CSS-макетов возможны незначительные расхождения в итоговом отображении.

2. Пути к изображениям : теги <img> в HTML автоматически преобразуются в изображения в Word. Убедитесь, что пути к изображениям (как локальные, так и URL-адреса) доступны во время конвертации.

3. Табличная вёрстка : для сложных таблиц рекомендуется избегать специальных свойств вроде table-layout: fixed, чтобы обеспечить корректное отображение таблиц в Word.

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

Заключение

С помощью Spire.Doc for .NET разработчики могут реализовать высококачественное и высокоточное взаимное преобразование HTML и Word в проектах на C#, используя минимальный объём кода. Будь то обработка динамически генерируемых HTML-строк или пакетное преобразование существующих HTML-файлов — эта библиотека предлагает стабильное и эффективное решение. Она помогает быстро выстроить автоматизированный процесс работы с документами, позволяя сосредоточиться на бизнес-логике приложения.

1. Обзор компонента Spire.Doc for .NET

Free Spire.Doc for .NET — это профессиональный компонент для работы с документами Word, который позволяет разработчикам создавать, читать, изменять и конвертировать документы Word напрямую через код без установки Microsoft Office. Компонент предоставляет полный набор возможностей для работы с водяными знаками и поддерживает два основных типа:

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

Настройка окружения

Перед началом кодирования необходимо установить Free Spire.Doc в проект через диспетчер пакетов NuGet. Выполните следующую команду в «Консоли диспетчера пакетов» Visual Studio:

Install-Package FreeSpire.Doc

После установки необходимо подключить следующие пространства имён в файле кода:

using Spire.Doc;

using Spire.Doc.Documents;

using System.Drawing; // Для работы с цветами и изображениями

2. Добавление текстового водяного знака

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

Описание основных свойств

Класс TextWatermark предоставляет следующие настраиваемые свойства:

Реализация кода

using System;

using System.Drawing;

using Spire.Doc;

using Spire.Doc.Documents;

namespace InsertTextWatermark

{

internal class Program

{

static void Main(string[] args)

{

// Создание экземпляра объекта Document

Document document = new Document();

// Загрузка документа Word с диска

document.LoadFromFile("input.docx");

// Вставка текстового водяного знака

InsertTextWatermark(document);

// Сохранение документа

document.SaveToFile("TextWatermark.docx", FileFormat.Docx);

}

private static void InsertTextWatermark(Document document)

{

TextWatermark txtWatermark = new TextWatermark();

txtWatermark.Text = "НЕ КОПИРОВАТЬ"; // Текст водяного знака

txtWatermark.FontSize = 50; // Размер шрифта

txtWatermark.Color = Color.Blue; // Цвет текста

txtWatermark.Layout = WatermarkLayout.Diagonal; // Диагональное расположение

document.Watermark = txtWatermark;

}

}

}

Ключевые моменты

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

• При сохранении необходимо явно указать формат FileFormat.Docx, чтобы информация о водяном знаке была корректно записана в структуру файла Word.

• Если требуется горизонтальное центрированное отображение водяного знака, установите свойство Layout в WatermarkLayout.Horizontal.

3. Добавление водяного знака-изображения

По сравнению с текстовыми водяными знаками, водяные знаки-изображения подходят для более широкого круга сценариев:

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

• Наложение изображений с авторскими правами на дизайнерские макеты

• Использование изображения подписи как утверждающего водяного знака документа

Описание основных свойств

Класс PictureWatermark предоставляет следующие настраиваемые свойства:

Реализация кода

using System;

using System.Drawing;

using Spire.Doc;

using Spire.Doc.Documents;

namespace InsertImageWatermark

{

internal class Program

{

static void Main(string[] args)

{

// Создание экземпляра объекта Document

Document document = new Document();

// Загрузка документа Word

document.LoadFromFile("Input.docx");

// Вставка водяного знака-изображения

InsertImageWatermark(document);

// Сохранение документа

document.SaveToFile("InsertImageWatermark.docx", FileFormat.Docx);

}

private static void InsertImageWatermark(Document document)

{

PictureWatermark picture = new PictureWatermark();

picture.Picture = Image.FromFile("watermark.png"); // Загрузка изображения

picture.Scaling = 200; // Масштаб (%)

picture.IsWashout = false; // Использовать ли эффект выцветания

document.Watermark = picture;

}

}

}

Два визуальных эффекта для водяного знака-изображения

4. Удаление водяного знака

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

Принцип работы

В Spire.Doc удаление водяного знака реализовано очень просто: свойство Document.Watermark по сути является ссылкой на объект. Когда оно указывает на экземпляр TextWatermark или PictureWatermark, это означает, что водяной знак активен. Если же присвоить этому свойству пустую ссылку, водяной знак будет удалён из документа.

Реализация кода

using Spire.Doc;

namespace RemoveWatermark

{

class Program

{

static void Main(string[] args)

{

// Создание экземпляра Document

Document doc = new Document();

// Загрузка документа Word с водяным знаком

doc.LoadFromFile("Input.docx");

// Удаление водяного знака

doc.Watermark = null;

// Сохранение результата

doc.SaveToFile("RemoveWatermark.docx", FileFormat.Docx2013);

}

}

}

⚠️ Важные замечания

Этот способ удаления работает только для стандартных водяных знаков, добавленных через Spire.Doc. Если «водяной знак» реализован нестандартным способом (например, полупрозрачная фигура в колонтитуле или встроенное фоновое изображение), данный метод не сработает — потребуется использовать другие стратегии удаления содержимого документа.

5. Заключение

С помощью Spire.Doc for .NET разработчики могут легко и стандартизированно добавлять и удалять водяные знаки в документах Word с использованием C#. Основные операции, рассмотренные в статье:

Рекомендации по применению

• Текстовые водяные знаки : подходят для сценариев с динамической генерацией текста, например отображения различных уровней конфиденциальности в зависимости от прав пользователя

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

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

Это решение не зависит от среды Microsoft Office и подходит для развёртывания в серверных приложениях и фоновых службах, обеспечивая хорошую стабильность и масштабируемость.