Correct way to AddOrUpdate Property of Class in a ConcurrentDictionary?

Question

I have a ConcurrentDictionary we'll call ParamaterList.  And a class named Parameter. 
Class parameter{
public string Username = string.Empty;
public string FirstName = string.Empty;
public string LastName = string.Empty;       
public bool enabled = false;
ConcurrentDictionary<string, parameter> ParameterList = new ConcurrentDictionary<string, parameter>;
I want to confirm that I'm doing this correctly and there isn't a better way.  To update a class I am doing this:
ParameterList.AddOrUpdate("username", true, (k, v) => {v.enabled = true; return v;});
Is that the correct approach or is there a 'correct' way to update a property of v directly without returning a full 'new' class? My classes are small now but I would like to learn best practices for concurrentDictionaries. 

Answer 1

1) TryGetValue is thread safe.  If someone is trying to modify the collection while you're retrieving it then they will block until you have the value.
2) Yes another thread could remove the item after you get it but there is no concurrent collection that guarantees otherwise. A concurrent collection simply guarantees that while a particular method on the collection is being executed that no other
thread will cause changes that will cause it to fail.  Once the method returns another thread can do whatever it wants.  90% of the time that is perfectly fine and expected.  In the few cases where you need to ensure an item remains in a collection
for some fixed period of time then you'll have to use a lock instead.  But after the lock is released the item can still be removed. 
Removing an item from the collection does not invalidate your copy of that item.  You still have a reference to the item and it'll exist and be usable as long as you hold onto it.  Whether it is in the collection or not doesn't matter.  In
general multiple writers to a collection is not a good thing to have so you'll want to consider modifying your code to have a single writer but any # of readers.  This will simplify your code and make it easier to maintain.
3) If you want to update an item if it exists or create a new one if it doesn't then you have to make some decisions.  TryAddUpdate would be the way to go if you want to recreate the item each time whether it is already there or not. If you only want
to create it if it doesn't exist then use TryGetValue and if that fails then use TryAdd to add a new one. However a concurrent collection doesn't prevent modifications between these calls so between the time you get the value and update/add it somebody else
could remove it, add it or both.  If you need a gurantee that the collection does not change during these calls then you have to use a lock because the collection itself doesn't provide a long enough lock. 
If you do decide to use TryAddUpdate note that each time you will add a new object to the collection and this will cause problems for other threads.  For example another thread may use TryGetValue to get the object and then set one of the properties. 
But if another thread calls TryAddUpdate during this time a new object is created and added to the collection so the original thread's changes are lost and they are none the wiser.  However if you use TryGetValue first and only call TryAdd if the item
doesn't exist yet then you will always be working against the same object across threads and by using the return value of the methods you can determine whether you got a value or successfully added it.  This is the cost of using multiple writers.
4) The collections are thread-safe, not the objects in them.  There is no guarantees around the thread safety of the objects in the collection. If you need thread safety on the objects themselves then either the object type needs to be thread safe or
you have to use a lock.  For the case of a single writer, multiple readers then you are better off using a ReaderWriterLock instead of a concurrent dictionary.