public static SessionStateItem Load(string headerPrefix, string dataPrefix, IMemcachedClient client, string id, bool metaOnly)
            {
                // Load the header for the item
                var header = client.GetWithCas <byte[]>(headerPrefix + id);

                if (header.Result == null)
                {
                    return(null);
                }

                // Deserialize the header values
                SessionStateItem entry;

                using (var ms = new MemoryStream(header.Result)) {
                    entry = SessionStateItem.LoadItem(ms);
                }
                entry.HeadCas = header.Cas;

                // Bail early if we are only loading the meta data
                if (metaOnly)
                {
                    return(entry);
                }

                // Load the data for the item
                var data = client.GetWithCas <byte[]>(dataPrefix + id);

                if (data.Result == null)
                {
                    return(null);
                }
                entry.DataCas = data.Cas;

                // Deserialize the data
                using (var ms = new MemoryStream(data.Result)) {
                    using (var br = new BinaryReader(ms)) {
                        entry.Data = SessionStateItemCollection.Deserialize(br);
                    }
                }

                // Return the session entry
                return(entry);
            }
            public static SessionStateItem Load(IMemcachedClient client, string id, bool metaOnly)
            {
                var header = client.GetWithCas <byte[]>(HeaderPrefix + id);

                if (header.Result == null)
                {
                    return(null);
                }

                SessionStateItem entry;

                using (var ms = new MemoryStream(header.Result))
                    entry = SessionStateItem.LoadItem(ms);

                if (entry != null)
                {
                    entry.HeadCas = header.Cas;
                }
                if (metaOnly)
                {
                    return(entry);
                }

                var data = client.GetWithCas <byte[]>(DataPrefix + id);

                if (data.Result == null)
                {
                    return(null);
                }

                using (var ms = new MemoryStream(data.Result))
                    using (var br = new BinaryReader(ms))
                        entry.Data = SessionStateItemCollection.Deserialize(br);

                entry.DataCas = data.Cas;

                return(entry);
            }
Ejemplo n.º 3
0
        public IActionResult Gets(string key)
        {
            var value  = _memcachedClient.GetWithCas(key);
            var result = new { value = value.Result, cas = value.Cas, statusCode = value.StatusCode };

            if (value.Result != null)
            {
                return(Ok(result));
            }
            else
            {
                return(StatusCode(StatusCodes.Status404NotFound));
            }
        }
Ejemplo n.º 4
0
 public CasResult <object> GetWithCas(string key)
 {
     return(_memcachedClient.GetWithCas(key));
 }
            public static SessionStateItem Load(IMemcachedClient client, string id, bool metaOnly)
            {
                var header = client.GetWithCas<byte[]>(HeaderPrefix + id);
                if (header.Result == null) return null;

                SessionStateItem entry;

                using (var ms = new MemoryStream(header.Result))
                    entry = SessionStateItem.LoadItem(ms);

                if (entry != null) entry.HeadCas = header.Cas;
                if (metaOnly) return entry;

                var data = client.GetWithCas<byte[]>(DataPrefix + id);
                if (data.Result == null) return null;

                using (var ms = new MemoryStream(data.Result))
                using (var br = new BinaryReader(ms))
                    entry.Data = SessionStateItemCollection.Deserialize(br);

                entry.DataCas = data.Cas;

                return entry;
            }
Ejemplo n.º 6
0
        private static SessionStateItem Load(string headerPrefix, string dataPrefix, IMemcachedClient client, string id, bool metaOnly, ICompressor compressor, Logger logger)
        {
            // Load the header for the item
            var header = client.GetWithCas <byte[]>(headerPrefix + id);

            if (header.Result == null)
            {
                return(null);
            }

            // Deserialize the header values
            SessionStateItem entry;

            using (var ms = new MemoryStream(header.Result))
            {
                entry = LoadItem(ms);
            }
            entry.HeadCas = header.Cas;

            // Bail early if we are only loading the meta data
            if (metaOnly)
            {
                return(entry);
            }

            // Load the data for the item
            var data = client.GetWithCas <byte[]>(dataPrefix + id);

            if (data.Result == null)
            {
                return(null);
            }
            entry.DataCas = data.Cas;

            // Deserialize the data
            if (compressor == null)
            {
                if (logger != null)
                {
                    logger.Info(string.Format("Load data from Session item with id '{0}' with size {1}", id, data.Result.LongLength));
                }

                using (var ms = new MemoryStream(data.Result))
                {
                    using (var br = new BinaryReader(ms))
                    {
                        entry.Data = SessionStateItemCollection.Deserialize(br);
                    }
                }
            }
            else
            {
                using (var input = new MemoryStream(data.Result))
                {
                    var decompressed = compressor.Decompress(input);

                    if (logger != null)
                    {
                        logger.Info(string.Format("Load data from Session item with id '{0}' with compessed size {1}. Size after decompression is {2}", id, data.Result.LongLength, decompressed.LongLength));
                    }

                    using (var output = new MemoryStream(decompressed))
                    {
                        using (var reader = new BinaryReader(output))
                        {
                            entry.Data = SessionStateItemCollection.Deserialize(reader);
                        }
                    }
                }
            }

            // Return the session entry
            return(entry);
        }
Ejemplo n.º 7
0
        private static SessionStateItem Load(string headerPrefix, string dataPrefix, IMemcachedClient client, string id, bool metaOnly, ICompressor compressor, Logger logger)
        {
            // Load the header for the item
            var header = client.GetWithCas<byte[]>(headerPrefix + id);
            if (header.Result == null)
            {
                return null;
            }

            // Deserialize the header values
            SessionStateItem entry;
            using (var ms = new MemoryStream(header.Result))
            {
                entry = LoadItem(ms);
            }
            entry.HeadCas = header.Cas;

            // Bail early if we are only loading the meta data
            if (metaOnly)
            {
                return entry;
            }

            // Load the data for the item
            var data = client.GetWithCas<byte[]>(dataPrefix + id);
            if (data.Result == null)
            {
                return null;
            }
            entry.DataCas = data.Cas;

            // Deserialize the data
            if (compressor == null)
            {
                if (logger != null)
                    logger.Info(string.Format("Load data from Session item with id '{0}' with size {1}", id, data.Result.LongLength));

                using (var ms = new MemoryStream(data.Result))
                {
                    using (var br = new BinaryReader(ms))
                    {
                        entry.Data = SessionStateItemCollection.Deserialize(br);
                    }
                }
            }
            else
            {
                using (var input = new MemoryStream(data.Result))
                {
                    var decompressed = compressor.Decompress(input);

                    if (logger != null)
                        logger.Info(string.Format("Load data from Session item with id '{0}' with compessed size {1}. Size after decompression is {2}", id, data.Result.LongLength, decompressed.LongLength));

                    using (var output = new MemoryStream(decompressed))
                    {
                        using (var reader = new BinaryReader(output))
                        {
                            entry.Data = SessionStateItemCollection.Deserialize(reader);
                        }
                    }
                }
            }

            // Return the session entry
            return entry;
        }
            public static SessionStateItem Load(string headerPrefix, string dataPrefix, IMemcachedClient client, string id, bool metaOnly)
            {
                // Load the header for the item
                var header = client.GetWithCas<byte[]>(headerPrefix + id);
                if (header.Result == null) {
                    return null;
                }

                // Deserialize the header values
                SessionStateItem entry;
                using (var ms = new MemoryStream(header.Result)) {
                    entry = SessionStateItem.LoadItem(ms);
                }
                entry.HeadCas = header.Cas;

                // Bail early if we are only loading the meta data
                if (metaOnly) {
                    return entry;
                }

                // Load the data for the item
                var data = client.GetWithCas<byte[]>(dataPrefix + id);
                if (data.Result == null) {
                    return null;
                }
                entry.DataCas = data.Cas;

                // Deserialize the data
                using (var ms = new MemoryStream(data.Result)) {
                    using (var br = new BinaryReader(ms)) {
                        entry.Data = SessionStateItemCollection.Deserialize(br);
                    }
                }

                // Return the session entry
                return entry;
            }