Aldmi's questions

.grid_container {
  height: 100vh;
  display: grid;
  grid-template-columns: 1fr;
  grid-template-rows: 2fr 1fr;
}
  .item {
    text-align: center;
    background-color: #4a7a60;
    padding: 3px;
    font-size: 35px;
    width: 300px;
    //height: 600px ;
    overflow-y: auto; // если данных много должна появится полоса прокрутки, и не расти высота контейнера
  }
  .zone_1 {
    background-color: #455a64;
  }
  .zone_2 {
    background-color: #455a00;
  }

<div class="grid_container">
  <div class="zone_1">
    <div class="item">
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
      <p>Данные_1</p>
    </div>
  </div>

  <div class="zone_2">
    ZONE_2
  </div>
</div>

您好，网格容器中有 2 行，行的高度占据了所有可用空间的比例，grid-template-rows: 2fr 1fr 如果元素的高度在这些行内变大，那么区域也会开始扩展，但我需要滚动才能。出现并且比率 2fr 1fr 不变。如果手动限制元素的高度，溢出时会出现滚动，但元素将无法占据整个分配的行高。

有一个简化的公式来确定三角形顶点的坐标，如果三角形的底位于x轴上。（导航时需要确定位置，只使用2个锚点，而不是3个）

/// <summary>
/// Определение координат вершины треугольника C.
/// по закону косинусов и теореме пифагора можно вычислить позицию тега. 
/// Треугольник задан вершинами ABC
/// A находится в начале координат (0,0)
/// B вдоль оси X, (var, 0)
/// </summary>
/// <param name="a">длина стороны CB - расстояние от тега C до якоря B</param>
/// <param name="b">длина стороны CA - расстояние от тега C до якоря A (ОТРЕЗОК ВЫХОДЯЩИЙ ИЗ НАЧАЛА КООРДИНАТ - A (0,0))</param>
/// <param name="c">длина стороны AB - расстояние между якорями A и B</param>
/// 
/// <returns></returns>
public static (double x, double y)  CalculatePosition(double a, double b, double c)
{
    var cosA= (b*b + c*c - a*a)/(2*b*c);
    var x = b * cosA;
    var y = b * Math.Sqrt(1 - cosA * cosA);
    return (Math.Round(x, 1, MidpointRounding.AwayFromZero), Math.Round(y, 1, MidpointRounding.AwayFromZero));
}

A (0,0)
B (70,0)
C (x,y)
c= 70
b=58
a= 37

C (x,y) = 50,30

如果顶点 B 不在 x 轴上怎么办？公式的输入数据仍然是相同的，它是边长 (abc)，但点 B 现在有坐标 B (65.25)。让我们将点 A (0,0) 留在坐标原点 我们仍然需要确定点 C 的坐标。

通过迭代器清除内存时，会发生异常。

#include <stdint.h>
#include <vector> 
#include "Shared.h"

using namespace std;

const int RangeItems = 3;

struct Anchor
{
    uint16_t anchor_addr;
    float range[RangeItems];
    float dbm;

    Anchor(uint16_t addr) : anchor_addr(addr), dbm(0) {}
};


struct Link
{
   vector<Anchor> Anchors;

   Link()
   {
       Anchors.reserve(10); //зарезервировать сразу N элементов
   }
};

struct Link* init_link(uint16_t addr)
{
    Link* l = new Link();
    Anchor* a = new Anchor(addr);
    l->Anchors.push_back(*a);
    return l;
}


void add_To_End(struct Link* p, uint16_t addr)
{
    Anchor* a = new Anchor(addr);
    p->Anchors.push_back(*a);
}


Result delete_Anchor(Link* p, uint16_t addr)
{
    for (auto it = p->Anchors.begin(); it != p->Anchors.end(); ++it)
    {
        Anchor a = *it;
        if (a.anchor_addr == addr)
        {
            p->Anchors.erase(it);
            delete &a;               //ECXEPTION!!!!!
            return Succsess;
        }
    }
    return NotFound;
}

用向量测试

int main()
{   
    uwb_data= init_link(1);
    add_To_End(uwb_data, 2);
    add_To_End(uwb_data, 3);
    add_To_End(uwb_data, 4);
    auto res = delete_Anchor(uwb_data, 3);
}

当从vector中移除一个元素时，我想清除Anchor元素占用的内存，但是出现Exception。

该程序有一个后台任务（通过 HttpListener 等待请求），在这个任务内部，当请求到达时，我创建一个任务来处理请求上下文本身。我把处理请求上下文的任务放到了一个HashSet中，请求可以被处理很长时间（最长5秒），并且任务会周期性的累积在HashSet中。我想运行一个后台任务来控制HashSet，即 获取第一个完成的任务，将其从 HashSet 中移除并记录任务完成的结果

StartListen()- 启动所有任务，但启动时没有收到任何请求且HashSet为空，因此无法通过WhenAny等待第一个完成的任务。我可以手动循环，例如，每 100 毫秒一次，检查 HashSet 的元素并在那里查找已完成的任务。所以我有一个问题，这是手动完成的还是可以通过其他方式完成的？

    private readonly  HashSet<Task<Result>> _httpContextTasks = new HashSet<Task<Result>>();


    public Result<Task> StartListen()
    {
        _cts =  new CancellationTokenSource();         
        _bgTask = BackgroundController4ContextHandlers(_cts.Token);
        return ListenHttpAsync(_cts.Token);
    }


    private async Task BackgroundController4ContextHandlers(CancellationToken ct)
    {
        await Task.Run(async () =>
        {
            while (!ct.IsCancellationRequested)
            {
                var completedTask = await Task.WhenAny(_httpContextTasks);
                _httpContextTasks.Remove(completedTask);

                var res = completedTask.Result;
                var strResult = res.ToString();
                _logger.Information("{HttpServer}","ЗАПРОС ОБРАБОТАН", strResult);
            }
            _logger.Information("{HttpServer}","ФОНОВАЯ обработка Task запросов остановлена");
        }, ct);
    }
    
    
    private async Task ListenHttpAsync(CancellationToken ct)
    {
        _listener.Start();
        _logger.Information("{HttpServer}", "Ожидание запросов ...");
        while (!ct.IsCancellationRequested)
        {
            try
            {
                var context = await _listener.GetContextAsync();
                var handler = HttpListenerContextHandlerAsync(context, ct);
                _httpContextTasks.Add(handler);
            }
            catch (TaskCanceledException) { }
        }
    }

你好，这个问题是问题的延续

帮我写一个从模式中排除花括号的正则表达式

简而言之，要从字符串中选择变量及其格式，我使用模式

Pattern = "\{([^:{]+)(:[^{}]+)?\}"

当前使用的模式分配了 2 个组，但有必要再引入一个 OPTIONAL 组。

var str ="0x57{Nbyte(а-С):X2}hhh"
Groups[0] = {Nbyte(а-С):X2}
Groups[1] = Nbyte
Groups[2] = (а-С)    - новая группа
Groups[3] = :X2

1 группа - выделяет имя переменной (исключая 2 симола :{) -  ([^:{]+)
2 группа - должна быделить НЕ ОБЯЗАТЕЛЬНЫЕ опции заключенные в () или []. внутри опций может быть симол : но не может быть символов {}
3 группа - выделяет формат (вместе с :) исключая симолы {} - (:[^{}]+)

例子：

var str ="0x57{Nbyte:X2}hhh"
Groups[0] = {Nbyte:X2}
Groups[1] = Nbyte
Groups[2] = 
Groups[3] = :X2

var str ="0x57{Nbyte}hhh"
Groups[0] = {Nbyte}
Groups[1] = Nbyte
Groups[2] = 
Groups[3] =

var str ="0x57{Nbyte[:-+]:X2}hhh"
Groups[0] = {Nbyte[:-+]:X2}
Groups[1] = Nbyte
Groups[2] = [:-+]
Groups[3] =:X2

var str ="0x57{Nbyte[:-+]}hhh"
Groups[0] = {Nbyte[:-+]}
Groups[1] = Nbyte
Groups[2] = [:-+]
Groups[3] =

var str ="0x57{Nbyte[{hghfghgtf]:X2}hhh" 
- опции не валидны, т.к. внутри [] содержится симол {

PS请在回答中写下关于常规赛的详细评论。

有一个用于解析变量名称及其格式的正则表达式。

var pattern= @"\{(.*?)(:.+?)?\}"
var str="0x57{Nbyte:X2}hhh"

 var matches = Regex.Matches(str, pattern)

 match.Groups[0].Value - все выражение {Nbyte:X2}
 match.Groups[1].Value - имя переменной Nbyte
 match.Groups[2].Value - формат :X2 

如果工程师错误地设置了字符串

 var str = "0x57{Nbyte:X2 fff {CRCXor[0x02-0x03]:X2}";
 {Nbyte:X2 - забыли закр. скобку

然后程序正在谈论一个错误（这很好））），现在有一堆新协议，这种情况可能是有效的。那些。{Nbyte:X2解析时只需要忽略，只选择{CRCXor[0x02-0x03]:X2} строку.

Резульат парсинга:
     match.Groups[0].Value - все выражение {Nbyte:X2 fff {CRCXor[0x02-0x03]:X2}
     match.Groups[1].Value - имя переменной Nbyte
     match.Groups[2].Value - формат :X2 fff {CRCXor[0x02-0x03]:X2

我认为有必要设置一个规则 - 所选行内不应有括号，{}。请帮我为 {,} 添加排除规则

告诉我如何编写 JSON 对象作为yml文件的参数。net core 应用程序的所有配置都是在容器启动时完成的docker-compose，通过传入环境变量 ( environment)。

services:
  webapiswc:
    image: ${DOCKER_REGISTRY-}webapiswc
    build:
      context: .
      dockerfile: WebApis/Dockerfile
    ports:
     - "44138:80"
    environment:
     - ASPNETCORE_ENVIRONMENT=Production
     - DbConnection=User ID = postgres; Password = dmitr; Server = host.docker.internal; Port = 5432; Database = OptionDevice_Prod; Integrated Security = true; Pooling = true;
     - HowCreateDb=Migrate
     - Logger_MinLevel=Information

我需要通过以下设置：

- Firewall= { "IPAddress": ["192.168.100.33", "192.168.100.40" ], "CIDRNotation":["110.40.88.12/28" ]}

那些。IPAddress 列表和 CIDRNotation 列表。然后我反序列化这个对象。

接受 从变量中获取调试ASPNETCORE_ENVIRONMENT=Debug设置的规则。事实证明，您需要以某种方式屏蔽括号、引号，以便传输常规字符串。没有找到文件是如何完成的。appsettings.jsonProductionenvironment.yml

您好，在处理 AspNetCore 2.2 上的 Web 服务的到达数据之前，需要执行一项任务。

该服务启动多达 100 个通过 POST 请求接收数据的并行设备。我不会描述设备如何处理这些数据。

在处理这些数据之前有一项任务要做。例如，在输入中，有一个字符串类型的字段“名称”，其值为“MyLongName”。工程师制定了如何转换此字符串的规则。

1. 如果超过限制修剪线
2. 在正确的位置插入子字符串
3. 更改案例
4. ...

那些。构建了一个动作管道来处理该类型。

public class MiddleWareInData<TIn> : IDisposable
{
    public List<StringHandlerMiddleWare> StringHandlers { get; }
    public List<DateTimeHandlerMiddleWare> DateTimeHandlers { get; }

    private void HandleInvoke(IEnumerable<TIn> datas)
    {
        foreach (var data in datas)
        {
            //ОБРАБОТЧИКИ String
            Parallel.ForEach(StringHandlers, (stringHandler) =>
            {
                //Псевдо код обработки !!!
                var str = "Начальная строка";          //Найденное свойство в типе через рефлексию
                var res = stringHandler.Convert(str);  //Преобразование
                str = res;                             //перезаписали занчение свойства
            });

            //ОБРАБОТЧИКИ DateTime
            //foreach (var dateTimeHandler in DateTimeHandlers)
            //{

            //}
        }
    }
}


public class StringHandlerMiddleWare : BaseHandlerMiddleWare<string>
{

    public StringHandlerMiddleWare(StringHandlerMiddleWareOption option)
    {
        PropName = option.PropName;

        if (option.InseartStringConverterOption != null)
        {
            Converters.Add(new InseartStringConverter(option.InseartStringConverterOption));
        }
        if (option.LimitStringConverterOption != null)
        {
            Converters.Add(new LimitStringComverter(option.LimitStringConverterOption));
        }
        if (option.ReplaceEmptyStringConverterOption != null)
        {
            Converters.Add(new ReplaceEmptyStringConverter(option.ReplaceEmptyStringConverterOption));
        }
    }
}


public abstract class BaseHandlerMiddleWare<T>
{
    public string PropName { get; protected set; }
    protected readonly List<IConverterMiddleWare<T>> Converters = new List<IConverterMiddleWare<T>>();

    public virtual T Convert(T inProp)
    {
        var processedPrallel = Converters
            .AsParallel()
            .AsOrdered();

        foreach (var converter in processedPrallel)
        {
            inProp = converter.Convert(inProp);
        }
        return inProp;
    }
}

在 MiddleWareInData 类中，数据进入 HandleInvoke 方法，在该方法中它们开始按顺序处理，一次 1。我决定并行处理。最简单的方法是使用Parallel.ForEach，跨类型并行处理（一个数据单元的所有String类型都是并行处理的），在String类型的处理里面，启动了一个类型处理流水线，也可以运行在使用 PLINQ 并行（保持转换器调用的顺序）。您还可以使用 Parallel.ForEach 并行开始迭代 stringHandler 的数据本身。

那些。我们得到一个从 1 开始并行处理的输入数据列表。在这个数据单元的处理程序中，所有字符串类型都是并行处理的。字符串处理管道也是并行的（保留调用的顺序）。

我考虑过使用 MapReduce，但处理结束时不需要 Reduce（卷积），最后会有与输入相同的数据列表，只有转换后的数据。这种方式并行化处理是正常的，还是需要手动限制线程数，比如Parallel.ForEach。或者也许在某处使用 Task-i。

我将举一个具体的例子来分析并行操作设备100个。每个设备接受一个包含 50 个项目的列表。每个元素由 10 个 Handler 处理（需要更改 10 个 String 类型） 每个元素的处理管道由 5 个阶段组成。

您好，我阅读了很多关于 DDD 的内容，遵循此概念的 RIGID 要求之一是仅在“聚合根”类型中使用存储库

 public abstract class Repository<T> where T : AggregateRoot
 {
   public T GetById(long id)
   {

   }      
   public void Save( T aggregateRoot)
   {

   }
 }

估值公司有领域模型（子领域）参考。域内部几乎没有业务逻辑，更需要具有 CRUD 操作的存储系统，但仍然可以区分成熟的域。
每个公司都包含要评估的房屋列表，每个房屋都有一组属性和业务逻辑。

PS 在示例中，我特意指定了一个简单的域模型（公共获取，为属性设置）。

базовые классы:
DomainEntity - содержит Id, объект мутабелен
DomainValueObject - НЕ содержит Id объект имутабелен.

public class Company : AggregateRoot
{    
    public string Name { get; set; } 
    public List<House> Houses { get; set; }    
}

public class House : DomainValueObject<House>
{     
    public string City { get; set; }                // Город
    public string District { get; set; }            // Район
    public string Street { get; set; }              // Улица
    public string Number { get; set; }              // Дом

    public int? Year { get; set; }                  // Год постройки
    public string MetroStation { get; set; }        // Ближайшая станция метро
    public string Geo { get; set; }                 // гео координаты
    public WallMaterial WallMaterial { get; set; }

    //бизнес логика......
}

public class WallMaterial : DomainValueObject<WallMaterial>
{
  public string Name { get; }  

  //бизнес логика......
}

在我的示例中，公司是聚合根

1. 阅读这家公司的所有房屋。我将不得不拉动整个公司。

    var company= companyRepository.GetById(1);//Тут все зависимости (полный объект Домена)
    var houses= company.Houses;
   

DDD 对此有一个答案，对返回的对象执行 Dto（在特殊情况下）。

var housesDto= companyRepository.GetAllHousesDto(); 

返回的不是House，而是假的，为了符合这个概念——你不能部分地使用聚合，而只能通过聚合的根。houseDto 不是聚合的一部分，它是它的假冒。在这里，遵循这个概念是可以理解的，也不是很痛苦。

2. 添加一个新家。

那些。添加新房子，我们通过聚合根进行交互：据我了解，存储库的这种使用是假设的

  var company= companyRepository.GetById(1);
  company.Houses.Add(newHouse); 
  companyRepository.Save(company);

那些。为了让我添加房子，我需要从数据库中提取公司，以及所有依赖项，添加房子然后保存。但这不是最优的，不是吗？为什么我需要额外的读取操作？

根据经典（如果您使用 EFcore 作为存储技术），我们这样做。

public async Task<bool> AddHouseInCompanyAsync(long companyId, House house)
{
    var efHouse = Mapper.Map<EfHouse>(house);
    efHouse.EfCompanyId = companyId;
    var res= await _context.Houses.AddAsync(efHouse);
    return res.State == EntityState.Added;
}

但这已经是违反 DDD 了，repository 方法使用了 House 部分。

怎样成为？总是通过公司更改对象（即通过聚合根）？还是 DDD 不适合我的任务，使用 CRUD 包装器更好吗？

我在 asp net core 2.2 上的应用程序中通过 POST 多部分请求收到 Xml 文档当我尝试将文档反序列化为 Dto 对象时，出现异常，指示包含俄语字符的字符串中的编码错误。

{System.InvalidOperationException: There is an error in XML document (8, 15). ---> System.Xml.XmlException: Invalid character in the given encoding. Line 8, position 15.

<StartStation>Красноярск</StartStation>

如果克拉斯诺亚尔斯克被克拉斯诺亚尔斯克取代，那么一切都会奏效。

XML 标头中的编码是“utf-8”，不能更改，因为 PHP 中的许多客户端通常会接收文件。

<?xml version="1.0" encoding="utf-8"?>
<tlist>
<t>
<ScheduleId>20905</ScheduleId>
<TrainNumber>6337</TrainNumber>
<TrainType></TrainType>
<StartStation>Красноярск</StartStation>
</t>
</tlist>


[Serializable]
[XmlRoot("tlist")]
public class AdInputType4XmlDtoContainer
{
    [XmlElement("t")]
    public List<AdInputType4XmlDto> Trains { get; set; } = new List<AdInputType4XmlDto>();
}

[Serializable]
public class AdInputType4XmlDto
{
    public int Id { get; set; }
    public int  ScheduleId { get; set; }                          
    public int TrnId { get; set; }                                 
    public string TrainNumber { get; set; }                        
    public string TrainType { get; set; }                    
    public string DirectionStation  { get; set; }                  
    public string StartStation { get; set; }                        

}


    [HttpPost("SendDataXmlMultipart4Devices")]
    public async Task<IActionResult> SendDataXmlMultipart4Devices([FromForm] IFormFile username)                                                                      )
    {
        var xmlFile = username;
        try
        {
            if (username.Length > 0)
            {
                using (var memoryStream = new MemoryStream())
                {
                    await xmlFile.CopyToAsync(memoryStream);
                    var formatter = new XmlSerializer(typeof(AdInputType4XmlDtoContainer));
                    memoryStream.Position = 0;
                    var adInputType4XmlList = (AdInputType4XmlDtoContainer)formatter.Deserialize(memoryStream); //!!!! ИСКЛЮЧЕНИЕ
                }
            }
        }
        catch (Exception ex)
        {
            _logger.Error(ex, "Ошибка в InputDataController/SendDataXmlMultipart4Devices");
            throw;
        }
    }

您好，我需要发送这样一个 XML 文档

<tlist>
    <t>
        <ScheduleId>12254</ScheduleId>
        ...
    </t>
    <t>
        <ScheduleId>333333</ScheduleId>
        ...
    </t>
</tlist>

添加了支持"application/xml" services.AddXmlSerializerFormatters()

[HttpPost]
[Produces("application/xml")]
public void Post([FromBody] ТипДляПриемаDto trainsList)
{

}

我创建了 TrainDto 类型并通过 GET 请求返回了一个 List，结果如下：

public class TrainDto
{
   public int  ScheduleId { get; set; }
}

<ArrayOfTrainDto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <TrainDto>
        <ScheduleId>0</ScheduleId>
    </TrainDto>
</ArrayOfTrainDto>

也就是说，对象的集合被包装在<ArrayOf...>默认处理程序的标记中。

告诉我如何编写自己的 XML 处理程序，还是必须接受 XML 作为字符串并自己解析它？

在 {} 之间有一条线，其中设置了插入变量的位置。对于数字变量，您可以指定插入格式，{AddressDevice:X2} 这意味着变量AddressDevice = 5将以十六进制格式插入05。

例如，有一行：

 "STX{AddressDevice:X2}{Nbyte:X2}"

只有 {AddressDevice:X2} 需要在其中替换。我做了一个实现，我用 } 分割行，然后分别解析它们，这在某种程度上不是最优的。请让我知道这是否可以完成

  Regex.Replace(...)

如果AddressDevice = 5，粘贴后应该是“STX05{Nbyte:X2}”

我一直使用存储库模式，但更像是单元测试所需的包装器，可以通过装饰器和其他一些贴花功能嵌入缓存，仅此而已，我没有看到任何其他好处。

我对模式经典实现的疑惑和疑问：

1. 不仅在使用数据访问层的项目（特定存储技术的特定存储库）中存在上下文依赖关系，而且在必须在 DI 中注册 Ef 上下文的主项目中也存在上下文依赖关系。以便稍后存储库在构造函数中接收上下文。这不是很奇怪吗？该思想意味着使用抽象存储库作为对数据的通用访问，例如，10 个存储库实现 IGenericDataRepository，每个存储库（项目）都有自己的依赖项和自己的数据存储模型。也就是说，EFCore 上下文只能在实现基于 EFCore 技术的存储系统的项目中使用。与外界的唯一连接是设置和连接字符串。但基本上每个人都只使用这种存储库模式的变体（甚至在 EFCore 场外给出了一个示例）。

2. 一些暴露在外面的 IQuerible 而不是 Ienumerable ——那何必费心呢，DbSet 接口已经不错了。

我试图制作最抽象的存储库，可以在 DI 中用各种存储技术实现（通过 EFCore 的 SQL，存储在 XML 文件中，存储在 NoSql 中）来替换。下面我将给出项目的结构和代码，请发表你的意见，T.K. 出现了一个具有复杂数据层的项目，我再次考虑存储库。您可能不必用另一个存储系统替换 EfCoreRepository，但您仍然希望尽可能独立和抽象地处理数据。

项目结构

DAL.Abstract 项目包含：

IGenericDataRepository.cs- 抽象存储库接口

    public interface IGenericDataRepository<T>
    {
        T GetById(int id);
        Task<T> GetByIdAsync(int id);

        T GetSingle(Expression<Func<T, bool>> predicate);
        Task<T> GetSingleAsync(Expression<Func<T, bool>> predicate);
        IEnumerable<T> GetWithInclude(params Expression<Func<T, object>>[] includeProperties); //?????

        IEnumerable<T> List();
        IEnumerable<T> List(Expression<Func<T, bool>> predicate);
        Task<IEnumerable<T>> ListAsync();
        Task<IEnumerable<T>> ListAsync(Expression<Func<T, bool>> predicate);

        int Count(Expression<Func<T, bool>> predicate);
        Task<int> CountAsync(Expression<Func<T, bool>> predicate);

        void Add(T entity);
        Task AddAsync(T entity);

        void AddRange(IEnumerable<T> entitys); 
        Task AddRangeAsync(IEnumerable<T> entitys); 

        void Delete(T entity);
        void Delete(Expression<Func<T, bool>> predicate);
        Task DeleteAsync(T entity);
        Task DeleteAsync(Expression<Func<T, bool>> predicate);

        void Edit(T entity);
        Task EditAsync(T entity);

        bool IsExist(Expression<Func<T, bool>> predicate);
        Task<bool> IsExistAsync(Expression<Func<T, bool>> predicate);
    }

IRepository.cs- 特定存储库的接口。突然之间，您需要一种非常具体的方法来处理特定存储库的数据，而不是将其添加到 IGenericDataRepository。

public interface ISerialPortOptionRepository : IGenericDataRepository<SerialOption>
{  
}
public interface ITcpIpOptionRepository : IGenericDataRepository<TcpIpOption>
{
}

public interface IHttpOptionRepository : IGenericDataRepository<HttpOption>
{
}

public interface IExchangeOptionRepository : IGenericDataRepository<ExchangeOption>
{
}
public interface IDeviceOptionRepository : IGenericDataRepository<DeviceOption>
{
}

在文件夹Entities中，需要保存在存储库中的数据模型。纯模型（没有属性和附加存储特定设备的属性）

DeviceOption.cs- 某种可用于业务逻辑的数据模型

    public class DeviceOption : EntityBase
    {
        public string Name { get; set; }
        public string TopicName4MessageBroker { get; set; }         
        public string Description { get; set; }
        public bool AutoBuild { get; set; }                        
        public bool AutoStart{ get; set; }                
        public List<string> ExchangeKeys { get; set; }
    }

该项目DAL.EFCore包含特定存储技术的实施

进入数据模型文件夹，可以方便地Entities在其中存储特定技术的数据（在本例中为EFCore）。

EfDeviceOption.cs- 相同的模型 ( DeviceOption)，仅适用于存储系统，以它可以理解的形式。

public class EfDeviceOption : IEntity
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; }

    [Required]
    [MaxLength(256)]
    public string Name { get; set; }

    [Required]
    [MaxLength(256)]
    public string TopicName4MessageBroker { get; set; }         

    [Required]
    public string Description { get; set; }
    public bool AutoBuild { get; set; }                         
    public bool AutoStart { get; set; }                        


    private string _exchangeKeysMetaData;
    [NotMapped]
    public string[] ExchangeKeys
    {
        get => _exchangeKeysMetaData.Split(';');
        set => _exchangeKeysMetaData = string.Join($"{';'}", value);
    }
}

Context.cs- EfCore 的数据上下文。

public sealed class Context : Microsoft.EntityFrameworkCore.DbContext
{
    private readonly string _connStr;  // строка подключенния

    #region Reps

    public DbSet<EfSerialOption> SerialPortOptions { get; set; }
    public DbSet<EfTcpIpOption> TcpIpOptions { get; set; }
    public DbSet<EfHttpOption> HttpOptions { get; set; }
    public DbSet<EfDeviceOption> DeviceOptions { get; set; }
    public DbSet<EfExchangeOption> ExchangeOptions { get; set; }

    #endregion

    #region ctor

    public Context(string connStr)
    {
        _connStr = connStr;
        ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
        Database.EnsureCreated();
    }

    #endregion

    #region Config

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(_connStr);
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
       modelBuilder.ApplyConfiguration(new EfDeviceOptionConfig());
       modelBuilder.ApplyConfiguration(new EfExchangeOptionConfig());
       modelBuilder.ApplyConfiguration(new EfHttpOptionConfig());
       base.OnModelCreating(modelBuilder);
    }

    #endregion
}

DesignTimeDbContextFactory.cs- 用于迁移系统的上下文创建工厂 - 模型与之间的AutoMapperConfig.cs映射设置DAL.AbstractDAL.EFCore

Repository在特定存储库的文件夹实现中

EfBaseRepository.cs- EfCore 的基础存储库类

/// <summary>
/// Базовый тип репозитория для EntitiFramework
/// </summary>
/// <typeparam name="TDb">Тип в системе хранения</typeparam>
/// <typeparam name="TMap">Тип в бизнесс логики</typeparam>
public abstract class EfBaseRepository<TDb, TMap> : IDisposable
                                                    where TDb : class, IEntity
                                                    where TMap : class
{
    #region field
    protected readonly Context Context;
    protected readonly DbSet<TDb> DbSet;
    #endregion


    #region ctor
    protected EfBaseRepository(string connectionString)
    {
        Context = new Context(connectionString);
        DbSet = Context.Set<TDb>();
    }
    static EfBaseRepository()
    {
        AutoMapperConfig.Register();
    }
    #endregion


    #region CRUD
    protected TMap GetById(int id)
    {
        var efSpOption = DbSet.Find(id);
        var spOptions = AutoMapperConfig.Mapper.Map<TMap>(efSpOption);
        return spOptions;
    }

    protected async Task<TMap> GetByIdAsync(int id)
    {
        var efSpOption = await DbSet.FindAsync(id);
        var spOptions = AutoMapperConfig.Mapper.Map<TMap>(efSpOption);
        return spOptions;
    }

    protected TMap GetSingle(Expression<Func<TMap, bool>> predicate)
    {
        var efPredicate = AutoMapperConfig.Mapper.MapExpression<Expression<Func<TDb, bool>>>(predicate);
        var efSpOption = DbSet.SingleOrDefault(efPredicate);
        var spOption = AutoMapperConfig.Mapper.Map<TMap>(efSpOption);
        return spOption;
    }

    protected async Task<TMap> GetSingleAsync(Expression<Func<TMap, bool>> predicate)
    {
        var efPredicate = AutoMapperConfig.Mapper.MapExpression<Expression<Func<TDb, bool>>>(predicate);
        var efSpOption = await DbSet.SingleOrDefaultAsync(efPredicate);
        var spOption = AutoMapperConfig.Mapper.Map<TMap>(efSpOption);
        return spOption;
    }

    // ... И ДРУГИЕ МЕТОДЫ РЕПОЗИТОРИЯ
    #endregion


    #region Methode
    private IQueryable<TDb> Include(params Expression<Func<TDb, object>>[] includeProperties)
    {
        IQueryable<TDb> query = DbSet.AsNoTracking();
        return includeProperties.Aggregate(query, (current, includeProperty) => current.Include(includeProperty));
    }
    #endregion


    #region Disposable
    public void Dispose()
    {
        Context?.Dispose();
    }
    #endregion
}

EfDeviceOptionRepository.cs- 特定的存储库实施IDeviceOptionRepository

public class EfExchangeOptionRepository : EfBaseRepository<EfExchangeOption, ExchangeOption>, IExchangeOptionRepository
{
    #region ctor

    public EfExchangeOptionRepository(string connectionString) : base(connectionString)
    {
    }

    #endregion



    #region CRUD

    public new ExchangeOption GetById(int id)
    {
        return base.GetById(id);
    }

    public new async Task<ExchangeOption> GetByIdAsync(int id)
    {
        return await base.GetByIdAsync(id);
    }

    public new ExchangeOption GetSingle(Expression<Func<ExchangeOption, bool>> predicate)
    {
        return base.GetSingle(predicate);
    }

     // ... И ДРУГИЕ МЕТОДЫ РЕПОЗИТОРИЯ (ЕCЛИ protected ДОCТУП В БАЗОВОМ КЛАССЕ ПОМЕНЯТЬ НА public то можно использовать базовую реализацию, не замещая метод через new)

    #endregion
}

该项目BL.Services包含各种业务逻辑服务，其中一项服务与存储库集成工作，提供方便的界面。

MediatorForOptions.cs- 一些与存储库一起使用的高级逻辑

/// <summary>
/// Сервис объединяет работу с репозиотриями опций для устройств.
/// DeviceOption + ExchangeOption + TransportOption.
/// </summary>
public class MediatorForOptions
{
    #region fields
    private readonly IDeviceOptionRepository _deviceOptionRep;
    private readonly IExchangeOptionRepository _exchangeOptionRep;
    private readonly ISerialPortOptionRepository _serialPortOptionRep;
    private readonly ITcpIpOptionRepository _tcpIpOptionRep;
    private readonly IHttpOptionRepository _httpOptionRep;
    #endregion


    #region ctor
    public MediatorForOptions(IDeviceOptionRepository deviceOptionRep,
        IExchangeOptionRepository exchangeOptionRep,
        ISerialPortOptionRepository serialPortOptionRep,
        ITcpIpOptionRepository tcpIpOptionRep,
        IHttpOptionRepository httpOptionRep)
    {
        _deviceOptionRep = deviceOptionRep;
        _exchangeOptionRep = exchangeOptionRep;
        _serialPortOptionRep = serialPortOptionRep;
        _tcpIpOptionRep = tcpIpOptionRep;
        _httpOptionRep = httpOptionRep;
    }
    #endregion


    #region Methode
     //МЕТОДЫ ОБЪЕДИНЯЮЩИЕ РАБОТУ С РЕПОЗИТОРИЯМИ 
    #endregion
}

项目WebServer- 应用程序入口点 ( WebApi)Autofac用作DI容器。

RepositoryAutofacModule.cs - 用于注册 DI 依赖项以解析存储库的模块（选择特定的存储系统）

public class RepositoryAutofacModule : Module
    {
        private readonly string _connectionString;


        #region ctor
        public RepositoryAutofacModule(string connectionString)
        {
            _connectionString = connectionString;
        }
        #endregion


        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<EfSerialPortOptionRepository>().As<ISerialPortOptionRepository>()
                .WithParameters(new List<Parameter>
                {
                    new NamedParameter("connectionString", _connectionString),
                })
                .InstancePerLifetimeScope();

            builder.RegisterType<EfTcpIpOptionRepository>().As<ITcpIpOptionRepository>()
                .WithParameters(new List<Parameter>
                {
                    new NamedParameter("connectionString", _connectionString),
                })
                .InstancePerLifetimeScope();

            builder.RegisterType<EfHttpOptionRepository>().As<IHttpOptionRepository>()
                .WithParameters(new List<Parameter>
                {
                    new NamedParameter("connectionString", _connectionString),
                })
                .InstancePerLifetimeScope();

            builder.RegisterType<EfExchangeOptionRepository>().As<IExchangeOptionRepository>()
                .WithParameters(new List<Parameter>
                {
                    new NamedParameter("connectionString", _connectionString),
                })
                .InstancePerLifetimeScope();

            builder.RegisterType<EfDeviceOptionRepository>().As<IDeviceOptionRepository>()
                .WithParameters(new List<Parameter>
                {
                    new NamedParameter("connectionString", _connectionString),
                })
                .InstancePerLifetimeScope();
        }
    }

MediatorsAutofacModule.cs- 用于注册 DI 依赖项以解决业务逻辑服务的模块。

MediatorsAutofacModule.cs   
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<MediatorForOptions>().InstancePerDependency();
    }
}

全部 - - - - - - - - - - - - -

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

МИНУСЫ которые вижу я 

1. МНОООГО маппинга - т.к. у каждой системы хранения своя модель данных, но система хранения обязуется работать в общих типах (Entities из DAL.Abstract).

2. Запросы к БД сложно оптимизировать т.к. наружу торчит не IQuereble, а Ienumerable. Следовательно каждый метод репозитория выполняет какое-то 1 действие и их нельзя объединит. (паттерн UnitOfWork не использую).

3. В новой версии 2.1 EfCore появилась система регистрации контекста в ПУЛЕ (services.AddDbContextPool(...)), вместо perScope. Что должно увеличить производительность. Но в моей модели где я контекст создаю сам, эту фишку НЕЛЬЗЯ использовать.

4. Довольно много кода.

Стоит ли вообще заморачиваться?

И что можно улучшить?

用户数据库“UserDbWebApi”上有一个单独的 WebApi 项目，项目使用该项目对IdentityServer4 “IdentityServerApi_AspNetIdentity”进行授权。

要为“UserDbWebApi”提供 CRUD 操作，还需要通过 IdentityServer4 进行注册（只有具有 SuperAdmin 角色的用户才能访问此 api）。ApplicationUser用户以继承自 IdentityUser (ASP.NET Core Identity)的便捷方式存储。问题是认证ASP.NET Core Identity系统覆盖了认证系统IdentityServer4。

为了方便使用用户数据库，ASP.NET Core Identity建议在 EF 上使用方便的服务：

UserManager<ApplicationUser>
RoleManager<ApplicationUser>

要在 DI 中注册它们，您需要连接

services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();

然后在整个项目中通过 DI 提供这些服务。

但是该调用AddIdentity还将授权ASP.NET Core Identity和访问与颁发的令牌连接起来IdentityServer4不再起作用。

[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    [Authorize(Roles = "SuperAdmin")]
    public ActionResult<IEnumerable<string>> Get()
    {
      //Доступ работает только с токеном выданным IdentityServer4
    }
}

因此，对于授权的正常操作AddIdentity，我不需要连接，但我需要服务UserManager，RoleManager。如何注册DI？在额头不起作用

  services.AddScoped<UserManager<ApplicationUser>>();
  services.AddScoped<RoleManager<ApplicationUser>>();

或者如何使用禁用授权AddIdentity？

还是您仍然必须放弃 UserManager、RoleManager 并直接使用 EF 上下文？

我为 Linq.Dynamic 设置了一个表达式（我用字符串动态地为 Where 指定过滤）

例如我正在使用

var where = "Id > 2 && EventTrain == \"Transit\"";
var filtred= trains.Where(where).ToList(); //trains - список поездов

除了简单的表达式之外，还需要按相对于当前时间 + - delta 的时间进行过滤。

那些。我想出了这个表达

var where = "ArrivalTime > DateTime.Now.AddMinute(-100) && ArrivalTime < DateTime.Now.AddMinute(100)";     

但是，当然，Linq.Dynamic 不接受它，为了使用时间，您需要使用格式中的 DateTime

  $"DateTime({now.Year}, {now.Month}, {now.Day}, {now.Hour}, {now.Minute}, {now.Second})"

那些。我需要表达

var where = "ArrivalTime > DateTime.Now.AddMinute(-100) && ArrivalTime < DateTime.Now.AddMinute(100)"; 

选择 DateTime.Now.AddMinute(-100) 并根据上面指定的日期格式将其替换为实际计算的表达式。选择 DateTime.Now.AddMinute(100) 并根据上面指定的日期格式将其替换为实际计算的表达式。

我是正则表达式的新手，我试图将表达式“DateTime.Now.AddMinute(DeltaTime)”中括号之间的分钟分开

              if (Regex.Match(where, "DateTime.Now.AddMinute\\((.*)\\)").Success)
                {
                    var val= Regex.Match(where, "DateTime.Now.AddMinute\\((.*)\\)").Groups[1].Value;
                    if (int.TryParse(val, out var min))
                    {
                        var date = now.AddMinutes(min);
                        where = where.Replace("DateTime.Now", $"DateTime({date.Year}, {date.Month}, {date.Day}, {date.Hour}, {date.Minute}, 0)");
                    }
                }

但是这样一个简单的正则表达式只适用于示例

var where = "ArrivalTime > DateTime.Now.AddMinute(-100)"

如果有多个这样的表达式，也可以有括号，例如：

 var where = "(ArrivalTime > DateTime.Now.AddMinute(-100)) && (ArrivalTime < DateTime.Now.AddMinute(100)) && (EventTrain == \"Transit\")"; 

帮我用计算的表达式替换 DateTime.Now.AddMinute(DeltaTime) 表达式！

你好，我的WPF项目一直都是用的Nlog，Linux下有AspNetCore上的项目，我决定尝试用Serilog替换标准的logger（因为看了不同项目的代码AspNetCore，on GitHub，几乎每个人都用Serilog）。

在研究了文档和示例之后，我创建了一个测试项目，在那里我实现了记录器实例被创建并DI Autofac通过 Autofac 扩展集成到容器中。那些。现在我可以解决ILog我需要的地方并获取记录器实例serilog。

我对如何设置记录器有要求：

1. MinimumLevel = Info，写入 Main.log（主要工作日志）
2. Level = Debug，写在debug.json中（调试日志写在json中（因为可以保存对象的状态）只有Debug级别的调试信息）

3. 报告专用日志，写在report.csv（报告用Excel）

   记录器是这样设置的：

   Log.Logger = new LoggerConfiguration()
       .MinimumLevel.Debug()
       .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
       .Enrich.FromLogContext()
       .WriteTo.Console()
       .WriteTo.File("log-.txt", rollingInterval: RollingInterval.Day)
       .CreateLogger();
   

一个 MinimumLevel 对应于多个 WriteTo 源和所有！

那些。一份记录器只能解决 3 个任务中的一个？以及如何设置Level，而不是MinimumLevel？

那些。对于我的每项任务，我LoggerConfiguration通过构建器创建自己的 ILogger 实例并将其注入必要的服务中？

对于第 3 号任务，我认为为需要某种统计信息的每个服务创建一个单独的记录器实例是合乎逻辑的，但我想将第 1 号和第 2 号任务结合起来，轻松转移这个实例通过 Autofac 记录整个系统。

使用 Nlog，我可以在一个记录器实例中解决所有任务。

IExchangeDataProvider 接口有多种实现。

服务：

public interface IExchangeDataProvider
{
     string ProviderName { get; set; }
}

public class DataProvider_1 : IExchangeDataProvider
{
  public string ProviderName { get; set; } = "DataProvider_1";
}

public class DataProvider_2 : IExchangeDataProvider
{
  public string ProviderName { get; set; } = "DataProvider_2";
}

在 Autofac 容器中注册：

 builder.RegisterType<DataProvider_1>().As<IExchangeDataProvider>().InstancePerDependency();
 builder.RegisterType<DataProvider_2>().As<IExchangeDataProvider>().InstancePerDependency();

我不仅需要IEnumerable<IExchangeDataProvider>注入到构造函数中，还IEnumerable<Func<IExchangeDataProvider>> 需要能够选择所需的服务工厂。

依赖解析

    public class MainService
    {
        IEnumerable<Func<IExchangeDataProvider>> _providerFactories;

        public MainService(IEnumerable<Func<IExchangeDataProvider>> providerFactories)
        {
          _providerFactories= providerFactories;
        }

        public void Foo()
        {
          for(int i=0; i<10; i++)
          {
              var providerName= GetProviderName(i); // providerName= "DataProvider_1"
              var dataProviderFactory= _providerFactories.FirstOrDefault("найти фабрику по имени или еще как то для создания именно DataProvider_1 без создания DataProvider_2");
              var dataProvider= dataProviderFactory();
          }
        }
    }

我尝试通过反射工厂实际创建的类名，但它也没有成功，我没有在那里找到它。

现在我没有理性地这样做（每次使用工厂时我都必须创建一个新的 IExchangeDataProvider 集合并在其中查找所需的元素）

public class MainService
{
    Func<IEnumerable<IExchangeDataProvider>> _providerFactories;

    public MainService(Func<IEnumerable<IExchangeDataProvider>> providerFactories)
    {
      _providerFactories= providerFactories;
    }

    public void Foo()
    {
      for(int i=0; i<10; i++)
      {  
          var providerName= GetProviderName(i); // providerName= "DataProvider_1"
          var dataProvider =_dataProviderCollectionFactory()?.FirstOrDefault(p=>p.ProviderName == dataProvider);
      }
    }
}

您好，我重新创建了我在工作项目中遇到的问题。

//КЛАСС Startup.cs

public async void Configure(IApplicationBuilder app, IHostingEnvironment env, IDataAccessService dataAccessService)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    try
    {             
        await dataAccessService.LongInvoke();
        var disp = dataAccessService.IsDispose; // !!!! true
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        throw;
    }
    app.UseMvc();
}

//РЕГИСТРАЦИЯ сервиса

builder.RegisterType<DataAccessService>()
       .As<IDataAccessService>()
       .InstancePerLifetimeScope();

//СЕРВИС

public class DataAccessService : IDataAccessService, IDisposable
{
    public bool IsDispose { get; set; }

    public async Task LongInvoke()
    {
        await Task.Delay(10000);
        var calc = 5000 + 500;
    }

    public void Dispose()
    {
        IsDispose = true;
    }
}

如果在注入服务的Configure类方法中执行操作，则内​​部调用 dataAccessService 将比操作完成更快（标志 disp == true）。在调用 后立即 ，即 当一个线程返回到线程池时，它会立即被调用。Startup.csLongInvokeDisposeawait Task.Delay(10000)LongInvokeDispose()LongInvoke

但是如果你这样做

dataAccessService.LongInvoke().GetAwaiter().GetResult();

然后一切正常，我不明白其中的区别，请解释。

我想在 Win7 上运行 apache kafka。（在装有 Win10 的电脑上一切顺利）。我使用来自 Apache kafka 网站的 QuickStart 指令。将包含 kaffka 文件的文件夹解压缩到 C:\ 驱动器

第一步是尝试运行 zookeper

C:\kafka_2.11-2.0.0\bin\windows\zookeeper-server-start.bat config\zookeeper.propertie

并立即出现错误（Inavlid config，异常退出）

JAVA安装的是什么：

对 zookeeper 的配置文件发誓，但它是默认设置。也许有人遇到过这样的问题？

配置文件的路径

你好，你需要实现一个内部的EventBus（比如不是基于RabbitMq的微服务交互）。所有发布者都将带有类型数据（MyData）的事件生成写入公共总线。订阅者侦听总线并按国家类型（MyData）过滤发布者。最好在订阅时返回 IDisposable。发布者也可以取消订阅所有订阅者。

没有时间寻找现成的解决方案，所以我很快做了一个 ReactiveExt 的包装器

public class ReactiveEventBus
{
    public ISubject<object> Bus { get; set; }


    public ReactiveEventBus()
    {
        Bus = new Subject<object>();
    }


    public void Publish<TMessage>(TMessage msg)
    {
        Bus.OnNext(msg);
    }


    public IDisposable Subscribe<TMessage>(Action<TMessage> action)
    {
        return Bus
            .Where(item=> item.GetType() == typeof(TMessage))
            .Subscribe((obj) =>
            {
                var val = (TMessage) obj;
                action(val);
            });
    }
}

那些。订阅适用于所有发布，仅适用于必要的事件，我按类型过滤 Where。

boxing/unboxing如果 TMessage 值是类型的，就会出现问题，因为 ( var val = (TMessage) obj)在调用委托本身之前有一个对象的转换。但我不太可能有价值事件。

Where如果订阅者很多且事件频繁发布，过滤 () 对 Rx 事件的性能有多大影响。

是否值得用现成的解决方案替换这个实现（MemBus 遇到的第一件事）？