punteros - Dirección de memoria de un objeto en C#

¿ en c# qué es método?

Question

Tengo una función escrita hace un tiempo (para .NET 3.5), y ahora que me actualicé a 4.0 no puedo hacer que funcione.

La función es:

public static class MemoryAddress
{
public static string Get(object a)
{
GCHandle handle = GCHandle.Alloc(a, GCHandleType.Pinned);
IntPtr pointer = GCHandle.ToIntPtr(handle);
handle.Free();
return "0x" + pointer.ToString("X");
}
}

Ahora, cuando lo llamo - MemoryAddress.Get (auto nuevo ("azul"))

public class Car
{
public string Color;
public Car(string color)
{
Color = color;
}
}

Me sale el error: "El objeto contiene datos no primitivos o no blittable".

¿Por qué ya no funciona? ¿Cómo puedo obtener ahora la dirección de memoria de los objetos administrados?

Answer 1

Cambiar el tipo de alloc:

GCHandle handle = GCHandle.Alloc(a, GCHandleType.Normal);

Answer 2

Cuando liberas ese identificador, el recolector de basura puede mover libremente la memoria que estaba anclada. Si tiene un puntero a la memoria que se supone que está inmovilizado, y usted anula esa memoria, entonces todas las apuestas están desactivadas. Que esto funcionó en 3.5 fue probablemente solo por suerte. El compilador JIT y el tiempo de ejecución para 4.0 probablemente hagan un mejor trabajo en el análisis de la duración del objeto.

Si realmente quieres hacer esto, puedes utilizar una try/finally para evitar que el objeto se desenganche hasta después de que lo hayas usado:

public static string Get(object a)
{
GCHandle handle = GCHandle.Alloc(a, GCHandleType.Pinned);
try
{
IntPtr pointer = GCHandle.ToIntPtr(handle);
return "0x" + pointer.ToString("X");
}
finally
{
handle.Free();
}
}

Answer 3

En lugar de este código, debe llamar a GetHashCode() , que devolverá un valor único (con suerte) para cada instancia.

También puede usar la clase ObjectIDGenerator , que se garantiza que es única.

Answer 4

Esto funciona para mí ...

#region AddressOf
/// <summary>
/// Provides the current address of the given object.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
public static System.IntPtr AddressOf(object obj)
{
if (obj == null) return System.IntPtr.Zero;
System.TypedReference reference = __makeref(obj);
System.TypedReference* pRef = &reference;
return (System.IntPtr)pRef; //(&pRef)
}
/// <summary>
/// Provides the current address of the given element
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
public static System.IntPtr AddressOf<T>(T t)
//refember ReferenceTypes are references to the CLRHeader
//where TOriginal : struct
{
System.TypedReference reference = __makeref(t);
return *(System.IntPtr*)(&reference);
}
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
static System.IntPtr AddressOfRef<T>(ref T t)
//refember ReferenceTypes are references to the CLRHeader
//where TOriginal : struct
{
System.TypedReference reference = __makeref(t);
System.TypedReference* pRef = &reference;
return (System.IntPtr)pRef; //(&pRef)
}
/// <summary>
/// Returns the unmanaged address of the given array.
/// </summary>
/// <param name="array"></param>
/// <returns><see cref="IntPtr.Zero"/> if null, otherwise the address of the array</returns>
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
public static System.IntPtr AddressOfByteArray(byte[] array)
{
if (array == null) return System.IntPtr.Zero;
fixed (byte* ptr = array)
return (System.IntPtr)(ptr - 2 * sizeof(void*)); //Todo staticaly determine size of void?
}
#endregion

Answer 5

Hay una solución mejor si realmente no necesita la dirección de la memoria, sino más bien algunos medios para identificar de manera única un objeto administrado:

using System.Runtime.CompilerServices;
public static class Extensions
{
private static readonly ConditionalWeakTable<object, RefId> _ids = new ConditionalWeakTable<object, RefId>();
public static Guid GetRefId<T>(this T obj) where T: class
{
if (obj == null)
return default(Guid);
return _ids.GetOrCreateValue(obj).Id;
}
private class RefId
{
public Guid Id { get; } = Guid.NewGuid();
}
}

Esto es seguro para hilos y utiliza referencias débiles internamente, por lo que no tendrá pérdidas de memoria.

Puede usar cualquier medio de generación de claves que desee. Estoy usando Guid.NewGuid() aquí porque es simple y seguro para subprocesos.

Actualizar

Seguí adelante y creé un paquete Overby.Extensions.Attachments que contiene algunos métodos de extensión para unir objetos a otros objetos. Hay una extensión llamada GetReferenceId() que efectivamente hace lo que muestra el código en esta respuesta.

Answer 6

Obtener la dirección de un objeto arbitrario en .NET no es posible, pero se puede hacer si cambias el código fuente y usas mono. Vea las instrucciones aquí: Obtenga la dirección de memoria del objeto .NET (C #)

Answer 7

Puede usar GCHandleType.Weak en lugar de Pineado. Por otro lado, hay otra forma de obtener puntero a un objeto:

object o = new object();
TypedReference tr = __makeref(o);
IntPtr ptr = **(IntPtr**)(&tr);

Requiere un bloqueo inseguro y es muy, muy peligroso y no debe usarse en absoluto. ☺