Gain insights into fundamental and advanced C# programming concepts. Learn about conditional statements, loops, methods, arrays, classes, inheritance, interfaces, and delegates through practical challenges.

This course introduces you to fundamental programming concepts in C#, one of the most popular languages in the world. The highly interactive course begins with a simple Hello world program and proceeds on to cover common concepts such as conditional statements, loop statements, and methods in C#. It also reflects upon the idea of arrays as well as the power they give to the programmer to write better code. Finally, it dives deeper in order to teach about advanced concepts such as classes, inheritance, interfaces, and delegates in C# through interactive challenges and exercises.

C# for Programmers: A Practical Guide

# Introduction

Recursion can be defined as:

>A *method* that calls itself until a specific *condition* is met.

# Example 
An excellent and simple example of *recursion* is a method that will get the **factorial** of a given number:

using System;

class FactorialExample
{
    static void Main()
    {
        Console.WriteLine("Factorial of 4 is: {0}",Factorial(4));
    }
    public static int Factorial(int number)
    {
        if(number == 1 || number == 0) // if number equals 1 or 0 we return 1
        {
            return 1;
        }
        else
        {
            return number*Factorial(number-1); //recursively calling the function if n is other then 1 or 0
        }

    }
}

## Code Explanation
In the above example, we can see that the *method* will take an argument, `number`.

**Step by step:**

Given the example, executing `Factorial(4)`
1. Is `number (4) == 1`?
2. **No**? *return* `4 * Factorial(number-1) (3)`
3. Because the *method* is called once again, it now *repeats* the **first** step using `Factorial(3)` as the new argument.
4. This continues until `Factorial(1)` is executed and `number (1) == 1` returns `1`.
5. Overall, the calculation "builds up" `4 * 3 * 2 * 1` and finally returns `24`.

Many times, a *recursive* solution to a problem is very easy to program. 

* The drawback of using *recursion* is that there is a lot of *overhead*. 

Every time a function is called, it is placed in *memory*. Since you don't **exit** the `Factorial` function until **n** reaches **1**, **n** functions will reside in *memory*. This isn't a problem with​ the simple `Factorial(4)`, but other functions can lead to serious memory requirements.  

The key to understanding **recursion** is that the *method* calls a new instance of itself. After *returning*, the execution of the *calling* instance continues.



This lesson introduces the concept of recursion and how it is implemented in C#

Introduction

Variables and Casting

Operators

Conditions

Loops

Arrays

Methods

Exception Handling

Classes

OOP in C#

Delegates

C# Exam

Recursion

Introduction