Discussion :

[adrien1]

Bonsoir a tous,
je veux utiliser une classe qui ne peut s'instancier qu'une fois et qui soit thread-safe.
De plus je veux pouvoir la serialiser dans un fichier et la deserialiser.
La serialiser ne me pose pas de probleme par contre pour la deserialiser ca me pose probleme.
voici la definition de ma classe:

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
    [Serializable()]
    public class BlackList : ISerializable
    {
        //Variables
        public List<BlackListNumber> ListBlackListNumber { get; set; }
        static readonly BlackList instance = new BlackList();
        public static BlackList Instance { get { return instance; } }
        //Constructeurs
        private BlackList() { ListBlackListNumber = new List<BlackListNumber>(); }
        //Methodes
        public static void writeObject(string path,BlackList ObjectToSerialize)
        {
            Stream stream = File.Open(path, FileMode.Create);
            BinaryFormatter bformatter = new BinaryFormatter();
            bformatter.Serialize(stream, ObjectToSerialize);
            stream.Close();
        }
        public void writeObject(string path)
        {
            Stream stream = File.Open(path, FileMode.Create);
            BinaryFormatter bformatter = new BinaryFormatter();
            bformatter.Serialize(stream, this);
            stream.Close();
        }
        public static BlackList ReadObject(string path)
        {
            Stream stream = File.Open(path, FileMode.Open);
            BinaryFormatter bformatter = new BinaryFormatter();
            BlackList retour;
            retour = (BlackList)bformatter.Deserialize(stream);
            stream.Close();
            return retour;
        }
        public override string ToString()
        {
            string retour = "";

            var e = this.ListBlackListNumber.GetEnumerator();
            while (e.MoveNext())
            {
                retour += e.Current.ToString() + "\n";
            }
            return retour;
        }

        //Imlementation interfaces
        #region ISerializable Membres

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("ListBlackListNumber", this.ListBlackListNumber);
            info.AddValue("instance", instance);
        }

        #endregion

        public BlackList(SerializationInfo info, StreamingContext context)
        {
            this.ListBlackListNumber = (List<BlackListNumber>)info.GetValue("ListBlackListNumber", typeof(List<BlackListNumber>));
            instance = (BlackList)info.GetValue("instance", typeof(BlackList));
        }
    }

il me dit que :

Erreur1 Un champ readonly statique ne peut pas être assigné (sauf s'il appartient à un constructeur statique ou un initialiseur de variable) C:\Users\Thomas\Documents\Visual Studio 2008\Projects\BlackListingFunctions\BlackList.cs

[worm83]

salut,

Va falloir que tu modifie les propriété de ton objet, il est readonly static ce qui veux dire que tu ne pourra pas le modifier une fois instancier. Tu peut en revanche recupéré une autre instance de la blacklist de cette maniere :

Code C# :

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

1
2
3
4
5
public BlackList BlackList(SerializationInfo info, StreamingContext context)
{
            this.ListBlackListNumber = (List<BlackListNumber>)info.GetValue("ListBlackListNumber", typeof(List<BlackListNumber>));
            return (BlackList)info.GetValue("instance", typeof(BlackList));
}

Apres c'est a toi de revoir ta conception et de voir ce que tu va en faire.

Cordialement.

[cybermaxs]

ou plus simplement enlever le readonly du champ ...

[adrien1]

Merci pour les infos

Par contre, sera-t-il toujours thread-safe?

[worm83]

Non il ne sera plus Thread safe.


Mais tu peut implementer un vrai pattern Singleton.

http://www.yoda.arachsys.com/csharp/singleton.html

[cybermaxs]

Non il ne sera plus Thread safe.


Mais tu peut implementer un vrai pattern Singleton.

http://www.yoda.arachsys.com/csharp/singleton.html

+1
J'ai souvent fait appel à cet article pour mes implémentations.

Il aurait peut être thread safe si tu utilisais un constructeur statique.

[adrien1]

merci pour le site mais j'ai deja regarde,ca me pose probleme en cas de (de)serialisation

[worm83]

Excuse moi, mais qu'est ce qui t as posé problème ??

Car j'ai déjà sérialise des instance "singleton" (d'ailleurs en ce moment je bosse sur ça) et ça ne m'a jamais posé problème....

[adrien1]

Sérialiser ma classe dans un fichier ne me pose pas de probleme.
C'est la désérialiser depuis ce fichier.

pour que mon singleton soit thread safe il faut utiliser du read-only et ca sa marche pas

[worm83]

En fait il faut que tu encapsule ton objet BlackList dans un espèce de BlackListControler qui lui sera un singleton et qui gerea l'acces à la blackListe

[adrien1]

ok
Aurais-tu de la doc sur ca car je ne connais pas

[worm83]

en rentrant je t'ecrit un exemple

[worm83]

re bon je vais essaye de t'expliquer par l'exemple pour que tu voit le principe :

donc l'idee est la suivante tu fait d'abord une classe BlackListe normale serializable

Code C# :

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

1
2
3
4
5
[Serializable()]
public class BlackList
{
//Code
}

ensuite tu creer ton "manager" qui est singleton et qui va s'occupper d'encapsuler ta classe blacklist et surtout de la concurence des threads

Code C# :

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
63
64
65
public class BlackListControler
{
private static readonly object SynchInstance = new object();
 
private static readonly object SynchList = new object();
 
 
//Encapsulation de la BlackList
private BlackList _Liste {get; set;}
public BlackList Liste 
{
   get
   {
      lock(SynchList)
      {
         return this._Liste;
      }
   }
   set
   {
      lock(SynchList)
      {
         this.Liste= value;
      }
   }
}
 
//Instance du controler
private static BlackListControler _Instance =null;
 
//Accesseur de l'instance implementation du Singleton
public static BlackListControler Instance
{
   get
   {
           lock (SynchInstance)
           {
                if (BlackListControler._Instance == null)
                   lock (SynchInstance)
                   {
                        BlackListControler._Instance = new BlackListControler();
                    }
                    return BlackListControler._Instance;
            }
   }
}
 
//Constructeur privé
private BlackListeControler()
{
//Initialisation des valeur
this.deserialiseList();
}
 
private void deserialiseList()
{
  //deserialisation
this.Liste = (BlackList)info.GetValue("instance", typeof(BlackList));
}
 
 
}
 
 
}

Voila grossièrement ce que j'essaye de t'expliquer.

Cordialement

Edit : dure d'ecrire du code un petit peu long la dedans