��������private void FlushCollections(IEventSource session)
��������
{
������������log.Debug("Processing unreferenced collections");
�
������������ICollection list = IdentityMap.Entries(session.PersistenceContext.CollectionEntries);
������������foreach(DictionaryEntry me in list)
������������ {
����������������CollectionEntry ce = (CollectionEntry)me.Value;
����������������if(!ce.IsReached && !ce.IsIgnore)
���������������� {
��������������������Collections.ProcessUnreachableCollection((IPersistentCollection)me.Key, session);
����������������
}
������������
}
�
������������// Schedule updates to collections:
�
������������log.Debug("Scheduling collection removes/(re)creates/updates");
�
������������list = IdentityMap.Entries(session.PersistenceContext.CollectionEntries);
������������ActionQueue actionQueue = session.ActionQueue;
������������foreach(DictionaryEntry me in list)
������������ {
����������������IPersistentCollection coll = (IPersistentCollection)me.Key;
����������������CollectionEntry ce = (CollectionEntry)me.Value;
�
����������������if(ce.IsDorecreate)
����������������
{
��������������������session.Interceptor.OnCollectionRecreate(coll, ce.CurrentKey);
��������������������actionQueue.AddAction(new CollectionRecreateAction(coll, ce.CurrentPersister, ce.CurrentKey, session));
����������������
}
����������������if(ce.IsDoremove)
���������������� {
��������������������session.Interceptor.OnCollectionRemove(coll, ce.LoadedKey);
��������������������actionQueue.AddAction(
������������������������new CollectionRemoveAction(coll, ce.LoadedPersister, ce.LoadedKey, ce.IsSnapshotEmpty(coll), session));
����������������
}
����������������if(ce.IsDoupdate)
���������������� {
��������������������session.Interceptor.OnCollectionUpdate(coll, ce.LoadedKey);
��������������������actionQueue.AddAction(
������������������������new CollectionUpdateAction(coll, ce.LoadedPersister, ce.LoadedKey, ce.IsSnapshotEmpty(coll), session));
����������������
}
������������
}
������������actionQueue.SortCollectionActions();
��������
}
/// <summary>
/// 提供给外部手动执行LUA脚本的接口
/// </summary>
public void Initilize()
{
if (!Directory.Exists(PathConfig.localModLuaFilePath))
{
Debug.logger.Log(PathConfig.localModLuaFilePath);
Directory.CreateDirectory(PathConfig.localModLuaFilePath);
}
string[] filePaths = Directory.GetFiles(PathConfig.localModLuaFilePath, "*.txt", SearchOption.AllDirectories);
ActionQueue loadQueue = new ActionQueue();
foreach (string path in filePaths)
{
loadQueue.AddAction((act) =>
{
ResourcesLoaderHelper.Instance.LoadTextResourcesByPath("file:///" + path, (scr, bo) =>
{
if (bo)
{
luaTableList.Add(LuaManager.luaScrMgr.DoString(scr)[0] as LuaTable);
act();
}
});
});
}
loadQueue.AddAction((act) =>
{
foreach (LuaTable LuaModule in luaTableList)
{
CallLuaFunction("Init", LuaModule, LuaModule);
}
});
}
/// <summary>
/// 断开场景
/// </summary>
public void Disconnect(System.Action onDisconnect = null)
{
if (sceneConnected == false)
{
Debug.unityLogger.LogError("NetPost", "当前不存在连接");
return;
}
currentScene.OnBeforeDisconnect();
sceneConnected = false;
Int32Data sceneIdData = new Int32Data();
sceneIdData.Value = currentSceneId;
ActionQueue destroyQueue = new ActionQueue();
//添加删除物体的行为
foreach (var kvp in clientNetBehaviorDict)
{
Debug.Log(kvp.Value.gameObject.name);
destroyQueue.AddAction((act) => { kvp.Value.RequestDestroy(act); });
}
//添加最终断开场景的行为
destroyQueue.AddAction((act) =>
{
currentServer.Request(HandlerConst.RequestId.DisconnectSceneHandler, -1, sceneIdData, SendType.TCP, (pkg) =>
{
bool result = pkg.GetValue <BoolData>().Value;
if (result == true)
{
Debug.unityLogger.Log("成功断开场景");
}
else
{
Debug.unityLogger.Log("断开场景失败");
}
currentScene.OnAfterDisconnect(result);
act();
}, () =>
{
Debug.unityLogger.LogError("NetPost", "断开场景超时");
});
});
destroyQueue.AddAction(OnDestroy);
if (onDisconnect != null)
{
destroyQueue.AddAction(onDisconnect);
}
}
protected virtual async Task FlushCollectionsAsync(IEventSource session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
log.Debug("Processing unreferenced collections");
ICollection list = IdentityMap.Entries(session.PersistenceContext.CollectionEntries);
foreach (DictionaryEntry me in list)
{
CollectionEntry ce = (CollectionEntry)me.Value;
if (!ce.IsReached && !ce.IsIgnore)
{
await(Collections.ProcessUnreachableCollectionAsync((IPersistentCollection)me.Key, session, cancellationToken)).ConfigureAwait(false);
}
}
// Schedule updates to collections:
log.Debug("Scheduling collection removes/(re)creates/updates");
list = IdentityMap.Entries(session.PersistenceContext.CollectionEntries);
ActionQueue actionQueue = session.ActionQueue;
foreach (DictionaryEntry me in list)
{
IPersistentCollection coll = (IPersistentCollection)me.Key;
CollectionEntry ce = (CollectionEntry)me.Value;
if (ce.IsDorecreate)
{
session.Interceptor.OnCollectionRecreate(coll, ce.CurrentKey);
actionQueue.AddAction(new CollectionRecreateAction(coll, ce.CurrentPersister, ce.CurrentKey, session));
}
if (ce.IsDoremove)
{
session.Interceptor.OnCollectionRemove(coll, ce.LoadedKey);
actionQueue.AddAction(
new CollectionRemoveAction(coll, ce.LoadedPersister, ce.LoadedKey, ce.IsSnapshotEmpty(coll), session));
}
if (ce.IsDoupdate)
{
session.Interceptor.OnCollectionUpdate(coll, ce.LoadedKey);
actionQueue.AddAction(
new CollectionUpdateAction(coll, ce.LoadedPersister, ce.LoadedKey, ce.IsSnapshotEmpty(coll), session));
}
}
actionQueue.SortCollectionActions();
}
public void ReceivePackage(int len, byte[] data)
{
byte[] finalData = data.SubArray(0, len);
packetBuffer = packetBuffer.Concat(finalData);
//标记是否有完整的包接收到
bool hasCompletePacket = false;
do
{
int packSize = GetDataLength(packetBuffer);
if (packSize == 0)
{
break;
}
hasCompletePacket = packetBuffer.Length >= packSize;
if (hasCompletePacket)
{
byte[] packBytes = ArrayEx.CutHeadByLength(ref packetBuffer, packSize);
handleQueue.AddAction((act) =>
{
NetPackageHandler.HandlePackage(server, Package.PrasePackage(packBytes), act);
});
}
} while (hasCompletePacket);
}
public void Run(Action callback = null)
{
foreach (var task in _taskQueue)
{
_actionQueue.AddAction((cb) =>
{
Console.WriteLine($"\n========================{task.Comment}===========================\n");
task.Run(cb, _environmentVarDict);
});
}
if (callback != null)
{
_actionQueue.AddAction(callback);
}
}
public bool EnqueueAction(QueuedAction action)
{
if (CanPerformeAction(action))
{
currentActionPoints -= action.GetCost();
actionQueue.AddAction(action);
return(true);
}
return(false);
}
public void HandlePackageInQueue()
{
if (packageList.Count > 0)
{
foreach (var package in packageList)
{
handleQueue.AddAction((act) => {
Handler.HandlePackage(package, act);
});
}
packageList.Clear();
}
}
public void HandlePackageInQueue()
{
if (packageList.Count > 0)
{
for (int i = 0; i < packageList.Count; i++)
{
handleQueue.AddAction((act) => {
NetPackageHandler.HandlePackage(server, packageList[i], act);
});
}
packageList.Clear();
}
}
public void TestCanExecuteAction()
{
bool isSet = false;
ActionQueue queue = new ActionQueue();
Task t = queue.AddAction(() =>
{
Thread.Sleep(200);
isSet = true;
Thread.Sleep(200);
});
Assert.AreEqual(TaskStatus.WaitingToRun, t.Status);
Assert.AreEqual(false, isSet);
Task.WaitAll(t);
Assert.AreEqual(TaskStatus.RanToCompletion, t.Status);
Assert.AreEqual(true, isSet);
}
static void Main(string[] args)
{
Console.WriteLine("===== Muhammet Kandemir ======");
Console.WriteLine("Welcome dmuka.Semaphore Tests!");
// Create instance new semphore
// This instance will have 4 core(Thread)
ActionQueue semaphore = new ActionQueue(coreCount: 4);
// Start semaphore as async
semaphore.Start();
var rowIndex = 0;
// This thread is for add 10 action per 5 second
// And each action wait 1 second after complate
new Thread(() =>
{
while (true)
{
for (int i = 0; i < 10; i++)
{
semaphore.AddAction(() =>
{
Console.WriteLine("Row Index = {0}", ++rowIndex);
Thread.Sleep(1000);
});
}
Thread.Sleep(5000);
}
}).Start();
while (true)
{
Thread.Sleep(1);
}
}
/// <summary>
/// 将远端对应的物体销毁，脱离服务端,使用内部销毁队列销毁
/// </summary>
public void RequestDestroy()
{
destroyQueue.AddAction((act) => RequestDestroy(act));
}
public override void AddToQueue(ActionQueue queue)
{
queue.AddAction(Execute);
}
public String GetProduct(int id)
{
ActionQueue.AddAction(id);
return("ok");
}
