Discussion :

[Wil14]

Bonjour,

Est-il possible d'avoir le code du singleton dans une classe de base et ensuite d'hériter de ce code pour les nouveaux objets ?

Wil

[Nathanael Marchand]

Les membres statiques ne sont pas hérités donc tu ne peux pas gérer de cette manière l'héritage de singleton. Peut-être eventuellement en implémentant un Pattern Factory.
Quel est le besoin derrière?

[Wil14]

Je vais avoir une dizaine d'objets fonctionnant sur le principe du singleton.
C'est juste pour éviter de re-écrire le code.

[Nathanael Marchand]

Dans ce cas la, il faut plutôt utiliser un framework comme Spring.Net ou Unity qui sont des conteneurs de singletons (en gros)

[Bluedeep]

Les membres statiques ne sont pas hérités

Si, les membres statiques sont hérités et c'est justement le problème dans son cas. Il ne peut pas masquer le membre static pour le différencier dans chaque classe héritée.

[Nathanael Marchand]

Me suis mal exprimé, dans le cas d'un héritage, ca ne peut pas être redéfini!

Voici un exemple de container gérant les singletons des classes hérités d'une classe de base:

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
void Main()
{
	var car = Factory<Vehicule>.GetInstance<Car>();
	car.WhoAmI();
 
	var boat = Factory<Vehicule>.GetInstance<Boat>();
	boat.WhoAmI();
 
	var plane = Factory<Vehicule>.GetInstance<Plane>();
	plane.WhoAmI();
}
 
public static class Factory<T>
{
	private static readonly KeyedByTypeCollection<T> _instances = new KeyedByTypeCollection<T>();
 
	public static V GetInstance<V>() where V : T, new()
	{
		if (!_instances.Contains(typeof(V)))
		{
			_instances.Add(new V());
		}
		return (V)_instances[typeof(V)];
	}
} 
 
public abstract class Vehicule
{
	public abstract void WhoAmI();
}
 
public class Car : Vehicule
{
	public override void WhoAmI()
	{
		Console.WriteLine("I'm a car");
	}
}
 
public class Plane : Vehicule
{
	public override void WhoAmI()
	{
		Console.WriteLine("I'm a plane");
	}
}
 
public class Boat : Vehicule
{
	public override void WhoAmI()
	{
		Console.WriteLine("I'm a boat");
	}
}

[MetalGeek]

Salut,
utilise les generics comme dit plus haut. Le fait de vouloir implémenter des classes dérivées juste pour économiser du code, ça s'appelle l'héritage d'implémentation et c'est pas bon du tout !

[Wil14]

J'ai un souci lors de l’implémentation car le SingletonPattern doit hériter d'un objet de base.
La syntaxe est-elle correcte :

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 class ObjDeBase:DataTable
{
  public ObjDeBase(string MaChaine)
  {
    ....
  }
}
 
    public abstract class SingletonPattern<T> where T : ObjDeBase, new()
    {
        private static T fInstance;
        public static T Instance
        {
            get
            {
                if (fInstance == null)
                {
                    fInstance = new T();
                }
                return fInstance;
            }
        }
 
        private SingletonPattern(string MaChaine): base(MaChaine)
        {
        }
    }
 
public class MySingleton : SingletonPattern<MySingleton>
{
  private MySingleton():base("bla bla bla")
  {
  }
}

Sur la déclaration de MySingleton, j'ai :

'MySingleton' doit être un type non abstrait avec un constructeur sans paramètre public afin de l'utiliser comme paramètre 'T' dans le type ou la méthode générique 'SingletonPattern<T>'

[Bluedeep]

Bonjour,

Est-il possible d'avoir le code du singleton dans une classe de base et ensuite d'hériter de ce code pour les nouveaux objets ?

Wil

Bien sur. Voici un exemple classe générique d'implémentation de singleton :

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
	/// <summary>
	/// Implemenatin standard singleton.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	public abstract class SingletonPattern<T> where T : class, new()
	{
		private static T _instance;
		public SingletonPattern()
		{
		}
		public static T Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new T();
				}
				return _instance;
			}
		}
	}

après tu crées ton singleton ainsi :

Code :

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

1
2
3
4
class MySingleton : SingletonPattern<MySingleton>
{
// .. implementation de la classe.
}

Et tu l'utilises :

Code :

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

MySingleton.Instance