Come posso mantenere il pattern DI di un writer di risultati, con 2 set di risultati diversi?

Ci sono un paio di cambiamenti che farei. Per prima cosa renderei Consumer una classe astratta che accetta un generico, quindi metti i tuoi due Consumatori in cima a quello.

public abstract class Consumer<T>
{
    protected IResultWriter<T> _writer;
    public Consumer(IResultWriter<T> writer)
    {
        _writer = writer;
    }   

    private void DoTriggeredByProducer()
    {       
        //write(results); 
    }


    public virtual void write(List<T> results)
    {
        _writer.write(results);
    }
}

public class Consumer_WithoutExtra : Consumer<DoerResult>
{

    public Consumer_WithoutExtra(IResultWriter<DoerResult> writer) : base(writer)
    {
    }   

    private void DoTriggeredByProducer()
    {       
        //write(results); 
    }


    public virtual void write(List<DoerResult> results)
    {
        _writer.write(results);
    }
}



public class Consumer_WithExtra : Consumer<DoerResult_WithExtra>
{

    public string ExtraSomething {get; set;}

    public Consumer_WithExtra(IResultWriter<DoerResult_WithExtra> writer) : base(writer)
    {
    }   

    private void DoTriggeredByProducer()
    {
        //** Need to get Extra something to the 
        //write(results);

    }

    public override void write(List<DoerResult_WithExtra> results)
    {
        _writer.write(results);
    }

    private List<DoerResult_WithExtra> ConvertResults(List<DoerResult> results)
    {
        List<DoerResult_WithExtra> convertedResults = new List<DoerResult_WithExtra>();
        foreach(var r in results)
        {
           // convertedResults.Add(new DoerResult_WithExtra(r) { ExtraProperty = this.ExtraSomething });
        }

        return convertedResults;
    }
}

Quindi configurerei IResultWriter anche come generico

public interface IResultWriter<T>
{
    void write(List<T> results);
}

public class ResultWriter : IResultWriter<DoerResult>
{
    public virtual void write(List<DoerResult> results)
    {
        foreach(var r in results)
            Console.WriteLine(r.Name);
    }
}

public class ResultWriter_WithExtra : IResultWriter<DoerResult_WithExtra>
{
    public virtual void write(List<DoerResult_WithExtra> results)
    {
        foreach(var r in results)
            Console.WriteLine(r.Name + ", " + r.ExtraProperty);
    }
}

Questo dovrebbe ripulire il tuo DI in modo da passare il nuovo Consumer_WithExtra e il nuovo ResultWriter_WithExtra, nascondendo i generici, o il nuovo Consumer_WithoutExtra e il nuovo ResultWriter

Ne ho un esempio su link

Come ho capito, il tuo problema è che l'unico requisito di IResultWriter è che possa scrivere DoResults mentre tu vuoi che sia in grado di scrivere anche altre cose.

In questo caso puoi:

1. Sposta la logica di scrittura sulla classe DoResult in modo che lo scrittore possa chiamarla
2. Chiedi a questa classe di esporre le sue proprietà in modo strongmente tipizzato, in modo che lo Scrittore non debba ricorrere a indovinare il tipo o il riflesso. ad es. List<Property> Doresult.Properties
3. Chiedi allo scrittore di utilizzare la riflessione per scrivere qualsiasi oggetto
4. Divertiti con i generici!

Il problema con i generici è che tendono a farsi strada lungo la catena.

Quindi in fondo abbiamo

public interface IResultWriter<T>
{
    void write(List<T> results);
}

Questo significa che ogni redattore dei risultati conosce il tipo passato, quindi può usare la proprietà extra. Ma! devi anche abbinare alcune delle altre classi. Potenzialmente fino alla cima del tuo grafico

public interface Consumer<T>
{

    public Consumer(IProducer<T> producer, IDoer<T> Doer, IResultsWriter<T> writer)
    {

    }   

    private void DoTriggeredByProducer()
    {       
        write(results); 
    }


    protected virtual void write(List<T> results)
    {
        writer.write(results);
    }
}

Tuttavia !! nel complesso suggerirei un approccio alternativo. I costruttori non sono ereditati. quindi non c'è ragione per cui ogni Consumer abbia bisogno di avere un IResultWriter o qualsiasi altra forma di ResultWriter diversa da quella che si eredita da una classe base che ne richiede uno.

Non ereditare, invece hai un'interfaccia e componi.

public class Consumer_WithExtra : IConsumer
{
    public Consumer_WithExtra(
        IProducer producer, 
        IDoer doer
        )

    private void DoTriggeredByProducer()
    {
        //** whatever the hell I want to do with whatever I want to inject
    }
}