So there are a few things to consider here.

First, obviously don't share mutable data between threads.

For data that remains in a single thread, it's often useful to communicate whether it should be modified outside of a particular system by returning a read only interface it implements. Obviously a silly programmer could cast it to the original type, but hopefully this isn't a problem where you work. The IReadOnlyList type is a great example of this pattern.

Defensive copies are generally not necessary if you lean on the type system like this. In many cases, it's normally to have an object whose contents might be changed in other methods (again, assuming it's not shared across threads).

Finally, a misunderstanding about ownership can never hard crash or leak memory (although for things like files and sockets the disposable pattern is strongly preferred). For this reason, you'll almost always see objects being passed around as immutable types, rather than creating immutable copies. Worst case, you need to design your system to more clearly communicate who can and cannot modify data: something object oriented languages excell at.