C# for Absolute Beginners (With STEP-BY-STEP Videos)
Tags: csharp, beginners, tutorial, dotnet
Published: 2019-10-30 15:58:52

![C# for Absolute Beginners: the Basics](https://miro.medium.com/max/1920/1*Ut-3svKA6tkLHNXmgLOesw.jpeg "C# for Absolute Beginners: the Basics")

>_Begin your journey with C#. The objective of this article and [YOUTUBE videos](https://www.youtube.com/codebuns) is to familiarize you with the **C# programming basics**. This article is for absolute beginners who want to learn **C# fundamentals** by coding. **Please share** if you like [this](https://www.codebuns.com/csharp-basics/c-programming-basics-for-absolute-beginners/) article._


C# Online Editors
------
There are many C# online editors out there, you can use for coding but I have selected 2 for this article. I have used both the editors very extensively for preparing this step by step C# tutorial and it worked very well for me. By the way, all the editors are lightweight and free to use in the browser.

{% youtube KAOSFgjKMRE %}

I don't know about you guys. But I want a few basic things in an online C# editor.

First, it should have a **Simple and Clean Interface**. I don't wanna see lots of ads popping up all over the page. Moreover, it must have an easy-to-use interface.

Additionally, I want **Code Completion** in the editor; I need auto-completion with IntelliSense support, which can provide smart completion based on variable types, function definitions, etc.

Lastly, I want **Syntax Highlighting** to improve code readability.

###C# Online Editors
- [try.dot.net](https://try.dot.net)
- [dotnetfiddle.net](https://dotnetfiddle.net)


Variables in C#
------
"Variable" is the name given to a computer memory location for storing data that can be reused throughout the program-that is, it is used to store, retrieve, and modify changeable data.

A variable is always defined with a datatype, which means that it will hold the value of a specific type, such as **string**, **int**, **float**, and so on. Always assign value to a variable before using it to avoid a compile-time error.

{% youtube RUgsDUIUWMU %}

###C# Variable Naming Conventions
Rules regarding variable names that must be followed:
* **camelCase** for local variables, such as **name**, **firstName**, **lastName**, and **isMarried**.
* Can contain the letters a-z and A-Z, the numbers 0–9, and the underscore (_) character-other symbols are not allowed.
* No spaces and cannot start with a number.
* Cannot use C# language-keywords such as namespace, class, using, and so on.

###Declaring Variables in C#.
To declare a variable, use the **type** and then a **name**:

```c#
string name; 
int age;
```

[Run Demo](https://dotnetfiddle.net/LHQ645)

**Type** must be one of the valid data types, and **variableName** is the identifier. This is an **explicitly typed** local variable where the type is explicitly defined.

You can declare multiple variables on one line in the form of a comma-separated "**,**" list if they are of the same type. Use a semicolon (**;**) if they are of different types.

```c#
string name; int age, weight;
```

To initialize the variable with a value, you have to use the assignment operator "**=**". The variable name is on the left side of the operator and on the right side is the value, like this:

```c#
name = "Pirzada"; 
age = 35;
```

[Run Demo](https://dotnetfiddle.net/YKjiQY)

Alternatively, you can declare the variable with a type, and assign it a value at the same time on the same line, which is more convenient:

```c#
string name = "Pirzada"; 
int age = 35;
```

[Run Demo](https://dotnetfiddle.net/lADdDp)

###var Variable in C# (Type Inference)
To declare **implicitly typed** local variable, use the **var** keyword:

```c#
var name = "Pirzada"; 
var age = 35;
```

[Run Demo](https://dotnetfiddle.net/wLrWTG)

Now you can declare a variable without giving an explicit or real type. The **var** keyword in c# instructs the compiler to infer the type of a variable from the expression on the right side of the initialization statement. Actually, compiler determines and assigns the most appropriate type.

**Note:** **var** can only be declared and initialized in a single statement. Otherwise, the compiler doesn't have anything from which to infer the type.


C# Comments
------
C# comments are only for you to read, not for the computer to execute. Use comments only to clarify code that's difficult to understand.

{% youtube g8wIRPXtWrM %}

###Single-Line Comments
You can make any line into a C# single-line comment by starting it with the two forward slash marks `//`, indicating that the remainder of the line is a comment.

Once the compiler reads the slashes, it ignores all characters until the end of the current line.

```c#
// This is a comment 
Console.WriteLine("This is not a comment");
```

If you run these two lines, you'll get the following output: `This is not a comment`

[Run Demo](https://dotnetfiddle.net/o9WKuE)

###End-Of-Line Comments
You can put a comment at the end of a line, like this:

```c#
int variableName = 1; //this is a comment
```

Everything before `//` is a normal line of code, and everything after that is a comment.

[Run Demo](https://dotnetfiddle.net/Eps2xf)

###Multi-Line Comments (Delimited comments)
C# multiline comment begins with an open comment mark `/*` and ends with a closed comment mark `*/`. All the text between the delimiters is ignored by the compiler. 

Here is an example.

```c#
/* 
Comment Line 1 
Comment Line 2 
*/
```

[Run Demo](https://dotnetfiddle.net/VNe9XO)


C# if else Statement
------
C# if else statement is one of the most commonly used control flow statement. With **if** statements, you can tell the computer to make a choice by evaluating a Boolean logical expression (true or false) called **condition**. It allows you to tell the computer whether to run the code inside the block based on the condition or set of conditions.

{% youtube HmZ1ZvR10V8 %}

###if Statement
When you only need to execute code for a true condition, use an **if** statement.

**if** Condition flowchart

![C#’s if condition flowchart](https://miro.medium.com/max/178/0*xBiUckZJ9QrwcdAY.png "C#’s if condition flowchart")

**if** Condition Example

![C# if condition example](https://miro.medium.com/max/850/0*aEJOra_a3Id7RGoT.png "C# if condition example")

[Run Demo](https://dotnetfiddle.net/CBbHSG)

The value of the number variable is 8. So the expression `(number > 7)` is evaluated to **true** because 8 is greater than 7. Hence, the statements inside the body of the **if** block is executed. If you change the value of the number variable from 8 to 6, then the expression will return **false**, which will ignore the execution of the **if** body.

###else Statement
You can also have an **else** clause. Whenever the Boolean condition of the **if** statement is **false**, the **else** clause executes as shown in the following code block.

**if else** flowchart

![C#’s if-else flowchart](https://miro.medium.com/max/264/0*Dv09mEQSPKygyL74.png "C#’s if-else flowchart")

**if else** Condition Example

![C#’s if-else condition example](https://miro.medium.com/max/425/0*xH3b1BDeEEKUVtQU.png "C#’s if-else condition example")

[Run Demo](https://dotnetfiddle.net/a4HL5R)

The value of a number variable is 6. So the expression `(number > 7)` is evaluated to **false** because 6 is less than 7. Hence, the code inside **else** block is executed.

###else if Statement
C# **if statement** can be extended by any number of **else if** clauses. This statement follows directly after the **if** statement to let you use multiple conditions for testing.

**if else-if else** flowchart

![C#’s if else-if else Condition Example](https://miro.medium.com/max/304/0*AHnwDqak5ezOZUEq.png "C#’s if else-if else Condition Example")

**Note:** Order of tests is important if you are using an **if else-if** construct.

**if else-if else** Condition Example

![C#’s if else-if else condition example](https://miro.medium.com/max/459/0*q_bKTVUDnQtzec_8.png "C#’s if else-if else condition example")

[Run Demo](https://dotnetfiddle.net/QkdL5E)

In the above example, the expression `(gender == "Female")` is evaluated to **true**, which is the condition of the **else if** block and everything inside the pair of braces (**{ }**) is carried out and the rest of **if** statement will be skipped.

**Note:** Each additional condition will only be evaluated if all previous conditions are **false**.


C# Conditional Operator (if else shorthand)
------
C# provides a conditional operator "?:", which is sometimes called C# ternary or question operator. This operator is a shorthand method of writing a simple single line **if else** statement.

C# **Ternary** operator

![C#’s ternary operator](https://miro.medium.com/max/331/0*mHUMQjwnIT-0gxW6.png "C#’s ternary operator")

C# **Ternary operator** flowchart

![C#’s ternary operator flowchart](https://miro.medium.com/max/365/0*ezDlfwUlLpDyuNU1.png "C#’s ternary operator flowchart")

C# conditional operator uses three operands on one line. The first operand is a Boolean expression that evaluates to true or false. If the expression is true, the value of the second operand is returned; otherwise, the value of the third is returned.

```c#
bool loggedIn = true; 
string status = loggedIn ? "Online" : "Offline"; 
Console.WriteLine($"User is {status}"); // Print
```

In the above code, the result of the ternary operator is one of two strings, both of which may be assigned to `status` variable. The choice of which string to assign depends on the value of the `loggedIn` variable being true or false. In this case, a value of true results in the first string being assigned, and a value of false results in the second string being assigned.

The above code is equivalent to the following:

```c#
bool loggedIn = true; 
string status = String.Empty; 
if (loggedIn) 
   status = "Online"; 
else 
   status = "Offline";
 
Console.WriteLine($"User is {status}"); // Print
```

[Run Demo](https://dotnetfiddle.net/CDvend)


C# switch Statement
------
The C# switch statement evaluates a single expression against a list of multiple possible cases. Every switch case is related to the single expression and must end with the **break** or **goto case** or an empty block. The break statement passes control out of the switch. You can omit a **break** statement if two cases lead to the same action.

{% youtube 31tBUGr5oy4 %}

A **switch** statement starts with the **switch** keyword followed by a **switch** expression in parentheses. After the **switch** expression, you include multiple case labels that represent the possible values of the **switch** expression. When the **switch** expression finds the matching value specified by a case label, the statements inside that case are executed.

![C# switch statement example](https://miro.medium.com/max/686/0*nifOFXObO5pBtsM1.png "C# switch statement example")

**switch Statement** flowchart

![C# switch statement flowchart](https://miro.medium.com/max/395/0*GN1h08jLuzO-8pyY.png "C# switch statement flowchart")

**Note:** The **default** case is optional and is executed if no other case applies. It's also a common practice to code the **default** label last for easy reading.

In the following example, the value of a number variable is 4. None of the cases matches with the value provided by the switch expression. In this case, the default block is executed which prints out "Unknown number!"

![C#’s switch default](https://miro.medium.com/max/492/0*KIZlL5WVfeLYGu_t.png "C#’s switch default")

[Run Demo](https://dotnetfiddle.net/3Xfb4G)


Iteration Statements
------
Iteration statement (loop) is a block of code that will repeat itself over and over again until a given condition is true or some terminating condition is reached.

There are four looping structures in C# that enable you to execute a block of code multiple times until a certain condition is met.

* for loop
* while loop
* do…while loop
* foreach loop

###for Loop
The C# for loop executes a block of code repeatedly until the condition is **false**. This type of loop is useful when the number of loop iterations is fixed, and the counter variable that determines how many times the loop is going to be executed is needed in the loop.

{% youtube qoHLHVcduYo %}

C# **for loop** structure

![C#’s for loop structure](https://miro.medium.com/max/383/0*aaTSkIikLRehlulD.png "C#’s for loop structure")

C# **for loop** flowchart

![C#’s for loop structure](https://miro.medium.com/max/290/0*CVmvaHSx9iVexvC8.png "C#’s for loop structure")

The C# **for** loop starts with the **for** keyword followed by three expressions separated by semicolons within parentheses.
* The first parameter declares and initializes a counter variable once at the start.
* The second parameter is a condition and is evaluated before each new iteration of the loop.
* The third parameter is an iterator, which prepares the loop for the next iteration.
* Statements are the block of code that you want to execute multiple times in a loop.

####for Loop Example
The following example demonstrates usage of C# **for** loop. It writes out all the integers from 0 to 4.

![C#’s for loop example](https://miro.medium.com/max/284/0*q8_N6bf8piv03Udr.jpg "C#’s for loop example")

[Run Demo](https://dotnetfiddle.net/9z21Mo)

The above code consists of:
1. When the loop is first encountered, C# initializes the **counter** variable `i` with the **int** type and assigns an initial value of 0 to it `(i=0)`.
2. A Boolean condition `(i < 4)` will repeatedly execute until the counter is less than 4.
3. An expression for updating the counter (`i++` meaning **i=i+1**) adds 1 at the end of each repetition of the loop, thus increasing the counter variable by 1.

###while Loop
The C# while loop repeatedly executes a block of code inside the loop while the given logical expression is **true**; otherwise, it breaks. This type of loop is useful when the number of loop iterations does not need to be known before the loop begins, and a counter variable is not needed.

**Note:** Bear in mind that somewhere in the loop, the expression should be changed to false to avoid an inﬁnite or endless loop.

{% youtube etEgbRhl3Ao %}

C# **while loop** structure

![C#’s while structure](https://miro.medium.com/max/287/0*aR72wqd8aaVZwOAP.png "C#’s while structure")

C# **while loop** flowchart

![C#’s while loop flowchart](https://miro.medium.com/max/206/0*fCBGGLw8DaGkFkci.png "C#’s while loop flowchart")

The C# **while** loop starts with the **while** keyword followed by a single expression within parentheses.
* Loop takes only one expression.
* The condition is only evaluated at the beginning of each iteration.
* The condition (Boolean expression) is evaluated before each new iteration of the loop. This must be true in order for the next iteration to be performed. The iterations end when the condition is false.
* Set a Boolean flag to false somewhere in the loop to avoid an inﬁnite or endless loop.
* Loop ends with a semicolon ";".
* Statements are the block of code that you want to execute multiple times in a loop.

####while Loop Example
The code below shows an example of how a C# **while** loop works. It writes out all the integers from 1 to 4.

![C#’s while loop example](https://miro.medium.com/max/410/0*dVRrSO2P74coSKNm.png "C#’s while loop example")

[Run Demo](https://dotnetfiddle.net/jXP3OO)

The above code consists of:
1. Declared and initialized a **counter** variable with the **int** type and assigned an initial value of 0 to it, `counter=0`.
2. The Boolean expression is evaluated, and if it is **true**, then the sequence of operations in the body of the loop is executed.
3. A Boolean condition `(counter < 4)` will repeatedly execute until the counter is less than 4.
4. An expression for updating the counter (`counter++` is a syntactically-shorter version of **counter=counter+1**) adds 1 at the end of each repetition, thus increasing the counter variable by 1.

###do…while Loop
The C# do-while loop is a variant of the **while** loop except for one main difference: it will always execute the loop body at least once in the beginning irrespective of the condition being **true** or **false**. The condition is evaluated at the end of the first execution of the block when the **while** statement is encountered.

**Note:** Bear in mind that somewhere in the loop, the expression should be changed to **false** to avoid an inﬁnite or endless loop.

{% youtube B6FudGf7fAA %}

C# **do-while loop** structure

![C#’s do-while loop structure](https://miro.medium.com/max/362/0*uAeZI4FP4vtQ7Kk4.png "C#’s do-while loop structure")

C# **do-while loop** flowchart

![C#’s do-while loop flow chart](https://miro.medium.com/max/214/0*dxmMmqmTSFSeTrYZ.png "C#’s do-while loop flow chart")

The **do-while** loop starts with the **do** keyword and the loop body. At the bottom of the block is **while** keyword followed by single expression within parentheses ().
* Always executes the loop body at least once, even if the condition fails the ﬁrst time.
* The condition (Boolean expression) is evaluated after each new iteration of the loop. This must be **true** in order for the next iteration to be performed. The iterations end when the condition is **false**.
* Set a Boolean flag to false somewhere in the loop to avoid an inﬁnite or endless loop.
* Loop ends with a semicolon ";".
* Statements are the block of code that you want to execute multiple times in a loop.

####do-while Loop Example
The code below shows an example of how a **do-while** loop works. It writes out all the integers from 1 to 4.

![C#’s do-while loop example](https://miro.medium.com/max/486/0*yUC3uJIqR4DMNONU.png "C#’s do-while loop example")

[Run Demo](https://dotnetfiddle.net/jczQsR)

The above code consists of:
1. Declared and initialized a Counter variable with the **int** type and assigned an initial value of 0 to it, `counter=0`.
2. First time in the beginning, the loop body executes at least once irrespective of the condition being true or false.
3. The Boolean expression is evaluated at the bottom of the code block when encountered.
4. The Boolean condition `(counter < 4)` will repeatedly execute until the counter is less than 4.
5. An expression for updating the counter (`counter++` is a syntactically-shorter version of **counter=counter+1**) adds 1 at the end of each repetition, thus increasing the counter variable by 1.

###foreach Loop
The C# **foreach** loop provides simple syntax to cycle through all the elements in an array or collection unless you explicitly end the loop with the **break** command.

{% youtube k_SmGu7GYYU %}

C# **foreach loop** structure

![C#’s foreach loop structure](https://miro.medium.com/max/361/0*XWw6ASbdhKSpS8MW.png "C#’s foreach loop structure")

C# **foreach loop** flowchart

![C#’s foreach loop structure](https://miro.medium.com/max/397/0*tDAMeHoOlZiSNUBB.png "C#’s foreach loop structure")

The C# **foreach** loop starts with the **foreach** keyword followed by parentheses. See the above images.
* The **type** is used to declare the data-type of the variable. You can use the **var** keyword, which instructs the compiler to infer the type of the item from the type of the collection.
* The item is the looping variable used inside the loop body into which the next element is automatically acquired from the collection on each iteration. The variable (**the iterator**) data-type must be the same as the items in the array or list.
* The collection is the array or list representing a number of values over which you want to iterate.
* The statements are the block of code that executes for each iteration of the loop multiple times.

**Note:** The compiler only allows reading from, not writing to, the collection during the execution of a **foreach** loop.

####foreach Loop Example
If you have more than one statement within the loop, you must enclose the statements in the opening and closing braces. You can use braces with a single statement as well.

```c#
int[] integerValues = { 1, 2, 3, 4 }; 
foreach (int value in integerValues) 
{ 
    System.Console.WriteLine(value); 
}
```

[Run Demo](https://dotnetfiddle.net/E0q3WO)

In the code above, you have an int variable **value** that is used for looping. Each time the loop runs, an element in the `integerValues` array is assigned to the variable **value**. For example, the first time the loop runs, the number 1 is assigned to **value**. It then executes the code within the block that makes up the **foreach** loop body. The line `System.Console.Write(value);` simply prints out the number 1 on the console. In the second iteration, number 2 is assigned and printed out. This continues until all the elements in the array have been printed. This means that the code inside the C# **foreach** loop is called as many times as there are elements in the `integerValues` array. So, if `integerValues` contains 4 elements, the code inside the loop block will be executed 4 times.


String Concatenation
------
A common use of string concatenation (kon-kat-en-ay-shun) is to inject variable values into the string using the string formatting syntax. C# provides the string operator `+` (plus symbol) or the **String.Format** method to format and organize various strings. Both ways can be used to join (concatenate) two or more strings together to generate a new string.

###C# String.Concat( ) and "+"
The variable **result** in the following example would contain the value `a` and `b` after concatenating all the strings.

```c#
int a = 2; 
int b = 5; 

//+ operator concatenates two strings 
string result = "Addition of " + a + " + " + b + " is " + (a + b);
```

Here, `a` and `b` are numeric. Operands that are not of type string will be automatically converted to its string representation by calling the virtual `ToString` method on that operand.

```c#
//+ symbol actually translates to the String.Concat() method 
string result = String.Concat("Addition of ", a, " + ", b, " is ", (a + b));
```
OR
```c#
string result = string.Concat(new object[] {"Addition of ", a, " + ", b, " is ", (a + b)});
```

The C# compiler converts the `+` operator into the static **String.Concat()** method at compile time; there is no real benefit in choosing one method over the other.

###C# String Interpolation (New Way)
C# 6.0 introduced string interpolation which provides another option on how to insert variable values into a string. Now you can insert one or more expressions directly in the string literal just by adding the `$` prefix to output the result in a nicely formatted manner. Interpolated strings are more readable and less error-prone than any other previous methods of formatting strings.

####C# String Interpolation Format
The following example uses string interpolation to create the string **result** using the `$` prefix. A string with a `$` sign can use curly braces `{...}` around the name of a variable to output the value assigned to it at that position in the string. Without the leading `$` symbol, the string `{...}` would be treated as a string literal.

```c#
int a = 2; 
int b = 5; 
string result = $"Addition of {a} + {b} is {a + b}"; // string interpolation
```

[Run Demo](https://dotnetfiddle.net/XJRscp)


Type Conversion
------
Conversion of one type to another is called type conversion. There are two conversion mechanisms supported by C#:

* Implicit Type Conversion
* Explicit Type Conversion

###Implicit Type Conversion (Hidden)
If one type is converted into another type automatically by the **CLR**, it's called implicit type conversion. No special casting syntax is required, and no data is lost during implicit conversion.

C# performs implicit data type conversion when types are compatible, and the compiler knows the conversion is safe. For example, the following code declares an **int** variable and set its value equal to 100. Because an **int** can always fit in a **double**, C# knows this is safe and doesn't complain.

```c#
int i = 786; 
double d = i; // Implicit casting from int to double 
int i = 57; 
// automatic type conversion 
long l = i; 
float f = l; 
char i = '0'; 
int d = i;
```

[Run Demo](https://dotnetfiddle.net/bJSZJz)

###Explicit Type Conversion (Cast)
Explicit conversion is required when the data cannot convert from one simple-type to another automatically by the compiler or when conversion may change the value by producing an incorrect result due to the possible loss of data (**narrowing conversions**). To prevent a compilation error, the compiler requires you to use a cast operator to perform the type conversion.

Let's look at different ways of explicit type conversion in C#.
* Casting
* Converting
* Parsing

####Casting
The parentheses (**( )**) operator is used to explicitly cast one type to another by forcing the compiler to make the conversion. Casting works only between compatible data types, where **CLR** knows how to convert from one type to the other.

To perform a cast, put the target data type inside parentheses in front of the value or variable to be converted. If the cast is successful, it returns a value in that type; otherwise, it throws an exception. Take a look at the following example.

Some of the conversions that cannot be made implicitly:

```c#
long l = 2222; 
// use ( ) operator to convert a type explicitly 
int i = (int)l; // Explicit casting from long to int
```

[Run Demo](https://dotnetfiddle.net/fU8DBp)

####Converting
You can use the **System.Convert** class to perform conversions between base types where implicit or explicit casting isn't possible. This class contains a complete set of static methods for both up level or down level casting and throws an **InvalidCastException** for failed conversions while performing a cast from one type to another.

The string supplied must be a valid representation of a number, and that number must be one that won't cause an overflow. The following code uses the Convert class **ToInt32** method to change the string into an int:

```c#
string val = "786"; 
// Conversion from string to int 
int result = Convert.ToInt32(val); // Return 786
```

[Run Demo](https://dotnetfiddle.net/tMxL7y)

####Parsing
Parsing is used to convert the string type into a primitive value type by using built-in parsers, which are included in all the data structures of the .NET framework. You can use the **Parse** or **TryParse** methods to convert a string representation of a number to an integer, such as the **System.Int32** type.

The **TryParse** method which takes two parameters: the first is the string to be parsed, and the second is an int variable with the **out** keyword to be filled with the value returned if the conversion succeeds.

```c#
string val = "786"; 
int parsedValue; 
bool result = Int32.TryParse(val, out parsedValue); // Return True 
// With Code block 
if (int.TryParse(val, out parsedValue)) {...} else {...}
```

[Run Demo](https://dotnetfiddle.net/MRajIF)

The **Parse** method takes a string as a parameter and returns an int if the string contains an integer value.

```c#
string val = "786"; 
Int32.Parse(val); // Return 786
```

[Run Demo](https://dotnetfiddle.net/8l30qq)


C# Constant, Readonly
------
C# supports two types of constants:

* **Compile-time constants:** The field value of the constant cannot be changed after the initial assignment, and it must, therefore, be assigned a value as it is declared.
* **Run-time constants:** The value of the constant can be assigned during run-time; once it's assigned a value, it can't be changed.

**Note:** A constant can be any of the built-in numeric types, bool, char, string, or an enum type.

###Constant (Compile-time Constants)
For compile-time constants, you can use the **const** keyword before the data type to declare a constant field or a constant local to a method, like this:

![C# Compile-Time Constant](https://miro.medium.com/max/518/0*ZLdaFgDSZ2E50ExW.png "C# Compile-Time Constant")

[Run Demo](https://dotnetfiddle.net/XG0gQV)

The **const** modifier creates a compile-time constant, so the compiler will replace all usage of the constant with its value. Therefore, the value must be assigned at the time of declaration.

###Readonly (Run-time Constants)
For run-time constants, use the **readonly** keyword. For example:

![C#’s Run-Time Constant](https://miro.medium.com/max/606/0*rbkZqSiqXjC4YnlM.png "C#’s Run-Time Constant")

[Run Demo](https://dotnetfiddle.net/UqgiWs)

This modifier may only be applied to fields and can only be initialized either at the declaration or in a constructor but nowhere else.

Please Share This Post With Love ❤️