[fixes] UInt160 Class

src/Neo/UInt160.cs

@@ -11,8 +11,9 @@
 
 using Neo.IO;
 using System;
-using System.Globalization;
 using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace Neo
@@ -31,68 +32,72 @@ public class UInt160 : IComparable<UInt160>, IEquatable<UInt160>, ISerializable
         /// <summary>
         /// Represents 0.
         /// </summary>
-        public static readonly UInt160 Zero = new();
+        public static UInt160 Zero => new();
 
-        [FieldOffset(0)] private ulong value1;
-        [FieldOffset(8)] private ulong value2;
-        [FieldOffset(16)] private uint value3;
+        [FieldOffset(0)] private ulong _value1;
+        [FieldOffset(8)] private ulong _value2;
+        [FieldOffset(16)] private uint _value3;
 
         public int Size => Length;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="UInt160"/> class.
         /// </summary>
-        public UInt160()
-        {
-        }
+        public UInt160() { }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="UInt160"/> class.
         /// </summary>
         /// <param name="value">The value of the <see cref="UInt160"/>.</param>
-        public unsafe UInt160(ReadOnlySpan<byte> value)
+        public UInt160(ReadOnlySpan<byte> value)
         {
-            if (value.Length != Length) throw new FormatException();
-            fixed (ulong* p = &value1)
-            {
-                Span<byte> dst = new(p, Length);
-                value[..Length].CopyTo(dst);
-            }
+            if (value.Length != Length)
+                throw new FormatException();
+
+            var bytes = value.ToArray();
+            _value1 = Unsafe.As<byte, ulong>(ref bytes[0]);
+            _value2 = Unsafe.As<byte, ulong>(ref bytes[8]);
+            _value3 = Unsafe.As<byte, uint>(ref bytes[16]);
         }
 
         public int CompareTo(UInt160 other)
         {
-            int result = value3.CompareTo(other.value3);
+            var result = _value3.CompareTo(other._value3);
             if (result != 0) return result;
-            result = value2.CompareTo(other.value2);
+            result = _value2.CompareTo(other._value2);
             if (result != 0) return result;
-            return value1.CompareTo(other.value1);
+            return _value1.CompareTo(other._value1);
         }
 
         public void Deserialize(ref MemoryReader reader)
         {
-            value1 = reader.ReadUInt64();
-            value2 = reader.ReadUInt64();
-            value3 = reader.ReadUInt32();
+            _value1 = reader.ReadUInt64();
+            _value2 = reader.ReadUInt64();
+            _value3 = reader.ReadUInt32();
         }
 
         public override bool Equals(object obj)
         {
-            if (ReferenceEquals(obj, this)) return true;
-            return Equals(obj as UInt160);
+            if (obj == null)
+                return false;
+
+            var other = obj as UInt160;
+            if (other == null)
+                return false;
+            return Equals(other);
         }
 
         public bool Equals(UInt160 other)
         {
-            if (other is null) return false;
-            return value1 == other.value1
-                && value2 == other.value2
-                && value3 == other.value3;
+            if (other == null) return false;
+            return _value1 == other._value1 &&
+                _value2 == other._value2 &&
+                _value3 == other._value3;
         }
 
         public override int GetHashCode()
         {
-            return (int)value1;
+            return HashCode.Combine(_value1, _value2, _value3);
         }
 
         /// <summary>
@@ -109,9 +114,9 @@ public static UInt160 Parse(string value)
 
         public void Serialize(BinaryWriter writer)
         {
-            writer.Write(value1);
-            writer.Write(value2);
-            writer.Write(value3);
+            writer.Write(_value1);
+            writer.Write(_value2);
+            writer.Write(_value3);
         }
 
         public override string ToString()
@@ -122,44 +127,60 @@ public override string ToString()
         /// <summary>
         /// Parses an <see cref="UInt160"/> from the specified <see cref="string"/>.
         /// </summary>
-        /// <param name="s">An <see cref="UInt160"/> represented by a <see cref="string"/>.</param>
+        /// <param name="str">An <see cref="UInt160"/> represented by a <see cref="string"/>.</param>
         /// <param name="result">The parsed <see cref="UInt160"/>.</param>
         /// <returns><see langword="true"/> if an <see cref="UInt160"/> is successfully parsed; otherwise, <see langword="false"/>.</returns>
-        public static bool TryParse(string s, out UInt160 result)
+        public static bool TryParse(string str, out UInt160 result)
         {
-            if (s == null)
+            result = null;
+
+            if (string.IsNullOrWhiteSpace(str)) return false;
+
+            if (str.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase))
+                str = str[2..];
+
+            if (str.Length != Length * 2) return false;
+
+            try
             {
-                result = null;
-                return false;
+                var data = Enumerable.Range(0, Length)
+                    .Select(s => Convert.ToByte(str.Substring(s * 2, 2), 16))
+                    .Reverse()
+                    .ToArray();
+
+                result = new(data);
+                return true;
             }
-            if (s.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase))
-                s = s[2..];
-            if (s.Length != Length * 2)
+            catch
             {
-                result = null;
                 return false;
             }
-            byte[] data = new byte[Length];
-            for (int i = 0; i < Length; i++)
-                if (!byte.TryParse(s.Substring(i * 2, 2), NumberStyles.AllowHexSpecifier, null, out data[Length - i - 1]))
-                {
-                    result = null;
-                    return false;
-                }
-            result = new UInt160(data);
-            return true;
+        }
+
+        public static implicit operator UInt160(string s)
+        {
+            return Parse(s);
+        }
+
+        public static implicit operator UInt160(byte[] b)
+        {
+            return new UInt160(b);
         }
 
         public static bool operator ==(UInt160 left, UInt160 right)
         {
             if (ReferenceEquals(left, right)) return true;
-            if (left is null || right is null) return false;
+            if (left is null || right is null)
+                return Equals(left, right);
             return left.Equals(right);
         }
 
         public static bool operator !=(UInt160 left, UInt160 right)
         {
-            return !(left == right);
+            if (ReferenceEquals(left, right)) return false;
+            if (left is null || right is null)
+                return !Equals(left, right);
+            return !left.Equals(right);
         }
 
         public static bool operator >(UInt160 left, UInt160 right)

tests/Neo.UnitTests/UT_UInt160.cs

@@ -9,11 +9,10 @@
 // Redistribution and use in source and binary forms with or without
 // modifications are permitted.
 
-#pragma warning disable CS1718
-
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
+using System.Security.Cryptography;
 
 namespace Neo.UnitTests.IO
 {
@@ -36,8 +35,16 @@ public void TestGernerator1()
         [TestMethod]
         public void TestGernerator2()
         {
-            UInt160 uInt160 = new UInt160(new byte[20]);
+            UInt160 uInt160 = new byte[20];
+            Assert.IsNotNull(uInt160);
+        }
+
+        [TestMethod]
+        public void TestGernerator3()
+        {
+            UInt160 uInt160 = "0xff00000000000000000000000000000000000001";
             Assert.IsNotNull(uInt160);
+            Assert.IsTrue(uInt160.ToString() == "0xff00000000000000000000000000000000000001");
         }
 
         [TestMethod]
@@ -57,9 +64,13 @@ public void TestEquals()
             byte[] temp = new byte[20];
             temp[19] = 0x01;
             UInt160 result = new UInt160(temp);
-            Assert.AreEqual(true, UInt160.Zero.Equals(UInt160.Zero));
-            Assert.AreEqual(false, UInt160.Zero.Equals(result));
-            Assert.AreEqual(false, result.Equals(null));
+            Assert.IsTrue(UInt160.Zero.Equals(UInt160.Zero));
+            Assert.IsFalse(UInt160.Zero.Equals(result));
+            Assert.IsFalse(result.Equals(null));
+            Assert.IsTrue(UInt160.Zero == UInt160.Zero);
+            Assert.IsFalse(UInt160.Zero != UInt160.Zero);
+            Assert.IsTrue(UInt160.Zero == "0x0000000000000000000000000000000000000000");
+            Assert.IsFalse(UInt160.Zero == "0x0000000000000000000000000000000000000001");
         }
 
         [TestMethod]
@@ -92,24 +103,28 @@ public void TestTryParse()
         public void TestOperatorLarger()
         {
             Assert.AreEqual(false, UInt160.Zero > UInt160.Zero);
+            Assert.IsFalse(UInt160.Zero > "0x0000000000000000000000000000000000000000");
         }
 
         [TestMethod]
         public void TestOperatorLargerAndEqual()
         {
             Assert.AreEqual(true, UInt160.Zero >= UInt160.Zero);
+            Assert.IsTrue(UInt160.Zero >= "0x0000000000000000000000000000000000000000");
         }
 
         [TestMethod]
         public void TestOperatorSmaller()
         {
             Assert.AreEqual(false, UInt160.Zero < UInt160.Zero);
+            Assert.IsFalse(UInt160.Zero < "0x0000000000000000000000000000000000000000");
         }
 
         [TestMethod]
         public void TestOperatorSmallerAndEqual()
         {
             Assert.AreEqual(true, UInt160.Zero <= UInt160.Zero);
+            Assert.IsTrue(UInt160.Zero >= "0x0000000000000000000000000000000000000000");
         }
     }
 }