Пример #1
0
 public IHttpActionResult Left([FromBody] string encodedData)
 {
     try
     {
         _streams.AddOrUpdate(LeftKey, encodedData);
         return(Ok(encodedData));
     }
     catch
     {
         return(BadRequest());
     }
 }
Пример #2
0
 public IHttpActionResult Left([ModelBinder(typeof(ByteArrayModelBinder))] byte[] content)
 {
     try
     {
         _streams.AddOrUpdate(LeftKey, content);
         return(Ok());
     }
     catch
     {
         return(BadRequest());
     }
 }
Пример #3
0
        public TValue AddOrUpdate(TKey key, Func <TKey, TValue> addValueFactory, Func <TKey, TValue, TValue> updateValueFactory)
        {
            // key could be null
            if (key == null)
            {
                // ConcurrentDictionary hates null
                throw new ArgumentNullException(nameof(key));
            }

            // addValueFactory and updateValueFactory are checked for null inside the call
            var result = _wrapped.AddOrUpdate
                         (
                key,
                addValueFactory,
                updateValueFactory
                         );

            return(result);
        }
Пример #4
0
            public void AddOrUpdate()
            {
                var dict = new ThreadSafeDictionary <int, int>(Enumerable.Range(0, 10).Select(x => new KeyValuePair <int, int>(x, 2 * x)));
                int val;

                Assert.IsTrue(dict.AddOrUpdate(10, 18, 99, EqualityComparer <int> .Default, out val));
                Assert.AreEqual(0, val);
                Assert.AreEqual(18, dict[10]);
                Assert.IsFalse(dict.AddOrUpdate(10, 20, 99, EqualityComparer <int> .Default, out val));
                Assert.AreEqual(18, val);
                Assert.AreEqual(18, dict[10]);
                Assert.IsTrue(dict.AddOrUpdate(10, 20, 18, EqualityComparer <int> .Default, out val));
                Assert.AreEqual(18, val);
                Assert.AreEqual(20, dict[10]);

                Assert.IsTrue(dict.AddOrUpdate(100, 180, 99, EqualityComparer <int> .Default));
                Assert.AreEqual(180, dict[100]);
                Assert.IsFalse(dict.AddOrUpdate(100, 200, 99, EqualityComparer <int> .Default));
                Assert.AreEqual(180, dict[100]);
                Assert.IsTrue(dict.AddOrUpdate(100, 200, 180, EqualityComparer <int> .Default));
                Assert.AreEqual(200, dict[100]);

                dict.Remove(10);
                dict.Remove(100);

                Assert.IsTrue(dict.AddOrUpdate(10, 18, 99, out val));
                Assert.AreEqual(0, val);
                Assert.AreEqual(18, dict[10]);
                Assert.IsFalse(dict.AddOrUpdate(10, 20, 99, out val));
                Assert.AreEqual(18, val);
                Assert.AreEqual(18, dict[10]);
                Assert.IsTrue(dict.AddOrUpdate(10, 20, 18, out val));
                Assert.AreEqual(18, val);
                Assert.AreEqual(20, dict[10]);

                Assert.IsTrue(dict.AddOrUpdate(100, 180, 99));
                Assert.AreEqual(180, dict[100]);
                Assert.IsFalse(dict.AddOrUpdate(100, 200, 99));
                Assert.AreEqual(180, dict[100]);
                Assert.IsTrue(dict.AddOrUpdate(100, 200, 180));
                Assert.AreEqual(200, dict[100]);

                bool calledUpdater = false;

                Assert.AreEqual(18, dict.AddOrUpdate(20, 18, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }, out val));
                Assert.IsFalse(calledUpdater);
                Assert.AreEqual(0, val);
                Assert.AreEqual(18, dict[20]);
                Assert.AreEqual(20, dict.AddOrUpdate(20, 18, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }, out val));
                Assert.IsTrue(calledUpdater);
                Assert.AreEqual(18, val);
                Assert.AreEqual(20, dict[20]);

                calledUpdater = false;
                dict.Remove(20);
                Assert.AreEqual(18, dict.AddOrUpdate(20, 18, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }));
                Assert.IsFalse(calledUpdater);
                Assert.AreEqual(18, dict[20]);
                Assert.AreEqual(20, dict.AddOrUpdate(20, 18, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }));
                Assert.IsTrue(calledUpdater);
                Assert.AreEqual(20, dict[20]);

                calledUpdater = false;
                bool calledFactory = false;

                dict.Remove(20);

                Assert.AreEqual(18, dict.AddOrUpdate(20, k => {
                    calledFactory = true;
                    return(18);
                }, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }, out val));
                Assert.IsTrue(calledFactory);
                Assert.IsFalse(calledUpdater);
                Assert.AreEqual(18, dict[20]);
                Assert.AreEqual(0, val);
                calledFactory = false;
                Assert.AreEqual(20, dict.AddOrUpdate(20, k => {
                    calledFactory = true;
                    return(18);
                }, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }, out val));
                Assert.IsFalse(calledFactory);
                Assert.IsTrue(calledUpdater);
                Assert.AreEqual(20, dict[20]);
                Assert.AreEqual(18, val);


                dict.Remove(20);
                calledUpdater = false;

                Assert.AreEqual(18, dict.AddOrUpdate(20, k => {
                    calledFactory = true;
                    return(18);
                }, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }));
                Assert.IsTrue(calledFactory);
                Assert.IsFalse(calledUpdater);
                Assert.AreEqual(18, dict[20]);
                calledFactory = false;
                Assert.AreEqual(20, dict.AddOrUpdate(20, k => {
                    calledFactory = true;
                    return(18);
                }, (k, v) => {
                    calledUpdater = true;
                    return(20);
                }));
                Assert.IsFalse(calledFactory);
                Assert.IsTrue(calledUpdater);
                Assert.AreEqual(20, dict[20]);
            }
 public void Adds_Value_To_Dictionary()
 {
     Assert.AreEqual(0, _dictionary.Count());
     _dictionary.AddOrUpdate(1, "Test Value");
     Assert.AreEqual(1, _dictionary.Count());
 }