private async void Animate(AsyncContext context, IEnumerable<ParticleState> states)
{
var en = states.GetEnumerator();
while (en.MoveNext())
{
var state = en.Current;
Color = state.Color * Opacity;
Scale = new Vector2(state.Scale);
if (state.Duration <= 0)
continue;
if (!en.MoveNext())
await context.Delay(TimeSpan.FromMilliseconds(state.Duration));
else
{
var nextState = en.Current;
await TaskEx.WhenAll<TimeSpan>(
(Task<TimeSpan>)context.Animate(TimeSpan.FromMilliseconds(state.Duration), state.Scale, nextState.Scale, v => Scale = new Vector2(v)),
(Task<TimeSpan>)context.Animate(TimeSpan.FromMilliseconds(state.Duration), state.Color, nextState.Color, v => Color = v));
}
}
Screen.RemoveEntity(this);
if (OnDecay != null)
OnDecay(this, EventArgs.Empty);
}
private static void addSubscription(AsyncContext asyncContext)
{
lock (asyncContext)
{
eventSubscriptions.Add(asyncContext);
}
}
public async Task<LiveConnectClient> Login()
{
LiveLoginResult result = await AuthClient.InitializeAsync(Scopes);
if (result.Status == LiveConnectSessionStatus.Connected)
{
return new LiveConnectClient(result.Session);
}
_context = new AsyncContext
{
WaitHandle = new AutoResetEvent(false)
};
Deployment.Current.Dispatcher.BeginInvoke(() => Login(_context));
await Task.Factory.StartNew(() => _context.WaitHandle.WaitOne());
if (_context.Error != null)
{
throw _context.Error;
}
result = _context.LoginResult;
if (result.Status == LiveConnectSessionStatus.Connected)
{
return new LiveConnectClient(result.Session);
}
return null;
}
private static void fireEvent()
{
AsyncContext[] subscriptions;
lock (eventSubscriptions)
{
subscriptions = new AsyncContext[eventSubscriptions.Count];
eventSubscriptions.CopyTo(subscriptions);
eventSubscriptions.Clear();
}
if (0 < subscriptions.Length)
{
var response = new EventResponse();
foreach (var elm in subscriptions)
{
try
{
elm.completeCall(response.toByteArray());
}
catch (Exception e)
{
}
}
}
}
private static void executeAsync2(IRpcClientInfo client, AsyncContext asyncState, byte[] bytes)
{
using (client.Impersonate())
{
var request = Serializer.Deserialize<EventRequest>(new MemoryStream(bytes));
addSubscription(asyncState);
}
}
private async void Login(AsyncContext context)
{
try
{
context.LoginResult = await AuthClient.LoginAsync(Scopes);
}
catch (Exception e)
{
context.Error = e;
}
finally
{
context.WaitHandle.Set();
}
}
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
var asyncContext = new AsyncContext(0);
var ar = new AsyncContextResult(extraData, asyncContext.WaitHandle);
// Set the completion handler for when all asynchronous work completes:
if (cb != null)
asyncContext.SetCompleted(() => { ar.SetCompleted(); cb(ar); });
else
asyncContext.SetCompleted(() => { });
// Start the asynchronous work:
HandleRequestAsync(context, asyncContext);
return ar;
}
protected RESTRequest(AsyncRESTHandler handler, HttpContext http, AsyncContext work)
{
this.handler = handler;
this.http = http;
this.work = work;
this.req = http.Request;
this.rsp = http.Response;
// Remove the /path/to/file.ashx prefix from the request URL:
string basePath = req.ApplicationPath.RemoveIfEndsWith("/") + req.AppRelativeCurrentExecutionFilePath.Substring(1);
url = req.Url.AbsolutePath.RemoveIfStartsWith(basePath, StringComparison.OrdinalIgnoreCase).RemoveIfStartsWith("/", StringComparison.Ordinal);
// Split the url by '/' into route portions:
route = url.Split(_splitChars, StringSplitOptions.RemoveEmptyEntries);
// Unescape route parts:
for (int i = 0; i < route.Length; ++i)
route[i] = Uri.UnescapeDataString(route[i]);
}
public override void HandleRequestAsync(HttpContext http, AsyncContext work)
{
try
{
// NOTE(jsd): Calling `work.Done()` will mark the request as completed in the event that no other async work has been done.
var req = CreateRequestHandler(http, work);
if (req == null)
{
work.Done();
return;
}
req.ProcessRequest();
}
catch (Exception ex)
{
http.Response.Clear();
http.Response.StatusCode = 500;
http.Response.Output.WriteLine(ex.ToString());
http.Response.End();
work.Done();
}
}
public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
{
GetResponseDelegate d = new GetResponseDelegate (GetAsyncResponse);
DelegateAsyncResult result = new DelegateAsyncResult ();
AsyncContext userContext = new AsyncContext (d, result, callback, state);
result.AsyncResult = d.BeginInvoke (new AsyncCallback (DelegateAsyncResult.Callback), userContext);
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncContextThread"/> class, creating a child thread waiting for commands. If <paramref name="sta"/> is <c>true</c>, then the child thread is an STA thread (throwing <see cref="NotSupportedException"/> if the platform does not support STA threads).
/// </summary>
public AsyncContextThread(bool sta)
{
_context = new AsyncContext();
_context.SynchronizationContext.OperationStarted();
_thread = new SingleThreadedApartmentThread(Execute, sta);
}
public string State() => AsyncContext.Run(() => SetDivarStateAsync(bu));
public static void RuncSync(Func <Task> action)
{
AsyncContext.Run(action);
}
public void Session_ProgressObservable_IntegrationTests(ProgressMode mode)
{
const int ObjectSize = 1000000;
const int ObjectsToRecord = 2;
AsyncContext.Run(async() =>
{
var realm = await SyncTestHelpers.GetIntegrationRealm("progress");
var completionTCS = new TaskCompletionSource <ulong>();
var callbacksInvoked = 0;
var session = realm.GetSession();
var observable = session.GetProgressObservable(ProgressDirection.Upload, mode);
for (var i = 0; i < ObjectsToRecord; i++)
{
realm.Write(() =>
{
realm.Add(new HugeSyncObject(ObjectSize));
});
}
var token = observable.Subscribe(p =>
{
try
{
callbacksInvoked++;
Assert.That(p.TransferredBytes, Is.LessThanOrEqualTo(p.TransferableBytes));
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
Assert.That(p.TransferableBytes, Is.GreaterThan(ObjectSize));
Assert.That(p.TransferableBytes, Is.LessThan((ObjectsToRecord + 1) * ObjectSize));
}
}
catch (Exception e)
{
completionTCS.TrySetException(e);
}
if (p.TransferredBytes == p.TransferableBytes)
{
completionTCS.TrySetResult(p.TransferredBytes);
}
});
realm.Write(() =>
{
realm.Add(new HugeSyncObject(ObjectSize));
});
var totalTransferred = await completionTCS.Task;
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
Assert.That(totalTransferred, Is.GreaterThanOrEqualTo(ObjectSize));
// We add ObjectsToRecord + 1 items, but the last item is added after subscribing
// so in the fixed mode, we should not get updates for it.
Assert.That(totalTransferred, Is.LessThan((ObjectsToRecord + 1) * ObjectSize));
}
else
{
Assert.That(totalTransferred, Is.GreaterThanOrEqualTo((ObjectsToRecord + 1) * ObjectSize));
}
Assert.That(callbacksInvoked, Is.GreaterThan(1));
token.Dispose();
realm.Dispose();
Realm.DeleteRealm(realm.Config);
});
}
public string City() => AsyncContext.Run(() => SetDivarCityAsync(bu));
static void Main(string[] args)
{
AsyncContext.Run(() => Fetch());
}
public ReturnedSaveFuncInfo Save(string tranName = "") => AsyncContext.Run(() => SaveAsync(tranName));
public void ChangeEncoderType()
{
TestHelper.SetConfigurationDefaults();
AsyncContext.Run(async() =>
{
var vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "avi");
TestHelper.CleanDirectory("/home/pi/videos/tests");
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.AddSeconds(20)))
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.MJPEG, MMALEncoding.I420, 10, 25000000);
//Create our component pipeline.
fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALVideoRenderer());
fixture.MMALCamera.ConfigureCameraSettings();
//Record video for 20 seconds
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.VideoPort, vidEncoder);
if (System.IO.File.Exists(vidCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(vidCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {vidCaptureHandler.GetFilepath()} was not created");
}
}
vidCaptureHandler = new VideoStreamCaptureHandler("/home/pi/videos/tests", "mjpeg");
using (var vidEncoder = new MMALVideoEncoder(vidCaptureHandler, new MMAL_RATIONAL_T(25, 1), DateTime.Now.AddSeconds(20)))
{
vidEncoder.ConfigureOutputPort(0, MMALEncoding.MJPEG, MMALEncoding.I420, 90, 25000000);
//Create our component pipeline.
fixture.MMALCamera.Camera.VideoPort
.ConnectTo(vidEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALVideoRenderer());
fixture.MMALCamera.ConfigureCameraSettings();
//Record video for 20 seconds
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.VideoPort, vidEncoder);
if (System.IO.File.Exists(vidCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(vidCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {vidCaptureHandler.GetFilepath()} was not created");
}
}
});
}
public override int Run(string[] remainingArguments)
{
AsyncContext.Run(() => DoWork(remainingArguments[0].ToAbsoluteDirectoryPath()));
return(0);
}
private static void fireShutDownEvent()
{
AsyncContext[] subscriptions;
lock (eventSubscriptions)
{
subscriptions = new AsyncContext[eventSubscriptions.Count];
eventSubscriptions.CopyTo(subscriptions);
eventSubscriptions.Clear();
}
if (0 < subscriptions.Length)
{
foreach (var elm in subscriptions)
{
try
{
elm.completeCall((uint) RpcError.RPC_S_SERVER_UNAVAILABLE);
}
catch (Exception e)
{
}
}
}
}
public void TaskSchedulerCurrent_FromAsyncContext_IsAsyncContextTaskScheduler()
{
TaskScheduler observedScheduler = null;
var context = new AsyncContext();
context.Factory.Run(() =>
{
observedScheduler = TaskScheduler.Current;
});
context.Execute();
Assert.AreSame(context.Scheduler, observedScheduler);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncContextTaskScheduler"/> class.
/// </summary>
/// <param name="context">The async context for this task scheduler. May not be <c>null</c>.</param>
public AsyncContextTaskScheduler(AsyncContext context)
{
_context = context;
}
/// <summary>
/// Can be over-ridden in a derived class to handle the incomming RPC request, or you can
/// subscribe to the OnExecuteAsync event.
/// </summary>
public virtual void ExecuteAsync(IRpcClientInfo client, AsyncContext asyncContext, byte[] input)
{
RpcExecuteAsyncHandler proc = _asyncHandler;
if (proc != null)
{
proc(client, asyncContext, input);
}
}
public abstract void HandleRequestAsync(HttpContext http, AsyncContext work);
public void Id_IsEqualToTaskSchedulerId()
{
var context = new AsyncContext();
Assert.AreEqual(context.Scheduler.Id, context.Id);
}
protected abstract RESTRequest CreateRequestHandler(HttpContext http, AsyncContext work);
public void BulkInsertDataFromDataTableIntoMdbSynchronouslyWithoutDeadLock() => AsyncContext.Run(() => BulkInsertDataFromDataTableIntoMdbCore());
public void Test_ClassSetPermissions()
{
SyncTestHelpers.RequiresRos();
AsyncContext.Run(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var userC = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
CreatePermissions(ClassPermission.Get <ObjectWithPermissions>(r).Permissions);
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
reader.Users.Add(userB);
reader.Users.Add(userC);
var writer = PermissionRole.Get(r, "writer");
writer.Users.Add(userA);
writer.Users.Add(userB);
var admin = PermissionRole.Get(r, "admin");
admin.Users.Add(userA);
});
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
// B is 'writer' - shouldn't be able to update the role access level
realm.Write(() =>
{
var readerPermission = Permission.Get <ObjectWithPermissions>("reader", realm);
readerPermission.CanUpdate = true;
readerPermission.CanCreate = true;
});
await WaitForSyncAsync(realm);
}
using (var realm = GetRealm(userC, realmUri))
{
// C shouldn't be able to create objects
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe);
AssertObjectPrivileges(realm, ObjectPrivileges.Read);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
await WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
}
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
// A should be able to update role access level
realm.Write(() =>
{
var readerPermission = Permission.Get <ObjectWithPermissions>("reader", realm);
readerPermission.CanUpdate = true;
readerPermission.CanCreate = true;
});
await WaitForSyncAsync(realm);
}
using (var realm = GetRealm(userC, realmUri))
{
// C should now be able to create objects
// Why does my subscription timeout?
// var subscription = await SubscribeToObjectsAsync(realm);
await WaitForSyncAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe | ClassPrivileges.Update | ClassPrivileges.Create);
AssertObjectPrivileges(realm, ObjectPrivileges.Read | ObjectPrivileges.Update | ObjectPrivileges.Delete | ObjectPrivileges.SetPermissions);
var objects = realm.All <ObjectWithPermissions>();
Assert.That(objects.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(objects.Count(), Is.EqualTo(6));
await WaitForSyncAsync(realm);
Assert.That(objects.Count(), Is.EqualTo(6));
}
});
}
static void Main(string[] args)
{
AsyncContext.Run(() => MainAsync(args));
}
public static BuildingTypeBussines Get(Guid guid) => AsyncContext.Run(() => GetAsync(guid));
public static SmsPanelsBussines Get(Guid guid) => AsyncContext.Run(() => GetAsync(guid));
static void Main(string[] args)
{
//Program.EvaluateRandomExpressions();
AsyncContext.Run(
() => Program.MainAsync(args));
}
public static UserBussines Get(Guid guid) => AsyncContext.Run(() => GetAsync(guid));
static void Main(string[] args)
// A main function to enter the Async main method
{
AsyncContext.Run(() => MainA());
}
public static string[] GetAllRolles(string userName) => AsyncContext.Run(() => GetAllRollesAsync(userName));
/// <summary>
/// Creates a request and invokes it
/// </summary>
/// <returns></returns>
/// <exception cref="MwsException">Exceptions from invoking the request</exception>
public IMwsReader invoke()
{
string responseBody;
string message;
HttpStatusCode statusCode = default(HttpStatusCode);
/* Add required request parameters */
AddRequiredParameters();
string queryString = GetParametersAsString(parameters);
int retries = 0;
do
{
/* Submit the request and read response body */
try
{
request = connection.GetHttpClient(serviceEndPoint.URI);
byte[] requestData = new UTF8Encoding().GetBytes(queryString);
//request.ContentLength = requestData.Length;
using (Stream requestStream = request.GetRequestStreamAsync().Result)
{
requestStream.Write(requestData, 0, requestData.Length);
}
using (HttpWebResponse httpResponse = AsyncContext.Run(request.GetResponseAsync) as HttpWebResponse)
{
statusCode = httpResponse.StatusCode;
message = httpResponse.StatusDescription;
ResponseHeaderMetadata = GetResponseHeaderMetadata(httpResponse);
StreamReader reader = new StreamReader(httpResponse.GetResponseStream(), Encoding.UTF8);
responseBody = reader.ReadToEnd();
}
if (statusCode == HttpStatusCode.OK)
{
return(new MwsXmlReader(responseBody));
}
MwsException e = new MwsException((int)statusCode, message, null, null, responseBody, ResponseHeaderMetadata);
if (statusCode == HttpStatusCode.InternalServerError)
{
if (PauseIfRetryNeeded(retries++))
{
continue;
}
}
throw e;
}
/* Web exception is thrown on unsuccessful responses */
catch (WebException we)
{
using (HttpWebResponse httpErrorResponse = (HttpWebResponse)we.Response as HttpWebResponse)
{
if (httpErrorResponse == null)
{
throw new MwsException(we);
}
statusCode = httpErrorResponse.StatusCode;
using (StreamReader reader = new StreamReader(httpErrorResponse.GetResponseStream(), Encoding.UTF8))
{
responseBody = reader.ReadToEnd();
}
}
//retry logic
if (PauseIfRetryNeeded(retries++))
{
continue;
}
throw new MwsException((int)statusCode, null, null, null, responseBody, null);
}
/* Catch other exceptions, attempt to convert to formatted exception,
* else rethrow wrapped exception */
catch (Exception e)
{
throw new MwsException(e);
}
} while (true);
}
public void Session_ProgressObservable_UnitTests(ProgressDirection direction, ProgressMode mode)
{
AsyncContext.Run(async() =>
{
var callbacksInvoked = 0;
var completionTCS = new TaskCompletionSource <ulong>();
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
session.SimulateProgress(0, 100, 0, 100);
var observable = session.GetProgressObservable(direction, mode);
var token = observable.Subscribe(p =>
{
try
{
callbacksInvoked++;
Assert.That(p.TransferredBytes, Is.LessThanOrEqualTo(p.TransferableBytes));
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
Assert.That(p.TransferableBytes, Is.EqualTo(100));
}
}
catch (Exception e)
{
completionTCS.TrySetException(e);
}
if (p.TransferredBytes == p.TransferableBytes)
{
completionTCS.TrySetResult(p.TransferredBytes);
}
});
session.SimulateProgress(50, 150, 50, 150);
await Task.Delay(50);
session.SimulateProgress(100, 200, 100, 200);
await Task.Delay(50);
session.SimulateProgress(150, 200, 150, 200);
await Task.Delay(50);
session.SimulateProgress(200, 200, 200, 200);
await Task.Delay(50);
var totalTransferred = await completionTCS.Task;
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
Assert.That(totalTransferred, Is.EqualTo(100));
Assert.That(callbacksInvoked, Is.EqualTo(3));
}
else
{
Assert.That(totalTransferred, Is.EqualTo(200));
Assert.That(callbacksInvoked, Is.EqualTo(5));
}
token.Dispose();
realm.Dispose();
Realm.DeleteRealm(realm.Config);
});
}
static void Main(string[] args)
{
LocationService ls = new LocationService();
AsyncContext.Run(() => ls.MainAsync(args));
}
public string Region() => AsyncContext.Run(() => SetDivarRegionAsync(bu));
private void InitializeStrongTimer()
{
if (Interval < 60 && Interval != 0)
{
ConsoleHelper.WriteError($"指定的时间周期必须大于或等于 60 秒，用户指定的值：{Interval}");
Environment.Exit(-1);
}
var intervalSec = (int)TimeSpan.FromSeconds(Interval).TotalMilliseconds;
_strongTimer = new StrongTimer
{
Period = intervalSec == 0 ? 5000 : intervalSec,
RunOnStart = true
};
_strongTimer.Elapsed += (sender, args) =>
{
AsyncContext.Run(async() =>
{
var records = (await _apiRequestTool.GetRecordsWithMainDomainAsync(ConfigurationHelper.Configuration.MainDomain))
.SelectTokens($"$.DomainRecords.Record[*]")
.Select(x => new AliCloudRecordModel
{
RecordId = x.SelectToken("$.RecordId")?.Value <string>(),
SubName = x.SelectToken("$.RR")?.Value <string>(),
Value = x.SelectToken("$.Value")?.Value <string>()
})
.ToList();
var currentPubicIp = (await NetworkHelper.GetPublicNetworkIp()).Replace("\n", "");
foreach (var subDomain in ConfigurationHelper.Configuration.SubDomains)
{
var record = records.FirstOrDefault(x => x.SubName == subDomain.SubDomain);
if (record == null)
{
continue;
}
if (record.Value == currentPubicIp)
{
continue;
}
// 更新指定的子域名 IP。
var result = (await _apiRequestTool.UpdateRecordAsync(record.RecordId, currentPubicIp, subDomain)).SelectToken("$.RecordId").Value <string>();
if (result == null || result != record.RecordId)
{
ConsoleHelper.WriteError($"记录 {record.SubName} 更新失败...");
}
}
});
};
_strongTimer.Start();
ConsoleHelper.WriteMessage("程序已经开始运行...");
if (Interval == 0)
{
_strongTimer.Stop();
ConsoleHelper.WriteMessage("程序执行完成...");
Environment.Exit(0);
}
}
public static TResult RunSync <TResult>(Func <Task <TResult> > func)
{
return(AsyncContext.Run(func));
}
public void TestWithSyncContext()
{
AsyncContext.Run(Run);
}
public void Start()
{
AsyncContext.Run(() => StartAsync());
}
public void Session_ProgressObservable_UnitTests(ProgressDirection direction, ProgressMode mode)
{
AsyncContext.Run(async() =>
{
var callbacksInvoked = 0;
var completionTCS = new TaskCompletionSource <ulong>();
var config = await SyncTestHelpers.GetFakeConfigAsync();
var realm = GetRealm(config);
var session = GetSession(realm);
session.SimulateProgress(0, 100, 0, 100);
var observable = session.GetProgressObservable(direction, mode);
var token = observable.Subscribe(p =>
{
try
{
callbacksInvoked++;
// .NET Core dislikes asserts in the callback so much it crashes.
if (p.TransferredBytes > p.TransferableBytes)
{
throw new Exception("TransferredBytes must be less than or equal to TransferableBytes");
}
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
if (p.TransferableBytes != 100)
{
throw new Exception("TransferableBytes must be equal to 100");
}
}
}
catch (Exception e)
{
completionTCS.TrySetException(e);
}
if (p.TransferredBytes == p.TransferableBytes)
{
completionTCS.TrySetResult(p.TransferredBytes);
}
});
using (token)
{
session.SimulateProgress(50, 150, 50, 150);
await Task.Delay(50);
session.SimulateProgress(100, 200, 100, 200);
await Task.Delay(50);
session.SimulateProgress(150, 200, 150, 200);
await Task.Delay(50);
session.SimulateProgress(200, 200, 200, 200);
await Task.Delay(50);
var totalTransferred = await completionTCS.Task;
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
Assert.That(totalTransferred, Is.EqualTo(100));
Assert.That(callbacksInvoked, Is.EqualTo(3));
}
else
{
Assert.That(totalTransferred, Is.EqualTo(200));
Assert.That(callbacksInvoked, Is.EqualTo(5));
}
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncContextSynchronizationContext"/> class.
/// </summary>
/// <param name="context">The async context.</param>
public AsyncContextSynchronizationContext(AsyncContext context) {
_context = context;
}
public void ChangeEncodingType()
{
AsyncContext.Run(async() =>
{
var imgCaptureHandler = new ImageStreamCaptureHandler("/home/pi/images/tests", "jpg");
TestHelper.CleanDirectory("/home/pi/images/tests");
using (var imgEncoder = new MMALImageEncoder(imgCaptureHandler))
{
fixture.MMALCamera.ConfigureCameraSettings();
imgEncoder.ConfigureOutputPort(0, MMALEncoding.JPEG, MMALEncoding.I420, 90);
//Create our component pipeline.
fixture.MMALCamera.Camera.StillPort
.ConnectTo(imgEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALNullSinkComponent());
//Camera warm up time
await Task.Delay(2000);
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.StillPort);
}
if (System.IO.File.Exists(imgCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(imgCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {imgCaptureHandler.GetFilepath()} was not created");
}
imgCaptureHandler = new ImageStreamCaptureHandler("/home/pi/images/tests", "bmp");
using (var imgEncoder = new MMALImageEncoder(imgCaptureHandler))
{
imgEncoder.ConfigureOutputPort(0, MMALEncoding.BMP, MMALEncoding.I420, 90);
//Create our component pipeline.
fixture.MMALCamera.Camera.StillPort
.ConnectTo(imgEncoder);
fixture.MMALCamera.Camera.PreviewPort
.ConnectTo(new MMALNullSinkComponent());
//Camera warm up time
await Task.Delay(2000);
await fixture.MMALCamera.BeginProcessing(fixture.MMALCamera.Camera.StillPort);
}
if (System.IO.File.Exists(imgCaptureHandler.GetFilepath()))
{
var length = new System.IO.FileInfo(imgCaptureHandler.GetFilepath()).Length;
Assert.True(length > 0);
}
else
{
Assert.True(false, $"File {imgCaptureHandler.GetFilepath()} was not created");
}
});
}
public void SynchronizationContextCurrent_FromAsyncContext_IsAsyncContextSynchronizationContext()
{
SynchronizationContext observedContext = null;
var context = new AsyncContext();
context.Factory.Run(() =>
{
observedContext = SynchronizationContext.Current;
});
context.Execute();
Assert.AreSame(context.SynchronizationContext, observedContext);
}
/// <summary>
/// 执行
/// </summary>
/// <param name="action">操作,范例：Async.Run( async () => await SendAsync() );</param>
public static void Run(Action action)
{
AsyncContext.Run(action);
}
public void Task_AfterExecute_NeverRuns()
{
int value = 0;
var context = new AsyncContext();
context.Factory.Run(() => { value = 1; });
context.Execute();
var task = context.Factory.Run(() => { value = 2; });
task.ContinueWith(_ => { Assert.Fail(); });
Assert.AreEqual(1, value);
}
/// <summary>
/// 执行
/// </summary>
/// <typeparam name="TResult">返回类型</typeparam>
/// <param name="action">操作,范例：Async.Run( async () => await SendAsync() );</param>
public static TResult Run <TResult>(Func <Task <TResult> > action)
{
return(AsyncContext.Run(action));
}
public void Current_FromAsyncContext_IsAsyncContext()
{
AsyncContext observedContext = null;
var context = new AsyncContext();
context.Factory.Run(() =>
{
observedContext = AsyncContext.Current;
});
context.Execute();
Assert.AreSame(context, observedContext);
}
public void BulkInsertDataFromIBulkActionDataReaderIntoMdbSynchronouslyWithoutDeadLock() => AsyncContext.Run(() => BulkInsertDataFromIBulkActionDataReaderIntoMdbCore());
