Here are the examples of the csharp api System.Threading.Monitor.Exit(object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
802 Examples
19
Source : ServerHandler.cs
with MIT License
from azist
with MIT License
from azist
private ResponseMsg doWork(RequestMsg request)
{
var contract = request.Contract;//this throws when contract can't be found
var server = getServerImplementer(request.ServerTransport.ServerEndpoint, contract);//throws when no implementor match found
if (server.AuthenticationSupport)
interpretAuthenticationHeader(request);
//Authorizes user to the whole server contract and implementing clreplaced
Permission.AuthorizeAndGuardAction(App.SecurityManager, server.Contract);
Permission.AuthorizeAndGuardAction(App.SecurityManager, server.Implementation);
serverImplementer.mapping mapped = server.SpecToMethodInfos(request.Method);
Permission.AuthorizeAndGuardAction(App.SecurityManager, mapped.miContract);
Permission.AuthorizeAndGuardAction(App.SecurityManager, mapped.miImplementation);
Guid? checkedOutID;
bool lockTaken;
var instance = getServerInstance(server, request, out checkedOutID, out lockTaken); //throws when instance expired or cant be locked
try
{
Guid? instanceID = null;
bool isCtor = false;
bool isDctor = false;
if (server.InstanceMode == ServerInstanceMode.Stateful ||
server.InstanceMode == ServerInstanceMode.AutoConstructedStateful)
{
instanceID = request.RemoteInstance;
isCtor = Attribute.IsDefined(mapped.miContract, typeof(ConstructorAttribute));
isDctor= Attribute.IsDefined(mapped.miContract, typeof(DestructorAttribute));
if (isCtor && isDctor)
throw new ServerMethodInvocationException(StringConsts.GLUE_AMBIGUOUS_CTOR_DCTOR_DEFINITION_ERROR
.Args( contract.FullName, request.MethodName));
if (server.InstanceMode != ServerInstanceMode.AutoConstructedStateful &&
!instanceID.HasValue &&
!isCtor)
throw new ServerMethodInvocationException(StringConsts.GLUE_NO_SERVER_INSTANCE_ERROR
.Args( contract.FullName, request.MethodName));
}
//========================================================================================================
object result;
try
{
var any = request as RequestAnyMsg;
if (any!=null)
result = mapped.miContract.Invoke(instance, any.Arguments); //do actual contract-implementing method work
else
{
//call functor using typed RequestMsg derivative
if (mapped.fBody==null)
throw new ServerMethodInvocationException(StringConsts.GLUE_NO_ARGS_MARSHAL_LAMBDA_ERROR
.Args( contract.FullName, request.MethodName));
result = mapped.fBody(instance, request); //do actual contract-implementing method work via Lambda
}
}
catch(Exception bodyError)
{
Exception err = bodyError;
if (err is TargetInvocationException)//unwrap the inner error which is wrapped by Invoke()
if (err.InnerException!=null) err = err.InnerException;
throw new ServerMethodInvocationException(StringConsts.GLUE_SERVER_CONTRACT_METHOD_INVOCATION_ERROR
.Args(contract.FullName, request.MethodName, err.ToMessageWithType()),
err);
}
//========================================================================================================
if (server.InstanceMode == ServerInstanceMode.Stateful ||
server.InstanceMode == ServerInstanceMode.AutoConstructedStateful)
{
if (isCtor || (server.InstanceMode == ServerInstanceMode.AutoConstructedStateful && !isDctor && !instanceID.HasValue))
{
instanceID = Guid.NewGuid();
App.ObjectStore.CheckIn(instanceID.Value, instance, server.InstanceTimeoutMs);
}
else
if (isDctor)
{
if (instanceID.HasValue)
{
App.ObjectStore.Delete(instanceID.Value);
instanceID = null;
checkedOutID = null;
}
}
}
if (request.OneWay) return null;
var response = new ResponseMsg(request.RequestID, instanceID, result);
response.__SetBindingSpecificContext(request);
return response;
}
finally
{
if (lockTaken)
Monitor.Exit(instance);
if (checkedOutID.HasValue)
App.ObjectStore.CheckIn(checkedOutID.Value, server.InstanceTimeoutMs);
}
}
19
Source : KeyedMonitor.cs
with MIT License
from azist
with MIT License
from azist
public bool Exit(TKey key)
{
var bucket = getBucket(key);
_slot _lock;
lock (bucket)
{
if (!bucket.TryGetValue(key, out _lock)) return false;
Monitor.Exit(_lock);
_lock.RefCount--;
if (_lock.RefCount==0)
bucket.Remove(key);
}
return true;
}
19
Source : Metabank.cs
with MIT License
from azist
with MIT License
from azist
internal Configuration GetConfigFromExistingFile(string path)
{
var session = obtainSession();
try
{
var rootedPath = m_FS.CombinePaths(m_FSRootPath, path);
return getConfigFromExistingFile(session, rootedPath);
}
finally
{
Monitor.Exit(session);
}
}
19
Source : Metabank.cs
with MIT License
from azist
with MIT License
from azist
private FileSystemSession obtainSession()
{
EnsureObjectNotDisposed();
var callerThread = Thread.CurrentThread;
_fss session;
lock(m_FSSessionCache)
{
if (m_FSSessionCacheThread==null)
{
m_FSSessionCacheThread = new Thread(
(object objBank)=>
{
var bank = objBank as Metabank;
while(bank.Active)
{
m_FSSessionCacheThreadWaiter.WaitOne(1000);
try
{
lock(m_FSSessionCache)
{
var now = DateTime.UtcNow;
var allKvp = m_FSSessionCache.ToList();
foreach(var kvp in allKvp)
if (Monitor.TryEnter(kvp.Value.Session))
try
{
if ((now - kvp.Value.LastAccess).TotalSeconds > 30)//how long to keep fsSession open
{
try{ kvp.Value.Session.Dispose();}
finally{m_FSSessionCache.Remove(kvp.Key);}
}
}
finally
{
Monitor.Exit(kvp.Value.Session);
}
}
}
catch(Exception error)
{
WriteLog(MessageType.Error,
"obtainSession(timedLoop)",
"Thread '{0}' leaked: {1}".Args(m_FSSessionCacheThread.Name, error.ToMessageWithType()),
error);
}
}//while
}
);
m_FSSessionCacheThread.IsBackground = false;
m_FSSessionCacheThread.Name = "Metabank FS Session Cache Thread";
m_FSSessionCacheThreadWaiter = new AutoResetEvent(false);
m_FSSessionCacheThread.Start(this);
}//if thread==null
if (m_FSSessionCache.TryGetValue(callerThread, out session))
{
session.LastAccess = DateTime.UtcNow;
}
else
{
session = new _fss{ Session = m_FS.StartSession(m_FSSessionConnectParams), LastAccess = DateTime.UtcNow};
m_FSSessionCache.Add(callerThread, session);
}
Monitor.Enter(session.Session);
return session.Session;
}
}
19
Source : Metabank.cs
with MIT License
from azist
with MIT License
from azist
internal T fsAccess<T>(string operationName, string path, Func<FileSystemSession, FileSystemDirectory, T> body)
{
var session = obtainSession();
try
{
var catPath = m_FS.CombinePaths(m_FSRootPath, path);
var catDir = session[catPath] as FileSystemDirectory;
if (catDir==null) throw new MetabaseException(StringConsts.METABASE_PATH_NOT_FOUND_ERROR.Args(operationName, catPath));
T result;
try
{
result = body(session, catDir);
}
finally
{
//close all file and directory handles
var sessionItems = session.Items.ToList();
foreach(var item in sessionItems)
item.Dispose();
}
return result;
}
finally
{
Monitor.Exit(session);
}
}
19
Source : LockServerService.cs
with MIT License
from azist
with MIT License
from azist
private void removeExpiredSessions(DateTime now)
{
int totalTimedOut = 0;
foreach( var session in m_Sessions)//thread-safe snapshot
{
if (!Running) return;
if (Monitor.TryEnter(session))
try
{
var sessionMaxAge = session.Data.MaxAgeSec.HasValue ? session.Data.MaxAgeSec.Value : this.m_DefaultSessionMaxAgeSec;
if ((now - session.m_LastInteractionUTC).TotalSeconds > sessionMaxAge)//session times out
{
m_Sessions.Unregister( session );
session.Dispose();
totalTimedOut++;
}
}
finally
{
Monitor.Exit(session);
}
}
if (m_InstrumentationEnabled)
Interlocked.Increment(ref m_stat_ExpiredSessions);
}
19
Source : PileMutableTests.cs
with MIT License
from azist
with MIT License
from azist
[Run("cnt=1 tcount=8 seconds=20")]
[Run("cnt=12 tcount=8 seconds=20")]
[Run("cnt=256 tcount=8 seconds=30")]
[Run("cnt=1024 tcount=8 seconds=30")]
[Run("cnt=1048576 tcount=12 seconds=60")]
public void TestThreadSafety(int cnt, int tcount, int seconds)
{
using (var pile = new DefaultPile(NOPApplication.Instance))
{
var App = pile.App;
// pile.SegmentSize = 64 * 1024 * 1024;
pile.Start();
var data = new PilePointer[cnt];
for(var i=0; i<cnt; i++)
data[i] = pile.Put(new byte[0], preallocateBlockSize: Memory.PTR_RAW_BYTE_SIZE + (137 * (i%17)));
var lst = new List<Task>();
long statRead = 0;
long statPut = 0;
long statDelete = 0;
var sw = Stopwatch.StartNew();
var sd = DateTime.UtcNow;
var deleteLock = new object();
for(var i=0; i<tcount; i++)
lst.Add( Task.Factory.StartNew( () =>
{
while(true)
{
var now = DateTime.UtcNow;
if ((now - sd).TotalSeconds>seconds) break;
var it = App.Random.NextScaledRandomInteger(10,100);
for(var j=0; j<it; j++)
{
var pp = data[App.Random.NextScaledRandomInteger(0, cnt-1)];
Aver.IsTrue( pile.Get(pp) is byte[] );
Interlocked.Increment(ref statRead);
}
it = App.Random.NextScaledRandomInteger(10,100);
for(var j=0; j<it; j++)
{
var pp = data[App.Random.NextScaledRandomInteger(0, cnt-1)];
Aver.IsTrue( pile.Put(pp, new byte[App.Random.NextScaledRandomInteger(0,3791)], link: true) );
Interlocked.Increment(ref statPut);
}
if (App.Random.NextScaledRandomInteger(0,100)>50 && Monitor.TryEnter(deleteLock))
try
{
var newData = (PilePointer[])data.Clone();
it = App.Random.NextScaledRandomInteger(0, 10 + (cnt / 2));
var toDelete = new List<PilePointer>();
for(var j=0; j<it; j++)
{
var idx = App.Random.NextScaledRandomInteger(0, cnt-1);
toDelete.Add( newData[idx] );
newData[idx] = pile.Put(new byte[12], preallocateBlockSize: App.Random.NextScaledRandomInteger(24, 1024));
}
data = newData;//atomic;
Thread.Sleep(1000);
foreach(var pp in toDelete)
{
Aver.IsTrue( pile.Delete(pp) );
Interlocked.Increment(ref statDelete);
}
}
finally
{
Monitor.Exit(deleteLock);
}
}
}, TaskCreationOptions.LongRunning));
Task.WaitAll(lst.ToArray());
var el = sw.ElapsedMilliseconds;
Console.WriteLine("Read {0:n0} at {1:n0} ops/sec".Args(statRead, statRead /(el / 1000d)));
Console.WriteLine("Put {0:n0} at {1:n0} ops/sec".Args(statPut, statPut /(el / 1000d)));
Console.WriteLine("Deleted {0:n0} at {1:n0} ops/sec".Args(statDelete, statDelete /(el / 1000d)));
for(var i=0; i<data.Length; i++)
Aver.IsTrue( pile.Delete(data[i]) );
Aver.AreEqual(0, pile.ObjectCount);
Aver.AreEqual(0, pile.ObjectLinkCount);
Aver.AreEqual(0, pile.AllocatedMemoryBytes);
}
}
19
Source : WriterReaderPhaser.cs
with MIT License
from Azure
with MIT License
from Azure
public void ReaderUnlock()
{
Monitor.Exit(_readerLock);
}
19
Source : HttpClientFactory.cs
with MIT License
from Azure
with MIT License
from Azure
private void OnCleanup(object state) {
StopCleanupTimer();
if (Monitor.TryEnter(_cleanupActiveLock)) {
try {
var initialCount = _expiredHandlers.Count;
for (var i = 0; i < initialCount; i++) {
#pragma warning disable IDE0068 // Use recommended dispose pattern
_expiredHandlers.TryDequeue(out var entry);
#pragma warning restore IDE0068 // Use recommended dispose pattern
if (entry.CanDispose) {
try {
entry.Dispose();
}
catch (Exception ex) {
_logger.Error(ex, "Failed to cleanup handler {name}",
entry.Name);
}
}
else {
// If the entry is still live, put it back in the
// queue so we can process it during the next cycle.
_expiredHandlers.Enqueue(entry);
}
}
}
finally {
Monitor.Exit(_cleanupActiveLock);
}
}
if (_expiredHandlers.Count > 0) {
StartCleanupTimer();
}
}
19
Source : LimitingScheduler.cs
with MIT License
from Azure
with MIT License
from Azure
protected sealed override IEnumerable<Task> GetScheduledTasks() {
var lockTaken = false;
try {
Monitor.TryEnter(_tasks, ref lockTaken);
if (lockTaken) {
return _tasks.ToArray();
}
throw new NotSupportedException();
}
finally {
if (lockTaken) {
Monitor.Exit(_tasks);
}
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1 )
{
try
{
Monitor.Enter( TrampolineInitializer.Sync );
object result = TrampolineHandler.Func( t1, TrampolineInitializer.Data );
return result;
}
finally
{
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
object result = TrampolineHandler.Func( t1, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2, T3 t3 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
data.Parameters[ 1 ] = t3;
object result = TrampolineHandler.Func( t1, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2, T3 t3, T4 t4 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
data.Parameters[ 1 ] = t3;
data.Parameters[ 2 ] = t4;
object result = TrampolineHandler.Func( t1, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
data.Parameters[ 1 ] = t3;
data.Parameters[ 2 ] = t4;
data.Parameters[ 3 ] = t5;
object result = TrampolineHandler.Func( t1, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
data.Parameters[ 3 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1 )
{
try
{
Monitor.Enter( TrampolineInitializer.Sync );
TrampolineHandler.Action( t1, TrampolineInitializer.Data );
}
finally
{
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
TrampolineHandler.Action( t1, data );
}
finally
{
data.Parameters[ 0 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2, T3 t3 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
data.Parameters[ 1 ] = t3;
TrampolineHandler.Action( t1, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2, T3 t3, T4 t4 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
data.Parameters[ 1 ] = t3;
data.Parameters[ 2 ] = t4;
TrampolineHandler.Action( t1, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t2;
data.Parameters[ 1 ] = t3;
data.Parameters[ 2 ] = t4;
data.Parameters[ 3 ] = t5;
TrampolineHandler.Action( t1, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
data.Parameters[ 3 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override()
{
try
{
Monitor.Enter( TrampolineInitializer.Sync );
object result = TrampolineHandler.Func( null, TrampolineInitializer.Data );
return result;
}
finally
{
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
object result = TrampolineHandler.Func( null, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
object result = TrampolineHandler.Func( null, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2, T3 t3 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
data.Parameters[ 2 ] = t3;
object result = TrampolineHandler.Func( null, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2, T3 t3, T4 t4 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
data.Parameters[ 2 ] = t3;
data.Parameters[ 3 ] = t4;
object result = TrampolineHandler.Func( null, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
data.Parameters[ 3 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static object Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
data.Parameters[ 2 ] = t3;
data.Parameters[ 3 ] = t4;
data.Parameters[ 4 ] = t5;
object result = TrampolineHandler.Func( null, data );
return result;
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
data.Parameters[ 3 ] = null;
data.Parameters[ 4 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override()
{
try
{
Monitor.Enter( TrampolineInitializer.Sync );
TrampolineHandler.Action( null, TrampolineInitializer.Data );
}
finally
{
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
TrampolineHandler.Action( null, data );
}
finally
{
data.Parameters[ 0 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
TrampolineHandler.Action( null, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2, T3 t3 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
data.Parameters[ 2 ] = t3;
TrampolineHandler.Action( null, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2, T3 t3, T4 t4 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
data.Parameters[ 2 ] = t3;
data.Parameters[ 3 ] = t4;
TrampolineHandler.Action( null, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
data.Parameters[ 3 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Trampolines.cs
with MIT License
from bbepis
with MIT License
from bbepis
static void Override( T1 t1, T2 t2, T3 t3, T4 t4, T5 t5 )
{
var data = TrampolineInitializer.Data;
try
{
Monitor.Enter( TrampolineInitializer.Sync );
data.Parameters[ 0 ] = t1;
data.Parameters[ 1 ] = t2;
data.Parameters[ 2 ] = t3;
data.Parameters[ 3 ] = t4;
data.Parameters[ 4 ] = t5;
TrampolineHandler.Action( null, data );
}
finally
{
data.Parameters[ 0 ] = null;
data.Parameters[ 1 ] = null;
data.Parameters[ 2 ] = null;
data.Parameters[ 3 ] = null;
data.Parameters[ 4 ] = null;
Monitor.Exit( TrampolineInitializer.Sync );
}
}
19
Source : Clients.cs
with Apache License 2.0
from beetlex-io
with Apache License 2.0
from beetlex-io
public async Task<ConnectStatus> Connect()
{
ConnectStatus result = new ConnectStatus();
result.NewConnection = false;
System.Threading.Monitor.Enter(this);
try
{
if (!IsConnected)
{
await OnConnect();
result.NewConnection = true;
}
}
finally
{
System.Threading.Monitor.Exit(this);
}
result.Connected = mConnected;
return result;
}
19
Source : ActorCollection.cs
with Apache License 2.0
from beetlex-io
with Apache License 2.0
from beetlex-io
public async Task Initialize()
{
if (!mInitialized)
{
System.Threading.Monitor.Enter(Actor);
try
{
if (!mInitialized)
{
if (Actor is IActorState actorState)
await actorState.ActorInit(ActorID);
}
}
finally
{
mInitialized = true;
System.Threading.Monitor.Exit(Actor);
}
}
}
19
Source : LocalLock.cs
with MIT License
from bing-framework
with MIT License
from bing-framework
public bool LockRelease(string key, string value)
{
Check.NotNull(key, nameof(key));
Check.NotNull(value, nameof(value));
_lockCache.TryGetValue(key, out var obj);
if (obj != null)
{
if (_lockUserCache[key] == value)
{
Monitor.Exit(obj);
return true;
}
return false;
}
return true;
}
19
Source : LimitedConcurrencyLevelTaskScheduler.cs
with GNU General Public License v3.0
from bonarr
with GNU General Public License v3.0
from bonarr
protected sealed override IEnumerable<Task> GetScheduledTasks()
{
bool lockTaken = false;
try
{
Monitor.TryEnter(_tasks, ref lockTaken);
if (lockTaken) return _tasks.ToArray();
else throw new NotSupportedException();
}
finally
{
if (lockTaken) Monitor.Exit(_tasks);
}
}
19
Source : AssemblyUtilities.cs
with MIT License
from BrunoS3D
with MIT License
from BrunoS3D
private static void Registerreplacedembly_THREADSAFE(replacedembly replacedembly, bool mightNotBeInitialized)
{
if (mightNotBeInitialized)
{
EnsureInitialized();
}
// This immediately fails to acquire the lock if it is not available,
// deadlocks should be fundamentally impossible.
if (Monitor.TryEnter(MAIN_LOCK))
{
try
{
Registerreplacedembly_NOT_THREADSAFE(replacedembly);
replacedembly[] queuedreplacedemblies;
while (GetAndClearQueuedreplacedemblies(out queuedreplacedemblies))
{
for (int i = 0; i < queuedreplacedemblies.Length; i++)
{
Registerreplacedembly_NOT_THREADSAFE(queuedreplacedemblies[i]);
}
}
}
catch (ReflectionTypeLoadException)
{
// This happens in builds if people are compiling with a subset of .NET
// It means we simply skip this replacedembly and its types completely when scanning for formatter types
}
finally
{
Monitor.Exit(MAIN_LOCK);
}
}
// We failed to acquire the lock - instead queue the replacedembly
// There is a possibility that queued replacedemblies are "missed" here,
// and left in the queue for quite a long time. This is acceptable,
// however, as EnsureInitialized() processes the queue if necessary,
// and EnsureInitialized() is called by all API's that rely on
// replacedemblies being registered.
else
{
lock (replacedEMBLY_LOAD_QUEUE_LOCK)
{
replacedemblyLoadQueue.Enqueue(replacedembly);
}
}
}
19
Source : TradierBrokerage.cs
with Apache License 2.0
from Capnode
with Apache License 2.0
from Capnode
private void CheckForFills()
{
// reentrance guard
if (!Monitor.TryEnter(_fillLock))
{
return;
}
try
{
var intradayAndPendingOrders = GetIntradayAndPendingOrders();
if (intradayAndPendingOrders == null)
{
Log.Error("TradierBrokerage.CheckForFills(): Returned null response!");
return;
}
var updatedOrders = intradayAndPendingOrders.ToDictionary(x => x.Id);
// loop over our cache of orders looking for changes in status for fill quanreplacedies
foreach (var cachedOrder in _cachedOpenOrdersByTradierOrderID)
{
TradierOrder updatedOrder;
var hasUpdatedOrder = updatedOrders.TryGetValue(cachedOrder.Key, out updatedOrder);
if (hasUpdatedOrder)
{
// determine if the order has been updated and produce fills accordingly
ProcessPotentiallyUpdatedOrder(cachedOrder.Value, updatedOrder);
// if the order is still open, update the cached value
if (!OrderIsClosed(updatedOrder)) UpdateCachedOpenOrder(cachedOrder.Key, updatedOrder);
continue;
}
// if we made it here this may be a canceled order via another portal, so we need to figure this one
// out with its own rest call, do this async to not block this thread
if (!_reentranceGuardByTradierOrderID.Add(cachedOrder.Key))
{
// we don't want to reenter this task, so we'll use a hashset to keep track of what orders are currently in there
continue;
}
var cachedOrderLocal = cachedOrder;
Task.Run(() =>
{
try
{
var updatedOrderLocal = GetOrder(cachedOrderLocal.Key);
if (updatedOrderLocal == null)
{
Log.Error($"TradierBrokerage.CheckForFills(): Unable to locate order {cachedOrderLocal.Key} in cached open orders.");
throw new InvalidOperationException("TradierBrokerage.CheckForFills(): GetOrder() return null response");
}
UpdateCachedOpenOrder(cachedOrderLocal.Key, updatedOrderLocal);
ProcessPotentiallyUpdatedOrder(cachedOrderLocal.Value, updatedOrderLocal);
}
catch (Exception err)
{
Log.Error(err);
OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, "PendingOrderNotReturned",
"An error occurred while trying to resolve fill events from Tradier orders: " + err));
}
finally
{
// signal that we've left the task
_reentranceGuardByTradierOrderID.Remove(cachedOrderLocal.Key);
}
});
}
// if we get order updates for orders we're unaware of we need to bail, this can corrupt the algorithm state
var unknownOrderIDs = updatedOrders.Where(IsUnknownOrderID).ToHashSet(x => x.Key);
unknownOrderIDs.ExceptWith(_verifiedUnknownTradierOrderIDs);
var fireTask = unknownOrderIDs.Count != 0 && _unknownTradierOrderIDs.Count == 0;
foreach (var unknownOrderID in unknownOrderIDs)
{
_unknownTradierOrderIDs.Add(unknownOrderID);
}
if (fireTask)
{
// wait a second and then check the order provider to see if we have these broker IDs, maybe they came in later (ex, symbol denied for short trading)
Task.Delay(TimeSpan.FromSeconds(2)).ContinueWith(t =>
{
var localUnknownTradierOrderIDs = _unknownTradierOrderIDs.ToHashSet();
_unknownTradierOrderIDs.Clear();
try
{
// verify we don't have them in the order provider
Log.Trace("TradierBrokerage.CheckForFills(): Verifying missing brokerage IDs: " + string.Join(",", localUnknownTradierOrderIDs));
var orders = localUnknownTradierOrderIDs.Select(x => _orderProvider.GetOrderByBrokerageId(x)).Where(x => x != null);
var stillUnknownOrderIDs = localUnknownTradierOrderIDs.Where(x => !orders.Any(y => y.BrokerId.Contains(x.ToStringInvariant()))).ToList();
if (stillUnknownOrderIDs.Count > 0)
{
// fetch all rejected intraday orders within the last minute, we're going to exclude rejected orders from the error condition
var recentOrders = GetIntradayAndPendingOrders().Where(x => x.Status == TradierOrderStatus.Rejected)
.Where(x => DateTime.UtcNow - x.TransactionDate < TimeSpan.FromMinutes(1)).ToHashSet(x => x.Id);
// remove recently rejected orders, sometimes we'll get updates for these but we've already marked them as rejected
stillUnknownOrderIDs.RemoveAll(x => recentOrders.Contains(x));
if (stillUnknownOrderIDs.Count > 0)
{
// if we still have unknown IDs then we've gotta bail on the algorithm
var ids = string.Join(", ", stillUnknownOrderIDs);
Log.Error("TradierBrokerage.CheckForFills(): Unable to verify all missing brokerage IDs: " + ids);
OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Error, "UnknownOrderId", "Received unknown Tradier order id(s): " + ids));
return;
}
}
foreach (var unknownTradierOrderID in localUnknownTradierOrderIDs)
{
// add these to the verified list so we don't check them again
_verifiedUnknownTradierOrderIDs.Add(unknownTradierOrderID);
}
Log.Trace("TradierBrokerage.CheckForFills(): Verified all missing brokerage IDs.");
}
catch (Exception err)
{
// we need to recheck these order ids since we failed, so add them back to the set
foreach (var id in localUnknownTradierOrderIDs) _unknownTradierOrderIDs.Add(id);
Log.Error(err);
OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, "UnknownIdResolution", "An error occurred while trying to resolve unknown Tradier order IDs: " + err));
}
});
}
}
catch (Exception err)
{
Log.Error(err);
OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, "CheckForFillsError", "An error occurred while checking for fills: " + err));
}
finally
{
Monitor.Exit(_fillLock);
}
}
19
Source : Brokerage.cs
with Apache License 2.0
from Capnode
with Apache License 2.0
from Capnode
public virtual bool PerformCashSync(IAlgorithm algorithm, DateTime currentTimeUtc, Func<TimeSpan> getTimeSinceLastFill)
{
try
{
// prevent reentrance in this method
if (!Monitor.TryEnter(_performCashSyncReentranceGuard))
{
Log.Trace("Brokerage.PerformCashSync(): Reentrant call, cash sync not performed");
return false;
}
Log.Trace("Brokerage.PerformCashSync(): Sync cash balance");
var balances = new List<CashAmount>();
try
{
balances = GetCashBalance();
}
catch (Exception err)
{
Log.Error(err, "Error in GetCashBalance:");
}
if (balances.Count == 0)
{
Log.Trace("Brokerage.PerformCashSync(): No cash balances available, cash sync not performed");
return false;
}
// Adds currency to the cashbook that the user might have deposited
foreach (var balance in balances)
{
if (!algorithm.Portfolio.CashBook.ContainsKey(balance.Currency))
{
Log.Trace($"Brokerage.PerformCashSync(): Unexpected cash found {balance.Currency} {balance.Amount}", true);
algorithm.Portfolio.SetCash(balance.Currency, balance.Amount, 0);
}
}
// if we were returned our balances, update everything and flip our flag as having performed sync today
foreach (var kvp in algorithm.Portfolio.CashBook)
{
var cash = kvp.Value;
//update the cash if the entry if found in the balances
var balanceCash = balances.Find(balance => balance.Currency == cash.Symbol);
if (balanceCash != default(CashAmount))
{
// compare in account currency
var delta = cash.Amount - balanceCash.Amount;
if (Math.Abs(algorithm.Portfolio.CashBook.ConvertToAccountCurrency(delta, cash.Symbol)) > 5)
{
// log the delta between
Log.Trace($"Brokerage.PerformCashSync(): {balanceCash.Currency} Delta: {delta:0.00}", true);
}
algorithm.Portfolio.CashBook[cash.Symbol].SetAmount(balanceCash.Amount);
}
else
{
//Set the cash amount to zero if cash entry not found in the balances
Log.Trace($"Brokerage.PerformCashSync(): {cash.Symbol} was not found in brokerage cash balance, setting the amount to 0", true);
algorithm.Portfolio.CashBook[cash.Symbol].SetAmount(0);
}
}
_syncedLiveBrokerageCashToday = true;
_lastSyncTimeTicks = currentTimeUtc.Ticks;
}
finally
{
Monitor.Exit(_performCashSyncReentranceGuard);
}
// fire off this task to check if we've had recent fills, if we have then we'll invalidate the cash sync
// and do it again until we're confident in it
Task.Delay(TimeSpan.FromSeconds(10)).ContinueWith(_ =>
{
// we want to make sure this is a good value, so check for any recent fills
if (getTimeSinceLastFill() <= TimeSpan.FromSeconds(20))
{
// this will cause us to come back in and reset cash again until we
// haven't processed a fill for +- 10 seconds of the set cash time
_syncedLiveBrokerageCashToday = false;
//_failedCashSyncAttempts = 0;
Log.Trace("Brokerage.PerformCashSync(): Unverified cash sync - resync required.");
}
else
{
Log.Trace("Brokerage.PerformCashSync(): Verified cash sync.");
algorithm.Portfolio.LogMarginInformation();
}
});
return true;
}
19
Source : BrokerageConcurrentMessageHandler.cs
with Apache License 2.0
from Capnode
with Apache License 2.0
from Capnode
public void HandleNewMessage(T message)
{
lock (_messageBuffer)
{
if (Monitor.TryEnter(_streamLocked))
{
try
{
ProcessMessages(message);
}
finally
{
Monitor.Exit(_streamLocked);
}
}
else
{
if (message != default)
{
// if someone has the lock just enqueue the new message they will process any remaining messages
// if by chance they are about to free the lock, no worries, we will always process first any remaining message first see 'ProcessMessages'
_messageBuffer.Enqueue(message);
}
}
}
}
19
Source : BrokerageConcurrentMessageHandler.cs
with Apache License 2.0
from Capnode
with Apache License 2.0
from Capnode
public void WithLockedStream(Action code)
{
Monitor.Enter(_streamLocked);
try
{
code();
}
finally
{
// once we finish our 'code' we will process any message that come through,
// to make sure no message get's left behind (race condition between us finishing 'ProcessMessages'
// and some message being enqueued to it, we just take a lock on the buffer
lock (_messageBuffer)
{
// we release the '_streamLocked' first so by the time we release '_messageBuffer' any new message is processed immediately and not enqueued
Monitor.Exit(_streamLocked);
ProcessMessages();
}
}
}
19
Source : DbContentFactory.cs
with Apache License 2.0
from ccnetcore
with Apache License 2.0
from ccnetcore
public static DataContext GetCurrentDbContent()
{
DataContext db = CallContext.GetData("DbContext") as DataContext;
if (db == null)//线程在数据槽里面没有此上下文
{
db = Webcontext;
CallContext.SetData("DbContext", db);//放到数据槽中去,DbContext是key,db是value
}
try
{
Monitor.Exit(myLock);
}
catch
{
}
return db;
}
19
Source : ManualHisDataMemoryBlock.cs
with Apache License 2.0
from cdy816
with Apache License 2.0
from cdy816
public void Relase()
{
Monitor.Exit(this);
}
19
Source : 001_LockAcquiredOutsideTryClause.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth1()
{
Monitor.Enter(myLockObj);
try
{
}
finally
{
Monitor.Exit(myLockObj);
}
}
19
Source : 001_LockAcquiredOutsideTryClause.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth2()
{
var lockAcquired = Monitor.TryEnter(myLockObj);
try
{
}
finally
{
if(lockAcquired)
Monitor.Exit(myLockObj);
}
}
19
Source : 002_LockAcquiredInsideTryClause.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth1()
{
try
{
Monitor.Enter(myLockObj);
}
finally
{
Monitor.Exit(myLockObj);
}
}
19
Source : 002_LockAcquiredInsideTryClause.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth2()
{
var lockAcquired = false;
try
{
lockAcquired = Monitor.TryEnter(myLockObj);
}
finally
{
if(lockAcquired)
Monitor.Exit(myLockObj);
}
}
19
Source : 003_LockReleasedOutsideFinallyClause.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth1()
{
Monitor.Enter(myLockObj);
Monitor.Exit(myLockObj);
}
19
Source : 001_LockOnNonReadonlyField.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth2()
{
Monitor.Enter(lockobj);
Monitor.Exit(lockobj);
}
19
Source : 001_LockOnNonReadonlyField.cs
with MIT License
from cezarypiatek
with MIT License
from cezarypiatek
public void DoSth3()
{
var wasTaken = false;
Monitor.TryEnter(lockobj, ref wasTaken);
if (wasTaken)
{
Monitor.Exit(lockobj);
}
}
See More Examples