Notificar o uso e implementação de dependência de banco de dados extensível
Além de Dependência Extensível em Massa, NCache fornece outro método para dependência de cache chamado Dependência Extensível Baseada em Notificação ou Dependência de Banco de Dados Extensível de Notificação. No Notify Extensible Database Dependency, o lado do cliente é responsável por implantar um provedor que mantém a lógica por trás da dependência e quando invocar essa dependência.
Note
Este recurso está disponível apenas no NCache Enterprise para Servidores .NET.
O servidor então invoca o cache para métodos relacionados à dependência do banco de dados, considerando a lógica fornecida pelo cliente. O cache verifica itens em Notificar Dependência Extensível e se eles precisam ser removidos ou não.
Na Dependência Extensível Baseada em Notificação, os clientes têm todo o controle sobre quando e como chamar uma dependência em um item. Desta forma, os itens podem expirar do cache de uma forma extremamente flexível.
NCache fornece uma classe abstrata NotifyExtensibleDependency
, uma extensão de dependências personalizadas fornecidas por NCache, que implementa esse comportamento.
Dica
Consulte Dependências de cache personalizadas para se familiarizar com todos os métodos personalizados de dependência de cache fornecidos por NCache.
Pré-requisitos
- 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.
- O projeto deve ser implementado como uma biblioteca de classes (.dll) no Visual Studio. Isso será implantado em NCache grupo.
- Tenha certeza de Implantar provedores de dependência personalizados usando o NCache Centro de Gestão.
- A
NotifyExtensibleDependency
classe deve ser implantado no cache - Para detalhes da API, consulte: ICache, Item de cache, Adicionar, inserir, Eliminar, Dependência Personalizada, Criar Dependência, ICustomDependencyProvider, NotificarDependência Extensível, DependencyChangedHandler.
Note
Para obter informações detalhadas sobre os métodos implementados em NotifyExtensibleDependency
, consulte o De Depósito seção.
Etapa 1: implementar a classe NotifyExtensibleDependency
A primeira etapa para introduzir sua própria lógica para Notify Extensible Dependency é herdar o NotifyExtensibleDependency
classe.
Suponhamos que você queira adicionar clientes ao seu banco de dados Cosmos com sua própria lógica de dependência. Veja como implementar a Dependência Extensível de Notificação com Cosmos DB em seu aplicativo.
[Serializable]
public class NotificationDependency<T> : NotifyExtensibleDependency
{
// Class parameters
public NotificationDependency(/* */)
{
// Assign values to class members
}
public override bool Initialize()
{
// Register dependency against key
RegisterDependency(_key, this);
return true;
}
public bool RegisterDependency(string key, NotifyExtensibleDependency dependency)
{
lock (this)
{
// Your logic here
dependencies.Add(key, dependency);
}
return true;
}
public void OnFeedChange(params object[] args)
{
// Find the matching dependency and fire its DependencyChangedEvent
var key = args[0];
var notifyExtensibleDep = (dependencies[key] as NotifyExtensibleDependency);
notifyExtensibleDep?.DependencyChanged.Invoke(this);
// Remove the matched keys from cache
lock (dependencies)
{
dependencies.Remove(key);
}
}
protected override void DependencyDispose()
{
// Dispose off resources
}
// This class is to be deployed on NCache
}
Etapa 2: implementar o NotifyCustomDependencyProvider
Para implementar o provedor Notify Extensible Dependency em seu aplicativo, use o trecho de código a seguir.
public class NotifyCustomDependencyProvider : ICustomDependencyProvider
{
private string cacheName;
private string monitoredUri;
private string authKey;
private string databaseName;
public void Init(IDictionary<string, string> parameters, string cacheName)
{
// Initialize cache and class parameters
}
public NotificationDependency CreateDependency(string key, IDictionary<string, string> dependencyParameters)
{
string customerId="";
string monitoredCollection = "";
string leaseCollection = "";
if (dependencyParameters != null)
{
if (dependencyParameters.ContainsKey("Key"))
customerId = dependencyParameters["Key"];
if (dependencyParameters.ContainsKey("MonitoredCollectionName"))
monitoredCollection = dependencyParameters["MonitoredCollectionName"];
if (dependencyParameters.ContainsKey("LeaseCollectionName"))
leaseCollection = dependencyParameters["LeaseCollectionName"];
// Create notify extensible dependency
NotificationDependency<Customer> cosmosDbDependency = new NotificationDependency<Customer>(customerId,
monitoredUri, authKey, databaseName, monitoredCollection, databaseName, leaseCollection);
return cosmosDbDependency;
}
else
{
// Dependency parameters not found
}
}
public void Dispose ()
{
// Dispose off all resources
}
}
Etapa 3: implantar a implementação no cache
Implante esta classe e todos os outros assemblies dependentes em NCache referindo-se a Implantar provedores no Guia do Administrador para obter ajuda.
Etapa 4: usar a dependência extensível de notificação
Depois que a Dependência Extensível Baseada em Notificação tiver sido implementada e implantada no cache, ela estará pronta para ser usada em seu aplicativo. O código a seguir mostra como adicionar dados usando o inserção método com dependência personalizada baseada em notificação.
Note
No caso de cache do cliente, o usuário precisa implantar explicitamente esses assemblies no cache do cliente.
// Specify the connection credentials
string endPoint = ConfigurationManager.AppSettings["EndPoint"];
string authKey = ConfigurationManager.AppSettings["AuthKey"];
string monitoredCollection = ConfigurationManager.AppSettings["MonitoredCollection"];
string leaseCollection = ConfigurationManager.AppSettings["LeaseCollection"];
string databaseName = ConfigurationManager.AppSettings["DatabaseName"];
string providerName = ConfigurationManager.AppSettings["ProviderName"];
// Fetch a sample customer from the database
Customer customer = LoadCustomerFromDatabase(customerId);
// Specify the unique key of the item
string key = "Customer#" + customer.Id ;
// Create dictionary for dependency parameters
IDictionary<string, string> param = new Dictionary<string, string>();
param.Add("CustomerID", customer.Id);
param.Add("EndPOint", endPoint);
param.Add("AuthKey", authKey);
param.Add("MonitoredCollection", monitoredCollection);
param.Add("LeaseCollection", leaseCollection);
param.Add("DatabaseName", databaseName);
//Creating notification dependency
CustomDependency cosmosDbDependency = new CustomDependency(providerName, param);
// Create a cacheItem
var cacheItem = new CacheItem(customer);
cacheItem.Dependency = cosmosDbDependency;
// Add cacheItem to the cache with notification dependency
cache.Insert(key, cacheItem);
De Depósito
Inicializar()
Cada vez que um item é adicionado ao cache, o Initialize
O método é chamado para verificar se o cache tem uma conexão segura com a fonte de dados ou não. Se este método retornar verdadeiro, significa que o cache pode estabelecer uma conexão segura com a fonte de dados. Em seguida, ele coloca o item no armazenamento de valores-chave e na lista de dependências do cache até que precise ser removido.
Porém, caso este método retorne falso, mostra que a fonte de dados necessária para acessar e monitorar os dados não está disponível para o cache, portanto, esse item é removido do cache. O método de inicialização está disponível para todas as dependências extensíveis.
Dependência alterada()
Depois que um item é colocado com sucesso no cache, é necessário saber como invocar a dependência dele. Por isso, um delegado DependencyChanged
é usado. Um manipulador desse delegado é implantado no cache. O cliente consegue controlar quando chamar esse delegado e invocar a dependência de um item. Sempre que esse delegado é chamado, ele remove do cache o item contra o qual foi chamado.
Recursos adicionais
NCache fornece aplicativo de amostra para Dependência Extensível de Notificação em GitHub.
Veja também
.INTERNET: Alachisoft.NCache.Runtime.Dependências espaço para nome.