What does it mean that a C# variable seems to work directly with an object?

The wording is more complicated than it needs to be. A class defines the structure and behavior, while an object is a particular instance created from that class. The variable named `dice` usually stores a reference to that object rather than containing the entire object itself. C# lets you use the reference as though you were working directly with the object, while the runtime handles the underlying memory details for you.

Imagine drawing an object as a box on a whiteboard and drawing an arrow from `dice` to that box. If you write `otherDice = dice`, both variables point to the same box. Changing the object through either variable changes the same object. But if you later assign a different object to `dice`, only the `dice` arrow moves; `otherDice` still points to the original object. An instance is simply a specific object created from a class.

The runtime manages details that languages such as C or C++ may expose more directly, such as memory allocation, object movement, and reference tracking. You generally do not manually dereference pointers or manage the object's lifetime in ordinary C# code. The object remains available while something still references it, and the garbage collector can reclaim it when nothing does. There is no mysterious alternative way to access the object—the “illusion” simply means C# hides those implementation details behind normal-looking member access.