ClrDump: GetFieldNames can't find fields from interface type

fremag · fremag · commit 382919323a62 · 2016-09-24T15:34:48.000+02:00
Closes #140
diff --git a/MemoDummy/ComplexObject.cs b/MemoDummy/ComplexObject.cs
@@ -13,17 +13,24 @@ struct StructData
     public interface IMyInterface
     {
         int Id { get; }
+        double MyDoubleValue { get; }
     }
 
     public class MyInterfaceImpl_V1 : IMyInterface
     {
         private static int n = 0;
-        public int Id { get; }
-
+        protected int backfield_id;
+        public int Id {
+            get {
+                return backfield_id;
+            }
+        }
+        public double MyDoubleValue { get; set; }
         public string name;
         public MyInterfaceImpl_V1()
         {
-            Id = n++;
+            backfield_id = n++;
+            MyDoubleValue = backfield_id + 0.001;
             name = $"#{0:Id}";
         }
     }
@@ -33,6 +40,8 @@ public class MyInterfaceImpl_V2 : MyInterfaceImpl_V1
         public DateTime TimeStamp { get; set; }
         public MyInterfaceImpl_V2()
         {
+            backfield_id *= -1;
+            MyDoubleValue = backfield_id - 0.001;
             TimeStamp = DateTime.Now;
         }
     }
@@ -44,6 +53,26 @@ class InternalData
         public double X { get; set; }
         public double Y { get; set; }
     }
+    public abstract class AnAbstractType 
+    {
+        public abstract double AbstractDoubleProperty { get; }
+        public double MyDoubleProperty { get; set; }
+    }
+
+    public class AnAbstractTypeImpl : AnAbstractType
+    {
+        private static int n = 0;
+        public new double MyDoubleProperty { get; }
+        public override double AbstractDoubleProperty { get; }
+
+        public AnAbstractTypeImpl()
+        {
+            n++;
+            AbstractDoubleProperty = -n - 0.0005;
+            base.MyDoubleProperty = n + 0.0005;
+            this.MyDoubleProperty = n + 0.0006;
+        }
+    }
 
     internal class ComplexObject
     {
@@ -54,7 +83,7 @@ internal class ComplexObject
         internal StructData StructData => structData;
 
         double value;
-        InternalData data;
+        InternalData data; 
         bool isEven;
         DateTime date;
         TimeSpan time;
@@ -64,7 +93,7 @@ internal class ComplexObject
         int[] someInts;
         double[] someDoubles;
         IMyInterface myInterface;
-
+        AnAbstractType aFieldWithAbstractType;
         public ComplexObject()
         {
             id = n++;
@@ -102,7 +131,7 @@ public ComplexObject()
                 someDoubles[i] = 2 * (n + i);
             }
             myInterface = id % 2 == 0 ? new MyInterfaceImpl_V1() : new MyInterfaceImpl_V2();
+            aFieldWithAbstractType = new AnAbstractTypeImpl();
         }
-
     }
 }
diff --git a/MemoScope/Core/ClrDump.cs b/MemoScope/Core/ClrDump.cs
@@ -35,7 +35,7 @@ public class ClrDump : IClrDump
 
         public List<ClrHandle> Handles => Runtime.EnumerateHandles().ToList();
         public List<ulong> FinalizerQueueObjectAddresses => Runtime.EnumerateFinalizerQueueObjectAddresses().ToList();
-        public IEnumerable<IGrouping<ClrType, ulong>> FinalizerQueueObjectAddressesByType => Runtime.EnumerateFinalizerQueueObjectAddresses().GroupBy( address => GetObjectType(address));
+        public IEnumerable<IGrouping<ClrType, ulong>> FinalizerQueueObjectAddressesByType => Runtime.EnumerateFinalizerQueueObjectAddresses().GroupBy(address => GetObjectType(address));
         public IList<ClrThread> Threads => Runtime.Threads;
         public ClrThreadPool ThreadPool => Runtime.GetThreadPool();
         public List<ClrType> AllTypes => Heap.EnumerateTypes().ToList();
@@ -57,7 +57,7 @@ public Dictionary<int, ThreadProperty> ThreadProperties
         Dictionary<int, ThreadProperty> threadProperties;
         private readonly SingleThreadWorker worker;
         private ClrDumpCache cache;
-        
+
         public ClrDump(DataTarget target, string dumpPath, MessageBus msgBus)
         {
             Id = n++;
@@ -94,7 +94,7 @@ private void InitRuntime()
 
         public List<ClrType> GetTypes()
         {
-            List<ClrType> t = worker.Eval( () => t = AllTypes);
+            List<ClrType> t = worker.Eval(() => t = AllTypes);
             return t;
         }
 
@@ -110,7 +110,7 @@ internal void Dispose()
             logger.Debug("Cache dispose");
             cache.Dispose();
             logger.Debug("Runtime.DataTarget.Dispose");
-            Run( () => Runtime?.DataTarget?.Dispose());
+            Run(() => Runtime?.DataTarget?.Dispose());
             logger.Debug("Worker.Dispose");
             worker.Dispose();
         }
@@ -205,7 +205,7 @@ private object GetSimpleValueImpl(ulong address, ClrType type)
                 var value = SimpleValueHelper.GetSimpleValue(address, type, false);
                 return value;
             }
-            
+
             return address;
         }
 
@@ -225,28 +225,30 @@ public object GetFieldValue(ulong address, ClrType type, ClrInstanceField field)
             return obj;
         }
 
-        internal Dictionary<string, ClrType> GetFieldNames(ClrType type)
+        internal List<FieldInfo> GetFieldInfos(ClrType type)
         {
-            Dictionary<string, ClrType> fieldNames = Eval(() => GetFieldNamesImpl(type));
+            List<FieldInfo> fieldNames = Eval(() => GetFieldNamesImpl(type));
             return fieldNames;
         }
 
-        private Dictionary<string, ClrType> GetFieldNamesImpl(ClrType type)
+        private List<FieldInfo> GetFieldNamesImpl(ClrType type)
         {
-            var fieldNames = type.Fields.ToDictionary(f => f.Name, f => f.Type);
-            if( type.IsInterface)
+            var fieldNames = type.Fields.Select(f => new FieldInfo(f.Name, f.Type)).ToList();
+            if (type.IsInterface || type.IsAbstract)
             {
-                var properties = type.Methods.Where(meth => meth.Name.StartsWith("get_") && meth.IsVirtual);
-                foreach (var meth in properties)
+                foreach (var someType in Heap.EnumerateTypes())
                 {
-                    var propName = meth.Name.Substring("get_".Length);
-                    // BUG: this is not the real type of the field ! 
-                    // TODO: get the return type from the method
-                    fieldNames[propName] = meth.Type;
+                    if (type.IsInterface && someType.Interfaces.Any(interf => interf.Name == type.Name))
+                    {
+                        fieldNames.AddRange(GetFieldNamesImpl(someType));
+                    }
+                    if (type.IsAbstract && someType.BaseType == type)
+                    {
+                        fieldNames.AddRange(GetFieldNamesImpl(someType));
+                    }
                 }
-
             }
-            return fieldNames;
+            return fieldNames.Distinct().ToList();
         }
 
         public object GetFieldValueImpl(ulong address, ClrType type, List<ClrInstanceField> fields)
@@ -257,7 +259,7 @@ public object GetFieldValueImpl(ulong address, ClrType type, List<ClrInstanceFie
             {
                 var field = fields[i];
                 obj = obj[field];
-                if( obj.IsNull )
+                if (obj.IsNull)
                 {
                     return null;
                 }
@@ -272,7 +274,13 @@ public object GetFieldValueImpl(ulong address, ClrType type, List<string> fieldN
             for (int i = 0; i < fieldNames.Count; i++)
             {
                 var fieldName = fieldNames[i];
-                obj = obj[fieldName];
+                ClrInstanceField field = obj.GetField(fieldName);
+                if( field == null)
+                {
+                    return null;
+                }
+
+                obj = obj[field];
                 if (obj.IsNull)
                 {
                     return null;
@@ -313,7 +321,7 @@ public bool HasReferers(ulong address)
 
         public int CountReferers(ulong address)
         {
-            var count = cache.CountReferers(address) ;
+            var count = cache.CountReferers(address);
             return count;
         }
 
@@ -384,15 +392,15 @@ public ClrMethod GetMethodByHandle(ulong methodDescriptorPtr)
         }
 
         // Find the field in instance at address that references refAddress
-        public string GetFieldNameReference(ulong refAddress, ulong address, bool prefixWithType=false)
+        public string GetFieldNameReference(ulong refAddress, ulong address, bool prefixWithType = false)
         {
             return Eval(() => GetFieldNameReferenceImpl(refAddress, address, prefixWithType));
         }
 
         public string GetFieldNameReferenceImpl(ulong refAddress, ulong address, bool prefixWithType)
-        { 
+        {
             ClrType type = GetObjectTypeImpl(address);
-            if( type == null)
+            if (type == null)
             {
                 return "Unknown";
             }
@@ -504,16 +512,16 @@ public List<ClrRoot> GetClrRoots()
 
         public bool HasField(ClrType clrType)
         {
-            if( clrType.IsPrimitive)
+            if (clrType.IsPrimitive)
             {
                 return false;
             }
-            if ( clrType.Fields.Any())
+            if (clrType.Fields.Any())
             {
                 return true;
             }
 
-            if( clrType.IsInterface && clrType.Methods.Any(meth => meth.Name.StartsWith("get_"))) 
+            if (clrType.IsInterface && clrType.Methods.Any(meth => meth.Name.StartsWith("get_")))
             {
                 return true;
             }
@@ -531,4 +539,27 @@ public class ThreadProperty
         public int Priority { get; set; }
         public int ManagedId { get; set; }
     }
+
+    public class FieldInfo : IEquatable<FieldInfo>
+    {
+        public string Name { get; }
+        public ClrType FieldType { get; }
+        public FieldInfo(string name, ClrType fieldType)
+        {
+            Name = name;
+            FieldType = fieldType;
+        }
+        public bool Equals(FieldInfo fieldInfo)
+        {
+            return fieldInfo.Name == Name && fieldInfo.FieldType.Name == FieldType.Name;
+        }
+        public override bool Equals(object o )
+        {
+            return ((IEquatable<FieldInfo>)this).Equals((FieldInfo)o);
+        }
+        public override int GetHashCode()
+        {
+            return Name.GetHashCode() * 37 + FieldType.Name.GetHashCode();
+        }
+    }
 }
diff --git a/MemoScope/Core/Data/ClrObject.cs b/MemoScope/Core/Data/ClrObject.cs
@@ -22,7 +22,7 @@ public ClrObject this[string fieldName]
                 ClrInstanceField field = GetField(fieldName);
 
                 if (field == null)
-                    throw new ArgumentException(string.Format("Field '{0}' not found in Type '{1}'", fieldName, Type.Name));
+                    throw new ArgumentException($"Field '{fieldName}' not found in Type '{Type.Name}'");
 
                 return this[field];
             }
diff --git a/MemoScope/Modules/Instances/FieldNode.cs b/MemoScope/Modules/Instances/FieldNode.cs
@@ -40,8 +40,8 @@ public List<FieldNode> Children
         {
             get
             {
-                var fieldTypesByName = ClrDump.GetFieldNames(ClrType);
-                var fieldNodes = fieldTypesByName.Select(kvp => new FieldNode(kvp.Key, kvp.Value, ClrDump, this));
+                var fieldInfos = ClrDump.GetFieldInfos(ClrType);
+                var fieldNodes = fieldInfos.Select(fieldInfo => new FieldNode(fieldInfo.Name, fieldInfo.FieldType, ClrDump, this));
                 return fieldNodes.ToList();
             }
         }
diff --git a/MemoScope/Modules/Instances/InstancesModule.cs b/MemoScope/Modules/Instances/InstancesModule.cs
@@ -19,7 +19,7 @@ namespace MemoScope.Modules.Instances
 {
     public partial class InstancesModule : UIClrDumpModule, UIDataProvider<ClrDumpType>, UIDataProvider<ClrDumpObject>, IModelFilter
     {
-        private Dictionary<string, ClrType> fieldTypesByNames;
+        private List<FieldInfo> fieldInfos;
         private AddressList AddressList { get; set; }
         private List<Func<bool>> filters;
         private FieldAccessor myFieldAccessor;
@@ -193,13 +193,13 @@ public override void Init()
         {
             var dump = AddressList.ClrDump;
             var type = AddressList.ClrType;
-            fieldTypesByNames = dump.GetFieldNames(type);
+            fieldInfos = dump.GetFieldInfos(type);
         }
 
         // Gui thread
         public override void PostInit()
         {
-            var fieldNodes = fieldTypesByNames.Select(kvp => new FieldNode(kvp.Key, kvp.Value, AddressList.ClrDump));
+            var fieldNodes = fieldInfos.Select(fieldInfo=> new FieldNode(fieldInfo.Name, fieldInfo.FieldType, AddressList.ClrDump));
             dtlvFields.Roots = fieldNodes;
             dlvAdresses.VirtualListDataSource = new InstanceVirtualSource(dlvAdresses, AddressList, filteredAddresses);
             Summary = $"{AddressList.Addresses.Count:###,###,###,##0} instances";

Original file line number	Diff line number	Diff line change
`@@ -13,17 +13,24 @@ struct StructData`
`13`	`13`	`public interface IMyInterface`
`14`	`14`	`{`
`15`	`15`	`int Id { get; }`
	`16`	`+ double MyDoubleValue { get; }`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`public class MyInterfaceImpl_V1 : IMyInterface`
`19`	`20`	`{`
`20`	`21`	`private static int n = 0;`
`21`		`- public int Id { get; }`
`22`		`-`
	`22`	`+ protected int backfield_id;`
	`23`	`+ public int Id {`
	`24`	`+ get {`
	`25`	`+ return backfield_id;`
	`26`	`+ }`
	`27`	`+ }`
	`28`	`+ public double MyDoubleValue { get; set; }`
`23`	`29`	`public string name;`
`24`	`30`	`public MyInterfaceImpl_V1()`
`25`	`31`	`{`
`26`		`- Id = n++;`
	`32`	`+ backfield_id = n++;`
	`33`	`+ MyDoubleValue = backfield_id + 0.001;`
`27`	`34`	`name = $"#{0:Id}";`
`28`	`35`	`}`
`29`	`36`	`}`
`@@ -33,6 +40,8 @@ public class MyInterfaceImpl_V2 : MyInterfaceImpl_V1`
`33`	`40`	`public DateTime TimeStamp { get; set; }`
`34`	`41`	`public MyInterfaceImpl_V2()`
`35`	`42`	`{`
	`43`	`+ backfield_id *= -1;`
	`44`	`+ MyDoubleValue = backfield_id - 0.001;`
`36`	`45`	`TimeStamp = DateTime.Now;`
`37`	`46`	`}`
`38`	`47`	`}`
`@@ -44,6 +53,26 @@ class InternalData`
`44`	`53`	`public double X { get; set; }`
`45`	`54`	`public double Y { get; set; }`
`46`	`55`	`}`
	`56`	`+ public abstract class AnAbstractType`
	`57`	`+ {`
	`58`	`+ public abstract double AbstractDoubleProperty { get; }`
	`59`	`+ public double MyDoubleProperty { get; set; }`
	`60`	`+ }`
	`61`	`+`
	`62`	`+ public class AnAbstractTypeImpl : AnAbstractType`
	`63`	`+ {`
	`64`	`+ private static int n = 0;`
	`65`	`+ public new double MyDoubleProperty { get; }`
	`66`	`+ public override double AbstractDoubleProperty { get; }`
	`67`	`+`
	`68`	`+ public AnAbstractTypeImpl()`
	`69`	`+ {`
	`70`	`+ n++;`
	`71`	`+ AbstractDoubleProperty = -n - 0.0005;`
	`72`	`+ base.MyDoubleProperty = n + 0.0005;`
	`73`	`+ this.MyDoubleProperty = n + 0.0006;`
	`74`	`+ }`
	`75`	`+ }`
`47`	`76`
`48`	`77`	`internal class ComplexObject`
`49`	`78`	`{`
`@@ -54,7 +83,7 @@ internal class ComplexObject`
`54`	`83`	`internal StructData StructData => structData;`
`55`	`84`
`56`	`85`	`double value;`
`57`		`- InternalData data;`
	`86`	`+ InternalData data;`
`58`	`87`	`bool isEven;`
`59`	`88`	`DateTime date;`
`60`	`89`	`TimeSpan time;`
`@@ -64,7 +93,7 @@ internal class ComplexObject`
`64`	`93`	`int[] someInts;`
`65`	`94`	`double[] someDoubles;`
`66`	`95`	`IMyInterface myInterface;`
`67`		`-`
	`96`	`+ AnAbstractType aFieldWithAbstractType;`
`68`	`97`	`public ComplexObject()`
`69`	`98`	`{`
`70`	`99`	`id = n++;`
`@@ -102,7 +131,7 @@ public ComplexObject()`
`102`	`131`	`someDoubles[i] = 2 * (n + i);`
`103`	`132`	`}`
`104`	`133`	`myInterface = id % 2 == 0 ? new MyInterfaceImpl_V1() : new MyInterfaceImpl_V2();`
	`134`	`+ aFieldWithAbstractType = new AnAbstractTypeImpl();`
`105`	`135`	`}`
`106`		`-`
`107`	`136`	`}`
`108`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public class ClrDump : IClrDump`
`35`	`35`
`36`	`36`	`public List<ClrHandle> Handles => Runtime.EnumerateHandles().ToList();`
`37`	`37`	`public List<ulong> FinalizerQueueObjectAddresses => Runtime.EnumerateFinalizerQueueObjectAddresses().ToList();`
`38`		`- public IEnumerable<IGrouping<ClrType, ulong>> FinalizerQueueObjectAddressesByType => Runtime.EnumerateFinalizerQueueObjectAddresses().GroupBy( address => GetObjectType(address));`
	`38`	`+ public IEnumerable<IGrouping<ClrType, ulong>> FinalizerQueueObjectAddressesByType => Runtime.EnumerateFinalizerQueueObjectAddresses().GroupBy(address => GetObjectType(address));`
`39`	`39`	`public IList<ClrThread> Threads => Runtime.Threads;`
`40`	`40`	`public ClrThreadPool ThreadPool => Runtime.GetThreadPool();`
`41`	`41`	`public List<ClrType> AllTypes => Heap.EnumerateTypes().ToList();`
`@@ -57,7 +57,7 @@ public Dictionary<int, ThreadProperty> ThreadProperties`
`57`	`57`	`Dictionary<int, ThreadProperty> threadProperties;`
`58`	`58`	`private readonly SingleThreadWorker worker;`
`59`	`59`	`private ClrDumpCache cache;`
`60`		`-`
	`60`	`+`
`61`	`61`	`public ClrDump(DataTarget target, string dumpPath, MessageBus msgBus)`
`62`	`62`	`{`
`63`	`63`	`Id = n++;`
`@@ -94,7 +94,7 @@ private void InitRuntime()`
`94`	`94`
`95`	`95`	`public List<ClrType> GetTypes()`
`96`	`96`	`{`
`97`		`- List<ClrType> t = worker.Eval( () => t = AllTypes);`
	`97`	`+ List<ClrType> t = worker.Eval(() => t = AllTypes);`
`98`	`98`	`return t;`
`99`	`99`	`}`
`100`	`100`
`@@ -110,7 +110,7 @@ internal void Dispose()`
`110`	`110`	`logger.Debug("Cache dispose");`
`111`	`111`	`cache.Dispose();`
`112`	`112`	`logger.Debug("Runtime.DataTarget.Dispose");`
`113`		`- Run( () => Runtime?.DataTarget?.Dispose());`
	`113`	`+ Run(() => Runtime?.DataTarget?.Dispose());`
`114`	`114`	`logger.Debug("Worker.Dispose");`
`115`	`115`	`worker.Dispose();`
`116`	`116`	`}`
`@@ -205,7 +205,7 @@ private object GetSimpleValueImpl(ulong address, ClrType type)`
`205`	`205`	`var value = SimpleValueHelper.GetSimpleValue(address, type, false);`
`206`	`206`	`return value;`
`207`	`207`	`}`
`208`		`-`
	`208`	`+`
`209`	`209`	`return address;`
`210`	`210`	`}`
`211`	`211`
`@@ -225,28 +225,30 @@ public object GetFieldValue(ulong address, ClrType type, ClrInstanceField field)`
`225`	`225`	`return obj;`
`226`	`226`	`}`
`227`	`227`
`228`		`- internal Dictionary<string, ClrType> GetFieldNames(ClrType type)`
	`228`	`+ internal List<FieldInfo> GetFieldInfos(ClrType type)`
`229`	`229`	`{`
`230`		`- Dictionary<string, ClrType> fieldNames = Eval(() => GetFieldNamesImpl(type));`
	`230`	`+ List<FieldInfo> fieldNames = Eval(() => GetFieldNamesImpl(type));`
`231`	`231`	`return fieldNames;`
`232`	`232`	`}`
`233`	`233`
`234`		`- private Dictionary<string, ClrType> GetFieldNamesImpl(ClrType type)`
	`234`	`+ private List<FieldInfo> GetFieldNamesImpl(ClrType type)`
`235`	`235`	`{`
`236`		`- var fieldNames = type.Fields.ToDictionary(f => f.Name, f => f.Type);`
`237`		`- if( type.IsInterface)`
	`236`	`+ var fieldNames = type.Fields.Select(f => new FieldInfo(f.Name, f.Type)).ToList();`
	`237`	`+ if (type.IsInterface \|\| type.IsAbstract)`
`238`	`238`	`{`
`239`		`- var properties = type.Methods.Where(meth => meth.Name.StartsWith("get_") && meth.IsVirtual);`
`240`		`- foreach (var meth in properties)`
	`239`	`+ foreach (var someType in Heap.EnumerateTypes())`
`241`	`240`	`{`
`242`		`- var propName = meth.Name.Substring("get_".Length);`
`243`		`- // BUG: this is not the real type of the field !`
`244`		`- // TODO: get the return type from the method`
`245`		`- fieldNames[propName] = meth.Type;`
	`241`	`+ if (type.IsInterface && someType.Interfaces.Any(interf => interf.Name == type.Name))`
	`242`	`+ {`
	`243`	`+ fieldNames.AddRange(GetFieldNamesImpl(someType));`
	`244`	`+ }`
	`245`	`+ if (type.IsAbstract && someType.BaseType == type)`
	`246`	`+ {`
	`247`	`+ fieldNames.AddRange(GetFieldNamesImpl(someType));`
	`248`	`+ }`
`246`	`249`	`}`
`247`		`-`
`248`	`250`	`}`
`249`		`- return fieldNames;`
	`251`	`+ return fieldNames.Distinct().ToList();`
`250`	`252`	`}`
`251`	`253`
`252`	`254`	`public object GetFieldValueImpl(ulong address, ClrType type, List<ClrInstanceField> fields)`
`@@ -257,7 +259,7 @@ public object GetFieldValueImpl(ulong address, ClrType type, List<ClrInstanceFie`
`257`	`259`	`{`
`258`	`260`	`var field = fields[i];`
`259`	`261`	`obj = obj[field];`
`260`		`- if( obj.IsNull )`
	`262`	`+ if (obj.IsNull)`
`261`	`263`	`{`
`262`	`264`	`return null;`
`263`	`265`	`}`
`@@ -272,7 +274,13 @@ public object GetFieldValueImpl(ulong address, ClrType type, List<string> fieldN`
`272`	`274`	`for (int i = 0; i < fieldNames.Count; i++)`
`273`	`275`	`{`
`274`	`276`	`var fieldName = fieldNames[i];`
`275`		`- obj = obj[fieldName];`
	`277`	`+ ClrInstanceField field = obj.GetField(fieldName);`
	`278`	`+ if( field == null)`
	`279`	`+ {`
	`280`	`+ return null;`
	`281`	`+ }`
	`282`	`+`
	`283`	`+ obj = obj[field];`
`276`	`284`	`if (obj.IsNull)`
`277`	`285`	`{`
`278`	`286`	`return null;`
`@@ -313,7 +321,7 @@ public bool HasReferers(ulong address)`
`313`	`321`
`314`	`322`	`public int CountReferers(ulong address)`
`315`	`323`	`{`
`316`		`- var count = cache.CountReferers(address) ;`
	`324`	`+ var count = cache.CountReferers(address);`
`317`	`325`	`return count;`
`318`	`326`	`}`
`319`	`327`
`@@ -384,15 +392,15 @@ public ClrMethod GetMethodByHandle(ulong methodDescriptorPtr)`
`384`	`392`	`}`
`385`	`393`
`386`	`394`	`// Find the field in instance at address that references refAddress`
`387`		`- public string GetFieldNameReference(ulong refAddress, ulong address, bool prefixWithType=false)`
	`395`	`+ public string GetFieldNameReference(ulong refAddress, ulong address, bool prefixWithType = false)`
`388`	`396`	`{`
`389`	`397`	`return Eval(() => GetFieldNameReferenceImpl(refAddress, address, prefixWithType));`
`390`	`398`	`}`
`391`	`399`
`392`	`400`	`public string GetFieldNameReferenceImpl(ulong refAddress, ulong address, bool prefixWithType)`
`393`		`- {`
	`401`	`+ {`
`394`	`402`	`ClrType type = GetObjectTypeImpl(address);`
`395`		`- if( type == null)`
	`403`	`+ if (type == null)`
`396`	`404`	`{`
`397`	`405`	`return "Unknown";`
`398`	`406`	`}`
`@@ -504,16 +512,16 @@ public List<ClrRoot> GetClrRoots()`
`504`	`512`
`505`	`513`	`public bool HasField(ClrType clrType)`
`506`	`514`	`{`
`507`		`- if( clrType.IsPrimitive)`
	`515`	`+ if (clrType.IsPrimitive)`
`508`	`516`	`{`
`509`	`517`	`return false;`
`510`	`518`	`}`
`511`		`- if ( clrType.Fields.Any())`
	`519`	`+ if (clrType.Fields.Any())`
`512`	`520`	`{`
`513`	`521`	`return true;`
`514`	`522`	`}`
`515`	`523`
`516`		`- if( clrType.IsInterface && clrType.Methods.Any(meth => meth.Name.StartsWith("get_")))`
	`524`	`+ if (clrType.IsInterface && clrType.Methods.Any(meth => meth.Name.StartsWith("get_")))`
`517`	`525`	`{`
`518`	`526`	`return true;`
`519`	`527`	`}`
`@@ -531,4 +539,27 @@ public class ThreadProperty`
`531`	`539`	`public int Priority { get; set; }`
`532`	`540`	`public int ManagedId { get; set; }`
`533`	`541`	`}`
	`542`	`+`
	`543`	`+ public class FieldInfo : IEquatable<FieldInfo>`
	`544`	`+ {`
	`545`	`+ public string Name { get; }`
	`546`	`+ public ClrType FieldType { get; }`
	`547`	`+ public FieldInfo(string name, ClrType fieldType)`
	`548`	`+ {`
	`549`	`+ Name = name;`
	`550`	`+ FieldType = fieldType;`
	`551`	`+ }`
	`552`	`+ public bool Equals(FieldInfo fieldInfo)`
	`553`	`+ {`
	`554`	`+ return fieldInfo.Name == Name && fieldInfo.FieldType.Name == FieldType.Name;`
	`555`	`+ }`
	`556`	`+ public override bool Equals(object o )`
	`557`	`+ {`
	`558`	`+ return ((IEquatable<FieldInfo>)this).Equals((FieldInfo)o);`
	`559`	`+ }`
	`560`	`+ public override int GetHashCode()`
	`561`	`+ {`
	`562`	`+ return Name.GetHashCode() * 37 + FieldType.Name.GetHashCode();`
	`563`	`+ }`
	`564`	`+ }`
`534`	`565`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public ClrObject this[string fieldName]`
`22`	`22`	`ClrInstanceField field = GetField(fieldName);`
`23`	`23`
`24`	`24`	`if (field == null)`
`25`		`- throw new ArgumentException(string.Format("Field '{0}' not found in Type '{1}'", fieldName, Type.Name));`
	`25`	`+ throw new ArgumentException($"Field '{fieldName}' not found in Type '{Type.Name}'");`
`26`	`26`
`27`	`27`	`return this[field];`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,8 @@ public List<FieldNode> Children`
`40`	`40`	`{`
`41`	`41`	`get`
`42`	`42`	`{`
`43`		`- var fieldTypesByName = ClrDump.GetFieldNames(ClrType);`
`44`		`- var fieldNodes = fieldTypesByName.Select(kvp => new FieldNode(kvp.Key, kvp.Value, ClrDump, this));`
	`43`	`+ var fieldInfos = ClrDump.GetFieldInfos(ClrType);`
	`44`	`+ var fieldNodes = fieldInfos.Select(fieldInfo => new FieldNode(fieldInfo.Name, fieldInfo.FieldType, ClrDump, this));`
`45`	`45`	`return fieldNodes.ToList();`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ namespace MemoScope.Modules.Instances`
`19`	`19`	`{`
`20`	`20`	`public partial class InstancesModule : UIClrDumpModule, UIDataProvider<ClrDumpType>, UIDataProvider<ClrDumpObject>, IModelFilter`
`21`	`21`	`{`
`22`		`- private Dictionary<string, ClrType> fieldTypesByNames;`
	`22`	`+ private List<FieldInfo> fieldInfos;`
`23`	`23`	`private AddressList AddressList { get; set; }`
`24`	`24`	`private List<Func<bool>> filters;`
`25`	`25`	`private FieldAccessor myFieldAccessor;`
`@@ -193,13 +193,13 @@ public override void Init()`
`193`	`193`	`{`
`194`	`194`	`var dump = AddressList.ClrDump;`
`195`	`195`	`var type = AddressList.ClrType;`
`196`		`- fieldTypesByNames = dump.GetFieldNames(type);`
	`196`	`+ fieldInfos = dump.GetFieldInfos(type);`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`// Gui thread`
`200`	`200`	`public override void PostInit()`
`201`	`201`	`{`
`202`		`- var fieldNodes = fieldTypesByNames.Select(kvp => new FieldNode(kvp.Key, kvp.Value, AddressList.ClrDump));`
	`202`	`+ var fieldNodes = fieldInfos.Select(fieldInfo=> new FieldNode(fieldInfo.Name, fieldInfo.FieldType, AddressList.ClrDump));`
`203`	`203`	`dtlvFields.Roots = fieldNodes;`
`204`	`204`	`dlvAdresses.VirtualListDataSource = new InstanceVirtualSource(dlvAdresses, AddressList, filteredAddresses);`
`205`	`205`	`Summary = $"{AddressList.Addresses.Count:###,###,###,##0} instances";`