dan-kli's questions

Tenho duas tabelas PostgreSQL: objectse metadata. Cada objeto tem uma sizepropriedade que representa seu tamanho em bytes e pode ser armazenado em um local exclusivo com storage_id. Nos metadados, a total_sizepropriedade de todos os objetos de cada armazenamento com um dado storage_idé mantida. Tabelas simplificadas:

CREATE TABLE IF NOT EXISTS objects (
  object_id UUID PRIMARY KEY,
  storage_id UUID NOT NULL,
  size BIGINT NOT NULL,
  FOREIGN KEY (storage_id) REFERENCES metadata(storage_id)
);

CREATE TABLE IF NOT EXISTS metadata (
  storage_id UUID PRIMARY KEY,
  total_size BIGINT DEFAULT 0
);

Para manter o total_sizena metadatatabela, tenho gatilhos que sempre que um objeto é inserido ou excluído, ele total_sizeé atualizado, ou seja, aqui está o gatilho para inserção:

CREATE OR REPLACE FUNCTION update_size_on_insert() RETURNS TRIGGER AS $$
BEGIN
  UPDATE metadata
  SET total_size = total_size + NEW.size
  WHERE storage_id = NEW.storage_id;
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE TRIGGER trg_update_size_on_insert
AFTER INSERT ON objects
FOR EACH ROW
EXECUTE FUNCTION update_size_on_insert();

O problema é que inserções/exclusões simultâneas podem sobrescrever o comando, o total_sizeque leva a dados inválidos. Como posso alterar o gatilho para que ele contenha um bloqueio em nível de linhaSET total_size = total_size + NEW.size quando o comando for executado? Eu estava pensando na FOR UPDATEinstrução, mas isso requer um comando SELECT. Posso usar PERFORM ... FOR UPDATE;para bloquear a linha?

Estamos usando o operador de chamada &para executar um executável em um processo automatizado:

& $pathToExecutable

Agora parece que o PowerShell não espera inerentemente que esse executável termine e continua a execução do script, levando a uma falha do nosso processo automatizado em alguns casos de uso. O operador de chamada não espera que o processo iniciado termine ou ele só espera sob certas condições ou por um tipo específico de comando?

A documentação do operador call não menciona se ele espera ou não, ele simplesmente diz que o comando roda em um escopo filho. Eu sinto que por padrão você esperaria que ele rodasse o comando de forma síncrona e executasse a próxima linha quando esse comando fosse finalizado.

Seguindo a integração da fábrica de clientes gRPC no .NET, posso registrar um cliente gRPC assim:

builder.Services.AddGrpcClient<Greeter.GreeterClient>(o =>
{
    o.Address = new Uri("https://localhost:5001");
});

Agora eu gostaria de definir um prazo universal para todas as chamadas feitas com este cliente. Talvez algo assim:

int deadline = ReadFromConfig();

builder.Services.AddGrpcClient<Greeter.GreeterClient>(o =>
{
    o.Address = new Uri("https://localhost:5001");
    o.CallOptionsActions.Add(o => 
        o.CallOptions.Deadline = DateTime.UtcNow.AddSeconds(deadline))
});

No entanto, o prazo nas opções de chamada é somente leitura aqui. Parece que não consigo defini-lo aqui. Estou fazendo errado ou só é possível definir um prazo ao enviar a solicitação?

Observar a seguinte função que espera outra Function com um tipo de saída Te simplesmente a chama retorna o resultado:

T CallFunction<T>(Func<T> lambda)
{
  return lambda();
}

Eu esperaria poder substituir Func<T> lambdapor delegate T lambda<T>(). No entanto, isso parece não ser possível, não posso fazer algo como:

T CallFunction<T>(delegate T lambda<T>())
{
  return lambda();
}

ou:

delegate T MyLambda<T>();

T CallFunction<T>(MyLambda lambda)
{
  return lambda();
}

Apenas minha sintaxe está errada ou ainda não entendi completamente o que é Delegate e Func ? Não é Func<T> lambdaapenas um delegado que retorna o tipo Tneste caso?

O seguinte simples Program.csespera um único argumento para um comando root definido:

using System.CommandLine;

var inputArgument = new Argument<string>(
  name: "--input", 
  description: "input any value and print it out");

var rootCommand = new RootCommand();
rootCommand.AddArgument(inputArgument);
rootCommand.SetHandler((inputArgumentValue) =>
{
  Console.WriteLine($"{inputArgumentValue}");
}, inputArgument);

rootCommand.Invoke(args);

Eu esperaria chamar isso com o seguinte parâmetro: --input "Hello World"imprimir Hello World no shell. No entanto, recebo o seguinte erro:

Unrecognized command or argument 'Hello World'.

Quando substituo a classe Argument pela Option , funciona conforme o esperado:

using System.CommandLine;

var inputArgument = new Option<string>(
  name: "--input", 
  description: "input any value and print it out");

var rootCommand = new RootCommand();
rootCommand.AddOption(inputArgument);
rootCommand.SetHandler((inputArgumentValue) =>
{
  Console.WriteLine($"{inputArgumentValue}");
}, inputArgument);

rootCommand.Invoke(args);

O que eu entendi mal sobre a Argumentaula? Por que não consigo passar um argumento com um valor para ele?

Quero usar a classe de argumento em vez de opções devido às suas outras propriedades. Estou usando .NET 6.0 e System.CommandLine versão 2.0.0-beta4.22272.1