Merge branch 'master' into feature/1.0

Author: ymh199478

CatLib.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26430.16
+VisualStudioVersion = 15.0.26430.13
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CatLib", "projects\CatLib\CatLib.csproj", "{BBB2DAE2-638B-4419-9591-3CECCA312E4E}"
 EndProject

projects/CatLib.API/Hashing/Checksums.cs

@@ -14,16 +14,33 @@ namespace CatLib.API.Hashing
  /// <summary>
  /// 使用的校验方法
  /// </summary>
- public enum Checksums
+ public class Checksums : Enum
  {
  /// <summary>
  /// Adler32
  /// </summary>
- Adler32,
+ public static readonly Checksums Adler32 = new Checksums("Adler32");
 
  /// <summary>
  /// Crc32
  /// </summary>
- Crc32,
+ public static readonly Checksums Crc32 = new Checksums("Crc32");
+
+ /// <summary>
+ /// 哈希算法类型
+ /// </summary>
+ /// <param name="name">哈希算法名字</param>
+ protected Checksums(string name) : base(name)
+ {
+ }
+
+ /// <summary>
+ /// 字符串转Checksums
+ /// </summary>
+ /// <param name="type">类型</param>
+ public static implicit operator Checksums(string type)
+ {
+ return new Checksums(type);
+ }
  }
 }

projects/CatLib.API/Hashing/Hashes.cs

@@ -14,16 +14,33 @@ namespace CatLib.API.Hashing
  /// <summary>
  /// 哈希算法
  /// </summary>
- public enum Hashes
+ public class Hashes : Enum
  {
  /// <summary>
  /// DJB Hash
  /// </summary>
- Djb,
+ public static readonly Hashes Djb = new Hashes("Djb");
 
  /// <summary>
  /// Murmur Hash
  /// </summary>
- MurmurHash
+ public static readonly Hashes MurmurHash = new Hashes("MurmurHash");
+
+ /// <summary>
+ /// 哈希算法类型
+ /// </summary>
+ /// <param name="name">哈希算法名字</param>
+ protected Hashes(string name) : base(name)
+ {
+ }
+
+ /// <summary>
+ /// 字符串转Hashes
+ /// </summary>
+ /// <param name="type">类型</param>
+ public static implicit operator Hashes(string type)
+ {
+ return new Hashes(type);
+ }
  }
 }

projects/CatLib.API/Hashing/IHashing.cs

@@ -18,13 +18,20 @@ namespace CatLib.API.Hashing
  /// </summary>
  public interface IHashing
  {
+ /// <summary>
+ /// 计算校验和
+ /// </summary>
+ /// <param name="buffer">字节数组</param>
+ /// <returns>校验和</returns>
+ long Checksum(byte[] buffer);
+
  /// <summary>
  /// 计算校验和
  /// </summary>
  /// <param name="buffer">字节数组</param>
  /// <param name="checksum">使用校验类类型</param>
  /// <returns>校验和</returns>
- long Checksum(byte[] buffer , Checksums checksum = Checksums.Crc32);
+ long Checksum(byte[] buffer, Checksums checksum);
 
  /// <summary>
  /// 对输入值进行加密性Hash
@@ -42,13 +49,20 @@ public interface IHashing
  /// <returns>是否匹配</returns>
  bool CheckPassword(string input, string hash);
 
+ /// <summary>
+ /// 对输入值进行非加密哈希
+ /// </summary>
+ /// <param name="input">输入值</param>
+ /// <returns>哈希值</returns>
+ uint HashString(string input);
+
  /// <summary>
  /// 对输入值进行非加密哈希
  /// </summary>
  /// <param name="input">输入值</param>
  /// <param name="hash">使用的哈希算法</param>
  /// <returns>哈希值</returns>
- uint HashString(string input, Hashes hash = Hashes.MurmurHash);
+ uint HashString(string input, Hashes hash);
 
  /// <summary>
  /// 对输入值进行非加密哈希
@@ -57,14 +71,21 @@ public interface IHashing
  /// <param name="encoding">编码</param>
  /// <param name="hash">使用的哈希算法</param>
  /// <returns>哈希值</returns>
- uint HashString(string input, Encoding encoding, Hashes hash = Hashes.MurmurHash);
+ uint HashString(string input, Encoding encoding, Hashes hash);
+
+ /// <summary>
+ /// 对输入值进行非加密哈希
+ /// </summary>
+ /// <param name="input">输入值</param>
+ /// <returns>哈希值</returns>
+ uint HashByte(byte[] input);
 
  /// <summary>
  /// 对输入值进行非加密哈希
  /// </summary>
  /// <param name="input">输入值</param>
  /// <param name="hash">使用的哈希算法</param>
  /// <returns>哈希值</returns>
- uint HashByte(byte[] input, Hashes hash = Hashes.MurmurHash);
+ uint HashByte(byte[] input, Hashes hash);
  }
 }

projects/CatLib.Tests/Hashing/HashingProviderTests.cs

@@ -43,14 +43,18 @@ public void TestCrc64()
  {
  var app = MakeEnv();
  var hash = app.Make<IHashing>();
+ var code0 = hash.Checksum(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
  var code = hash.Checksum(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, Checksums.Crc32);
  var code2 = hash.Checksum(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, Checksums.Crc32);
  var code3 = hash.Checksum(new byte[] { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, Checksums.Crc32);
  var code4 = hash.Checksum(System.Text.Encoding.Default.GetBytes("123"), Checksums.Crc32);
+ var code5 = hash.Checksum(System.Text.Encoding.Default.GetBytes("123"));
 
+ Assert.AreEqual(code, code0);
  Assert.AreEqual(code , code2);
  Assert.AreNotEqual(code2 , code3);
  Assert.AreEqual(2286445522, code4);
+ Assert.AreEqual(2286445522, code5);
  }
 
  [TestMethod]
@@ -102,12 +106,16 @@ public void TestMurmurHash()
  var app = MakeEnv();
  var hash = app.Make<IHashing>();
 
+ var hash0 = hash.HashString("helloworld");
  var hash1 = hash.HashString("helloworld", Hashes.MurmurHash);
  var hash2 = hash.HashString("helloworld", Hashes.MurmurHash);
  var hash3 = hash.HashString("helloworl", Hashes.MurmurHash);
+ var hash4 = hash.HashByte(System.Text.Encoding.Default.GetBytes("helloworl"));
 
+ Assert.AreEqual(hash1, hash0);
  Assert.AreEqual(hash1, hash2);
  Assert.AreNotEqual(hash2, hash3);
+ Assert.AreEqual(hash3, hash4);
  }
 
  [TestMethod]

projects/CatLib/Hashing/Hashing.cs

@@ -11,8 +11,6 @@
 
 using CatLib.API.Hashing;
 using CatLib.Hashing.Checksum;
-using CatLib.Hashing.HashString;
-using Murmur;
 using System;
 using System.Collections.Generic;
 using System.Security.Cryptography;
@@ -25,6 +23,16 @@ namespace CatLib.Hashing
  /// </summary>
  internal sealed class Hashing : IHashing
  {
+ /// <summary>
+ /// 校验类字典
+ /// </summary>
+ private readonly Dictionary<Checksums, Func<IChecksum>> checksumsMaker;
+
+ /// <summary>
+ /// 非加密哈希字典
+ /// </summary>
+ private readonly Dictionary<Hashes, Func<HashAlgorithm>> hashByteMaker;
+
  /// <summary>
  /// 校验类字典
  /// </summary>
@@ -40,22 +48,65 @@ internal sealed class Hashing : IHashing
  /// </summary>
  private readonly object syncRoot = new object();
 
+ /// <summary>
+ /// 默认的校验算法
+ /// </summary>
+ private readonly Checksums defaultChecksum;
+
+ /// <summary>
+ /// 默认的哈希算法
+ /// </summary>
+ private readonly Hashes defaultHash;
+
  /// <summary>
  /// 哈希
  /// </summary>
- public Hashing()
+ public Hashing(Checksums defaultChecksum, Hashes defaultHash)
  {
- checksumsDict = new Dictionary<Checksums, IChecksum>
- {
- { Checksums.Crc32, new Crc32() },
- { Checksums.Adler32, new Adler32() }
- };
+ Guard.Requires<ArgumentNullException>(defaultChecksum != null);
+ Guard.Requires<ArgumentNullException>(defaultHash != null);
 
- hashByteDict = new Dictionary<Hashes, HashAlgorithm>
- {
- { Hashes.MurmurHash , new Murmur32ManagedX86() },
- { Hashes.Djb, new DjbHash() }
- };
+ this.defaultChecksum = defaultChecksum;
+ this.defaultHash = defaultHash;
+
+ checksumsMaker = new Dictionary<Checksums, Func<IChecksum>>();
+ hashByteMaker = new Dictionary<Hashes, Func<HashAlgorithm>>();
+ checksumsDict = new Dictionary<Checksums, IChecksum>();
+ hashByteDict = new Dictionary<Hashes, HashAlgorithm>();
+ }
+
+ /// <summary>
+ /// 注册校验算法
+ /// </summary>
+ /// <param name="checksum">校验类类型</param>
+ /// <param name="builder">构建器</param>
+ public void RegisterChecksum(Checksums checksum, Func<IChecksum> builder)
+ {
+ Guard.Requires<ArgumentNullException>(checksum != null);
+ Guard.Requires<ArgumentNullException>(builder != null);
+ checksumsMaker.Add(checksum, builder);
+ }
+
+ /// <summary>
+ /// 注册校验算法
+ /// </summary>
+ /// <param name="hash">哈希类类型</param>
+ /// <param name="builder">构建器</param>
+ public void RegisterHash(Hashes hash, Func<HashAlgorithm> builder)
+ {
+ Guard.Requires<ArgumentNullException>(hash != null);
+ Guard.Requires<ArgumentNullException>(builder != null);
+ hashByteMaker.Add(hash, builder);
+ }
+
+ /// <summary>
+ /// 使用默认的校验算法计算校验和
+ /// </summary>
+ /// <param name="buffer">字节数组</param>
+ /// <returns>校验和</returns>
+ public long Checksum(byte[] buffer)
+ {
+ return Checksum(buffer, defaultChecksum);
  }
 
  /// <summary>
@@ -64,13 +115,19 @@ public Hashing()
  /// <param name="buffer">字节数组</param>
  /// <param name="checksum">使用校验类类型</param>
  /// <returns>校验和</returns>
- public long Checksum(byte[] buffer, Checksums checksum = Checksums.Crc32)
+ public long Checksum(byte[] buffer, Checksums checksum)
  {
  Guard.Requires<ArgumentNullException>(buffer != null);
  IChecksum checksumClass;
  if (!checksumsDict.TryGetValue(checksum, out checksumClass))
  {
- throw new RuntimeException("Undefiend Checksum:" + checksum);
+ Func<IChecksum> checksumMaker;
+ if (!checksumsMaker.TryGetValue(checksum, out checksumMaker)
+ || (checksumClass = checksumMaker.Invoke()) == null)
+ {
+ throw new RuntimeException("Undefiend Checksum:" + checksum);
+ }
+ checksumsDict[checksum] = checksumClass;
  }
  lock (syncRoot)
  {
@@ -105,13 +162,23 @@ public bool CheckPassword(string input, string hash)
  return BCrypt.Net.BCrypt.Verify(input, hash);
  }
 
+ /// <summary>
+ /// 对输入值进行非加密哈希
+ /// </summary>
+ /// <param name="input">输入值</param>
+ /// <returns>哈希值</returns>
+ public uint HashString(string input)
+ {
+ return HashString(input, defaultHash);
+ }
+
  /// <summary>
  /// 对输入值进行非加密哈希
  /// </summary>
  /// <param name="input">输入值</param>
  /// <param name="hash">使用的哈希算法</param>
  /// <returns>哈希值</returns>
- public uint HashString(string input, Hashes hash = Hashes.MurmurHash)
+ public uint HashString(string input, Hashes hash)
  {
  return HashString(input, Encoding.Default, hash);
  }
@@ -123,28 +190,47 @@ public uint HashString(string input, Hashes hash = Hashes.MurmurHash)
  /// <param name="encoding">编码</param>
  /// <param name="hash">使用的哈希算法</param>
  /// <returns>哈希值</returns>
- public uint HashString(string input, Encoding encoding, Hashes hash = Hashes.MurmurHash)
+ public uint HashString(string input, Encoding encoding, Hashes hash)
  {
  Guard.Requires<ArgumentNullException>(input != null);
  Guard.Requires<ArgumentNullException>(encoding != null);
  var data = encoding.GetBytes(input);
  return HashByte(data, hash);
  }
 
+ /// <summary>
+ /// 对输入值进行非加密哈希
+ /// </summary>
+ /// <param name="input">输入值</param>
+ /// <returns>哈希值</returns>
+ public uint HashByte(byte[] input)
+ {
+ return HashByte(input, defaultHash);
+ }
+
  /// <summary>
  /// 对输入值进行非加密哈希
  /// </summary>
  /// <param name="input">输入值</param>
  /// <param name="hash">使用的哈希算法</param>
  /// <returns>哈希值</returns>
- public uint HashByte(byte[] input, Hashes hash = Hashes.MurmurHash)
+ public uint HashByte(byte[] input, Hashes hash)
  {
  Guard.Requires<ArgumentNullException>(input != null);
+ Guard.Requires<ArgumentNullException>(hash != null);
+
  HashAlgorithm hashStringClass;
  if (!hashByteDict.TryGetValue(hash, out hashStringClass))
  {
- throw new RuntimeException("Undefiend Hashing:" + hash);
+ Func<HashAlgorithm> hashStringMaker;
+ if (!hashByteMaker.TryGetValue(hash, out hashStringMaker)
+ || (hashStringClass = hashStringMaker.Invoke()) == null)
+ {
+ throw new RuntimeException("Undefiend Hashing:" + hash);
+ }
+ hashByteDict[hash] = hashStringClass;
  }
+
  return BitConverter.ToUInt32(hashStringClass.ComputeHash(input), 0);
  }
  }