• https://en.wikipedia.org/wiki/XY_problem
• https://xyproblem.info/

1. [ALINK="packaging"]В каком виде поставлять обновления?[/ALINK]
2. [ALINK="how_check_new_version"]Как проверять, что существует новая версия?[/ALINK]
3. [ALINK="when_check_new_version"]Когда проверять, что существует новая версия?[/ALINK]
4. [ALINK="when_start_downloading"]Когда начинать загрузку?[/ALINK]
5. [ALINK="how_download"]Как загружать?[/ALINK]
6. [ALINK="when_install"]Когда устанавливать?[/ALINK]
7. [ALINK="how_install"]Как устанавливать?[/ALINK]
8. [ALINK="after"]Что делать с данными?[/ALINK]

• Если программа из нескольких файлов (dll и прочие ресурсы), то
  • Либо архив, тогда также же в программе должна быть встроена функциональность распаковки/удаления/замены файлов;
  • Либо инсталлятор, который это всё автоматом берёт на себя;
• Если программа из одного EXE, можно поставлять его. Но тогда в программе должны быть предусмотрены некоторые дополнительные функции (см. ниже);
• Если файлов достаточно много (клиент какой-либо игры на фришарде), лучше всего посмотреть через сниффер, как этот вопрос решают существующие клиенты игр (типа EVE Online, Elite Dangerous, WoT и др.).
  Так как в этом случае может быть оптимальнее загружать только отличающиеся файлы, а то и вовсе лишь сами отличия (патчи).
  Пример по ссылке в конце ↓↓↓

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

{
  "Items": [
    {
      "Uri": "https://www.cyberforum.ru/updates/program_1.0.0.exe",
      "FileVersion": "1.0.0.0",
      "ProductVersion": "1.0.0+Branch.master.Sha.bed8da0d56ea48c5e580e3e557f81360c0405431",
      "SHA1": "W/+KW9hRW7pmU5EpB064psKLjHs=",
      "Changes": [
        "Первый выпуск"
      ]
    },
    {
      "Uri": "https://www.cyberforum.ru/updates/program_1.1.0.exe",
      "FileVersion": "1.1.0.0",
      "ProductVersion": "1.1.0+Branch.master.Sha.12adef0d56ea48c5e580e3e557f81360c0405431",
      "SHA1": "W/+459hRW7pmU5E1B064psKLjHs=",
      "Changes": [
        "Исправлены старые баги",
        "Добавлены новые баги"
      ]
    }
  ]
}

• Явным вызовом в меню программы Справка - Проверить наличие обновлений;
• Автоматически при запуске программы;
• Перидически в ходе работы программы;
• Через планировщик заданий Windows (хотя, зачем?).

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

• Некоторые программы выдают ссылку на сайт и предлагают пользователю скачать обновление самостоятельно;
• Другие приостанавливают работу и в модальном окне показывают ход загрузки файлов;
• Третьи показывают прогресс где-то в статусбаре, либо вообще не показывают.

• Закрыть программу и начать установку.
• Дождаться закрытия программы и начать установку.

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

• Простейший обновлятор приложения на PowerShell с использованием файловой системы.
• Скачивание файлов с папки. Только отличающихся файлов. Как у игр.

• На отладке работает, но не работает в нужной папке - C#
• Отказано в доступе по пути С# - C#
• Не найден файл - C#/.NET 4.x
• Путь к базе - C#
• Программа неправильно работает при запуске через Планировщик Заданий - PascalABC.NET
• И т.п.

1. Вообще не задумываются об том, что и откуда берётся, указывая путь вида database.mdf, file.txt.
2. Намеренно (но без понимания), указывают путь вида dir/file, ..dir/file, ../file, ./file и т.п., ошибочно полагая, что путь к файлу/каталогу будет отсчитываться от каталога, где находится программа.
3. Намеренно (но c недопониманием), указывают путь вида current_directory + "/file.txt", ошибочно полагая, что current directory это каталог, где находится программа.
4. ...

Увидеть значение current directory можно в:

• Проводнике Windows, отображается в адресной строке;
• Консоли Windows или Linux, отображается в строке приглашения к вводу (промпт);
• Консоли Windows, выполнив команду

  Windows Batch file
  1 cd

• Консоли Linux, выполнив команду

  Bash
  1 pwd

1
2

R:\demo\1\file1.txt
R:\demo\2\file2.txt

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

r:\demo\1>dir
 Содержимое папки r:\demo\1
 
03.08.2018  00:07    <DIR>          .
03.08.2018  00:07    <DIR>          ..
03.08.2018  00:10                11 file1.txt
               1 файлов             11 байт
               2 папок   2*038*804*480 байт свободно
 
r:\demo\1>more file1.txt
content 1
 
r:\demo\1>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

r:\demo\1>dir
 Содержимое папки r:\demo\1
 
03.08.2018  00:07    <DIR>          .
03.08.2018  00:07    <DIR>          ..
03.08.2018  00:10                11 file1.txt
               1 файлов             11 байт
               2 папок   2*038*804*480 байт свободно
 
r:\demo\1>more file2.txt
Не удается получить доступ к файлу R:\demo\1\file2.txt
 
r:\demo\1>more r:\demo\2\file2.txt
content 2
 
r:\demo\1>

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

r:\demo\1>dir
 Содержимое папки r:\demo\1
 
03.08.2018  00:07    <DIR>          .
03.08.2018  00:07    <DIR>          ..
03.08.2018  00:10                11 file1.txt
               1 файлов             11 байт
               2 папок   2*038*804*480 байт свободно
 
r:\demo\1>more ..\2\file2.txt
content 2
 
r:\demo\1>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

r:\demo\1>dir
 Содержимое папки r:\demo\1
 
03.08.2018  00:07    <DIR>          .
03.08.2018  00:07    <DIR>          ..
03.08.2018  00:10                11 file1.txt
               1 файлов             11 байт
               2 папок   2*038*804*480 байт свободно
 
r:\demo\1>cd r:\
 
r:\>more ..\2\file2.txt
Не удается получить доступ к файлу R:\2\file2.txt
 
r:\>more R:\demo\2\file2.txt
content 2
 
r:\>

• Запуске через проводник, в котором открыт каталог с исполняемым файлом;
• Запуске через командную строку, в которой промпт указывает каталог с программой.

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

В комментах кое-кто утверждает, что нужно пользоваться только относительными путями.
Пользоваться можно, только осторожно но не нужно. Этот способ применим только к месту (например, в консольных утилитах) и при условии хорошего понимания, как это всё работает и отчего может измениться значение current directory.

Пример того, к чему может привести

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

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

Во избежание проблем, если всё-таки current directory требуется, лучше сохранить это значение в переменную при старте приложения и после, на её основе, формировать абсолютные пути по мере надобности.
Какие могут быть проблемы, помимо бага в ОС?
Например, некий код обработки файлов в каталоге был построен на использовании относительного пути. При попытке его использования в нескольких потоках для обработки независимых каталогов, возникнет проблема с тем, что значение current directory одно для процесса. С абсолютными же путями никаких проблем не будет.
Код надо писать так, чтобы возможностей ошибиться при его использовании было как можно меньше.

1
2
3

Public Function GetExeDir() As String
    GetExeDir = My.Application.Info.DirectoryPath
End Function

1
2
3
4

TCHAR exePath[MAX_PATH];
HMODULE hModule = GetModuleHandleW(NULL);
GetModuleFileNameW(hModule, exePath, MAX_PATH);
PathRemoveFileSpec(exePath);

1
2
3
4
5
6
7

var
  AppDir: string;
begin
  AppDir := ExtractFileDir(Application.ExeName);
  // Do something with AppDir, e.g.:
  ShowMessage(AppDir);
end;

1
2
3
4
5
6

string exeDir = @"r:\demo\1"; // Путь к исходному каталогу
string relPath = @"..\2\file2.txt"; // Относительный путь к файлу
string resPath = Path.Combine(exeDir, relPath); // Объединяет две строки в путь.
Console.WriteLine(resPath);
resPath = Path.GetFullPath(resPath); // Возвращает для указанной строки пути абсолютный путь.
Console.WriteLine(resPath);

1
2
3
4
5
6
7
8
9
10

Sub Main()
    Dim exeDir, relPath, resPath As String
 
    exeDir = "r:\demo\1" ' Путь к исходному каталогу
    relPath = "..\2\file2.txt" ' Относительный путь к файлу
    resPath = System.IO.Path.Combine(exeDir, relPath) ' Объединяет две строки в путь.
    Console.WriteLine(resPath)
    resPath = System.IO.Path.GetFullPath(resPath) ' Возвращает для указанной строки пути абсолютный путь.
    Console.WriteLine(resPath)
End Sub

1
2
3
4
5
6
7
8
9
10

TCHAR libraryPath[MAX_PATH] = { 0 };
_tcscat_s(libraryPath, MAX_PATH, exePath);
 
#ifdef _M_IX86
  _tcscat_s(libraryPath, MAX_PATH, TEXT("\\x86\\library.dll"));
#elif defined(_M_AMD64)
  _tcscat_s(libraryPath, MAX_PATH, TEXT("\\x64\\library.dll"));
#endif
 
LoadLibrary(libraryPath);

1
2
3
4
5
6
7

r:\>echo %PATH%
C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Program Files\dotnet\;C:\Users\User\AppData\Local\Microsoft\WindowsApps
 
r:\>where more
C:\Windows\System32\more.com
 
r:\>

• Блокировка удаления каталога установкой его текущим: The curse of the current directory;
• Смена текущего каталога программы вызовом диалога выбора файла: Why does the common file dialog change the current directory?.

1. Берём статическую (чтобы не искать потом библиотеки зависимостей) сборку iconv для Windows. Например, из проекта mlocati/gettext-iconv-windows, gettext0.19.8.1-iconv1.14-static-64.zip.
2. Куда-нибудь распаковываем.
3. Переходим в каталог с jom.exe, например c:\Qt\Qt5.10.1\Tools\QtCreator\bin\ .
4. Создаём файл jom.bat, в котором вызываем jom.exe и передаём его вывод в iconv:
   

   Windows Batch file
   1 2 @echo off c:\Qt\Qt5.10.1\Tools\QtCreator\bin\jom.exe %* | d:\Software\Installed\iconv1.14\bin\iconv.exe -f CP866 -t WINDOWS-1251

5. В параметрах сборки заменяем путь с jom.exe на jom.bat.
   
6. Запускаем пересборку и видим русский текст:
   

1. Переходим в каталог с jom.exe, например c:\Qt\Qt5.10.1\Tools\QtCreator\bin\ .
2. Создаём файл jom.bat с вызовом скрипта на PowerShell:
   

   Windows Batch file
   1 2 @echo off PowerShell -NoProfile -ExecutionPolicy Bypass -Command "& 'c:\Qt\Qt5.10.1\Tools\QtCreator\bin\jom.ps1' %*"

3. Создаём файл jom.ps1:
   

   PowerShell

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 $ErrorActionPreference = "Stop" #$VerbosePreference = "Continue"   $jomPath = Join-Path $PSScriptRoot "jom.exe"   function RunConsole($scriptBlock) {     [Console]::OutputEncoding = [System.Text.Encoding]::GetEncoding("windows-1251")       function ConvertTo-Encoding ([string]$From, [string]$To)     {         Begin         {             $encFrom = [System.Text.Encoding]::GetEncoding($From)             $encTo = [System.Text.Encoding]::GetEncoding($To)         }         Process         {             $bytes = $encFrom.GetBytes($_)             $bytes = [System.Text.Encoding]::Convert($encFrom, $encTo, $bytes)             $encTo.GetString($bytes)         }     }       &$scriptBlock | ConvertTo-Encoding cp866 windows-1251 }   RunConsole {     & $jomPath $args }

4. В параметрах сборки заменяем путь с jom.exe на jom.bat.
   
5. Запускаем пересборку и видим русский текст.
   • От компилятора:
     
   • И от линкера:
     

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

• В интернетах достаточно информации для самостоятельного изучения. Такой как:
  • Книги;
    По вопросам C# почти всё можно найти в этих источниках.
  • Google/Yandex;
  • Форумы;
  • И т.д.
  Ответы на все ваши вопросы там есть с вероятностью 99.(9)%. Потому что, чтобы упереться в неизвестную доселе проблему, нужны знания, чтобы в эту ситуацию вляпаться. А те, у кого знания есть, смогут найти ответ самостоятельно. Если не смогут - надо задать вопрос на форуме, что повысит вероятность найти ответ среди множества знающих людей.
• На выполнение всех работ в учебных заведениях даётся достаточный срок.
  Если вы прогуляли отпущенное время для самостоятельных занятий и не учились в учебное время, то просто честно получите двояк.
• Те, кто хочет, чтобы работу просто сделали за него, могут обратиться в специальный раздел форума. Там вам с радостью помогут.
• Почему вы не отвечаете на мой вопрос?
• Я не являюсь:
  • преподавателем;
  • тренером,
  • коучером,
  • телепатом,
  • пророком,
  • супер программистом;
  • тыжпрограммистом.
• В моё свободное время у меня есть свои, личные дела. Мне незачем его тратить на кого-то, кто не удосужился приложить усилия для самостоятельного решения и изучения своего вопроса.

• Идёт Будда с учениками по дороге. Видит: яма, в ней вол, крестьянин пытается его вытянуть, но сил не хватает. Будда кивнул ученикам, они быстро помогли вытянуть животное. Идут дальше, снова яма, в ней вол, на краю сидит крестьянин и горько плачет. Будда прошёл мимо и как бы не заметил. Ученики его спрашивают: - Учитель, почему ты не захотел помочь этому крестьянину? - Помочь плакать?

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

• Программа состоит из EXE и нескольких DLL;
• Пользователю надо поставлять этот набор файлов;
• Пользователь криворук и "лишние" файлы теряет;
• В то же время программист криворук и не умеет / не хочет создавать инсталлятор.

• Библиотека (плагин) для какой-то системы;
• Система умеет сама подгружать только один файл DLL, а зависимости не умеет;
• Зависимости надо встроить так, чтобы их загрузка средствами системы не потребовалась.

1. Добавляем библиотеку в ресурсы проекта;
2. В Build Action ставим значение Embedded Resource;
   
3. При запуске программы считывает все ресурсы, похожие по имени на *.dll, и собираем их в словарь;
   

   C#

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 /// <summary> /// Загрузка библиотек из ресурсов /// </summary> /// <returns>Словарь библиотек</returns> private static Dictionary<string, Assembly> PreloadAssemblies() {     Dictionary<string, Assembly> result = new Dictionary<string, Assembly>();       Assembly assembly = Assembly.GetExecutingAssembly();     var resources = assembly.GetManifestResourceNames()         .Where(x => x.StartsWith("EmbeddedLibraryExe.Resources"))         .Where(x => x.ToLower().EndsWith("dll"))         .ToArray();       foreach (var item in resources)     {         using (Stream stream = assembly.GetManifestResourceStream(item))         {             byte[] buffer = new byte[stream.Length];             stream.Read(buffer, 0, buffer.Length);             Assembly loadedAssembly = Assembly.Load(buffer);             result.Add(loadedAssembly.FullName, loadedAssembly);         }     }       return result; }

4. В текущем домене подписываемся на событие AssemblyResolve;
5. В обработчике события ищем запрашиваемую библиотеку в словаре по её имени и возвращаем её;
   

   C#
   1 2 3 4 5 6 7 8 9 static System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) {     if (mPreloaded.ContainsKey(args.Name))     {         return mPreloaded[args.Name];     }       return null; }

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

   C#

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /// <summary> /// Словарь сборок, предварительно загруженных из ресурсов /// </summary> static Dictionary<string, Assembly> mPreloaded;   static void Main(string[] args) {     // Загрузка из ресурсов     mPreloaded = PreloadAssemblies();       // События поиска библиотеки     AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;       // Создание класса из библиотеки     Test t = new Test();     Console.WriteLine(t.Check()); }

Вложения

EmbeddedLibrary.zip (12.7 Кб, 566 просмотров)

• Eclipse IDE for C/C++ Developers;
• Java SE Runtime Environment;
• GNU ARM Embedded Toolchain;
• GNU ARM Eclipse Build Tools;
• GNU ARM Eclipse plug-ins;
• STM32CubeMX Eclipse plug in.

1. Добавляем к проекту пакет DocumentFormat.OpenXML через NuGet;
2. Рисуем оставшуюся часть совы.

1
2
3
4
5
6
7
8
9
10
11

        public class BookmarksPair
        {
            public BookmarkStart Start { get; private set; }
            public BookmarkEnd End { get; private set; }
 
            public BookmarksPair(BookmarkStart start, BookmarkEnd end)
            {
                this.Start = start;
                this.End = end;
            }
        }

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

        public static BookmarksPair[] GetBookmarks(string filename)
        {
            var templateFile = new FileInfo(filename);
 
            if (templateFile.Exists)
            {
                using (var documentStream = templateFile.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
                {
                    using (var document = WordprocessingDocument.Open(documentStream, true))
                    {
                        var bookmarks = GetBookmarks(document.MainDocumentPart, "").ToArray();
                        return bookmarks;
                    }
                }
            }
 
            return new BookmarksPair[] { };
        }
 
        private static IEnumerable<BookmarksPair> GetBookmarks(MainDocumentPart documentPart, string prefix)
        {
            var starts = documentPart.Document.Descendants<BookmarkStart>();
            var ends = documentPart.Document.Descendants<BookmarkEnd>();
 
            var result = from start in starts
                         join end in ends on (string)start.Id equals (string)end.Id
                         where ((string)start.Name).StartsWith(prefix)
                         where start.Parent == end.Parent // Закладки, находящиеся внутри общего элемента
                         select new BookmarksPair(start, end);
            return result;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

        public static void ReplaceAndSave(string filenameSource, string filenameDestination, string bookmarkName, string value)
        {
            var templateFile = new FileInfo(filenameSource);
 
            if (templateFile.Exists)
            {
                var tempFile = templateFile.CopyTo(Path.GetTempFileName(), true);
 
                using (var documentStream = tempFile.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
                {
                    using (var document = WordprocessingDocument.Open(documentStream, true))
                    {
                        var bookmarks = GetBookmarks(document.MainDocumentPart, "");
 
                        BookmarksPair pair = bookmarks.FirstOrDefault(x => x.Start.Name == bookmarkName);
 
                        if (pair != null)
                        {
                            ReplaceBookmarkContent(pair, value);
                        }
 
                    }
                }
 
                tempFile.MoveTo(filenameDestination);
            }
        }
 
        private static void ReplaceBookmarkContent(BookmarksPair bookmarksPair, string value)
        {
            CleanContentBetweenBookmarks(bookmarksPair);
 
            Run run = new Run(new Text(value));
 
            bookmarksPair.Start.InsertAfterSelf(run);
        }
 
        private static void CleanContentBetweenBookmarks(BookmarksPair bookmarksPair)
        {
            List<OpenXmlElement> elements = new List<OpenXmlElement>();
            OpenXmlElement element = bookmarksPair.Start.NextSibling();
 
            while (element != null)
            {
                if (element == bookmarksPair.End) break;
 
                elements.Add(element);
 
                element = element.NextSibling();
            }
 
            foreach (var item in elements)
            {
                item.Remove();
            }
        }

• Опрос свойства BytesToRead в цикле затратен по времени и ресурсам.
• Событие DataReceived тоже кривое. Может прийти в начале приёма данных, может позже. Работает само по себе. Поэтому для схемы запрос-ответ надо городить огород вокруг него, чтобы удостовериться в завершении приёма всех данных.
• Read(Byte[], Int32, Int32) уже получше, но таймаут у него задаётся один.

• Если таймаут небольшой, то можно не дождаться начала ответа.
• Если таймаут большой, то время ожидания завершения ответа будет потрачено напрасно.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

/// <summary>
/// Отправка/приём данных через SerialPort.
/// </summary>
/// <param name="connection">SerialPort, используемый для связи.</param>
/// <param name="sendBuffer">Массив отправляемых байт.</param>
/// <param name="waitingForStart">Время ожидания от отправки до начала ответа.</param>
/// <param name="waitForEnd">Время ожидания после завершения ответа.</param>
/// <param name="cancellationToken">Токен отмены.</param>
/// <param name="recvBuffer">Массив буфера для приёма байт.</param>
/// <param name="received">Количество принятых байт.</param>
/// <returns>Получен ли какой-нибудь ответ.</returns>
public bool SendRecv(SerialPort connection, byte[] sendBuffer, int waitingForStart, int waitForEnd, CancellationToken cancellationToken, ref byte[] recvBuffer, out int received)
{
    bool result = false;
    received = -1;
 
    try
    {
        // Порт должен быть открыт.
        if (connection.IsOpen)
        {
            // Сброс буферов.
            connection.DiscardInBuffer();
            connection.DiscardOutBuffer();
 
            if (connection.BytesToRead > 0)
            {
                connection.ReadExisting();
            }
 
            // Установка таймаута начала ответа.
            connection.ReadTimeout = waitingForStart;
 
            // Отправка данных.
            connection.Write(sendBuffer, 0, sendBuffer.Length);
 
            int readed = 0;
 
            try
            {
                // Ожидание первого байта. Если ничего не придёт за waitingForStart мс, то вылетит TimeoutException.
                recvBuffer[readed++] = Convert.ToByte(connection.ReadByte());
 
                // Установка таймаута для определения завершения ответа.
                connection.ReadTimeout = waitForEnd;
 
                try
                {
                    // Временный буфер для приёма частями.
                    byte[] temp = new byte[16];
 
                    do
                    {
                        // Чтение и заполнение буфера.
                        // Если ничего не принято, то вылетит TimeoutException.
                        // Если считано меньше или равно размеру буфера, это число возвращается функцией.
                        int b = connection.Read(temp, 0, 16);
 
                        // Копирование в выходной буфер.
                        for (int i = 0; i < b; i++)
                        {
                            recvBuffer[readed++] = temp[i];
                        }
 
                        // Повтор до явной отмены.
                        // Также, выход доступен по таймауту чтения.
                    } while (!cancellationToken.IsCancellationRequested);
                }
                catch (TimeoutException)
                {
                }
                finally
                {
                    // Количество считанного.
                    received = readed;
                    // Возвращаемый результат: принято ли что-нибудь.
                    result = readed > 0;
                }
            }
            catch (TimeoutException)
            {
            }
        }
    }
    catch
    {
        result = false;
    }
 
    return result;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

using System;
using System.Threading;
 
namespace SerialStreamTest
{
    /// <summary>
    /// Таймер отсчёта таймаута
    /// </summary>
    class TimerTimeout
    {
        private Timer mTimer;
        private Action mCallback;
        private object mCallbackLocker;
 
        public TimerTimeout()
        {
            this.mTimer = new Timer(this.CallBack, null, Timeout.Infinite, Timeout.Infinite);
            this.mCallback = null;
            this.mCallbackLocker = new object();
        }
 
        private void CallBack(object state)
        {
            lock (this.mCallbackLocker)
            {
                if (this.mCallback != null)
                {
                    this.mCallback();
                }
            }
        }
 
        /// <summary>
        /// Запуск/перезапуск таймера.
        /// <paramref name="Callback"/> будет вызван через <paramref name="millisecondsTimeout"/> мс после текущего момента времени.
        /// Если таймер был запущен ранее, предыдущий <paramref name="Callback"/> отменится.
        /// </summary>
        /// <param name="millisecondsTimeout">Время, через которое будет вызван <paramref name="Callback"/>.</param>
        /// <param name="callback">Функция обратного вызова по срабатыванию таймера.</param>
        public void ReStart(int millisecondsTimeout, Action callback)
        {
            lock (this.mCallbackLocker)
            {
                this.mCallback = callback;
            }
 
            this.mTimer.Change(millisecondsTimeout, Timeout.Infinite);
        }
 
        /// <summary>
        /// Отмена отсчёта таймера.
        /// </summary>
        public void Stop()
        {
            this.mTimer.Change(Timeout.Infinite, Timeout.Infinite);
 
            lock (this.mCallbackLocker)
            {
                this.mCallback = null;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespace SerialStreamTest
{
    /// <summary>
    /// Класс чтения/записи в последовательный порт.
    /// </summary>
    /// <remarks>
    /// Задача: записать данные в порт и принять ответ.
    /// Ответа может и не быть.
    /// Отдельные таймауты на ожидание начала приёма и на ожидание завершения приёма.
    /// 
    /// Запись работает как обычно.
    /// 
    /// Приём:
    /// Запускаем таймер отсчёта начала ответа.
    /// Входим в состояние приёма.
    /// Выход из него возможен по таймауту начала ответа и по таймауту завершения приёма.
    /// Если время начала ответа вышло, ожидание завершается и возвращается пустой массив.
    /// Если за время начала ответа этот ответ начал приниматься, ждём уже завершения приёма.
    /// </remarks>
    class SerialStream4 : IDisposable
    {
        protected SerialPort mPort;
 
        protected ConcurrentQueue<byte> mReceiveQueue;
        /// <summary>
        /// Задача для повторяющегося чтения
        /// </summary>
        protected Task mReaderTask;
        /// <summary>
        /// Токен отмены задачи повторяющегося чтения
        /// </summary>
        protected CancellationTokenSource mReaderTaskToken;
        /// <summary>
        /// Событие приёма чего-либо
        /// </summary>
        protected ManualResetEventSlim mReadEvent;
        /// <summary>
        /// Событие таймаута начала приёма
        /// </summary>
        protected ManualResetEventSlim mStartTimeoutEvent;
        /// <summary>
        /// Событие таймаута после приёма
        /// </summary>
        protected ManualResetEventSlim mEndTimeoutEvent;
        /// <summary>
        /// Таймер для отсчёта таймаута начала пакета
        /// </summary>
        protected TimerTimeout mTimerStartTimeout;
        /// <summary>
        /// Таймер для отсчёта таймаута завершения пакета
        /// </summary>
        protected TimerTimeout mTimerEndTimeout;
        /// <summary>
        /// Время ожидания завершения приёма, мс
        /// </summary>
        protected int mEndTimeout;
 
        public SerialStream4()
        {
            this.mPort = new SerialPort();
            this.mReceiveQueue = new ConcurrentQueue<byte>();
            this.mReadEvent = new ManualResetEventSlim(false);
            this.mStartTimeoutEvent = new ManualResetEventSlim(false);
            this.mEndTimeoutEvent = new ManualResetEventSlim(false);
            this.mTimerStartTimeout = new TimerTimeout();
            this.mTimerEndTimeout = new TimerTimeout();
            this.mEndTimeout = Timeout.Infinite;
        }
 
        public void Dispose()
        {
            this.Close();
        }
 
        public bool Open(string portName, int baudRate, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
        {
            this.mPort.PortName = portName;
            this.mPort.BaudRate = baudRate;
            this.mPort.Parity = parity;
            this.mPort.DataBits = dataBits;
            this.mPort.StopBits = stopBits;
            this.mPort.ReadTimeout = 100;
 
            this.mPort.Open();
 
            if (this.mPort.IsOpen)
            {
                this.mReaderTaskToken = new CancellationTokenSource();
                this.mReaderTask = Task.Factory.StartNew(o => this.AsyncReader((CancellationToken)o), this.mReaderTaskToken.Token, this.mReaderTaskToken.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
            }
 
            return this.mPort.IsOpen;
        }
 
        private void AsyncReader(CancellationToken token)
        {
            while (true)
            {
                Task<ReadedData> task = this.ReadPart(64, 100, this.mReaderTaskToken.Token);
 
                task.Wait(token);
                token.ThrowIfCancellationRequested();
 
                foreach (var b in task.Result.Array.Take(task.Result.Count))
                {
                    this.mReceiveQueue.Enqueue(b);
                }
 
                this.mReadEvent.Set();
            }
        }
 
        public void Close()
        {
            if (this.mPort.IsOpen)
            {
                try
                {
                    this.mReaderTaskToken.Cancel();
                    this.mReaderTask.Wait();
                }
                catch (AggregateException)
                {
                }
            }
 
            this.mPort.Close();
        }
 
        public bool IsOpen
        {
            get { return this.mPort.IsOpen; }
        }
 
        public void DiscardInBuffer()
        {
            byte b;
 
            while (this.mReceiveQueue.TryDequeue(out b)) ;
 
            this.mReadEvent.Reset();
        }
 
        public void Write(byte[] buffer)
        {
            Console.WriteLine("Send");
            this.mPort.Write(buffer, 0, buffer.Length);
        }
 
        public bool Read(out byte[] receivedBuffer, int startTimeout, int endTimeout, CancellationToken cancellationToken)
        {
            this.mStartTimeoutEvent.Reset();
            this.mEndTimeoutEvent.Reset();
 
            this.mEndTimeout = endTimeout;
 
            //this.mTimerStartTimeout.ReStart(startTimeout, this.mStartTimeoutEvent.Set);
            this.mTimerStartTimeout.ReStart(startTimeout, this.StartTimeoutCallback);
 
            int completedIndex = WaitHandle.WaitAny(
                new WaitHandle[] {
                    this.mEndTimeoutEvent.WaitHandle,
                    this.mStartTimeoutEvent.WaitHandle,
                    cancellationToken.WaitHandle
                });
 
            switch (completedIndex)
            {
                case 0:
                    {
                        this.mEndTimeoutEvent.Reset();
                        this.mStartTimeoutEvent.Reset();
 
                        List<byte> bytes = new List<byte>();
                        byte b;
 
                        while (this.mReceiveQueue.TryDequeue(out b))
                        {
                            bytes.Add(b);
                        }
 
                        receivedBuffer = bytes.ToArray();
 
                        return true;
                    }
                case 1:
                case 2:
                default:
                    {
                        this.mEndTimeoutEvent.Reset();
                        this.mStartTimeoutEvent.Reset();
 
                        receivedBuffer = new byte[] { };
 
                        return false;
                    }
            }
        }
 
        private Task<ReadedData> ReadPart(int expectedCount, int millisecondsTimeout, CancellationToken cancellationToken)
        {
            ReadedData data = new ReadedData();
 
            List<byte> buffer = new List<byte>();
            byte[] tempBuffer = new byte[expectedCount];
 
            data.Array = tempBuffer;
 
            Task<int> taskReader = Task<int>.Factory.FromAsync(
                this.mPort.BaseStream.BeginRead, // IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
                this.mPort.BaseStream.EndRead, // int EndRead(IAsyncResult asyncResult);
                tempBuffer,
                0,
                tempBuffer.Length,
                data);
 
            Task<ReadedData> taskContinuation = taskReader.ContinueWith<ReadedData>(x =>
            {
                int actualLength = 0;
 
                try
                {
                    actualLength = x.Result;
                    data.Count = actualLength;
                    this.mTimerStartTimeout.Stop();
 
                    //this.mTimerEndTimeout.ReStart(this.mEndTimeout, this.mEndTimeoutEvent.Set);
                    this.mTimerEndTimeout.ReStart(this.mEndTimeout, this.EndTimeoutCallback);
 
                    Console.WriteLine("Received: [{0}]", actualLength);
                }
                catch (IOException exc)
                {
                    Console.WriteLine(exc.Message);
                    data.Exception = exc;
                }
 
                return data;
            });
 
            return taskContinuation;
        }
 
        private void StartTimeoutCallback()
        {
            Console.WriteLine("Answer not received");
            this.mStartTimeoutEvent.Set();
        }
 
        private void EndTimeoutCallback()
        {
            Console.WriteLine("Answer completed");
            this.mEndTimeoutEvent.Set();
        }
 
        private class ReadedData
        {
            public byte[] Array { get; set; }
            public int Count { get; set; }
            public Exception Exception { get; set; }
 
            public ReadedData()
            {
                this.Array = new byte[] { };
                this.Count = 0;
                this.Exception = null;
            }
        }
    }
}

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

using System;
using System.IO.Ports;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespace SerialStreamTest
{
    class Program
    {
        static void Main(string[] args)
        {
            CancellationTokenSource token = new CancellationTokenSource();
 
            Task task = Task.Factory.StartNew(o => Read((CancellationToken)o), token.Token, token.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
 
            Console.ReadLine();
 
            try
            {
                token.Cancel();
                task.Wait();
            }
            catch (AggregateException)
            {
            }
        }
 
        private static void Read(CancellationToken token)
        {
            byte[] send = new byte[] { ... тут байты запроса ... };
            using (var port = new SerialStream4())
            {
                port.Open("COM28", 19200, Parity.Odd, 8, StopBits.One);
 
                while (!token.IsCancellationRequested)
                {
                    port.Write(send);
 
                    byte[] recv;
 
                    if (port.Read(out recv, 100, 4, token))
                    {
                        Console.WriteLine("[{0}] {1}", recv.Length, String.Join(" ", recv.Select(x => x.ToString("X2"))));
                    }
                }
 
                port.Close();
            }
        }
    }
}

Вложения

SerialStreamTest.zip (30.5 Кб, 860 просмотров)

• Windows 7
  https://www.microsoft.com/ru-r... d/windows7
  Требуется ключ продукта.
  
• Windows 8
  https://www.microsoft.com/ru-r... d/windows8
  
• Windows 10
  https://www.microsoft.com/ru-r... /windows10
  Скачивается утилита для создания установочного носителя. В ней вместо создания флешки/диска выбирается создания ISO образа.

• Выбираете нужную версию из списка ниже.
• Узнаёте ещё хэш.
• Ищете торрент с таким хешем.
• Скачиваете образ с торрента.
• Проверяете хеш.
• Если хеш соответствует - у вас оригинальный образ винды с MSDN. Никаких кряков, активаторов, встроенных троянов, ратов и бэкдоров.

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

75d348d5708fc58eb13444700f3b2a8f61dc9472 *en-us_windows_10_business_editions_version_22h2_x64_dvd_8cf17b79.iso
08efc0c24f86cf5920b72d98e1de767719d342b2 *en-us_windows_10_business_editions_version_22h2_x86_dvd_186a68c3.iso
af8d0e9efd3ef482d0ab365766e191e420777b2b *en-us_windows_10_consumer_editions_version_22h2_x64_dvd_8da72ab3.iso
3704f52690e6f84d010f9a10faf598348ff11081 *en-us_windows_10_consumer_editions_version_22h2_x86_dvd_90883feb.iso
2fb2897373c4f71b06f4490943b3d564b0f0fd6d *en-us_windows_10_enterprise_ltsc_2021_x64_dvd_d289cf96.iso
3f7f38802043aa55ebe930655ee35be876213e4d *en-us_windows_10_enterprise_ltsc_2021_x86_dvd_9f4aa95f.iso
a68c150649089263a34b21a7f1833e3ab41d6172 *en-us_windows_11_business_editions_version_22h2_updated_march_2023_x64_dvd_4b362179.iso
4e0d7db5a79ff6c68f2076f65685739b0ae17bd0 *en-us_windows_11_business_editions_version_22h2_updated_may_2023_x64_dvd_c2d14816.iso
55bfc9add5552e315e387797cab9e0b82400b95c *en-us_windows_11_consumer_editions_version_22h2_updated_march_2023_x64_dvd_e9856a7a.iso
962ebdfe3e8c0b174c5ca5e430dac4cdefb34c66 *en_windows_10_business_editions_version_1809_updated_jun_2021_x64_dvd_68278277.iso
04565134db37ecfac8b3b52176880562ce42f584 *en_windows_10_business_editions_version_1909_updated_jun_2021_x64_dvd_df323900.iso
080ec1de94b88b0f7e8d000690a4aaaa031e2719 *en_windows_7_home_basic_with_sp1_x86_dvd_u_676470.iso
101574faa17fdb430bb027271ef0a58f0e18ad47 *en_windows_7_home_basic_x86_dvd_x15-65654.iso
6c9058389c1e2e5122b7c933275f963edf1c07b9 *en_windows_7_home_premium_with_sp1_x64_dvd_u_676549.iso
6071b4553fcf0ea53d589a846b5ae76743dd68fc *en_windows_7_home_premium_with_sp1_x86_dvd_u_676701.iso
336779ea6b65f63e11a609b4d021439c47ab315b *en_windows_7_home_premium_x64_dvd_x15-65733.iso
cc9d8220b2179e784d85bf1ea98d2ee2190d534f *en_windows_7_home_premium_x86_dvd_x15-65732.iso
0bcfc54019ea175b1ee51f6d2b207a3d14dd2b58 *en_windows_7_professional_with_sp1_x64_dvd_u_676939.iso
d89937df3a9bc2ec1a1486195fd308cd3dade928 *en_windows_7_professional_with_sp1_x86_dvd_u_677056.iso
36ae90defbad9d9539e649b193ae573b77a71c83 *en_windows_7_ultimate_with_sp1_x64_dvd_u_677332.iso
65fce0f445d9bf7e78e43f17e441e08c63722657 *en_windows_7_ultimate_with_sp1_x86_dvd_u_677460.iso
0afc66d392503cd2508ef17be9b5444efee3d4c3 *ru-ru_windows_10_business_editions_version_22h2_x64_dvd_61849fe8.iso
04550d7496800143650b1a665f7ed45fddb134e7 *ru-ru_windows_10_business_editions_version_22h2_x86_dvd_1f394559.iso
25b6b946137c359661f2a95c524e92ce552f8772 *ru-ru_windows_10_consumer_editions_version_22h2_x64_dvd_86fd5014.iso
04c357121776ff09aa5e92557c229167392c2aa6 *ru-ru_windows_10_consumer_editions_version_22h2_x86_dvd_2e77f200.iso
b8addd641b1ac9121ebccdc1a3c86153f6020cf4 *ru-ru_windows_10_enterprise_ltsc_2021_x64_dvd_5044a1e7.iso
2dd68f358f41056c04b509a58a68d4182b28694b *ru-ru_windows_10_enterprise_ltsc_2021_x86_dvd_cdf355eb.iso
0b8c33e55dd39f0b0e1e494728f44cf1493a77d4 *ru-ru_windows_11_business_editions_version_22h2_updated_march_2023_x64_dvd_9c7515af.iso
75f1def1c3d0941c0d17b4409244cd7594200e69 *ru-ru_windows_11_business_editions_version_22h2_updated_may_2023_x64_dvd_90166b2e.iso
a3c89108eb1a0ba714e22bfa8a4de556ba7a6f97 *ru-ru_windows_11_consumer_editions_version_22h2_updated_march_2023_x64_dvd_d3b36a20.iso
f4664fcbc4da42d638c32e6b9899438e984d65a8 *ru_windows_10_business_editions_version_1809_updated_jun_2021_x64_dvd_41c42150.iso
bd027567284044f06664661a3bd2e341fbbe431f *ru_windows_10_business_editions_version_1909_updated_jun_2021_x64_dvd_acc57c13.iso
7c7446200c478814cc983a04fa8431bfdba95f19 *ru_windows_7_home_basic_with_sp1_x86_dvd_u_676482.iso
7f68c908f04dd6f3ece4c595416acf53d72c2bb6 *ru_windows_7_home_basic_x86_dvd_x15-65691.iso
3f467e896feb5ea817b14b5f9483800b36b989b8 *ru_windows_7_home_premium_with_sp1_x64_dvd_u_676728.iso
4187e9bd9d591215ac27898c0a070ad31f94a7e1 *ru_windows_7_home_premium_with_sp1_x86_dvd_u_676719.iso
b29a597223233aa5f408adfc0238f82960cb665f *ru_windows_7_home_premium_x64_dvd_x15-65763.iso
efbe7ec9e8d8924785012a4bc22d2810995dbec3 *ru_windows_7_home_premium_x86_dvd_x15-65762.iso
6aafbbffc12bb63894932210d5bcb69773b46c98 *ru_windows_7_professional_with_sp1_x64_dvd_u_677024.iso
e1c39ccc6c83985c2208fc19ca7058044b682f08 *ru_windows_7_professional_with_sp1_x86_dvd_u_677084.iso
106caf0695318ad0d82e441a54be8460bf099b09 *ru_windows_7_ultimate_with_sp1_x64_dvd_u_677391.iso
d224888cfa62847faa3505630a206bdcd10a9930 *ru_windows_7_ultimate_with_sp1_x86_dvd_u_677463.iso

• Рекурсивно в каталоге с приложением ищутся все dll файлы сборок.
• Найденные по очереди перебираются и загружаются в память с помощью Assembly.LoadFile().
• Из сборки достаются все существующие в ней типы. Опять же, по одному перебираются и проверяются на наличие интерфейса плагина.
• Если таковой у типа имеется, тип считается плагином и сохраняется для последующего использования.

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

private List<IPlugin> ScanPlugins()
{
    List<IPlugin> result = new List<IPlugin>();
 
    string[] files = this.GetLibraries();
 
    var watch = System.Diagnostics.Stopwatch.StartNew();
 
    foreach (var filename in files)
    {
        try
        {
            Assembly assembly = Assembly.LoadFile(filename);
            Type[] types = assembly.GetTypes();
 
            foreach (var type in types)
            {
                Type t = type.GetInterface(typeof(IPlugin).FullName);
 
                if (t != null && !type.IsAbstract)
                {
                    IPlugin pluginInfo = (IPlugin)Activator.CreateInstance(type);
                    result.Add(pluginInfo);
                }
            }
        }
        catch (Exception exc)
        {
            System.Diagnostics.Debug.WriteLine(exc.Message);
        }
    }
 
    watch.Stop();
    var elapsedMs = watch.ElapsedMilliseconds;
 
    return result;
}

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace MyApp.Core.Classes
{
    [AttributeUsage(AttributeTargets.Assembly)]
    public class AssemblyPluginTypeAttribute : Attribute
    {
        public Type PluginType { get; private set; }
 
        public AssemblyPluginTypeAttribute(Type value) { this.PluginType = value; }
    }
}

1

[assembly: MyApp.Core.Classes.AssemblyPluginType(typeof(MyApp.About.Classes.Plugin))]

• Рекурсивно в каталоге с приложением ищутся все dll файлы сборок.
• Найденные по очереди перебираются и загружаются в память с помощью Assembly.LoadFile().
• Из сборки достаются её указанные атрибуты. Из атрибутов получаются типы, реализующие интерфейс плагина.
• Тип плагина сохраняется для последующего использования.

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

private List<IPlugin> ScanPlugins()
{
    List<IPlugin> result = new List<IPlugin>();
 
    string[] files = this.GetLibraries();
 
    var watch = System.Diagnostics.Stopwatch.StartNew();
 
    foreach (var filename in files)
    {
        try
        {
            Assembly assembly = Assembly.LoadFile(filename);
            object[] attributesPlugin = assembly.GetCustomAttributes(typeof(AssemblyPluginTypeAttribute), false);
 
            foreach (var attributePlugin in attributesPlugin)
            {
                Type pluginType = (attributePlugin as AssemblyPluginTypeAttribute).PluginType;
                Type t = pluginType.GetInterface(typeof(IPlugin).FullName);
 
                if (t != null && !pluginType.IsAbstract)
                {
                    IPlugin pluginInfo = (IPlugin)Activator.CreateInstance(pluginType);
                    result.Add(pluginInfo);
                }
            }
        }
        catch (Exception exc)
        {
            System.Diagnostics.Debug.WriteLine(exc.Message);
        }
    }
 
    watch.Stop();
    var elapsedMs = watch.ElapsedMilliseconds;
 
    return result;
}

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

        private List<IPlugin> ScanPlugins(IApplication app)
        {
            List<IPlugin> result = new List<IPlugin>();
 
            var files = this.GetLibraries();
 
            try
            {
                var plugins = from filename in files.AsParallel()
                              let assembly = Assembly.LoadFile(filename)
                              from attributePlugin in assembly.GetCustomAttributes(typeof(AssemblyPluginTypeAttribute), false).AsParallel()
                              let pluginType = (attributePlugin as AssemblyPluginTypeAttribute).PluginType
                              let interfaceType = pluginType.GetInterface(typeof(IPlugin).FullName)
                              where interfaceType != null && !pluginType.IsAbstract
                              let pluginInfo = (IPlugin)Activator.CreateInstance(pluginType) // Создание экземпляра
                              select pluginInfo;
 
                result = plugins.ToList();
 
                Parallel.ForEach(result, (plugin) =>
                    {
                        plugin.Initialize(app); // Дополнительная инициализация каждого экземпляра
                    });
            }
            catch (Exception exc)
            {
                System.Diagnostics.Debug.WriteLine(exc.Message);
            }
 
            return result;
        }