/// <summary>
/// read data from stream
/// </summary>
/// <param name="stream">your stream to read a block</param>
/// <param name="compress">compress mode</param>
/// <returns>return a block byte array</returns>
public static byte[] ReadBlockToEnd(NetworkStream stream, CompressMode compress, uint maximum, bool isWebSocket)
{
if (isWebSocket)
{
ulong size = 0;
var bytes = GetLengthOfWebSocket(stream, ref size);
var newBytes = ReadBlockSize(stream, size);
List <byte> b = new List <byte>();
b.AddRange(bytes);
b.AddRange(newBytes);
var decode = DecodeMessage(b.ToArray());
if (decode == null || decode.Length == 0)
{
AutoLogger.LogText($"decode zero size: {size} bytes: {ByteArrayToText(bytes.ToArray())} newBytes:{ByteArrayToText(newBytes)} decode: {ByteArrayToText(decode)}");
}
return(decode);
}
else
{
//first 4 bytes are size of block
var dataLenByte = ReadBlockSize(stream, 4);
//convert bytes to int
int dataLength = BitConverter.ToInt32(dataLenByte, 0);
if (dataLength > maximum)
{
throw new Exception("dataLength is upper than maximum :" + dataLength + " " + isWebSocket);
}
//else
// AutoLogger.LogText("size: " + dataLength);
//read a block
var dataBytes = ReadBlockSize(stream, (ulong)dataLength);
return(dataBytes);
}
}
/// <summary>
/// Compress a given stream with the given compression mode.
/// </summary>
/// <param name="stream"> the stream to compress. </param>
/// <param name="streamOut"> [out] than finished the compressed out stream. </param>
/// <param name="compressMode"> (Optional) the compression mode. </param>
/// <returns>
/// <c>true</c> if successfully compressed the stream; <c>false</c> otherwise.
/// </returns>
/// <exception cref="ArgumentNullException"> Thrown when one or more required arguments are null. </exception>
/// <exception cref="ArgumentException">
/// Thrown when one or more arguments have unsupported or
/// illegal values.
/// </exception>
public static bool CompressStream(Stream stream,
out Stream streamOut,
CompressMode compressMode = CompressMode.Gzip)
{
try
{
stream.Position = 0;
streamOut = new MemoryStream();
streamOut.Write(s_magicHeader, 0, s_magicHeader.Length);
streamOut.WriteByte((byte)compressMode);
switch (compressMode)
{
case CompressMode.Gzip:
GzipCompress(stream, streamOut);
break;
default: throw new ArgumentException("no compression method found", nameof(compressMode));
}
}
catch
{
streamOut = null !;
return(false);
}
return(true);
}
/// <summary>
/// 字节数组压缩成字节数组
/// </summary>
/// <param name="data">压缩前字节数组</param>
/// <param name="mode">压缩方法<see cref="CompressMode"/></param>
/// <returns></returns>
public byte[] Compress(byte[] data, CompressMode mode)
{
try
{
if (mode == CompressMode.None)
{
return(data);
}
using MemoryStream inputStream = new MemoryStream(data);
using var outputStream = new MemoryStream();
if (mode == CompressMode.Deflate)
{
using var compressor = new DeflateStream(outputStream, CompressionMode.Compress, true);
inputStream.CopyTo(compressor);
}
#if NETCOREAPP
else if (mode == CompressMode.Brotli)
{
using var compressor = new BrotliStream(outputStream, CompressionMode.Compress, true);
inputStream.CopyTo(compressor);
}
#endif
else
{
using var compressor = new GZipStream(outputStream, CompressionMode.Compress, true);
inputStream.CopyTo(compressor);
}
return(outputStream.ToArray());
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Compresses the whole content of a directory structure into the Zip file given with <paramref name="zipFile"/>.
/// </summary>
/// <param name="baseDir">The base directory of the ZipFile's content. The directory itself will not be included.</param>
/// <param name="zipFile">The relative or absolute path to the target zip file.</param>
/// <param name="compressMode">Sets how the code should handle an already existing ZipFile.</param>
public void Compress(string baseDir, string zipFile, CompressMode compressMode = CompressMode.Throw)
{
if (File.Exists(zipFile))
{
switch (compressMode)
{
case CompressMode.Throw when File.Exists(zipFile):
throw new Exception($"File '{zipFile}' already exists.");
case CompressMode.Backup:
var backupFile = zipFile + ".bak";
if (File.Exists(backupFile))
{
File.Delete(backupFile);
}
File.Move(zipFile, zipFile + ".bak");
break;
case CompressMode.Overwrite:
File.Delete(zipFile);
break;
}
}
using (var zip = new ZipFile(zipFile))
{
var dir = new DirectoryInfo(baseDir);
foreach (var file in dir.GetFiles("*", SearchOption.AllDirectories))
{
zip.AddFile(file.FullName, file.DirectoryName.Replace(dir.FullName, String.Empty));
}
zip.Save();
}
}
/// <summary>
/// 将流压缩成流
/// </summary>
/// <param name="data">压缩前的流</param>
/// <param name="mode">压缩方法<see cref="CompressMode"/></param>
/// <returns></returns>
public Stream Compress(Stream data, CompressMode mode)
{
try
{
if (mode == CompressMode.None)
{
return(data);
}
data.Seek(0, SeekOrigin.Begin);
MemoryStream outputStream = new MemoryStream();
if (mode == CompressMode.Deflate)
{
using var compressor = new DeflateStream(outputStream, CompressionMode.Compress, true);
data.CopyTo(compressor);
}
#if NETCOREAPP
else if (mode == CompressMode.Brotli)
{
using var compressor = new BrotliStream(outputStream, CompressionMode.Compress, true);
data.CopyTo(compressor);
}
#endif
else
{
using var compressor = new GZipStream(outputStream, CompressionMode.Compress, true);
data.CopyTo(compressor);
}
return(outputStream);
}
catch (Exception ex)
{
throw ex;
}
}
public KeyValue <DataType, CompressMode> ReadFirstData(PipeNetworkStream stream, int maximumReceiveStreamHeaderBlock)
{
DataType responseType = (DataType)SignalGoStreamBase.CurrentBase.ReadOneByte(stream);
CompressMode compressMode = (CompressMode)SignalGoStreamBase.CurrentBase.ReadOneByte(stream);
return(new KeyValue <DataType, CompressMode>(responseType, compressMode));
}
} // func OpenWrite
/// <summary>Erzeugt die angegebene Datei (neu).</summary>
/// <param name="file">Datei die angelegt werden soll.</param>
/// <param name="notify">Zugriff auf die UI.</param>
/// <param name="compressed">Soll die Datei gepackt sein.</param>
/// <returns></returns>
public static Stream OpenCreate(this FileInfo file, CmdletNotify notify, CompressMode compressed = CompressMode.Stored)
{
if (file.Exists)
{
var choices = new Collection <ChoiceDescription>
{
new ChoiceDescription("&Überschreiben"),
new ChoiceDescription("&Abbrechen")
};
if (notify.UI.PromptForChoice("Überschreiben", $"Datei '{file.Name}' überschreiben?", choices, 0) != 0)
{
notify.Abort();
}
notify.SafeIO(file.Delete, $"Datei '{file.Name}' löschen.");
}
// Erzeuge die Datei im sicheren Context
var src = notify.SafeIO(() => OpenWrite(file), $"Datei '{file.Name}' konnte nicht angelegt werden.");
// Entpacke die Daten automatisch
if (compressed == CompressMode.Compressed || (compressed == CompressMode.Auto && IsGZipFile(file.Name)))
{
return(new GZipStream(src, CompressionMode.Compress, false));
}
else
{
return(src);
}
} // func OpenCreate
/// <summary>
/// 将流解压成流
/// </summary>
/// <param name="data">压缩后的流</param>
/// <param name="mode">压缩方法<see cref="CompressMode"/></param>
/// <returns></returns>
public Stream DeCompress(Stream data, CompressMode mode)
{
if (mode == CompressMode.None)
{
return(data);
}
data.Seek(0, SeekOrigin.Begin);
var outputStream = new MemoryStream();
if (mode == CompressMode.Deflate)
{
using var decompressor = new DeflateStream(data, CompressionMode.Decompress, true);
decompressor.CopyTo(outputStream);
}
#if NETCOREAPP
else if (mode == CompressMode.Brotli)
{
using var decompressor = new BrotliStream(data, CompressionMode.Decompress, true);
decompressor.CopyTo(outputStream);
}
#endif
else
{
using var decompressor = new GZipStream(data, CompressionMode.Decompress, true);
decompressor.CopyTo(outputStream);
}
return(outputStream);
}
/// <summary>
/// 字节数组解压成字节数组
/// </summary>
/// <param name="data">压缩后的字节数组</param>
/// <param name="mode">压缩方法<see cref="CompressMode"/></param>
/// <returns></returns>
public byte[] DeCompress(byte[] data, CompressMode mode)
{
if (mode == CompressMode.None)
{
return(data);
}
using MemoryStream inputStream = new MemoryStream(data);
using var outputStream = new MemoryStream();
if (mode == CompressMode.Deflate)
{
using var decompressor = new DeflateStream(inputStream, CompressionMode.Decompress, true);
decompressor.CopyTo(outputStream);
}
#if NETCOREAPP
else if (mode == CompressMode.Brotli)
{
using var decompressor = new BrotliStream(inputStream, CompressionMode.Decompress, true);
decompressor.CopyTo(outputStream);
}
#endif
else
{
using var decompressor = new GZipStream(inputStream, CompressionMode.Decompress, true);
decompressor.CopyTo(outputStream);
}
return(outputStream.GetBuffer());
}
/// <summary>
/// 设置压缩方式
/// </summary>
/// <param name="compressMode"></param>
public void SetResponse(CompressMode compressMode)
{
this.response = new Owin.Response();
this.response.headers = new Dictionary <string, string[]>(StringComparer.Ordinal);
this.response.statusCode = 200;
this.response.stream = new MemoryStream();
this.compressMode = compressMode;
if (compressMode == CompressMode.None)
{
this.writeStream = this.response.stream;
}
else
{
if (compressMode == CompressMode.GZip)
{
this.writeStream = new System.IO.Compression.GZipStream(this.response.stream, System.IO.Compression.CompressionMode.Compress, true);
this.response.headers.Add(NFinal.Constant.HeaderContentEncoding, NFinal.Constant.HeaderContentEncodingGzip);
}
else if (compressMode == CompressMode.Deflate)
{
this.writeStream = new System.IO.Compression.DeflateStream(this.response.stream, System.IO.Compression.CompressionMode.Compress, true);
this.response.headers.Add(NFinal.Constant.HeaderContentEncoding, NFinal.Constant.HeaderContentEncodingDeflate);
}
}
}
/// <summary>
/// compress the input data
/// </summary>
/// <param name="input">the input data</param>
/// <param name="compressMode">the compress mode of this compress</param>
/// <returns>compressed data, if the compressed data is larger than input data, the original data
/// is returned</returns>
public byte[] Compress(byte[] input, out CompressMode compressMode)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
compressMode = CompressMode.Compressed;
if (input.Length > (window8k - slidingWindow.Count))
{
compressMode = compressMode | CompressMode.SetToFront;
hashTable.Clear();
slidingWindow.Clear();
}
CompressCore(input);
byte[] ret = new byte[outputStream.Length];
outputStream.Position = 0;
outputStream.Read(ret, 0, ret.Length);
//put stream position to 0 for next round compress
outputStream.SetLength(0);
if (ret.Length > input.Length)
{
compressMode = CompressMode.Flush;
hashTable.Clear();
slidingWindow.Clear();
return(input);
}
return(ret);
}
public async Task SetPositionFlushAsync(long position)
{
DataType dataType = DataType.FlushStream;
CompressMode compressMode = CompressMode.None;
await SignalGoStreamBase.CurrentBase.WriteToStreamAsync(Stream, new byte[] { (byte)dataType, (byte)compressMode });
byte[] data = BitConverter.GetBytes(position);
await SignalGoStreamBase.CurrentBase.WriteBlockToStreamAsync(Stream, data);
}
/// <summary>
/// 获取文件实际地址。
/// </summary>
/// <param name="path">文件地址</param>
/// <param name="mode">图片压缩模式</param>
/// <returns>图像地址</returns>
public string GetFile(string path, CompressMode mode = CompressMode.Small)
{
if (string.IsNullOrWhiteSpace(path))
{
return null;
}
var id = Convert.ToBase64String(Encoding.UTF8.GetBytes(path));
return $"{FileRemoteUrl}File/Index/{id}?mode={mode}";
}
public override StreamInfo RegisterFileToDownload(NetworkStream stream, CompressMode compressMode, ClientInfo client, bool isWebSocket)
{
var bytes = GoStreamReader.ReadBlockToEnd(stream, compressMode, ProviderSetting.MaximumReceiveDataBlock, isWebSocket);
var json = Encoding.UTF8.GetString(bytes);
MethodCallInfo callInfo = ServerSerializationHelper.Deserialize <MethodCallInfo>(json);
MethodCallbackInfo callback = new MethodCallbackInfo();
callback.Guid = callInfo.Guid;
var serviceType = RegisteredServiceTypes[callInfo.ServiceName];
var sessionId = callInfo.Data.ToString();
var clientInfo = (from x in Services.ToArray() where x.Key.SessionId == sessionId select x.Key).FirstOrDefault();
if (clientInfo == null)
{
throw new Exception("RegisterFile client not found!");
}
var service = FindClientServiceByType(clientInfo, serviceType);
#if (NETSTANDARD1_6 || NETCOREAPP1_1)
var method = serviceType.GetTypeInfo().GetMethod(callInfo.MethodName, RuntimeTypeHelper.GetMethodTypes(serviceType, callInfo).ToArray());
#else
var method = serviceType.GetMethod(callInfo.MethodName, RuntimeTypeHelper.GetMethodTypes(serviceType, callInfo).ToArray());
#endif
List <object> parameters = new List <object>();
int index = 0;
var prms = method.GetParameters();
foreach (var item in callInfo.Parameters)
{
parameters.Add(ServerSerializationHelper.Deserialize(item.Value, prms[index].ParameterType));
index++;
}
if (method.ReturnType != typeof(StreamInfo))
{
throw new Exception("return type for upload must StreamInfo!");
}
else
{
StreamInfo data = null;
data = (StreamInfo)method.Invoke(service, parameters.ToArray());
if (data == null)
{
throw new Exception($"StreamInfo cannot be null");
}
var streamReader = data.Stream;
data.Stream = null;
callback.Data = ServerSerializationHelper.SerializeObject(data, this);
SendCallbackData(callback, client);
data.Stream = streamReader;
return(data);
}
}
public FileWrite(CmdletNotify notify, FileInfo file, bool createMode, CompressMode compressed)
{
this.notify = notify;
this.file = file;
this.createMode = createMode;
this.compressed = compressed;
this.tempFile = new FileInfo(Path.Combine(file.Directory.FullName, Guid.NewGuid().ToString("N") + ".tmp"));
if (compressed == CompressMode.Auto)
{
this.compressed = Stuff.IsGZipFile(file.Name) ? CompressMode.Compressed : CompressMode.Stored;
}
} // ctor
} // func OpenCreate
/// <summary>Öffnet die Datei zum Schreiben.</summary>
/// <param name="file">Datei die geöffnet werden soll.</param>
/// <param name="notify">Zugriff auf die UI.</param>
/// <param name="compressed">Soll die Datei gepackt sein.</param>
/// <returns></returns>
public static Stream OpenWrite(this FileInfo file, CmdletNotify notify, CompressMode compressed = CompressMode.Stored)
{
// Erzeuge die Datei im sicheren Context
var src = notify.SafeIO(() => OpenWrite(file), $"Datei '{file.Name}' konnte nicht zum Schreiben geöffnet werden.");
// Entpacke die Daten automatisch
if (compressed == CompressMode.Compressed || (compressed == CompressMode.Auto && IsGZipFile(file.Name)))
{
return(new GZipStream(src, CompressionMode.Compress, false));
}
else
{
return(src);
}
} // func OpenWrite
public virtual byte[] ReadBlockToEnd(PipeNetworkStream stream, CompressMode compress, int maximum)
{
//first 4 bytes are size of block
byte[] dataLenByte = ReadBlockSize(stream, 4);
//convert bytes to int
int dataLength = BitConverter.ToInt32(dataLenByte, 0);
if (dataLength > maximum)
{
throw new Exception("dataLength is upper than maximum :" + dataLength);
}
//read a block
byte[] dataBytes = ReadBlockSize(stream, dataLength);
return(dataBytes);
}
public static void Start(FileStream source, FileStream target, CompressMode mode)
{
if (mode == CompressMode.Compress)
{
using (GZipStream gzipStream = new GZipStream(target, CompressionLevel.Optimal, true))
{
Converter.Convert(source, gzipStream, ConvertMode.Convert);
}
}
else
{
using (var gzipStream = new GZipStream(source, CompressionMode.Decompress, true))
{
Converter.Convert(gzipStream, target, ConvertMode.Deconvert);
}
}
}
} // func OpenWrite
/// <summary>Öffnet die Datei zum Lesen.</summary>
/// <param name="file">Datei die geöffnet werden soll.</param>
/// <param name="notify">Zugriff auf die UI.</param>
/// <param name="compressed">Soll die Datei entpackt werden.</param>
public static Stream OpenRead(this FileInfo file, CmdletNotify notify, CompressMode compressed = CompressMode.Stored, bool allowEmpty = false)
{
var desc = $"Datei '{file.Name}' kann nicht geöffnet werden.";
var src = allowEmpty ?
notify.SafeOpen(OpenRead, file, desc) :
notify.SafeIO(() => OpenRead(file), desc);
// Entpacke die Daten automatisch
if (compressed == CompressMode.Compressed || (compressed == CompressMode.Auto && IsGZipFile(file.Name)))
{
return(new GZipStream(src, CompressionMode.Decompress, false));
}
else
{
return(src);
}
} // func OpenRead
/// <summary>
/// read one byte from server
/// </summary>
/// <param name="stream">stream to read</param>
/// <param name="compress">compress mode</param>
/// <param name="maximum">maximum read</param>
/// <param name="isWebSocket">if reading socket is websocket</param>
/// <returns></returns>
public static byte ReadOneByte(NetworkStream stream, CompressMode compress, uint maximum, bool isWebSocket)
{
byte[] dataBytes = null;
if (isWebSocket)
{
dataBytes = ReadBlockToEnd(stream, compress, maximum, isWebSocket);
}
else
{
var data = stream.ReadByte();
if (data < 0)
{
throw new Exception($"read one byte is correct or disconnected client! {data}");
}
return((byte)data);
}
return(dataBytes[0]);
}
private static byte[] Compress(Stream input, CompressMode mode)
{
if (mode == CompressMode.Deflate)
{
using (var compressStream = new MemoryStream())
using (var compressor = new DeflateStream(compressStream, CompressionMode.Compress))
{
input.CopyTo(compressor);
return(compressStream.ToArray());
}
}
else
{
using (var compressStream = new MemoryStream())
using (var compressor = new GZipStream(compressStream, CompressionMode.Compress))
{
input.CopyTo(compressor);
return(compressStream.ToArray());
}
}
}
/// <summary>
/// HtmlWriter类初始化
/// </summary>
/// <param name="stream"></param>
/// <param name="compressMode"></param>
public HtmlWriter(Stream stream, CompressMode compressMode)
{
this.compressMode = compressMode;
this.response = new Response();
this.response.statusCode = 200;
this.response.headers = new Dictionary <string, string[]>(StringComparer.Ordinal);
this.setCookies = new Dictionary <string, string>(StringComparer.Ordinal);
this.response.stream = stream;
if (compressMode == CompressMode.GZip)
{
this.writeStream = new System.IO.Compression.GZipStream(this.response.stream, System.IO.Compression.CompressionMode.Compress, true);
this.response.headers.Add(NFinal.Constant.HeaderContentEncoding, NFinal.Constant.HeaderContentEncodingGzip);
}
else if (compressMode == CompressMode.Deflate)
{
this.writeStream = new System.IO.Compression.DeflateStream(this.response.stream, System.IO.Compression.CompressionMode.Compress, true);
this.response.headers.Add(NFinal.Constant.HeaderContentEncoding, NFinal.Constant.HeaderContentEncodingDeflate);
}
else
{
this.writeStream = this.response.stream;
}
}
private static byte[] Decompress(byte[] input, CompressMode mode)
{
var output = new MemoryStream();
if (mode == CompressMode.Deflate)
{
using (var compressStream = new MemoryStream(input))
using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
decompressor.CopyTo(output);
output.Position = 0;
return(output.ToArray());
}
else
{
using (var compressStream = new MemoryStream(input))
using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
decompressor.CopyTo(output);
output.Position = 0;
return(output.ToArray());
}
}
/// <summary>
/// Decompress input data
/// </summary>
/// <param name="input">input</param>
/// <param name="compressMode">the compress mode</param>
/// <returns>decompressed data</returns>
public byte[] Decompress(byte[] input, CompressMode compressMode)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (((compressMode & ~CompressMode.Flush) != 0) && ((compressMode & CompressMode.Flush) != 0))
{
throw new ArgumentException("invalid flag. CompressMode.Flush can't be mixed with others");
}
if ((compressMode & CompressMode.Flush) == CompressMode.Flush ||
(compressMode & CompressMode.SetToFront) == CompressMode.SetToFront)
{
InitializeAll();
}
if ((compressMode & CompressMode.Compressed) != CompressMode.Compressed)
{
return((byte[])input.Clone());
}
DecompressCore(input);
DecompressFinnal();
byte[] ret = new byte[outputStream.Length];
outputStream.Position = 0;
outputStream.Read(ret, 0, ret.Length);
remain = 0;
remainBitsCount = 0;
//set stream length to 0 for next round compress
outputStream.SetLength(0);
return(ret);
}
/// <summary>
/// Decompress input data
/// </summary>
/// <param name="input">input</param>
/// <param name="compressMode">the compress mode</param>
/// <returns>decompressed data</returns>
public byte[] Decompress(byte[] input, CompressMode compressMode)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (((compressMode & ~CompressMode.Flush) != 0) && ((compressMode & CompressMode.Flush) != 0))
{
throw new ArgumentException("invalid flag. CompressMode.Flush can't be mixed with others");
}
if ((compressMode & CompressMode.Flush) == CompressMode.Flush
|| (compressMode & CompressMode.SetToFront) == CompressMode.SetToFront)
{
InitializeAll();
}
if ((compressMode & CompressMode.Compressed) != CompressMode.Compressed)
{
return (byte[])input.Clone();
}
DecompressCore(input);
DecompressFinnal();
byte[] ret = new byte[outputStream.Length];
outputStream.Position = 0;
outputStream.Read(ret, 0, ret.Length);
remain = 0;
remainBitsCount = 0;
//set stream length to 0 for next round compress
outputStream.SetLength(0);
return ret;
}
/// <summary> /// 字节数组解压成字符串，默认使用UTF8编码 /// </summary> /// <param name="data">要解压的字节数组</param> /// <param name="mode">压缩方法<see cref="CompressMode"/></param> /// <returns></returns> public string DeCompressFromByte(byte[] data, CompressMode mode) => DeCompress(data, mode).BytesToString(Encoding.UTF8);
/// <summary> /// 字符串压缩成Base64字符串，可设置编码 /// </summary> /// <param name="data">要压缩的字符串</param> /// <param name="mode">压缩方法<see cref="CompressMode"/></param> /// <param name="encoding">编码</param> /// <returns></returns> public string CompressToBase64(string data, CompressMode mode, Encoding encoding) => Compress(data.ToBytes(encoding), mode).ToBase64();
public ActionResult Index(string id, CompressMode mode = CompressMode.Small)
{
var bytes = id.ToCharArray();
var base64Bytes = Convert.FromBase64CharArray(bytes, 0, bytes.Length);
var rsp = this.FileService.GetFileByPath(Encoding.UTF8.GetString(base64Bytes));
if (rsp.Data != null)
{
var filePath = Server.MapPath(rsp.Data.SavedPath);
if (!System.IO.File.Exists(filePath))
{
return View("Error", model: "文件不存在！");
}
if (mode != CompressMode.Original && ImageMimes.Contains(rsp.Data.ContentType))
{
// 源图像的信息
var img = Image.FromFile(filePath);
// 返回调整后的图像Width与Height
var newSize = NewSize(mode, img.Width, img.Height);
if (newSize.Width >= img.Width || newSize.Height >= img.Height)
{
img.Dispose();
return File(filePath, rsp.Data.ContentType, rsp.Data.Name);
}
var compressionPath = this.GetCompressionImage(mode, filePath);
if (System.IO.File.Exists(compressionPath))
{
return File(compressionPath, rsp.Data.ContentType, rsp.Data.Name);
}
// 源图像的格式
var thisformat = img.RawFormat;
var outBmp = new Bitmap(newSize.Width, newSize.Height);
using (var g = Graphics.FromImage(outBmp))
{
// 设置画布的描绘质量
g.CompositingQuality = CompositingQuality.HighQuality;
g.SmoothingMode = SmoothingMode.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.DrawImage(img, new Rectangle(0, 0, newSize.Width, newSize.Height), 0, 0, img.Width, img.Height, GraphicsUnit.Pixel);
g.Dispose();
}
// 以下代码为保存图片时，设置压缩质量
var encoderParams = new EncoderParameters();
var quality = new long[1];
quality[0] = 100;
var encoderParam = new EncoderParameter(Encoder.Quality, quality);
encoderParams.Param[0] = encoderParam;
// 获取包含有关内置图像编码解码器的信息的ImageCodecInfo对象。
var arrayICI = ImageCodecInfo.GetImageEncoders();
ImageCodecInfo jpegICI = null;
for (var x = 0; x < arrayICI.Length; x++)
{
if (arrayICI[x].FormatDescription.Equals("JPEG"))
{
// 设置jpeg编码
jpegICI = arrayICI[x];
break;
}
}
if (jpegICI == null)
{
outBmp.Save(compressionPath, thisformat);
}
else
{
outBmp.Save(compressionPath, jpegICI, encoderParams);
}
outBmp.Dispose();
img.Dispose();
return File(compressionPath, rsp.Data.ContentType, rsp.Data.Name);
}
return File(filePath, rsp.Data.ContentType, rsp.Data.Name);
}
return View("Error", model: rsp.IsSuccess ? "文件不存在！" : rsp.ErrorMessage);
}
/// <summary> /// 字节数组解压成字符串，可设置编码 /// </summary> /// <param name="data">要解压的字节数组</param> /// <param name="mode">压缩方法<see cref="CompressMode"/></param> /// <param name="encoding">编码</param> /// <returns></returns> public string DeCompressFromByte(byte[] data, CompressMode mode, Encoding encoding) => DeCompress(data, mode).BytesToString(encoding);
private static Size NewSize(CompressMode mode, int width, int height)
{
var maxWidth = width;
var maxHeight = height;
switch (mode)
{
case CompressMode.Small:
maxWidth = 400;
maxHeight = 300;
break;
case CompressMode.Medium:
maxWidth = 800;
maxHeight = 600;
break;
case CompressMode.Large:
maxWidth = 1024;
maxHeight = 768;
break;
}
var w = 0.0;
var h = 0.0;
var sw = Convert.ToDouble(width);
var sh = Convert.ToDouble(height);
var mw = Convert.ToDouble(maxWidth);
var mh = Convert.ToDouble(maxHeight);
// 如果maxWidth和maxHeight大于源图像，则缩略图的长和高不变
if (sw < mw && sh < mh)
{
w = sw;
h = sh;
}
else if ((sw / sh) > (mw / mh))
{
w = maxWidth;
h = (w * sh) / sw;
}
else
{
h = maxHeight;
w = (h * sw) / sh;
}
return new Size(Convert.ToInt32(w), Convert.ToInt32(h));
}
private string GetCompressionImage(CompressMode mode, string file)
{
var directory = $@"{Path.GetDirectoryName(file)}\Compression";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
return $@"{directory}\{mode}_{Path.GetFileName(file)}";
}
/// <summary> /// Base64字符串解压成字符串，可设置编码 /// </summary> /// <param name="data">要压缩的Base64字符串</param> /// <param name="mode">压缩方法CompressMode</param> /// <param name="encoding">编码</param> /// <returns></returns> public string DeCompressFromBase64(string data, CompressMode mode, Encoding encoding) => DeCompressFromByte(data.Base64ToBytes(), mode, encoding);
/// <summary> /// Base64字符串解压成字符串，默认使用UTF8编码 /// </summary> /// <param name="data">要解压的Base64字符串</param> /// <param name="mode">压缩方法<see cref="CompressMode"/></param> /// <returns></returns> public string DeCompressFromBase64(string data, CompressMode mode) => DeCompressFromByte(data.Base64ToBytes(), mode);
/// <summary>
/// 流输出初始化函数
/// </summary>
/// <param param name="plugConfig">插件配置</param>
/// <param name="methodName">行为名称</param>
/// <param name="context">Http上下文</param>
/// <param name="outputStream">输出流</param>
/// <param name="request"></param>
/// <param name="compressMode"></param>
public override void Initialization(HttpContext context, string methodName, Stream outputStream, HttpRequest request, CompressMode compressMode, NFinal.Config.Plug.PlugConfig plugConfig)
{
base.Initialization(context, methodName, outputStream, request, compressMode, plugConfig);
this.parameters = new NFinal.NameValueCollection();
foreach (var query in request.Query)
{
this.parameters.Add(query.Key, query.Value);
}
if (context.Request.HasFormContentType)
{
foreach (var form in context.Request.Form)
{
this.parameters.Add(form.Key, form.Value);
}
}
IDictionary <string, string> requestCookie = new Dictionary <string, string>();
foreach (var cookie in this.request.Cookies)
{
requestCookie.Add(cookie.Key, cookie.Value);
}
this.Cookie = new Cookie(requestCookie);
this.Session = GetSession(Cookie.SessionId);
if (outputStream == null)
{
this.outputStream = context.Response.Body;
}
else
{
this.outputStream = outputStream;
}
}
public static async Task StartToReadingClientData(ClientInfo client, ServerBase serverBase)
{
try
{
Console.WriteLine($"WebSocket Client Connected: {client.IPAddress}");
Shared.IO.PipeNetworkStream stream = client.ClientStream;
while (true)
{
byte oneByteOfDataType = await client.StreamHelper.ReadOneByteAsync(stream);
//type of data
DataType dataType = (DataType)oneByteOfDataType;
if (dataType == DataType.PingPong)
{
await client.StreamHelper.WriteToStreamAsync(client.ClientStream, new byte[] { 5 });
continue;
}
//compress mode of data
CompressMode compressMode = (CompressMode)await client.StreamHelper.ReadOneByteAsync(stream);
//a server service method called from client
if (dataType == DataType.CallMethod)
{
string json = "";
//if (client.IsOwinClient)
//{
// json = await stream.ReadLineAsync("#end");
// if (json.EndsWith("#end"))
// json = json.Substring(0, json.Length - 4);
//}
//else
//{
byte[] bytes = await client.StreamHelper.ReadBlockToEndAsync(stream, compressMode, serverBase.ProviderSetting.MaximumReceiveDataBlock);
//if (ClientsSettings.ContainsKey(client))
// bytes = DecryptBytes(bytes, client);
json = Encoding.UTF8.GetString(bytes);
//}
MethodCallInfo callInfo = ServerSerializationHelper.Deserialize <MethodCallInfo>(json, serverBase);
if (callInfo.PartNumber != 0)
{
SegmentManager segmentManager = new SegmentManager();
ISegment result = segmentManager.GenerateAndMixSegments(callInfo);
if (result != null)
{
callInfo = (MethodCallInfo)result;
}
else
{
continue;
}
}
#if (NET35 || NET40)
MethodCallbackInfo callbackResult = CallMethod(callInfo, client, json, serverBase).Result;
SendCallbackData(callbackResult, client, serverBase);
#else
Task <MethodCallbackInfo> callbackResult = CallMethod(callInfo, client, json, serverBase);
SendCallbackData(callbackResult, client, serverBase);
#endif
}
//reponse of client method that server called to client
else if (dataType == DataType.ResponseCallMethod)
{
byte[] bytes = await client.StreamHelper.ReadBlockToEndAsync(stream, compressMode, serverBase.ProviderSetting.MaximumReceiveDataBlock);
//if (ClientsSettings.ContainsKey(client))
// bytes = DecryptBytes(bytes, client);
string json = Encoding.UTF8.GetString(bytes);
MethodCallbackInfo callback = ServerSerializationHelper.Deserialize <MethodCallbackInfo>(json, serverBase);
if (callback == null)
{
serverBase.AutoLogger.LogText($"{client.IPAddress} {client.ClientId} callback is null:" + json);
}
if (callback.PartNumber != 0)
{
SegmentManager segmentManager = new SegmentManager();
ISegment result = segmentManager.GenerateAndMixSegments(callback);
if (result != null)
{
callback = (MethodCallbackInfo)result;
}
else
{
continue;
}
}
if (serverBase.ClientServiceCallMethodsResult.TryGetValue(callback.Guid, out KeyValue <Type, object> resultTask))
{
if (callback.IsException)
{
resultTask.Value.GetType().FindMethod("SetException").Invoke(resultTask.Value, new object[] { new Exception(callback.Data) });
}
else
{
resultTask.Value.GetType().FindMethod("SetResult").Invoke(resultTask.Value, new object[] { ServerSerializationHelper.Deserialize(callback.Data, resultTask.Key, serverBase) });
}
}
}
else if (dataType == DataType.GetServiceDetails)
{
byte[] bytes = await client.StreamHelper.ReadBlockToEndAsync(stream, compressMode, serverBase.ProviderSetting.MaximumReceiveDataBlock);
//if (ClientsSettings.ContainsKey(client))
// bytes = DecryptBytes(bytes, client);
string json = Encoding.UTF8.GetString(bytes);
string hostUrl = ServerSerializationHelper.Deserialize <string>(json, serverBase);
ServerServicesManager serverServicesManager = new ServerServicesManager();
ProviderDetailsInfo detail = serverServicesManager.SendServiceDetail(hostUrl, serverBase);
json = ServerSerializationHelper.SerializeObject(detail, serverBase);
List <byte> resultBytes = new List <byte>
{
(byte)DataType.GetServiceDetails,
(byte)CompressMode.None
};
byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
byte[] dataLen = BitConverter.GetBytes(jsonBytes.Length);
resultBytes.AddRange(dataLen);
resultBytes.AddRange(jsonBytes);
await client.StreamHelper.WriteToStreamAsync(client.ClientStream, resultBytes.ToArray());
}
else if (dataType == DataType.GetMethodParameterDetails)
{
byte[] bytes = await client.StreamHelper.ReadBlockToEndAsync(stream, compressMode, serverBase.ProviderSetting.MaximumReceiveDataBlock);
//if (ClientsSettings.ContainsKey(client))
// bytes = DecryptBytes(bytes, client);
string json = Encoding.UTF8.GetString(bytes);
MethodParameterDetails detail = ServerSerializationHelper.Deserialize <MethodParameterDetails>(json, serverBase);
if (!serverBase.RegisteredServiceTypes.TryGetValue(detail.ServiceName, out Type serviceType))
{
throw new Exception($"{client.IPAddress} {client.ClientId} Service {detail.ServiceName} not found");
}
if (serviceType == null)
{
throw new Exception($"{client.IPAddress} {client.ClientId} serviceType {detail.ServiceName} not found");
}
ServerServicesManager serverServicesManager = new ServerServicesManager();
json = serverServicesManager.SendMethodParameterDetail(serviceType, detail, serverBase);
List <byte> resultBytes = new List <byte>
{
(byte)DataType.GetMethodParameterDetails,
(byte)CompressMode.None
};
byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
byte[] dataLen = BitConverter.GetBytes(jsonBytes.Length);
resultBytes.AddRange(dataLen);
resultBytes.AddRange(jsonBytes);
await client.StreamHelper.WriteToStreamAsync(client.ClientStream, resultBytes.ToArray());
}
else if (dataType == DataType.GetClientId)
{
byte[] bytes = Encoding.UTF8.GetBytes(client.ClientId);
List <byte> result = new List <byte>();
result.Add((byte)DataType.GetClientId);
result.Add((byte)CompressMode.None);
result.AddRange(BitConverter.GetBytes(bytes.Length));
result.AddRange(bytes);
//if (ClientsSettings.ContainsKey(client))
// bytes = EncryptBytes(bytes, client);
if (result.Count > serverBase.ProviderSetting.MaximumSendDataBlock)
{
throw new Exception($"{client.IPAddress} {client.ClientId} GetClientId data length exceeds MaximumSendDataBlock");
}
await client.StreamHelper.WriteToStreamAsync(client.ClientStream, result.ToArray());
}
else
{
//throw new Exception($"Correct DataType Data {dataType}");
serverBase.AutoLogger.LogText($"Correct DataType Data {oneByteOfDataType} {client.ClientId} {client.IPAddress}");
break;
}
}
serverBase.DisposeClient(client, null, "StartToReadingClientData while break");
}
catch (Exception ex)
{
serverBase.AutoLogger.LogError(ex, $"{client.IPAddress} {client.ClientId} ServerBase SignalGoDuplexServiceProvider StartToReadingClientData");
serverBase.DisposeClient(client, null, "SignalGoDuplexServiceProvider StartToReadingClientData exception");
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="mode"></param>
/// <returns></returns>
public static string GetFileUrl(string filePath, CompressMode mode = CompressMode.Small)
{
return string.IsNullOrEmpty(filePath) ? string.Empty : _FileStorageClient.GetFile(filePath, mode);
}
/// <summary>
/// 获取文件URL。
/// </summary>
/// <param name="url">Url帮助器</param>
/// <param name="filePath">文件地址</param>
/// <param name="mode">图片压缩模式</param>
/// <returns>文件URL</returns>
public static string GetFileUrl(this UrlHelper url, string filePath, CompressMode mode = CompressMode.Small)
{
return string.IsNullOrEmpty(filePath)
? string.Empty
: url.Content(_FileStorageClient.GetFile(filePath, mode));
}
/// <summary>
/// compress the input data
/// </summary>
/// <param name="input">the input data</param>
/// <param name="compressMode">the compress mode of this compress</param>
/// <returns>compressed data, if the compressed data is larger than input data, the original data
/// is returned</returns>
public byte[] Compress(byte[] input, out CompressMode compressMode)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
compressMode = CompressMode.Compressed;
if (input.Length > (window8k - slidingWindow.Count))
{
compressMode = compressMode | CompressMode.SetToFront;
hashTable.Clear();
slidingWindow.Clear();
}
CompressCore(input);
byte[] ret = new byte[outputStream.Length];
outputStream.Position = 0;
outputStream.Read(ret, 0, ret.Length);
//put stream position to 0 for next round compress
outputStream.SetLength(0);
if (ret.Length > input.Length)
{
compressMode = CompressMode.Flush;
hashTable.Clear();
slidingWindow.Clear();
return input;
}
return ret;
}
