Início / coding / Perguntas / 78944896
Accepted
lonix
Asked: 2024-09-03 22:43:00 +0800 CST

Converta isso para um tipo genérico sem enganar o compilador

  • 772

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?

c#

1 respostas

  1. Best Answer

    Um erro de tempo de execução é possível se você tiver outra classe herdando de Processor, digamos BarProcessor. Então BarProcessor p = new FooProcessor().Run<BarProcessor>();será compilado, mas falhará em tempo de execução.

    O C# não suporta um tipo "self" como este (veja por exemplo https://github.com/dotnet/csharplang/issues/5413 ), mas o código pode ser melhorado movendo o parâmetro de tipo do método para o tipo. Isso restringe o potencial de erros nas implementações de classe e reduz a necessidade de especificar parâmetros de tipo no site da chamada.

    Por exemplo:

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

public abstract class Processor<TProcessor> : IProcessor<TProcessor>
    where TProcessor : Processor<TProcessor>
{
    public async Task<TProcessor> Run()
    {
      await DoWork();
      return (TProcessor)this;
    }

    protected abstract Task DoWork();
}

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

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

    Agora, os chamadores de Runnão podem especificar um parâmetro de tipo errado (já que não há nenhum), mas FooProcessorainda podem herdar erroneamente de Processor<BarProcessor>. Além disso, a interface IProcessor<TProcessor>agora é claramente útil apenas como uma restrição ( where T: IProcessor<T>), não como um tipo.

    Note que FooProcessore BarProcessorsão selados. Permitir herança de uma Processor<TProcessor>subclasse exigirá que essa subclasse seja genérica, como public abstract class SpecialProcessor<TProcessor> : Processor<TProcessor> where TProcessor : SpecialProcessor<TProcessor>.

    • 3

relate perguntas