public HttpPostRequestEncoder(
IHttpDataFactory factory, IHttpRequest request, bool multipart, Encoding charset,
EncoderMode encoderMode)
{
Contract.Requires(request != null);
Contract.Requires(factory != null);
Contract.Requires(charset != null);
this.request = request;
this.charset = charset;
this.factory = factory;
HttpMethod method = request.Method;
if (method.Equals(HttpMethod.Trace))
{
throw new ErrorDataEncoderException("Cannot create a Encoder if request is a TRACE");
}
// Fill default values
this.bodyListDatas = new List <IInterfaceHttpData>();
// default mode
this.isLastChunk = false;
this.isLastChunkSent = false;
this.isMultipart = multipart;
this.MultipartHttpDatas = new List <IInterfaceHttpData>();
this.encoderMode = encoderMode;
if (this.isMultipart)
{
this.InitDataMultipart();
}
}
/// <summary>
/// 带编码模式的字符串加密
/// </summary>
/// <param name="data">要加密的数据</param>
/// <param name="pass">密码</param>
/// <param name="em">编码模式</param>
/// <returns>加密后经过编码的字符串</returns>
public static String Encrypt(String data, String pass, EncoderMode em)
{
if (data == null || pass == null) return null;
if (em == EncoderMode.Base64Encoder)
return Convert.ToBase64String(EncryptEx(Encode.GetBytes(data), pass));
else
return ByteToHex(EncryptEx(Encode.GetBytes(data), pass));
}
/// <summary>
/// 带编码模式的字符串解密
/// </summary>
/// <param name="data">要解密的数据</param>
/// <param name="pass">密码</param>
/// <param name="em">编码模式</param>
/// <returns>明文</returns>
public static String Decrypt(String data, String pass, EncoderMode em)
{
if (data == null || pass == null) return null;
if (em == EncoderMode.Base64Encoder)
return Encode.GetString(DecryptEx(Convert.FromBase64String(data), pass));
else
return Encode.GetString(DecryptEx(HexToByte(data), pass));
}
public MidiDefinition(string midiNote, MidiControlType controlType, float minValue, float maxValue, EncoderMode encoderMode, int controlId)
: base("DCDT")
{
MidiNote = midiNote;
MidiControlType = controlType;
MinValue = MinValue;
MaxValue = maxValue;
EncoderMode = encoderMode;
ControlId = controlId;
}
/// <summary>
/// 带编码模式的字符串解密
/// </summary>
/// <param name="data">要解密的数据</param>
/// <param name="pass">密码</param>
/// <param name="em">编码模式</param>
/// <returns>明文</returns>
public String Decrypt(String data, String pass, EncoderMode em)
{
if (data == null || pass == null)
{
return(null);
}
if (em == EncoderMode.Base64Encoder)
{
return(Encode.GetString(DecryptEx(Convert.FromBase64String(data), pass)));
}
return(Encode.GetString(DecryptEx(HexToByte(data), pass)));
}
/// <summary>
/// 带编码模式的字符串加密
/// </summary>
/// <param name="data">要加密的数据</param>
/// <param name="pass">密码</param>
/// <param name="em">编码模式</param>
/// <returns>加密后经过编码的字符串</returns>
public String Encrypt(String data, String pass, EncoderMode em)
{
if (data == null || pass == null)
{
return(null);
}
if (em == EncoderMode.Base64Encoder)
{
return(Convert.ToBase64String(EncryptEx(Encode.GetBytes(data), pass)));
}
return(ByteToHex(EncryptEx(Encode.GetBytes(data), pass)));
}
/// <summary>
/// 带编码模式的字符串加密
/// </summary>
/// <param name="data">要加密的数据</param>
/// <param name="key">密码</param>
/// <param name="em">编码模式</param>
/// <returns>加密后经过编码的字符串</returns>
public static string Encrypt(string data, string key, EncoderMode mode)
{
if (string.IsNullOrEmpty(data))
{
return("");
}
if (string.IsNullOrEmpty(key))
{
key = DEFAULT_KEY;
}
if (mode == EncoderMode.Base64Encoder)
{
return(Convert.ToBase64String(Encrypt(DEFAULT_ENCODING.GetBytes(data), key)));
}
else
{
return(ByteToHex(Encrypt(DEFAULT_ENCODING.GetBytes(data), key)));
}
}
/// <summary>
/// 带编码模式的字符串解密
/// </summary>
/// <param name="data">要解密的数据</param>
/// <param name="key">密码</param>
/// <param name="em">编码模式</param>
/// <returns>明文</returns>
public static string Decrypt(string data, string key, EncoderMode em)
{
if (string.IsNullOrEmpty(data))
{
return("");
}
if (string.IsNullOrEmpty(key))
{
key = DEFAULT_KEY;
}
if (em == EncoderMode.Base64Encoder)
{
return(DEFAULT_ENCODING.GetString(Decrypt(Convert.FromBase64String(data), key)));
}
else
{
return(DEFAULT_ENCODING.GetString(Decrypt(HexToByte(data), key)));
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="factory">the factory used to create InterfaceHttpData</param>
/// <param name="request">the request to encode</param>
/// <param name="multipart">True if the FORM is a ENCTYPE="multipart/form-data"</param>
/// <param name="encoderMode">the mode for the encoder to use. See <see cref="EncoderMode"/> for the details.</param>
public HttpPostRequestEncoder(IHttpDataFactory factory, IHttpRequest request, bool multipart, EncoderMode encoderMode)
{
if (request is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.request);
}
if (factory is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.factory);
}
if (charset is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.charset);
}
this.request = request;
this.factory = factory;
HttpMethod method = request.Method;
if (method.Equals(HttpMethod.Trace))
{
ThrowHelper.ThrowErrorDataEncoderException_CannotCreate();
}
// Fill default values
this.bodyListDatas = new List <IInterfaceHttpData>();
// default mode
this.isLastChunk = false;
this.isLastChunkSent = false;
this.isMultipart = multipart;
this.MultipartHttpDatas = new List <IInterfaceHttpData>();
this.encoderMode = encoderMode;
if (this.isMultipart)
{
this.InitDataMultipart();
}
}
public RHREncoder(EncoderMode mode, ushort comprSize = 0x80, ushort decomprSize = 0x80)
{
Mode = mode;
TileCompressedSize = comprSize;
TileDecompressedSize = decomprSize;
}
