コード例 #1
0
 public void LeereCache()
 {
     try
     {
         lock (this._cacheLock)
         {
             while (this._container.Count > 0)
             {
                 ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer = this._container[0];
                 this._container.Remove(objectCacheContainer);
                 objectCacheContainer.Dispose();
             }
         }
     }
     catch (Exception ex)
     {
     }
 }
コード例 #2
0
 public void LeereCache()
 {
     try
     {
         object cacheLock = this._cacheLock;
         Monitor.Enter(cacheLock);
         try
         {
             while (this._container.Count > 0)
             {
                 ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer = this._container[0];
                 this._container.Remove(objectCacheContainer);
                 objectCacheContainer.Dispose();
             }
         }
         finally
         {
             Monitor.Exit(cacheLock);
         }
     }
     catch (Exception)
     {
     }
 }
コード例 #3
0
        public ObjektTyp GetCacheObjekt(KeyTyp key, object referenzObjekt, ObjektSerialisiererVerwaltung <ObjektTyp> .WasTunWennObjektNichtVorhanden wasTunWennNull)
        {
            ObjektTyp objekt = default(ObjektTyp);

            if (!this.NichtCachen)
            {
                try
                {
                    for (int num = this._container.Count - 1; num >= 0; num--)
                    {
                        if (DateTime.UtcNow.Ticks > this._container[num].VerfallsZeitpunktTicks)
                        {
                            object cacheLock = this._cacheLock;
                            Monitor.Enter(cacheLock);
                            try
                            {
                                ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer = this._container[num];
                                this._container.Remove(objectCacheContainer);
                                objectCacheContainer.Dispose();
                            }
                            finally
                            {
                                Monitor.Exit(cacheLock);
                            }
                        }
                    }
                }
                catch (Exception)
                {
                    string text = "";
                }
                foreach (ObjectCacheContainer <ObjektTyp, KeyTyp> item in this._container)
                {
                    ObjektTyp objekt2 = item.GetObjekt(key);
                    if (objekt2 != null)
                    {
                        return(objekt2);
                    }
                }
            }
            NeuesObjektWirdBenoetigtEventArgs neuesObjektWirdBenoetigtEventArgs = new NeuesObjektWirdBenoetigtEventArgs(key, referenzObjekt, objekt, wasTunWennNull);

            this.NeuesObjektWirdBenoetigtEventWerfen(neuesObjektWirdBenoetigtEventArgs);
            objekt = neuesObjektWirdBenoetigtEventArgs.Objekt;
            if (!this.NichtCachen && objekt != null)
            {
                ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer2 = null;
                if (this._container.Count == 0)
                {
                    objectCacheContainer2 = new ObjectCacheContainer <ObjektTyp, KeyTyp>(DateTime.UtcNow + this.MaxObjektLebensdauer);
                    this._container.Add(objectCacheContainer2);
                }
                else
                {
                    int num2 = 0;
                    try
                    {
                        while (objectCacheContainer2 == null && num2 < this._container.Count)
                        {
                            objectCacheContainer2 = this._container[num2];
                            if (objectCacheContainer2.AnzahlObjekte >= this._maxObjekteProContainer)
                            {
                                objectCacheContainer2 = null;
                            }
                            num2++;
                        }
                    }
                    catch (Exception)
                    {
                        string text2 = "";
                    }
                    if (objectCacheContainer2 == null)
                    {
                        object cacheLock2 = this._cacheLock;
                        Monitor.Enter(cacheLock2);
                        try
                        {
                            objectCacheContainer2 = new ObjectCacheContainer <ObjektTyp, KeyTyp>(DateTime.UtcNow + this.MaxObjektLebensdauer);
                            this._container.Add(objectCacheContainer2);
                            while (this._container.Count > this._maxContainer)
                            {
                                ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer3 = this._container[0];
                                this._container.Remove(objectCacheContainer3);
                                objectCacheContainer3.Dispose();
                            }
                        }
                        finally
                        {
                            Monitor.Exit(cacheLock2);
                        }
                    }
                }
                objectCacheContainer2.AddObjekt(key, objekt);
            }
            if (objekt == null)
            {
                switch (wasTunWennNull)
                {
                case ObjektSerialisiererVerwaltung <ObjektTyp> .WasTunWennObjektNichtVorhanden.FehlerWerfen:
                    throw new ApplicationException("Es konnte kein Objekt für den key '" + key + "' bereitgestellt werden!");

                default:
                    throw new ApplicationException("Unbehandeltes ObjektCacheFehlerBeiNullObjekt '" + wasTunWennNull + "' bei wasTunWennNull für key '" + key + "'!");

                case ObjektSerialisiererVerwaltung <ObjektTyp> .WasTunWennObjektNichtVorhanden.NullZurueckgeben:
                    break;
                }
            }
            return(objekt);
        }
コード例 #4
0
        public ObjektTyp GetCacheObjekt(
            KeyTyp key,
            object referenzObjekt,
            ObjektSerialisiererVerwaltung <ObjektTyp> .WasTunWennObjektNichtVorhanden wasTunWennNull)
        {
            ObjektTyp objekt1 = default(ObjektTyp);

            if (!this.NichtCachen)
            {
                try
                {
                    for (int index = this._container.Count - 1; index >= 0; --index)
                    {
                        if (DateTime.UtcNow.Ticks > this._container[index].VerfallsZeitpunktTicks)
                        {
                            lock (this._cacheLock)
                            {
                                ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer = this._container[index];
                                this._container.Remove(objectCacheContainer);
                                objectCacheContainer.Dispose();
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                }
                foreach (ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer in this._container)
                {
                    ObjektTyp objekt2 = objectCacheContainer.GetObjekt(key);
                    if ((object)objekt2 != null)
                    {
                        return(objekt2);
                    }
                }
            }
            ObjektCache <KeyTyp, ObjektTyp> .NeuesObjektWirdBenoetigtEventArgs eventArgs = new ObjektCache <KeyTyp, ObjektTyp> .NeuesObjektWirdBenoetigtEventArgs(key, referenzObjekt, objekt1, wasTunWennNull);

            this.NeuesObjektWirdBenoetigtEventWerfen(eventArgs);
            ObjektTyp objekt3 = eventArgs.Objekt;

            if (!this.NichtCachen && (object)objekt3 != null)
            {
                ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer1 = (ObjectCacheContainer <ObjektTyp, KeyTyp>)null;
                if (this._container.Count == 0)
                {
                    objectCacheContainer1 = new ObjectCacheContainer <ObjektTyp, KeyTyp>(DateTime.UtcNow + this.MaxObjektLebensdauer);
                    this._container.Add(objectCacheContainer1);
                }
                else
                {
                    int index = 0;
                    try
                    {
                        for (; objectCacheContainer1 == null && index < this._container.Count; ++index)
                        {
                            objectCacheContainer1 = this._container[index];
                            if (objectCacheContainer1.AnzahlObjekte >= this._maxObjekteProContainer)
                            {
                                objectCacheContainer1 = (ObjectCacheContainer <ObjektTyp, KeyTyp>)null;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                    if (objectCacheContainer1 == null)
                    {
                        lock (this._cacheLock)
                        {
                            objectCacheContainer1 = new ObjectCacheContainer <ObjektTyp, KeyTyp>(DateTime.UtcNow + this.MaxObjektLebensdauer);
                            this._container.Add(objectCacheContainer1);
                            while ((long)this._container.Count > this._maxContainer)
                            {
                                ObjectCacheContainer <ObjektTyp, KeyTyp> objectCacheContainer2 = this._container[0];
                                this._container.Remove(objectCacheContainer2);
                                objectCacheContainer2.Dispose();
                            }
                        }
                    }
                }
                objectCacheContainer1.AddObjekt(key, objekt3);
            }
            if ((object)objekt3 == null)
            {
                switch (wasTunWennNull)
                {
                case ObjektSerialisiererVerwaltung <ObjektTyp> .WasTunWennObjektNichtVorhanden.FehlerWerfen:
                    throw new ApplicationException("Es konnte kein Objekt für den key '" + (object)key + "' bereitgestellt werden!");

                case ObjektSerialisiererVerwaltung <ObjektTyp> .WasTunWennObjektNichtVorhanden.NullZurueckgeben:
                    break;

                default:
                    throw new ApplicationException("Unbehandeltes ObjektCacheFehlerBeiNullObjekt '" + (object)wasTunWennNull + "' bei wasTunWennNull für key '" + (object)key + "'!");
                }
            }
            return(objekt3);
        }