void OnLoadDataTable(object sender, AsyncEventArgs e)
{
Table tbl = new Table {
{ "id" }, { "name" }
};
tbl.AddRow(new { id = "1", name = "李全亮" });
tbl.AddRow(new { id = "2", name = "杨乐" });
tbl.AddRow(new { id = "3", name = "任艳莉" });
tbl.AddRow(new { id = "4", name = "潘洋" });
tbl.AddRow(new { id = "5", name = "李妍" });
tbl.AddRow(new { id = "6", name = "尚涛" });
((CList)sender).Data = tbl;
}
private void TcpServer_DataReceived(object sender, AsyncEventArgs e)
{
byte[] a = e._state.Buffer;
int length = e._state.RecLength;
var Temp = a.Skip(0).Take(length).ToArray();
TestMesseages TestMesseages = new TestMesseages(TcpServer, Temp);
TestMesseages.ReturnMessages();
//readBytes = e._state.NetworkStream.Read(buffer, 0, buffer.Length);
//string str = Encoding.ASCII.GetString(buffer).Substring(0, readBytes);
}
protected virtual async void OnPositionChanged(object sender, AsyncEventArgs e)
{
using (e.Defer())
{
await Windows.Invoke(() =>
{
if (this.PositionChanged != null)
{
this.PositionChanged(sender, e);
}
this.OnPropertyChanged("Position");
}).ConfigureAwait(false);
}
}
internal AsyncCompletionResult GetBufferAsync(GetBufferAsyncEventArgs getBufferState)
{
Fx.Assert(getBufferState != null, "GetBufferAsyncEventArgs cannot be null.");
int count = getBufferState.Arguments.Count;
Fx.Assert(count >= 0 && count <= bufferLength, String.Empty);
int finalOffset = 0;
int bufferOffset = this.offset;
if (bufferOffset + count <= bufferLength)
{
finalOffset = bufferOffset;
}
else
{
if (onGetFlushComplete == null)
{
onGetFlushComplete = new AsyncEventArgsCallback(GetBufferFlushComplete);
}
if (flushBufferState == null)
{
this.flushBufferState = new AsyncEventArgs <object>();
}
this.flushBufferState.Set(onGetFlushComplete, getBufferState, this);
if (FlushBufferAsync(this.flushBufferState) == AsyncCompletionResult.Completed)
{
finalOffset = 0;
this.flushBufferState.Complete(true);
}
else
{
return(AsyncCompletionResult.Queued);
}
}
#if DEBUG
Fx.Assert(finalOffset + count <= bufferLength, "");
for (int i = 0; i < count; i++)
{
buffer[finalOffset + i] = (byte)'<';
}
#endif
//return the buffer and finalOffset;
getBufferState.Result = getBufferState.Result ?? new GetBufferEventResult();
getBufferState.Result.Buffer = this.buffer;
getBufferState.Result.Offset = finalOffset;
return(AsyncCompletionResult.Completed);
}
public void RegisterBackgroundTask_PassNonNullForFunc_ShouldPassCancellationTokenToFunc()
{
// Arrange.
var func = Substitute.For <Func <CancellationToken, Task> >();
func(Arg.Any <CancellationToken>()).Returns(Task.CompletedTask);
using (var cancellationSource = new CancellationTokenSource())
{
// Act.
var subject = new AsyncEventArgs(cancellationSource.Token);
subject.RegisterBackgroundTask(func);
// Assert.
func.Received(1)(cancellationSource.Token);
}
}
static void searcher_SearchCompleted(object sender, AsyncEventArgs e)
{
//this is volatile, so we need check it first or another thread
//could change this from under us
bool lastSearch = (((AsyncSearcher)sender).PendingSearches == 0);
Console.WriteLine(
"{0} Search Complete on thread {1}",
e.RequestID.Equals(_guid) ? "First" : "Second",
Thread.CurrentThread.ManagedThreadId
);
if (lastSearch)
{
_resetEvent.Set();
}
}
private static void MyClient_AsyncReadcompleted(object sender, AsyncEventArgs e)
{
Console.WriteLine("收到读取完毕事件！");
string msg = "";
bool b = Util.VeryfyMessage(e._data, out msg);
if (!b)
{
Console.WriteLine("验证消息失败");
}
else
{
Console.WriteLine("解压缩前的数据长度{0}", e._data.Length);
Console.WriteLine("解压缩后数据长度：{0}", msg.Length);
DataTable dt = Util.JsonToDataTable(msg);
Console.WriteLine("反序列化输出行数：{0}", dt.Rows.Count);
}
}
void TcpServer_ClientDisconnected(object sender, AsyncEventArgs e)
{
AsyncTCPServer server = sender as AsyncTCPServer;
int temp = ServersList.ToList <ServersInfo>().FindIndex(ex => (ex.IPAddr.ToString() == server.Address.ToString() && ex.Port == server.Port));
if (temp == -1)//列表中没找到服务器
{
return;
}
TCPClientState client = e._state as TCPClientState;
EndPoint endpoint = client.TcpClient.Client.RemoteEndPoint;
App.Current.Dispatcher.Invoke((System.Action)(() =>
{
var tmp = ServersList[temp].ClientsList.First(ex => ex.IpEndPort == endpoint);
ServersList[temp].ClientsList.Remove(tmp);
}));
}
protected virtual async void OnFaulted(object sender, AsyncEventArgs e)
{
using (e.Defer())
{
var backgroundTask = sender as IBackgroundTask;
if (backgroundTask.Exception is AggregateException)
{
foreach (var innerException in (backgroundTask.Exception as AggregateException).InnerExceptions)
{
await this.Add(new ComponentError(backgroundTask, innerException.Message, innerException)).ConfigureAwait(false);
}
}
else
{
await this.Add(new ComponentError(backgroundTask, backgroundTask.Exception.Message, backgroundTask.Exception)).ConfigureAwait(false);
}
}
}
public void _socket_DataReceived(object sender, AsyncEventArgs e)
{
if (e._state.Buffer.Length > 10)
{
try
{
string recvstring = Encoding.Unicode.GetString(e._state.Buffer);
recvstring = recvstring.Remove(recvstring.IndexOf('\0'));
if (recvstring != "")
{
RecvDataDel del = new RecvDataDel(RecvData);
del.BeginInvoke(recvstring, null, null);
}
}
catch (Exception ex)
{
}
}
}
/// <summary>
/// The callback method which will be executed each time an async operation completes.
/// </summary>
/// <param name="eventArgs"> Async operation event arguments </param>
private static void AsyncOperationCallBack(AsyncEventArgs eventArgs)
{
if (eventArgs != null)
{
Console.WriteLine("Callback for the " + eventArgs.AsyncOperationType + " operation received.");
if (eventArgs.Success)
{
Console.WriteLine("The operation was completed successfully.\n");
}
else
{
Console.WriteLine("The operation was completed with errors.\n");
if (eventArgs.FailedDocuments != null)
{
foreach (var failedDocument in eventArgs.FailedDocuments)
{
PrintFailedDocumentDetails(failedDocument);
}
}
}
}
}
public async Task InvokeAsync_BaseEventArgsWithCancelledBackgroundTasks_ShouldCompleteCancelled()
{
// Arrange.
BaseEvent += (sender, e) => e.RegisterBackgroundTask(Task.CompletedTask);
BaseEvent += (sender, e) => e.RegisterBackgroundTask(async cancellationToken =>
{
await Task.Yield();
cancellationToken.ThrowIfCancellationRequested();
});
using (var cancellationSource = new CancellationTokenSource())
{
cancellationSource.Cancel();
// Act.
var args = new AsyncEventArgs(cancellationSource.Token);
var error = await Assert.ThrowsAsync <OperationCanceledException>(() => BaseEvent.InvokeAsync(this, args));
// Assert.
Assert.Equal(cancellationSource.Token, error.CancellationToken);
}
}
static private void OnTrailBytesComplete(IAsyncEventArgs eventArgs)
{
InternalWriteBase64TextAsyncWriter thisPtr = (InternalWriteBase64TextAsyncWriter)eventArgs.AsyncState;
Exception completionException = null;
bool completeSelf = false;
try
{
if (eventArgs.Exception != null)
{
completionException = eventArgs.Exception;
completeSelf = true;
}
else if (thisPtr.WriteBufferAsync() == AsyncCompletionResult.Completed)
{
completeSelf = true;
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completionException = exception;
completeSelf = true;
}
if (completeSelf)
{
AsyncEventArgs <XmlNodeWriterWriteBase64TextArgs> state = thisPtr.nodeState;
thisPtr.nodeState = null;
state.Complete(false, eventArgs.Exception);
}
}
/// <summary>
/// 接收到数据事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void MyTcpServer_DataReceived(object sender, AsyncEventArgs e)
{
TCPClientState state = e._state;
string clientCmdString = ""; //= Encoding.UTF8.GetString(state.Buffer);
byte[] data = new byte[state.Buffer.Length];
Buffer.BlockCopy(state.Buffer, 0, data, 0, state.Buffer.Length);
bool bsucceed = Util.VeryfyMessage(data, out clientCmdString);
if (!bsucceed)
{
return;
}
//clientCmdString = clientCmdString.Trim(new char[] { '\0' });
Console.WriteLine("接收到:" + state.TcpClient.Client.RemoteEndPoint.ToString() + "\t" + clientCmdString);
QueryAndSendPara pra = new QueryAndSendPara();
pra.cmd = clientCmdString;
pra.state = state;
Thread thread = new Thread(new ParameterizedThreadStart(QueryAndSend));
thread.Start(pra);
}
private void TcpServer_DataReceived(object sender, AsyncEventArgs e)
{
byte[] a = e._state.Buffer;
int length = e._state.RecLength;
var Temp = a.Skip(0).Take(length).ToArray();
if (Encoding.Default.GetString(Temp) == "Flag")
{
SendBytcp(new byte[] { (byte)Flag });
}
SendDataToclient();
string jsondata = JsonSoltion.Getjsonstr(Temp, ref Flag);
if (null != jsondata && Flag == -1)
{
RefreshUi(jsondata);
WorkingSets.local.updateJob();
StartTcptest(jsondata);
}
else
{
SendBytcp(new byte[] { (byte)Flag });
}
}
private void Current_AsyncProcessStarted(object sender, AsyncEventArgs e)
{
operationCount = e.OperationCount;
operationIndex = 0;
ResetGuages(true);
}
private static void sendcomplete_callback(object os, AsyncEventArgs state)
{
//send complete
}
private void TcpServer_ClientConnected(object sender, AsyncEventArgs e)
{
// throw new NotImplementedException();
}
protected virtual Task OnSnapshotRestorationCommencingAsync(CancellationToken?cancellationToken = default)
{
return(SnapshotRestorationCommencing.InvokeAsync(
this,
AsyncEventArgs.Empty(cancellationToken: cancellationToken)));
}
private static void clientconnect_callback(object os, AsyncEventArgs state)
{
show_connect_info("connect:" + state._state.TcpClient.Client.RemoteEndPoint.ToString());
client_fd = state._state;//保存client信息,发送会用到
send_read_gain();
}
void OnLoadField(object sender, AsyncEventArgs e)
{
((CList)_fv["field"]).Data = _info.Root.Data.GetColsData(_level.Matrix.Tbl);
}
private void TcpServer_DataReceived(object sender, AsyncEventArgs e)
{
}
private void TcpServer_ClientConnected(object sender, AsyncEventArgs e)
{
}
private void TcpServer_CompletedSend(object sender, AsyncEventArgs e)
{
}
void lb_SubmitScoreCompleted(object sender, AsyncEventArgs e)
{
if (e.Result.ReturnValue)
{
// Succeed
XLiveScoreForm form = new XLiveScoreForm(this.manager);
form.FormResultEvent += new EventHandler<ScoreFormResultEventArgs>(form_FormResultEvent);
form.Show("6070f347-e93d-4463-9954-cb66fddeaf7e", tFinalScore);
}
else
{
OpenXLive.MessageBox.Show(e.Result.ErrorMessage);
}
}
private void ApplicationState_AsyncProcessStarted(object sender, AsyncEventArgs e)
{
batchTreeView.Enabled = false;
}
private void ApplicationState_AsyncProcessStarted(object sender, AsyncEventArgs e)
{
dataSourceTreeView.Enabled = false;
dataSourceTreeView.ContextMenuStrip.Enabled = false;
}
private static void clientdisconnect_callback(object os, AsyncEventArgs state)
{
show_connect_info("disconnect");
do_update_type = do_update_type | 0x0002;
}
private void ManagerDownloadCompleted(object sender, AsyncEventArgs e)
{
BusyOperations--;
var user = e.Result as User;
if (user != null)
{
User = user;
BusyOperations++;
_manager.GetObjectListAsync<Issue>(new NameValueCollection {{"assigned_to_id", User.Id.ToString()}});
BusyOperations++;
_manager.GetObjectListAsync<TimeEntry>(new NameValueCollection
{
{
"user_id",
User.Id.ToString(CultureInfo.InvariantCulture)
},
{
"spent_on",
$"><{TimeLogger.StartDate:yyyy-MM-dd}|{TimeLogger.EndDate:yyyy-MM-dd}"
}
});
}
else
{
var arrayList = e.Result as ArrayList;
if (arrayList == null) return;
var list = arrayList;
if (list.Count > 0)
{
if (list[0] is Issue)
{
_issues = list.OfType<Issue>();
}
else if (list[0] is TimeEntry)
{
_timeEntries = list.OfType<TimeEntry>();
}
}
if (BusyOperations != 0) return;
_logger = new LoggerModel();
_logger.Init(_issues, _timeEntries.Where(entry => entry.User.Id == User.Id));
TimeLogger.Logger = _logger;
}
}
private void ApplicationState_AsyncProcessStarted(object sender, AsyncEventArgs e)
{
EnableControls();
}
protected virtual void OnCurrentStreamChanged(object sender, AsyncEventArgs e)
{
var task = this.Refresh();
}
public AsyncEventArgsTests()
{
this.subject = new AsyncEventArgs(CancellationToken.None);
}
