1 Visão Geral
Normalmente, quando executamos o programa, alguns dados intermediários serão gerados e esses dados intermediários precisarão ser lidos em algum momento no futuro. Isso exige que o armazenemos em um local que forneça acesso de alta velocidade. A melhor escolha é na memória. Por esse e muitos motivos, precisamos armazenar essa parte em outras máquinas, o que cria um problema de cache distribuído.
Na verdade, um cache distribuído basicamente fornece memória adicional para outra máquina ajudar a armazenar e localizar dados.
2 Métodos de implementação
Primeiro crie um objeto de coleção, que deve ser thread-safe. O código é o seguinte
Código
1 classe estática pública MemObject
2 {
3 MemObject estático()
4 {
5 MemObjl = novo Dicionário<string, objeto>();
6}
7
8 Dicionário estático público<string, objeto> Get()
9 {
10 se (MemObjl == nulo)
11 MemObjl = new Dicionário<string, objeto>();
12 retornam MemObjl;
13}
14
15 public static void Add (chave de string, objeto obj)
16 {
17 Dicionário<string, objeto> obg = Get();
18 se (!obg.ContainsKey(chave))
19 obg.Add(chave, obj);
20}
vinte e um
22 public static void Remove (chave de string)
vinte e três {
24 Get().Remover(chave);
25}
26
27 contagem interna estática pública()
28 {
29 return Get().Contagem;
30}
31
32 objeto estático público Get (chave de string)
33 {
34 Dicionário<string, objeto> obg = Get();
35 se (obg.ContainsKey(chave))
36 retornar obg[chave];
37 retorna nulo;
38}
39
40 saídas bool estáticas públicas (chave de string)
41 {
42 return Get().ContainsKey(chave);
43}
44
45 dicionário estático privado<string, objeto> MemObjl;
46}
Então finalizamos e chamamos remotamente. O código é o seguinte.
Código
1 classe pública DataCatcher: MarshalByRefObject, ICarrier.ICarrier
2 {
3 conjunto público vazio (chave de string, valor do objeto)
4 {
5 //if (Saída(chave))
6 // Remove(chave);
7 //MemObjl.Add(chave, valor);
8 MemObject.Add(chave, valor);
9}
10
11 saídas bool públicas (chave de string)
12 {
13 retorne MemObject.Exits(chave);
14}
15
16 public void Remove (chave de string)
17 {
18 MemObject.Remove(chave);
19}
20
21 Contagem interna pública()
vinte e dois {
23 return MemObject.Count();
vinte e quatro }
25
26 objeto público Get (chave de string)
27 {
28 retorne MemObject.Get(chave);
29}
30}
Para evitar vazamento de nossa lógica de negócios, disponibilizamos uma interface ao cliente para chamada
Código
1 interface pública ICarrier
2 {
3
4 void Remover (chave de string);
5
6 saídas bool (chave de string);
7
8 void Set (chave de string, valor do objeto);
9
10 objeto Get (chave de string);
11
12 int Contagem();
13}
tudo bem. Desta forma, nosso código do lado do servidor é concluído.
A seguir publicamos o serviço para os clientes ligarem
Código
1 classe parcial pública SharpCatchedService: ServiceBase
2 {
3SharpCatchedService público()
4 {
5 InicializarComponent();
6}
7
8 substituição protegida void OnStart(string[] args)
9 {
10 Canal TcpChannel = novo TcpChannel(ConfigHelper.Port);
11 ChannelServices.RegisterChannel(canal, falso);
12 RemotingConfiguration.RegisterWellKnownServiceType(typeof(DataCatcher),
13 "SharpCatched", WellKnownObjectMode.Singleton);
14}
15
16 substituição protegida void OnStop()
17 {
18}
19}
Desta forma, o cliente pode acessar dados remotos através desta interface.
No lado do cliente, primeiro obtemos o objeto remoto
Código
portadora pública estática ICarrier()
{
Operadora ICarrier = (ICarrier)Activator.GetObject(typeof(ICarrier), "tcp://localhost:" + ConfigHelper.Port + "/SharpCatched");
transportadora de retorno;
}
Então nós embalamos
Código
1 classe pública SharpCatchedAPI
2 {
3 ICarrier iCarrier;
4
5 inicialização pública vazia ()
6 {
7 icarrier = DoConnect.Carrier();
8}
9
10 conjunto de void público (chave de string, valor do objeto)
11 {
12icarrier.Set(chave, valor);
13}
14
15 public void Remove (chave de string)
16 {
17 icarrier.Remove(chave);
18}
19
20 objeto público Get (chave de string)
vinte e um {
22 retorne icarrier.Get(chave);
vinte e três }
vinte e quatro
25 saídas bool públicas (chave de string)
26 {
27 return icarrier.Exits(chave);
28}
29}
3 acompanhamento
A implementação acima é a solução de cache distribuído mais básica. Na verdade, podemos converter esta coleção em outros objetos de coleção, como HashTable. Um thread daemon é iniciado quando o objeto é iniciado. A tarefa desse processo é anexar o objeto de cache expirado a um objeto de coleção e, em seguida, percorrer o objeto para destruir o objeto de cache. Também podemos fazer hash do objeto uma vez e armazená-lo em vários servidores de cache.