PersistenceManager

The following table describes the region attributes that can be configured for the SQLite persistence manager.

The following is an example of how to specify the following region attributes in your client's cache.xml:

<region-attributes>
   <persistence-manager library-name="libSqLiteImpl.so" library-function-name="createSqLiteInstance">
      <properties>
         <property name="PersistenceDirectory" value="/xyz"/>
         <property name="PageSize" value="65536"/>
         <property name="MaxPageCount" value="1073741823"/>
      </properties>
   </persistence-manager>
</region-attributes>

To load the SQLite persistence manager plug-in for .NET applications, you can configure it either in your client's cache.xml or programmatically using the .NET API:

<persistence-manager library-name="Gemstone.Gemfire.Plugins.SqLite" 
   library-function-name="GemStone.GemFire.Plugins.SqLite.SqLiteImpl&lt;System.Object, System.Object&gt;.Create"> 
    <properties>
       <property name="PersistenceDirectory" value="SqLite"/>
       <property name="MaxPageCount" value="1073741823"/>
       <property name="PageSize" value="65536"/>
    </properties>
</persistence-manager>

When developing .NET managed applications, you can use the IPersistenceManager managed interface to implement your own persistence manager. The following code sample provides the IPersistenceManager interface:

/// <summary> 
/// IPersistenceManager interface for persistence and overflow. 
/// This class abstracts the disk-related operations in case of persistence or overflow to disk. 
/// A specific disk storage implementation will implement all the methods described here. 
/// </summary> 
generic<class TKey, class TValue> 
public interface class IPersistenceManager 
 { 
   public: 
   /// <summary> 
   /// Called after an implementation object is created. Initializes all the implementation specific environments needed. 
   /// </summary> 
   /// <param name="region"> 
   /// Region for which this PersistenceManager is initialized. 
   /// </param> 
   /// <param name="diskProperties"> 
   /// Configuration Properties used by PersistenceManager implementation. 
   /// </param> 
   void Init(IRegion<TKey, TValue>^ region, Properties<String^, String^>^ diskProperties); 
   
   /// <summary> 
   /// Writes a key, value pair of region to the disk. The actual file or database related write operations should be implemented in this method. 
   /// </summary> 
   /// <param name="key"> 
   /// the key to write. 
   /// </param> 
   /// <param name="value"> 
   /// the value to write. 
   /// </param> 
   void Write(TKey key, TValue value); 

   /// <summary> 
   /// This method is not used. 
   /// </summary> 
   bool WriteAll(); 

   /// <summary> 
   /// Reads the value for the key from the disk. 
   /// </summary> 
   /// <param name="key"> 
   /// key for which the value has to be read. 
   /// </param> 
   TValue Read(TKey key); 

   /// <summary> 
   /// This method is not used. 
   /// </summary> 
   bool ReadAll(); 

   /// <summary> 
   /// Destroys the entry specified by the key in the argument. 
   /// </summary> 
   /// <param name="key"> 
   /// key of the entry which is being destroyed. 
   /// </param>
   void Destroy(TKey key); 

   /// <summary> 
   /// Closes the persistence manager instance. 
   /// </summary> 
   void Close(); 
}

The following is a sample interface implementation:

class MyPersistenceManager<TKey, TValue> : IPersistenceManager<TKey, TValue> 
   { 
      #region IPersistenceManager<TKey,TValue> Members
      public void Close() 
      { 
         throw new NotImplementedException(); 
      } 

      public void Destroy(TKey key) 
      { 
         throw new NotImplementedException(); 
      } 

      public void Init(IRegion<TKey, TValue> region, Properties<string, string> disk Properties) 
      { 
         throw new NotImplementedException(); 
      } 

      public TValue Read(TKey key) 
      { 
         throw new NotImplementedException(); 
      } 

      public void Write(TKey key, TValue value) 
      { 
         throw new NotImplementedException(); 
      } 

      public bool ReadAll() 
      { 
         throw new NotImplementedException(); 
      } 

      public bool WriteAll() 
      {
         throw new NotImplementedException(); 
      } 
      #endregion 
   }