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

# Integer
An _integer_ is a number that does not have any decimal places. It is a whole number, for example, **1,2,3,4** are all integers. **4.3** is not. If you were to try and place the number **4.3** into an integer, the number would​ be truncated to **4**.

There are further different types in an integer as well. All of them differ in size which we'll discuss further down the lesson.

Let’s take a look at them one by one.

using System;

namespace VariablesExampleOne
{
    class Program
    {
        static void Main(string[] args)
        {
            sbyte a = -128; 
            Console.WriteLine("The variable a contains " + a);
            byte b = 255;
            Console.WriteLine("The variable b contains " + b);
            short c = 32767;
            Console.WriteLine("The variable c contains " + c);
            ushort d = 65535;
            Console.WriteLine("The variable d contains " + d);
            int e = 2147483647;
            Console.WriteLine("The variable e contains " + e);
            uint f = 4294967295;
            Console.WriteLine("The variable f contains " + f);
            long g = 9223372036854775807;
            Console.WriteLine("The variable g contains " + g);
            ulong h = 18446744073709551615;
            Console.WriteLine("The variable h contains " + h);
        }
    }
}

# Float
Floats are _floating point_ numbers with a storage size of `4 bytes`, which means that these numbers can hold decimal places. This allows us to store numbers such as **“8.344”** and **“34353.24123”**.

Let's go through different types of floats:

using System;

namespace VariablesExampleOne
{
    class Program
    {
        static void Main(string[] args)
        {
            float i = 256.4788f; 
            Console.WriteLine("The variable i contains " + i);
            double j = 2545645645.6647; 
            Console.WriteLine("The variable j contains " + j);
            decimal k = 0.33333333333333333333333333357m; 
            Console.WriteLine("The variable k contains " + k);
        }
    }
}

# Char
A `char` is a **16-bit** data type. This means that a `char` can store between **U+0000 and U+FFFF**. `char` are commonly used to store text in _UTF-16_ (Unicode) format. A `char` can be initialized to hold either a number or a character, but it will store only the _Unicode_ value.

using System;

namespace VariablesExampleOne
{
    class Program
    {
        static void Main(string[] args)
        {
            char a = 'a'; 
            Console.WriteLine("The variable a contains " + a);
        }
    }
}

> **Note:** _ASCII_ is a system where a numerical value is assigned to every character you can think of. For a complete conversion chart visit http://ascii-code.com/

# Boolean
The `bool` (boolean) type is a 1-byte data type that is either true or false. A true being any number other than zero and false being zero. The true keyword uses the value 1 to assign true.

using System;

class BooleanExample {
  static void Main() {
    bool canJump = false;
    bool canDo = true;
    Console.WriteLine("Value of canJump is: {0}", canJump);
    Console.WriteLine("Value of canDo is: {0}", canDo);

  }
}

# Sizes

This table portrays how the variable sizes vary with the variable types.

|  **C# Alias**  |  **Size (bits)**   |   **Range**  |
| --- | --- | --- |
|  `sbyte`  | 8    |  -128 to 127   |
|  `byte`   |   8  |  0 to 255   |
|  `short`   |  16   |  -32,768 to 32,767   |
|  `ushort`  |  16  |  0 to 65,535   |
|  `char`  | 16  |  A unicode character of code 0 to 65,535  |
|  `int`  |  32   |  -2,147,483,648 to 2,147,483,647   |
|  `uint`  | 32  |  0 to 4,294,967,295  |
|  `long`  | 64  |  -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
|  `ulong`  | 64   | 0 to 18,446,744,073,709,551,615  |
|   <br>`float`  |  32  | $1.5 ×$ $10^{-45}$ to $3.4 ×$ $10^{38}$   |
|  `double` |  64 |  $5.0 ×$ $10^{-324}$ to $1.7 ×$ $10^{308}$ |
|  `decimal`  |  128 |  $1.0 ×$ $10^{-28}$ to $7.9 ×$ $10^{28}$   |
|  <br>`bool`  |  8   |  true or false  |
|   `string`  |  16*length  |   A unicode string with no special upper bound.  |
|  `object`  |  32/64  |  Platform dependent (a pointer to an object).   |

$$$$

## Stay away from any possible error!
If you'll try to store some value that exceeds the specific range of a variable type, you'll get a runtime error:


This lesson gives an overview of all the types of variables in C# like int, bool, double, char and float and much more!

Introduction

Variables and Casting

Operators

Conditions

Loops

Arrays

Methods

Exception Handling

Classes

OOP in C#

Delegates

C# Exam

Variable Types

Integer

Float