コード例 #1
0
        private static int GetStructSize(Type structType)
        {
            int size;

#if SIZE_CACHE_USE_RESOURCE_LOCK
            _sizeCacheLock.AcquireShared();

            if (_sizeCache.ContainsKey(structType))
            {
                size = _sizeCache[structType];
                _sizeCacheLock.ReleaseShared();
            }
            else
            {
                _sizeCacheLock.ReleaseShared();

                size = Marshal.SizeOf(structType);
                _sizeCacheLock.AcquireExclusive();

                try
                {
                    if (!_sizeCache.ContainsKey(structType))
                    {
                        _sizeCache.Add(structType, size);
                    }
                }
                finally
                {
                    _sizeCacheLock.ReleaseExclusive();
                }
            }

            return(size);
#else
            lock (_sizeCache)
            {
                if (_sizeCache.ContainsKey(structType))
                {
                    size = _sizeCache[structType];
                }
                else
                {
                    _sizeCache.Add(structType, size = Marshal.SizeOf(structType));
                }

                return(size);
            }
#endif
        }
コード例 #2
0
        //protected override void UnloadData()
        //{ TurretActions = null; }

        public static void EnqueueAction(Action item, FastResourceLock lock_MyAPIGateway = null)
        {
            using (lock_TurretActions.AcquireExclusiveUsing())
                TurretActions.Push(item);
            using (lock_isRunning.AcquireExclusiveUsing())
            {
                if (isRunning)
                {
                    return;
                }
                isRunning = true;
            }
            if (lock_MyAPIGateway != null)
            {
                lock_MyAPIGateway.AcquireShared();
            }
            try { MyAPIGateway.Parallel.Start(Run); }
            finally
            {
                if (lock_MyAPIGateway != null)
                {
                    lock_MyAPIGateway.ReleaseShared();
                }
            }
        }
コード例 #3
0
        /// <summary>
        /// Gets and loads the texture.
        /// Texture is unloaded when nobody is using it.
        /// </summary>
        /// <typeparam name="T">MyTexture2D or MyTextureCube</typeparam>
        /// <param name="path">The path.</param>
        /// <param name="loadedCallback">Callback that is invoked when texture is really loaded and ready for use.</param>
        /// <param name="loadingMode">The loading mode viz. LoadingMode.</param>
        /// <param name="flags">The flags.</param>
        /// <returns></returns>
        public static T GetTexture <T>(string path, TextureLoadedHandler loadedCallback = null, LoadingMode loadingMode = (MyFakes.LOAD_TEXTURES_IMMEDIATELY ? LoadingMode.Immediate : LoadingMode.Lazy)
                                       , TextureFlags flags = TextureFlags.None) where T : MyTexture
        {
            if (OverrideLoadingMode != null)
            {
                loadingMode = OverrideLoadingMode.Value;
            }

            MyTexture texture;

            TexturesLock.AcquireShared();

            if (!m_textures.TryGetValue(path, out texture))
            {
                TexturesLock.ReleaseShared();
                return(LoadTexture <T>(path, loadedCallback, loadingMode, flags));
            }
            TexturesLock.ReleaseShared();

            DbgWatchLoadedTextures();

            return((T)texture);
        }
コード例 #4
0
        protected override void Update()
        {
            var networkDict = Windows.GetNetworkConnections();
            var preKeyDict  = new Dictionary <string, KeyValuePair <int, NetworkConnection> >();
            var keyDict     = new Dictionary <string, NetworkItem>();
            Dictionary <string, NetworkItem> newDict =
                new Dictionary <string, NetworkItem>(this.Dictionary);

            // Flattens list, assigns IDs and counts
            foreach (var list in networkDict.Values)
            {
                foreach (var connection in list)
                {
                    if (connection.Pid == Program.CurrentProcessId &&
                        Settings.Instance.HideProcessHackerNetworkConnections)
                    {
                        continue;
                    }

                    string id = connection.Pid.ToString() + "-" + connection.Local.ToString() + "-" +
                                (connection.Remote != null ? connection.Remote.ToString() : "") + "-" + connection.Protocol.ToString();

                    if (preKeyDict.ContainsKey(id))
                    {
                        preKeyDict[id] = new KeyValuePair <int, NetworkConnection>(
                            preKeyDict[id].Key + 1, preKeyDict[id].Value);
                    }
                    else
                    {
                        preKeyDict.Add(id, new KeyValuePair <int, NetworkConnection>(1, connection));
                    }
                }
            }

            // Merges counts into IDs
            foreach (string s in preKeyDict.Keys)
            {
                var         connection = preKeyDict[s].Value;
                NetworkItem item       = new NetworkItem
                {
                    Id         = s + "-" + preKeyDict[s].Key.ToString(),
                    Connection = connection
                };

                keyDict.Add(s + "-" + preKeyDict[s].Key.ToString(), item);
            }

            foreach (var connection in this.Dictionary.Values)
            {
                if (!keyDict.ContainsKey(connection.Id))
                {
                    OnDictionaryRemoved(connection);
                    newDict.Remove(connection.Id);
                }
            }

            // Get resolve results.
            _messageQueue.Listen();

            foreach (var connection in keyDict.Values)
            {
                if (!this.Dictionary.ContainsKey(connection.Id))
                {
                    connection.Tag = this.RunCount;

                    // Resolve the IP addresses.
                    if (connection.Connection.Local != null)
                    {
                        if (!connection.Connection.Local.Address.GetAddressBytes().IsEmpty())
                        {
                            bool queue = false;

                            // See if IP address is in the cache.

                            _resolveCacheLock.AcquireShared();

                            try
                            {
                                if (_resolveCache.ContainsKey(connection.Connection.Local.Address))
                                {
                                    // We have the resolved address.
                                    connection.LocalString = _resolveCache[connection.Connection.Local.Address];
                                }
                                else
                                {
                                    queue = true;
                                }
                            }
                            finally
                            {
                                _resolveCacheLock.ReleaseShared();
                            }

                            if (queue)
                            {
                                // Queue for resolve.
                                WorkQueue.GlobalQueueWorkItemTag(
                                    new Action <string, bool, IPAddress>(this.ResolveAddresses),
                                    "network-resolve-local",
                                    connection.Id,
                                    false,
                                    connection.Connection.Local.Address
                                    );
                            }
                        }
                    }

                    if (connection.Connection.Remote != null)
                    {
                        if (!connection.Connection.Remote.Address.GetAddressBytes().IsEmpty())
                        {
                            bool queue = false;

                            _resolveCacheLock.AcquireShared();

                            try
                            {
                                if (_resolveCache.ContainsKey(connection.Connection.Remote.Address))
                                {
                                    // We have the resolved address.
                                    connection.RemoteString = _resolveCache[connection.Connection.Remote.Address];
                                }
                                else
                                {
                                    queue = true;
                                }
                            }
                            finally
                            {
                                _resolveCacheLock.ReleaseShared();
                            }

                            if (queue)
                            {
                                WorkQueue.GlobalQueueWorkItemTag(
                                    new Action <string, bool, IPAddress>(this.ResolveAddresses),
                                    "network-resolve-remote",
                                    connection.Id,
                                    true,
                                    connection.Connection.Remote.Address
                                    );
                            }
                        }
                    }

                    // Update the dictionary.
                    newDict.Add(connection.Id, connection);
                    OnDictionaryAdded(connection);
                }
                else
                {
                    if (
                        connection.Connection.State != Dictionary[connection.Id].Connection.State ||
                        Dictionary[connection.Id].JustProcessed
                        )
                    {
                        NetworkItem oldConnection = Dictionary[connection.Id].Clone() as NetworkItem;

                        newDict[connection.Id].Connection.State = connection.Connection.State;
                        newDict[connection.Id].JustProcessed    = false;

                        OnDictionaryModified(oldConnection, newDict[connection.Id]);
                    }
                }
            }

            this.Dictionary = newDict;
        }
コード例 #5
0
ファイル: LockedDictionary.cs プロジェクト: Rynchodon/SEPC
 public void Dispose()
 {
     _lock.ReleaseShared();
     _enumerator.Dispose();
 }
コード例 #6
0
 public void Dispose()
 {
     m_lockObject.ReleaseShared();
 }