Méthodes de groupe dans la classe abstraite

Question

Je travaille sur un modèle de fabrique de base de données pour une application qui doit prendre en charge Sql Server et Oracle. J'ai des classes abstraites avec toutes les requêtes Sql pour l'application. J'ai implémenté la classe abstraite dans deux classes: SqlServerClass et OracleClass. En fonction de la chaîne de connexion définie dans le fichier de configuration, l'application crée une instance de la classe correspondante et récupère les requêtes Sql pour la base de données.

public abstract class ProviderFactory 
    { 
     public abstract string GetCustomersSql(); 
     public abstract string GetCustomersByIdSql(); 
     public abstract string GetUsersSql(); 
     public abstract string GetUsersByIdSql(); 
    } 

    public class OracleClass : ProviderFactory 
    { 
     public override string GetCustomersSql() 
     { 
      // return sql query for Oracle 
     } 
     // other methods 
    } 
    public class SqlServerClass : ProviderFactory 
    { 
     public override string GetCustomersSql() 
     { 
      // return sql query for Sql Server 
     } 
     // other methods 
    } 

Maintenant, ma question est, est-il un moyen de regrouper ces requêtes SQL dans la classe abstraite de sorte que l'on peut facilement identifier les requêtes SQL utilisées pour la fonctionnalité particulière. Par exemple, je peux regrouper tous les clients et les utilisateurs des requêtes connexes de requêtes connexes afin que quand je les appelle, ce serait ....

ProviderFactory instance; 
// create an instance 
instance.Customers.GetCustomersSql(); 

Est-ce que je fais ici une approche valable? Veuillez suggérer. Je vous remercie.

Answer 1

Je recommande fortement d'utiliser un ORM tel que NHibernate. Il supports both SQL Server and Oracle et résume les différences entre les deux. Je veux dire par là que vous n'avez qu'à écrire la requête une seule fois dans un format que NHibernate comprend et qu'elle traduira cela en versions que SQL Server et Oracle comprennent.

Si vous voulez continuer votre chemin actuel ce que vous pouvez faire est de créer ce que j'appelle un répertoire de requête:

public interface IQueryDirectory 
{ 
    ICustomerQueries Customer { get; } 
    IUserQueries User { get; } 
} 

public interface ICustomerQueries 
{ 
    string Customers { get; } 
    string CustomersById { get; } 
} 

public interface IUserQueries 
{ 
    string Users { get; } 
    string UsersById { get; } 
} 

Exemple mise en œuvre:

public abstract class QueryDirectory : IQueryDirectory 
{ 
    private ICustomerQueries customer; 
    private IUserQueries user; 

    public ICustomerQueries Customer 
    { 
     get { return customer; } 
    } 

    public IUserQueries User 
    { 
     get { return user; } 
    } 

    protected QueryDirectory(ICustomerQueries customer, IUserQueries user) 
    { 
     this.customer = customer; 
     this.user = user; 
    } 
} 

public class SqlServerQueryDirectory : QueryDirectory 
{ 
    public SqlServerQueryDirectory(SqlServerCustomerQueries customer, 
     SqlServerUserQueries user) : base(customer, user) {} 
} 

public class SqlServerCustomerQueries : ICustomerQueries 
{ 
    public string Customers 
    { 
     get "some sql"; 
    } 

    public string CustomersById 
    { 
     get "some sql"; 
    } 
} 

Ensuite, vous pouvez mettre en œuvre la répertoires séparément pour chaque base de données. Mais honnêtement, je recommande vraiment, vraiment, vraiment d'utiliser un ORM à la place.