Discussion :

[cheachwood]

Bonjour,

je développe un mini framework de logging s'appuyant sur Log4Net afin de faciliter la tâche des développeurs qui doivent prendre la suite.
J'ai donc créé une classe Attribut qui doit être systématiquement utilisée sur des méthodes des classes de Service, j'ai alors créé une interface qui déclare ces méthodes et chaque nouvelle classe de service doit implémenter cette interface, seulement voilà le développeur doit lui même rajouter les attributs sur toutes les méthodes et si il oublie et bien tant pis la méthode n'est pas suivi.

Si je déclare les Attributs au niveau des interfaces, lorsqu'elles sont implémentées les méthodes ne sont pas précédées des Attributs et il n'est pas tenu en compte.

Ma question, est-il possible de forcé la signature et les Attributs d'une méthode déclarées dans une interfaces?

Voici le code que j'ai avec les Attributs déclarés à la main:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
    public interface IObjectService
    {
        int Insert(object obj);
        int Update(object obj);
        int Delete(object obj);
    }
 
    public class ObjectDomaine:IObjectService
    {
        #region IObjectService Membres
 
        [LoggingAttribute("toto", "Insert", "ObjectDomaine")]
        public int Insert(object obj)
        {
            return 0;
           // throw new Exception("The method or operation is not implemented.");
        }
 
        [LoggingAttribute("toto", "Update", "ObjectDomaine")]
        public int Update(object obj)
        {
            return 0;
           // throw new Exception("The method or operation is not implemented.");
        }
 
        [LoggingAttribute("toto", "Delete", "ObjectDomaine")]
        public int Delete(object obj)
        {
            return 0;
           // throw new Exception("The method or operation is not implemented.");
        }
 
        #endregion
    }

et le code que je voudrais avec les Attributs déclarés et implémentés automatiquement par l'interface:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
    public interface IObjectService
    {
       [LoggingAttribute("toto", "Insert", string)]
        int Insert(object obj);
 
       [LoggingAttribute("toto", "Update", string)]
        int Update(object obj);
 
       [LoggingAttribute("toto", "Delete", string)]
        int Delete(object obj);
    }
 
    public class ObjectDomaine:IObjectService
    {
        #region IObjectService Membres
 
        [LoggingAttribute("toto", "Insert", "ObjectDomaine")]
        public int Insert(object obj)
        {
            return 0;
           // throw new Exception("The method or operation is not implemented.");
        }
 
        [LoggingAttribute("toto", "Update", "ObjectDomaine")]
        public int Update(object obj)
        {
            return 0;
           // throw new Exception("The method or operation is not implemented.");
        }
 
        [LoggingAttribute("toto", "Delete", "ObjectDomaine")]
        public int Delete(object obj)
        {
            return 0;
           // throw new Exception("The method or operation is not implemented.");
        }
 
        #endregion
    }

de plus comment peut-on dire dans la déclaration d'un Attribut que je souhaite renvoyer le nom de la classe en cours? Afin de remplacer ce bout de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 [LoggingAttribute("toto", "Insert", "ObjectDomaine")]
        public int Insert(object obj)

par par exemple (le code est faux mais c'est pour la démonstration):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 [LoggingAttribute("toto", "Insert", ObjectDomaine.GetType().FullName)]
        public int Insert(object obj)

Merci d'avance

[cheachwood]

Bon voilà, j'ai finalement trouvé tout seul.

Pour l'écriture obligatoire des attributs sue les méthodes j'ai créé une classe abstraite en utilisant les générics, cette classe doit donc être systématiquement utilisé par les futures développeurs.

Pour le deuxième point, j'ai simplifier l'attribut en ne passant plus qu'un seul paramètre, il n'y a plus le nom de la méthode ni le nom de la classe, il y avait tout ce qu'il fallait dans la classe qui permet de créer un attribut.

Pour les curieux voici quelques bouts de code :

L'interface qui déclare les méthodes à implémenter obligatoirement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
using System;
using System.Collections.Generic;
using System.Text;
namespace Appli.BLL.BusinessRulesInterfaces
{
    /// <summary>
    /// Permet de déclarer les méthodes qui doivent être systématiquement redéfinies
    /// par les méthodes de Service des objets métiers, ceci à des fins de suivie des actions 
    /// des utilisateurs de l'application
    /// </summary>
    public interface IObjectService<T, idT>
    {
        /// <summary>
        /// Permet l'insertion d'objets métier dans une ressource
        /// </summary>
        /// <param name="obj">L'objet métier à enregistrer</param>
        /// <returns>l'id de l'objet enregistré</returns>
        T Save(T instance);
 
        /// <summary>
        /// Permet la mise à jour d'objets métier dans une ressource
        /// </summary>
        /// <param name="obj">L'objet métier à mettre à jour</param>
        /// <returns>l'id de l'objet mis à jour</returns>
        T SaveOrUpdate(T instance);
 
        /// <summary>
        /// Permet la suppression d'objets métier d'une ressource
        /// </summary>
        /// <param name="obj">L'objet métier à supprimer</param>
        /// <returns>true si suppression réussie, false dans le cas contraire</returns>
        bool Delete(T instance);
 
        /// <summary>
        /// Permet de lister tous les objets de ce domaine
        /// </summary>
        /// <returns>Une liste d'objet du domaine</returns>
        IList<T> FindAll();
 
        /// <summary>
        /// Permet de retrouver un objet par son id
        /// </summary>
        /// <param name="id">L'id de l'objet à retrouver</param>
        /// <returns>un objet du domaine</returns>
        T FindById(idT id);
    }
}

Code de la classe abstraite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using System;
using System.Collections.Generic;
using System.Text;
using Appli.Logger.Attributes;
using Appli.BLL.BusinessRulesInterfaces;
 
namespace Appli.BLL.BusinessRules
{
    /// <summary>
    /// Exemple de Service à implémenter
    /// </summary>
    public abstract class ServiceObjectDomaine<T, idT> : IObjectService<T,idT>
    {
 
        #region IObjectService<T> Membres
        [LoggingAttribute("cheachwood")]
        public T Save(T instance)
        {
            return default(T);
        }
 
        [LoggingAttribute("cheachwood")]
        public T SaveOrUpdate(T instance)
        {
            return default(T);
        }
 
        [LoggingAttribute("cheachwood")]
        public bool Delete(T instance)
        {
            return false;
        }
 
        [LoggingAttribute("cheachwood")]
        public IList<T> FindAll()
        {
            return null;
        }
 
        [LoggingAttribute("cheachwood")]
        public T FindById(idT id)
        {
            return default(T);
        }
 
        #endregion
    }
}

Exemple d'implémentation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
using System;
using System.Collections.Generic;
using System.Text;
using Appli.Domaine.Aide;
 
namespace Appli.BLL.BusinessRules
{
    public class ServiceReferentiel:ServiceObjectDomaine<Referentiel,string>
    {
    }
}

Ou Referentiel est un classe métier.

Enfin le bout de code qui liste le nom de la méthode et le type de l'objet passé en paramètre défini par l'attribut:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
       public object Invoke(IMethodInvocation invocation)
        {
            // Récupération des Attributs définies pour la méthode invoquées
            LoggingAttribute[] consoleLoggingInfo =
                (LoggingAttribute[])invocation.Method.GetCustomAttributes(typeof(LoggingAttribute), false);
 
            // Récupération des paramètres de l'attibuts déclarés pour la méthode
            List<object> listParams = (List<object>)consoleLoggingInfo[0].GetParams();
 
            // Insertion de la méthode invoquée pour suivi
            listParams.Insert(0, invocation.Method.Name);
            listParams.Insert(1, invocation.TargetType.Name);
 
            // Enregsitrement des éléments du tableau dans le log
            log.Info(String.Format(message.Lancement_Methode, listParams.ToArray()));
 
            object rval = invocation.Proceed();
            return rval;
        }

@+