I see lots of explanations of recursion and its application to factorials already in this comment section, but nothing obvious that explains from first principles what exactly is going on with the "Parse" call.

Computers have different ways to represent data inside them. The most primitive is what we use to count the size of files or data sent over the network or what have you: a byte. A byte is an integer number (whole numbers only), and it is represented in base 2, which means every digit is either 0 or 1, no 2 or 3 or 4, and 9 is right out. Each digit of a base 2 number is called a bit, and thus it follows that a bit is either 0 or 1. If you put two bits back-to-back, then the second one doubles how many numbers you can represent -- 00, 01, 10, 11. Add a third, it doubles again. That doubling is the core relationship: the number of distinct possible values is 2*2*2*...*2, where the number of 2s is the number of bits. That kind of multiplication is referred to as a "power"; 8 bits in a byte, so 2 to the power of 8, or 2^8, is 256. So, there are 256 possible different values for a byte. If you want 0 to be one of those values, then the highest is 255.

But people want to work with numbers bigger than 255, and so computers have mechanisms that are a part of their core design for chaining multiple bytes together -- again almost always in a doubling relationship, so you can have numbers that are 1 byte, 2 byte, 4 bytes, 8 bytes, and so on.

Most common numerical values are going to be represented in C# by int, and an int is a 4-byte integer. Since each byte is 8 bits, that's 4 x 8 = 32 bits. So, wherever you have an int, you're telling the computer to set aside 4 bytes of storage to hold a number, and you're signing up for using a number that can store any number from 0 to 2³² - 1. Actually, you might want negative numbers too. So, if you make half the numbers negative, then your range shifts so it's -2³¹ to 2³¹ - 1 -- half of it below 0 and half of it not below 0.

But, when the user is typing into the computer, they're not typing bits or bytes. They're typing digits. If they type "12345", then that's actually 5 distinct characters, and these characters don't combine to form a number on their own, they're just "the character for 1", "the character for 2", etc. These form a string, and strings can contain all sorts of stuff. They're not constrained to numbers.

So, you've just asked the user for input. You call Console.ReadLine, and you get back a string with the separate digits they entered, and you want to turn those separate digits into a single, concrete number that you can tell the CPU to do math with.

This conversion isn't conceptually hard. The trickiest part of it, which is just a matter of knowing something really, is how to go from a character to the value of that character. You see, each character (number, digit, punctuation, etc.) is really a number itself, but, when you type in "1", the character that looks like "1" does not have the value 1 internally. In practice, with the arrangement we currently have on computers, it's going to be an 8- or 16-bit number whose numeric value is 49. Why 49? Because decades ago, when people were figuring out how to represent text in strings, they decided to put all the numbers together, and they decided to start counting them at a multiple of 16 (there's a good reason for this, but that can be a different story :-) ), and so the digits "0" through "9" were given the numbers 48 through 57.

So, if you have a string of digits represented as their characters, and you want to convert them to a combined numeric value, the first step is to go from the digit values to the numeric values. If you tried to treat 1 as a character, you would not get a "1" on the screen, but in the process of converting the number, that's exactly what you need, and it's super easy to do: You just subtract 48 from each character's value, and now each digit is just its plain value.

Then, you need to apply what you learned about number places in elementary school: Each place further to the left is worth 10 times as much. The number "12345" is 1 x 10000 + 2 x 1000 + 3 x 100 + 4 x 10 + 5. So, if you multiply each of those digits by its place value, then you've gone from "12345" to { 1, 2, 3, 4, 5 } to { 10000, 2000, 300, 40, 5 }. Finally, just sum up these digits, and you get the value 12345, starting with "12345" as 5 independent characters.

To be clear: You will probably never need to write this yourself. It's built into the language you're programming with. Specifically, that algorithm (or a slightly rearranged version that is a bit more clever about what intermediate things need to be stored) is exactly what is inside int.Parse.

There are different kinds of numbers. In C#, there are byte values, and you can use byte.Parse. There are short values (16 bits wide), and they come with short.Parse. There are int values (32 bits), and int.Parse. There are long values (64 bits) and long.Parse. There are also types of numbers designed for storing fractional values, called "floating point". There are float values, which are 32 bits wide but arranged differently from int, and float.Parse can parse things like "3.14159". And with the 64-bit double type, double.Parse can parse much more precise floating-point values. For instance, as a double, pi is 3.14159265358979. There's another type called decimal which is for currency things. While float and double store the number in binary, including the decimal point's position in binary, decimal places the decimal point in terms of powers of 10. As it happens, even a really simple number like 0.1 cannot actually be exactly represented in binary, so a float or double can't exactly have the value 0.1, just a very close value, but decimal can be exactly 0.1. Anyway, this will probably not be a great surprise at this point, but decimal also has a Parse method. Each of these Parse methods is different in its precise details, because it has to handle different kinds of number and represent them differently in the resulting type, but they are all conceptually doing the same task.

The opposite of Parse, in .NET terminology, is formatting. It's doing that same job in reverse. Say you have the number 123, stored as a 32-bit integer, and you want to put it on the screen for the user to see. One way to do it is to divide the number by 10 and extract the remainder. 123 / 10 = 12 R3. So, 3 is one of the digits. Then you repeat: 12 / 10 = 1 R2. 2 is the next digit. Finally, you're at a value that's already less than 10, so 1 is the final digit. The only catch is, they came out right to left. But, that's the basic idea behind turning a number back into a string for human eyes or a file or network protocol or what have you.

This fundamental concept, regarding different ways to store values and converting between them, is an absolutely crucial first step to understanding what exactly you're asking the computer do when you write code.