This is a bit complicated.
First, multi core means multithreaded, but not vice versa (that is, you need at least one thread per core to fully utilize all cores, but a single core can run multiple threads). So to use all the cores you need to delve into programming with threads.
Basically, traditional programming languages are based on a single threading model (that is, a single core). In fact, the C++ standard pre C++0x didn't even have the concept that other hardware threads were even possible (which makes cross platform multithreaded programming in C++ a nightmare).
Usually, making a program use more cores is a huge engineering effort because threads will be contending with each other. Imagine, for instance, if two cores try to write to the same place in memory at the same time. Or worse, if one thread reads from a memory location while another writes to it. This is made even worse with caching (but luckily that's more a problem for hardware engineers than programmers).
That said, there are newer languages built around the idea of massive core systems, where the paradigm is shifted from threads to kernels (that is, instead of telling threads what to do you just define some basic "jobs" that need doing, in small chunks, and the environment decides how to split those up between available cores). See, for instance,
OpenCL.
On top of all that, it's useful to be aware of
Amdaahl's Law: not all tasks can be parallelized, and as you get more cores to throw at a problem the speed up is not linear if the problem is not perfectly parallelizable, which most problems aren't.
...
All that said, to your specific question, in the .NET world the basic idea to set up a thread object, give it a task, and then "launch" it. For a full breakdown, see
this series.
It's definitely not as simple as setting a "go faster" flag or anything. It's up to the programmer to divide the computational task into smaller sub tasks that can be farmed out to other threads, and then to synchronize those threads to get a final result, while ensuring that the threads aren't contending with each other for resources. Which is why multithreading is usually considered a fairly advanced programming issue.
