C# 實作一個基于值相等性比較的字典

Intro

今天在專案里遇到一個需求，大概是這樣的我要比較兩個 JSON 字串是不是相等，JSON 字串其實是一個 Dictionary<string, string> 但是順序可能不同，和上一篇 record 使用場景 中的第一個需求類似，前面我們介紹過使用 record 可以比較方便的解決，但是我們的專案是 .netcoreapp3.1 的，不能使用 record，如何比較方便的比較呢？我們能否自己實作一個類似于 record 的型別，基于值去比較呢？于是就有了本文的探索

StringValueDictioanry

實作了一個基于值進行比較的字典，實作代碼如下，實作的比較簡單，涉及到一些簡單的知識點，平時不怎么用已經忘了怎么寫了，通過寫下面的代碼又學習了一下

先來看測驗代碼吧，測驗代碼如下：

[Fact]
public void EqualsTest()
{
    var abc = new { Id = 1, Name = "Tom" };
    var dic1 = StringValueDictionary.FromObject(abc);
    var dic2 = StringValueDictionary.FromObject(new Dictionary<string, object>()
    {
        {"Name", "Tom" },
        {"Id", 1},
    });

    Assert.True(dic1 == dic2);
    Assert.Equal(dic1, dic2);
}

[Fact]
public void DistinctTest()
{
    var abc = new { Id = 1, Name = "Tom" };
    var dic1 = StringValueDictionary.FromObject(abc);
    var dic2 = StringValueDictionary.FromObject(new Dictionary<string, object>()
    {
        {"Id", 1},
        {"Name", "Tom" },
    });
    var set = new HashSet<StringValueDictionary>();
    set.Add(dic1);
    set.Add(dic2);

    Assert.Single(set);
}

[Fact]
public void CloneTest()
{
    var dic1 = StringValueDictionary.FromObject(new Dictionary<string, object>()
    {
        {"Id", 1},
        {"Name", "Tom" }
    });
    var dic2 = dic1.Clone();
    Assert.False(ReferenceEquals(dic1, dic2));
    Assert.True(dic1 == dic2);
}

[Fact]
public void ImplicitConvertTest()
{
    var abc = new { Id = 1, Name = "Tom" };
    var stringValueDictionary = StringValueDictionary.FromObject(abc);
    Dictionary<string, string> dictionary = stringValueDictionary;
    Assert.Equal(stringValueDictionary.Count, dictionary.Count);

    var dic2 = StringValueDictionary.FromObject(dictionary);

    Assert.Equal(dic2, stringValueDictionary);
    Assert.True(dic2 == stringValueDictionary);
}

從上面的代碼可能大概能看出一些實作，重寫了默認的 Equals 和 GetHashCode，并多載了“==” 運算子，并且實作了一個從 StringValueDictionary 到 Dictionary 的隱式轉換，來看下面的實作代碼：

public sealed class StringValueDictionary : IEquatable<StringValueDictionary>
{
    private readonly Dictionary<string, string?> _dictionary = new();

    private StringValueDictionary(IDictionary<string, string?> dictionary)
    {
        foreach (var pair in dictionary)
        {
            _dictionary[pair.Key] = pair.Value;
        }
    }

    private StringValueDictionary(StringValueDictionary dictionary)
    {
        foreach (var key in dictionary.Keys)
        {
            _dictionary[key] = dictionary[key];
        }
    }

    public static StringValueDictionary FromObject(object obj)
    {
        if (obj is null) throw new ArgumentNullException(nameof(obj));
        if (obj is IDictionary<string, string?> dictionary)
        {
            return new StringValueDictionary(dictionary);
        }
        if (obj is IDictionary<string, object?> dictionary2)
        {
            return new StringValueDictionary(dictionary2.ToDictionary(p => p.Key, p => p.Value?.ToString()));
        }
        if (obj is StringValueDictionary dictionary3)
        {
            return new StringValueDictionary(dictionary3);
        }
        return new StringValueDictionary(obj.GetType().GetProperties()
            .ToDictionary(p => p.Name, p => p.GetValue(obj)?.ToString()));
    }

    public static StringValueDictionary FromJson(string json)
    {
        Guard.NotNull(json, nameof(json));
        var dic = json.JsonToObject<Dictionary<string, object?>>()
            .ToDictionary(x => x.Key, x => x.Value?.ToString());
        return new StringValueDictionary(dic);
    }

    public StringValueDictionary Clone() => new(this);

    public int Count => _dictionary.Count;

    public bool ContainsKey(string key) => _dictionary.ContainsKey(key) ? _dictionary.ContainsKey(key) : throw new ArgumentOutOfRangeException(nameof(key));

    public string? this[string key] => _dictionary[key];

    public Dictionary<string, string>.KeyCollection Keys => _dictionary.Keys!;

    public bool Equals(StringValueDictionary? other)
    {
        if (other is null) return false;
        if (other.Count != Count) return false;
        foreach (var key in _dictionary.Keys)
        {
            if (!other.ContainsKey(key))
            {
                return false;
            }
            if (_dictionary[key] != other[key])
            {
                return false;
            }
        }
        return true;
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as StringValueDictionary);
    }

    public override int GetHashCode()
    {
        var stringBuilder = new StringBuilder();
        foreach (var pair in _dictionary)
        {
            stringBuilder.Append($"{pair.Key}={pair.Value}_");
        }
        return stringBuilder.ToString().GetHashCode();
    }

    public static bool operator ==(StringValueDictionary? current, StringValueDictionary? other)
    {
        return current?.Equals(other) == true;
    }

    public static bool operator !=(StringValueDictionary? current, StringValueDictionary? other)
    {
        return current?.Equals(other) != true;
    }

    public static implicit operator Dictionary<string, string?>(StringValueDictionary dictionary)
    {
        return dictionary._dictionary;
    }
}

More

上述代碼實作的有點粗糙，可能會有一些問題，僅供參考

以上代碼基本實作了基于想要的值的相等性比較以及 Clone（復制、克隆）的目標

實作相等性比較的時候，Equals 和 GetHashCode 方法也要重寫，如果沒有重寫 GetHashCode，編譯器也會給出警告，如果沒有重寫 GetHashCode 在實際在 HashSet 或者 Dictionary 里可能會出現重復 key

多載運算子的時候需要一個靜態方法，"==" 和 "!=" 是一對操作運算子，如果要實作兩個都要實作，不能只實作其中一個

implicit 也算是一個特殊的運算子，巧妙的使用隱式轉換可以大大簡化代碼的寫法，StackExchange.Redis 中就使用了 implicit 來實作 RedisValue 和 string 等其他常用型別的隱式轉換

References

• https://github.com/WeihanLi/WeihanLi.Common/blob/dev/src/WeihanLi.Common/Models/StringValueDictionary.cs
• https://github.com/WeihanLi/WeihanLi.Common/blob/dev/test/WeihanLi.Common.Test/ModelsTest/StringValueDictionaryTest.cs

標籤：C#

上一篇：C#基礎篇——Hello World

下一篇：巧用lock解決快取擊穿的解決方案