lonix's questions

Quero usar um campo de apoio do EF Core .

A entidade possui:

public IReadOnlyCollection<Product> Products => _products;
private readonly List<Product> _products = default!;

Configuração EF:

builder
  .HasMany(x => x.Products)
  .WithOne()
  .HasForeignKey(x => x.ManufacturerId)
  .OnDelete(DeleteBehavior.Cascade);

builder                            // <----- problem here
  .Property(x => x.Products)
  .HasField("_products");

Isso produz:

Não foi possível criar um 'DbContext' do tipo ''. A exceção 'A propriedade ou navegação 'Produtos' não pode ser adicionada ao tipo 'Fabricante' porque uma propriedade ou navegação com o mesmo nome já existe no tipo 'Fabricante'.' foi gerada durante a tentativa de criar uma instância.

Suspeito que o código de configuração tenta adicionar a mesma navegação duas vezes. Qualquer uma delas pode ser usada, mas não simultaneamente. Eu poderia remover uma e confiar em convenções, mas não quero fazer isso, pois prefiro código de configuração explícito.

Como posso configurar explicitamente esse campo de apoio e evitar o erro?

Quando meu código não tem um namespace, posso usar o "usings quickfix" ( ctrl + .) para recomendar namespaces aplicáveis.

Eu uso uma biblioteca que possui muitos tipos com nomes idênticos aos do framework e até mesmo aos do meu próprio código. Portanto, o quickfix frequentemente recomenda namespaces dessa biblioteca e os coloca primeiro no pop-up.

Posso configurar o roslyn para ignorar determinados namespaces ao usar o quickfix?

Tenho um elemento DOM com um atributo que é adicionado/removido por uma biblioteca externa (por exemplo, bootstrap).

Antes:

<div x-data="{ fooEnabled: false }">
  ...
</div>

Depois:

<div x-data="{ fooEnabled: false }" data-foo="123">
  ...
</div>

Gostaria de alternar fooEnabledquando o atributo data-fooé adicionado/removido.

Isso pode ser feito com um observador de mutação, mas espero que seja possível (e mais fácil) usando alpinejs. Como faço isso?

Cada linha da tabela tem uma célula com alguns dados "caros" carregados sob demanda; antes de serem carregados, ela mostra "?". Quando o botão dessa linha é clicado, a célula é preenchida.

<table>
  <tbody>

    <!-- rows 1..10  -->

    <tr x-data="{ foo: '?' }">
      <td><span x-text="foo"></span></td>
      <!-- ... -->
      <td><button onclick="foo = await fetchFoo('row-11')">Load</button></td>
    </tr>

    <!-- rows 12... -->

  </tbody>
</table>

<script>
  async function fetchFoo(rowId) {
    let url      = `https://www.example.com/foo/${rowId}`;
    let response = await fetch(url);
    let result   = await response.text();
    return result;
  }
</script>

Como passo os dados buscados do botão para a célula?

ATUALIZAR

Aqui está uma demonstração mostrando que não funciona; tentei várias sintaxes:

<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/cdn.min.js" defer></script>

<table>
  <tbody>
    <tr x-data="{ foo: '?' }">
      <td>Hello</td>
      <td><span x-text="foo"></span></td>
      <td><button onclick="foo = await fetchFoo('row-1')">Load</button></td>
    </tr>
    <tr x-data="{ foo: '?' }">
      <td>World</td>
      <td><span x-text="foo"></span></td>
      <td><button onclick="async () => { foo = await fetchFoo('row-2') }">Load</button></td>
    </tr>
    <tr x-data="{ foo: '?' }">
      <td>Hi</td>
      <td><span x-text="foo"></span></td>
      <td><button onclick="fetchFoo('row-3')">Load</button></td>
    </tr>
    <!-- rows 4+... -->
  </tbody>
</table>

<script>
  async function fetchFoo(rowIndex) {
    return new Promise(resolve => setTimeout(() => resolve(rowIndex), 1000));
  }
</script>

Quero abrir dois arquivos markdown, com duas abas de visualização, e tê-los em dois monitores para poder editar os dois arquivos simultaneamente.

Passos:

• abra o espaço de trabalho no vscode
• abra ambos os arquivos markdown
• mover um arquivo/guia para um monitor diferente
• para cada aba de redução, clique no botão de visualização para abrir a aba de visualização associada

Espera-se que cada aba de visualização renderize seu markdown associado.

No entanto, ambas as guias de pré-visualização renderizam o markdown para a guia selecionada no momento . Então, embora eu possa visualizar dois arquivos markdown simultaneamente, só consigo visualizar uma pré-visualização markdown.

Como faço isso?

Estou usando um ConcurrentQueue<T>. Eu preciso:

• vários consumidores para enfileirar itens
• um único consumidor para retirar todos os itens da fila de uma só vez
• durante a dequeue, para bloquear a fila para que outros consumidores não possam enfileirar novos itens ao mesmo tempo

public class Cache
{

  private readonly ConcurrentQueue<Item> _queue = new();

  public void Enqueue(Item item)    // what synchronisation to perform here?
  {
    ArgumentNullException.ThrowIfNull(item, nameof(item));
    _queue.Enqueue(item);
  }

  public void Flush()               // what synchronisation to perform here?
  {
    // dequeue all items
    var items = new List<Item>();
    while (_queue.TryDequeue(out var item))
      items.Add(item);

    // `DoSomething` could take time; therefore above we
    // dequeued and cached all items, so other consumers
    // can immediately continue enqueuing
    foreach (var item in items)
      DoSomething(item);
  }

  public void DoSomething(Item item)
  {
    // ...
  }

}

Estou confuso sobre qual é a melhor ferramenta de simultaneidade para sincronizar o acesso _queue(em Enqueuee Flush).

Devo usar um simples lockou algo mais exótico?

ATUALIZAÇÃO: para responder aos comentários abaixo, não estou vinculado ao ConcurrentQueue; se houver uma coleção simultânea mais apropriada, por favor me avise.

Quero evitar o commit de arquivos com uma determinada string, por exemplo:

// TODO foo bar baz

Então eu uso um hook de pré-commit do git :

#!/bin/sh

EXTENSIONS='\.(cs|cshtml|csproj|css|js|scss|sh|ts|xml|yml|md)?$'
FORBIDDEN='TODO'

git diff --cached --name-only | \
  sed -n -E "/$EXTENSIONS/p" | \
  GREP_COLORS='4;5;37;41' xargs grep --color --with-filename -n "$FORBIDDEN" \
  && echo 'ERROR: Found forbidden texts; remove them then retry' && exit 1 \
  || exit 0

Isso funciona. Mas tem uma falha.

As grepbuscas pelo texto proibido no arquivo inteiro, em vez de apenas os pedaços preparados. Então, se um arquivo tem pedaços que eu preparo, e um pedaço com o texto proibido (que eu não preparo), então ele cancelará o commit.

É possível procurar o padrão apenas nos pedaços preparados, em vez de no arquivo inteiro?

(Gostaria que o script funcionasse no dash.)

No C# 12, há o analisador "A inicialização da coleção pode ser simplificada" IDE0028 .

Estou me perguntando como o fixador decide quando corrigir ou não inicializadores como new(), new List<string>(), new Collection<int>(), Array.Empty<double>(), new string[] { }, etc. A correção é substituir um inicializador qualificado por [].

Por exemplo:

// Collection initialization can be simplified
public List<string> Foo1 { get; } = new List<string>();
public HashSet<string> Foo2 { get; } = new HashSet<string>();
public ICollection<string> Foo3 { get; } = new List<string>();
public Dictionary<int, string> Foo4 = new Dictionary<int, string>();

// Collection initialization can be simplified (may change semantics)
public IEnumerable<string> Bar1 { get; } = new List<string>();
public ICollection<string> Bar2 { get; } = new Collection<string>();

// no code fix offered
public IDictionary<int, string> Baz1 = new Dictionary<int, string>();

Geralmente escolho um tipo de coleção que se adapta a um propósito específico. Então, não quero aceitar cegamente a recomendação do analisador sem entender qual tipo de coleção o compilador realmente usará quando vir [].

Então:

• Como o analisador/fixador decide quando sugerir uma correção e o que exatamente significa "pode ​​alterar a semântica"
• Que tipo de coleção o compilador/tempo de execução realmente usa quando encontra[]

Considere esta hierarquia de classes simplificada:

public interface IProcessor
{
  Task<TProcessor> Run<TProcessor>() where TProcessor : IProcessor;
}


public abstract class Processor : IProcessor
{

  public async Task<TProcessor> Run<TProcessor>() where TProcessor : IProcessor
  {
    await DoWork();
    return (TProcessor)(object)this;  // works, but yuck
    //return (TProcessor)this;        // error: "Cannot convert type 'Processor' to 'TProcessor'"
  }

  protected abstract Task DoWork();

}


public sealed class FooProcessor : Processor
{
  protected override Task DoWork() => Task.CompletedTask;
}

O (TProcessor)(object)thistruque funciona, mas é um truque feio de compilador.

Posso modificar este código para depender de verificações em tempo de compilação?

Para registrar algum serviço em relação à interface e à implementação:

services.AddSingleton<IFoo, Foo>();
services.AddSingleton<Foo>(x => x.GetRequiredService<IFoo>());

Isso garante que seja possível resolver ambos IFooe Foo, e que o contêiner forneceria a mesma instância .

Estou tentando estender esse conceito ao meu caso de uso:

Eu escrevi uma biblioteca que executa uma varredura de assembly na inicialização e registra automaticamente tipos que implementam IAnalyser. No código do cliente, quero resolver ambos IEnumerable<IAnalyser>e FooAnalyser.

Não tenho certeza de como realizar os registros. Isto é o que tenho até agora:

IEnumerable<Type> implementationTypes = ScanClientAssembliesForImplementationsOfIAnalyser();

foreach (var implementationType in implementationTypes)
{
  services.AddSingleton(typeof(IAnalyser), implementationType);  // (1) works
  //services.AddSingleton(implementationType);                   // (2) incorrect
  services.AddSingleton(x => /* ...?... */);                     // (3)
}

O registro em (1) corretamente me permite resolver IEnumerable<IAnalyser>.

O registro em (2) me permite resolver FooAnalyser, mas seria uma instância diferente e, portanto, está incorreto.

Acho que a abordagem correta é registrar a mesma instância por meio de uma fábrica. Como faço isso em (3)?

(Observe que minha abordagem acima pode estar errada. Tudo o que quero é resolver ambos IEnumerable<IAnalyser>e FooAnalyser, no código do cliente. Talvez haja uma maneira completamente diferente de fazer isso?)

Sempre que preciso de serviços transitórios ou com escopo dentro de um serviço singleton ou em segundo plano, eu os crio em um escopo filho:

using var serviceScope = _serviceScopeFactory.CreateScope();
var foo = serviceScope.ServiceProvider.GetRequiredService<Foo>();

No entanto, acabei de notar os documentos da API para CreateScopeo estado:

Retorna: Um IServiceScope controlando o tempo de vida do escopo. Depois que isso for descartado, todos os serviços com escopo que foram resolvidos do IServiceScope.ServiceProvider também serão descartados.

Observe o texto "quaisquer serviços com escopo definido" .

Isso significa que o contêiner com escopo definido não descarta serviços transitórios (apenas serviços com escopo definido)? Sempre pensei que um contêiner filho descarta tudo o que cria e é apenas o contêiner raiz que mantém referências transitórias.

(Estou acostumado com o Autofac e algumas nuances entre ele e o .NET DI são um pouco confusas.)

Nas páginas ASP.NET Core Razor, um token antifalsificação é adicionado automaticamente a um formulário:

A geração automática de tokens antifalsificação para elementos de formulário HTML ocorre quando a tag contém o atributo method="post" e uma das seguintes afirmações é verdadeira:

• O atributo action está vazio (action="").
• O atributo action não é fornecido ().

Estou tão acostumado com esse comportamento automático que, quando um formulário tem uma ação, esqueço de adicionar manualmente um token e, claro, o POST falhará com 400 (e perderei muito tempo depurando).

Qual é o motivo desse comportamento - por que o token não é adicionado quando há uma ação?

Além disso, existe alguma maneira durante o desenvolvimento de registrar erros mais informativos do que POST '/somepage' responded '400'quando ocorre um erro antifalsificação? Eu tropecei nessa pegadinha várias vezes, então me pergunto se posso evitá-la no futuro.

Estou usando páginas ASP.NET Core Razor com identidade. Eu uso o middleware StatusCodePages da maneira padrão:

app.UseStatusCodePagesWithReExecute("/Error", "?statusCode={0}");

Nessa página do Razor, posso ativar o código de status para renderizar conteúdo diferente para 401, 403, 404 e "outros" (todos os outros códigos no intervalo 400..599). No entanto, isso fica confuso; Eu prefiro páginas separadas.

Então, em vez disso:

• /Páginas/Erro.cshtml

Eu quero isso:

• /Páginas/401.cshtml
• /Páginas/403.cshtml
• /Páginas/404.cshtml
• /Páginas/400_599.cshtml

Isso é possível?

Soluções alternativas feias que eu já conheço:

• Eu poderia usar o URL template "/Error/{0}", mas isso é impraticável: eu teria que definir uma página separada para cada código no intervalo 400..599. Eu definitivamente não posso fazer isso.
• Na classe de modelo de página "/Pages/Error.cshtml.cs", eu poderia redirecionar para páginas diferentes com base no código de status. Prefiro não fazer isso, suspeito que seja ruim para o SEO.
• Para o endpoint "/Error", eu poderia usar um controlador MVC com visualizações (em vez de Razor Pages); o método de ação pode retornar a visão apropriada. Não é uma solução ruim, mas acrescenta complexidade desnecessária; Eu prefiro uma abordagem Razor Pages.

Durante a inicialização, configuro o cookie de autenticação de identidade:

services.ConfigureApplicationCookie(x =>
{
  x.Cookie.Name = "foo";    // default is ".AspNetCore.Identity.Application"
  // other config...
});

Eu preciso das informações desse cookie durante o tempo de execução, então em algum controlador eu injeto IOptions<CookieAuthenticationOptions>e tento obter o nome do cookie:

var cookieName = cookieAuthenticationOptions.Value.Cookie;

Isso dá ".AspNetCore."em vez de "foo". As outras propriedades desse objeto também estão erradas, todas parecem ser valores padrão.

Por que isso está acontecendo e como obtenho uma instância válida desse objeto de opções?

Em um projeto de biblioteca dotnet, preciso acessar SecurityStampValidatorOptions .

Isso parece fazer parte do assembly "Microsoft.AspNetCore.Identity", cujo pacote nuget está obsoleto .

Então tentei fazer referência a Microsoft.AspNetCore.Identity.EntityFrameworkCore , mas isso também não ajuda. eu recebo

O tipo ou nome do namespace 'SecurityStampValidatorOptions' não existe no namespace 'Microsoft.AspNetCore.Identity' (falta uma referência de assembly?)

(Definitivamente, está nesse namespace e, no meu projeto principal do ASP.NET Core, funciona.)

Onde essa classe está definida?

Eu tenho esta propriedade de entidade, que é armazenada no banco de dados como CSV ou nulo:

public ICollection<string> Names { get; } = new List<string>();

Eu tenho esta configuração:

modelBuilder
  .Entity<Person>()
  .Property(e => e.Names)
  .HasConversion(
    x => x.Any() ? string.Join(',', x) : null,                     // this works
    x => (x ?? "").Split(',', StringSplitOptions.None).ToList(),   // this fails
    new ValueComparer<ICollection<string>>(
      equalsExpression:   (c1, c2) => c1!.SequenceEqual(c2!),
      hashCodeExpression: c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode(StringComparison.Ordinal))),
      snapshotExpression: c => c.ToHashSet())
  .IsRequired(false);

Isso traduz com êxito uma coleção vazia em um banco de dados NULL. Mas um banco de dados NULL é convertido em ac# nullem vez de uma coleção vazia.

Onde está o meu erro?

(Não posso alterar a nulidade da propriedade ou remodelar o banco de dados; ambos estão fora do meu controle.)

Devido a bugs, estou usando a excelente solução alternativaBackgroundService de Stephen Cleary . Funciona, mas não consigo retornar um código de saída diferente de zero em caso de falha.

Um exemplo mínimo de trabalho (para uso com o $ dotnet new workermodelo):

MyBackgroundService.cs

public class MyBackgroundService : BackgroundService {

  private readonly IHostApplicationLifetime _lifetime;
  public MyBackgroundService(IHostApplicationLifetime lifetime) => _lifetime = lifetime;

  protected override Task ExecuteAsync(CancellationToken stoppingToken) => Task.Run(async () => {
    try {
      while (!stoppingToken.IsCancellationRequested) {
        await Task.Delay(1000);
        if (Random.Shared.NextDouble() < 0.5) throw new Exception("RANDOM CRASH!");
      }
    }
    catch {
      throw;         // I can hit a debug breakpoint here
    }
    finally {
      _lifetime.StopApplication();
    }
  });

}

Program.cs

public class Program {
  public static int Main(string[] args) {
    try {
      var builder = Host.CreateApplicationBuilder(args);
      builder.Services.AddHostedService<MyBackgroundService>();
      var host = builder.Build();
      host.Run();
      return 0;
    }
    catch (Exception) {
      return 1;                // <----- execution never arrives here
    }
  }
}

Quando o aplicativo trava, espero que o código de saída seja 1, mas na verdade é o padrão 0. Quando eu depuro, ele nunca entra no bloco catch.

Qual seria a razão?

Dockerfile:

FROM mcr.microsoft.com/dotnet/runtime-deps:7.0.10-alpine3.18-amd64
ARG APP_DIR=/var/lib/app/
WORKDIR $APP_DIR
# etc.
ENTRYPOINT ["MyApp"]     # executable file located at /var/lib/app/MyApp

Ao executar esse contêiner:

docker: Resposta de erro do daemon: falha ao criar a tarefa para o contêiner: falha ao criar a tarefa shim: falha na criação do tempo de execução do OCI: falha na criação do runc: não foi possível iniciar o processo do contêiner: exec: "MyApp": arquivo executável não encontrado em $PATH: desconhecido .

Eu especifiquei WORKDIR, então por que o executável não foi encontrado?

(Funciona se eu usar ENTRYPOINT ["/var/lib/app/MyApp"], então não é um problema de permissão.)