/// <inheritdoc />
public override UploadSession GetSession(string uploadSessionId)
{
try
{
#if NET35
_sessionsLock.EnterReadLock();
#else
_sessionsLock.AcquireReaderLock(-1);
#endif
UploadSession session;
if (!_uploadSessions.TryGetValue(uploadSessionId, out session))
{
session = null;
}
return(session);
}
finally
{
#if NET35
_sessionsLock.ExitReadLock();
#else
_sessionsLock.ReleaseReaderLock();
#endif
}
}
/// <inheritdoc />
public override void SaveRequest(UploadRequest request, bool isCreate)
{
// TODO: uncomment, add check to make sure object is the same
//if (isCreate)
//{
try
{
#if NET35
_requestsLock.EnterUpgradeableReadLock();
#else
_requestsLock.AcquireReaderLock(-1);
#endif
Dictionary <string, UploadRequest> requests;
if (!_uploadRequests.TryGetValue(request.UploadSessionId, out requests))
{
requests = new Dictionary <string, UploadRequest>();
requests[request.UploadRequestId] = request;
#if !NET35
// TODO: does this break something?
LockCookie cookie = new LockCookie();
#endif
try
{
#if NET35
_requestsLock.EnterWriteLock();
#else
cookie = _requestsLock.UpgradeToWriterLock(-1);
#endif
_uploadRequests[request.UploadSessionId] = requests;
}
finally
{
#if NET35
_requestsLock.ExitWriteLock();
#else
_requestsLock.DowngradeFromWriterLock(ref cookie);
#endif
}
}
else
{
lock (requests)
requests[request.UploadRequestId] = request;
}
}
finally
{
#if NET35
_requestsLock.ExitUpgradeableReadLock();
#else
_requestsLock.ReleaseReaderLock();
#endif
}
//}
}
internal void GetReaderLock()
{
IncrementRef();
#if NET40
_rwsObject.EnterReadLock();
#else
_rwsObject.AcquireReaderLock(Timeout.Infinite);
#endif
}
public void CanAcquireReadLock()
{
// Setup
var l = new ReaderWriterLockSlim();
// Act
l.AcquireReaderLock(100);
Assert.IsTrue(l.IsReaderLockHeld);
l.ReleaseReaderLock();
Assert.IsFalse(l.IsReaderLockHeld);
} // end of function - CanAcquireReadLock
public void StillInReadLockAfterDowngrading()
{
// Setup
var l = new ReaderWriterLockSlim();
// Act/Verify
l.AcquireReaderLock(0);
Assert.IsTrue(l.IsReaderLockHeld);
l.UpgradeToWriterLock(0);
Assert.IsTrue(l.IsWriterLockHeld);
Assert.IsTrue(l.IsReaderLockHeld);
l.DowngradeFromWriterLock();
Assert.IsFalse(l.IsWriterLockHeld);
Assert.IsTrue(l.IsReaderLockHeld);
l.ReleaseReaderLock();
Assert.IsFalse(l.IsReaderLockHeld);
} // end of function - StillInReadLockAfterDowngrading
public static CtorAccessor Get(Type type)
{
CtorAccessor ctorAccessor = null;
try {
#if (dotNET35 || dotNET4)
ctorAccessorsCacheLock.EnterReadLock();
#else
ctorAccessorsCacheLock.AcquireReaderLock(-1);
#endif
if (ctorAccessorsCache.TryGetValue(type, out ctorAccessor))
{
return(ctorAccessor);
}
}
finally {
#if (dotNET35 || dotNET4)
ctorAccessorsCacheLock.ExitReadLock();
#else
ctorAccessorsCacheLock.ReleaseReaderLock();
#endif
}
try {
#if (dotNET35 || dotNET4)
ctorAccessorsCacheLock.EnterWriteLock();
#else
ctorAccessorsCacheLock.AcquireWriterLock(-1);
#endif
if (ctorAccessorsCache.TryGetValue(type, out ctorAccessor))
{
return(ctorAccessor);
}
ctorAccessor = new CtorAccessor(type);
ctorAccessorsCache[type] = ctorAccessor;
}
finally {
#if (dotNET35 || dotNET4)
ctorAccessorsCacheLock.ExitWriteLock();
#else
ctorAccessorsCacheLock.ReleaseWriterLock();
#endif
}
return(ctorAccessor);
}
public static ObjectSerializer Get(Type type)
{
ObjectSerializer serializer = null;
try {
#if (dotNET35 || dotNET4)
serializersCacheLock.EnterReadLock();
#else
serializersCacheLock.AcquireReaderLock(-1);
#endif
if (serializersCache.TryGetValue(type, out serializer))
{
return(serializer);
}
}
finally {
#if (dotNET35 || dotNET4)
serializersCacheLock.ExitReadLock();
#else
serializersCacheLock.ReleaseReaderLock();
#endif
}
try {
#if (dotNET35 || dotNET4)
serializersCacheLock.EnterWriteLock();
#else
serializersCacheLock.AcquireWriterLock(-1);
#endif
if (serializersCache.TryGetValue(type, out serializer))
{
return(serializer);
}
serializer = new ObjectSerializer(type);
serializersCache[type] = serializer;
}
finally {
#if (dotNET35 || dotNET4)
serializersCacheLock.ExitWriteLock();
#else
serializersCacheLock.ReleaseWriterLock();
#endif
}
return(serializer);
}
public void EnterReadLock(int millisecondsTimeout)
{
#if NET35_OR_GREATER || NETCOREAPP || NETSTANDARD
if (ReaderWriterLock.IsReadLockHeld || ReaderWriterLock.IsWriteLockHeld)
{
return;
}
if (!ReaderWriterLock.TryEnterReadLock(millisecondsTimeout))
{
throw new TimeoutException("获取读锁超时");
}
#else
if (ReaderWriterLock.IsReaderLockHeld || ReaderWriterLock.IsWriterLockHeld)
{
return;
}
ReaderWriterLock.AcquireReaderLock(millisecondsTimeout);
#endif
}
public virtual AbstractServiceEntry?Get(Type serviceInterface, string?name, QueryModes mode)
{
CheckNotDisposed();
Ensure.Parameter.IsNotNull(serviceInterface, nameof(serviceInterface));
Ensure.Parameter.IsInterface(serviceInterface, nameof(serviceInterface));
IServiceId key = MakeId(serviceInterface);
AbstractServiceEntry existing;
using (FLock.AcquireReaderLock())
{
//
// 1. eset: Vissza tudjuk adni amit kerestunk.
//
if (FEntries.TryGetValue(key, out existing))
{
return(existing);
}
//
// 2. eset: A bejegyzes generikus parjat kell majd feldolgozni.
//
bool hasGenericEntry = mode.HasFlag(QueryModes.AllowSpecialization) &&
serviceInterface.IsGenericType &&
FEntries.TryGetValue
(
MakeId(serviceInterface.GetGenericTypeDefinition()),
out existing
);
//
// 3. eset: Egyik se jott be, vagy kivetelt v NULL-t adunk vissza.
//
if (!hasGenericEntry)
{
return(!mode.HasFlag(QueryModes.ThrowOnError)
? (AbstractServiceEntry?)null
: throw new ServiceNotFoundException(string.Format(Resources.Culture, Resources.SERVICE_NOT_FOUND, key.FriendlyName())));
}
}
Assert(existing.IsGeneric());
Assert(mode.HasFlag(QueryModes.AllowSpecialization));
using (FLock.AcquireWriterLock())
{
//
// Kozben vki berakta mar?
//
if (FEntries.TryGetValue(key, out AbstractServiceEntry? specialized))
{
return(specialized);
}
//
// Ha nem mi vagyunk a tulajdonosok akkor ertesitjuk a tulajdonost h tipizalja o a bejegyzest
// majd masoljuk az uj elemet sajat magunkhoz (epp ugy mint ha "orokoltuk" vna).
//
// Igy lehetove tesszuk h pl singleton elettartamnal a tipizalt peldany elettartamarol is a
// deklaralo kollekcio gondoskodjon.
//
if (existing.Owner != this)
{
specialized = existing
.Owner
.Get(serviceInterface, name, mode);
//
// "specialized" lehet NULL ha a "QueryModes.ThrowOnError" nem volt beallitva es "existing"
// nem valositja meg a "ISupportsSpecialization" interface-t.
//
return(specialized?.CopyTo(this));
}
//
// Ha mi vagyunk a tulajdonosok akkor nekunk kell tipizalni majd felvenni a bejegyzest.
//
if (existing is ISupportsSpecialization generic)
{
//
// Ne az "FEntries.Add(specialized, specialized)"-ot hivjuk mert a "this.Add()" virtualis.
//
Add(specialized = generic.Specialize(serviceInterface.GetGenericArguments()));
return(specialized);
}
return(!mode.HasFlag(QueryModes.ThrowOnError)
? (AbstractServiceEntry?)null
: throw new NotSupportedException(Resources.ENTRY_CANNOT_BE_SPECIALIZED));
}
IServiceId MakeId(Type iface) => new ServiceId(iface, name);
}
