Ist es möglich, ein Strategie-Muster für Datenstrukturen ohne gemeinsamen Vorfahren zu verwenden?

Question

ich zwei Datenstrukturklassen haben (dies ist eine vereinfachte Version von meinem Code)

• Tier: Hat eine Eigenschaft „int Age“
• Person: Hat eine Eigenschaft „Datetime Geburtstag“

Was ich versuche zu erreichen, ist "Hochladen" (persistent in der Datenbank) zu kompilieren, die in allen verschiedenen Datenstrukturklassen üblich ist. Also in erster Linie meines Ziel ist es, eine kleine Upload-Methode zu haben, die

foreach (TypeName typeName in Enum.GetValues(typeof(TypeName))) 
    { 
     IDataPopulator populator = 
      new DataFactory().CreateDataPopulator(typeName); 
     populator.Populate(string.Empty); 
    } 

Aber das Problem ist, wie
sieht, dass populator gibt ein Objekt Instanzen verschiedenen Typen, die ich, da sie keine Gemeinsamkeiten zu verkapseln versucht habe Eigenschaften. (IDataPopulator.TResult Füllen (Zeichenfolge Daten) in den folgenden Code)

Gibt es eine Möglichkeit, um dies zu umgehen? Oder passt das Strategie-Muster nicht zu dieser Art von Szenario?

Hier ist der Code, den ich mit

public class Program 
{ 
    public static void Main() 
    { 
     foreach (TypeName typeName in Enum.GetValues(typeof(TypeName))) 
     { 
      IDataPopulator populator = new DataFactory().CreateDataPopulator(typeName); 
      populator.Populate(string.Empty); 
     } 
    } 
} 

public enum TypeName { Person, Animal } 
public class Person { public DateTime Birthday { get; set; } } 
public class Animal { public int Age { get; set; } } 

public interface IDataPopulator 
{ 
    TResult Populate(string data); 
} 

class AnimalDataPopulator : IDataPopulator 
{ 
    public Animal Populate(string data) 
    { 
     // create an instance of Animal using data 
    } 
} 

class PersonDataPopulator : IDataPopulator 
{ 
    public Person Populate(string data) 
    { 
     // create an instance of Person using data 
    } 
} 

public class DataFactory 
{ 
    public IDataPopulator CreateDataPopulator(TypeName typeName) 
    { 
     switch (typeName) 
     { 
      case TypeName.Person: 
       return new PersonDataPopulator(); 
      case TypeName.Animal: 
       return new AnimalDataPopulator(); 
      default: 
       throw new ArgumentOutOfRangeException("typeName"); 
     } 
    } 
} 

public class UploadContext 
{ 
    private readonly IUploader _Uploader; 
    public UploadContext(IUploader uploader) { _Uploader = uploader; } 
    public void Upload() { _Uploader.Upload(); } 
} 

public interface IUploader 
{ 
    void Upload(); 
} 

class PersonUploader : IUploader 
{ 
    private Person _Person; 
    public PersonUploader(Person person) { _Person = person; } 
    public void Upload() 
    { 
     Console.WriteLine("Uploading person..."); 
    } 
} 
class AnimalUploader : IUploader 
{ 
    private Animal _Animal; 
    public AnimalUploader(Animal animal) { _Animal = animal; } 
    public void Upload() 
    { 
     Console.WriteLine("Uploading animal..."); 
    } 
} 

Answer 1

Ich sehe nicht, wie das Strategie-Muster hier passen würde. Das Muster betrifft eine Familie von Algorithmen, z. Strichbruch-Strategien. Sie haben keine Strategien hier, Sie haben eine einzige abstrakte Methode

TResult Populate(string data);

und mehrere Implementierungen davon.

Ich verstehe auch nicht das ursprüngliche Problem, vielleicht möchten Sie mehrere Serialisierungsvorgänge in die Warteschlange? In diesem Fall ist das Befehlsmuster dein Freund.

Answer 2

gearbeitet haben denke ich, was Sie nach ist entweder Serialisierung, wenn Sie Blobs nur speichern, oder ein ORM-Framework.