Esempio n. 1
0
        public IReadOnlyList <KeyValuePair <ClrObject, ClrObject> > GetKeyValuePair()
        {
            // bucketsObject is an array of 'bucket' struct
            var bucketsObject = TargetObject.ReadObjectField("buckets");

            var elementType    = bucketsObject.Type.ComponentType;
            var bucketKeyField = elementType.GetFieldByName("key");
            var bucketValField = elementType.GetFieldByName("val");
            var bucketsLength  = bucketsObject.AsArray().Length;
            var result         = new List <KeyValuePair <ClrObject, ClrObject> >();

            for (int bucketIndex = 0; bucketIndex < bucketsLength; bucketIndex++)
            {
                //var arrayProxy = new ArrayProxy(Context, bucketsObject);
                // TODO move to ArrayProxy
                var elementAddress = bucketsObject.Type.GetArrayElementAddress(bucketsObject.Address, bucketIndex);
                var keyObject      = bucketKeyField.ReadObject(elementAddress, true);

                if (!keyObject.IsNull)
                {
                    var valObject = bucketValField.ReadObject(elementAddress, true);

                    var kvp = new KeyValuePair <ClrObject, ClrObject>(keyObject, valObject);
                    result.Add(kvp);
                }
            }

            return(result);
        }
Esempio n. 2
0
        private IEnumerable <KeyValuePair <TKey, TValue> > EnumerateKeyValuePairs <TKey, TValue>(Func <ulong, ClrInstanceField, ClrInstanceField, KeyValuePair <TKey, TValue> > kvpBuilder)
        // where TKey : notnull
        {
            var entries       = TargetObject.ReadObjectField("entries");
            var entriesLength = entries.AsArray().Length;
            var componentType = entries.AsArray().Type.ComponentType;
            // Lower 31 bits of hash code, -1 if unused
            var hashCodeField = componentType.GetFieldByName("hashCode");
            // Index of next entry, -1 if last
            var nextField  = componentType.GetFieldByName("next");
            var keyField   = componentType.GetFieldByName("key");
            var valueField = componentType.GetFieldByName("value");

            // var entriesField = TargetObject.Type.GetFieldByName("entries");
            // var s = entriesField.ReadStruct(entries.Type.GetArrayElementAddress(entries, 0), true);

            for (int entryIndex = 0; entryIndex < Count; entryIndex++)
            {
                var elementAddress = entries.Type.GetArrayElementAddress(entries, entryIndex);

                var hashCode = hashCodeField.Read <int>(elementAddress, true);
                var next     = nextField.Read <int>(elementAddress, true);

                if (hashCode == -1 /* || (hashCode == 0 && next == 0)*/)
                {
                    continue;
                }

                yield return(kvpBuilder(elementAddress, keyField, valueField));
            }
        }
Esempio n. 3
0
        private int GetCount()
        {
            var tablesObject       = TargetObject.ReadObjectField("_tables");
            var countPerLockObject = tablesObject.ReadObjectField("_countPerLock"); // int[]

            var countPerLock = new ArrayProxy(Context, countPerLockObject);

            return(countPerLock.GetInt32Array().Sum());
        }
Esempio n. 4
0
        public IEnumerable <HttpWebRequestProxy> GetWaitListItems()
        {
            var waitList = new ListProxy(Context, TargetObject.ReadObjectField("m_WaitList"));

            foreach (var item in waitList.GetItems())
            {
                yield return(new HttpWebRequestProxy(Context, item.ReadObjectField("request")));
            }
        }
Esempio n. 5
0
        private int GetBusyCount()
        {
            var readDone        = TargetObject.ReadField <bool>("m_ReadDone");
            var reservedCount   = TargetObject.ReadField <int>("m_ReservedCount");
            var waitListObject  = TargetObject.ReadObjectField("m_WaitList");
            var waitListSize    = waitListObject.ReadField <int>("_size");
            var writeListObject = TargetObject.ReadObjectField("m_WriteList");
            var writeListSize   = writeListObject.ReadField <int>("_size");

            return((readDone ? 0 : 1) + 2 * (waitListSize + writeListSize) + reservedCount);
        }
Esempio n. 6
0
        public IEnumerable <ClrObject> GetItems()
        {
            if (Count == 0)
            {
                yield break;
            }

            var itemsProxy = new ArrayProxy(Context, TargetObject.ReadObjectField("_items"));
            var arrayItems = itemsProxy.GetItems();

            for (int itemIndex = 0; itemIndex < Count; itemIndex++)
            {
                yield return(arrayItems[itemIndex]);
            }
        }
Esempio n. 7
0
        private int GetCurrentConnections()
        {
            if (Context.IsCoreRuntime)
            {
                return(0);
            }

            var connectionGroupListObject       = TargetObject.ReadObjectField("m_ConnectionGroupList");
            var connectionGroupListProxy        = new HashtableProxy(Context, connectionGroupListObject);
            var connectionGroupListKeyValuePair = connectionGroupListProxy.GetKeyValuePair();

            int result = 0;

            foreach (var connectionGroupItem in connectionGroupListKeyValuePair)
            {
                var connectionListObject = connectionGroupItem.Value.ReadObjectField("m_ConnectionList");
                var connectionListProxy  = new ArrayListProxy(Context, connectionListObject);
                result += connectionListProxy.Count;
            }

            return(result);
        }
Esempio n. 8
0
        public IReadOnlyList <KeyValuePair <ClrObject, ClrObject> > GetKeyValuePair()
        {
            var bucketsObject = TargetObject.ReadObjectField("_tables").ReadObjectField("_buckets");
            var buckets       = new ArrayProxy(Context, bucketsObject);

            var result = new List <KeyValuePair <ClrObject, ClrObject> >();

            foreach (var bucketObject in buckets.GetItems())
            {
                var currentNodeObject = bucketObject;
                while (!currentNodeObject.IsNull)
                {
                    var keyObject = currentNodeObject.ReadObjectField("_key");
                    var valObject = currentNodeObject.ReadObjectField("_value");
                    var kvp       = new KeyValuePair <ClrObject, ClrObject>(keyObject, valObject);
                    result.Add(kvp);

                    currentNodeObject = currentNodeObject.ReadObjectField("_next");
                }
            }

            return(result);
        }
Esempio n. 9
0
        public IEnumerable <ConnectionProxy> GetConnections()
        {
            if (Context.IsCoreRuntime)
            {
                throw new CoreRuntimeNotSupportedException();
            }

            // TODO join logic with GetCurrentConnections
            var connectionGroupListObject = TargetObject.ReadObjectField("m_ConnectionGroupList");
            var connectionGroupListProxy  = new HashtableProxy(Context, connectionGroupListObject);

            var connectionGroupListKeyValuePair = connectionGroupListProxy.GetKeyValuePair();

            foreach (var connectionGroupItem in connectionGroupListKeyValuePair)
            {
                var connectionListProxy = new ArrayListProxy(Context, connectionGroupItem.Value.ReadObjectField("m_ConnectionList"));

                foreach (var connectionObject in connectionListProxy.GetItems())
                {
                    yield return(new ConnectionProxy(Context, connectionObject));
                }
            }
        }
Esempio n. 10
0
        public IReadOnlyDictionary <string, string[]> GetHeaders()
        {
            var entriesArrayObject = TargetObject
                                     .ReadObjectField("m_InnerCollection") // NameValueCollection
                                     .ReadObjectField("_entriesArray");    // ArrayList

            var entriesArrayProxy = new ArrayListProxy(Context, entriesArrayObject);

            var result = new Dictionary <string, string[]>();

            foreach (var headerObject in entriesArrayProxy.GetItems())
            {
                var headerName = headerObject.ReadStringField("Key");

                var itemsArrayObject = headerObject.ReadObjectField("Value").ReadObjectField("_items");
                var itemsArrayProxy  = new ArrayProxy(Context, itemsArrayObject);

                var values = itemsArrayProxy.GetStringArray();

                result.Add(headerName, values);
            }

            return(result);
        }