Interface générique et héritage [Résolu]

Question

Posez votre question Signaler Répondre au sujet

Interface générique et héritage [Résolu]

thiosyiasar 186 Messages postés lundi 11 mars 2002Date d'inscription 30 novembre 2010 Dernière intervention - 15 janv. 2008 à 17:50 - Dernière réponse : thiosyiasar 186 Messages postés lundi 11 mars 2002Date d'inscription 30 novembre 2010 Dernière intervention

- 17 janv. 2008 à 15:35

C# / .NET Posez votre question Signaler Répondre au sujet

<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /??>
Boujour,

J’ai un fournisseur de service d’accès aux données.

Je lui passe un type d’entité et lui me retourne le service correspondant.

Chaque service implémente une interface générique en définissant le type d’entité géré

Le code fournit compile mais il ‘ y un pb de cast à l’exécution, ce qui m’étonne à moitié.

Avez-vous des solutions ?

Sachant que les services doivent restés typés pour le type d’entité.

Et que j'ai besoin d'un méthode qui me fournit le service a partir d'un type d'entité

//// CODE A EXECUTER

    //// CODE A EXECUTER //////////////////////////////
    static class Program
    {
        [STAThread]
        static void Main()
        {
            // Création de l'entité
            User oUser = new User();

            // Sélection du service d'accès aux données
            IEntityService<Entity> oService = ServiceProvider.GetService(oUser.GetType());

            // Utiliastion du service pour enregistrer
            oService.Save(User);
        }

    }

    //// DEFINITION DES ENTITES ///
    public abstract class Entity
    {
        public long Id = 0;
    }

    public class Content : Entity { }

    public class User : Entity { }

    //// DEFINITION DES SERVICES ///
    public interface IEntityService<TEntity> where TEntity : Entity
    {
        void Save(TEntity entity);
    }

    public class ContentService : IEntityService<Content>
    {
        public void Save(Content entity) { }
    }

    public class UserService : IEntityService
    {
        public void Save(User entity) { }
    }

    //// DEFINITION DU FOURNISSEUR DE SERVICE ///
    public static class ServiceProvider
    {
        public static IEntityService<Entity> GetService(Type type)
        {
            if (type.Equals(typeof(Content)))
                return (IEntityService<Entity>)new ContentService();
            else if (type.Equals(typeof(User)))
                return (IEntityService<Entity>)new UserService();
            else
                return null;
        }
    }

Merci,

Nico

Afficher la suite

2 réponses

Répondre au sujet

Signaler Commenter la réponse de thiosyiasar

thiosyiasar 186 Messages postés lundi 11 mars 2002Date d'inscription 30 novembre 2010 Dernière intervention - 17 janv. 2008 à 15:34

0

Utile

Nico

Accepted Answer

+3

Utile

Bon ca n'a pas l'air d'emballer grand monde mon histoire.... :(

J'ai trouvé une solution alternative, le but est d'attaquer le service correspondant sans connaitre le type d'entité.

J'ai supprimé la méthode public GetService, et mon provider reprend tout les méthode des services (ici pour l'exemple, la méthode Save(Entity entity), dans le cas d'une méthode sans paramètre, (par ex GetNew()), on lui passe le type en paramètre (Entity GetNew(Type entityType))

Le fournisseur de service a donc cette tete maintenant et ca marche, en utilisant la rélfexion.

Si vous avez une solutions plus propres... je suis preneur

static class Program
{
[STAThread]
static void Main()
{
// Création de l'entité
User oUser = new User();

// Sélection du service d'accès aux données
ServiceProvider.Save(oUser);
}
}

public static class ServiceProvider
{
public static void Save(Entity entity)
{
if (entity == null)
throw new ArgumentException("L'entité ne peut être nulle");
ExecuteService(entity.GetType(), "Save", new object[] { entity });
}

private static object ExecuteService(Type entityType, string methodName, object[] parameters)
{
// Sélection du service
object oService = GetService(entityType);

// Sélection de la méthode
Type oServiceType = oService.GetType();
MethodInfo oMethod = oServiceType.GetMethod(methodName);

// Execution et retour de la valeur
object oValue = oMethod.Invoke(oService, parameters);
return oValue;
}

/// <summary>
/// Retourne le service en fonction du type d'entité donné
/// </summary>
/// <returns>IEntityService</returns>
private static object GetService(Type entityType)
{
if (entityType == null)
throw new ArgumentException("Le type ne peut pas etre null");
else if (!entityType.IsSubclassOf(typeof(Entity)))
throw new ArgumentException("Le type doit etre un entité");
else if (entityType.Equals(typeof(Content)))
return new ContentService();
else if (entityType.Equals(typeof(User)))
return new UserService();
else
throw new ArgumentException("Ce type d'entité n'a pas de service attribué");
}

}

Nico

Cette réponse vous a-t-elle aidé ? Oui Non

Interface générique et héritage [Résolu]

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !