.Net Core, обмен с 1C по TCP/IP между различными устройствами

Начну с «Вести с полей»: вышло обновление Updates in .NET Core 1.0.1. Главное из этого для меня было Access violation on Windows – coreclr 6460:

In Jitstartup, JIT creates a file descriptor for stdout and unconditionally passes it to setmode, without checking for failures. This happens at. Failure to check for invalid descriptors can result in setmode triggering failfast.

Из-за этой ошибки вылетало исключение при вызове статического .Net-метода в 64 разрядном клиенте 1С.
В 

Необработанное исключение по адресу 0x00007FFD76FB8528 (ucrtbase.dll) в 1cv8.exe: Недопустимый параметр был передан функции, для которой недопустимые параметры вызывают неустранимую ошибку.

   Сейчас починили, и код прекрасно выполняется под 64 разрядным клиентом на 8.3.9. В примерах заменил библиотеки .NET Core на 1.0.1. Хотел написать про SignalR, но пока можно написать только сервер на .Net Core — ASP.NET Core SignalR for Windows 10 UWP App

aspnet/SignalR-Server

   Клиента пока нет. В WCF пока только клиент под Web сервис. ServiceHost нет. Есть стороннее решение .NET core cross platform remote service invocation

   Но решил написать решение из своего опыта 8 летней давности для обмена данными по TCP/IP между ТСД на Win CE и 1С еще 7-ки. Конечно, с 1С можно обмениваться через Web-сервисы, но есть задачи, где нужно взаимодействие с оператором для выбора данных, брать данные, подготовленные на клиенте, печать на мобильный принтер.

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

   Также были проблемы при считывании двумерного штрихкода. Медленная печать с терминального сервера. Для решения этих проблем на машине клиента устанавливалась локальная 1С, которая работала как клиент и сервер. Данные со сканеров отправлялись на терминальный сервер и там обрабатывались. Для печати на фискальный регистратор отправлялись данные с сервера по TCP/IP, и с локальной 1С печатался чек. При печати этикеток с сервера оправлялись данные, на основании которых на локальной 1С формировался документ и отправлялся на печать.

   Кроме того, под многое оборудование для Linux нет драйверов. Можно, используя виртуализацию, держать Linux и Windows на одной машине, на Windows считывать данные и обмениваться с Linux по TCP/IP.

   Сейчас много у кого есть ТСД под WinCe, WinMo (недавно предлагали работу по настройке обмена на них). Кроме того, можно использовать ТСД на других осях, используя UWP и Xamarin.

   Кроме того, можно обмениваться сообщениями между клиентами 1С, наподобие чата.

  В большом .Net я часто использую обмен по TCp/IP
Использование сборок .NET в 1С 7.x b 8.x. Создание внешних Компонент.

Использование ТСД на WM 6 как беспроводной сканер с получением данных из 1С

  Поэтому я решил написать этот же обмен, но на .Net Core, и добавить новый подход.

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

  Нужно было создать класс для обмена сообщениями с сжатыми данными.
  Для отправки данных использовался метод

        // Отправляем команду на сервер
// Отправляем данные на сервер
// string Команда имя метода который будет обрабатывать данные
// string ДанныеДляКоманды это сериализованные данные в виде строки
// bool ЕстьОтвет признак функции или процедуры метода обрабатывающего данные
public ДанныеОтветаПоTCP ОтправитьКоманду(string АдресСервера, int порт, string Команда, string ДанныеДляКоманды, bool ЕстьОтвет)

   На стороне 1С принимается такой класс

 // Данные отправляемые в 1С для обработки запроса
public class ДанныеДляКлиета1С
{

public bool ЕстьОтвет;
public string Команда;
public string Данные;
TcpClient Клиент;
public ДанныеДляКлиета1С(СтруктураСообщения Даннные, TcpClient Клиент)
{

this.ЕстьОтвет = Даннные.ЕстьОтвет;
this.Команда = Даннные.Команда;
this.Данные = Даннные.Данные;

if (ЕстьОтвет)
this.Клиент = Клиент;
else // Если нет ответа то закрываем соединение
{
Клиент.Dispose();
this.Клиент = null;
}
}


// Отсылаем данные клиенту
//Создадим новую задачу, что бы основной поток 1С не ждал отпраки
//Ответ пытаемся сжать
public void Ответить(string Ответ)
{
Task.Run(() =>
{
var strim = Клиент.GetStream();
ДляОбменаПоТСП.WriteCompressedString(strim, Ответ);
// Закроем соединение
strim.Dispose();
Клиент.Dispose();

});

}

public override string ToString()
{
return $"ЕстьОтвет={ЕстьОтвет}, Команда={Команда}, Данные={Данные}";
}
}

   Модуль для формирования сообщений, который был написан 8 лет назад, с небольшими изменениями.
   Уже тогда я вовсю использовал Руслиш.

   На сервере создается класс для прослушивания

// Класс для получения и отправки сообщений
public class TCPConnector
{

TcpListener Server;

// Будем записывать ошибки в файл
// Нужно прописать в зависимости "System.Diagnostics.TextWriterTraceListener"
// Файл будет рядом с этой DLL
TextWriterTraceListener myTextListener;

// Устанавливаем флаг при закрытии
bool ЭтоЗакрытие = false;
// Клиент для отпраки сообщений на сервер
Socket клиент;

// делегат для вызова внешнего события в 1С
// Который ставит сообщение в очередь событий в 1С
public Action<string, string, object> ВнешнееСобытие1С;

//Делегат для вывода ошибки в окне сообщений
public Action<string> СообщитьОбОшибкев1С;

// Получаем директорию сборки содержащий данный класс
string AssemblyDirectory
{
get
{
string codeBase = typeof(TCPConnector).GetTypeInfo().Assembly.Location;
UriBuilder uri = new UriBuilder(codeBase);
string path = Uri.UnescapeDataString(uri.Path);
return Path.GetDirectoryName(path) + "\";
}
}

public TCPConnector()
{


myTextListener = null;

}

// Записываем ошибку a файл и сообщаем об ошибке в 1С
void ЗаписатьОшибку(string Ошибка)
{
if (myTextListener == null)
{
try
{
FileStream fs = new FileStream(AssemblyDirectory + @"ТрассировкаОтладки",
FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);

StreamWriter myOutputWriter = new StreamWriter(fs, Encoding.GetEncoding(1251));
myTextListener = new TextWriterTraceListener(myOutputWriter);
Trace.Listeners.Add(myTextListener);

}
catch (Exception)
{

// проглотим ошибку что бы приложение закрылось
}
}

Trace.WriteLine(Ошибка);
Trace.Flush();
СообщитьОбОшибкев1С?.DynamicInvoke(Ошибка);
}



// Откроем порт и количество слушющих задач которое обычно равно подсоединенным устройствам
// Нужно учитывть, что 1С обрабатывает все события последовательно ставя события в очередь
public void Открыть(int НомерПорта = 6891, int КоличествоСлушателей = 1)
{
ЭтоЗакрытие = false;

IPEndPoint ipEndpoint = new IPEndPoint(IPAddress.Any, НомерПорта);
Server = new TcpListener(ipEndpoint);
Server.Start();

// Создадим задачи для прослушивания порта
//При подключении клиента запустим метод ОбработкаСоединения
// Подсмотрено здесь https://github.com/imatitya/netcorersi/blob/master/src/NETCoreRemoveServices.Core/Hosting/TcpServerListener.cs
for (int i = 0; i < КоличествоСлушателей; i++)
Server.AcceptTcpClientAsync().ContinueWith(ОбработкаСоединения);

}


// Метод для обработки сообщения от клиента
private void ОбработкаСоединения(Task<TcpClient> task)
{

if (task.IsFaulted || task.IsCanceled)
{
// Скорее всего вызвано  Server.Stop();
return;
}

// Получим клиента
TcpClient client = task.Result;

// И вызовем метод для обработки данных
//
ВыполнитьКоманду(client);

// Если Server не закрыт то запускаем нового слушателя
if (!ЭтоЗакрытие)
Server.AcceptTcpClientAsync().ContinueWith(ОбработкаСоединения);

}




private void ВыполнитьКоманду(TcpClient client)
{

NetworkStream стрим = client.GetStream();
try
{

// Получим данные с клиента и на основании этих данных
//Создадим ДанныеДляКлиета1С котрый кроме данных содержит
//TcpClient для отправки ответа
var Данные = new ДанныеДляКлиета1С(ДляОбменаПоТСП.ПринятьКоманду(стрим), client);

// Вызвается метод 1С для постановки сообщения в очередь
// Которое будет обработано через ВнешнееСобытие
ВнешнееСобытие1С?.DynamicInvoke("TCPConnector", Данные.Команда, Данные);

}
catch (Exception e)
{
ЗаписатьОшибку(DateTime.Now.ToString() + e.ToString());

}
}


// Закроем ресурсы
public void Закрыть()
{
if (Server != null)
{
ЭтоЗакрытие = true;
Server.Stop();
Server = null;


}
if (myTextListener != null)
{

Trace.Listeners.Remove(myTextListener);
myTextListener.Dispose();
}

}

   Все достаточно просто. При соединении считываем данные, создаем объект для отправки в 1С. Запускаем нового слушателя.

Отправка сделана на голых сокетах, можно посмотреть в исходниках.

Упрощенно это выглядит так

IPEndPoint ipEndpoint = new IPEndPoint(IPAddress.Parse(АдресСервера), порт); //6891 по умолчанию
клиент = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
клиент.Connect(ipEndpoint);

var поток= new NetworkStream(клиент);
ДляОбменаПоТСП.ОтправитьКоманду(поток, Команда, ДанныеДляКоманды, ЕстьОтвет);

// считываем сжатые данные в строку
if (ЕстьОтвет) result = ДляОбменаПоТСП.ReadCompressedString(strim);

поток.Dispose();
клиент.Dispose();

Вот как это обрабатывается в 1С

// В Net core для NetStandard System.Threading.Tasks не существует
Task=ъТип("System.Threading.Tasks.Task","System.Threading.Tasks");

Процедура СоздатьСерверTCP()

Если СерверTCP<>Неопределено Тогда
возврат
КонецЕсли;

TCPConnector=ъТип("TCPConnectTo1C.TCPConnector","ОбменПоTCPIPCore.dll");
СерверTCP=ъНовый(TCPConnector.ПолучитьСсылку());
Ссылка=СерверTCP.ПолучитьСсылку();
Врап.УстановитьДелегатДляВызоваВнешнегоСобытия(Ссылка,"ВнешнееСобытие1С");
Врап.УстановитьДелегатДляСообщенииОбОшибке(Ссылка,"СообщитьОбОшибкев1С");

КонецПроцедуры// СоздатьTCP()

Процедура ТестTCPConnectНажатие(Элемент)

// Установим размер очереди событий равный удвоенному количеству
//обслуживаемых устройств
// Но нужно учесть, что запросы без ответа ставятся в очередь 1С
// и сразу закрывается соединение
// Клиент не ждет
// Если будут проблемы нужно посылать запрос с ответом
Сообщить(Врап.УстановитьРазмерОчередиСобытий(3*2));
Сообщить(Врап.УстановитьРазмерОчередиСобытий(3*2));
СоздатьСерверTCP();
СерверTCP.Открыть(6891,3);

ЭлементыФормы.ДанныеДляОтправки.Видимость=ложь;
ЭлементыФормы.ОтправитьКоманды.Видимость=ложь;
ЭлементыФормы.НадписьДанныеДляОтправки.Видимость=ложь;

КонецПроцедуры

Процедура СканированШК(знач Данные)

// Съэмулируем долгую обработку для проверки очереди событий
ъ(Task.Delay(1000)).Wait();
Ответ="Ответ на команду "+Данные.Команда+"
|Данные "+Данные.Данные+"
|ВремяНаСервере="+XmlСтрока(ТекущаяДата());
Данные.Ответить(Ответ);
КонецПроцедуры

Процедура ВыполнитьБезОтвета(знач Данные)
// Съэмулируем долгую обработку для проверки очереди событий
ъ(Task.Delay(1000)).Wait();
КонецПроцедуры

// Для теста из других компонент
Процедура ПолучениеДанныхПоTCP(знач Данные)
Сообщить("Команда="+Данные.Команда);
Сообщить("Данные="+Данные.Данные);
Сообщить("ЕстьОтвет="+Данные.ЕстьОтвет);

ъ(Task.Delay(1000)).Wait();
Если Данные.ЕстьОтвет Тогда
Ответ="Ответ на команду "+Данные.Команда+"
|Данные "+Данные.Данные+"
|ВремяНаСервере="+XmlСтрока(ТекущаяДата());
Данные.Ответить(Ответ);
КонецЕсли;

КонецПроцедуры


Процедура ВнешнееСобытие(Источник, Событие, Данные)

Если Источник="TCPConnector" Тогда
//Получим объект по переданной ссылке
Данные=ъ(Данные);
Сообщить("Данные="+Врап.ВСтроку(Данные.ПолучитьСсылку()));
// Тест из отчета  ТестNetObjectToIDispatch
Если Событие="Тест Отправки Сообщения" Тогда

ПолучениеДанныхПоTCP(Данные)
иначе
// Запускаем метод переданный в коанде
Выполнить(Событие+"(Данные)");

КонецЕсли;
КонецЕсли;

КонецПроцедуры

Процедура ОтправитьКоманду(знач КлиентTCP,ServerAdress,порт,Команда,ДанныеДляКоманды,ЕстьОтвет)

резулт=ъ(КлиентTCP.ОтправитьКоманду(ServerAdress,порт,Команда,ДанныеДляКоманды,ЕстьОтвет));
Сообщить(Врап.ВСтроку(резулт.ПолучитьСсылку()));
Если резулт.ОшибкаСоединения Тогда
СтрОшибки="ОшибкаСоединения
|"+резулт.Данные;
Предупреждение(СтрОшибки);
КонецЕсли;


КонецПроцедуры

Процедура ОтправитьКомандыНажатие(Элемент)
СоздатьСерверTCP();
КлиентTCP=СерверTCP;
ServerAdress="127.0.0.1";
порт=6891;
Команда="Тест Отправки Сообщения";
ДанныеДляКоманды=XmlСтрока(ТекущаяДата());

ЕстьОтвет=истина;
ЗакрытьСоединение=истина;
ОшибкаСоединения=false;

Для сч=1 По 3 Цикл

ОтправитьКоманду(КлиентTCP,ServerAdress,порт,Команда,ДанныеДляКоманды,истина);
ОтправитьКоманду(КлиентTCP,ServerAdress,порт,"ВыполнитьБезОтвета",ДанныеДляОтправки,ложь);
ОтправитьКоманду(КлиентTCP,ServerAdress,порт,"СканированШК","12345678901",истина);
КонецЦикла;

КонецПроцедуры

Процедура ПриЗакрытии()
// Вставить содержимое обработчика.
Если СерверTCP<> неопределено Тогда

СерверTCP.Закрыть();
СерверTCP=Неопределено;
КонецЕсли;

GC=ъТип("System.GC");
GC.Collect();
GC.WaitForPendingFinalizers();
Врап=Неопределено;

КонецПроцедуры

   Ответ передаем через полученный объект

 Данные.Ответить(Ответ);

По умолчанию очередь событий в 1С равна 1. Поэтому 1 задача может выполняться, а еще одна дожидаться в очереди.

Так как можно работать с несколькими устройствами, то нужно установить нужный размер очереди через

Врап.УстановитьРазмерОчередиСобытий(размер очереди));

Который возвращает текущий размер очереди.

Конечно, можно запустить несколько приложений 1С и запустить TCP/IP сервер под разными портами, но на практике операторы путаются. Чем проще для них, тем лучше.

Для установки нужных делегатов используются методы

Врап.УстановитьДелегатДляВызоваВнешнегоСобытия(Ссылка,"ВнешнееСобытие1С");
Врап.УстановитьДелегатДляСообщенииОбОшибке(Ссылка,"СообщитьОбОшибкев1С");

В зависимости от типа делегата устанавливается нужный делегат

   if (ReturnType == typeof(Action<string, string, object>)) return new Action<string, string, object>(ВызватьВнешнееСобытиеСОбъектом);

if (ReturnType == typeof(Action<string, string, string>)) return new Action<string, string, string>(AutoWrap.ВызватьВнешнееСобытие1С);

Конечно, можно использовать события и динамическую компиляцию 1С,.Net Core. Динамическая компиляция класса обертки для получения событий .Net объекта в 1С

Но раз пишем под 1С, то проще объявить делегаты нужного типа, и установить из 1С.

Для теста нужно использовать 3 клиентов 1С и вызвать ТестОбменПоTCPIP.epf для проверки очереди событий в 1С.

Исходники можно скачать Здесь