Question

我们必须为对象创建一致的Guid。我正在考虑采用以下方法为具有相同属性的对象创建唯一的guid，不知何故感觉不对。

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
    {
        return "Person: " + Name + " " + Age;
    }
}

// Below tool is taken from http://stackoverflow.com/questions/2642141/how-to-create-deterministic-guids
Guid guid = GuidUtility.Create(GLOBAL, new Person(..).ToString();

我想要。

我想到的另一个可能的解决方案是在持久存储中保存Map<Guid, serialized Object>，并且每次创建新对象时都会查看具有相同属性的对象是否已存在。

RFC 4122很有可能保证每个命名空间和名称都具有确定性和唯一性。 https://tools.ietf.org/html/rfc4122#page-13 请给我任何建议。谢谢

Answer 1

我在这个答案GetHashCode上使用哈希算法提出了这个问题。显然，对于具有相同哈希码的不同有价值对象，总是存在冲突问题。但是这个问题是不可解决的，因为你本质上是从无限域转换到非常有限的范围，大多数是32位，对于Guid的128位。对于那种问题唯一的解决方法是，即使它发生的可能性非常低，正如你所说，实施一个查找表。

public static class ConsistentGuid
{
    public static System.Guid Generate(object obj)
    {
        var bytes = new byte[16];

        var type = obj.GetType();

        var features = new object[]
        {
            type,
            obj
        };

        BitConverter.GetBytes(LongHash(features))
            .CopyTo(bytes, 0);

        var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
        features = new object[properties.Length];
        for (int i = 0; i < properties.Length; i++)
            features[i] = properties[i].GetValue(obj);

        BitConverter.GetBytes(LongHash(features))
            .CopyTo(bytes, 8);

        return new System.Guid(bytes);
    }

    public static int Hash(object[] features, uint seed = 2166136261)
    {
        // https://stackoverflow.com/questions/263400/what-is-the-best-algorithm-for-an-overridden-system-object-gethashcode/263416#263416
        unchecked // Overflow is fine, just wrap
        {
            int hash = (int)seed;
            for (int i = 0; i < features.Length; i++)
            {
                if (features[i] == null) // Suitable nullity checks etc, of course :)
                    continue;

                hash = (hash * 16777619) ^ features[i].GetHashCode();
            }

            return hash;
        }
    }

    private static long LongHash(object[] features, ulong seed = 2166136261)
    {
        // https://stackoverflow.com/questions/263400/what-is-the-best-algorithm-for-an-overridden-system-object-gethashcode/263416#263416
        unchecked // Overflow is fine, just wrap
        {
            long hash = (long)seed;
            for (int i = 0; i < features.Length; i++)
            {
                if (features[i] == null) // Suitable nullity checks etc, of course :)
                    continue;

                hash = (hash * 16777619) ^ features[i].GetHashCode();
            }

            return hash;
        }
    }
}

以下是通过的测试;

public class ConsistentGuidTests
{
    [Fact]
    public void Referencewise_Equal_Objects_Should_Generate_Same_Guids()
    {
        var obj = new object();
        var obj2 = obj;

        var guid1 = ConsistentGuid.Generate(obj);
        var guid2 = ConsistentGuid.Generate(obj2);

        Assert.True(ReferenceEquals(obj, obj2));
        Assert.Equal(guid1, guid2);
    }

    [Fact]
    public void ValueObjects_Of_DifferentTypes_Should_Generate_Different_Guids()
    {
        var obj = new object();
        var other = new int();

        var guid1 = ConsistentGuid.Generate(obj);
        var guid2 = ConsistentGuid.Generate(other);

        Assert.NotEqual(guid1, guid2);
    }

    [Fact]
    public void ValueObjects_With_Same_Values_Should_Generate_Same_Guids()
    {
        var obj = 123;
        var other = 123;

        var guid1 = ConsistentGuid.Generate(obj);
        var guid2 = ConsistentGuid.Generate(other);

        Assert.False(ReferenceEquals(obj, other));
        Assert.Equal(guid1, guid2);
    }

    [Fact]
    public void ValueObjects_With_Different_Values_Should_Generate_Different_Guids()
    {
        var obj = 123;
        var other = 124;

        var guid1 = ConsistentGuid.Generate(obj);
        var guid2 = ConsistentGuid.Generate(other);

        Assert.NotEqual(guid1, guid2);
    }

    class AReferenceType
    {
        public int SomeProperty { get; set; }
        public string SomeOtherProperty { get; set; }

        public AReferenceType(int a, string b)
        {
            SomeProperty = a;
            SomeOtherProperty = b;
        }

        public override int GetHashCode()
        {
            return ConsistentGuid.Hash(new object[]
            {
                SomeProperty,
                SomeOtherProperty
            });
        }
    }

    [Fact]
    public void ReferenceObjects_With_Same_Values_Should_Generate_Same_Guids()
    {
        var a = 123;
        var b = "asd";

        var obj = new AReferenceType(a, b);
        var other = new AReferenceType(a, b);

        var guid1 = ConsistentGuid.Generate(obj);
        var guid2 = ConsistentGuid.Generate(other);

        Assert.False(ReferenceEquals(obj, other));
        Assert.Equal(obj.GetHashCode(), other.GetHashCode());
        Assert.Equal(guid1, guid2);
    }

    [Fact]
    public void ReferenceObjects_With_Different_Values_Should_Generate_Different_Guids()
    {
        var a = 123;
        var b = "asd";

        var obj = new AReferenceType(a, b);
        var other = new AReferenceType(a + 1, b);

        var guid1 = ConsistentGuid.Generate(obj);
        var guid2 = ConsistentGuid.Generate(other);

        Assert.NotEqual(guid1, guid2);
    }
}

为对象创建一致的Guid

1 个答案: