C# constructeur de l'interface

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 tiens vraiment à remplacer ISomething's FillWithDataRow méthode avec un constructeur en quelque sorte.

De cette façon, mon membre en classe peut implémenter l'interface et encore être en lecture seule (elle ne peut pas avec la FillWithDataRow méthode).

Quelqu'un aurait-il un modèle qui va faire ce que je veux?

Quel membre de la classe, vous voulez être en lecture seule?
double - jetez un oeil ici stackoverflow.com/questions/619856/...
Double Possible de l'Interface de la définition d'une signature du constructeur?

OriginalL'auteur Toto | 2009-11-06

  1. 3

    (Je devrais l'avoir d'abord vérifié, mais je suis fatigué - c'est surtout un double.)

    Soit une interface de fabrique, ou de passer un Func<DataRow, T> dans votre constructeur. (Ils sont quasiment équivalent, vraiment. L'interface est probablement mieux pour l'Injection de Dépendance 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));

    OriginalL'auteur Jon Skeet

  2. 6

    utilisation d'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);
}

    OriginalL'auteur NDM