public static async Task AsyncStream()
{
var asyncStream = new AsyncStream();
await asyncStream.Print();
await asyncStream.PrintParallel();
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
{
if (disposing)
{
// Release managed resources
try {
if (AsyncSocket != null)
{
if (AsyncSocket.Connected)
{
AsyncSocket.Shutdown(SocketShutdown.Both);
}
if (AsyncStream != null)
{
AsyncStream.Close();
AsyncStream.Dispose();
AsyncStream = null;
}
AsyncSocket.Close();
AsyncSocket = null;
}
}
catch { }
}
// Release unmanaged resources
}
}
/// <summary>
/// 发送字节流.
/// </summary>
/// <param name="Packet">The packet.</param>
public virtual void SendPacket(byte[] Packet)
{
try {
if (AsyncStream.CanWrite)
{
__outPacket = new P();
__outPacket.Put(Packet, 0, Packet.Length);
//异步读取文件,把FileStream对象作为异步的参数// <-
AsyncCallback callback = new AsyncCallback(OnWriteCompletion);
IAsyncResult async = AsyncStream.BeginWrite(Packet, 0, Packet.Length, callback, AsyncStream); // <-
}
}
catch (IOException ex) {
FireOnDisconnect();
#if DEBUG
WriteLog(ex);
#endif
}
catch (System.Exception ex)
{
#if DEBUG
WriteLog(ex);
#endif
}
}
public async Task <ChannelReader <int> > DuplexOneChannel(ChannelReader <int> requestChannel)
{
var responseChannel = Channel.CreateUnbounded <int>();
_ = AsyncStream.EnumerateBackChannel(requestChannel, responseChannel.Writer, _logger);
return(await _appTwoClient.StreamDuplexTwoChannel(responseChannel.Reader));
}
//*/
public ChannelReader <int> DuplexTwoChannel(ChannelReader <int> requestChannel)
{
var responseChannel = Channel.CreateUnbounded <int>();
AsyncStream.EnumerateBackChannel(requestChannel, responseChannel.Writer, _logger);
return(responseChannel.Reader);
}
public StreamLocalAsyncFactory(Stream stream)
{
this.stream = stream as AsyncStream;
if (this.stream == null)
{
nativeAsyncFactory = new StreamNativeAsyncFactory(stream);
}
}
public static AsyncStream <TResult> ParallelizeStreamAsync <T, TResult>(this AsyncStream <T> source,
Func <T, CancellationToken, Task <TResult> > actionAsync, ParallelizeOption option)
{
if (actionAsync == null)
{
throw new ArgumentNullException(nameof(actionAsync));
}
return(ParallelizeStreamInternalAsync(source, actionAsync, option));
}
public static async Task <ParallelizedSummary> GetExceptionsAsync <T>(this AsyncStream <T> source)
{
var exceptions = new ConcurrentBag <Exception>();
while (await source.ChannelReader.WaitToReadAsync())
{
var sourceValue = await source.ChannelReader.ReadAsync();
if (sourceValue.Status == ExecutionStatus.Faulted && sourceValue.Exception != null)
{
exceptions.Add(sourceValue.Exception);
}
}
return(new ParallelizedSummary(exceptions, source.CancellationToken.IsCancellationRequested));
}
public async Task AsyncReadWorks()
{
MemoryStream = new AsyncStream();
Reader = new StreamPipeReader(MemoryStream, 16, new TestMemoryPool());
Write(Encoding.ASCII.GetBytes(new string('a', 10000)));
for (var i = 0; i < 99; i++)
{
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End);
}
var result = await Reader.ReadAsync();
Assert.Equal(1600, result.Buffer.Length);
Reader.AdvanceTo(result.Buffer.End);
}
public async Task AsyncReadWorks()
{
MemoryStream = new AsyncStream();
CreateReader();
WriteByteArray(2000);
for (var i = 0; i < 99; i++)
{
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End);
}
var result = await Reader.ReadAsync();
Assert.Equal(1600, result.Buffer.Length);
Reader.AdvanceTo(result.Buffer.End);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
//make sure this does not block startup as it forces the continuation to be scheduled on ANY OTHER threadpool worker this SynchronizationContext is null => returns imediatly
await Task.Yield();
//Waiting for connection to be done
await _appOneClient.OnConnectedAsync();
while (!stoppingToken.IsCancellationRequested)
{
//var stream = _appOneClient.StartDuplexOneAsync(AsyncStream.GenerateStream(1));
//await AsyncStream.EnumerateStream(stream, _logger);
var responseChannel = await _appOneClient.StreamDuplexOneChannelAsync(AsyncStream.GenerateChannelReader(1));
await AsyncStream.EnumerateChannel(responseChannel, _logger);
await Task.Delay(4000);
}
}
private static Task ParallelizeCoreStreamAsync <T, TResult>(ParallelizeCore core,
Func <T, CancellationToken, Task <TResult> > actionAsync,
AsyncStream <T> source,
ChannelWriter <StreamedValue <TResult> > resultsChannel,
int index,
ParallelMonitor <T> monitor)
{
return(Task.Run(async() =>
{
while (await source.ChannelReader.WaitToReadAsync()) //returns false when the channel is completed
{
while (source.ChannelReader.TryRead(out StreamedValue <T> streamedValue))
{
if (streamedValue.Status != ExecutionStatus.Succeeded)
{
continue;
}
var item = streamedValue.Item;
monitor.SetActive(index, item);
if (core.IsLoopBreakRequested)
{
await YieldNotExecutedAsync(resultsChannel, default, item);
public IAsyncStream <T> GetStream <T>(Guid streamId, string streamNamespace)
{
ActorModel.Runtime.SendEvent(StreamDictionaryMachineID, new StreamDictionaryMachine.EGetStream(
streamId, streamNamespace, ActorModel.Runtime.GetCurrentMachineId()));
Event resultEvent = ActorModel.Runtime.Receive(typeof(StreamDictionaryMachine.EStream));
object resultStream = ((StreamDictionaryMachine.EStream)resultEvent).stream;
if (resultStream != null)
{
return((IAsyncStream <T>)((StreamDictionaryMachine.EStream)resultEvent).stream);
}
else
{
object streamToAdd = new AsyncStream <T>(streamId, streamNamespace);
ActorModel.Runtime.SendEvent(StreamDictionaryMachineID,
new StreamDictionaryMachine.EAddStream(streamId, streamNamespace, streamToAdd, ActorModel.Runtime.GetCurrentMachineId()));
resultEvent = ActorModel.Runtime.Receive(typeof(StreamDictionaryMachine.EStream));
object addedStream = ((StreamDictionaryMachine.EStream)resultEvent).stream;
Console.WriteLine("Created new stream for: " + streamId.ToString() + " " + streamNamespace);
return((IAsyncStream <T>)addedStream);
}
}
static private IEnumerable <Topic> GetTopicsForWhatsNewCSharp()
{
Debugger.Break();
var topics = new List <Topic>();
// C# 7 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#throw-expressions
topics.Add(new Topic("Throw Expressions"));
ThrowExp.Run();
Debugger.Break();
// C# 7 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#tuples"
topics.Add(new Topic("Tuples"));
Tuples.Run();
Debugger.Break();
// C# 7 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#pattern-matching
topics.Add(new Topic("Pattern Matching"));
PatternMatchingIs.Run();
PatternMatchingSwitch.Run();
Debugger.Break();
// C# 7 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#discards
topics.Add(new Topic("Discards"));
Discards.Run();
Debugger.Break();
// C# 7 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#local-functions
// C# 8 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#static-local-functions
topics.Add(new Topic("Local Functions & Static Local Functions."));
LocalFunctions.Run();
Debugger.Break();
// C# 7.1 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-1#async-main
topics.Add(new Topic("Async Main"));
Debugger.Break();
// C# 7.1 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-1#default-literal-expressions
topics.Add(new Topic("Default Literal Expressions"));
DefaultLiteralExpressions.Run();
Debugger.Break();
// C# 7.1 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-1#inferred-tuple-element-names
topics.Add(new Topic("Inferred Tuple Property Names"));
InferredTuple.Run();
Debugger.Break();
// C# 7.2 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-2#safe-efficient-code-enhancements
// https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code
topics.Add(new Topic("Safe Code Enhancements"));
Debugger.Break();
// C# 7.2 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-2#private-protected-access-modifier
topics.Add(new Topic("Private Protected modifier"));
PrivateProtected.Run();
Debugger.Break();
// C# 7.3 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-3
topics.Add(new Topic("C# 7.3 Improvements"));
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#default-interface-methods
topics.Add(new Topic("Interface Implementation"));
InterfaceImplementation.Run();
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#more-patterns-in-more-places
topics.Add(new Topic("Switch Expressions"));
SwitchExpressions.Run();
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#using-declarations
topics.Add(new Topic("Using Declaration"));
UsingDeclaration.Run();
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#using-declarations
topics.Add(new Topic("Nullable Refernce types"));
NullableRefTypes.Run();
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#asynchronous-streams
topics.Add(new Topic("Async Streams"));
AsyncStream.Run();
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#null-coalescing-assignment
topics.Add(new Topic("Null Coalescing Assignment"));
NullCoalescing.Run();
Debugger.Break();
// C# 8.0 - https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#indices-and-ranges
topics.Add(new Topic("Indexes and Ranges"));
IndexesAndRanges.Run();
Debugger.Break();
return(topics);
}
/*/
* public IAsyncEnumerable<int> DuplexTwo()
* {
* return AsyncStream.Generatestream(100);
* }
* /*/
public IAsyncEnumerable <int> DuplexTwo(IAsyncEnumerable <int> incommingStream)
{
return(AsyncStream.EnumerateBackStream(incommingStream, _logger));
}
/// <summary>
/// 发送数据包(上次发送后未取回数据包时不可再发送数据包).
/// </summary>
public virtual void ReadPacket()
{
try {
data = new byte[bufferSize];
//异步读取文件,把FileStream对象作为异步的参数// <-
if (AsyncStream.CanRead)
{
LastPacket = __inPacket;
data = new byte[bufferSize];
IAsyncResult result = AsyncStream.BeginRead(data, 0, bufferSize,
new AsyncCallback(OnReadCompletion),
AsyncStream);
if (!result.AsyncWaitHandle.SafeWaitHandle.IsClosed)
{
// this line impliments the timeout, if there is a timeout, the callback fires and the request becomes aborted
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(
delegate(object state, bool timedOut)
{
if (timedOut)
{
if (this.OnAsyncTimeout != null)
{
this.OnAsyncTimeout(this, new AsyncEventArgs <T>(this as T));
}
}
}
), AsyncStream, PacketTimeout ?? __DefaultTimeout, true);
}
// The response came in the allowed time. The work processing will happen in the
// callback function.
allDone.WaitOne();
}
else
{
#if DEBUG
Console.WriteLine("Sorry. You cannot read from this NetworkStream.");
#endif
}
}
catch (SocketException ex) {
/*
* 1、客户端程序异常。
* 对于这种情况，我们很好处理，因为客户端程序异常退出会在服务端引发ConnectionReset的Socket异常（就是WinSock2中的10054异常）。
* 只要在服务端处理这个异常就可以了。
* 2、网络链路异常。
* 如：网线拔出、交换机掉电、客户端机器掉电。当出现这些情况的时候服务端不会出现任何异常。
* 这样的话上面的代码就不能处理这种情况了。对于这种情况在MSDN里面是这样处理的，我在这里贴出MSDN的原文：
* 如果您需要确定连接的当前状态，请进行非阻止、零字节的 Send 调用。
* 如果该调用成功返回或引发 WAEWOULDBLOCK 错误代码 (10035)，则该套接字仍然处于连接状态；否则，该套接字不再处于连接状态。
*/
if (ex.ErrorCode == 10054)
{
FireOnDisconnect();
}
#if DEBUG
WriteLog(ex);
#endif
}
catch (Exception ex) {
#if DEBUG
WriteLog(ex);
#endif
}
}
static void Main(string[] args)
{
AsyncStream.Demo();
Console.ReadKey();
}
private static AsyncStream <TResult> ParallelizeStreamInternalAsync <T, TResult>(this AsyncStream <T> source,
Func <T, CancellationToken, Task <TResult> > actionAsync, ParallelizeOption option)
{
var core = new ParallelizeCore(source.CancellationToken, option);
var monitor = new ParallelMonitor <T>(option.MaxDegreeOfParallelism);
var channel = Channel.CreateUnbounded <StreamedValue <TResult> >();
var task = Task.Run(async() =>
{
try
{
using (core)
{
var parallelTasks =
Enumerable.Range(0, option.MaxDegreeOfParallelism)
.Select(i => ParallelizeCoreStreamAsync(core, actionAsync, source, channel, i, monitor))
.ToArray();
await Task.WhenAll(parallelTasks);
}
}
catch (Exception e)
{
channel.Writer.Complete(e);
throw;
}
channel.Writer.Complete();
ThrowOnErrors(option, core);
});
return(new AsyncStream <TResult>(channel, task, source.CancellationToken));
}
public IAsyncEnumerable <int> DuplexOne(IAsyncEnumerable <int> stream)
{
_logger.LogInformation("Doing 'DuplexOne'");
return(AsyncStream.EnumerateBackStream(_appTwoClient.StreamDuplexTwo(stream), _logger));
}
/// <summary>
/// Synchronized version of an async stream.
/// </summary>
/// <param name="stream">Stream to synchronize.</param>
/// <returns>the synchronized version of the given stream.</returns>
public static AsyncStream Synchronized(this AsyncStream stream)
{
return(AsyncStream.Synchronized(stream));
}
