Discussion :

[tortuegenie]

Bonjour, j'ai une classe DataAccess qui comprends plusieur méthode pour créer une connexion, executer des requetes, etc...

Dans mes pages aspx, je fais ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public partial class Accueil : PageCulture
{
    DataAcces myFac = new DataAcces();
 
    protected void Page_Load(object sender, EventArgs e)
    {
    }
 
}

J'instancie avant le page load. Ma question est la suivante, est ce une bonne méthode. Ou bien dois-je instancier la classe seulement lorsque j'en ai besoin.
Dans mon cas, je l'a déclare 1 seule fois dans la page (avant le page_load), et j'utilise le meme objet "myFac".

Merci pour votre réponse

[Hinault Romaric]

Ben on extensie un objet lorsque l'on doit l'utiliser pas par simple plaisir

[topolino]

Sinon utilise des class static, tu feras par consequent

Code :

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

DAL.CreateConnection();

[tortuegenie]

pour les classes statiques j'ai déjà des trucs qui fonctionnent. Mais là c'est vrai que l'objet peut etre instancier 1 fois et être utilisé pour plusieur méthodes.
Je sais bien on utilise un objet quand on en a besoin, mais pour réutiliser l'objet ou pour ecrire moins de code, c'est sur que c'est mieux

[topolino]

Alors je n'ai pas entierement compris ta question

[tortuegenie]

Actuellement.J'ai une classe d'acces aux données DataAcces.

Ensuite dans le code-behind de ma page au tout début avant le page_load, je fais DataAcces myFac = new DataAcces() et j'utilise l'objet myFac dans les n méthodes qui sont définis dans ma page.

La question que je pose c'est est ce que je peux faire cela comme ça. Ou bien dans chacune de mes fonctions ou j'ai besoin de faire un acces à ma classe faire ceci.

Code :

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

DataAcces myFac = new DataAcces() ;

Comprends-tu mieux?

[Arthis]

Pourquoi ne passe tu pas par un accesseur qui creeras ton objet en dynamique quand il est utilisé :

Code :

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

1
2
3
4
5
6
public DAC MonDAC 
{
      if (monconteneur["MonDAC "]==null)
         monconteneur["MonDAC "]= new DAC();
      return (DAC )monconteneur["MonDAC "];
}

Ainsi peu importe de savoir quel est son état , quand tu l'appeleras tu l'auras.

[tortuegenie]

ok, je vais voir ce que je peux faire.
Merci

[Immobilis]

Salut,

J'ai aussi un objet de ce type.

Il y a une chose importante à retenir: une classe qui utilise des objets disposables doit elle-même être disposable.

Le code ci-dessous ne respecte pas cette bonne pratique:

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
public class DataAcces
{
    private IDbConnection cn;
 
    public IDbConnection Connexion
    {
        get { return cn; }
        set { cn = value; }
    }
 
    public DataAcces()
    {
        this.Connexion = new SqlConnection();
        this.Connexion.ConnectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
        this.Connexion.Open();
    }
}

Le bon code

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class DataAcces : IDisposable
{
    private IDbConnection cn;
    private bool _disposed = false;
 
    public IDbConnection Connexion
    {
        get { return cn; }
        set { cn = value; }
    }
 
    public DataAcces()
    {
        this.Connexion = new SqlConnection();
        this.Connexion.ConnectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
        this.Connexion.Open();
    }
 
    #region IDisposable Members
 
    public void Dispose()
    {
        // Check if Dispose has already been called 
        if (!_disposed)
        {
            // Call the overridden Dispose method that contains common cleanup code
            // Pass true to indicate that it is called from Dispose
            Dispose(true);
            // Prevent subsequent finalization of this object. This is not needed 
            // because managed and unmanaged resources have been explicitly released
            GC.SuppressFinalize(this);
            _disposed = true;
        }
    }
 
    private void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (this.Connexion != null)
            {
                if (this.Connexion.State == ConnectionState.Open)
                {
                    this.Connexion.Close();
                }
                this.Connexion.Dispose();
                this.Connexion = null;
            }
        }
    }
 
    /// <summary>
    /// Implement a finalizer by using destructor style syntax
    /// </summary>
    ~DataAcces()
    {
        // Call the overridden Dispose method that contains common cleanup code
        // Pass false to indicate the it is not called from Dispose
        Dispose(false);
    }
    #endregion
}

Il faut respecter ce schéma et détruire tous les objets non gérés dans la méthode

Code :

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

private void Dispose(bool disposing)

Son utilisation:

Code :

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

1
2
3
4
5
6
7
8
9
10
public class Program
{
    public static void Main(string[] args)
    {
        using (DataAcces da = new DataAcces())
        {
            // Ton code pour récupérer les données
        }
    }
}

Tu peux ainsi faire appel à un block "using" dans lequel les variables déclarées n'ont pas de portée en-dehors du block. C'est plus propre.

Finalement, que tu créés une instance à la demande ou bien une instance pour toute ta classe n'a pas énormement d'importance. En pratique, créer des instances à la volées doit prendre un peu de ressources créer/détruire, aller chercher une connexion dans le pool... Il faut aussi savoir que si tu as besoin d'une deuxième connexion (requêtes imbriquées) il te faudra une nouvelle instance.

Personnellement, mes objets qui font appel à DataAccess ont chacun une seule instance qui dure tant que l'objet n'est pas détruit. Exemple

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
49
50
51
52
53
54
public class MonProvider : IDisposable
{
    private DataAcces da = null;
    private bool _disposed = false;
 
    public MonProvider()
    {
        da = new DataAcces();
    }
 
    public object Load(int id)
    {
        object obj = new object();
        // Mon code pour récupérer les donnée en fonction de mon id
        return obj;
    }
 
    #region IDisposable Members
 
    public void Dispose()
    {
        // Check if Dispose has already been called 
        if (!_disposed)
        {
            // Call the overridden Dispose method that contains common cleanup code
            // Pass true to indicate that it is called from Dispose
            Dispose(true);
            // Prevent subsequent finalization of this object. This is not needed 
            // because managed and unmanaged resources have been explicitly released
            GC.SuppressFinalize(this);
            _disposed = true;
        }
    }
 
    private void Dispose(bool disposing)
    {
        if (disposing)
        {
            da.Dispose();
        }
    }
 
    /// <summary>
    /// Implement a finalizer by using destructor style syntax
    /// </summary>
    ~MonProvider()
    {
        // Call the overridden Dispose method that contains common cleanup code
        // Pass false to indicate the it is not called from Dispose
        Dispose(false);
    }
    #endregion
 
}

Petite remarque, un objet d'accès aux données ne devrait pas apparaître dans une IHM.

A+

[Arthis]

tout à fait d'Accord avec immobilis. Mais si tu utilises le petit bout de code que je t'ai mis plus haut, tu n'as plus qu a l'integrer dans ta page PageCulture par exemple et dans l'evenement onUnload tu pourras fermer cette connection si elle est ouverte.

C'est un petit truc sympa et rapide a faire pour gerer sa connection. Maintenant, tout ce qu'a dis Immobilis est mieux, mais fais selon tes possibilites pour le moment...

[tortuegenie]

Merci beaucoup pour vos réponses, je vais voir comment je peux continuer et au pire je ne pourrais faire que mieux la prochaine fois.

[Arthis]

N'hésites pas à marquer comme résolue tes questions.


à bientôt,

[tortuegenie]

c'est vrai.dsl