Usine simple pour récupérer des fichiers en utilisant l'injection de dépendances de constructeur

Question

Je veux créer une classe, qui est flexible pour que je puisse changer d'implémentation.

Problème: Les fichiers/documents de magasin
Options: soit stocker localement sur le système de fichiers du serveur, base de données ou etc.

Quelqu'un peut-il aider à une structure de squelette de la classe, et comment je l'appellerais? Je n'utilise pas d'IoC, et je ne veux pas vraiment le faire pour le moment. Je veux juste la flexibilité où je ferais peut-être un changement de code en usine pour appeler une autre implémentation.

Answer 1

l'interface. Où que vous ayez besoin de stocker des fichiers, autorisez simplement un IFileStorer. Si vous avez besoin d'une nouvelle façon de le stocker, ajoutez simplement un autre type IFileStorer.

interface IFileStorer 
{ 
    void Store(string file, byte[] data); 
} 

class LocalStorer : IFileStorer 
{ 
    void Store (string id, byte[] data) 
    { 
     //code to store locally 
    } 
} 


class DBStorer : IFileStorer 
{ 
    void Store (string id, byte[] data) 
    { 
     //code to store in db 
    } 
} 

class AnywhereStorer : IFileStorer 
{ 
    void Store (string id, byte[] data) 
    { 
     //code to store in anywhere 
    } 
} 

Answer 2

Utilisez une interface.

interface IStorage 
{ 
    void Save(string filename); 
} 

Ensuite, créez vos différentes implémentations:

class LocalStorage : IStorage 
{ 
    void Save(string filename) 
    { 
     -implementation code- 
    } 
} 

Et puis, dans vos classes de consommation

IStorage storage = new LocalStorage(); 

// uses local storage 
storage.Save(); 

storage = new DatabaseStorage(); 

// now use database storage 
storage.Save(); 

Answer 3

Juste pour ajouter un peu de ce que les autres ont affiché, si vous voulez vraiment juste faire un changement, considérer une usine statique:

public interface IFileStorage 
{ 
    void Store(); //parameters if needed 
} 

public class FileStorage : IFileStorage 
{ 
    public void Store(){} 
} 

public class DatabaseStorage : IFileStorage 
{ 
    public void Store(){} 
} 

Ensuite, avoir un ENUM que vous mapper les classes concrètes:

public enum FileStorageTypes 
{ 
    Database, 
    FileSystem 
} 

et enfin l'usine:

public static class StorageFactory 
{ 
    public static IFileStorage GetStorage(FileStorageTypes types) 
    { 
     switch(types) 
     { 
     case FileStorageTypes.Database: return new DatabaseStorage(); 
     case FileStorageTypes.FileSystem: return new FileStorage(); 
     } 
    } 
} 

Ensuite, si vous avez quelque part dans votre code que vous devez faire un travail de stockage:

public void DoStorage(IFileStorage storage) 
{ 
    storage.Store(); 
} 

Vous pouvez simplement appeler cette méthode:

DoStorage(StorageFactory.GetStorage(FileStorageTypes.Database)); 

et facilement l'échanger si nécessaire.