Question

想象一下，我有一个类，有两个实例：

MyClass a = new MyClass();
MyClass b = new MyClass();

MyClass有一个方法PrintUniqueInstanceID：

void PrintUniqueInstanceID()
{
  Console.Write("Unique ID for the *instance* of this class: {0}", 
      [what goes here???]
  );
}

理想情况下，输出类似于：

Unique ID for the *instance* of this class: 23439434        // from a.PrintUniqueInstanceID
Unique ID for the *instance* of this class: 89654           // from b.PrintUniqueInstanceID

那么 - 我会在上面的“[what goes here???]”中插入什么，它会为每个类的唯一实例打印一个唯一的数字？

观

也许将“this”转换为int指针，并使用它？
以某种方式使用GCHandle？
在方法中访问“this”的属性，以唯一标识它？

（可选）专家背景资料

我需要这个的原因是我使用AOP和PostSharp来自动检测线程问题。我需要在字典中查找类的每个唯一实例，以验证多个线程没有访问类的相同唯一实例（如果每个类实例有一个线程，则确定）。

更新

正如其他人所指出的，我应该提到我不能触及30,000线项目中的任何现有类。上面的PrintUniqueInstanceID是一个方面（参见PostSharp），它被添加到顶级类，由整个项目中的每个类继承，并在整个项目中的每个方法条目上执行。

一旦我确认一切都是线程安全的，我将删除该方面以恢复性能。

Answer 1

向您的类添加Guid属性，然后在类的构造函数中将其分配给NewGuid（）。

public class MyClass
{
    public Guid InstanceID {get; private set;}
    // Other properties, etc.

    public MyClass()
    {
        this.InstanceID = Guid.NewGuid();
    }

    void PrintUniqueInstanceID() 
    {   
        Console.Write("Unique ID for the *instance* of this class: {0}", this.InstanceID); 
    } 
}

Answer 2

修订答案

根据我们现有的其他信息，我相信您可以使用ConditionalWeakTable（仅从.NET 4开始）轻松解决您的问题。

它可用于将任意数据与托管对象实例相关联
它使用引用相等来确定对象标识;移动，类作者不能修改这种行为（因为你不是地球上每个班级的作者都很方便）

可以即时填充

因此，您可以在“经理”类中创建此类全局表，并将每个对象与long，Guid或您可能需要的任何其他内容相关联。每当你的经理遇到一个对象时，它就可以获得它的相关id（如果你之前已经看过它），或者将它添加到表中并将其与当场创建的新id相关联。

¹实际上表中的值必须是引用类型，因此您不能使用例如long直接作为值类型。但是，一个简单的解决方法是使用object代替long值。

原始答案

这不是static成员的基本用法示例吗？

class Foo { private static int instanceCounter; private readonly int instanceId; Foo() { this.instanceId = ++instanceCounter; } public int UniqueId { get { return this.instanceId; } } }

当然，您必须注意标识符的范围，以便在创建数十亿个实例时不会重新使用它们，但这很容易解决。

Answer 3

使用ObjectIDGenerator类：

http://msdn.microsoft.com/en-us/library/system.runtime.serialization.objectidgenerator.aspx

引用：

ID在ObjectIDGenerator实例的生命周期中是唯一的。

使用哈希表，ObjectIDGenerator会保留分配的ID   到哪个对象。对象引用，唯一标识每个   object，是运行时垃圾收集堆中的地址。宾语   参考值可以在序列化期间更改，但表格是   自动更新，以便信息正确。

对象ID是64位数字。分配从一个开始，所以零是   永远不是有效的对象ID。格式化程序可以选择零值   表示值为null的对象引用。

<强>更新

这是解决问题的代码。在方面类中，使用以下内容：

public static ObjectIDGenerator ObjectIDGen = new ObjectIDGenerator();

然后：

bool firstTime;
long classInstanceID = ObjectIDGenerator.GetId(args.Instance, out firstTime);

<强>更新

以为我会发布整个帖子所基于的代码。此代码通过在多个线程访问同一个类实例时触发警告，帮助检测整个项目中的线程安全热点。

如果您有30k行现有代码，并且想要添加更正式的线程安全验证（这是非常难以正常执行的事情），这很有用。它确实会影响运行时性能，因此您可以在调试模式下运行它几天后将其删除。

要使用，请将PostSharp +此类添加到项目中，然后将“[MyThreadSafety]”方面添加到任何类。 PostSharp将在每次方法调用之前在“OnEntry”中插入代码。方面传播到所有子类和子方法，因此您只需使用一行代码就可以将线程安全检查添加到整个项目中。

有关此技术的另一个示例，请参阅example designed to easily add caching to method calls。

    using System;
    using System.Diagnostics;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.Serialization;
    using System.Text;
    using System.Threading;
    using MyLogType;
    using PostSharp.Aspects;
    using System.Collections.Concurrent;
    using PostSharp.Extensibility;

    namespace Demo
    {
        /// <summary>
        /// Example code based on the page from a Google search of:
        /// postsharp "Example: Tracing Method Execution"
        /// </summary>
        [Serializable]
        public sealed class MyThreadSafetyCheck : OnMethodBoundaryAspect
        {
            /// <summary>
            /// We need to be able to track if a different ThreadID is seen when executing a method within the *same* instance of a class. Its
            /// ok if we see different ThreadID values when accessing different instances of a class. In fact, creating one copy of a class per
            /// thread is a reliable method to fix threading issues in the first place.
            /// 
            /// Key: unique ID for every instance of every class.
            /// Value: LastThreadID, tracks the ID of the last thread which accessed the current instance of this class.
            /// </summary>
            public static ConcurrentDictionary<long, int> DetectThreadingIssues = new ConcurrentDictionary<long, int>();

            /// <summary>
            /// Allows us to generate a unique ID for each instance of every class that we see.
            /// </summary>
            public static ObjectIDGenerator ObjectIDGenerator = new ObjectIDGenerator();

            /// <summary>
            /// These fields are initialized at runtime. They do not need to be serialized.
            /// </summary>
            [NonSerialized]
            private string MethodName;

            [NonSerialized]
            private long LastTotalMilliseconds;

            /// <summary>
            /// Stopwatch which we can use to avoid swamping the log with too many messages for threading violations.
            /// </summary>
            [NonSerialized]
            private Stopwatch sw;

            /// <summary>
            /// Invoked only once at runtime from the static constructor of type declaring the target method. 
            /// </summary>
            /// <param name="method"></param>
            public override void RuntimeInitialize(MethodBase method)
            {
                if (method.DeclaringType != null)
                {
                    this.MethodName = method.DeclaringType.FullName + "." + method.Name;
                }

                this.sw = new Stopwatch();
                this.sw.Start();

                this.LastTotalMilliseconds = -1000000;
            }

            /// <summary>
            /// Invoked at runtime before that target method is invoked.
            /// </summary>
            /// <param name="args">Arguments to the function.</param>   
            public override void OnEntry(MethodExecutionArgs args)
            {
                if (args.Instance == null)
                {
                    return;
                }

                if (this.MethodName.Contains(".ctor"))
                {
                    // Ignore the thread that accesses the constructor.
                    // If we remove this check, then we get a false positive.
                    return;
                }

                bool firstTime;
                long classInstanceID = ObjectIDGenerator.GetId(args.Instance, out firstTime);

                if (firstTime)
                {
                    // This the first time we have called this, there is no LastThreadID. Return.
                    if (DetectThreadingIssues.TryAdd(classInstanceID, Thread.CurrentThread.ManagedThreadId) == false)
                    {
                        Console.Write(string.Format("{0}Error E20120320-1349. Could not add an initial key to the \"DetectThreadingIssues\" dictionary.\n",
                            MyLog.NPrefix()));
                    }
                    return;
                }

                int lastThreadID = DetectThreadingIssues[classInstanceID];

                // Check 1: Continue if this instance of the class was accessed by a different thread (which is definitely bad).
                if (lastThreadID != Thread.CurrentThread.ManagedThreadId)
                {
                    // Check 2: Are we printing more than one message per second?
                    if ((sw.ElapsedMilliseconds - this.LastTotalMilliseconds) > 1000)
                    {
                        Console.Write(string.Format("{0}Warning: ThreadID {1} then {2} accessed \"{3}\". To remove warning, manually check thread safety, then add \"[MyThreadSafetyCheck(AttributeExclude = true)]\".\n",
                            MyLog.NPrefix(), lastThreadID, Thread.CurrentThread.ManagedThreadId, this.MethodName));
                        this.LastTotalMilliseconds = sw.ElapsedMilliseconds;
                    }
                }

                // Update the value of "LastThreadID" for this particular instance of the class.
                DetectThreadingIssues[classInstanceID] = Thread.CurrentThread.ManagedThreadId;
            }
        }
    }

我可以按需提供完整的演示项目。

Answer 4

调试时一种有效的（非自动）解决方案是右键单击一个实例，然后选择“生成对象ID”。它将在您的实例名称和类旁边附加一个{$1}。

如果稍后您偶然发现另一个实例，它将丢失{$1}标记。

Answer 5

您不能从基类或接口继承所有类，并且需要实现UniqueID属性吗？

另一种可能性是将它们包装在一个包含通用对象引用和唯一ID的类中，然后按照懒惰的方式对它们进行编目。清理这样一个独特任务目录可能很尴尬。

Answer 6

可以使用：

ClassName + MethodName + this.GetHashCode();

虽然GetHashCode（）不保证唯一值，但如果它与类名和方法名配对，则冲突的可能性会降低。

即使存在冲突，唯一的影响是它会在日志中生成更多警告，这不是什么大问题。

我如何获得一个允许我分辨一个类的差异实例的ID？

6 个答案:

修订答案

原始答案