1 Aperçu
Habituellement, lorsque nous exécutons le programme, certaines données intermédiaires sont générées et ces données intermédiaires doivent être lues à un moment donné dans le futur. Cela nous oblige à le stocker dans un endroit offrant un accès à haut débit. Le meilleur choix est en mémoire. Pour cette raison et bien d’autres, nous devons stocker cette partie sur d’autres machines, ce qui crée un problème de cache distribué.
En fait, un cache distribué fournit essentiellement une mémoire supplémentaire à une autre machine pour l'aider à stocker et à rechercher des données.
2 Modalités de mise en œuvre
Créez d’abord un objet de collection, qui doit être thread-safe. Le code est le suivant
Code
1 classe statique publique MemObject
2 {
3 MemObject statique()
4 {
5 MemObjl = new Dictionary<string, object>();
6}
7
8 Dictionnaire statique public<string, object> Get()
9 {
10 si (MemObjl == null)
11 MemObjl = new Dictionary<string, object>();
12 renvoie MemObjl ;
13}
14
15 public static void Add (clé de chaîne, objet obj)
16 {
17 Dictionnaire<string, object> obg = Get();
18 si (!obg.ContainsKey(clé))
19 obg.Add(clé, obj);
20}
vingt-et-un
22 public static void Supprimer (clé de chaîne)
vingt-trois {
24 Get().Remove(clé);
25}
26
27 public statique int Count()
28 {
29 return Get().Count;
30}
31
32 objet statique public Get (clé de chaîne)
33 {
34 Dictionnaire<string, object> obg = Get();
35 si (obg.ContainsKey(key))
36 return obg[clé];
37 renvoie nul ;
38 }
39
40 sorties booléennes statiques publiques (clé de chaîne)
41 {
42 return Get().ContainsKey(key);
43}
44
45 Dictionnaire statique privé<string, object> MemObjl ;
46 }
Ensuite, nous le terminons et l'appelons à distance. Le code est le suivant.
Code
1 classe publique DataCatcher : MarshalByRefObject, ICarrier.ICarrier
2 {
3 public void Set (clé de chaîne, valeur de l'objet)
4 {
5 //if (Sortie(clé))
6 // Supprimer (clé);
7 //MemObjl.Add(clé, valeur);
8 MemObject.Add(clé, valeur);
9}
10
11 sorties booléennes publiques (clé de chaîne)
12 {
13 return MemObject.Exits(key);
14}
15
16 public void Supprimer (clé de chaîne)
17 {
18 MemObject.Remove(clé);
19}
20
21 public int Nombre()
vingt-deux {
23 return MemObject.Count();
vingt-quatre }
25
26 objet public Get (clé de chaîne)
27 {
28 return MemObject.Get(clé);
29 }
30}
Afin d'éviter les fuites de notre logique métier, nous fournissons une interface au client pour appeler
Code
1 interface publique ICarrier
2 {
3
4 void Remove (clé de chaîne);
5
6 booléens Sorties (clé de chaîne);
7
8 void Set (clé de chaîne, valeur de l'objet);
9
10 objet Get(clé de chaîne);
11
12 int Nombre();
13}
Très bien. De cette façon, notre code côté serveur est complété.
Ensuite, nous publions le service que les clients peuvent appeler
Code
1 classe partielle publique SharpCatchedService : ServiceBase
2 {
3 SharpCatchedService public()
4 {
5 InitializeComponent();
6}
7
8 remplacement protégé void OnStart (string[] args)
9 {
10 Canal TcpChannel = nouveau TcpChannel (ConfigHelper.Port) ;
11 ChannelServices.RegisterChannel(canal, faux);
12 RemotingConfiguration.RegisterWellKnownServiceType(typeof(DataCatcher),
13 "SharpCatched", WellKnownObjectMode.Singleton);
14}
15
16 remplacement protégé void OnStop()
17 {
18}
19}
De cette manière, le client peut accéder aux données distantes via cette interface.
Côté client, nous récupérons d’abord l’objet distant
Code
public statique ICarrier Carrier()
{
Transporteur ICarrier = (ICarrier)Activator.GetObject(typeof(ICarrier), "tcp://localhost:" + ConfigHelper.Port + "/SharpCatched");
transporteur de retour ;
}
Ensuite, nous l'emballons
Code
1 classe publique SharpCatchedAPI
2 {
3 ICarrier iCarrier ;
4
5 Init public vide()
6 {
7 icarrier = DoConnect.Carrier();
8}
9
10 public void Set (clé de chaîne, valeur de l'objet)
11 {
12icarrier.Set(clé, valeur);
13}
14
15 public void Supprimer (clé de chaîne)
16 {
17 icarrier.Remove(clé);
18}
19
20 objets publics Get (clé de chaîne)
vingt-et-un {
22 return icarrier.Get(key);
vingt-trois }
vingt-quatre
25 sorties booléennes publiques (clé de chaîne)
26 {
27 return icarrier.Exits(clé);
28 }
29 }
3 suivis
L'implémentation ci-dessus est la solution de cache distribué la plus basique. En fait, nous pouvons convertir cette collection en d'autres objets de collection, tels que HashTable. Un thread démon est démarré au démarrage de l'objet. Le travail de ce processus consiste à ajouter l'objet de cache expiré à un objet de collection, puis à parcourir l'objet pour détruire l'objet de cache. Nous pouvons également hacher l'objet une fois et stocker l'objet sur plusieurs serveurs de cache.