public static void Run()
{
using (var factory = new PipeFactory())
{
var filePath = Path.GetFullPath("Program.cs");
// This is what Stream looks like
//var fs = File.OpenRead(filePath);
//var compressed = new MemoryStream();
//var compressStream = new DeflateStream(compressed, CompressionMode.Compress);
//fs.CopyTo(compressStream);
//compressStream.Flush();
//compressed.Seek(0, SeekOrigin.Begin);
var input = factory.ReadFile(filePath)
.DeflateCompress(factory, CompressionLevel.Optimal)
.DeflateDecompress(factory);
// Wrap the console in a pipeline writer
var output = factory.CreateWriter(Console.OpenStandardOutput());
// Copy from the file reader to the console writer
input.CopyToAsync(output).GetAwaiter().GetResult();
input.Complete();
output.Complete();
}
}
// filtering test function for writer
public static IPipeWriter Filter0xf0(this PipeFactory pfac, IPipeWriter writer)
{
return(pfac.CreateWriter(writer, async(r, w) =>
{
while (true)
{
var wbuf = w.Alloc();
try
{
var result = await r.ReadAsync();
if (result.IsCancelled)
{
// read cancelled
break;
}
if (result.IsCompleted && result.Buffer.IsEmpty)
{
// read end
break;
}
// ReadableBuffer is linked list of System.Memory<T>
foreach (var rbuf in result.Buffer)
{
// allocate buffer for writing
wbuf.Ensure(rbuf.Length);
// extract write buffer you want to use
var span = wbuf.Memory.Span.Slice(0, rbuf.Length);
// copy data to write buffer
// OutOfRangeException when wbuffer is shorter than read buffer
rbuf.CopyTo(span);
// change value of write buffer
for (int i = 0; i < span.Length; i++)
{
span[i] = (byte)(span[i] & 0x0f);
}
// send write buffer to next writer
wbuf.Advance(rbuf.Length);
}
// consume read buffer
// must call before next ReadAsync
r.Advance(result.Buffer.End);
}
catch (Exception e)
{
Console.WriteLine($"{e}");
}
// must call FlushAsync before next Alloc
await wbuf.FlushAsync();
}
w.Complete();
}));
}
static async Task Main(string[] args)
{
using (var factory = new PipeFactory())
{
var inputPipe = factory.ReadFile("data.txt");
var outputPipe = factory.CreateWriter(Console.OpenStandardOutput());
await inputPipe.CopyToAsync(outputPipe);
inputPipe.Complete();
outputPipe.Complete();
Console.ReadLine();
}
}
static void MemoryPipeTest()
{
using (var pfac = new PipeFactory())
{
// pipeline endpoint
// if you want only to output Stream, call AsPipelineWriter(this Stream) extension method or CopyToAsync(Stream)
var epwriter = pfac.CreateWriter(null, async(r, w) =>
{
while (true)
{
try
{
var result = await r.ReadAsync();
if (result.IsCancelled || (result.IsCompleted && result.Buffer.IsEmpty))
{
break;
}
foreach (var rbuf in result.Buffer)
{
for (int i = 0; i < rbuf.Length; i++)
{
Console.Write($"{rbuf.Span[i].ToString("x2")}");
if ((i & 0xf) == 0xf)
{
Console.WriteLine();
}
else
{
Console.Write(":");
}
}
}
r.Advance(result.Buffer.End);
}
catch (Exception e)
{
Console.WriteLine($"{e}");
}
}
});
var writer = pfac.Filter0xf0(epwriter);
var reader = pfac.CreateFromEnumerable(Enumerable.Range(0, 10000));
reader.CopyToAsync(writer).Wait();
}
}
public static IPipeWriter CreateGZipCompressWriter(this PipeFactory factory, IPipeWriter writer, CompressionLevel compressionLevel)
{
var deflater = new WritableDeflateTransform(compressionLevel, ZLibNative.GZip_DefaultWindowBits);
return(factory.CreateWriter(writer, deflater.Execute));
}
public StreamPipeConnection(PipeFactory factory, Stream stream)
{
Input = factory.CreateReader(stream);
Output = factory.CreateWriter(stream);
}