.Net Core, 1C, динамическая компиляция, Scripting API

Это продолжение статей Кроссплатформенное использование классов .Net в 1С через Native ВК. Или замена COM на Linux
Кроссплатформенное использование классов .Net в 1С через Native ВК. Или замена COM на Linux II
Асинхронное программирование в 1С через использование классов .Net из Native ВК
1С, Linux, Excel, Word, OpenXML, ADO, Net Core

На данный момент в .Net Core 2 варианта динамической компиляции 1. Это аналог CodeDom Microsoft.CodeAnalysis.CSharp.CSharpCompilation 
2. Roslyn Scripting Api. Примеры здесь

    var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("a")
.WithOptions(new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(Microsoft.CodeAnalysis    .OutputKind.DynamicallyLinkedLibrary))
.AddReferences(
Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location))
.AddSyntaxTrees(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(
@"
using System;

public  class C
{

public  C(){}
public string  M()
{
return ""Hello Roslyn."";
}
}"));

var fileName = @"d:NetStandartTestCoreNetAppsrcTestCoreNetAppinDebug
etcoreapp1.0a.dll";

compilation.Emit(fileName);

var a = System.Runtime.Loader.AssemblyLoadContext.Default.LoadFromAssemblyPath(fileName);


Type тип = a.GetType("C");
var obj = Activator.CreateInstance(тип);

var res = тип.GetMethod("M").Invoke(obj, null);
Console.WriteLine(res.ToString());

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

 Второй способ мне нравится больше. Возьмем на примере получения делегата.

            string words = "надо заменить все первые буквы в словах на заглавные";
string pattern = @"w+";

var scr = Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default;
var mscorlib = Assembly.Load(System.Runtime.Loader.AssemblyLoadContext.GetAssemblyName(@"c:UsersSmirnov_SA.nugetpackagesMicrosoft.NETCore.Portable.Compatibility1.0.1
ef
etcore50mscorlib.dll"));
scr =scr.WithReferences(mscorlib, typeof(MulticastDelegate).GetTypeInfo().Assembly, typeof(System.Runtime.CompilerServices.IStrongBox).GetTypeInfo().Assembly, typeof(MatchEvaluator).GetTypeInfo().Assembly, typeof(Regex).GetTypeInfo().Assembly)
.WithImports("System", "System.Text.RegularExpressions");


string КодДелегата = @"return (MatchEvaluator)((match) =>
{
string x = match.Value;
// If the first char is lower case...
if (char.IsLower(x[0]))
{
// Capitalize it.
return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
}
return x;

});";
var result = Microsoft.CodeAnalysis.CSharp.Scripting.CSharpScript.EvaluateAsync(КодДелегата, scr).Result;
MatchEvaluator evaluator = (MatchEvaluator)result;

Console.WriteLine(Regex.Replace(words, pattern, evaluator));

 Обязательно нужно указать ссылки на:
   mscorlib.dll
   System.Private.CoreLib.ni.dll
   System.Runtime.dll 

 Для компиляции используются следующие библиотеки:
   «Microsoft.CodeAnalysis.CSharp»: «2.0.0-beta3»,
    «Microsoft.CodeAnalysis.CSharp.Scripting»: «2.0.0-beta3»,
    «Microsoft.CodeAnalysis.Scripting.Common»: «2.0.0-beta3»,
     Microsoft.CodeAnalysis.Scripting

   По динамической компиляции. В свое время работал с запчастями для автомобилей. А там куча поставщиков и клиентов. При этом прайсы на миллионы позиций. И каждый горазд давать данные в своем формате.  Было проще для каждого клиента создавать код,  записывать в справочник и использовать через Выполнить или Вычислить. Правда, при работе с миллионными прайсами этот подход тормозил.
 
Так или иначе приходилось писать DLL и работать через COM.

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

 Скорость компиляции достаточно высокая (кроме первого раза секунд 5).

 Перейдем к 1С. Так воторй алгоритм на 1С выглядит так

            стр  = "return (MatchEvaluator)((match) =>
|{
|  string x = match.Value;
|// If the first char is lower case...
|if (char.IsLower(x[0]))
|{
|// Capitalize it.
|return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
|}
|return x;
|
|});";

текст = "надо заменить все первые буквы в словах на заглавные";
Образец = "w+";
// MatchEvaluator evaluator = (MatchEvaluator)ПолучитьДелегат();
ScriptOptions=ъТип("Microsoft.CodeAnalysis.Scripting.ScriptOptions","Microsoft.CodeAnalysis.Scripting");
CSharpScript=ъТип("Microsoft.CodeAnalysis.CSharp.Scripting.CSharpScript","Microsoft.CodeAnalysis.CSharp.Scripting");

scr = ъ(ScriptOptions.Default);
mscorlibСборка = ъ(Врап.Сборка("mscorlib.dll",Истина));
Private_CoreLibСборка=ъ(Врап.Сборка("System.Private.CoreLib.ni",Истина));
System_RuntimeСборка=ъ(Врап.Сборка("System.Runtime",Истина));
RegularExpressionsСборка=ъ(Врап.Сборка("System.Text.RegularExpressions",Истина));
Regex=ъ(RegularExpressionsСборка.GetType("System.Text.RegularExpressions.Regex"));
scr =ъ(scr.WithReferences(mscorlibСборка.ПолучитьСсылку(), Private_CoreLibСборка.ПолучитьСсылку(), System_RuntimeСборка.ПолучитьСсылку(), RegularExpressionsСборка.ПолучитьСсылку()));

scr =ъ(scr.WithImports("System", "System.Text.RegularExpressions"));

evaluator = ъ(ъ(CSharpScript.EvaluateAsync(стр, scr.ПолучитьСсылку())).Result);
Сообщить(Regex.Replace(текст, Образец, evaluator.ПолучитьСсылку()));

В общем, ничего особенного. Получили сборки, дали ссылки на них, скомпилировали, вызвали.

Перейдем к более сложным примерам. Так, в предыдущей статье я показывал примеры использования DocumentFormat.OpenXml на примере чтения Excel и Word.

Там была проблема в скорости из-за приведения строки к объекту через функцию, и сама скорость вызова из 1С в 5 раз медленнее её родного кода.

Поэтому вынесем большую часть кода в .Net. Аналогичный вариант есть на большом .Net  .Net в 1С. На примере использования HTTPClient,AngleSharp. Удобный парсинг сайтов с помощью библиотеки AngleSharp, в том числе с авторизацией аля JQuery с использованием CSS селекторов. Динамическая компиляция (пример в конце статьи).

Создадим класс и скопируем его в макет. Суть класса — прочитать данные ячеек и сгруппировать их по номеру строки

public class ДанныеЯчейки
{

public string ИмяЯчейки;
public string ИмяКолонки;
public int НомСтроки;
public string ЗначениеЯчейки;

}
public class ExcelReader
{
static Regex ШаблонКолонки = new Regex("[A-Za-z]+");
OpenXmlElementList ОбщиеСтроки;

void ЗаписатьДанныеАдреса(string адрес, ДанныеЯчейки данныеЯчейки)
{

данныеЯчейки.ИмяЯчейки = адрес;
var match = ШаблонКолонки.Match(адрес);
var ИмяКолонки = match.Value;
var НомерСтроки = int.Parse(адрес.Substring(ИмяКолонки.Length));
данныеЯчейки.ИмяКолонки = ИмяКолонки;
данныеЯчейки.НомСтроки = НомерСтроки;

}
void ДобавитьДанныеОбЯчейке(List<ДанныеЯчейки> ДанныеЭселя, Cell cell)
{
var адрес = cell.CellReference.InnerText;
var text = cell.CellValue?.Text;
var DataType = cell.DataType;
string res = text;
if (DataType != null && DataType == CellValues.SharedString)
{
int ssid = int.Parse(text);
res = ОбщиеСтроки[ssid].InnerText;
}

if (res == null) return;

var result = new ДанныеЯчейки();
ЗаписатьДанныеАдреса(адрес, result);
result.ЗначениеЯчейки = res;

ДанныеЭселя.Add(result);
}
public List<ДанныеЯчейки> ReadExcel(string fileName)
{
List<ДанныеЯчейки> ДанныеЭселя = new List<ДанныеЯчейки>();
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (SpreadsheetDocument doc = SpreadsheetDocument.Open(fs, false))
{
var workbookPart = doc.WorkbookPart;

// Строки хранятся отдельно
// В ячейках хранится индекс
var pt = workbookPart.GetPartsOfType<SharedStringTablePart>();
var sstpart = pt.First();
var sst = sstpart.SharedStringTable;
ОбщиеСтроки = sst.ChildElements;

var workbook = workbookPart.Workbook;

// Получим список страниц
var sheet = workbook.Descendants<Sheet>().First();

var worksheetPart = (DocumentFormat.OpenXml.Packaging.WorksheetPart)workbookPart.GetPartById(sheet.Id);

var worksheet = worksheetPart.Worksheet;

var cells = worksheet.Descendants<Cell>();


// One way: go through each cell in the sheet
foreach (Cell cell in cells)
{
ДобавитьДанныеОбЯчейке(ДанныеЭселя, cell);
}
}
}

return ДанныеЭселя;
}

static string НайтиИмяПоследнейКолонки(List<ДанныеЯчейки> Тз)
{
var рез = "";
var ДлинаРез = 0;
foreach (var стрТз in Тз)
{
var Стр = стрТз.ИмяКолонки;
var СтрДл = Стр.Length;

if (СтрДл > ДлинаРез)
{
ДлинаРез = СтрДл;
рез = Стр;
}
else if (СтрДл == ДлинаРез && string.Compare(Стр, рез, true) > 0)
рез = Стр;

}
return рез;
}

public static object ПолучитьДанныеЭкселя(string fileName)
{

var res = new ExcelReader();
var Данные = res.ReadExcel(fileName);
var данныеЭкселя = Данные.GroupBy(ё => ё.НомСтроки).Select(ъ => new { НомСтроки = ъ.Key, Ячейки = ъ.ToArray() }).OrderBy(ь => ь.НомСтроки);
var ИмяПоследнейКолонки = НайтиИмяПоследнейКолонки(Данные);
return new { ДанныеЁкселя = данныеЭкселя.ToList(), ИмяПоследнейКолонки = ИмяПоследнейКолонки };

}

}

return new Func<string, object>(ExcelReader.ПолучитьДанныеЭкселя);

Мы описали класс чтения и возвращаем ссылку на делегат, принимающий путь к файлу и возвращающий анонимный класс. Все равно в 1С мы будем работать с ним через рефлексию. Обратите внимание, что здесь описаны 2 класса.

Теперь вызовем этот код из 1С.

        ScriptOptions=ъТип("Microsoft.CodeAnalysis.Scripting.ScriptOptions","Microsoft.CodeAnalysis.Scripting");
CSharpScript=ъТип("Microsoft.CodeAnalysis.CSharp.Scripting.CSharpScript","Microsoft.CodeAnalysis.CSharp.Scripting");

scr = ъ(ScriptOptions.Default);
mscorlibСборка = ъ(Врап.Сборка("mscorlib.dll",Истина));
Private_CoreLibСборка=ъ(Врап.Сборка("System.Private.CoreLib.ni",Истина));
System_RuntimeСборка=ъ(Врап.Сборка("System.Runtime",Истина));
RegularExpressionsСборка=ъ(Врап.Сборка("System.Text.RegularExpressions",Истина));
OpenXmlСбока=ъ(Врап.Сборка("DocumentFormat.OpenXml.dll"));
LinqСбока=ъ(Врап.Сборка("System.Linq", истина));
FileSystemСбока=ъ(Врап.Сборка("System.IO.FileSystem", истина));

Regex=ъ(RegularExpressionsСборка.GetType("System.Text.RegularExpressions.Regex"));
scr =ъ(scr.WithReferences(mscorlibСборка.ПолучитьСсылку(), Private_CoreLibСборка.ПолучитьСсылку(), System_RuntimeСборка.ПолучитьСсылку(), RegularExpressionsСборка.ПолучитьСсылку(),OpenXmlСбока.ПолучитьСсылку(),LinqСбока.ПолучитьСсылку(),FileSystemСбока.ПолучитьСсылку()));
scr =ъ(scr.WithImports("System", "System.Collections.Generic", "System.Linq", "System.IO", "DocumentFormat.OpenXml", "DocumentFormat.OpenXml.Packaging", "DocumentFormat.OpenXml.Spreadsheet", "System.Text.RegularExpressions"));

Текст=ПолучитьМакет("ТекстКлассаЧтенияЕксель").ПолучитьТекст();

Делегат = ъ(ъ(CSharpScript.EvaluateAsync(Текст, scr.ПолучитьСсылку())).Result);
Данные= ъ(Делегат.DynamicInvoke(ИмяФайла));

Сообщить(Данные.ИмяПоследнейКолонки);

рез=новый ТаблицаЗначений;
ПоследняяКолонка=Данные.ИмяПоследнейКолонки;
СоздатьКолонки(рез.Колонки,ПоследняяКолонка);
Колонки=рез.Колонки;

Тз=ъ(Данные.ДанныеЁкселя);
Тз=ъ(Врап.ПолучитьЭнумератор(Тз.ПолучитьСсылку()));

сч=1;
// Получили сгруппированные данные по строкам
Пока Тз.MoveNext() Цикл
стрТз= ъ(Тз.Current);

НомСтроки=стрТз.НомСтроки;
Пока сч<НомСтроки Цикл
сч=сч+1;
рез.Добавить();
КонецЦикла;
сч=сч+1;
стр=рез.Добавить();

// получим ячейки по строке
ТзГр=ъ(стрТз.Ячейки);
ТзГр=ъ(Врап.ПолучитьЭнумератор(ТзГр.ПолучитьСсылку()));

Пока ТзГр.MoveNext() Цикл
стрТзГр= ъ(ТзГр.Current);
ИмяКолонки=стрТзГр.ИмяКолонки;
ЗначениеЯчейки=стрТзГр.ЗначениеЯчейки;
// Можно конечно получить индекс зная смещение символа 64 относительно 1 и 26 разрядную систему
// но найдем колонку по имени и её индекс
Колонка=Колонки.Найти(ИмяКолонки);
стр.Установить(Колонки.Индекс(Колонка),ЗначениеЯчейки);
КонецЦикла;
КонецЦикла;

Теперь скорость обработки Экселя значительно увеличилась, а затраты на компиляцию соизмеримы с затратами на чтения файлов.

Посмотрим процесс чтения Word. Не мудрствуя лукаво, я взял готовый класс здесь. Тем более там все на английском.

// Исходники можно скачать здесь
//https://code.msdn.microsoft.com/office/CSOpenXmlGetPlainText-554918c3/sourcecode?fileId=71592&pathId=851860130
public class GetWordPlainText : IDisposable
{
// Specify whether the instance is disposed.
private bool disposed = false;

// The word package
private WordprocessingDocument package = null;

/// <summary>
///  Get the file name
/// </summary>
private string FileName = string.Empty;

/// <summary>
///  Initialize the WordPlainTextManager instance
/// </summary>
/// <param name="filepath"></param>
public GetWordPlainText(string filepath)
{
this.FileName = filepath;
if (string.IsNullOrEmpty(filepath) || !File.Exists(filepath))
{
throw new Exception("The file is invalid. Please select an existing file again");
}

this.package = WordprocessingDocument.Open(filepath, true);
}

/// <summary>
///  Read Word Document
/// </summary>
/// <returns>Plain Text in document </returns>
public string ReadWordDocument()
{
StringBuilder sb = new StringBuilder();
OpenXmlElement element = package.MainDocumentPart.Document.Body;
if (element == null)
{
return string.Empty;
}

sb.Append(GetPlainText(element));
return sb.ToString();
}

/// <summary>
///  Read Plain Text in all XmlElements of word document
/// </summary>
/// <param name="element">XmlElement in document</param>
/// <returns>Plain Text in XmlElement</returns>
public string GetPlainText(OpenXmlElement element)
{
StringBuilder PlainTextInWord = new StringBuilder();
foreach (OpenXmlElement section in element.Elements())
{
switch (section.LocalName)
{
// Text
case "t":
PlainTextInWord.Append(section.InnerText);
break;

case "cr":                          // Carriage return
case "br":                          // Page break
PlainTextInWord.Append(Environment.NewLine);
break;

// Tab
case "tab":
PlainTextInWord.Append("	");
break;

// Paragraph
case "p":
PlainTextInWord.Append(GetPlainText(section));
PlainTextInWord.AppendLine(Environment.NewLine);
break;

default:
PlainTextInWord.Append(GetPlainText(section));
break;
}
}

return PlainTextInWord.ToString();
}

#region IDisposable interface

public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
// Protect from being called multiple times.
if (disposed)
{
return;
}

if (disposing)
{
// Clean up all managed resources.
if (this.package != null)
{
this.package.Dispose();
}
}

disposed = true;
}
#endregion

public static string GetText(string FileName)
{

using (var pt = new GetWordPlainText(FileName))
{

return pt.ReadWordDocument();
}
}
}

return new Func<string,string>(GetWordPlainText.GetText);

Но вернемся к Руслишу:

        ScriptOptions=ъТип("Microsoft.CodeAnalysis.Scripting.ScriptOptions","Microsoft.CodeAnalysis.Scripting");
CSharpScript=ъТип("Microsoft.CodeAnalysis.CSharp.Scripting.CSharpScript","Microsoft.CodeAnalysis.CSharp.Scripting");

scr = ъ(ScriptOptions.Default);
mscorlibСборка = ъ(Врап.Сборка("mscorlib.dll",Истина));
Private_CoreLibСборка=ъ(Врап.Сборка("System.Private.CoreLib.ni",Истина));
System_RuntimeСборка=ъ(Врап.Сборка("System.Runtime",Истина));
RegularExpressionsСборка=ъ(Врап.Сборка("System.Text.RegularExpressions",Истина));
OpenXmlСбока=ъ(Врап.Сборка("DocumentFormat.OpenXml.dll"));
LinqСбока=ъ(Врап.Сборка("System.Linq", истина));
FileSystemСбока=ъ(Врап.Сборка("System.IO.FileSystem", истина));

Regex=ъ(RegularExpressionsСборка.GetType("System.Text.RegularExpressions.Regex"));
scr =ъ(scr.WithReferences(mscorlibСборка.ПолучитьСсылку(), Private_CoreLibСборка.ПолучитьСсылку(), System_RuntimeСборка.ПолучитьСсылку(),OpenXmlСбока.ПолучитьСсылку(),FileSystemСбока.ПолучитьСсылку()));
scr =ъ(scr.WithImports("System", "System.Text",  "System.IO", "DocumentFormat.OpenXml", "DocumentFormat.OpenXml.Packaging"));

Текст=ПолучитьМакет("ТекстЧтенияВорд").ПолучитьТекст();

Делегат = ъ(ъ(CSharpScript.EvaluateAsync(Текст, scr.ПолучитьСсылку())).Result);
стр = Делегат.DynamicInvoke(ИмяФайла);

Текст=Новый ТекстовыйДокумент;
Текст.ДобавитьСтроку(стр);
Текст.Показать();

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

В следующей статье я сделаю динамическое создание обертки над объектами, использующими события, по аналогии с
.NET(C#) для 1С. Динамическая компиляция класса обертки для использования .Net событий в 1С через ДобавитьОбработчик или ОбработкаВнешнегоСобытия