I cannot promise I'll be brief, but I will try. Problem is that the answers are even more complicated than the questions. I will first try to simplify the questions. Let's take a look at them in the order they were asked.
When can values of parameters be read? I assume there are two concerns implied in this question. First, is it "safe" to read the value of a parameter? (Here "safe" means that such an attempt could be finished without an exception.) Second, can the value be trusted? (Meaning - is the value really what one should work with?)
The answer is: Reading parameters' values should be considered both unsafe and potentially inaccurate after changes were made to the model and the model have not been regenerated yet. After the model is regenerated, reading is safe assuming the parameter still exists. In most cases the acquired values can be trusted, even though it may not be the final values. Values are guaranteed to be final and up-o-date only between transactions. (Here up-to-date relates too local changes only; not chances happening in a central model.)
Is an Element object safe to be accessed after regeneration? Here the question seems clear and I assume the "safety" relates to being able to invoke methods and evaluate properties without causing exceptions.
The answer is: Yes, assuming the element has indeed not been deleted, directly or indirectly, it can be accessed. The problem here is, however, how can one really know whether an element has been deleted or not? Luckily for the Revit API developer, elements that have been deleted (here meaning: removed from the model, not necessarily physically deleted) will have their IsValidObject property returning False. That one property is always safe to access even on deleted elements, for it is implemented at the API layer only and is detached from the underlying element object (native) itself. Again, if there have been changes to the model, even still valid elements should not be read from at least until regeneration is performed. Furthermore, like with the reading parameters addressed earlier, if one needs an absolute guarantee that an element may be not only safely accessed but its properties are also accurate and up-to-date, one must finish the active transaction.
To put a little perspective on the subject, MOST values can be safely read and trusted just after a successful regeneration. However, for the 100% guarantee only, it must to be stated that no change is really done unless the transaction is done. As one example, dynamic updaters are called at the very end of every transaction. If an updater has a certain policy about what is considered valid, the updater can still make changes to satisfy its policy. So, from the perspective of that one particular updater, the model is not really valid until the updater is executed (i.e., practically, after the transaction committed.)
As a side note, perhaps, I can share a bit from our internal guidelines. We Revit developers try not to hold onto element objects in situations involving changes of the model and eventual regeneration. Instead, we prefer using element Ids and fetching the elements when we need them. The main reason is, again, that it is virtually impossible to predict what a regeneration would do, thus we cannot be sure whether or not we can safely access elements we got. (And, unfortunately, we do not have the convenience of the IsValidObject method the API developers enjoy.)
Arnošt Löbel
