public IDictionary <TKey, TValue> GetAll(ICollection <TKey> keys)
{
var partitionToKeyData = GetPartitionKeyData(keys);
var result = new Dictionary <TKey, TValue>();
if (_nearCache != null)
{
// remove items from list which are already found in the cache
foreach (var kvp in partitionToKeyData)
{
var list = kvp.Value;
for (var i = list.Count - 1; i >= 0; i--)
{
var keyData = kvp.Value[i];
var cached = _nearCache.Get(keyData);
if (cached != null && cached != ClientNearCache.NullObject)
{
list.RemoveAt(i);
result.Add(ToObject <TKey>(keyData), (TValue)cached);
}
}
}
}
var invocationService = GetContext().GetInvocationService();
var futures = new List <IFuture <IClientMessage> >(partitionToKeyData.Count);
foreach (var kvp in partitionToKeyData)
{
if (kvp.Value.Count > 0)
{
var request = MapGetAllCodec.EncodeRequest(GetName(), kvp.Value);
futures.Add(invocationService.InvokeOnPartition(request, kvp.Key));
}
}
var messages = ThreadUtil.GetResult(futures);
foreach (var clientMessage in messages)
{
var items = MapGetAllCodec.DecodeResponse(clientMessage).entrySet;
foreach (var entry in items)
{
var key = ToObject <TKey>(entry.Key);
var value = ToObject <TValue>(entry.Value);
result.Add(key, value);
if (_nearCache != null)
{
_nearCache.Put(entry.Key, value);
}
}
}
return(result);
}
private static Action <FirstCommand> FirstCommandConsumer(FirstCommand message)
{
return(command =>
{
ThreadUtil.Sleep(10.Milliseconds());
var response = new FirstResponse(command.CorrelationId);
CurrentMessage.Respond(response);
});
}
/// <inheritdoc />
public override void UnsafeDestroy()
{
ThreadUtil.assertIsGameThread();
if (!BarricadeManager.tryGetInfo(Model, out var x, out var y, out var plant, out var index,
out var bRegion))
{
return;
}
BarricadeManager.destroyBarricade(bRegion, x, y, plant, index);
}
private void TestDeleteExplanationItems(IELearningLabController eLearningLab)
{
eLearningLab.Delete();
eLearningLab.Sync();
Slide expSlide = PpOperations.SelectSlide(TestDeleteExplanationItemSlideNo);
ThreadUtil.WaitFor(1000);
Slide actualSlide = PpOperations.SelectSlide(ExpectedDeleteExplanationItemSlideNo);
SlideUtil.IsSameLooking(expSlide, actualSlide, similarityTolerance: 0.95);
}
private static void TestGenerateVisualAgendaWithSlideNumbers()
{
PpOperations.ShowAllSlideNumbers();
MessageBoxUtil.ExpectMessageBoxWillPopUp(AgendaExistsTitle, AgendaExistsContent,
PplFeatures.GenerateVisualAgenda, buttonNameToClick: "OK");
ThreadUtil.WaitFor(10000);
System.Collections.Generic.List <TestInterface.ISlideData> actualSlides = PpOperations.FetchCurrentPresentationData();
System.Collections.Generic.List <TestInterface.ISlideData> expectedSlides = PpOperations.FetchPresentationData(
PathUtil.GetDocTestPresentationPath("AgendaLab\\AgendaSlidesVisualWithSlideNumberDefault.pptx"));
PresentationUtil.AssertEqual(expectedSlides, actualSlides);
}
Action <FirstCommand> FirstCommandConsumer(FirstCommand message)
{
return(command =>
{
ThreadUtil.Sleep(10.Milliseconds());
var response = new FirstResponse(command.CorrelationId);
LocalBus.Context().Respond(response);
});
}
/// <exception cref="System.Exception"></exception>
public virtual bool TryLock(TKey key, long timeout, TimeUnit timeunit, long leaseTime, TimeUnit leaseUnit)
{
ValidationUtil.ThrowExceptionIfNull(key);
var keyData = ToData(key);
var request = MultiMapTryLockCodec.EncodeRequest(GetName(), keyData, ThreadUtil.GetThreadId(),
leaseUnit.ToMillis(leaseTime),
timeunit.ToMillis(timeout), _lockReferenceIdGenerator.GetNextReferenceId());
return(Invoke(request, keyData, m => MultiMapTryLockCodec.DecodeResponse(m).response));
}
private void ManagerAuthenticator(ClientConnection connection)
{
Logger.Finest("Authenticating against the owner node");
var ss = _client.GetSerializationService();
string uuid = null;
string ownerUuid = null;
if (_principal != null)
{
uuid = _principal.GetUuid();
ownerUuid = _principal.GetOwnerUuid();
}
ClientMessage request;
if (_credentials is UsernamePasswordCredentials)
{
var usernamePasswordCr = (UsernamePasswordCredentials)_credentials;
request = ClientAuthenticationCodec.EncodeRequest(usernamePasswordCr.GetUsername(),
usernamePasswordCr.GetPassword(), uuid, ownerUuid, true,
ClientTypes.Csharp, _client.GetSerializationService().GetVersion());
}
else
{
var data = ss.ToData(_credentials);
request = ClientAuthenticationCustomCodec.EncodeRequest(data, uuid, ownerUuid, false,
ClientTypes.Csharp, _client.GetSerializationService().GetVersion());
}
IClientMessage response;
try
{
var invocationService = (ClientInvocationService)_client.GetInvocationService();
response = ThreadUtil.GetResult(invocationService.InvokeOnConnection(request, connection));
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
var result = ClientAuthenticationCodec.DecodeResponse(response);
if (result.address == null)
{
throw new HazelcastException("Could not resolve address for owner node.");
}
var member = new Member(result.address, result.ownerUuid);
_principal = new ClientPrincipal(result.uuid, result.ownerUuid);
connection.Member = member;
connection.SetOwner();
}
protected ClientMessage InvokeOnPartition(ClientMessage request, int partitionId)
{
try
{
var task = Client.InvocationService.InvokeOnPartitionOwner(request, partitionId);
return(ThreadUtil.GetResult(task));
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
protected ClientMessage InvokeOnTarget(ClientMessage request, Guid target)
{
try
{
var task = Client.InvocationService.InvokeOnTarget(request, target);
return(ThreadUtil.GetResult(task));
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
protected virtual Task <TValue> PutAsyncInternal(IData keyData, TValue value, long ttl, TimeUnit timeunit)
{
var valueData = ToData(value);
var request =
MapPutCodec.EncodeRequest(GetName(), keyData, valueData, ThreadUtil.GetThreadId(), timeunit.ToMillis(ttl));
return(InvokeAsync(request, keyData, m =>
{
var response = MapPutCodec.DecodeResponse(m).response;
return ToObject <TValue>(response);
}));
}
public virtual Task <TValue> GetAsync(TKey key)
{
ValidationUtil.CheckNotNull(key, ValidationUtil.NULL_KEY_IS_NOT_ALLOWED);
var keyData = ToData(key);
var request = MapGetCodec.EncodeRequest(GetName(), keyData, ThreadUtil.GetThreadId());
return(InvokeAsync(request, keyData, m =>
{
var resp = MapGetCodec.DecodeResponse(m).response;
return ToObject <TValue>(resp);
}));
}
protected IClientMessage InvokeOnPartition(IClientMessage request, int partitionId)
{
try
{
var task = GetContext().GetInvocationService().InvokeOnPartition(request, partitionId);
return(ThreadUtil.GetResult(task));
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
public async Task RunOnStaThreadAsync()
{
Assert.Equal(1520, await ThreadUtil.RunOnStaThreadAsync(async() =>
{
Assert.Equal(ApartmentState.STA, Thread.CurrentThread.GetApartmentState());
var id = Thread.CurrentThread.ManagedThreadId;
await Task.Yield();
Assert.Equal(ApartmentState.STA, Thread.CurrentThread.GetApartmentState());
Assert.Equal(Thread.CurrentThread.ManagedThreadId, id);
return(1520);
}));
}
public void StopAllInOtherThread()
{
if (_opertaionThread != null)
{
if (_opertaionThread.ThreadState == ThreadState.Running || _opertaionThread.ThreadState == ThreadState.WaitSleepJoin)
{
return;
}
}
_opertaionThread = ThreadUtil.GetThread(StopAll);
_opertaionThread.Start();
}
private void btnGenerate_Click(object sender, EventArgs e)
{
if (!MyDialog.confirm("Do you want to generate stickers?"))
{
return;
}
progressBar.Show();
ThreadUtil.InvokeAsync(this, (f) =>
{
generateStickers();
});
}
public void Should_not_remove_any_existing_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.ShouldHaveSubscriptionFor <A>();
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
}
public void Should_properly_serialize_a_response()
{
var actor = AnonymousActor.New(inbox =>
{
_channel.Respond(new Test
{
Name = "Magic"
}, "21");
});
ThreadUtil.Sleep(1.Seconds());
}
private void PasteAtCursorPosition(int originalSlideNo, int expSlideNo)
{
Microsoft.Office.Interop.PowerPoint.ShapeRange shapes = GetShapesByPrefix(originalSlideNo, ShapeToCopyPrefix);
shapes.Cut();
RightClick(GetShapesByPrefix(originalSlideNo, ShapeToClick)[1]);
// wait for awhile for click to register properly
ThreadUtil.WaitFor(500);
PplFeatures.PasteAtCursorPosition();
AssertIsSame(originalSlideNo, expSlideNo);
}
public Task <V> RemoveAsync(K key)
{
var keyData = ToData(key);
var request = MapRemoveAsyncCodec.EncodeRequest(GetName(), keyData, ThreadUtil.GetThreadId());
InvalidateNearCacheEntry(keyData);
return(InvokeAsync(request, keyData, m =>
{
var response = MapRemoveAsyncCodec.DecodeResponse(m).response;
return ToObject <V>(response);
}));
}
public void DropMultiple(int Count)
{
ThreadUtil.SafeQueueWorkItem(new ThreadStart(() =>
{
for (int counter = 0; counter <= Count; counter++)
{
var c = Random.Next(65, 90);
var x = Random.Next(1, 128 - _font.CharWidth((char)c));
SingleDrop(x, (char)c);
}
}));
}
protected virtual IClientMessage Invoke(IClientMessage request)
{
try
{
var task = GetContext().GetInvocationService().InvokeOnRandomTarget(request);
return(ThreadUtil.GetResult(task));
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
protected virtual IClientMessage Invoke(IClientMessage request, object key)
{
try
{
var task = GetContext().GetInvocationService().InvokeOnKeyOwner(request, key);
return(ThreadUtil.GetResult(task));
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
/*! This methode starts the loading of a .blend file
* \param pathToMeshJson path to a .blend file */
public void LoadFile(string pathToMeshJson)
{
//Check if mesh.json exists
if (!File.Exists(pathToMeshJson))
{
Debug.LogWarning("Could not load mesh from: " + pathToMeshJson + ", file not found.");
return;
}
// Read mesh.json
string fileContent = "";
string line;
System.IO.StreamReader file = new System.IO.StreamReader(pathToMeshJson);
while ((line = file.ReadLine()) != null)
{
fileContent += line;
}
file.Close();
meshJson = JsonMapper.ToObject <MeshJson>(fileContent);
if (meshJson == null)
{
Debug.LogWarning("Error while parsing mesh.json");
return;
}
Patient currentPatient = Patient.getLoadedPatient();
string path = currentPatient.path + "/" + meshJson.pathToBlendFile;
//Loading blend file
if (File.Exists(path))
{
// Let loading screen know what we're currently doing:
PatientEventSystem.triggerEvent(PatientEventSystem.Event.LOADING_AddLoadingJob, "Mesh");
this.RemoveMesh();
this.Path = path;
MeshGameObjectContainers = new List <GameObject>();
// Reset scale, rotation, position:
meshNode.transform.localScale = new Vector3(0.007f, 0.007f, 0.007f);
meshNode.transform.parent.localScale = new Vector3(1.0f, 1.0f, 1.0f);
meshNode.transform.parent.localRotation = Quaternion.identity;
//meshNode.transform.parent.Rotate (90, 0, 0);
meshNode.transform.parent.GetComponent <ModelRotator>().setTargetOrientation(Quaternion.Euler(90, 0, 0));
ThreadUtil t = new ThreadUtil(this.LoadFileWorker, this.LoadFileCallback);
t.Run();
}
else
{
Debug.LogWarning("Could not load mesh from: '" + path + "', file not found.");
}
}
private void ClusterAuthenticator(ClientConnection connection)
{
var ss = _client.GetSerializationService();
var clusterService = (ClientClusterService)_client.GetClientClusterService();
var principal = clusterService.GetPrincipal();
var uuid = principal.GetUuid();
var ownerUuid = principal.GetOwnerUuid();
ClientMessage request;
var usernamePasswordCr = _credentials as UsernamePasswordCredentials;
if (usernamePasswordCr != null)
{
request = ClientAuthenticationCodec.EncodeRequest(usernamePasswordCr.GetUsername(),
usernamePasswordCr.GetPassword(), uuid, ownerUuid, false,
ClientTypes.Csharp, _client.GetSerializationService().GetVersion(), VersionUtil.GetDllVersion());
}
else
{
var data = ss.ToData(_credentials);
request = ClientAuthenticationCustomCodec.EncodeRequest(data, uuid, ownerUuid, false,
ClientTypes.Csharp, _client.GetSerializationService().GetVersion(), VersionUtil.GetDllVersion());
}
IClientMessage response;
try
{
var future = ((ClientInvocationService)_client.GetInvocationService()).InvokeOnConnection(request,
connection);
response = ThreadUtil.GetResult(future);
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
var rp = ClientAuthenticationCodec.DecodeResponse(response);
if (rp.address == null)
{
throw new HazelcastException("Could not resolve address for member.");
}
var member = _client.GetClientClusterService().GetMember(rp.address);
if (member == null)
{
throw new HazelcastException("Node with address '" + rp.address + "' was not found in the member list");
}
connection.Member = member;
}
/// <summary> 检测登录二维码扫描状态 </summary>
/// <param name="uid"></param>
private WxLoginScanResult executeLoginScanHttpTask(string uid)
{
try
{
string tip = "1";
while (true)
{
HttpTask ht = syncCreateHttpTask(WxHtpUtil.GetLoginScanParams(uid, tip));
if (ht == null)
{
return(null);
}
WxLoginScanResult result = WxRespUtil.ParseLoginScanResp(ht.ExecuteString());
#if Debug
Console.WriteLine("wx login scan result =" + (result == null ? "null" : result.Code.ToString()));
#endif
if (result == null)
{
}
else if (result.Code == WxResultCode.LOGIN_SCAN_SUCCESS)//201
{
//已扫描，未登录，这里可以获取头像
tip = "0";
}
else if (result.Code == WxResultCode.LOGIN_SCAN_LOGIN)//200
{
//点击登录
return(result);
}
else if (result.Code == WxResultCode.LOGIN_SCAN_TIMEOUT)//408
{
//微信端返的连接超时，继续连接
}
else if (result.Code == WxResultCode.LOGIN_SCAN_EXPIRED)//400
{
//二维码过期
return(result);
}
ThreadUtil.Sleep(500);
if (!syncCheckLoginingState())
{
return(null);
}
}
}
catch { }
return(null);
}
public void DoSomething(object state)
{
var transaction = state as DependentTransaction;
Magnum.Guard.AgainstNull(transaction, "transaction");
using (transaction)
{
ThreadUtil.Sleep(100.Milliseconds());
transaction.Rollback(new InvalidOperationException("System screwed up"));
// transaction.Complete();
}
}
static void Main(string[] args)
{
ThreadUtil.RunTask(() => {
for (int i = 0; i < 10; i++)
{
Console.WriteLine("JoJo：" + i.ToString());
Thread.Sleep(1000);
}
}, 5000);
Console.WriteLine("............");
Console.ReadKey();
}
public bool Replace(K key, V oldValue, V newValue)
{
var keyData = ToData(key);
var oldValueData = ToData(oldValue);
var newValueData = ToData(newValue);
var request = MapReplaceIfSameCodec.EncodeRequest(GetName(), keyData, oldValueData, newValueData,
ThreadUtil.GetThreadId());
InvalidateNearCacheEntry(keyData);
var clientMessage = Invoke(request, keyData);
return(MapReplaceIfSameCodec.DecodeResponse(clientMessage).response);
}
public V Put(K key, V value, long ttl, TimeUnit timeunit)
{
var keyData = ToData(key);
var valueData = ToData(value);
var request = MapPutCodec.EncodeRequest(GetName(), keyData, valueData, ThreadUtil.GetThreadId(),
timeunit.ToMillis(ttl));
InvalidateNearCacheEntry(keyData);
var clientMessage = Invoke(request, keyData);
var response = MapPutCodec.DecodeResponse(clientMessage).response;
return(ToObject <V>(response));
}
