C# constructeur dans l'interface

Question

Je sais que vous ne pouvez pas avoir un constructeur dans une interface, mais voici ce que je veux faire:

interface ISomething 
{ 
     void FillWithDataRow(DataRow) 
} 


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

Je voudrais vraiment remplacer la méthode de FillWithDataRowISomething avec un constructeur en quelque sorte. De cette façon, ma classe membre pourrait implémenter l'interface et être toujours en lecture seule (ce qui ne peut pas être fait avec la méthode FillWithDataRow).

Quelqu'un at-il un motif qui fera ce que je veux?

Answer 1

(je aurais dû vérifier d'abord, mais je suis fatigué. - c'est surtout une duplicate)

Soit vous avez une interface d'usine, soit vous passez un Func<DataRow, T> dans votre constructeur. (Ils sont la plupart du temps équivalent, vraiment L'interface est probablement mieux pour l'injection de dépendances alors que le délégué est moins pointilleux..)

Par exemple:

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

utiliser une classe abstraite à la place?

vous pouvez aussi avoir votre classe abstraite implémenter une interface si vous voulez ...

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

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

    protected void FillWith(DataRow row); 
}