1 Descripción general
Por lo general, cuando ejecutamos el programa, se generarán algunos datos intermedios y estos datos intermedios deberán leerse en algún momento en el futuro. Esto requiere que lo almacenemos en un lugar que proporcione acceso de alta velocidad. La mejor opción es la memoria. Por esta y muchas razones, necesitamos almacenar esta parte en otras máquinas, lo que crea un problema de caché distribuida.
De hecho, una caché distribuida básicamente proporciona memoria adicional para que otra máquina ayude a almacenar y encontrar datos.
2 métodos de implementación
Primero cree un objeto de colección, que debería ser seguro para subprocesos. El código es el siguiente.
Código
1 MemObject de clase estática pública
2 {
3 MemObject estático()
4 {
5 MemObjl = nuevo Diccionario<cadena, objeto>();
6}
7
8 Diccionario estático público <cadena, objeto> Obtener ()
9 {
10 si (MemObjl == nulo)
11 MemObjl = nuevo Diccionario<cadena, objeto>();
12 devolver MemObjl;
13}
14
15 Agregar vacío estático público (clave de cadena, objeto obj)
16 {
17 Diccionario<cadena, objeto> obg = Get();
18 si (!obg.ContainsKey(clave))
19 obg.Add(clave, obj);
20}
veintiuno
22 eliminación de vacío estático público (clave de cadena)
veintitrés {
24 Obtener().Quitar(clave);
25}
26
27 público estático int Count()
28 {
29 return Obtener().Count;
30}
31
32 objeto estático público Obtener (clave de cadena)
33 {
34 Diccionario<cadena, objeto> obg = Get();
35 si (obg.ContainsKey(clave))
36 return obg[clave];
37 devuelven nulo;
38 }
39
40 salidas bool estáticas públicas (clave de cadena)
41 {
42 return Get().ContainsKey(clave);
43}
44
45 Diccionario estático privado<cadena, objeto> MemObjl;
46 }
Luego lo resumimos y lo llamamos de forma remota. El código es el siguiente.
Código
1 clase pública DataCatcher: MarshalByRefObject, ICarrier.ICarrier
2 {
3 conjunto público vacío (clave de cadena, valor de objeto)
4 {
5 //si (Sale(clave))
6 // Eliminar(clave);
7 //MemObjl.Add(clave, valor);
8 MemObject.Add (clave, valor);
9}
10
11 salidas de bool público (clave de cadena)
12 {
13 devolver MemObject.Exits(clave);
14}
15
16 eliminación pública de vacío (clave de cadena)
17 {
18 MemObject.Remove(clave);
19}
20
21 público int Contar()
Veintidós {
23 devuelve MemObject.Count();
veinticuatro}
25
26 objeto público Obtener (clave de cadena)
27 {
28 devolver MemObject.Get(clave);
29 }
30}
Para evitar fugas de nuestra lógica de negocios, proporcionamos una interfaz al cliente para llamar
Código
1 interfaz pública ICarrier
2 {
3
4 void Eliminar (clave de cadena);
5
6 bool Salidas (clave de cadena);
7
8 Conjunto vacío (clave de cadena, valor del objeto);
9
10 objeto Obtener (clave de cadena);
11
12 int Contar();
13}
está bien. De esta manera, se completa nuestro código del lado del servidor.
A continuación publicamos el servicio para que los clientes llamen
Código
1 clase parcial pública SharpCatchedService: ServiceBase
2 {
3 servicio público SharpCatched()
4 {
5 InicializarComponente();
6}
7
8 anulación protegida void OnStart (cadena [] argumentos)
9 {
10 canal TcpChannel = nuevo TcpChannel(ConfigHelper.Port);
11 ChannelServices.RegisterChannel (canal, falso);
12 Configuración remota.RegisterWellKnownServiceType(tipode(DataCatcher),
13 "SharpCatched", WellKnownObjectMode.Singleton);
14}
15
16 anulación protegida anulación OnStop()
17 {
18}
19}
De esta forma, el cliente puede acceder a datos remotos a través de esta interfaz.
Del lado del cliente, primero obtenemos el objeto remoto.
Código
Portador ICarrier estático público()
{
Operador ICarrier = (ICarrier)Activator.GetObject(typeof(ICarrier), "tcp://localhost:" + ConfigHelper.Port + "/SharpCatched");
transportista de devolución;
}
Luego lo empaquetamos
Código
1 clase pública SharpCatchedAPI
2 {
3 ICarrier iCarrier;
4
5 inicio público vacío ()
6 {
7 icarrier = DoConnect.Carrier();
8}
9
10 conjunto público vacío (clave de cadena, valor de objeto)
11 {
12icarrier.Set(clave, valor);
13}
14
15 eliminación pública de vacío (clave de cadena)
16 {
17 icarrier.Remove(clave);
18}
19
20 objeto público Obtener (clave de cadena)
veintiuno {
22 retorno icarrier.Get(clave);
veintitrés }
veinticuatro
25 salidas de bool público (clave de cadena)
26 {
27 retorno icarrier.Salidas(clave);
28 }
29 }
3 seguimiento
La implementación anterior es la solución de caché distribuida más básica. De hecho, podemos convertir esta colección en otros objetos de colección, como HashTable. Se inicia un hilo de demonio cuando se inicia el objeto. El trabajo de este proceso es agregar el objeto de caché caducado a un objeto de colección y luego atravesar el objeto para destruir el objeto de caché. También podemos aplicar hash al objeto una vez y almacenarlo en varios servidores de caché.