Implementar o Carregador e Atualizador de Cache
Para usar o Cache Startup Loader and Refresher, o ICacheLoader
a interface precisa ser implementada primeiro. Em seguida, a lógica personalizada do Loader e do Refresher pode ser configurada usando NCache Centro de Gerenciamento or Ferramentas de linha de comando. NCache carrega e atualiza dados da fonte de dados configurada com base na lógica personalizada. Na inicialização do cache, NCache chama o Init
método do Cache Startup Loader para inicializá-lo. Inicialização bem-sucedida do Cache Startup Loader, chama o implementado LoadDatasetOnStartup
método para carregar dados no cache. Em seguida, usa o Atualizar conjunto de dados método para atualizar os dados carregados no cache no determinado Intervalo de atualização.
No exemplo a seguir, o cliente implementa o ICacheLoader
interface para configurar sua lógica personalizada de carregador e atualização. Se você configurou dois conjuntos de dados do NCache Centro de Gerenciamento: Produtos e Fornecedores. As seguintes cargas de implementação Produtos e Fornecedores na inicialização do cache. Além disso, ele atualiza esses conjuntos de dados no intervalo de tempo de atualização especificado.
Para mais detalhes sobre os componentes do Cache Loader, consulte o capítulo Componentes do Carregador e Atualizador de Inicialização do Cache.
Pré-requisitos do carregador de cache e da atualização
- Para aprender sobre os pré-requisitos padrão necessários para trabalhar com todos os NCache recursos do lado do servidor, consulte a página fornecida em Pré-requisitos da API do lado do servidor.
- Para obter detalhes da API, consulte: ICache, Item de cache, ICacheLoaderName.
- Este deve ser um projeto de biblioteca de classes.
- Tenha certeza de configurar o Cache Loader usando o NCache Centro de gerenciamento ou ferramentas de linha de comando no NCache grupo.
Inicializar carregador e atualização de cache
O código a seguir mostra como implementar o Init
método do ICacheLoader
interface. Esse método recebe parâmetros como entrada e atribui valores a eles.
public void Init(IDictionary<string, string> parameters, string cacheName)
{
cache = CacheManager.GetCache(cacheName);
connectionString = parameters.ContainsKey("ConnectionString") ? parameters["ConnectionString"] : null;
if (connectionString != null)
{
connection = new SqlConnection(connectionString);
}
}
Note
Para garantir que a operação seja à prova de falhas, é recomendável lidar com possíveis exceções em seu aplicativo, conforme explicado em Como lidar com falhas.
Carregar dados na inicialização do cache
A seguinte implementação do LoadDatasetOnStartup
método busca um Produto da fonte de dados e os adiciona ao cache. O LoadDatasetOnStartup
retorna um contexto de usuário que contém as informações sobre os dados carregados no cache. Este método é chamado quando o cache começa a pré-carregar dados no cache.
public object LoadDatasetOnStartup(string dataset)
{
// Create a list of datasets to load at cache startup
IList<object> datasetToLoad;
switch (dataset.ToLower())
{
// If dataset is products, fetch products from data source to load in cache
case "products":
datasetToLoad = FetchProductsFromDataSource();
// Insert fetched products in the cache
foreach (var product in datasetToLoad)
{
string key = $"ProductID:{product.Id}";
cache.Insert(key, product);
}
break;
// If dataset is suppliers, fetch suppliers from data source to load in cache
case "suppliers":
datasetToLoad = FetchSuppliersFromDataSource();
// Insert fetched suppliers in the cache
foreach (var supplier in datasetToLoad)
{
string key = $"SupplierID:{supplier.Id}";
cache.Insert(key, supplier);
}
break;
default:
// Invalid dataset
}
// User context is the time at which datasets were loaded in the cache
object userContext = DateTime.Now;
return userContext;
}
Atualizar conjunto de dados
O código a seguir implementa como atualizar os dados que foram carregados no cache na inicialização sempre que o Cache Refresher é invocado. o Atualizar conjunto de dados método usa o contexto do usuário retornado pelo LoadDatasetOnStartup método para verificar quais dados atualizar.
public object RefreshDataset(string dataset, object userContext)
{
DateTime? lastRefreshTime;
switch (dataset.ToLower())
{
// If dataset is products, fetch updated products from data source
case "products":
lastRefreshTime = userContext as DateTime?;
IList<Product> productsToRefresh = FetchUpdatedProducts(lastRefreshTime) as IList<Product>;
// Insert updated products in the cache
foreach (var product in productsToRefresh)
{
string key = $"ProductID:{product.Id}";
CacheItem cacheItem = new CacheItem(product);
_cache.Insert(key, cacheItem);
}
break;
// If dataset is supplier, fetch updated suppliers from data source
case "suppliers":
lastRefreshTime = userContext as DateTime?;
IList<Supplier> suppliersToRefresh = FetchUpdatedSuppliers(lastRefreshTime) as IList<Supplier>;
// Insert updated suppliers in the cache
foreach (var supplier in suppliersToRefresh)
{
string key = $"SupplierID:{supplier.Id}";
CacheItem cacheItem = new CacheItem(supplier);
_cache.Insert(key, cacheItem);
}
break;
default:
// Invalid dataset
}
// User context is the time at which datasets were refreshed
userContext = DateTime.Now;
return userContext;
}
Obter conjuntos de dados para atualizar
A GetDatasetsToRefresh implementa a lógica personalizada para atualizar um conjunto de dados pré-configurado em tempo de execução com base no RefreshPreference
. Este método pega o contexto do usuário e atribui um AtualizarPreferência dependendo do conjunto de dados especificado.
public IDictionary<string, RefreshPreference> GetDatasetsToRefresh(IDictionary<string, object> userContexts)
{
DateTime? lastRefreshTime;
bool datasetHasUpdated;
// Create a dictionary for datasets to refresh with their Refresh Preference
IDictionary<string, RefreshPreference> DatasetsToRefresh = new Dictionary<string, RefreshPreference>();
foreach (var dataset in userContexts.Keys)
{
switch (dataset.ToLower())
{
// If dataset is products, check if dataset has been updated in data source
// if yes, then refresh the dataset now
case "products":
lastRefreshTime = userContexts[dataset] as DateTime?;
datasetHasUpdated = HasProductDatasetUpdated(dataset, lastRefreshTime);
if (datasetHasUpdated)
{
DatasetsToRefresh.Add(dataset, RefreshPreference.RefreshNow);
}
break;
// If dataset is suppliers, check if dataset has been updated in data source
// if yes, then refresh dataset on next time of day
case "suppliers":
lastRefreshTime = userContexts[dataset] as DateTime?;
datasetHasUpdated = HasSupplierDatasetUpdated(dataset, lastRefreshTime);
if (datasetHasUpdated)
{
DatasetsToRefresh.Add(dataset, RefreshPreference.RefreshOnNextTimeOfDay);
}
break;
default:
// Invalid dataset
}
}
// Return the dictionary containing datasets to refresh on polling with their refresh preferences
return DatasetsToRefresh;
}
Descarte todos os recursos
Ao final, chamando o Dispose
O método garante que você fechou/excluiu todos os recursos para evitar desperdício.
Note
Configurar o carregador/atualizador de cache ativado NCache referindo-se a Configurar o Carregador e Atualizador de Cache no Guia do Administrador para obter ajuda.
Recursos adicionais
NCache fornece um aplicativo de exemplo para Cache Loader e Refresher em GitHub.
Veja também
.INTERNET: Alachisoft.NCache.Tempo de execução espaço para nome.
Java: com.alachisoft.ncache.runtime.cacheloader espaço para nome.