C# LockType类代码示例

 public Lock(System.Threading.ReaderWriterLock rwl, LockType lt)
 {
     rwlock = rwl;
     if (type == LockType.ForReading)
         rwl.AcquireReaderLock(-1);
     else if (type == LockType.ForWriting)
         rwl.AcquireWriterLock(-1);
 }

        public Calculator(LockType lockType, int lower, int upper, int modulus, int threads, ProgramMode programMode, string hash)
        {
            this.lower = lower; this.upper = upper;
            this.modulus = modulus; this.threads = threads;
            this.hash = hash;

            LockObject locker = CreateLocker(lockType);
            loop = CreateLoop(locker, programMode);
        }

        public bool GetLock(Guid entityId, LockType lockType)
        {
            LockType value;
            if (locks.TryGetValue(entityId, out value) && lockType == value)
                return true;

            var sessionManager = SessionManager.Manager;
            var session = sessionManager.GetSession(sessionManager.Current);
            using (var transaction = session.DbInfo.Connection.BeginTransaction(IsolationLevel.Serializable))
            {
                try
                {
                    var reader = ExecuteReader(entityId, session, (SqlTransaction)transaction);
                    var query = CREATE_QUERY;
                    if (reader.HasRows)
                    {
                        while (reader.Read())
                        {
                            var sessionId = reader.GetGuid(0);
                            var type = reader.GetInt16(1);

                            if (!Enum.TryParse<LockType>(type.ToString(), out value))
                            {
                                reader.Close();
                                throw new Exception("Wrong LockType fetched. " + type);
                            }

                            if ((lockType == LockType.Write || value == LockType.Write) && session.Id.CompareTo(sessionId) != 0)
                            {
                                reader.Close();
                                throw new Exception(string.Format("Can't get {0} lock for {1}, session {2} has {3} lock.", lockType.ToString(), SessionManager.Manager.GetSession(session.Id).Name, SessionManager.Manager.GetSession(sessionId).Name, value.ToString()));
                            }

                            if (session.Id.CompareTo(sessionId) == 0)
                                query = UPDATE_QUERY;
                        }
                    }
                    reader.Close();
                    ExecuteNonQuery(query, entityId, session, lockType, transaction);
                    transaction.Commit();
                    Console.WriteLine(string.Format("Session {0} adquired {1} lock for VersionId: {2}", session.Name, lockType.ToString(), entityId));
                    if (locks.ContainsKey(entityId))
                        locks[entityId] = lockType;
                    else
                        locks.Add(entityId, lockType);
                }
                catch (Exception ex)
                {

                    transaction.Rollback();
                    Console.WriteLine(ex.Message);
                    return false;
                }
            }
            return true;
        }

        public void GetLock(Guid entityId, LockType lockType)
        {
            LockType value;
            if (locks.TryGetValue(entityId, out value) && lockType == value)
                return;

            var connection = new SqlConnection(SQL_CONNECTION);
            connection.Open();
            using (var transaction = connection.BeginTransaction(IsolationLevel.Serializable))
            {
                try
                {
                    var reader = ExecuteReader(entityId, connection, transaction);
                    var query = CREATE_QUERY;
                    if (reader.HasRows)
                    {
                        while (reader.Read())
                        {
                            var currentOwnerId = reader.GetGuid(0);
                            var type = reader.GetInt16(1);

                            if (!Enum.TryParse<LockType>(type.ToString(), out value))
                            {
                                reader.Close();
                                throw new Exception("Wrong LockType fetched. " + type);
                            }

                            if ((lockType == LockType.Write || value == LockType.Write) && Session.Id.CompareTo(currentOwnerId) != 0)
                            {
                                reader.Close();
                                throw new Exception(string.Format("Can't get {0} lock for {1}, session ID '{2}' has {3} lock.", lockType.ToString(), Session.Name, currentOwnerId.ToString(), value.ToString()));
                            }

                            if (Session.Id.CompareTo(currentOwnerId) == 0)
                                query = UPDATE_QUERY;
                        }
                    }
                    reader.Close();
                    ExecuteNonQuery(query, entityId, lockType, connection, transaction);
                    transaction.Commit();
                    if (locks.ContainsKey(entityId))
                        locks[entityId] = lockType;
                    else
                        locks.Add(entityId, lockType);
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
                finally
                {
                    connection.Close();
                }
            }
        }

        public void UpgradeToWriterLock()
        {
            System.Diagnostics.Debug.Assert(type == LockType.ForReading);

            if (type == LockType.ForReading)
            {
                rwlock.UpgradeToWriterLock(-1);
                type = LockType.ForWriting;
            }
        }

 public void DowngradeToReaderLock()
 {
     System.Diagnostics.Debug.Assert(type == LockType.ForWriting);
     if (type == LockType.ForWriting)
     {
         System.Threading.LockCookie c = cookie.Value;
         rwlock.DowngradeFromWriterLock(ref c);
         cookie = null;
         type = LockType.ForReading;
     }
 }

 LockObject CreateLocker(LockType lockType)
 {
     switch (lockType)
     {
         case LockType.TaS:
             return new TTaSLock();
         case LockType.Lock:
             return new StatementLock();
         default:
             throw new NotImplementedException();
     }
 }

 public static ILockHelper Prepare(this ReaderWriterLockSlim lok, LockType type)
 {
     switch (type)
     {
         case LockType.Read:
             return new ReadLockHelper(lok);
         case LockType.UpgradeableRead:
             return new UpgradeableReadLockHelper(lok);
         case LockType.Write:
         default:
             return new WriteLockHelper(lok);
     }
 }

        public static ILock Create(LockType lockType)
        {
            switch (lockType)
            {
                case LockType.NoLock:
                    return new NoLock();

                case LockType.SpinLock:
                    return new SpinLock();

                case LockType.ClrLock:
                    return new ClrLock();

                default:
                    return null;
            }
        }

        public void ProcessAsync(Func<Task> func, LockType lockType)
        {
            if (_isStopped)
                throw new TaskCanceledException("Fiber was stopped");

            switch (lockType)
            {
                case LockType.None:
                    func();
                    break;
                case LockType.Read:
                    _readLockedQueue.Post(func);
                    break;
                case LockType.Write:
                    _writeLockedQueue.Post(func);
                    break;
            }
        }

 public void AdcquireLock(Guid lockable, Guid owner, LockType type)
 {
     var lockInfo = GetLockInfo(lockable, owner);
     if(!lockInfo.HasLock(type))
     {
         if(CanClaimLock(lockable, owner, type))
         {
             var db = ApplicationManager.INSTANCE.GetDbProvider();
             var connection = db.CreateConnection();
             connection.Open();
             try
             {
                 var transaction = connection.BeginTransaction(IsolationLevel.Serializable);
                 try
                 {
                     using (var command = connection.CreateCommand())
                     {
                         command.CommandType = CommandType.Text;
                         command.Transaction = transaction;
                         if (lockInfo.LockType == LockType.None)
                             command.CommandText = string.Format(INSERT_SQL, lockable, owner, (byte)type);
                         else
                             command.CommandText = string.Format(UPDATE_SQL, (byte)type, lockable, owner);
                         command.ExecuteNonQuery();
                         transaction.Commit();
                     }
                 }
                 catch(DbException e)
                 {
                     transaction.Rollback();
                     throw new ConcurrencyException("Unable to lock: " + lockable);
                 }
             }
             finally
             {
                 connection.Close();
             }
         }
         else
         {
             throw new ConcurrencyException("Unable to lock: " + lockable);
         }
     }
 }

 internal LockState(LockManager LockManager, LockType LockType, IEnumerable<LockableBase> BaseDataObjectStateTrackers, Action<LockState> StateChanged, Action<LockState> ReportStale, TimeSpan Timeout)
 {
     if (LockManager == null)
         throw new ArgumentNullException ("LockManager");
     if (BaseDataObjectStateTrackers == null)
         throw new ArgumentNullException ("BaseDataObjects");
     if (StateChanged == null)
         throw new ArgumentNullException ("StateChanged");
     if (ReportStale == null)
         throw new ArgumentNullException ("ReportStale");
     lockManager = LockManager;
     lock_status = new object ();
     reportStale = ReportStale;
     lockType = LockType;
     lockables = new SortedSet<LockableBase> (BaseDataObjectStateTrackers);
     stateChanged = StateChanged;
     defaultTimeout = Timeout;
     if (Timeout == TimeSpan.Zero) {
         Timeout = TimeSpan.MaxValue;
     }
 }

        //public static LockType AddRecordLock(string DBAlias, string TableName, string KeyFields, string KeyValues, ref string UserID)
        //{
        //    return AddRecordLock(DBAlias, TableName, KeyFields, KeyValues, ref UserID, LockType.Updating);
        //}
        public static LockType AddRecordLock(string DBAlias,string TableName, string KeyFields, string KeyValues, ref string UserID, LockType lt)
        {
            if (ServerConfig.RecordLockInDatabase)
            {
                return RecordLockInDB.AddRecordLock(DBAlias, TableName, KeyFields, KeyValues, ref UserID, lt);
            }
            else
            {
                //while (lockinuse)
                //{
                //    Thread.Sleep(100);
                //}
                LockType retval;
                //lockinuse = true;
                XmlDocument xml = new XmlDocument();
                xml.Load(RecordFileName);
                XmlNode nodeDBAlias = FindAlias(xml, DBAlias);
                if (nodeDBAlias == null)
                {
                    CreatRecord(xml, DBAlias, TableName, KeyFields, KeyValues, UserID, lt);
                    return LockType.Idle;
                }
                else
                {
                    XmlNode nodeTable = FindTable(nodeDBAlias, TableName);
                    if (nodeTable == null)
                    {
                        CreatRecord(xml, nodeDBAlias, TableName, KeyFields, KeyValues, UserID, lt);
                        retval = LockType.Idle;
                    }
                    else
                    {
                        XmlNode nodeRecord = FindRecord(nodeTable, KeyFields, KeyValues);
                        if (nodeRecord == null)
                        {
                            CreatRecord(xml, nodeTable, KeyFields, KeyValues, UserID, lt);
                            retval = LockType.Idle;
                        }
                        else
                        {
                            if (nodeRecord.Attributes["UserID"].Value == UserID)
                            {
                                switch (lt)
                                {
                                    case LockType.Updating: nodeRecord.Attributes["Status"].Value = "Updating"; break;
                                    case LockType.Deleting: nodeRecord.Attributes["Status"].Value = "Deleting"; break;
                                    default: nodeRecord.Attributes["Status"].Value = ""; break;
                                }
                                retval = LockType.Idle;
                                xml.Save(RecordFileName);
                            }
                            else
                            {
                                UserID = nodeRecord.Attributes["UserID"].Value;
                                switch (nodeRecord.Attributes["Status"].Value)
                                {
                                    case "Updating": retval = LockType.Updating; break;
                                    case "Deleting": retval = LockType.Deleting; break;
                                    default: retval = LockType.Other; break;
                                }
                            }
                        }

                    }
                }
                //lockinuse = false;
                return retval;
            }
        }

 internal LockHandle(ReaderWriterLockSlim rwlock, LockType type)
 {
     this.rwlock = rwlock;
     this.type = type;
 }

        public override float Run()
        {
            Player player = KickStarter.player;

            if (KickStarter.playerInput)
            {
                if (IsSingleLockMovement ())
                {
                    doLeftLock = doUpLock;
                    doRightLock = doUpLock;
                    doDownLock = doUpLock;
                }

                if (doUpLock == LockType.Disabled)
                {
                    KickStarter.playerInput.SetUpLock (true);
                }
                else if (doUpLock == LockType.Enabled)
                {
                    KickStarter.playerInput.SetUpLock (false);
                }

                if (doDownLock == LockType.Disabled)
                {
                    KickStarter.playerInput.SetDownLock (true);
                }
                else if (doDownLock == LockType.Enabled)
                {
                    KickStarter.playerInput.SetDownLock (false);
                }

                if (doLeftLock == LockType.Disabled)
                {
                    KickStarter.playerInput.SetLeftLock (true);
                }
                else if (doLeftLock == LockType.Enabled)
                {
                    KickStarter.playerInput.SetLeftLock (false);
                }

                if (doRightLock == LockType.Disabled)
                {
                    KickStarter.playerInput.SetRightLock (true);
                }
                else if (doRightLock == LockType.Enabled)
                {
                    KickStarter.playerInput.SetRightLock (false);
                }

                if (IsInFirstPerson ())
                {
                    if (freeAimLock == LockType.Disabled)
                    {
                        KickStarter.playerInput.SetFreeAimLock (true);
                    }
                    else if (freeAimLock == LockType.Enabled)
                    {
                        KickStarter.playerInput.SetFreeAimLock (false);
                    }
                }

                if (IsUltimateFPS ())
                {
                    return 0f;
                }

                if (doRunLock != PlayerMoveLock.NoChange)
                {
                    KickStarter.playerInput.runLock = doRunLock;
                }
            }

            if (player)
            {
                if (movePath)
                {
                    player.SetLockedPath (movePath);
                    player.SetMoveDirectionAsForward ();
                }
                else if (player.GetPath ())
                {
                    player.EndPath ();
                }

                if (doGravityLock == LockType.Enabled)
                {
                    player.ignoreGravity = false;
                }
                else if (doGravityLock == LockType.Disabled)
                {
                    player.ignoreGravity = true;
                }

                if (AllowHeadTurning ())
                {
                    if (doHotspotHeadTurnLock == LockType.Disabled)
                    {
                        player.SetHotspotHeadTurnLock (true);
                    }
                    else if (doHotspotHeadTurnLock == LockType.Enabled)
//.........这里部分代码省略.........