private void TryEnterLock(ThreadUnsafePolicy policy, MethodExecutionArgs args)
        {
            object syncObject;

            syncObject = GetSyncObject(policy, args.Instance, args.Method.DeclaringType);

            if (runningThreadSafeMethods != null && runningThreadSafeMethods.ContainsKey(syncObject))
            {
                return;
            }

            ThreadHandle currentThread = new ThreadHandle(Thread.CurrentThread);

            ThreadHandle actualThread = locks.AddOrUpdate(syncObject, o => currentThread,
                                                          (o, thread) =>
            {
                if (thread.Thread != currentThread.Thread)
                {
                    throw new ThreadUnsafeException(ThreadUnsafeErrorCode.SimultaneousAccess);
                }

                // Same thread, but different ThreadHandle: we are in a nested call on the same thread.
                return(thread);
            });


            if (actualThread == currentThread)
            {
                args.MethodExecutionTag = syncObject;
            }
        }
        private static object GetSyncObject(ThreadUnsafePolicy policy, object instance, Type type)
        {
            object syncObject;

            if (policy != ThreadUnsafePolicy.Static && instance != null)
            {
                syncObject = instance;
            }
            else
            {
                syncObject = type;
            }
            return(syncObject);
        }
 public ThreadUnsafeObjectAttribute(ThreadUnsafePolicy policy)
 {
     this.policy = policy;
 }
 public ThreadUnsafeObjectAttribute( ThreadUnsafePolicy policy )
 {
     this.policy = policy;
 }
        private void TryEnterLock( ThreadUnsafePolicy policy, MethodExecutionArgs args )
        {
            object syncObject;

            syncObject = GetSyncObject(policy, args.Instance, args.Method.DeclaringType);

            if ( runningThreadSafeMethods != null && runningThreadSafeMethods.ContainsKey( syncObject ) ) return;

            ThreadHandle currentThread = new ThreadHandle( Thread.CurrentThread );

            ThreadHandle actualThread = locks.AddOrUpdate( syncObject, o => currentThread,
                                                           ( o, thread ) =>
                                                               {
                                                                   if ( thread.Thread != currentThread.Thread )
                                                                       throw new ThreadUnsafeException(ThreadUnsafeErrorCode.SimultaneousAccess);

                                                                   // Same thread, but different ThreadHandle: we are in a nested call on the same thread.
                                                                   return thread;
                                                               } );

            if ( actualThread == currentThread )
            {
                args.MethodExecutionTag = syncObject;
            }
        }
 private static object GetSyncObject( ThreadUnsafePolicy policy, object instance, Type type )
 {
     object syncObject;
     if ( policy != ThreadUnsafePolicy.Static && instance != null )
     {
         syncObject = instance;
     }
     else
     {
         syncObject = type;
     }
     return syncObject;
 }