Beispiel #1
0
 internal object this[CacheObjType cacheType]
 {
     [SecurityCritical]
     get
     {
         InternalCacheItem[] cache = this.m_cache;
         int numItems = this.m_numItems;
         int index    = this.FindObjectPosition(cache, numItems, cacheType, false);
         if (index >= 0)
         {
             bool flag1 = BCLDebug.m_loggingNotEnabled;
             return(cache[index].Value);
         }
         bool loggingNotEnabled = BCLDebug.m_loggingNotEnabled;
         return(null);
     }
     [SecurityCritical]
     set
     {
         bool loggingNotEnabled = BCLDebug.m_loggingNotEnabled;
         lock (this)
         {
             int index = this.FindObjectPosition(this.m_cache, this.m_numItems, cacheType, true);
             if (index > 0)
             {
                 this.m_cache[index].Value = value;
                 this.m_cache[index].Key   = cacheType;
                 if (index == this.m_numItems)
                 {
                     this.m_numItems++;
                 }
             }
             else if (this.m_cache == null)
             {
                 bool flag2 = BCLDebug.m_loggingNotEnabled;
                 this.m_cache          = new InternalCacheItem[2];
                 this.m_cache[0].Value = value;
                 this.m_cache[0].Key   = cacheType;
                 this.m_numItems       = 1;
             }
             else
             {
                 bool flag3 = BCLDebug.m_loggingNotEnabled;
                 InternalCacheItem[] itemArray = new InternalCacheItem[this.m_numItems * 2];
                 for (int i = 0; i < this.m_numItems; i++)
                 {
                     itemArray[i] = this.m_cache[i];
                 }
                 itemArray[this.m_numItems].Value = value;
                 itemArray[this.m_numItems].Key   = cacheType;
                 this.m_cache = itemArray;
                 this.m_numItems++;
             }
         }
     }
 }
 private int FindObjectPosition(InternalCacheItem[] cache, int itemCount, CacheObjType cacheType, bool findEmpty)
 {
     if (cache != null)
     {
         if (itemCount > cache.Length)
         {
             itemCount = cache.Length;
         }
         for (int i = 0; i < itemCount; i++)
         {
             if (cacheType == cache[i].Key)
             {
                 return i;
             }
         }
         if (findEmpty && (itemCount < (cache.Length - 1)))
         {
             return (itemCount + 1);
         }
     }
     return -1;
 }
Beispiel #3
0
        internal Object this[CacheObjType cacheType] {
            [System.Security.SecurityCritical]  // auto-generated 
            get { 

                //Let's snapshot a reference to the array up front so that 
                //we don't have to worry about any writers.  It's important
                //to grab the cache first and then numItems.  In the event that
                //the cache gets cleared, m_numItems will be set to 0 before
                //we actually release the cache.  Getting it second will cause 
                //us to walk only 0 elements, but not to fault.
                InternalCacheItem[] cache = m_cache; 
                int numItems = m_numItems; 

                int position = FindObjectPosition(cache, numItems, cacheType, false); 
                if (position>=0) {
                    if (!BCLDebug.m_loggingNotEnabled)
                        LogAction(CacheAction.LookupItemHit, cacheType, cache[position].Value);
                    return cache[position].Value; 
                }
 
                //Couldn't find it -- oh, well. 
                if (!BCLDebug.m_loggingNotEnabled)
                    LogAction(CacheAction.LookupItemMiss, cacheType); 
                return null;
            }

            [System.Security.SecurityCritical]  // auto-generated 
            set {
                int position; 
 
                if (!BCLDebug.m_loggingNotEnabled)
                    LogAction(CacheAction.AddItem, cacheType, value); 
                lock(this) {
                    position = FindObjectPosition(m_cache, m_numItems, cacheType, true);
                    if (position>0) {
                        m_cache[position].Value = value; 
                        m_cache[position].Key = cacheType;
                        if (position==m_numItems) { 
                            m_numItems++; 
                        }
                        return; 
                    }

                    if (m_cache==null) {
                        if (!BCLDebug.m_loggingNotEnabled) 
                            LogAction(CacheAction.AllocateCache, cacheType);
                        //                        m_copying = true; 
                        m_cache = new InternalCacheItem[MinCacheSize]; 
                        m_cache[0].Value = value;
                        m_cache[0].Key = cacheType; 
                        m_numItems = 1;
                        //                        m_copying = false;
                    } else {
                        if (!BCLDebug.m_loggingNotEnabled) 
                            LogAction(CacheAction.GrowCache, cacheType);
 
                        //                        m_copying = true; 
                        InternalCacheItem[] tempCache = new InternalCacheItem[m_numItems * 2];
                        for (int i=0; i<m_numItems; i++) { 
                            tempCache[i] = m_cache[i];
                        }
                        tempCache[m_numItems].Value = value;
                        tempCache[m_numItems].Key = cacheType; 
                        m_cache = tempCache;
                        m_numItems++; 
                        //                        m_copying = false; 
                    }
                } 
            }
        }
Beispiel #4
0
        private int FindObjectPosition(InternalCacheItem[] cache, int itemCount, CacheObjType cacheType, bool findEmpty) { 
            if (cache==null) {
                return -1; 
            } 

            //This helps us in the case where we grabbed the cache and then 
            //somebody added an item, forced a reallocation, and hence made
            //itemCount greater than the length of cache.
            if (itemCount > cache.Length) {
                itemCount = cache.Length; 
            }
 
            for (int i=0; i<itemCount; i++) { 
                if (cacheType==cache[i].Key) {
                    return i; 
                }
            }
            if (findEmpty) {
                if (itemCount<(cache.Length-1)) { 
                    return itemCount + 1;
                } 
            } 
            return -1;
        } 
 internal object this[CacheObjType cacheType]
 {
     [SecurityCritical]
     get
     {
         InternalCacheItem[] cache = this.m_cache;
         int numItems = this.m_numItems;
         int index = this.FindObjectPosition(cache, numItems, cacheType, false);
         if (index >= 0)
         {
             bool flag1 = BCLDebug.m_loggingNotEnabled;
             return cache[index].Value;
         }
         bool loggingNotEnabled = BCLDebug.m_loggingNotEnabled;
         return null;
     }
     [SecurityCritical]
     set
     {
         bool loggingNotEnabled = BCLDebug.m_loggingNotEnabled;
         lock (this)
         {
             int index = this.FindObjectPosition(this.m_cache, this.m_numItems, cacheType, true);
             if (index > 0)
             {
                 this.m_cache[index].Value = value;
                 this.m_cache[index].Key = cacheType;
                 if (index == this.m_numItems)
                 {
                     this.m_numItems++;
                 }
             }
             else if (this.m_cache == null)
             {
                 bool flag2 = BCLDebug.m_loggingNotEnabled;
                 this.m_cache = new InternalCacheItem[2];
                 this.m_cache[0].Value = value;
                 this.m_cache[0].Key = cacheType;
                 this.m_numItems = 1;
             }
             else
             {
                 bool flag3 = BCLDebug.m_loggingNotEnabled;
                 InternalCacheItem[] itemArray = new InternalCacheItem[this.m_numItems * 2];
                 for (int i = 0; i < this.m_numItems; i++)
                 {
                     itemArray[i] = this.m_cache[i];
                 }
                 itemArray[this.m_numItems].Value = value;
                 itemArray[this.m_numItems].Key = cacheType;
                 this.m_cache = itemArray;
                 this.m_numItems++;
             }
         }
     }
 }
        internal Object this[CacheObjType cacheType] {
            get {
                //Let's snapshot a reference to the array up front so that
                //we don't have to worry about any writers.  It's important
                //to grab the cache first and then numItems.  In the event that
                //the cache gets cleared, m_numItems will be set to 0 before
                //we actually release the cache.  Getting it second will cause
                //us to walk only 0 elements, but not to fault.
                InternalCacheItem[] cache = m_cache;
                int numItems = m_numItems;

                int position = FindObjectPosition(cache, numItems, cacheType, false);
                if (position >= 0)
                {
                    LogAction(CacheAction.LookupItemHit, cacheType, cache[position].Value);
                    return(cache[position].Value);
                }

                //Couldn't find it -- oh, well.
                LogAction(CacheAction.LookupItemMiss, cacheType);
                return(null);
            }

            set {
                int position;

                LogAction(CacheAction.AddItem, cacheType, value);
                lock (this) {
                    position = FindObjectPosition(m_cache, m_numItems, cacheType, true);
                    if (position > 0)
                    {
                        m_cache[position].Value = value;
                        m_cache[position].Key   = cacheType;
                        if (position == m_numItems)
                        {
                            m_numItems++;
                        }
                        return;
                    }

                    if (m_cache == null)
                    {
                        LogAction(CacheAction.AllocateCache, cacheType);
                        //                        m_copying = true;
                        m_cache          = new InternalCacheItem[MinCacheSize];
                        m_cache[0].Value = value;
                        m_cache[0].Key   = cacheType;
                        m_numItems       = 1;
                        //                        m_copying = false;
                    }
                    else
                    {
                        LogAction(CacheAction.GrowCache, cacheType);

                        //                        m_copying = true;
                        InternalCacheItem[] tempCache = new InternalCacheItem[m_numItems * 2];
                        for (int i = 0; i < m_numItems; i++)
                        {
                            tempCache[i] = m_cache[i];
                        }
                        tempCache[m_numItems].Value = value;
                        tempCache[m_numItems].Key   = cacheType;
                        m_cache = tempCache;
                        m_numItems++;
                        //                        m_copying = false;
                    }
                }
            }
        }
        //This is a debugging-only function which verifies that the object is of the
        //the correct type and follows some arbitrary set of constraints.  Please
        //add any validation code which you require to the switch statement below.
        //
        //Note to Testing: These are not localized strings because this error checking
        //occurs only in the debug build and I don't want to push extra resources
        //into the build which are not going to be used for customers.
        [Conditional("_DEBUG")] private void OnValidate(InternalCacheItem item)
        {
            switch (item.Key)
            {
            case CacheObjType.ParameterInfo:
                if (!(item.Value is System.Reflection.ParameterInfo))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a ParameterInfo");
                }
                break;

            case CacheObjType.TypeName:
                if (!(item.Value is String))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
                }
                break;

            case CacheObjType.AssemblyName:
                if (!(item.Value is String))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
                }
                break;

            case CacheObjType.RemotingData:
                if (!(item.Value is RemotingCachedData))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a RemotingCacheData");
                }
                break;

            case CacheObjType.SerializableAttribute:
                if (!(item.Value is SerializableAttribute))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a SerializableAttribute");
                }
                break;

            case CacheObjType.FieldName:
                if (!(item.Value is String))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
                }
                break;

            case CacheObjType.FieldType:
                if (!(item.Value is Type))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null Type");
                }
                break;

            case CacheObjType.DefaultMember:
                if (!(item.Value is String))
                {
                    throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
                }
                break;

            default:
                throw new ArgumentException("Invalid caching type.  Please add " + item.Value + " to the validated types in InternalCache.");
            }
        }
Beispiel #8
0
 //This is a debugging-only function which verifies that the object is of the
 //the correct type and follows some arbitrary set of constraints.  Please
 //add any validation code which you require to the switch statement below.
 //
 //Note to Testing: These are not localized strings because this error checking
 //occurs only in the debug build and I don't want to push extra resources
 //into the build which are not going to be used for customers.
 [Conditional("_DEBUG")] private void OnValidate(InternalCacheItem item) {
     switch (item.Key) {
     case CacheObjType.ParameterInfo:
         if (!(item.Value is System.Reflection.ParameterInfo)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a ParameterInfo");
         }
         break;
     case CacheObjType.TypeName:
         if (!(item.Value is String)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
         }
         break;
     case CacheObjType.AssemblyName:
         if (!(item.Value is String)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
         }
         break;
     case CacheObjType.RemotingData:
         if (!(item.Value is RemotingCachedData)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a RemotingCacheData");
         }
         break;
     case CacheObjType.SerializableAttribute:
         if (!(item.Value is SerializableAttribute)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a SerializableAttribute");
         }
         break;
     case CacheObjType.FieldName:
         if (!(item.Value is String)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
         }
         break;
     case CacheObjType.FieldType:
         if (!(item.Value is Type)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null Type");
         }
         break;
     case CacheObjType.DefaultMember:
         if (!(item.Value is String)) {
             throw new ArgumentException("Invalid type for the internal cache.  " + item.Value + " requires a non-null String");
         }
         break;
     default:
         throw new ArgumentException("Invalid caching type.  Please add " + item.Value + " to the validated types in InternalCache.");
     }
 }