public static void PurgeQueryCache()
{
lock (_queryCache)
{
_queryCache.Clear();
}
OnQueryCachePurged();
}
public void SetAttachment(string name, object attach)
{
if (name == null)
{
Attachments.Clear();
}
else if (attach == null)
{
Attachments.TryRemove(name, out attach);
}
else
{
Attachments[name] = attach;
}
}
public async Task ClearAsync()
{
var builder = Builders <CacheItem> .Filter;
var filter = builder.Ne(c => c.SiteId, "");
await _collection.DeleteManyAsync(filter);
Items.Clear();
}
public void Dispose()
{
using (mLock.Enter())
{
mAwaitMessageLRU.Clear();
mAwaitMessages.Clear();
}
}
public void Stop()
{
socket?.Close();
socket?.Dispose();
//_task.Dispose();
_task = null;
_task2 = null;
dic.Clear();
}
private void ResetState()
{
_info.OnNext(Notification.Clear);
CancellationTokenSource = new CancellationTokenSource();
PathService.ClearDestination();
Directory.CreateDirectory(PathService.Destination);
PathService.ClearStandByList();
CumulatedProgressByFile.Clear();
ClearProgressInternal();
}
/// <summary>
/// Method to cancel the working queue, see http://dotspatial.codeplex.com/discussions/473428
/// </summary>
public void Clear()
{
_threadPool.Cancel(false);
foreach (var request in _activeTileRequests.ToArray())
{
int one;
if (!_openTileRequests.ContainsKey(request.Key))
{
if (!_activeTileRequests.TryRemove(request.Key, out one))
{
_activeTileRequests.TryRemove(request.Key, out one);
}
}
}
_openTileRequests.Clear();
}
private void clearStack()
{
foreach (var d in _dic_stackOfInterval)
{
d.Value.Item1.Clear();
d.Value.Item2.Clear();
}
_dic_stackOfInterval.Clear();
if (!ReferenceEquals(stopwatch, null))
{
if (stopwatch.IsRunning)
{
stopwatch.Stop();
}
stopwatch = null;
}
}
/// <summary>
/// 关闭后台处理线程
/// </summary>
public void Stop()
{
runFlag = false;
bWorker.CancelAsync();
while (bWorker.IsBusy)
{
Thread.Sleep(200);
}
//
UnBind();
//关闭通道连接
CloseSoket();
//将队列中剩余未应答数据全部移除
CmppCmdQueue.Clear();
}
public void Clear()
{
lock (_lockObj)
{
foreach (var node in _cacheKey)
{
node.Value.ChildNodeCollectionChanged -= node_ChildNodeCollectionChanged;
node.Value.ChildNodeCollectionChanging -= node_ChildNodeCollectionChanging;
node.Value.ChildNodeLoading -= node_ChildNodeLoading;
node.Value.PropertyChanging -= node_PropertyChanging;
node.Value.PropertyChanged -= node_PropertyChanged;
}
_cacheKey.Clear();
_root.Nodes.Clear();
}
}
private static void LoadConfig()
{
using (StreamReader reader = new StreamReader(MainConfigPath))
{
lock (configDoc)
{
configDoc.RemoveAll();
string xml = reader.ReadToEnd();
configDoc.LoadXml(xml);
}
lock (Sections)
{
Sections.Clear();
}
}
}
static int _m_Clear(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
System.Collections.Concurrent.ConcurrentDictionary <long, ulong> gen_to_be_invoked = (System.Collections.Concurrent.ConcurrentDictionary <long, ulong>)translator.FastGetCSObj(L, 1);
{
gen_to_be_invoked.Clear( );
return(0);
}
} catch (System.Exception gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
}
}
public override string DescribeSchema()
{
Service.Name = "K2NEServiceBroker";
Service.MetaData.DisplayName = "K2NE's General Purpose Service Broker";
Service.MetaData.Description = "A Service Broker that provides various functional service objects that aid the implementation of a K2 project.";
lock (describeSchemaLock)
{
_serviceObjectToType.Clear();
bool requireServiceFolders = false;
foreach (ServiceObjectBase entry in ServiceObjectClasses)
{
if (!string.IsNullOrEmpty(entry.ServiceFolder))
{
requireServiceFolders = true;
}
}
foreach (ServiceObjectBase entry in ServiceObjectClasses)
{
List <ServiceObject> serviceObjects = entry.DescribeServiceObjects();
foreach (ServiceObject so in serviceObjects)
{
Service.ServiceObjects.Create(so);
string dictKey = string.Concat(this.ServiceInstanceGuid.ToString(), "_", so.Name);
if (!_serviceObjectToType.TryAdd(dictKey, entry.GetType()))
{
throw new ApplicationException("Failed to add Service Object - Please change the service object name.");
}
if (requireServiceFolders)
{
ServiceFolder sf = InitializeServiceFolder(entry.ServiceFolder, entry.ServiceFolder);
sf.Add(so);
}
}
}
}
return(base.DescribeSchema());
}
public static void ClearExtendFunc()
{
_extendFuncCache.Clear();
}
/// <summary>
/// 清空所有配置
/// </summary>
public static void ClearCfg()
{
_allconfigures.Clear();
}
/// <summary>
/// Remove all cached items.
/// </summary>
public static void Clear()
{
m_cacheMap.Clear();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
//autofac will dispose the items in the list
//just want to clear the refs.
_contextCache?.Clear();
}
public void Clear() => _rules.Clear();
public static void ClearCache()
{
_proxyTypes.Clear();
}
public void Dispose()
{
mSubscribers.Clear();
Node = null;
}
/// <inheritdoc />
protected override void CloseTarget()
{
base.CloseTarget();
_loggers.Clear();
}
/// <inheritdoc/>
public void Clear()
{
_dictionary.Clear();
NotifyObserversOfChange();
}
public void Dispose()
{
mRemoteNodes.Clear();
}
/// <summary>
/// Clears all cached metadata.
/// </summary>
public static void ClearCachedTypes()
{
s_typeCache.Clear();
}
public void Clear()
{
_keyValue.Clear();
_valueKey.Clear();
}
public void Clear()
{
_cache.Clear();
}
public static void ClearService()
{
_services.Clear();
}
public void Clear()
{
queue.Clear();
bag.Clear();
}
public static void ClearAllOpers()
{
_operators.Clear();
}
/// <summary>
/// Clears all known redirects from the cache.
/// </summary>
public void Clear()
{
_CachedRedirects.Clear();
}
