ChangeMonitor Classe

Definição

public ref class ChangeMonitor abstract : IDisposable

public abstract class ChangeMonitor : IDisposable

type ChangeMonitor = class
    interface IDisposable

Public MustInherit Class ChangeMonitor
Implements IDisposable

Herança

Object

ChangeMonitor

Derivado

System.Runtime.Caching.CacheEntryChangeMonitor

System.Runtime.Caching.FileChangeMonitor

System.Runtime.Caching.SqlChangeMonitor

Implementações

IDisposable

Comentários

A ChangeMonitor classe é usada como a classe base para classes de monitor derivadas especializadas para implementações de cache específicas. Uma ChangeMonitor instância monitora as alterações no estado dos dados dos quais um item de cache depende. Por exemplo, o item pode ser um arquivo ou uma entidade de dados cujo conteúdo é armazenado em cache. Se a entidade de dados ou arquivo for atualizada, a entrada de cache associada também deverá ser alterada. Itens comuns que podem ser monitorados incluem entidades de dados (como campos de banco de dados, valores, linhas ou tabelas), outra entrada de cache e arquivos e atributos de arquivo.

Uma alteração de dependência é uma alteração no estado de uma dependência. Em uma implementação de cache típica, depois que uma ChangeMonitor instância notifica o cache de que uma dependência foi alterada, o cache executa a ação necessária, como invalidar a entrada de cache inserida.

Classes derivadas ChangeMonitor podem ser personalizadas para monitorar alterações de dependência para armazenamentos de dados diferentes específicos. Por exemplo, há implementações de cache para um sistema de arquivos, memória física ou um banco de dados. A ChangeMonitor classe examina as alterações que ocorrem fora do cache e, em seguida, alerta o cache de que as alterações ocorreram.

O .NET Framework inclui as seguintes classes derivadas da classe ChangeMonitor:

• CacheEntryChangeMonitor

• FileChangeMonitor

• HostFileChangeMonitor

• SqlChangeMonitor

Cada uma dessas classes funciona com diferentes tipos de dependências. Por exemplo, a classe derivada FileChangeMonitor monitora alterações em um cache para dados do sistema de arquivos (arquivos e pastas) dos quais o item de cache depende.

Notas aos Implementadores

Se você criar uma implementação de cache personalizada ou um tipo de monitor de alteração derivada, deverá seguir determinadas diretrizes. A lista a seguir resume essas diretrizes. Para obter mais informações, consulte a documentação de métodos ou propriedades individuais.

• O construtor de uma classe derivada deve definir a propriedade, iniciar o UniqueId monitoramento e chamar InitializationComplete() o método antes que o método retorne. Se um construtor encontrar um erro durante as construções e precisar descartar recursos, o construtor só poderá chamar a Dispose sobrecarga depois que o InitializationComplete() método for chamado porque a Dispose sobrecarga gerará uma InvalidOperationException exceção se a inicialização não for concluída.

• Se ocorrerem alterações nos dados que estão sendo monitorados antes da conclusão da inicialização, o construtor deverá chamar o OnChanged(Object) método antes de chamar o InitializationComplete() método.

• Depois que um tipo derivado ChangeMonitor for instanciado, você deverá inserir o monitor em uma implementação personalizada ObjectCache . Ou se terminar de usar o monitor de alteração, chame o Dispose método.

• Depois que uma ChangeMonitor instância é inserida em uma ObjectCache implementação, a ObjectCache instância exige que o monitor de alteração seja descartado. Mesmo que a inserção seja inválida e cause uma exceção, a ObjectCache implementação deverá chamar a Dispose sobrecarga.

• Depois que um monitor de alteração derivada é inserido em um cache, a ObjectCache implementação deve chamar NotifyOnChanged(OnChangedCallback), passando um OnChangedCallback objeto. O NotifyOnChanged(OnChangedCallback) método pode ser chamado apenas uma vez. Se uma alteração de dependência já tiver ocorrido, a OnChangedCallback instância será chamada imediatamente quando NotifyOnChanged(OnChangedCallback) for chamada. Caso contrário, a OnChangedCallback instância será chamada apenas uma vez. Essa chamada única ocorre quando o OnChanged(Object) método é chamado porque a ChangeMonitor instância detectou uma alteração ou quando o Dispose() método é chamado no , o ChangeMonitorque ocorrer primeiro.

• A OnChangedCallback instância fornecida por uma ObjectCache implementação deve remover a entrada de cache associada e especificar um motivo usando a DependencyChanged enumeração.

• Uma ChangeMonitor instância pode chamar o OnChanged(Object) método antes que uma implementação de cache tenha chamado NotifyOnChanged(OnChangedCallback) o método ou depois. Se o OnChanged(Object) método for chamado antes NotifyOnChanged(OnChangedCallback) de ser chamado, a implementação base ChangeMonitor notificará o cache de que isso ocorreu e disparará o retorno de chamada a NotifyOnChanged(OnChangedCallback) ser passado imediatamente quando NotifyOnChanged(OnChangedCallback) for invocado. Todos os dados de estado passados para o OnChanged(Object) método são salvos pelo monitor de alteração e, posteriormente, passados para o NotifyOnChanged(OnChangedCallback) método quando o NotifyOnChanged(OnChangedCallback) método é invocado.

• Um monitor de alteração deve implementar o Dispose(Boolean) método. Para obter mais informações, consulte a documentação do Dispose(Boolean) método.

• A Dispose() sobrecarga do método deve ser chamada para descartar a ChangeMonitor instância. As regras para chamar Dispose são as seguintes:

  • Antes que um item seja inserido no cache, é responsabilidade do chamador descartar uma ChangeMonitor instância.

  • Depois que o item de cache e as ChangeMonitor instâncias associadas a ele forem passados para um cache, o implementador de cache deverá verificar se o Dispose método é chamado, mesmo se a inserção falhar.

  • Depois que um item e suas instâncias associadas ChangeMonitor são passados para um cache, o chamador não deve descartar a dependência porque, quando o Dispose método é chamado, a chamada é tratada como se a dependência tivesse sido alterada. Como resultado, o OnChanged(Object) método é invocado automaticamente.

• Levando essas regras em consideração, o Dispose método deve ser chamado de uma das seguintes maneiras:

  • Os usuários devem chamar a sobrecarga do Dispose() método se decidirem não inserir a instância derivada do monitor de alterações em um cache.

  • Se a implementação tentar inserir a instância do monitor de alterações em um cache de objetos, mas a inserção falhar, a implementação do cache será responsável por chamar a Dispose() sobrecarga. Quando a tentativa de inserção causa uma exceção, a implementação do cache deve descartar quaisquer dependências associadas.

  • Se a entrada de cache for removida, a implementação do cache também deverá descartar a dependência.

  • A implementação interna do OnChanged(Object) método chama automaticamente o Dispose método depois que ele chama um retorno de chamada que é registrado por meio NotifyOnChanged(OnChangedCallback)de .

Observação: essa chamada automática para o método de descarte durante a ação de evento só ocorrerá se a inicialização da ChangeMonitor instância tiver sido concluída anteriormente.

Quando o construtor de um monitor de alteração derivada chama o InitializationComplete() método, se o estado do monitor de alteração já tiver sido alterado (ou seja, o estado monitorado já alterado quando o construtor ainda estava ativo), o InitializationComplete() método descartará automaticamente o monitor de alteração.

• A HasChanged propriedade é definida true como depois que o OnChanged(Object) método é chamado pela instância derivada do monitor de alterações, independentemente de um OnChangedCallback objeto ter sido definido por uma chamada para o NotifyOnChanged(OnChangedCallback) método ou não.

Acesso thread-safe

Esse tipo é thread safe.

Confira também

• System.Web.Caching
• ObjectCache