public ItemUpdateCallbackTask(Broker parent, string key, short callBackId, bool notifyAsync, EventCacheItem item, EventCacheItem oldItem, BitSet flag,EventDataFilter dataFilter)
 {
     this._parent = parent;
     this._key = key;
     this._callBackId = callBackId;
     this._notifyAsync = notifyAsync;
     this._item = item;
     this._oldItem = oldItem;
     this._flag = flag;
     this._dataFilter = dataFilter;
 }
 public ItemRemoveCallBackTask(Broker parent, string key, short callBackId, object value, CacheItemRemovedReason reason, BitSet flag, bool notifyAsync, EventCacheItem item,EventDataFilter dataFilter)
 {
     this._parent = parent;
     this._key = key;
     this._callBackId = callBackId;
     this._value = value;
     this._reason = reason;
     this._flag = flag;
     this._notifyAsync = notifyAsync;
     this._item = item;
     this._dataFilter = dataFilter;
 }
Beispiel #3
0
 /// <summary>
 /// Decerements the reference count of the cache and performs application-defined tasks 
 /// associated with freeing, releasing, or resetting unmanaged resources.
 /// </summary>
 /// <remarks>
 /// The behavior of this method depends upon the cache's sharing mode (inproc/outproc) 
 /// specified in the configuration.
 /// <para>If the application uses the cache in <b>inproc</b> mode, calling Dispose closes the cache 
 /// and releases the resources used by it. If in a cluster the calling node leaves the 
 /// cluster as well. 
 /// </para>
 /// <para>If the application uses the cache in <b>outproc</b> mode, calling Dispose releases the 
 /// reference to the cache object. The cache itself remains operational and cluster remains intact. 
 /// </para>
 /// </remarks>
 public override void Dispose(bool disposing)
 {
     if (_broker != null)
     {
         _broker.Dispose(disposing);
         _broker = null;
     }
 }
Beispiel #4
0
        internal RemoteCache(string cacheId, Cache parent, CacheInitParams initParams, PerfStatsCollector2 perfStatsCol)
            : base()
        {
            _parent = parent;
            _perfStatsCollector = perfStatsCol;
            if (_parent != null)
            {
                _asyncListener = new CacheAsyncEventsListener(_parent.AsyncListener);
                _eventListener = new CacheEventsListener(_parent.EventListener);
            }

            _cacheId = cacheId;
            _broker = new Broker(this, initParams, perfStatsCol);
            // changed this for init param task
            RemoteServer server = _broker.GetInitialServer();
            _broker.StartServices(cacheId, server.IpString, server.Port);

            if (!_broker.IsConnected)
                throw new OperationFailedException("No server is available to process the request for " + _cacheId);
            if (initParams.ServerList != null && initParams.ServerList.Length > 0)
               _serverId = initParams.ServerList[0].Name;
        }
Beispiel #5
0
 public ReconnectTask(Broker parent, Connection connection)
 {
     connection.IsReconnecting = true;
     this._parent = parent;
     this._connection = connection;
 }