Operators, Variables and Data Types

visual studio online


Variable values can be of various types (e.g, integer, decimal, or character) in C#. The type-safe feature of the language causes the compiler to confirm a correct data type for a variable's value. The compiler also rejects inappropriate operations on variables such as addition with a boolean variable. C# allows users to change variables.

The syntax of a variable declaration follows:


Review an example below:

int IDnumber = 7895436;

Variables can also be declared using the var keyword, which tells the compiler to infer its data type:

var maximumAmount = 1,000,000;

When declared, a variable cannot be declared with a new data type or assigned an incompatible value, however, its type can be converted through lossless polymorphism.

C# variables are classified as static, instance, or local variables. Static variables, which use the static keyword, are global variables. Instance variables only exist on the creation of a new class instance. Local variables only exist within their block


C# is a strongly typed language;thus, every constant, expression, and variable must have a data type. All method signatures must specify the data type of parameters and return values. C# offers a set of built-in numeric types and a broader set of more complex types covering constructs like network connections, arrays, and dates.

Two important aspects of types in the .NET framework follow:

  1. It supports inheritance. Types can come from parent types (i.e., “base” types).
  2. Each type falls in the category of either a value type or a reference type. Types defined through the struct keyword are value types. All native numeric types are structs. Types defined through the class keyword are reference types. Different rules are associated with each category.

Certain types have distinction:

  1. Object type – This reference type serves as the ultimate and incredibly versatile base class for every data type within C#.
  2. String type – This reference type allows for all string values to be assigned to a variable.
  3. Dynamic type - This reference type stores virtually any kind of value.
  4. Pointer type – Variables of this type hold the memory address of a type, and offer the same capabilities of C and C++ pointers.


Operators offered by C# include the following types:

Primary Operators
x.y Allows access to members
x?.y Provides conditional member access
Allows array and indexer access
Allows conditional array and indexer access
x++ post-increment
x-- post-decrement
new T(..)
new T(..){..}
new T[..]
Creates objects and delegates
Creates objects with an initializer
Provides an anonymous initializer
Creates an array
typeof(T) Gets the System.Type object for T
checked(x) Performs a checked evaluation
unchecked(x) Performs an unchecked evaluation
default(T) Gets the default value of type T
delegate{} An anonymous function (and method)
Unary Operators
+x Identity
-x Negation
Logical negation
~x Bitwise negation
++x pre-increment
(T)x Converts x explicitly to type T
Multiplicative Operators
* Multiplication
/ Division
% Remainder
Additive Operators
x + y Subtraction, removal of delegates
Shift Operators
x<<y Left shift
x>>y Right shift
Type and Relational Operators
x<y Less than
x>y Greater than
x <= y Less than or equal
x >= y Greater than or equal
x is T If x is a T, return true, otherwise false
x as T Return x as type T, or null if x is not T type
Equality Operators
x == y Equal
x != y Not equal
Logical, Conditional, and Null Operators
AND (logical) x & y Boolean AND, Integer bitwise AND
XOR (logical) x ^ y Boolean XOR, Integer bitwise XOR
OR (logical) x | y Boolean OR, Integer bitwise OR
AND (conditional) x && y If x is true, it evaluates y
OR (conditional) x || y If x is false, it evaluates y
Null coalescing x ?? y If x is null, it evaluates to y, else x
Conditional x ? y:z If x is true, it evaluates to y, else z
Assignment and Anonymous Operators
= Assignment
x operator = y Compound Assignment (+=, *=, etc.)
(T x) => y Lambda expression (anonymous function)

Expressions evaluate from left to right, but parentheses change the order dictated by operator precedence. Note that parentheses do not override a right associative operator such as “=”.