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: expression1 ? expression2 :
expression3
where expression1 is a bool and if true then the entire statement evaluates to expression2 otherwise it's
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);
}
}
}
Reader Postings:
log in to post comments