public static ILeoVisitor ToVisitor(this Type type,
AlgorithmKind kind = AlgorithmKind.Precision,
bool repeatable = RpMode.REPEATABLE,
bool strictMode = StMode.NORMALE)
{
return(LeoVisitorFactory.Create(type, kind, repeatable, strictMode));
}
public static ILeoVisitor ToVisitor(this Type type, IDictionary <string, object> initialValues,
AlgorithmKind kind = AlgorithmKind.Precision,
bool repeatable = RpMode.REPEATABLE,
bool strictMode = StMode.NORMALE)
{
return(LeoVisitorFactory.Create(type, initialValues, kind, repeatable, strictMode));
}
/// <summary>
/// Create an Object Visitor instance for the given object instance <br />
/// 为给定的对象实例创建一个 Object Visitor 实例
/// </summary>
/// <param name="instance"></param>
/// <param name="kind"></param>
/// <param name="repeatable"></param>
/// <param name="strictMode"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IObjectVisitor <T> Create <T>(T instance, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
{
TypeAmGuard.RejectSimpleType <T>();
var options = FillWith(kind, repeatable, strictMode);
return(ObjectVisitorFactoryCore.CreateForInstance(instance, options));
}
public static ICipher GetCipher(AlgorithmKind kind, CipherOptions options)
{
ICipher cipher;
switch (kind)
{
case AlgorithmKind.AES:
cipher = new Cipher(Aes.Create())
{
Options = options
};
break;
case AlgorithmKind.TripleDES:
cipher = new Cipher(TripleDES.Create())
{
Options = options
};
break;
default:
throw new NotSupportedException("Unknown algorithm");
}
return(cipher);
}
/// <summary>
/// Verifies the given data using this Verifier's key.
/// </summary>
/// <param name="data">The input data as a string to hash and sign.</param>
/// <param name="sig">Signature to compare verify as a base64 encoded string.</param>
/// <param name="encKind">Encoding format of the input data.</param>
/// <param name="algKind">Hashing algorithm to use.</param>
/// <returns>True if the given signature matches the input data, otherwise False.</returns>
public bool Verify(string data, string sig, EncodingKind encKind = EncodingKind.UTF8, AlgorithmKind algKind = AlgorithmKind.SHA1)
{
Contract.Requires(!string.IsNullOrEmpty(data));
Contract.Requires(!string.IsNullOrEmpty(sig));
return InvokeProvider(encKind, algKind, (rsa, enc, alg) => rsa.VerifyData(enc.GetBytes(data), alg, Convert.FromBase64String(sig)));
}
public static ILeoVisitor <T> ToVisitor <T>(this T instanceObj,
AlgorithmKind kind = AlgorithmKind.Precision,
bool repeatable = RpMode.REPEATABLE,
bool strictMode = StMode.NORMALE)
where T : class
{
return(LeoVisitorFactory.Create(instanceObj, kind, repeatable, strictMode));
}
public static ILeoVisitor Create(Type type, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
{
if (type.IsAbstract && type.IsSealed)
{
return(LeoVisitorFactoryCore.CreateForStaticType(type, kind, LvMode.FULL, strictMode));
}
return(LeoVisitorFactoryCore.CreateForFutureInstance(type, kind, repeatable, LvMode.FULL, strictMode));
}
private static ObjectVisitorOptions FillWith(AlgorithmKind kind, bool repeatable, bool strictMode)
{
return(ObjectVisitorOptions
.Default
.With(x => x.AlgorithmKind = kind)
.With(x => x.Repeatable = repeatable)
.With(x => x.StrictMode = strictMode));
}
public static StaticTypeLeoVisitor <T> CreateForStaticType <T, TStrategy>(AlgorithmKind kind, bool liteMode, bool strictMode)
where TStrategy : class, ILeoValidationStrategy <T>, new()
{
var handler = UnsafeLeoHandleSwitcher.Switch <T>(kind)().With <T>();
var visitor = new StaticTypeLeoVisitor <T>(handler, kind, liteMode, strictMode);
visitor.ValidationEntry.SetStrategy <TStrategy>();
return(visitor);
}
/// <summary>
/// Create an Object Visitor instance for the given type <br />
/// 为给定的类型创建一个 Object Visitor 实例
/// </summary>
/// <param name="kind"></param>
/// <param name="repeatable"></param>
/// <param name="strictMode"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IObjectVisitor <T> Create <T>(AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
{
TypeAmGuard.RejectSimpleType <T>(out var type);
var options = FillWith(kind, repeatable, strictMode);
if (type.IsAbstract && type.IsSealed)
{
return(ObjectVisitorFactoryCore.CreateForStaticType <T>(options));
}
return(ObjectVisitorFactoryCore.CreateForFutureInstance <T>(options));
}
public static ILeoVisitor <T> Create <T, TStrategy>(AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
where TStrategy : class, ILeoValidationStrategy <T>, new()
{
var type = typeof(T);
if (type.IsAbstract && type.IsSealed)
{
return(LeoVisitorFactoryCore.CreateForStaticType <T, TStrategy>(kind, LvMode.FULL, strictMode));
}
return(LeoVisitorFactoryCore.CreateForFutureInstance <T, TStrategy>(kind, repeatable, LvMode.FULL, strictMode));
}
public static Func <Type, ObjectCallerBase> Switch(AlgorithmKind kind)
{
#if NETFRAMEWORK
return(CompatibleCallerBuilder.Ctor);
#else
return(kind switch
{
AlgorithmKind.Precision => PrecisionDictOperator.CreateFromType,
AlgorithmKind.Hash => HashDictOperator.CreateFromType,
AlgorithmKind.Fuzzy => FuzzyDictOperator.CreateFromType,
_ => throw new InvalidOperationException("Unknown AlgorithmKind.")
});
public StaticTypeLeoVisitor(DictBase handler, Type targetType, AlgorithmKind kind, bool liteMode = false, bool strictMode = false)
{
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
_algorithmKind = kind;
SourceType = targetType ?? throw new ArgumentNullException(nameof(targetType));
LiteMode = liteMode;
_lazyMemberHandler = MemberHandler.Lazy(() => new MemberHandler(_handler, SourceType), liteMode);
_validationContext = strictMode
? new CorrectContext(this, true)
: null;
}
protected HashAlgorithm GetAlgorithm(AlgorithmKind algorithmKind)
{
HashAlgorithm algorithm;
switch (algorithmKind)
{
case AlgorithmKind.SHA1:
default:
algorithm = new SHA1CryptoServiceProvider();
break;
}
return(algorithm);
}
/// <summary>
/// 根据实现方式构造MD5算法类(Managed方式未实现)
/// </summary>
/// <param name="isCng">算法的实现方式(Managed无效)</param>
public MD5Crypto(AlgorithmKind kind)
{
switch (kind)
{
case AlgorithmKind.CryptoServiceProvider:
_MD5Alg = new MD5CryptoServiceProvider();
break;
case AlgorithmKind.Cng:
_MD5Alg = new MD5Cng();
break;
default:
_MD5Alg = new MD5CryptoServiceProvider();
break;
}
}
/// <summary>
/// 根据实现方式构造MD5算法类(Managed方式未实现)
/// </summary>
/// <param name="isCng">算法的实现方式(Managed无效)</param>
public MD5Crypto(AlgorithmKind kind)
{
switch (kind)
{
case AlgorithmKind.CryptoServiceProvider:
_MD5Alg = new MD5CryptoServiceProvider();
break;
case AlgorithmKind.Cng:
_MD5Alg = new MD5Cng();
break;
default:
_MD5Alg = new MD5CryptoServiceProvider();
break;
}
}
public static Func <Type, DictBase> Switch(AlgorithmKind kind)
{
switch (kind)
{
case AlgorithmKind.Precision:
return(PrecisionDictOperator.CreateFromType);
case AlgorithmKind.Hash:
return(HashDictOperator.CreateFromType);
case AlgorithmKind.Fuzzy:
return(FuzzyDictOperator.CreateFromType);
default:
throw new InvalidOperationException("Unknown AlgorithmKind.");
}
}
public static Func <DictBase> Switch <T>(AlgorithmKind kind)
{
switch (kind)
{
case AlgorithmKind.Precision:
return(() => PrecisionDictOperator <T> .Create());
case AlgorithmKind.Hash:
return(() => HashDictOperator <T> .Create());
case AlgorithmKind.Fuzzy:
return(() => FuzzyDictOperator <T> .Create());
default:
throw new InvalidOperationException("Unknown AlgorithmKind.");
}
}
protected T InvokeProvider <T>(EncodingKind encodingKind, AlgorithmKind algorithmKind, Func <RSACryptoServiceProvider, Encoding, HashAlgorithm, T> method)
{
var encoding = GetEncoding(encodingKind);
using (var rsa = new RSACryptoServiceProvider())
{
rsa.PersistKeyInCsp = false;
if (_isPrivate)
{
rsa.LoadPrivateKeyPEM(_pemKey);
}
else
{
rsa.LoadPublicKeyPEM(_pemKey);
}
using (var algorithm = GetAlgorithm(algorithmKind))
return(method(rsa, encoding, algorithm));
}
}
public InstanceVisitor(DictBase <T> handler, T instance, AlgorithmKind kind, bool repeatable,
bool liteMode = false, bool strictMode = false)
{
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
_instance = instance;
_algorithmKind = kind;
_handler.SetInstance(_instance);
SourceType = typeof(T);
GenericHistoricalContext = repeatable
? new HistoricalContext <T>(kind)
: null;
LiteMode = liteMode;
_lazyMemberHandler = MemberHandler.Lazy(() => new MemberHandler(_handler, SourceType), liteMode);
_validationContext = strictMode
? new CorrectContext <T>(this, true)
: null;
}
public static ImageFormat GetBestFittingFormat(Bitmap image, AlgorithmKind algorithm)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
switch (algorithm)
{
case AlgorithmKind.ComplexScanning:
return(GetBestFittingFormatAlgorithm(image));
case AlgorithmKind.BruteSaving:
return(GetBestFittingFormatBruteSaving(image));
case AlgorithmKind.Hybrid:
return(GetBestFittingFormatHybrid(image));
default:
throw new ArgumentException("Impossibru!");
}
}
public FutureInstanceVisitor(DictBase handler, Type sourceType, AlgorithmKind kind, bool repeatable,
IDictionary <string, object> initialValues = null, bool liteMode = false, bool strictMode = false)
{
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
_sourceType = sourceType ?? throw new ArgumentNullException(nameof(sourceType));
_algorithmKind = kind;
_handler.New();
NormalHistoricalContext = repeatable
? new HistoricalContext(sourceType, kind)
: null;
LiteMode = liteMode;
_lazyMemberHandler = MemberHandler.Lazy(() => new MemberHandler(_handler, _sourceType), liteMode);
_validationContext = strictMode
? new CorrectContext(this, true)
: null;
if (initialValues != null)
{
SetValue(initialValues);
}
}
private void Init(string value, AlgorithmKind algorithm)
{
Value = value;
Algorithm = algorithm;
}
public FluentSetterBuilder(Type type, AlgorithmKind kind)
{
_type = type;
_kind = kind;
}
/// <summary>
/// Initializes a new instance of the <see cref="Hash" /> class from the supplied values.
/// </summary>
/// <param name="value">
/// An initialization value for the <see cref="P: Value" /> property.
/// </param>
/// <param name="algorithm">
/// An initialization value for the <see cref="P: Algorithm" /> property.
/// </param>
public Hash(string value, AlgorithmKind algorithm)
{
Init(value, algorithm);
}
/// <summary>
/// Signs the given data using this Signer's key.
/// </summary>
/// <param name="data">The input data as a string to hash and sign.</param>
/// <param name="encKind">Encoding format of the input data.</param>
/// <param name="algKind">Hashing algorithm to use.</param>
/// <returns>The signature of the input data as a base64 encoded string.</returns>
public string Sign(string data, EncodingKind encKind = EncodingKind.UTF8, AlgorithmKind algKind = AlgorithmKind.SHA1)
{
Contract.Requires(!string.IsNullOrEmpty(data));
return(InvokeProvider(encKind, algKind, (rsa, enc, alg) => Convert.ToBase64String(rsa.SignData(enc.GetBytes(data), alg))));
}
public static ILeoVisitor Create(Type type, object instance, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
{
return(LeoVisitorFactoryCore.CreateForInstance(type, instance, kind, repeatable, LvMode.FULL, strictMode));
}
/// <summary>
/// Signs the given data using this Signer's key.
/// </summary>
/// <param name="data">The input data as a string to hash and sign.</param>
/// <param name="encKind">Encoding format of the input data.</param>
/// <param name="algKind">Hashing algorithm to use.</param>
/// <returns>The signature of the input data as a base64 encoded string.</returns>
public string Sign(string data, EncodingKind encKind = EncodingKind.UTF8, AlgorithmKind algKind = AlgorithmKind.SHA1)
{
Contract.Requires(!string.IsNullOrEmpty(data));
return InvokeProvider(encKind, algKind, (rsa, enc, alg) => Convert.ToBase64String(rsa.SignData(enc.GetBytes(data), alg)));
}
public static ILeoVisitor Create <TStrategy>(Type type, IDictionary <string, object> initialValues, TStrategy validationStrategy, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE,
bool strictMode = StMode.NORMALE)
where TStrategy : class, ILeoValidationStrategy, new()
{
if (type.IsAbstract && type.IsSealed)
{
return(LeoVisitorFactoryCore.CreateForStaticType(type, kind, LvMode.FULL, validationStrategy, strictMode));
}
return(LeoVisitorFactoryCore.CreateForFutureInstance(type, kind, repeatable, LvMode.FULL, validationStrategy, strictMode, initialValues));
}
public static ILeoVisitor <T> Create <T, TStrategy>(T instance, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
where TStrategy : class, ILeoValidationStrategy <T>, new()
{
return(LeoVisitorFactoryCore.CreateForInstance <T, TStrategy>(instance, kind, repeatable, LvMode.FULL, strictMode));
}
public static ILeoVisitor Create <TStrategy>(Type type, object instance, TStrategy validationStrategy, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
where TStrategy : class, ILeoValidationStrategy, new()
{
return(LeoVisitorFactoryCore.CreateForInstance(type, instance, kind, repeatable, LvMode.FULL, validationStrategy, strictMode));
}
public static ILeoVisitor <T> Create <T>(IDictionary <string, object> initialValues, AlgorithmKind kind = AlgorithmKind.Precision, bool repeatable = RpMode.REPEATABLE, bool strictMode = StMode.NORMALE)
{
var type = typeof(T);
if (type.IsAbstract && type.IsSealed)
{
return(LeoVisitorFactoryCore.CreateForStaticType <T>(kind, LvMode.FULL, strictMode));
}
return(LeoVisitorFactoryCore.CreateForFutureInstance <T>(kind, repeatable, LvMode.FULL, strictMode, initialValues));
}
/// <summary>
/// According to the given type, create an object of the corresponding type,
/// and fill the object with the data provided in the dictionary <br />
/// 根据给定的类型，创建对应类型的对象，并使用字典中提供的数据填充该对象
/// </summary>
/// <param name="type"></param>
/// <param name="keyValueCollections"></param>
/// <param name="visitor"></param>
/// <param name="kind"></param>
/// <returns></returns>
public static object Create(Type type, IDictionary <string, object> keyValueCollections, out IObjectVisitor visitor, AlgorithmKind kind = AlgorithmKind.Precision)
{
visitor = ObjectVisitor.Create(type, keyValueCollections, kind);
return(visitor.Instance);
}
/// <summary>
/// According to the given type, create an object of the corresponding type,
/// and fill the object with the data provided in the dictionary <br />
/// 根据给定的类型，创建对应类型的对象，并使用字典中提供的数据填充该对象
/// </summary>
/// <param name="keyValueCollections"></param>
/// <param name="visitor"></param>
/// <param name="kind"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T Create <T>(IDictionary <string, object> keyValueCollections, out IObjectVisitor <T> visitor, AlgorithmKind kind = AlgorithmKind.Precision)
{
visitor = ObjectVisitor.Create <T>(keyValueCollections, kind);
return(visitor.Instance);
}
/// <summary>
/// According to the given type, create an object of the corresponding type,
/// and fill the object with the data provided in the dictionary <br />
/// 根据给定的类型，创建对应类型的对象，并使用字典中提供的数据填充该对象
/// </summary>
/// <param name="keyValueCollections"></param>
/// <param name="kind"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T Create <T>(IDictionary <string, object> keyValueCollections, AlgorithmKind kind = AlgorithmKind.Precision)
{
return(Create <T>(keyValueCollections, out _, kind));
}
