CODEWITHSUNDEEP
c#.net-coreconcurrentdictionary
OJB1
OJB1

Reputation: 2785

C# Concurrent Dictionary Object Read/Update Thread Safety Question

In the code below I have a concurrent dictionary that i'm using for storing a single key/value pair where the value is a collection of strings.

I will be reading and updating the strings in this single key/value pair from different threads.

I'm aware that concurrent dictionaries are not entirely thread safe if one thread has changed a value before the other thread has perhaps finished reading it. But equally i'm not sure if string values really come into this topic or not, could someone please advise?

Its also worth mentioning that although I put this "GetRunTimeVariables" method into an interface for dependency injection, I actually cant use DI all the time for accessing this method due to the stages of app startup and OIDC events sign in/out where i need to access the dictionary values within classes that can't use dependency injection, so in essence I could be accessing this dictionary from nay means as necessary throughout the lifetime of the application.

Lastly i'm not really sure if there is any benefit in pushing this method into an interface, the other option is simply new up a reference to this class each time i need it, some thoughts on this would be appreciated.

public class RunTimeSettings : IRunTimeSettings
{
    // Create a new static instance of the RunTimeSettingsDictionary that is used for storing settings that are used for quick
    // access during the life time of the application. Various other classes/threads will read/update the parameters.
    public static readonly ConcurrentDictionary<int, RunTimeVariables> RunTimeSettingsDictionary = new ConcurrentDictionary<int, RunTimeVariables>();

    public object GetRunTimeVariables()
    {
        dynamic settings = new RunTimeVariables();

        if (RunTimeSettingsDictionary.TryGetValue(1, out RunTimeVariables runTimeVariables))
        {
            settings.Sitename = runTimeVariables.SiteName;                
            settings.Street = runTimeVariables.Street;
            settings.City = runTimeVariables.City;
            settings.Country = runTimeVariables.Country;
            settings.PostCode = runTimeVariables.PostCode;
            settings.Latitude = runTimeVariables.Latitude;
            settings.Longitude = runTimeVariables.Longitude;
        }

        return settings;
    }
}

Class for string values:

public class RunTimeVariables
{
    public bool InstalledLocationConfigured { get; set; }
    public string SiteName { get; set; }
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
    public string PostCode { get; set; }
    public string Latitude { get; set; }
    public string Longitude { get; set; }
}

Upvotes: 0

Views: 833

Answers (1)

xanatos
xanatos

Reputation: 111810

The System.String type (the classical strings of C#) is immutable. No one can modify the "content" of a String. Anyone can make a property reference a different String.

But in truth the only problem you have here is that the various values could be de-synced. You have various properties that are correlated. If one thread is modifying the object while another thread is reading it, the reading thread could see some properties of the "old" version and some properties of the "new" version. This isn't a big problem if the object once written to the ConcurrentDictionary is not changed (is "immutable" at least as a business rule). Clearly a correct solution is to have RuntimeVariables be an immutable object (composed only of readonly fields that are initialized at instancing for example)

Upvotes: 2

Related Questions