问题[asp.net-core]

为了使用数据库，我使用 ORM Entity Framework Core。启动应用程序后，对数据库的所有请求都会记录在控制台中。我没有安装日志记录。如何禁用它？

程序.cs：

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHangfire(x => x.UseSqlServerStorage(builder.Configuration.GetConnectionString("DefaultConnection")));
builder.Services.AddHangfireServer(opt =>
{
    opt.StopTimeout = TimeSpan.FromMinutes(5);
});
builder.Services.AddControllers();
builder.Services.AddSwaggerGen();
builder.Services.AddAutoMapper(typeof(AutoMapperConf));

builder.Services.AddCors(o => o.AddDefaultPolicy(builder =>
{
    builder
    .WithOrigins("http://localhost:80")
    .AllowCredentials()
    .AllowAnyHeader()
    .AllowAnyMethod();
}));

// DB Services
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

builder.Services.AddDbContext<AMContext>(options => options.UseSqlServer(connectionString), ServiceLifetime.Transient);
builder.Services.AddDbContext<AMIdentityContext>(options => options.UseSqlServer(connectionString), ServiceLifetime.Transient);

builder.Services.ConfigureApplicationCookie(opt =>
{
    opt.LoginPath = "/auth/login";
    opt.LogoutPath = "/auth/logut";
    opt.AccessDeniedPath = "/";
    opt.ExpireTimeSpan = TimeSpan.FromDays(180);
});

builder.Services.AddIdentity<DBUser, IdentityRole>(config =>
{
    config.Password.RequireNonAlphanumeric = false;
    config.Password.RequiredLength = 1;
    config.Password.RequireUppercase = false;
    config.Password.RequireDigit = false;
    config.Password.RequireLowercase = false;
})
    .AddEntityFrameworkStores<AMIdentityContext>()
    .AddDefaultTokenProviders();

builder.Services.AddSpaStaticFiles(configuration =>
{
    configuration.RootPath = "wwwroot";
});
var app = builder.Build();

app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseCors();
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseHangfireDashboard("/hangfire", new DashboardOptions
{
    Authorization = new[] { new HangfireAuthFilter() }
});

app.MapControllers();
app.UseEndpoints(endpoints =>
{
    endpoints.MapDefaultControllerRoute();
});

app.UseSpa(spa =>
{
    spa.Options.SourcePath = "ClientApp";
    if (app.Environment.IsDevelopment())
    {
        spa.UseAngularCliServer(npmScript: "start");
        spa.UseProxyToSpaDevelopmentServer("http://localhost:4200");
    }
});


RecurringJob.AddOrUpdate<HangFireTaskManager>("TaskParser", (method) => method.TaskParser(), "*/1 * * * * *");
RecurringJob.AddOrUpdate<HangFireTaskManager>("PostParser", (method) => method.PostParser(), "*/1 * * * * *");
RecurringJob.AddOrUpdate<HangFireTaskManager>("MonitorStatus", (method) => method.MonitorStatus(), "*/1 * * * * *");
RecurringJob.AddOrUpdate<HangFireTaskManager>("CommentParser", (method) => method.CommentParser(), "*/1 * * * * *");
RecurringJob.AddOrUpdate<HangFireTaskManager>("LikesParser", (method) => method.LikesParser(), "*/1 * * * * *");


// Init Roles
using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;
    try
    {
        var rolesManager = services.GetRequiredService<RoleManager<IdentityRole>>();
        await RoleInitializer.InitializeAsync(rolesManager);
    }
    catch (Exception ex)
    {
        var logger = services.GetRequiredService<ILogger<Program>>();
        logger.LogError(ex, "An error occurred while seeding the database.");
    }
}

app.Run();

我想通过 url 行显示产品信息。

我假设我需要向服务器发送一个字符串，然后将过滤后的数据按字符串发送回客户端。实际上，我试图实现它，但它不起作用。服务器控制器：

 private readonly DataContext _context;
    private List<Clothes> vendor;
    public ProductVendorController(DataContext context)
    {
        _context = context;
    }

    
    [HttpGet]
    public async Task<ActionResult> GetClothesUrl()
    {
        return Ok( vendor.ToList());
    }
    
    [HttpPost]
    public async Task<ActionResult> GetVendorClothes(string data)
    {
        var find = (from dadsa in _context.Clothes.Where(p => p.VendorCode == data)
                select dadsa
            ).ToListAsync();
        vendor = await find;
        return Ok();
    }

服务：

  public VendorFind(Vendor: string): Observable<string> {

        return this.http.post<string>(
          `${environment.apiUrl}/${this.urlVendor}`,
          Vendor
        );
      }
      public VendorFindGet():Observable<Clothes>{
          return this.http.get<Clothes>(
            `${environment.apiUrl}/${this.urlVendor}`);
    
        }

零件：

 VendorCode:string = "";
  private subscription: Subscription;
  constructor(private clothesService:ClothesServiceService,private activateRoute: ActivatedRoute) {
    this.subscription = this.activateRoute.params.subscribe(params => this.VendorCode = params['VendorCode'] );
  }
  vendorUpdated = new EventEmitter<string>();
  info:any = new Clothes;
  ngOnInit(): void {
    this.clothesService
      .VendorFind(this.VendorCode)
      .subscribe((vendor: string) => this.vendorUpdated.emit(vendor));
    this.clothesService
      .VendorFindGet()
      .subscribe((result:Clothes)=>(this.info = result));
      console.log("vendor",this.VendorCode);
      console.log("info",this.info);


  }

路由模块：

 { path: 'Clothes/Product/:VendorCode', component: ProductPageComponent }

一个示例 HTML 组件：

<h1>{{info.name}}</h1>
<span>Артикул: {{info.vendorCode}}</span>
<h1>Цена: {{info.price}}.</h1>

UPD：正面：

{ path: 'Clothes/Product/:VendorCode', component: ProductPageComponent}

后端：

app.MapControllerRoute(
    name: "ProductVendor",
    pattern: "{controller =  ProductVendor}/{action}/{id?}");

UPD 2：实际上，在产品选项卡上，当用户点击查看或输入带有文章的url时，会加载产品页面，该页面是从数据库中获取的。

产品标签：

产品页面：

大家好。有一个 Handler 将对象列表返回到前面。（Web API 项目）处理程序有 2 个调用它的控制器，一个用于搜索和排序，另一个仅用于排序。

尊敬的专家，请注意以下问题：如何搜索数组是否已通过 OrderBy 排序并相应地具有 IOrderedEnumerable 类型

返回类型最初是 List<> ，但必须更改为 IOrderedEnumerable<> 。

在这种情况下如何解决问题？

我有 4 个搜索条件。（前面有 4 个搜索字段，因为这是一个表格）

检查是否存在搜索请求。并从这里开始跳舞？那些。如果搜索失败，则只需默认（按日期）对列表进行排序并返回到前面。如果请求附带搜索字符串，则进行切换，在切换分支中，首先搜索列表，当它仍然是列表时，如果需要，然后在此分支中排序。

或者也许有一些 IOrderedEnumerable 的搜索方法？

目前的代码是：

readonly IReadonlyRepository<BlackListEntity> _readonlyRepository;
    public GetBlackListQueryHandler(
        IReadonlyRepository<BlackListEntity> readonlyRepository)
    {
        _readonlyRepository = readonlyRepository;
    }

    public async Task<IOrderedEnumerable<BlackList>> Handle(GetBlackListRequest request, CancellationToken cancellationToken)
    {
        IOrderedEnumerable<BlackList> x = null;
        var result = await _readonlyRepository.GetAsync(cancellationToken);
        var dataForSort = result.Value.Select(x => new BlackList
        {
            ItemId = x.Id,
            ...
        }).ToList();
        switch (request.SortBy)
        {
            case "LastName":
                x = dataForSort.OrderBy(x => x.LastName);
                break;
            case "LastNameDecs":
                x = dataForSort.OrderByDescending(x => x.LastName);
                break;
            case "FirstName":
                x = dataForSort.OrderBy(x => x.FirstName);
                break;
            case "FirstNameDesc":
                x = dataForSort.OrderByDescending(x => x.FirstName);
                break;
            case "MiddleName":
                x = dataForSort.OrderBy(x => x.MiddleName);
                break;
            case "MiddleNameDesc":
                x = dataForSort.OrderByDescending(x => x.MiddleName);
                break;
            case "PhoneNumber":
                x = dataForSort.OrderBy(x => x.PhoneNumber);
                break;
            case "PhoneNumberDesc":
                x = dataForSort.OrderByDescending(x => x.PhoneNumber);
                break;
            case "CreateDate":
                x = dataForSort.OrderBy(x => x.CreateDate);
                break;
            case "CreateDateDesc":
                x = dataForSort.OrderByDescending(x => x.CreateDate);
                break;
        }

        return x;

仍然可以以某种方式简化过滤吗？否则带有开关和每个过滤脚本的设计似乎有点hacky

有一个组织部门的列表。每个细分都有一个唯一的名称和状态（活动/锁定）。服务A提供了细分状态的数据，每个细分的状态应该每3秒变化一次。我正在尝试使用 System.Threading.Timer 服务来实现服务。问题是 Timer 委托不允许返回值（仅 void），在这种情况下如何正确实现数据传输？

直到 5 月 30 日，我使用 Gmail 从我的网站发送确认电子邮件。

看起来像这样

public static async Task<bool> SendEmail(string email, string subject, string body)
    {
        var fromAddress = new MailAddress("securemail@gmail.com", "Регистрация");
        var toAddress = new MailAddress(email);
        const string fromPassword = "securepass";

        var smtp = new System.Net.Mail.SmtpClient
        {
            UseDefaultCredentials = false,
            Host = "smtp.gmail.com",
            Port = 587,
            EnableSsl = true,
            DeliveryMethod = SmtpDeliveryMethod.Network,
            Credentials = new NetworkCredential(fromAddress.Address, fromPassword),
            Timeout = 20000
        };
        using (var message = new MailMessage(fromAddress, toAddress)
        {
            Subject = subject,
            Body = body,
        })
        {
            await smtp.SendMailAsync(message);
        }

        return true;
    }

如您所见，使用邮件密码对登录。但自 5 月 30 日起，谷歌禁用了这种“不安全的方式”，现在你需要以某种方式安全登录。

Google 本身通过 Oauth2 和同意屏幕说明您需要什么，但这些是为最终用户提供的服务，当您指定您的 Google 邮件并且 Google 允许您访问时。

但我不需要那样，我只需要从我的邮件中发送一封信到我的 .NETCore 应用程序中的其他邮件，最终用户无权访问该邮件。怎么做？