C# constructor de interfaz

Question

sé que no se puede tener un constructor en una interfaz, pero esto es lo que quiero hacer:

interface ISomething 
{ 
     void FillWithDataRow(DataRow) 
} 


class FooClass<T> where T : ISomething , new() 
{ 
     void BarMethod(DataRow row) 
     { 
      T t = new T() 
      t.FillWithDataRow(row); 
     } 
    } 

Realmente me gustaría reemplazar FillWithDataRow método ISomething 's con una constructor de alguna manera.

De esta manera, mi clase de miembro podría implementar la interfaz y seguir siendo de solo lectura (no puede con el método FillWithDataRow).

¿Alguien tiene un patrón que hará lo que yo quiero?

Answer 1

(debería haber revisado primero, pero estoy cansada -. Esto es sobre todo un duplicate)

O tiene una interfaz de fábrica o pasa Func<DataRow, T> en su constructor. (En su mayoría son equivalentes, en realidad La interfaz es probablemente mejor para la inyección de dependencias mientras que el delegado es menos exigente..)

Por ejemplo:

interface ISomething 
{  
    // Normal stuff - I assume you still need the interface 
} 

class Something : ISomething 
{ 
    internal Something(DataRow row) 
    { 
     // ... 
    }   
} 

class FooClass<T> where T : ISomething , new() 
{ 
    private readonly Func<DataRow, T> factory; 

    internal FooClass(Func<DataRow, T> factory) 
    { 
     this.factory = factory; 
    } 

    void BarMethod(DataRow row) 
    { 
      T t = factory(row); 
    } 
} 

... 

FooClass<Something> x = new FooClass<Something>(row => new Something(row)); 

Answer 2

¿usar una clase abstracta en su lugar?

también puede tener su clase abstracta implementar una interfaz si quieres ...

interface IFillable<T> { 
    void FillWith(T); 
} 

abstract class FooClass : IFillable<DataRow> { 
    public void FooClass(DataRow row){ 
     FillWith(row); 
    } 

    protected void FillWith(DataRow row); 
}