ChangeMonitor Classe

Definição

Fornece uma classe base para um tipo personalizado derivado que monitora alterações no estado dos dados, ao qual um item de cache depende.Provides a base class for a derived custom type that monitors changes in the state of the data which a cache item depends on.

public ref class ChangeMonitor abstract : IDisposable
public abstract class ChangeMonitor : IDisposable
type ChangeMonitor = class
    interface IDisposable
Public MustInherit Class ChangeMonitor
Implements IDisposable
Herança
ChangeMonitor
Derivado
Implementações

Comentários

A classe ChangeMonitor é usada como a classe base para classes de monitor derivadas que são especializadas para implementações de cache específicas.The ChangeMonitor class is used as the base class for derived monitor classes that are specialized for particular cache implementations. Uma instância de ChangeMonitor monitora as alterações no estado dos dados dos quais um item de cache depende.A ChangeMonitor instance monitors changes in the state of data which a cache item depends on. Por exemplo, o item pode ser um arquivo ou uma entidade de dados cujo conteúdo é armazenado em cache.For example, the item can be a file or data entity whose contents are cached. Se o arquivo ou a entidade de dados for atualizada, a entrada de cache associada também deverá ser alterada.If the file or data entity is updated, the associated cache entry must be changed also. Itens comuns que podem ser monitorados incluem entidades de dados (como campos, valores, linhas ou tabelas de banco de dado), outra entrada de cache e arquivos e atributos de arquivo.Common items that can be monitored include data entities (such as database fields, values, rows, or tables), another cache entry, and files and file attributes.

Uma alteração de dependência é uma alteração no estado de uma dependência.A dependency change is a change in the state of a dependency. Em uma implementação de cache típica, depois que uma instância de ChangeMonitor 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.In a typical cache implementation, after a ChangeMonitor instance notifies the cache that a dependency has changed, the cache performs the required action, such as invalidating the inserted cache entry.

Classes ChangeMonitor derivadas podem ser personalizadas para monitorar alterações de dependência para repositórios de dados diferentes específicos.Derived ChangeMonitor classes can be customized to monitor dependency changes for specific different data stores. Por exemplo, há implementações de cache para um sistema de arquivos, memória física ou um banco de dados.For example, there are cache implementations for a file system, physical memory, or a database. A classe ChangeMonitor examina as alterações que ocorrem fora do cache e, em seguida, alerta o cache de que as alterações ocorreram.The ChangeMonitor class examines changes that occur outside the cache, and then alerts the cache that changes have occurred.

A .NET Framework.NET Framework inclui as seguintes classes que derivam da classe ChangeMonitor:The .NET Framework.NET Framework includes the following classes that derive from ChangeMonitor class:

Cada uma dessas classes funciona com diferentes tipos de dependências.Each of these classes works with different types of dependencies. Por exemplo, a classe FileChangeMonitor derivada monitora as alterações em um cache para dados do sistema de arquivos (arquivos e pastas) dos quais o item de cache depende.For example, the derived FileChangeMonitor class monitors changes to a cache for file system data (files and folders) that the cache item depends on.

Notas aos Implementadores

Se você criar uma implementação de cache Personalizada ou um tipo de monitor de alteração derivado, deverá seguir algumas diretrizes.If you create a custom cache implementation or a derived change monitor type, you must follow certain guidelines. A lista a seguir resume essas diretrizes.The following list summarizes these guidelines. Para obter mais informações, consulte a documentação para métodos ou propriedades individuais.For more information, see the documentation for individual methods or properties.

-O construtor de uma classe derivada deve definir a propriedade UniqueId, iniciar o monitoramento e chamar o método InitializationComplete() antes que o método retorne.- The constructor of a derived class must set the UniqueId property, begin monitoring, and call InitializationComplete() method before the method returns. Se um Construtor encontrar um erro durante construções e precisar descartar recursos, o Construtor só poderá chamar a sobrecarga de Dispose depois que o método InitializationComplete() for chamado porque a sobrecarga de Dispose gerará uma exceção de InvalidOperationException se a inicialização não for concluída.If a constructor encounters an error during constructions and must have to dispose of resources, the constructor can only call the Dispose overload after the InitializationComplete() method is called because the Dispose overload will throw an InvalidOperationException exception if initialization is not completed.

-Se ocorrerem alterações nos dados que estão sendo monitorados antes da conclusão da inicialização, o Construtor deverá chamar o método OnChanged(Object) antes de chamar o método InitializationComplete().- If changes occur in the data that is being monitored before initialization is complete, the constructor must call the OnChanged(Object) method before calling the InitializationComplete() method.

-Depois que um tipo de ChangeMonitor derivado é instanciado, você deve inserir o monitor em uma implementação de ObjectCache personalizada.- After a derived ChangeMonitor type is instantiated, you must insert the monitor into a custom ObjectCache implementation. Ou, se você tiver terminado de usar o monitor de alterações, chame o método Dispose.Or if you are finished using the change monitor, call the Dispose method.

-Depois que uma instância de ChangeMonitor é inserida em uma implementação de ObjectCache, a instância ObjectCache requer que o monitor de alterações seja Descartado.- After a ChangeMonitor instance is inserted into a ObjectCache implementation, the ObjectCache instance require that the change monitor is disposed. Mesmo que a inserção seja inválida e cause uma exceção, a implementação de ObjectCache deve chamar a sobrecarga de Dispose.Even if the insertion is invalid and causes an exception, the ObjectCache implementation must call the Dispose overload.

-Depois que um monitor de alteração derivado é inserido em um cache, a implementação de ObjectCache deve chamar NotifyOnChanged(OnChangedCallback), passando um objeto OnChangedCallback.- After a derived change monitor is inserted into a cache, the ObjectCache implementation must call NotifyOnChanged(OnChangedCallback), by passing a OnChangedCallback object. O método NotifyOnChanged(OnChangedCallback) pode ser chamado apenas uma vez.The NotifyOnChanged(OnChangedCallback) method can be called only one time. Se uma alteração de dependência já tiver ocorrido, a instância OnChangedCallback será chamada imediatamente quando NotifyOnChanged(OnChangedCallback) for chamado.If a dependency change has already occurred, the OnChangedCallback instance will be called immediately when NotifyOnChanged(OnChangedCallback) is called. Caso contrário, a instância de OnChangedCallback será chamada apenas uma vez.Otherwise, the OnChangedCallback instance will be called only one time. Essa chamada única ocorrerá quando o método OnChanged(Object) for chamado porque a instância ChangeMonitor detectou uma alteração ou quando o método Dispose() for chamado no ChangeMonitor, o que ocorrer primeiro.This one time call occurs either when the OnChanged(Object) method is called because the ChangeMonitor instance detected a change, or when the Dispose() method is called on the ChangeMonitor, whichever occurs first.

-A instância de OnChangedCallback fornecida por uma implementação de ObjectCache deve remover a entrada de cache associada e especificar um motivo usando a enumeração DependencyChanged.- The OnChangedCallback instance that is provided by an ObjectCache implementation should remove the associated cache entry and specify a reason by using the DependencyChanged enumeration.

-Uma instância de ChangeMonitor pode chamar o método OnChanged(Object) antes de uma implementação de cache ter chamado método NotifyOnChanged(OnChangedCallback) ou posterior.- A ChangeMonitor instance can call the OnChanged(Object) method either before a cache implementation has called NotifyOnChanged(OnChangedCallback) method or after. Se o método OnChanged(Object) for chamado antes de NotifyOnChanged(OnChangedCallback) ser chamado, a implementação de ChangeMonitor base notificará o cache de que isso ocorreu e disparará o retorno de chamada a ser passado para NotifyOnChanged(OnChangedCallback) imediatamente quando NotifyOnChanged(OnChangedCallback) for invocado.If the OnChanged(Object) method is called before NotifyOnChanged(OnChangedCallback) is called, the base ChangeMonitor implementation will notify the cache that this has occurred and will trigger the callback to be passed to NotifyOnChanged(OnChangedCallback) immediately when NotifyOnChanged(OnChangedCallback) is invoked. Todos os dados de estado que são passados para o método OnChanged(Object) são salvos pelo monitor de alterações e subsequentemente passados para o método NotifyOnChanged(OnChangedCallback) quando o método NotifyOnChanged(OnChangedCallback) é invocado.Any state data that is passed to the OnChanged(Object) method is saved by the change monitor and subsequently passed to the NotifyOnChanged(OnChangedCallback) method when the NotifyOnChanged(OnChangedCallback) method is invoked.

-Um monitor de alteração deve implementar o método Dispose(Boolean).- A change monitor must implement the Dispose(Boolean) method. Para obter mais informações, consulte a documentação do método Dispose(Boolean).For more information, see the Dispose(Boolean) method documentation.

-A sobrecarga do método de Dispose() deve ser chamada para descartar a instância de ChangeMonitor.- The Dispose() method overload must be called to dispose of the ChangeMonitor instance. As regras para chamar Dispose são as seguintes:The rules for calling Dispose are as follows: -Antes que um item seja inserido no cache, é responsabilidade do chamador descartar uma instância de ChangeMonitor.- Before an item is inserted into the cache, it is the responsibility of caller to dispose of a ChangeMonitor instance.

-Um item de cache e as instâncias de ChangeMonitor associadas a ele são passados para um cache, o implementador de cache deve garantir que o método Dispose seja chamado, mesmo que a inserção falhe.- Once cache item and the ChangeMonitor instances that are associated with it are passed to a cache, the cache implementer must make sure that the Dispose method is called, even if the insert fails.

-Depois que um item e suas instâncias de ChangeMonitor associadas são passados para um cache, o chamador não deve descartar a dependência porque, quando o método Dispose é chamado, a chamada é tratada como se a dependência fosse alterada.- After an item and its associated ChangeMonitor instances are passed to a cache, the caller must not dispose the dependency because when the Dispose method is called, the call is treated as if the dependency has changed. Como resultado, o método OnChanged(Object) é invocado automaticamente.As a result, the OnChanged(Object) method is automatically invoked.

-Levando essas regras em consideração, o método de Dispose deve ser chamado de uma das seguintes maneiras:- Taking these rules into consideration, the Dispose method must be called in one of the following ways: -Os usuários devem chamar a sobrecarga do método Dispose() se decidirem não inserir a instância derivada do monitor de alterações em um cache.- Users must call the Dispose() method overload if they decide not to insert the derived change-monitor instance into a cache.

-Se a implementação tentar inserir a instância do monitor de alteração em um cache de objetos, mas a inserção falhar, a implementação do cache será responsável por chamar a sobrecarga de Dispose().- If the implementation tries to insert the change-monitor instance into an object cache but the insertion fails, the cache implementation is responsible for calling the Dispose() overload. Quando a tentativa de inserção causa uma exceção, a implementação do cache deve descartar quaisquer dependências associadas.When the insertion attempt causes an exception, the cache implementation must dispose of any associated dependencies.

-Se a entrada de cache for removida, a implementação de cache também deverá descartar a dependência.- If the cache entry is removed, the cache implementation must also dispose of the dependency.

-A implementação interna do método OnChanged(Object) chama automaticamente o método Dispose depois que ele chama um retorno de chamada registrado por meio de NotifyOnChanged(OnChangedCallback).- The internal implementation of the OnChanged(Object) method automatically calls the Dispose method after it calls a callback that is registered through NotifyOnChanged(OnChangedCallback).


Essa chamada automática para o método Dispose durante o acionamento do evento só ocorrerá se a inicialização da instância de ChangeMonitor tiver sido concluída anteriormente.This automatic call to the dispose method during the event firing only occurs if the initialization of the ChangeMonitor instance was previously completed.

Quando um construtor do monitor de alteração derivado chama o método InitializationComplete(), se o estado do monitor de alteração já tiver sido alterado (ou seja, o estado monitorado já alterado quando o Construtor ainda estiver ativo), o método InitializationComplete() descartará automaticamente o monitor de alterações.When a derived change monitor's constructor calls the InitializationComplete() method, if the state of the change monitor has already changed (that is, the state that is monitored already changed when the constructor was still active) then the InitializationComplete() method will automatically dispose of the change monitor. -A propriedade HasChanged é definida como true depois que o método OnChanged(Object) é chamado pela instância derivada do monitor de alteração, independentemente de um objeto OnChangedCallback ter sido definido por uma chamada para o método NotifyOnChanged(OnChangedCallback) ou não.- The HasChanged property is set to true after the OnChanged(Object) method is called by the derived change-monitor instance, regardless of whether a OnChangedCallback object has been set by a call to the NotifyOnChanged(OnChangedCallback) method or not.

Construtores

ChangeMonitor()

Inicializa uma nova instância da classe ChangeMonitor.Initializes a new instance of the ChangeMonitor class. Esse construtor é chamado de construtores em classes derivadas para inicializar a classe base.This constructor is called from constructors in derived classes to initialize the base class.

Propriedades

HasChanged

Obtém um valor que indica que o estado monitorado pela classe ChangeMonitor foi alterado.Gets a value that indicates that the state that is monitored by the ChangeMonitor class has changed.

IsDisposed

Obtém um valor que indica que a instância derivada de uma classe ChangeMonitor foi descartada.Gets a value that indicates that the derived instance of a ChangeMonitor class is disposed.

UniqueId

Obtém um valor que representa a instância da classe ChangeMonitor.Gets a value that represents the ChangeMonitor class instance.

Métodos

Dispose()

Libera todos os recursos usados pela instância atual da classe ChangeMonitor.Releases all resources that are used by the current instance of the ChangeMonitor class.

Dispose(Boolean)

Libera todos os recursos gerenciados e não gerenciados e todas as referências à instância de ChangeMonitor.Releases all managed and unmanaged resources and any references to the ChangeMonitor instance. Essa sobrecarga deve ser implementada por classes de monitor de alteração derivadas.This overload must be implemented by derived change-monitor classes.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
InitializationComplete()

Chamado do construtor de classes derivadas para indicar que a inicialização foi concluída.Called from the constructor of derived classes to indicate that initialization is finished.

MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
NotifyOnChanged(OnChangedCallback)

Chamado pelos implementadores de cache para registrar um retorno de chamada e notificar uma instância de ObjectCache por meio do delegado de OnChangedCallback quando uma dependência tiver sido alterada.Called by Cache implementers to register a callback and notify an ObjectCache instance through the OnChangedCallback delegate when a dependency has changed.

OnChanged(Object)

Chamado por classes derivadas para gerar o evento quando uma dependência é alterada.Called by derived classes to raise the event when a dependency changes.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também