`Add` does nothing (returns `false`) if there is already a value for that key. `Set` does an insert or update, as necessary.

`Remove` + `Add` would leave a gap in the middle when another thread querying that key would get no clue (`Set` does not; the swap is typically atomic); as such, while `Set` has the same **end result** as `Remove` + `Add`, the mechanism difference is important since it could impact other callers.

For example of [Add](http://msdn.microsoft.com/en-us/library/dd780614.aspx):

&gt; Return Value
&gt; 
&gt; Type: System.Boolean true if insertion succeeded, or false if there is an already an entry in the cache that has the same key as key. 

I assure you that I did look for an answer in SO for my question but none of them were helpful. Here I got a simple code that should present a `UIImagePickerController` within a `UIPopoverController`:
   
    -(void)takePicture:(id)sender{
    UIImagePickerController *picker=[[UIImagePickerController alloc] init];
    picker.delegate=self;
    picker.sourceType=UIImagePickerControllerSourceTypeCamera;
    picker.allowsEditing=YES;
    UIPopoverController *poc=[[UIPopoverController alloc] 
                                initWithContentViewController:picker];
    [poc presentPopoverFromBarButtonItem:bbItem 
                permittedArrowDirections:UIPopoverArrowDirectionAny
                                animated:NO];
    }

Now, even from the first time I get `[UIPopoveController dealloc]` reached while... error and the program crashes. I&#39;m not doing any retain,relase or autoreleases as per ARC. Is there any special consideration with `UIPopoverControllers` when benefitting from ARC?

UIPopovercontroller dealloc reached while popover is still visible

I am using jQuery, and wondering if I should use val() or text() (or another method) to read and update the content of a textarea.

I have tried both and I&#39;ve had issues with both. When I use text() to update textarea, line breaks (\n) don&#39;t work. When I use val() to retrieve the textarea content, the text gets truncated if it&#39;s too long.

val() vs. text() for textarea

I read the [MSDN documentation](https://msdn.microsoft.com/en-us/library/dd780623(v=vs.110).aspx) but didn&#39;t really understand it.

I believe that the behavior of `Set` is &quot;replace existing, or add&quot; (atomically).

Is that correct?

What&#39;s the difference between MemoryCache.Add and MemoryCache.Set?

I read the <a href="https://msdn.microsoft.com/en-us/library/dd780623(v=vs.110).aspx" target="_blank" rel="noopener noreferrer">MSDN documentation</a> but didn't really understand it.
I believe that the behavior of <code>Set</code> is "replace existing, or add" (atomically).
Is that correct?

I was looking for an efficient approach for calculating a&lt;sup&gt;b&lt;/sup&gt; (say `a = 2` and `b = 50`). To start things up, I decided to take a look at the implementation of `Math.Pow()` function. But in [.NET Reflector][1], all I found was this:

    [MethodImpl(MethodImplOptions.InternalCall), SecuritySafeCritical]
    public static extern double Pow(double x, double y);

What are some of the resources wherein I can see as what&#39;s going on inside when I call `Math.Pow()` function?

  [1]: http://en.wikipedia.org/wiki/.NET_Reflector


How is Math.Pow() implemented in .NET Framework?

Seems like in .NET Framework there is an issue with optional parameters when you override the method. The output of the code below is:
&quot;bbb&quot;
&quot;aaa&quot;
. But the output I&#39;m expecting is:
&quot;bbb&quot;
&quot;bbb&quot;
.Is there a solution for this. I know it can be solved with method overloading but wondering the reason for this. Also the code works fine in Mono.

    class Program
    {
        class AAA
        {
            public virtual void MyMethod(string s = &quot;aaa&quot;)
            {
                Console.WriteLine(s);
            }

            public virtual void MyMethod2()
            {
                MyMethod();
            }
        }

        class BBB : AAA
        {
            public override void MyMethod(string s = &quot;bbb&quot;)
            {
                base.MyMethod(s);
            }

            public override void MyMethod2()
            {
                MyMethod();
            }
        }

        static void Main(string[] args)
        {
            BBB asd = new BBB();
            asd.MyMethod();
            asd.MyMethod2();
        }
    }

C# optional parameters on overridden methods

I have a Web.config with several ConnectionStrings

    &lt;connectionStrings&gt;
        &lt;add name=&quot;connStr1&quot; connectionString=&quot;...
        &lt;add name=&quot;ConnStr2&quot; connectionString=&quot;...
        &lt;add name=&quot;connStr3&quot; connectionString=&quot;...

Is there a way using config transformations to remove a specific connectionstring? Something Like:

    &lt;connectionStrings&gt;
        &lt;xdt:Remove connStr2?

Obviously no where near the correct syntax, but you get my drift...

How to remove a ConnectionString using Config Transformations

One of the ConfigurationProperty I have in my ConfigurationSection is an ENUM. When .net parses this enum string value from the config file, an exception will be thrown if the case does not match exactly. 

Is there away to ignore case when parsing this value?

.net Custom Configuration How to case insensitive parse an enum ConfigurationProperty

    public interface IDic
    {
        int Id { get; set; }
        string Name { get; set; }
    }
    public class Client : IDic
    {

    }


How can I cast `List&lt;Client&gt;` to `List&lt;IDic&gt;`?

Cast List&lt;T&gt; to List&lt;Interface&gt;

On an ASP.NET MVC project we have several instances of data that requires good amount of resources and time to build. We want to cache them. 

`MemoryCache` provides certain level of thread-safety but not enough to avoid running multiple instances of building code in parallel. Here is an example:

    var data = cache[&quot;key&quot;];
    if(data == null)
    {
      data = buildDataUsingGoodAmountOfResources();
      cache[&quot;key&quot;] = data;
    }

As you can see on a busy website hundreds of threads could go inside the if statement simultaneously until the data is built and make the building operation even slower, unnecessarily consuming the server resources.

There is an atomic `AddOrGetExisting` implementation in MemoryCache but it incorrectly requires &quot;value to set&quot; instead of &quot;code to retrieve the value to set&quot; which I think renders the given method almost completely useless. 

We have been using our own ad-hoc scaffolding around MemoryCache to get it right however it requires explicit `lock`s. It&#39;s cumbersome to use per-entry lock objects and we usually get away by sharing lock objects which is far from ideal. That made me think that reasons to avoid such convention could be intentional.

So I have two questions:

- Is it a better practice not to `lock` building code? (That could have been proven more responsive for one, I wonder)

- What&#39;s the right way to achieve per-entry locking for MemoryCache for such a lock? The strong urge to use `key` string as the lock object is dismissed at &quot;.NET locking 101&quot;. 

How to deal with costly building operations using MemoryCache?

I&#39;m using `MemoryCache` in ASP.NET and it is working well. I have an object that is cached for an hour to prevent fresh pulls of data from the repository.

I can see the caching working in debug, but also once deployed to the server, after the 1st call is made and the object is cached subsequent calls are about 1/5 of the time. 

However I&#39;m noticing that each *new* client call (still inside that 1 hour window - in fact just a minute or 2 later) seems to have the 1st call to my service (that is doing the caching)  taking almost as long as the original call before the data was cached.

This made me start to wonder - is `MemoryCache` session specific, and each new client making the call is storing it&#39;s own cache, or is something else going on to cause the 1st call to take so long even *after* I know the data has been cached?

Is MemoryCache scope session or application wide?

For starters let me just throw it out there that I know the code below is not thread safe (correction: might be). What I am struggling with is finding an implementation that is and one that I can actually get to fail under test. I am refactoring a large WCF project right now that needs some (mostly) static data cached and its populated from a SQL database. It needs to expire and &quot;refresh&quot; at least once a day which is why I am using MemoryCache.

I know that the code below should not be thread safe but I cannot get it to fail under heavy load and to complicate matters a google search shows implementations both ways (with and without locks combined with debates whether or not they are necessary.

Could someone with knowledge of MemoryCache in a multi threaded environment let me definitively know whether or not I need to lock where appropriate so that a call to remove (which will seldom be called but its a requirement) will not throw during retrieval/repopulation.

    public class MemoryCacheService : IMemoryCacheService
    {
        private const string PunctuationMapCacheKey = &quot;punctuationMaps&quot;;
        private static readonly ObjectCache Cache;
        private readonly IAdoNet _adoNet;

        static MemoryCacheService()
        {
            Cache = MemoryCache.Default;
        }

        public MemoryCacheService(IAdoNet adoNet)
        {
            _adoNet = adoNet;
        }

        public void ClearPunctuationMaps()
        {
            Cache.Remove(PunctuationMapCacheKey);
        }

        public IEnumerable GetPunctuationMaps()
        {
            if (Cache.Contains(PunctuationMapCacheKey))
            {
                return (IEnumerable) Cache.Get(PunctuationMapCacheKey);
            }

            var punctuationMaps = GetPunctuationMappings();

            if (punctuationMaps == null)
            {
                throw new ApplicationException(&quot;Unable to retrieve punctuation mappings from the database.&quot;);
            }

            if (punctuationMaps.Cast&lt;IPunctuationMapDto&gt;().Any(p =&gt; p.UntaggedValue == null || p.TaggedValue == null))
            {
                throw new ApplicationException(&quot;Null values detected in Untagged or Tagged punctuation mappings.&quot;);
            }

            // Store data in the cache
            var cacheItemPolicy = new CacheItemPolicy
            {
                AbsoluteExpiration = DateTime.Now.AddDays(1.0)
            };

            Cache.AddOrGetExisting(PunctuationMapCacheKey, punctuationMaps, cacheItemPolicy);

            return punctuationMaps;
        }

        //Go oldschool ADO.NET to break the dependency on the entity framework and need to inject the database handler to populate cache
        private IEnumerable GetPunctuationMappings()
        {
            var table = _adoNet.ExecuteSelectCommand(&quot;SELECT [id], [TaggedValue],[UntaggedValue] FROM [dbo].[PunctuationMapper]&quot;, CommandType.Text);
            if (table != null &amp;&amp; table.Rows.Count != 0)
            {
                return AutoMapper.Mapper.DynamicMap&lt;IDataReader, IEnumerable&lt;PunctuationMapDto&gt;&gt;(table.CreateDataReader());
            }

            return null;
        }
    }

MemoryCache Thread Safety, Is Locking Necessary?

I assume this code has concurrency issues:


    const string CacheKey = &quot;CacheKey&quot;;
    static string GetCachedData()
    {
        string expensiveString =null;
        if (MemoryCache.Default.Contains(CacheKey))
        {
            expensiveString = MemoryCache.Default[CacheKey] as string;
        }
        else
        {
            CacheItemPolicy cip = new CacheItemPolicy()
            {
                AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(20))
            };
            expensiveString = SomeHeavyAndExpensiveCalculation();
            MemoryCache.Default.Set(CacheKey, expensiveString, cip);
        }
        return expensiveString;
    }

The reason for the concurrency issue is that multiple threads can get a null key and then attempt to  insert data into cache.

What would be the shortest and cleanest way to make this code concurrency proof? I like to follow a good pattern across my cache related code. A link to an online article would be a great help.


UPDATE:

I came up with this code based on @Scott Chamberlain&#39;s answer. Can anyone find any performance or concurrency issue with this?
If this works, it would save many line of code and errors. 

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Runtime.Caching;

    namespace CachePoc
    {
        class Program
        {
            static object everoneUseThisLockObject4CacheXYZ = new object();
            const string CacheXYZ = &quot;CacheXYZ&quot;;
            static object everoneUseThisLockObject4CacheABC = new object();
            const string CacheABC = &quot;CacheABC&quot;;

            static void Main(string[] args)
            {
                string xyzData = MemoryCacheHelper.GetCachedData&lt;string&gt;(CacheXYZ, everoneUseThisLockObject4CacheXYZ, 20, SomeHeavyAndExpensiveXYZCalculation);
                string abcData = MemoryCacheHelper.GetCachedData&lt;string&gt;(CacheABC, everoneUseThisLockObject4CacheXYZ, 20, SomeHeavyAndExpensiveXYZCalculation);
            }

            private static string SomeHeavyAndExpensiveXYZCalculation() {return &quot;Expensive&quot;;}
            private static string SomeHeavyAndExpensiveABCCalculation() {return &quot;Expensive&quot;;}

            public static class MemoryCacheHelper
            {
                public static T GetCachedData&lt;T&gt;(string cacheKey, object cacheLock, int cacheTimePolicyMinutes, Func&lt;T&gt; GetData)
                    where T : class
                {
                    //Returns null if the string does not exist, prevents a race condition where the cache invalidates between the contains check and the retreival.
                    T cachedData = MemoryCache.Default.Get(cacheKey, null) as T;

                    if (cachedData != null)
                    {
                        return cachedData;
                    }

                    lock (cacheLock)
                    {
                        //Check to see if anyone wrote to the cache while we where waiting our turn to write the new value.
                        cachedData = MemoryCache.Default.Get(cacheKey, null) as T;

                        if (cachedData != null)
                        {
                            return cachedData;
                        }

                        //The value still did not exist so we now write it in to the cache.
                        CacheItemPolicy cip = new CacheItemPolicy()
                        {
                            AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(cacheTimePolicyMinutes))
                        };
                        cachedData = GetData();
                        MemoryCache.Default.Set(cacheKey, cachedData, cip);
                        return cachedData;
                    }
                }
            }
        }
    }



Locking pattern for proper use of .NET MemoryCache

**AuthenticationRequiredAttribute Class** 


    public class AuthenticationRequiredAttribute : ActionFilterAttribute
    {
        ILoginTokenKeyApi _loginTokenKeyApi;
        IMemoryCache _memoryCache;

        public AuthenticationRequiredAttribute(IMemoryCache memoryCache)
        {
            _memoryCache = memoryCache;

            _loginTokenKeyApi = new LoginTokenKeyController(new UnitOfWork());
        }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            var memory = _memoryCache.Get(Constants.KEYNAME_FOR_AUTHENTICATED_PAGES);

            string requestedPath = filterContext.HttpContext.Request.Path;

            string tokenKey = filterContext.HttpContext.Session.GetString(&quot;TokenKey&quot;)?.ToString();

            bool? isLoggedIn = _loginTokenKeyApi.IsLoggedInByTokenKey(tokenKey).Data;

            if (isLoggedIn == null ||
                !((bool)isLoggedIn) ||
                !Constants.AUTHENTICATED_PAGES_FOR_NORMAL_USERS.Contains(requestedPath))
            {
                filterContext.Result = new JsonResult(new { HttpStatusCode.Unauthorized });
            }
        }
        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
        }
    }

**HomeController**

    public class HomeController : Controller
    {
        IUserApi _userApi;
        ILoginTokenKeyApi _loginTokenKey;
        IMemoryCache _memoryCache;

        public HomeController(IUserApi userApi, ILoginTokenKeyApi loginTokenKey, IMemoryCache memoryCache)
        {
            _loginTokenKey = loginTokenKey;
            _userApi = userApi;

            _memoryCache = memoryCache;
        }

        [AuthenticationRequired] // There is AN ERROR !!
        public IActionResult Example()
        {
            return View();
        }
    }

ERROR : 

&gt; Error	CS7036	There is no argument given that corresponds to the
&gt; required formal parameter &#39;memoryCache&#39; of
&gt; &#39;AuthenticationRequiredAttribute.AuthenticationRequiredAttribute(IMemoryCache)&#39;	Project.Ground.WebUI

**My problem is actually : I cant use dependency injection in attribute classes**.

I want to use that attribute without any parameter. Is there any solution to solve it? I use dependency injection but it cant be used for attributes. How I can use it?

Content Type	Original Author	Original Content on Stackoverflow
Question	Storm	View Question on Stackoverflow
Solution 1 - .Net	Marc Gravell	View Answer on Stackoverflow

What's the difference between MemoryCache.Add and MemoryCache.Set?

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

val() vs. text() for textarea

UIPopovercontroller dealloc reached while popover is still visible

Attributions