public void Test() { int valType = 0xFF; Assert.That(new IntPtr(&valType), Is.EqualTo(Unsafe.AddressOf(ref valType))); string s = "foo"; Assert.That(new IntPtr(CSUnsafe.AsPointer(ref s)), Is.EqualTo(Unsafe.AddressOf(ref s))); IntPtr sChars = Unsafe.AddressOfHeap(ref s, OffsetType.StringData); Assert.That(Marshal.ReadInt16(sChars), Is.EqualTo(s[0])); int[] arr = { 1, 2, 3 }; IntPtr arrData = Unsafe.AddressOfHeap(ref arr, OffsetType.ArrayData); Assert.That(Marshal.ReadInt32(arrData), Is.EqualTo(arr[0])); Dummy d = new Dummy(100, "bar"); IntPtr dData = Unsafe.AddressOfHeap(ref d, OffsetType.Fields); // Largest field is first in memory Assert.That(Marshal.ReadInt32(dData, IntPtr.Size), Is.EqualTo(100)); }
public static void WriteMethodTable <T>(ref T t, MethodTable *m) where T : class { var addrMt = Unsafe.AddressOfHeap(ref t); *((MethodTable **)addrMt) = m; //var h = GetHeapObject(ref t); //(**h).MethodTable = m; }
internal ReferenceAddressInfo(ref T t) : base(ref t) { Heap = Unsafe.AddressOfHeap(ref t); Fields = Unsafe.AddressOfHeap(ref t, OffsetType.Fields); if (typeof(T).IsArray) { HeapMisc = Unsafe.AddressOfHeap(ref t, OffsetType.ArrayData); } else if (typeof(T) == typeof(string)) { HeapMisc = Unsafe.AddressOfHeap(ref t, OffsetType.StringData); } else { HeapMisc = IntPtr.Zero; } }
/// <summary> /// Asserts that the heap and stack pointers of a reference type don't change at all /// during GC compaction. This test will pass if the parameter is pinned. /// </summary> internal static void AssertPinning <T>(ref T t) where T : class { (IntPtr stackPtr, IntPtr heap)mem = (Unsafe.AddressOf(ref t), Unsafe.AddressOfHeap(ref t)); int passes = 0; while (passes++ < MaxPasses) { object[] oArr = new object[MaxObjects]; for (int i = 0; i < oArr.Length; i++) { oArr[i] = new object(); } // pass when reference is pinned Assert.That(mem.stackPtr, Is.EqualTo(Unsafe.AddressOf(ref t))); Assert.That(mem.heap, Is.EqualTo(Unsafe.AddressOfHeap(ref t))); } }
public void TestString() { string s = "anime"; DecayPointer <char> ptr = s; Assert.That(ptr.FirstElement, Is.EqualTo(Unsafe.AddressOfHeap(ref s, OffsetType.StringData))); // Test indexing for (int i = 0; i < s.Length; i++) { Assert.That(ptr[i], Is.EqualTo(s[i])); } // Test incrementing for (int i = 0; i < s.Length; i++, ptr++) { Assert.That(ptr.Value, Is.EqualTo(s[i])); Assert.That(ptr[0], Is.EqualTo(s[i])); } // Test decrementing for (int i = s.Length - 1; i >= 0; i--) { Assert.That(ptr.Value, Is.EqualTo(s[i])); ptr--; } Assert.That(ptr.Value, Is.EqualTo(s[0])); Assert.That(ptr[0], Is.EqualTo(s[0])); //s += " bar"; Assert.That(ptr.Address, Is.EqualTo(Unsafe.AddressOfHeap(ref s, OffsetType.StringData))); Assert.That(ptr.Count, Is.EqualTo(s.Length)); //Debug.Assert(ptr.ToArray().SequenceEqual(s)); }
/// <summary> /// Reads a reference type's object header. /// </summary> /// <returns>A pointer to the reference type's header</returns> public static ObjHeader *ReadObjHeader <T>(ref T t) where T : class { IntPtr data = Unsafe.AddressOfHeap(ref t); return((ObjHeader *)(data - IntPtr.Size)); }
public void Setup() { _arrPtr = Unsafe.AddressOfHeap(ref _arr, OffsetType.ArrayData); }
internal static ObjHeader ReadObjHeader <T>(T value) where T : class { var ptr = Unsafe.AddressOfHeap(value, OffsetOptions.HEADER).Cast <ObjHeader>(); return(ptr.Value); }