1 Übersicht
Wenn wir das Programm ausführen, werden normalerweise einige Zwischendaten generiert, die zu einem späteren Zeitpunkt gelesen werden müssen. Dies erfordert, dass wir es an einem Ort speichern, der einen Hochgeschwindigkeitszugriff bietet. Die beste Wahl ist der Speicher. Aus diesem und vielen anderen Gründen müssen wir diesen Teil auf anderen Computern speichern, was zu einem verteilten Cache-Problem führt.
Tatsächlich stellt ein verteilter Cache im Grunde einen zusätzlichen Speicher für einen anderen Computer bereit, um beim Speichern und Suchen von Daten zu helfen.
2 Implementierungsmethoden
Erstellen Sie zunächst ein Sammlungsobjekt, das threadsicher sein sollte. Der Code lautet wie folgt
Code
1 öffentliche statische Klasse MemObject
2 {
3 statisches MemObject()
4 {
5 MemObjl = new Dictionary<string, object>();
6}
7
8 öffentliches statisches Wörterbuch<string, object> Get()
9 {
10 if (MemObjl == null)
11 MemObjl = new Dictionary<string, object>();
12 return MemObjl;
13}
14
15 public static void Add(string key, object obj)
16 {
17 Dictionary<string, object> obg = Get();
18 if (!obg.ContainsKey(key))
19 obg.Add(key, obj);
20}
einundzwanzig
22 public static void Remove(string key)
dreiundzwanzig {
24 Get().Remove(key);
25}
26
27 öffentliches statisches int Count()
28 {
29 return Get().Count;
30}
31
32 öffentliches statisches Objekt Get(string key)
33 {
34 Dictionary<string, object> obg = Get();
35 if (obg.ContainsKey(key))
36 return obg[key];
37 null zurückgeben;
38 }
39
40 öffentliche statische Bool-Exits (String-Schlüssel)
41 {
42 return Get().ContainsKey(key);
43}
44
45 privates statisches Dictionary<string, object> MemObjl;
46 }
Dann schließen wir es ab und rufen es aus der Ferne auf. Der Code lautet wie folgt
Code
1 öffentliche Klasse DataCatcher: MarshalByRefObject, ICarrier.ICarrier
2 {
3 public void Set(String-Schlüssel, Objektwert)
4 {
5 //if (Exits(key))
6 // Remove(key);
7 //MemObjl.Add(key, value);
8 MemObject.Add(key, value);
9}
10
11 öffentliche Bool-Exits (String-Schlüssel)
12 {
13 return MemObject.Exits(key);
14}
15
16 public void Remove(string key)
17 {
18 MemObject.Remove(key);
19}
20
21 public int Count()
zweiundzwanzig {
23 return MemObject.Count();
vierundzwanzig }
25
26 öffentliches Objekt Get(string key)
27 {
28 return MemObject.Get(key);
29 }
30}
Um ein Durchsickern unserer Geschäftslogik zu vermeiden, stellen wir dem Client eine Schnittstelle zum Aufrufen zur Verfügung
Code
1 öffentliche Schnittstelle ICarrier
2 {
3
4 void Remove(string key);
5
6 bool Exits(string key);
7
8 void Set(string key,object value);
9
10 Objekt Get(string key);
11
12 int Count();
13}
In Ordnung. Auf diese Weise ist unser serverseitiger Code vervollständigt.
Als nächstes veröffentlichen wir den Service, damit Kunden ihn anrufen können
Code
1 öffentliche Teilklasse SharpCatchedService: ServiceBase
2 {
3 öffentlicher SharpCatchedService()
4 {
5 InitializeComponent();
6}
7
8 protected override void OnStart(string[] args)
9 {
10 TcpChannel-Kanal = neuer TcpChannel(ConfigHelper.Port);
11 ChannelServices.RegisterChannel(channel, false);
12 RemotingConfiguration.RegisterWellKnownServiceType(typeof(DataCatcher),
13 „SharpCatched“, WellKnownObjectMode.Singleton);
14}
15
16 protected override void OnStop()
17 {
18}
19}
Auf diese Weise kann der Client über diese Schnittstelle auf Remote-Daten zugreifen.
Auf der Clientseite erhalten wir zunächst das Remote-Objekt
Code
öffentlicher statischer ICarrier Carrier()
{
ICarrier Carrier = (ICarrier)Activator.GetObject(typeof(ICarrier), "tcp://localhost:" + ConfigHelper.Port + "/SharpCatched");
Rückholträger;
}
Dann verpacken wir es
Code
1 öffentliche Klasse SharpCatchedAPI
2 {
3 ICarrier iCarrier;
4
5 public void Init()
6 {
7 icarrier = DoConnect.Carrier();
8}
9
10 public void Set(String-Schlüssel, Objektwert)
11 {
12icarrier.Set(key, value);
13}
14
15 public void Remove(string key)
16 {
17 icarrier.Remove(key);
18}
19
20 öffentliches Objekt Get(string key)
einundzwanzig {
22 return icarrier.Get(key);
dreiundzwanzig }
vierundzwanzig
25 öffentliche Bool-Exits (String-Schlüssel)
26 {
27 return icarrier.Exits(key);
28 }
29 }
3 Folgemaßnahmen
Die obige Implementierung ist die grundlegendste verteilte Cache-Lösung. Tatsächlich können wir diese Sammlung in andere Sammlungsobjekte wie HashTable konvertieren. Beim Starten des Objekts wird ein Daemon-Thread gestartet. Die Aufgabe dieses Prozesses besteht darin, das abgelaufene Cache-Objekt an ein Sammlungsobjekt anzuhängen und dann das Objekt zu durchlaufen, um das Cache-Objekt zu zerstören. Wir können das Objekt auch einmal hashen und es auf mehreren Cache-Servern speichern.