Identificador de objeto exclusivo do .NET

Existe uma maneira de obter um identificador exclusivo de uma instância?

GetHashCode()é o mesmo para as duas referências que apontam para a mesma instância. No entanto, duas instâncias diferentes podem (facilmente) obter o mesmo código hash:

Hashtable hashCodesSeen = new Hashtable();
LinkedList<object> l = new LinkedList<object>();
int n = 0;
while (true)
{
    object o = new object();
    // Remember objects so that they don't get collected.
    // This does not make any difference though :(
    l.AddFirst(o);
    int hashCode = o.GetHashCode();
    n++;
    if (hashCodesSeen.ContainsKey(hashCode))
    {
        // Same hashCode seen twice for DIFFERENT objects (n is as low as 5322).
        Console.WriteLine("Hashcode seen twice: " + n + " (" + hashCode + ")");
        break;
    }
    hashCodesSeen.Add(hashCode, null);
}

Estou escrevendo um addin de depuração e preciso obter algum tipo de ID para uma referência que seja única durante a execução do programa.

Já consegui o ADDRESS interno da instância, que é único até que o garbage collector (GC) compacta o heap (= move os objetos = muda os endereços).

Pergunta sobre Stack Overflow A implementação padrão para Object.GetHashCode () pode estar relacionada.

Os objetos não estão sob meu controle, pois estou acessando objetos em um programa que está sendo depurado usando a API do depurador. Se eu estivesse no controle dos objetos, adicionar meus próprios identificadores exclusivos seria trivial.

Eu queria o ID exclusivo para construir um ID hashtable -> objeto, para poder pesquisar objetos já vistos. Por enquanto eu resolvi assim:

Build a hashtable: 'hashCode' -> (list of objects with hash code == 'hashCode')
Find if object seen(o) {
    candidates = hashtable[o.GetHashCode()] // Objects with the same hashCode.
    If no candidates, the object is new
    If some candidates, compare their addresses to o.Address
        If no address is equal (the hash code was just a coincidence) -> o is new
        If some address equal, o already seen
}

A referência é o identificador exclusivo do objeto. Não conheço nenhuma maneira de converter isso em algo como uma string etc. O valor da referência mudará durante a compactação (como você viu), mas todos os valores A anteriores serão alterados para o valor B, até agora no que diz respeito ao código seguro, ainda é um ID único.

Se os objetos envolvidos estiverem sob seu controle, você pode criar um mapeamento usando referências fracas (para evitar a coleta de lixo) de uma referência a um ID de sua escolha (GUID, inteiro, qualquer que seja). No entanto, isso acrescentaria uma certa sobrecarga e complexidade.

.NET 4 e posterior apenas

Boas notícias, pessoal!

A ferramenta perfeita para esse trabalho é construída em .NET 4 e é chamada ConditionalWeakTable<TKey, TValue>. Esta aula:

• pode ser usado para associar dados arbitrários a instâncias de objetos gerenciados, como um dicionário (embora não seja um dicionário)
• não depende de endereços de memória, portanto, é imune ao GC compactando o heap
• não mantém os objetos vivos apenas porque foram inseridos como chaves na mesa, portanto, pode ser usado sem fazer com que todos os objetos em seu processo vivam para sempre
• usa igualdade de referência para determinar a identidade do objeto; Além disso, os autores da classe não podem modificar este comportamento, então ele pode ser usado consistentemente em objetos de qualquer tipo
• pode ser preenchido na hora, portanto, não requer que você injete código dentro de construtores de objeto

Check-out do ObjectIDGenerator classe? Isso faz o que você está tentando fazer e o que Marc Gravell descreve.

O ObjectIDGenerator rastreia os objetos identificados anteriormente. Quando você pede o ID de um objeto, o ObjectIDGenerator sabe se deve retornar o ID existente ou gerar e lembrar um novo ID.

Os IDs são exclusivos durante a vida da instância ObjectIDGenerator. Geralmente, a vida de um ObjectIDGenerator dura tanto quanto o Formatador que o criou. Os IDs de objeto têm significado apenas em um determinado fluxo serializado e são usados ​​para rastrear quais objetos têm referências a outros dentro do gráfico de objeto serializado.

Usando uma tabela hash, o ObjectIDGenerator retém qual ID é atribuído a qual objeto. As referências de objeto, que identificam exclusivamente cada objeto, são endereços no heap de coleta de lixo do tempo de execução. Os valores de referência do objeto podem mudar durante a serialização, mas a tabela é atualizada automaticamente para que as informações estejam corretas.

Os IDs de objeto são números de 64 bits. A alocação começa em um, portanto, zero nunca é um ID de objeto válido. Um formatador pode escolher um valor zero para representar uma referência de objeto cujo valor é uma referência nula (Nothing em Visual Basic).

RuntimeHelpers.GetHashCode()pode ajudar ( MSDN ).

Você pode desenvolver suas próprias coisas em um segundo. Por exemplo:

   class Program
    {
        static void Main(string[] args)
        {
            var a = new object();
            var b = new object();
            Console.WriteLine("", a.GetId(), b.GetId());
        }
    }

    public static class MyExtensions
    {
        //this dictionary should use weak key references
        static Dictionary<object, int> d = new Dictionary<object,int>();
        static int gid = 0;

        public static int GetId(this object o)
        {
            if (d.ContainsKey(o)) return d[o];
            return d[o] = gid++;
        }
    }   

Você pode escolher o que deseja ter como ID exclusivo por conta própria, por exemplo, System.Guid.NewGuid () ou simplesmente inteiro para acesso mais rápido.

Que tal este método:

Defina um campo no primeiro objeto com um novo valor. Se o mesmo campo no segundo objeto tiver o mesmo valor, provavelmente é a mesma instância. Caso contrário, saia como diferente.

Agora defina o campo no primeiro objeto com um novo valor diferente. Se o mesmo campo no segundo objeto mudou para um valor diferente, é definitivamente a mesma instância.

Não se esqueça de definir o campo no primeiro objeto de volta ao seu valor original ao sair.

Problemas?

É possível criar um identificador de objeto exclusivo no Visual Studio: Na janela de observação, clique com o botão direito do mouse na variável do objeto e escolha Criar ID do objeto no menu de contexto.

Infelizmente, esta é uma etapa manual e não acredito que o identificador possa ser acessado via código.

Você mesmo teria que atribuir tal identificador, manualmente - seja dentro da instância ou externamente.

Para registros relacionados a um banco de dados, a chave primária pode ser útil (mas você ainda pode obter duplicatas). Alternativamente, use a Guidou mantenha seu próprio contador, alocando usando Interlocked.Increment(e torne-o grande o suficiente para que não transborde).

Eu sei que isso foi respondido, mas é pelo menos útil observar que você pode usar:

http://msdn.microsoft.com/en-us/library/system.object.referenceequals.aspx

O que não dará a você um "id exclusivo" diretamente, mas combinado com WeakReferences (e um hashset?) Pode fornecer uma maneira muito fácil de rastrear várias instâncias.

As informações que dou aqui não são novas, apenas adicionei para completar.

A ideia deste código é bastante simples:

• Os objetos precisam de um ID exclusivo, que não existe por padrão. Em vez disso, temos que confiar na próxima melhor coisa, que é RuntimeHelpers.GetHashCodenos fornecer uma espécie de ID exclusivo
• Para verificar a exclusividade, isso implica que precisamos usar object.ReferenceEquals
• No entanto, ainda gostaríamos de ter um ID exclusivo, então adicionei um GUID, que por definição é exclusivo.
• Porque não gosto de trancar tudo se não for preciso, não uso ConditionalWeakTable.

Combinado, isso fornecerá o seguinte código:

public class UniqueIdMapper
{
    private class ObjectEqualityComparer : IEqualityComparer<object>
    {
        public bool Equals(object x, object y)
        {
            return object.ReferenceEquals(x, y);
        }

        public int GetHashCode(object obj)
        {
            return RuntimeHelpers.GetHashCode(obj);
        }
    }

    private Dictionary<object, Guid> dict = new Dictionary<object, Guid>(new ObjectEqualityComparer());
    public Guid GetUniqueId(object o)
    {
        Guid id;
        if (!dict.TryGetValue(o, out id))
        {
            id = Guid.NewGuid();
            dict.Add(o, id);
        }
        return id;
    }
}

Para usá-lo, crie uma instância de UniqueIdMappere use os GUIDs que retorna para os objetos.

Termo aditivo

Então, há um pouco mais acontecendo aqui; deixe-me escrever um pouco sobre ConditionalWeakTable.

ConditionalWeakTablefaz algumas coisas. O mais importante é que não se preocupe com o coletor de lixo, ou seja: os objetos que você referenciar nesta tabela serão coletados de qualquer maneira. Se você pesquisar um objeto, ele basicamente funcionará da mesma forma que o dicionário acima.

Curioso, não? Afinal, quando um objeto está sendo coletado pelo CG, ele verifica se há referências ao objeto e, se houver, as coleta. Portanto, se houver um objeto do ConditionalWeakTable, por que o objeto referenciado será coletado?

ConditionalWeakTableusa um pequeno truque, que algumas outras estruturas .NET também usam: em vez de armazenar uma referência ao objeto, ele na verdade armazena um IntPtr. Como essa não é uma referência real, o objeto pode ser coletado.

Portanto, neste ponto, há 2 problemas a serem resolvidos. Primeiro, os objetos podem ser movidos no heap, então o que usaremos como IntPtr? E em segundo lugar, como sabemos que os objetos têm uma referência ativa?

• O objeto pode ser fixado no heap e seu ponteiro real pode ser armazenado. Quando o GC atinge o objeto para remoção, ele o desenrosca e o coleta. No entanto, isso significaria que obteríamos um recurso fixado, o que não é uma boa ideia se você tiver muitos objetos (devido a problemas de fragmentação de memória). Provavelmente não é assim que funciona.
• Quando o GC move um objeto, ele chama de volta, que pode então atualizar as referências. Pode ser assim que está implementado a julgar pelas chamadas externas DependentHandle- mas acredito que seja um pouco mais sofisticado.
• Não o ponteiro para o próprio objeto, mas um ponteiro na lista de todos os objetos do GC é armazenado. O IntPtr é um índice ou um ponteiro nesta lista. A lista só muda quando um objeto muda de geração, ponto em que um simples retorno de chamada pode atualizar os ponteiros. Se você se lembra de como funciona o Mark & ​​Sweep, isso faz mais sentido. Não há fixação e a remoção é como antes. Eu acredito que é assim que funciona no DependentHandle.

Esta última solução exige que o tempo de execução não reutilize os depósitos de lista até que eles sejam explicitamente liberados e também exige que todos os objetos sejam recuperados por uma chamada para o tempo de execução.

Se presumirmos que eles usam essa solução, também podemos resolver o segundo problema. O algoritmo Mark & ​​Sweep mantém registro de quais objetos foram coletados; assim que for coletado, sabemos neste ponto. Depois que o objeto verifica se o objeto está lá, ele chama 'Livre', que remove o ponteiro e a entrada da lista. O objeto realmente se foi.

Uma coisa importante a se observar neste ponto é que as coisas dão terrivelmente errado se ConditionalWeakTablefor atualizado em vários threads e não for seguro para threads. O resultado seria um vazamento de memória. É por isso que todas as chamadas ConditionalWeakTablefazem um simples 'bloqueio' que garante que isso não aconteça.

Outra coisa a observar é que a limpeza das entradas deve acontecer de vez em quando. Embora os objetos reais sejam limpos pelo GC, as entradas não são. É por isso que ConditionalWeakTableapenas cresce em tamanho. Uma vez que atinge um certo limite (determinado pela chance de colisão no hash), ele aciona um Resize, que verifica se os objetos precisam ser limpos - se o fizerem, freeé chamado no processo de GC, removendo o IntPtridentificador.

Eu acredito que é também por isso que DependentHandlenão é exposto diretamente - você não quer bagunçar as coisas e ter um vazamento de memória como resultado. A próxima melhor coisa para isso é um WeakReference(que também armazena um em IntPtrvez de um objeto) - mas infelizmente não inclui o aspecto de 'dependência'.

O que resta é você brincar com a mecânica, para poder ver a dependência em ação. Certifique-se de iniciá-lo várias vezes e observar os resultados:

class DependentObject
{
    public class MyKey : IDisposable
    {
        public MyKey(bool iskey)
        {
            this.iskey = iskey;
        }

        private bool disposed = false;
        private bool iskey;

        public void Dispose()
        {
            if (!disposed)
            {
                disposed = true;
                Console.WriteLine("Cleanup {0}", iskey);
            }
        }

        ~MyKey()
        {
            Dispose();
        }
    }

    static void Main(string[] args)
    {
        var dep = new MyKey(true); // also try passing this to cwt.Add

        ConditionalWeakTable<MyKey, MyKey> cwt = new ConditionalWeakTable<MyKey, MyKey>();
        cwt.Add(new MyKey(true), dep); // try doing this 5 times f.ex.

        GC.Collect(GC.MaxGeneration);
        GC.WaitForFullGCComplete();

        Console.WriteLine("Wait");
        Console.ReadLine(); // Put a breakpoint here and inspect cwt to see that the IntPtr is still there
    }

Se você está escrevendo um módulo em seu próprio código para um uso específico, o método do majkinetor PODE ter funcionado. Mas existem alguns problemas.

Em primeiro lugar , o documento oficial NÃO garante que o GetHashCode()retorne um identificador exclusivo (consulte Object.GetHashCode Method () ):

Você não deve presumir que códigos hash iguais implicam igualdade de objeto.

Em segundo lugar , suponha que você tenha uma quantidade muito pequena de objetos para que GetHashCode()funcione na maioria dos casos, este método pode ser substituído por alguns tipos.
Por exemplo, você está usando alguma classe C e ela sobrescreve GetHashCode()para sempre retornar 0. Então, cada objeto de C obterá o mesmo código hash. Infelizmente, Dictionary, HashTablee alguns outros recipientes associativas fará usar este método:

Um código hash é um valor numérico usado para inserir e identificar um objeto em uma coleção baseada em hash, como a classe Dictionary <TKey, TValue>, a classe Hashtable ou um tipo derivado da classe DictionaryBase. O método GetHashCode fornece esse código hash para algoritmos que precisam de verificações rápidas de igualdade de objeto.

Portanto, essa abordagem tem grandes limitações.

E mais ainda , e se você quiser construir uma biblioteca de uso geral? Não apenas você não pode modificar o código-fonte das classes utilizadas, mas seu comportamento também é imprevisível.

Agradeço que Jon e Simon tenham postado suas respostas e postarei um exemplo de código e uma sugestão de desempenho abaixo.

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Collections.Generic;


namespace ObjectSet
{
    public interface IObjectSet
    {
        /// <summary> check the existence of an object. </summary>
        /// <returns> true if object is exist, false otherwise. </returns>
        bool IsExist(object obj);

        /// <summary> if the object is not in the set, add it in. else do nothing. </summary>
        /// <returns> true if successfully added, false otherwise. </returns>
        bool Add(object obj);
    }

    public sealed class ObjectSetUsingConditionalWeakTable : IObjectSet
    {
        /// <summary> unit test on object set. </summary>
        internal static void Main() {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ObjectSetUsingConditionalWeakTable objSet = new ObjectSetUsingConditionalWeakTable();
            for (int i = 0; i < 10000000; ++i) {
                object obj = new object();
                if (objSet.IsExist(obj)) { Console.WriteLine("bug!!!"); }
                if (!objSet.Add(obj)) { Console.WriteLine("bug!!!"); }
                if (!objSet.IsExist(obj)) { Console.WriteLine("bug!!!"); }
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
        }


        public bool IsExist(object obj) {
            return objectSet.TryGetValue(obj, out tryGetValue_out0);
        }

        public bool Add(object obj) {
            if (IsExist(obj)) {
                return false;
            } else {
                objectSet.Add(obj, null);
                return true;
            }
        }

        /// <summary> internal representation of the set. (only use the key) </summary>
        private ConditionalWeakTable<object, object> objectSet = new ConditionalWeakTable<object, object>();

        /// <summary> used to fill the out parameter of ConditionalWeakTable.TryGetValue(). </summary>
        private static object tryGetValue_out0 = null;
    }

    [Obsolete("It will crash if there are too many objects and ObjectSetUsingConditionalWeakTable get a better performance.")]
    public sealed class ObjectSetUsingObjectIDGenerator : IObjectSet
    {
        /// <summary> unit test on object set. </summary>
        internal static void Main() {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ObjectSetUsingObjectIDGenerator objSet = new ObjectSetUsingObjectIDGenerator();
            for (int i = 0; i < 10000000; ++i) {
                object obj = new object();
                if (objSet.IsExist(obj)) { Console.WriteLine("bug!!!"); }
                if (!objSet.Add(obj)) { Console.WriteLine("bug!!!"); }
                if (!objSet.IsExist(obj)) { Console.WriteLine("bug!!!"); }
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
        }


        public bool IsExist(object obj) {
            bool firstTime;
            idGenerator.HasId(obj, out firstTime);
            return !firstTime;
        }

        public bool Add(object obj) {
            bool firstTime;
            idGenerator.GetId(obj, out firstTime);
            return firstTime;
        }


        /// <summary> internal representation of the set. </summary>
        private ObjectIDGenerator idGenerator = new ObjectIDGenerator();
    }
}

Em meu teste, o ObjectIDGeneratorlançará uma exceção para reclamar que há muitos objetos ao criar 10.000.000 objetos (10x do que no código acima) no forloop.

Além disso, o resultado do benchmark é que a ConditionalWeakTableimplementação é 1,8x mais rápida do que a ObjectIDGeneratorimplementação.