如何在 .NET 中表示 URN（统一资源名称），以便 Equals 按预期工作

Question

RFC2141提到：

6. 词汇等价的例子

   以下 URN 比较突出显示了词汇等价
   定义：

       1- URN:foo:a123,456
       2- urn:foo:a123,456
       3- urn:FOO:a123,456
       4- urn:foo:A123,456
       5- urn:foo:a123%2C456
       6- URN:FOO:a123%2c456
   

   URN 1、2 和 3 在词法上都是等效的。

随后的RFC8141保留了该等价性：

2.1. 命名空间标识符 (NID)

NID 不区分大小写（例如，“ISBN”和“isbn”是等效的）。

我可以在 .NET 框架中轻松找到的最接近的 URN 表示形式是URI 类。然而，它似乎并没有完全尊重 RFC 的等效定义：

    [TestMethod]
    public void TestEquivalentUrnsAreBroken()
    {
        Assert.AreEqual(
            new Uri("URN:foo:a123,456"),
            new Uri("urn:foo:a123,456"));

        Assert.AreEqual(
            new Uri("urn:foo:a123,456"),
            new Uri("urn:FOO:a123,456"));
    }

在上面的代码示例中，第一个断言按预期工作，而第二个断言失败。

是否有任何合理的方法可以让 URI 类遵守等效定义？我应该使用其他课程吗？

请注意，我已经找到了URN 类，但文档提到不应直接使用它。

Answer 1

Uri类不支持开箱即用的方案的特定解析器。urn:也许可以理解，因为即使 NID 的比较规则指定它不区分大小写，比较两个 NSS 的规则也将取决于特定命名空间定义的规则（根据RFC 8141）。

对于快速而肮脏的方法，您可以尝试使用Uri.Compare()方法。如果两个 URI 相等，它将返回零，否则返回非零。

var u1 = new Uri("URN:foo:a123,456");
var u2 = new Uri("urn:foo:a123,456");
var u3 = new Uri("urn:FOO:a123,456");
var u4 = new Uri("urn:nope:a123,456");

Console.WriteLine(Uri.Compare(u1, u2, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase)); // 0
Console.WriteLine(Uri.Compare(u1, u3, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase)); // 0
Console.WriteLine(Uri.Compare(u2, u3, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase)); // 0
Console.WriteLine(Uri.Compare(u3, u4, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase)); // -8

对于更冒险的方法，您可以按照以下方式进行操作。这需要仔细思考才能正确实施。该代码并不意味着按原样使用，而是作为起点。

using System;
using System.Text.RegularExpressions;
                    
public class Program
{
    public static void Main()
    {
        var u1 = new Urn("URN:foo:a123,456");
        var u2 = new Urn("urn:foo:a123,456");
        var u3 = new Urn("urn:foo:a123,456");
        var u4 = new Urn("urn:FOO:a123,456");
        var u5 = new Urn("urn:not-this-one:a123,456");
        Console.WriteLine(u1 == u2); // True
        Console.WriteLine(u3 == u4); // True
        Console.WriteLine(u4 == u5); // False
    }

    public class Urn : Uri
    {
        public const string UrnScheme = "urn";
        private const RegexOptions UrnRegexOptions = RegexOptions.Singleline | RegexOptions.CultureInvariant;
        private static Regex UrnRegex = new Regex("^urn:(?<NID>[a-z|A-Z][a-z|A-Z|-]{0,30}[a-z|A-Z]):(?<NSS>.*)$", UrnRegexOptions);

        public string NID { get; }
        public string NSS { get; }

        public Urn(string s) : base(s, UriKind.Absolute)
        {
            if (this.Scheme != UrnScheme) throw new FormatException($"URN scheme must be '{UrnScheme}'.");
            var match = UrnRegex.Match(this.AbsoluteUri);
            if (!match.Success) throw new FormatException("URN's NID is invalid.");
            NID = match.Groups["NID"].Value;
            NSS = match.Groups["NSS"].Value;
        }

        public override bool Equals(object other)
        {
            if (ReferenceEquals(other, this)) return true;
            return
                other is Urn u &&
                string.Equals(NID, u.NID, StringComparison.InvariantCultureIgnoreCase) &&
                string.Equals(NSS, u.NSS, StringComparison.Ordinal);
        }

        public override int GetHashCode() => base.GetHashCode();

        public static bool operator == (Urn u1, Urn u2)
        {
            if (ReferenceEquals(u1, u2)) return true;
            if (ReferenceEquals(u1, null) || ReferenceEquals(u2, null)) return false;
            return u1.Equals(u2);
        }

        public static bool operator != (Urn u1, Urn u2)
        {
            if (ReferenceEquals(u1, u2)) return false;
            if (ReferenceEquals(u1, null) || ReferenceEquals(u2, null)) return true;
            return !u1.Equals(u2);
        }
    }
}