Discussion :

[AQkinkin]

Bonjour,

Qu'est qui est préférable entre une déclaration global pour un objet utilisé par plusieurs et une transmission de adresses entre objet.

Ceci d'un point de vu :
sécurité du code
rapidité du programme
utilisation de thead

Cas 1 :

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
 
static class Program
    {
        static public class ObjetCommun = new class();
        ...
    }
 
class Class1
{
     public vois func()
     {
         Program.ObjetCommun.func1();
     }
}
class Class2
{
     public vois func()
     {
         Program.ObjetCommun.func1();
     }
}

Cas 2:

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
 
class Class1
{
     private class _ObjetCommun;
 
     public Class1(class ObjetCommun)
     {
          _ObjetCommun = ObjetCommun;
     }
 
     public vois func()
     {
         _ObjetCommun.func1();
     }
}
class Class2
{
     private class _ObjetCommun;
 
     public Class2(class ObjetCommun)
     {
          _ObjetCommun = ObjetCommun;
     }
 
     public vois func()
     {
         _ObjetCommun.func1();
     }
}

merci pur vos réponses.

[Pol63]

les différences sont minimes, donc j'opterais pour le "tu choisis ce que tu préfères", surtout en fonction de la syntaxe donc
sur un petit programme j'opterais plus sur le static, pour quelque chose de plus gros ou qui nécessiterait de l'évolutivité la 2ème serait peut être préférable

sécurité du code => c'est à dire ? (si c'est la propreté je pense que c'est subjectif)
rapidité du programme => tu es vraiment à la nanoseconde près ?
utilisation de thead => je ne vois pas le rapport

[Noxen]

Personnellement j'ai maintenant une préférence pour la deuxième solution, qui a un modèle injection de dépendance et permet de mettre plus facilement en place des test unitaires. Mais rien ne t'empêche d'opter pour un compromis avec un constructeur paramétré ; par ailleurs je ne mettrais pas la référence static directement dans la classe Program par défaut du template de projet mais plutôt dans une classe dédiée à part que tu pourras extraire de l'assembly.

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
// Interface
public interface IContext { void DoSomething(); }
 
// Implémentation
public class Context:IContext{  public void DoSomething() { Console.WriteLine("Hello World!"); }
 
// Classe fournisseur global
public class Provider
{
  public static IContext Context { get; set; }
}
 
// Un utilisateur
public class Class1
{
  private IContext _context();
  public Class1(IContext context) { _context = context; }
  public Class1():this(Provider.Context);
  public void CallSomething() { _context.DoSomething(); }
}
 
// Le programme
class Program
{
  static void Main(string[] args)
  {
    Provider.Context = new Context();
    Class1 obj1 = new Class1();
    obj1.CallSomething();
  }
}
 
// Implémentation de IContext pour les tests
public class TestContext:IContext
{
  int CallCount { get; private set; }
  public void DoSomething() { CallCount++; }
}
 
// Classe de test
[TestFixture]
public class TestClass1
{
  [Test]
  public void TestCallSomething()
  {
    IContext context = new TestContext();
    Class1 obj1 = new Class1(context);
    obj1.CallSomething();
    Assert.IsTrue(context.CallCount > 0);
  }
}

On ne gère pas les Thread ici, mais on peut créer une classe de proxy pour protéger les appels.