.

NET
The “Hello World” in C#
using System;
class Hello
{
static void Main(string[] args)
{
Console.WriteLine("Hello world!");
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine("args[{0}] = {1}",
i, args[i]);
}
}
}

2
Main
Formy Main

static void Main() {…}

static void Main(string[] args) {…}
static int Main() {…}
static int Main(string[] args) {…}

3
Value Types
and Reference Types
int i = 123;
string s = "Text";

stack heap

i 123

s Text

4
Value type
• A variable of a value type contains an instance of the type
• Values are copied by default, on
• assignment
• passing an argument to a method
• returning a method result

• Struct
• Enum
• Tuple

• Might be generic
• All value types implicitly inherit from the class System.ValueType (seled
class)
• default constructor - parametrless instance constructor - returns a zero-
initialized instance (default value)
• Default constructor can be invoked
class Test
{
void F()
{
int i = 0;
int j = new int();
}}
Simple types
• Aliases for predefined struct types in the System namespace
Reference type
• String
• Arrays
• Class
• Delegate

• Default value
• null
Boxing
int i = 123;
object o = i;

stack heap
i 123

o System.Int32
123
 The process of converting a value type to the type object or to any interface type
implemented by this value type 9
 Object -> value type -> needs conversion
Boxing
• C#'s type system is unified, a value of any type can be treated as an
object
• Values of value types are treated as objects by performing boxing and
unboxing operations
C# Data Types
• object – reference to object
• string – sequence of Unicode characters
• byte, sbyte – 8-bit integer value
• short, ushort – 16-bit integer value
• int, uint – 32-bit integer value
• long, ulong – 64-bit integer value
• float, double – floating-point number
• bool – logical value (true or false)
• char – Unicode character
• decimal – fixed-point decimal number
11
Floating-point numeric types
• Float
• Range ±1.5 x 10−45 to ±3.4 x 1038
• Precision ~6 – 9 digits
• Double
• Range ±5.0 × 10−324 to ±1.7 × 10308
• Precision ~15-17 digits

• represent real numbers

• value types
• simple types (build-in)
• All simple types in c# are structure types
• Can be initialized with literals

• supported operators
• arithmetic
• comparison
• equality operators
double
• Double precision 64 bit number
• from negative 1.79769313486232e308 to positive 1.79769313486232e308
• positive or negative zero,
• PositiveInfinity,
• NegativeInfinity,
• not a number (NaN)
Part Bits
Significand or mantissa 0-51
Exponent 52-62
Sign (0 = Positive, 1 = Negative) 63
Floating point representation
double value = .1;
double result1 = value * 10;
double result2 = 0;
for (int i = 1; i <= 10; i++)
result2 += value;

Console.WriteLine(".1 * 10: {0:R}", result1);

Console.WriteLine(".1 Added 10 times: {0:R}", result2);

// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
Double.Epsilon
• Double.Epsilon - 4.94065645841247E-324 - the smallest positive Double value that is greater than zero

double[] values = { 0, Double.Epsilon, Double.Epsilon * .5 };

for (int i = 0; i <= values.Length - 2; i++) {

for (int j = i + 1; j <= values.Length - 1; j++) {
Console.WriteLine("{0:r} = {1:r}: {2}",
values[i], values[j],
values[i].Equals(values[j]));
}
Console.WriteLine();
}
// 0 = 4.94065645841247E-324: False
// 0 = 0: True -> zero and half value of epsilon are considered to be equal
// 4.94065645841247E-324 = 0: False
! Epsilon is not a general value for the precision of Double, precision of double vary, it is based on exponent.
Floating point comparision
• Avoid equal operator (=)
• Code example
double double1 = .333333;
double double2 = (double) 1/3;

//tolerance
double difference = Math.Abs(double1 * .00001);

// Compare the values

if (Math.Abs(double1 - double2) <= difference)
Console.WriteLine(“Values are equal.");
else
Console.WriteLine(“Values are not equal.");

• Warning: acceptable margin of difference depends on the magnitude of the Double values
• Math.Round(Double, Int32) - also can be applied (rounds double to selected precision)
Floating point representation
• Floating-point numbers have a limited number of significant digits
• real value approximation
• Some floating-point operations may lack the precision to change a floating
point value

double v = 123456789012.34567;
double add = Double.Epsilon * 1e15; //4.94065645841247E-324 * 1e15
Console.WriteLine("{0} + {1} = {2}", value, additional,
value + additional);
//123456789012.346 + 4.94065645841247E-309 = 123456789012.346
Floating point special values
• Double.PositiveInfinity,
• Double.NegativeInfinity
• Double.PositiveInfinity,
• Double.NegativeInfinity,
• Double.NaN
Decimal
• Decimal
• decimal floating point number
• 128-bit data type
• has more precision and a smaller range than floating point types
• Range
• ±1.0 x 10-28 to ±7.9228 x 1028
• 79,228,162,514,264,337,593,543,950,335
• Precision
• 28-29 significant digits

decimal myMoney = 300.5m

19
Decimal
• Type does not eliminate the need for rounding.
• It minimizes errors due to rounding.

decimal dividend = Decimal.One;

decimal divisor = 3;
Console.WriteLine(dividend/divisor * divisor);
// 0.9999999999999999999999999999

when Math.Round is utilized

decimal dividend = Decimal.One;
decimal divisor = 3;
Console.WriteLine(Math.Round(dividend/divisor * divisor, 2));
// 1.00
Decimal
• Composition
• 1-bit sign,
• 96-bit integer number,
• 31-bit scaling factor
• used to divide the 96-bit integer
• specifies what portion of it is a decimal fraction
Decimal
• Decimal
• Casting double

decimal myMoney = 99.9m;

double x = (double)myMoney;
myMoney = (decimal)x;

22
Arithmetic overflow and division by zero
• Integer arithmetic overflow
• Division by zero: DivideByZeroException
• Overflow: checked: OverflowException
• Floating-point arithmetic overflow
• Never throws exceptions
• Decimal
• Division by zero: DivideByZeroException
• Overflow: always: OverflowException
float / double behaviour
double a = 1.0 / 0.0; Console.WriteLine(a); // Infinity
Console.WriteLine(double.IsInfinity(a)); // True
Console.WriteLine(double.MaxValue + double.MaxValue); // Infinity

double b = 0.0 / 0.0; Console.WriteLine(b); // NaN

Console.WriteLine(double.IsNaN(b)); // True
Round off errors
Console.WriteLine(.41f % .2f); // output: 0.00999999

double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3); // output: False
Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17

decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m); // output: False
Console.WriteLine(d); // output: 0.9999999999999999999999999999
System.Numerics
• Additional datatypes
BigInteger
• public struct BigInteger : IComparable,
IComparable<System.Numerics.BigInteger>,
IEquatable<System.Numerics.BigInteger>, IFormattable

• Immutable – when the value is modified, new memory is allocated

• There is no upperbound – OutOfMemoryException can be thrown
BigInteger
• Assign value through constructor
BigInteger bigIntFromDouble = new BigInteger(17903233.6541);
BigInteger bigIntFromInt64 = new BigInteger(91544347136952);
long longValue = 34838499;
BigInteger assignedFromLong = longValue;

• Assign value through cast

BigInteger assignedFromDouble = (BigInteger) 43432.2343;
BigInteger assignedFromDecimal = (BigInteger) 43234.434m;

• Parse from string

• BigInteger parsed = BigInteger.Parse(“84738274836574838974853457834");

• Can be converted to byte array and restored from byte array

BigInteger
• Predefined values
• BigInteger.MinusOne
• BigInteger.Zero
• BigInteger.One
BigInteger - operations
• addition, subtraction, division, multiplication, subtraction, negation,
and unary negation
• bitwise And, Or, XOr, left shift, and right shift operators
• Pow / Log / Log10 / Max / Min /
• Sign (sign of BigInteger)
• Abs
• DivRem (returns both the quotient and remainder of a division
operation)
• GreatestCommonDivisor
BigInteger
• IsEven
• InOne
• InPowerOfTwo
• IsZero
BigInteger
BigInteger number = BigInteger.Multiply(Int64.MinValue, 4);
number--;
Console.WriteLine(number);
Complex
• Represents a complex number
• public struct Complex : IEquatable<System.Numerics.Complex>,
IFormattable

• Properties
• Real (double)
• Imaginary (double)
• Properties are read only, all methods that performs actions return
new Complex number
Complex - constructor
//Call constructor
Complex c1 = new Complex(12, 6);
// From Double
Complex c2 = 3.14;
// Through cast
Complex c3 = (Complex) 12.3m;

// Assign the return value of a method.

Complex c4 = Complex.Pow(Complex.One, -1);

// The value returned by an operator.

Complex c5 = Complex.One + Complex.One;

// Based on its polar coordinates.

Complex c6 = Complex.FromPolarCoordinates(10, .524);
Complex – useful Fields and Properties
• ImaginaryOne
• Infinity
• NaN
• One
• Zero
• Imaginary
• Real
• Magnitude (absolute value of a complex number)
• Phase
Matrix 3x3 / Matrix 4x4
• Represents a 3x2 or 4x4 matrix
• public struct Matrix3x2 : IEquatable<System.Numerics.Matrix3x2>
• public struct Matrix4x4 : IEquatable<System.Numerics.Matrix4x4>
• Useful for graphic programming contexts
• for coordinate transformations
• Libraries like Win2D
Methods / Operators
• Add
• Multiply
• Negate
• Substract

• Equality

• CreateRotation
• GetDeterminant
Default values
• int i = default; // 0 pre C# 7.1 int i = default(int);
• float f = default;// 0
• decimal d = default;// 0
• bool b = default;// false
• char c = default;// '\0'
System.Math
• Constants
• Static methods for
• trigonometric
• logarithmic
• Other common mathematical functions
• Abs etc.

• MathF – for floats (Single)

Arithmetic operators
•+
•-
•*
•/
• x % y for integer based type result of x - (x / y) * y
.Net data types
Alias .NET Type
byte System.Byte
sbyte System.SByte
int System.Int32
uint System.UInt32
short System.Int16
ushort System.UInt16
long System.Int64
ulong System.UInt64
float System.Single
double System.Double
char System.Char
bool System.Boolean
object System.Object
string System.String
decimal System.Decimal
DateTime System.DateTime

41
Implicit (automatical) numeric conversions
From To

sbyte short, int, long, float, double, or decimal

byte short, ushort, int, uint, long, ulong, float, double, or decimal

short int, long, float, double, or decimal

ushort int, uint, long, ulong, float, double, or decimal

int long, float, double, or decimal

uint long, ulong, float, double, or decimal

long float, double, or decimal

char ushort, int, uint, long, ulong, float, double, or decimal

float double

ulong float, double, or decimal

42
Automatic Type Conversions
sbyte char byte

short ushort

int uint

long float ulong

double

decimal
43
Explicit numeric conversions
From To
sbyte byte, ushort, uint, ulong, or char

byte Sbyte or char

short sbyte, byte, ushort, uint, ulong,
or char
ushort sbyte, byte, short, or char

int sbyte, byte, short, ushort, uint, ulong,

or char
uint sbyte, byte, short, ushort, int, or char

long sbyte, byte, short, ushort, int, uint, ulo

ng, or char

ulong sbyte, byte, short, ushort, int, uint, lon 44

g, or char
char sbyte, byte, or short
float sbyte, byte, short, ushort, int, uint, long, ulong, char,or d
ecimal

double sbyte, byte, short, ushort, int, uint, long, ulong, char, floa
t,or decimal

decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, floa
t, or double

45
Value range
• // compile time error: Cannot implicitly convert type 'long' to 'int'.
• int i = 21474236473;
Value suffix
• uint ui = 120u;
• float fl = 11.2f;
• long l = 4533554522222l;
• ulong ul = 457554523333222ul;
• double d = 11452223.555d;
• decimal mon = 1320.15m;
Scientific notation
• double d = 0.32e2;
• Console.WriteLine(d); // 32;

• float f = 333.45e-2f;
• Console.WriteLine(f); // 3.3345

• decimal m = 5.2e6m;
• Console.WriteLine(m);// 5200000
Strings
• Series of characters
• Maximus size of a string in memory: 2GB
• Immutable
• Syste.String vs string
• no difference

char[] c = {'T','e','s','t'};

string s1 = new string(chars);

String s2 = new String(chars);

foreach (char c in str1)

{
Console.WriteLine(c);
}
Strings
• Escape character \
• Escape sequence @
string str = @"test\sdfd";
string path = @"c:\test";

string s = @"multi \
line \
string";
Strings
string s1 = “Some text”;
string s2 = “c:\\temp\\myfile.dat”;
string s3 = @“c:\temp\myfile.dat”; // immediate
// string
// Length
int len = s1.Length;

// Concatenation
s1 = s1 + “ i psa”;

// Indexing
for (int i = 0; i < s1.Length; i++)
Console.WriteLine(„Znak {0} = {1}”, i, s1[i]);

51
Basic Strings Operations
string s1 = „Tekst”, s2 = „tekst”;
// Case-sensitive comparison
bool cmp1 = s1 == s2;
bool cmp2 = String.Compare(s1, s2) == 0;
// Case-insensitive comparison
bool cmp3 = String.Compare(s1, s2, true) == 0;

// Searching
int i1 = s1.IndexOf(“pattern”);

// Copying a substring
string substr = s1.Substring(2, 4);

// Replacing
s1 = s1.Replace(“old”, “new”);
52
String operations
String.IsNullOrEmpty(s1);
String.IsNullOrWhiteSpace(s1)

String.Split
String.Join

String.Contains
String.StartsWith
String.EndsWith
String.LastIndexOf
String.IndexOfAny
String.LastIndexOfAny
String.Equals
String operations
String.PadLeft / String.PadRight

String.Remove

String.ToLower
String.ToLowerInvariant
String.ToUpper
String.ToUpperInvariant
String interpolation (C# 6)
string name = “Test";
var date = DateTime.Now;

// Composite formatting:
Console.WriteLine("Hello, {0}! Day:{1}, current time:
{2:HH:mm}.", name, date.DayOfWeek, date);

// String interpolation:
Console.WriteLine($"Hello, {name}! Day: {date.DayOfWeek},
current time: {date:HH:mm}.");

// The same output for both calls

// Hello, Test! Day: Wednesday, current time: 19:40.

Waring: There can’t be any white space between the $ and

the " that starts a string literal.
55
String interpolation (C# 6)
 Item structure

 {<interpolationExpression>[,<alignment>][:<formatString>]}

Console.WriteLine($"|{"Left",-7}|{"Right",7}|");

const int RightAlignment = 20;

Console.WriteLine($"{Math.PI, RightAlignment} - default
formatting");
Console.WriteLine($"{Math.PI,RightAlignment:F3} - only three
decimal digits displayed");

// Expected output is:

// |Left | Right|
// 3.14159265358979 - default formatting
// 3.142 - only three decimal digits displayed

56
String interpolation (C# 6)
 Brace, "{" or "}", in interpolated string,
 use two braces, "{{" or "}}".

 Colon (":") has special meaning in an interpolation expression item,

 enclose that expression in parentheses.

string name = “TestUser";

int age = 34;
Console.WriteLine($“Test sentence, \“Your name is {name}?\"");
Console.WriteLine($"{name} is {age} year{(age == 1 ? "" : "s")} old.");
// Expected output is:
// Test sentence, “Your name is TestUser?",
// TestUser is 34 years old.

57
String Intern Pool
• Special table allocated on Large Object Heap
• Maintains all references to strings literals that are created by application
string string1 = "This is a string";
string string2 = "This is a string";

if((object)string1 == (object)string2)
Console.WriteLine("The references of string1 and string2 are equal");
else
Console.WriteLine("The references of string1 and string2 are unequal");

Console.ReadKey(true);

//Console: The references of string1 and string2 are equal

String Intern Pool
• However

string string1 = "This is a string";

string string2 = new StringBuilder().Append("This is a string").ToString();

if((object)string1 == (object)string2)
Console.WriteLine("The references of string1 and string2 are equal");
else
Console.WriteLine("The references of string1 and string2 are unequal");

Console.ReadKey(true);

//Console: The references of string1 and string2 are unequal

String Intern Pool
• Get reference to interned string

string string2 = string.Intern(new StringBuilder().Append("This is a

string").ToString());

• Issue: in order to get reference, string needs to be created, later it is

GCCollected
String Intern Pool
• Memory consideration: according to the documentation:
• Memory allocated for interned String objects is not likely to be released until the common language runtime (CLR)
terminates.
• CLR's reference to the interned String object can persist after your application, or even your application domain, terminates.
• Use: CompilationRelaxations.NoStringInterning at the level of the assembly in order to disable

[assembly:CompilationRelaxationsAttribute(CompilationRelaxations.NoStringInterning)]
class Program
{
static void Main(string[] args)
{
Console.WriteLine("The CompilationRelaxationsAttribute activated.");
}
}
Operators
• Arithmetic: + - * / %
• Logical: & | ^ ! ~ && || true false
• String concatenation: +
• Incrementation and decrementation: ++ --
• Bitwise shift: << >>
• Comparisons: == != < > <= >=
• Assignments: = += -= *= /= %= &= |= ^= <<= >>=
• Member access and indexing: . []
• Type cast: () as
• Conditional operator: ?: ??
• Creating objects, type information: new is sizeof typeof

63
Checked Statement
static void Main(string[] args)
{
int x = Int32.MaxValue;

Console.WriteLine(x + 1); // overflow

// without exception
checked {
Console.WriteLine(x + 1); // exception !!!
}
unchecked {
Console.WriteLine(x + 1); // overflow
// without exception
}
}

64
Checked statement
int a = int.MaxValue;
int b = 5;

Console.WriteLine(unchecked(a + b)); // output: -2147483644

try
{
int d = checked(a + b);
}
catch(OverflowException)
{
Console.WriteLine("Overflow occurred.");
}
Namespaces
namespace MyNamespace
{
namespace Inner
{
class MyClass
{
public static void F() {}
}
}
} using System;
using NamespaceAlias = MyNamespace.Inner;

static void Main()

{
NamespaceAlias.MyClass.F();
}
66
Namespaces
• global namespace is the “root” namespace e.g. global::System referes
to .NET System namespace
• global::System.Console.WriteLine("Using global alias");
Constants and Variables
static void Main()
{
// constants
const float r = 12.5;
const float pi = 3.14f;

// variables
int a = 12, b = 1;
int c;
//initialize only once
Public readonly double pi = 3.14

c = 2;
Console.WriteLine(a + b + c);
Console.WriteLine(pi * r * r);
}
68
const keyword vs readonly keyword
 const
 Cannot use static keyword (howevet they are accessed as
static field, the value is the same for all instances)
 Are related to the whole class not single instace
 Value is assigned during compilation
 Value can be set only in declaration
 Can be used in switch case
 Only certain types can be const
 Only build in types (excluding System.Object) can be const
 string / dynamic / int …

 ReadOnly
 Can be proceeded with static keyword
 Processed during runtime
 Can be initialized at the level of declaration
as well as Constructor

69
Enumerations
enum Color
{
Red,
Green = 10,
Blue
}

static void Main(string[] args)

{
Color c = Color.Green;

DrawBox2D(10, 20, c);

DrawBox2D(12, 10, Color.Blue);
}

70
Enumerations
enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

 Base type:
 Integral based

enum Days : byte {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

 All references to the individual values of an enum are converted to numeric literals at
compile time

71
Enumerations
Conversion

public class EnumTest

{
enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

static void Main()

{
int x = (int)Days.Sun;
int y = (int)Days.Fri;
Console.WriteLine("Sun = {0}", x);
Console.WriteLine("Fri = {0}", y);
}
}

72
 Enumerations
FlagsAttribute
Indicates that an enumeration can be treated as a bit field; that is, a set of flags; not required
Helps IDE
[Flags]
public enum CarOptions
{
// The flag for SunRoof is 0001.
SunRoof = 0x01,
// The flag for Spoiler is 0010.
Spoiler = 0x02,
// The flag for FogLights is 0100.
FogLights = 0x04,
// The flag for TintedWindows is 1000.
TintedWindows = 0x08,
}
class FlagTest
{
static void Main()
{
// The bitwise OR of 0001 and 0100 is 0101.
CarOptions options = CarOptions.SunRoof | CarOptions.FogLights;
// Because the Flags attribute is specified, Console.WriteLine displays
// the name of each enum element that corresponds to a flag that has
// the value 1 in variable options.
Console.WriteLine(options);
// The integer value of 0101 is 5.
Console.WriteLine((int)options);
}
} 73
Enumerations – get underlying type

• Enumeration type

var isInt = Suit.Diamonds is int; // false

var isEnum = Suit.Diamonds is Enum; // true
var baseType = typeof(Suit).BaseType; // Enum

// the underlying type is accessible

var underlyingType = typeof(Suit).GetEnumUnderlyingType();
// int
// alternativelly: Enum.GetUnderlyingType(Type)

74
Enumerations
• Enum to string
var text = Suit.Clubs.ToString(); // "Clubs"
var text2 = Enum.GetName(typeof(Suit), Suit.Clubs); // "Clubs"
var text3 = typeof(Suit).GetEnumName(Suit.Clubs); // "Clubs„

• String to Enum

Enum suit = Enum.Parse(typeof(Suit), "Diamonds"); // Suit.Diamonds

Enum suit2 = Enum.Parse(typeof(Suit), "0"); // Suit.Diamonds

Suit suit3;
var success = Enum.TryParse("NotASuit", out suit3); // false

75
Enumerations
• Get values - Array

Array values = Enum.GetValues(typeof(Suit)); // [Spades, Hearts, Diamonds, Clubs]

76
 Enumerations – Extension methods
• Can’t add custom methods to an enum type directly
• Solution:
• Extension methods
public static Color GetColor(this Suit @this)
{
switch (@this)
{
case Suit.Spades:
case Suit.Clubs:
return Color.Black;
case Suit.Diamonds:
case Suit.Hearts:
return Color.Red;
default:
throw new ArgumentException("Unexpected suit " + @this, "this");
}
}
77
var color = Suit.Hearts.GetColor(); // Color.Red
 Enumerations
• A variable of an enum value can hold any value of the underlying type, not just one of the
named values
• Type-Safe: NO

Suit notARealSuit = (Suit)5; // no error

var text = notARealSuit.ToString(); // "5"

// enum values can be verified with Enum.IsDefined()

var isASuit = Enum.IsDefined(typeof(Suit), notARealSuit); // false

78
 Enumerations – custom attributes
[Flags]
enum BookFlags
{
...
[Description("Hard cover")]
HardCover = 1
...
}

// Extension method – attribute value retrieval -> through Reflection mechanism

public static T GetAttribute<T>(this Enum enumVal) where T:System.Attribute
{
var type = enumVal.GetType();
var memInfo = type.GetMember(enumVal.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(T), false);
return (attributes.Length > 0) ? (T)attributes[0] : null;
}

var description = BookFlags.HardCover

.GetAttribute<DescriptionAttribute>().Description; // "Hard cover"

79
Enumeration - Alias

enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

Alias for Sun

enum Days { Sun, Mon = Sun, Tue, Wed, Thu, Fri, Sat };

enum Days { Sun, Mon = 0, Tue, Wed, Thu, Fri, Sat };

80
Enumeration –operators

+
Enum + literal / variable of enum underlying type
++
--

Returns enum

-
enum-enum
return number

Bitwise
^, &, |, ~ 81