# .NET C# Guide

## Variables

Examples of declaring several variables are here. There are six variables declared and four of them are initialized using the
*assignment operator* (`=`

).

```
int i = 123, x;
int j;
double d = 1.1;
char ch = 'A';
float f = 1f;
```

Variables can also be initialized with other variables.

```
int i = 123;
int j = i + 10; // j contains 133
int x = i; // x contains 123
```

## Operators

Operators are symbols that tell the compiler to perform a specific mathematical or logical manipulation. Basically, C# has four classes of operators: arithmetic, bitwise, relational and logical.

### Arithmetic Operators

operator | operation |
---|---|

+ | addition |

- | subtraction |

* | multiplication |

/ | division |

% | modulus |

++ | increment |

-- | decrement |

The operators +, -, *, and / all work as expected. The % operator (modulus) returns the remainder of an integer division. Interestingly, it also works with floating-point types which is something that C/C++ cannot do.

#### Increment and Decrement

The operators -- and ++ decrement and increment by one, respectively. They come in two flavors: prefix and postfix. These operators only work on variables. The prefix one works as one would expect.

```
int num = 10;
int i;
i = ++num + 10; // i is 21, num is 11
i = --num + 10; // i is 20, num is 10
```

The postfix increment/decrement operators are not so obvious.

```
int num = 10;
int i;
i = num++ + 10; // i is 20, num is 11
i = num-- + 10; // i is 21, num is 10
```

### The Assignment Operator: =

Consider this example:

```
int a, b, c;
a = b = c = 10; // a, b, and c equal 10
int x, y, z = 3; // z equals 3
x = y = z; // x and y equal 3
z = z + 6; // z equals 9
```

The statement `a = b = c = 10;`

is an example of a chain of assignments.

#### Compound Assignments

Compound assignments simplify the coding of some assignment statments. Consider this example:

```
int i = 0;
i = i + 5; // i equals 5
i += 10; // i equals 15
```

The arithmetic and logical assignment operators are: `+=`

`+=`

`*=`

`/=`

`&=`

`%=`

`^=`

`|=`

### Relational Operators

operator | operation |
---|---|

== | equal to |

!= | not equal to |

> | greater than |

< | less than |

>= | greater than or equal |

<= | less than or equal |

### Logical Operators

operator | operation |
---|---|

& | AND |

| | OR |

^ | XOR |

! | NOT |

|| | short-circuit OR |

&& | short-circuit AND |

#### Short-circuit Operators

Short-circuit AND and short-circuit OR operators are special AND and OR operators. The only difference between the short-circuit and normal versions is that the short-circuit version will evaluate the second operand only when necessary while the normal version always evaluates the second operand.

### Bitwise Operators

operator | operation |
---|---|

& | AND |

| | OR |

^ | XOR |

<< | shift left |

>> | shift right |

~ | unary NOT |

### The Conditional Operator: ?

The ? is a ternary operator because it requires three operands. It's syntax is:

where expression1 is a bool and if true then the entire statement evaluates to expression2 otherwise it's
expression3.*expression1* ? *expression2* :
*expression3*

```
int x = 0, i = 10;
i = (x == 0) ? i : (i / x);
```

### The Coalescing Operator: ??

The coalescing operator uses the syntax `??`

to define a default value for the conversion in case the nullable type has a value of null.
Here, `str2`

receives a value of `string.Empty`

because `str1`

is null.

```
string str1 = null;
string str2 = str1 ?? string.Empty;
```

The operators of C# are almost identical to the JavaScript ones with the exception of
`>>>`

, `===`

, and `!==`

as C# does not have these. And, values of `Infinity`

and `NaN`

do not exist in C#.
Note that JavaScript only supports a few data types unlike C#. The C# operators are identical to the C/C++ ones.

#### Example Program Code

This example uses the short-circuit AND to prevent the numerator from being divided by the denominator which is set to zero.

```
using System;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int numerator = 100;
int denominator = 0; // CANNOT DIVIDE BY ZERO!!!
// first check that denominator is "not equal to" zero
// if it is not then divide numerator by denominator
if ((denominator != 0) && ((numerator / denominator) == 1))
Console.WriteLine("numerator and denominator are equal.");
else
Console.WriteLine("numerator and denominator are not equal.");
}
}
}
```

This example uses the normal AND which will not prevent the numerator from being divided by the denominator which is set to zero. This will result in a divide-by-zero error which will crash the program.

```
using System;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int numerator = 100;
int denominator = 0; // CANNOT DIVIDE BY ZERO!!!
// first check that denominator is "not equal to" zero
// but also evaluate the second operand thereby dividing
// the numerator by the denominator crashing the program
if ((denominator != 0) & ((numerator / denominator) == 1))
Console.WriteLine("numerator and denominator are equal.");
else
Console.WriteLine("numerator and denominator are not equal.");
}
}
}
```

### Operator Precedence

Highest Precedence() [] . ++(postfix) --(postfix) checked new sizeof typeof unchecked ! ~ (cast) +(unary) -(unary) ++(prefix) --(prefix) * / % + - << >> < > <= >= is == != & ^ | && || ?: = += -= *= /= %= &= |= ^=Lowest Precedence

## Parentheses

Just like in algebra, parentheses increase the precendence of the operations contained with in them.

```
int i = 20 / 2 * 5; // i equals 50
int j = 20 / (2 * 5); // j equals 2
```

## Type Casting

Casting instructs the compiler to convert one type into another. Put the cast inside parentheses as follows.

```
double d = 1000.1;
int i = (int)d; // (int) is the cast; now i equals 1000
byte b = (byte)i; // b cannot fit 1000 so data is lost (b equals 232 because 2 bits were lost)
```

Also, casting can be done at runtime using the `as`

keyword. If the cast succeeds then a reference to type is returned otherwise
`null`

is returned.

## Type Identification

It is possible to determine an object's type at runtime using the keywords `is`

and `typeof`

.

To determine if an object is a certain type use the `is`

operator.

```
using System;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
string s = string.Empty;
object o = s;
int[] n = { 1, 2, 3 };
if (s is string)
Console.WriteLine("s is a string");
else
Console.WriteLine("s is not a string");
if (s is object)
Console.WriteLine("s is an object");
else
Console.WriteLine("s is not an object");
if (o is string)
Console.WriteLine("o is a string");
else
Console.WriteLine("o is not a string");
if (o is object)
Console.WriteLine("o is an object");
else
Console.WriteLine("o is not an object");
if (n is string)
Console.WriteLine("n is a string");
else
Console.WriteLine("n is not a string");
if (n is object)
Console.WriteLine("n is an object");
else
Console.WriteLine("n is not an object");
if (n is Array)
Console.WriteLine("n is an Array");
else
Console.WriteLine("n is not an Array");
}
}
}
```

Using `typeof`

:

```
using System;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Type t;
t = typeof(Console);
Console.WriteLine(t.FullName);
t = typeof(Program);
Console.WriteLine(t.FullName);
}
}
}
```