C# Starter L03-Utilities

Mohammad Shaker
mohammadshaker.com
C# Programming Course
@ZGTRShaker
2011, 2012, 2013, 2014
C# Starter
L03 – Utilities

Today’s Agenda
• const and readonly
• Casting
– Direct Casting
– as Keyword
• is Keyword
• enums
• Exception Handling
• UnSafe Code
• Nullable Types
• using Keyword
• Files
• Class Diagram
• Windows Forms

const and readonly
• const
– Must be initialized in the time of declaration
• readonly
– keyword is a modifier that you can use on fields. When a field declaration includes
a readonly modifier, assignments to the fields introduced by the declaration can only occur as
part of the declaration or in a constructor in the same class.
public const int WEIGHT = 1000;
public readonly int y = 5;

const and readonly
• const
– Must be initialized in the time of declaration
• readonly
– keyword is a modifier that you can use on fields. When a field declaration includes
a readonly modifier, assignments to the fields introduced by the declaration can only occur as
part of the declaration or in a constructor in the same class.
public const int WEIGHT = 1000;
public readonly int y;

Casting
Direct Casting “as” Keyword

void Example(object o)
{
// Casting
string s = (string)o; // 1 (Direct Casting)
// -OR-
string s = o as string; // 2 (Casting with “as” Keyword)
// -OR-
string s = o.ToString(); // 3 Calling a method
}
Casting
• What’s the difference? Output?

{
// Casting
// -OR-
// -OR-
}
Casting
Number (“1”)
• If (o is not a string) Throws InvalidCastException if o is not a string.
• Otherwise, assigns o to s, even if o is null.

{
// Casting
// -OR-
// -OR-
}
Casting
Number (“2”)
• Assigns null to s if o is not a string or if o is null.
• Otherwise assign to s “CAN’T BE A NULL VALUE”
For this reason, you cannot use it with value types.

{
// Casting
// -OR-
// -OR-
}
Casting
Number(“3”)
• Causes a NullReferenceException of o is null.
• Assigns whatever o.ToString() returns to s, no matter what type o is.

{
// Casting
// -OR-
// -OR-
}
Casting
1. Throws InvalidCastException if o is not a string. Otherwise, assigns o to s, even if o is null.
2. Assigns null to s if o is not a string or if o is null. Otherwise, assigns o to s. For this reason, you cannot use it with
value types.
3. Causes a NullReferenceException of o is null. Assigns whatever o.ToString() returns to s, no matter what type o is.

{
// I swear o is a string, C# compiler! I’m ordering you to cast, I know what am doing!
// I Donna know whether o is a string or not, try a cast and tell me!
// Am programming badly with this code!
}
Casting
• Meaning!

{
}
Casting
• Meaning!
“as” casting will never throw an exception, while “Direct cast” can.

{
}
Casting
• Meaning!
“as” casting will never throw an exception, while “Direct cast” can.
“as” cannot be used with value types (non-nullable types).

using System;
class MyClass1{}
class MyClass2{}
public class IsTest
{
public static void Main()
{
object[] myObjects = new object[6];
myObjects[0] = new MyClass1();
myObjects[2] = "hello";
myObjects[3] = 123;
myObjects[4] = 123.4;
myObjects[5] = null;
for (int i = 0; i < myObjects.Length; ++i)
{
string s = myObjects[i] as string;
Console.Write("{0}:", i);
if (s!= null)
Console.WriteLine("'" + s + "'");
else
Console.WriteLine("not a string");
}
}
}
Casting

using System;
class MyClass1{}
class MyClass2{}
public class IsTest
{
{
object[] myObjects = new object[6];
myObjects[2] = "hello";
myObjects[3] = 123;
myObjects[4] = 123.4;
myObjects[5] = null;
for (int i = 0; i < myObjects.Length; ++i)
{
string s = myObjects[i] as string;
Console.Write("{0}:", i);
if (s!= null)
Console.WriteLine("'" + s + "'");
else
Console.WriteLine("not a string");
}
}
}
Casting
0:not a string
1:not a string
2:'hello'
3:not a string
4:not a string
5:not a string

“is” Keyword
• The is operator is used to check whether the run-time type of an object is
compatible with a given type.
• The is operator is used in an expression of the form:
expression is type

“is” Keyword
• Let’s have the following example
class Class1{}
class Class2{}

“is” Keyword
public class IsTest
{
public static void Test(object o)
{
Class1 a;
Class2 b;
if (o is Class1)
{
Console.WriteLine("o is Class1");
a = (Class1)o;
// do something with a
}
else if (o is Class2)
{
b = (Class2)o;
// do something with b
}
else
{
Console.WriteLine("o is neither Class1 nor Class2.");
}
}
{
Class1 c1 = new Class1();
Test(c1);
Test(c2);
Test("a string");
}
}

“is” Keyword
public class IsTest
{
public static void Test(object o)
{
Class1 a;
Class2 b;
if (o is Class1)
{
a = (Class1)o;
// do something with a
}
else if (o is Class2)
{
b = (Class2)o;
// do something with b
}
else
{
Console.WriteLine("o is neither Class1 nor Class2.");
}
}
{
Test(c1);
Test(c2);
Test("a string");
}
}
o is Class1
o is Class2
o is neither Class1 nor Class2.
Press any key to continue...

enum
• As easy as:
• And that’s it!
// You define enumerations outside of other classes.
public enum DaysOfWeek { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
DaysOfWeek dayOfWeek = DaysOfWeek.Monday;
if(dayOfWeek == Wednesday)
{
// Do something here
}

Exception Handling
using System;
using System.IO;
class tryCatchDemo
{
static void Main(string[] args)
{
try
{
File.OpenRead("NonExistentFile");
}
catch(Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
The output?

Exception Handling – Multiple “catch”s
try
{
int number = Convert.ToInt32(userInput);
}
catch (FormatException e)
{
Console.WriteLine("You must enter a number.");
}
catch (OverflowException e)
{
Console.WriteLine("Enter a smaller number.");
}
catch (Exception e)
{
Console.WriteLine("An unknown error occurred.");
}

Exception Handling
• Multiple catch statement?!
catch(FileNotFoundException e)
{
Console.WriteLine(e.ToString());
}
catch(Exception ex)
{
}

Exception Handling – finally keyword
class FinallyDemo
{
static void Main(string[] args)
{
FileStream outStream = null;
FileStream inStream = null;
try
{
outStream = File.OpenWrite("DestinationFile.txt");
inStream = File.OpenRead("BogusInputFile.txt");
}
catch(Exception ex)
{
}
finally
{
if (outStream!= null)
{
outStream.Close();
Console.WriteLine("outStream closed.");
}
if (inStream!= null)
{
inStream.Close();
Console.WriteLine("inStream closed.");
}
}
}
}

Throwing Exceptions
• Like this:
• But why?
public void CauseProblemsForTheWorld() //always up to no good...
{
throw new Exception("Just doing my job!");
}

Searching for a catch
• Caller chain is traversed backwards until a method with a matching catch clause is
found.
• If none is found => Program is aborted with a stack trace
• Exceptions don't have to be caught in C# (in contrast to Java)

Creating Exceptions
• Let’s throw an exception when you over-eat Hamburgers!
• Now you can say:
public class AteTooManyHamburgersException : Exception
{
public int HamburgersEaten { get; set; }
public AteTooManyHamburgersException(int hamburgersEaten)
{
HamburgersEaten = hamburgersEaten;
}
}
try
{
EatSomeHamburgers(32);
}
catch(AteTooManyHamburgersException hamburgerException)
{
Console.WriteLine(hamburgerException.HamburgersEaten + " is too many hamburgers.");
}

Unsafe Code!
• unsafe code == (code using explicit pointers and memory allocation) in C#
// The following fixed statement pins the location of
// the src and dst objects in memory so that they will
// not be moved by garbage collection.
fixed (byte* pSrc = src, pDst = dst)
{
byte* ps = pSrc;
byte* pd = pDst;
// Loop over the count in blocks of 4 bytes, copying an
// integer (4 bytes) at a time:
for (int n =0; n < count/4; n++)
{
*((int*)pd) = *((int*)ps);
pd += 4;
ps += 4;
}

Nullable Types
• Declaration
DateTime? startDate;

Nullable Types
• Declaration
// You can assign a normal value to startDate like this:
startDate = DateTime.Now;

Nullable Types
• Declaration
// You can assign a normal value to startDate like this:
startDate = DateTime.Now;
// or you can assign null, like this:
startDate = null;

Nullable Types
• Declaration
// Here's another example that declares and initializes a
nullable int:
int? unitsInStock = 5;

Nullable Types
class Program
{
static void Main()
{
DateTime? startDate = DateTime.Now;
bool isNull = startDate == null;
Console.WriteLine("isNull: " + isNull);
}
}

Nullable Types
class Program
{
static void Main()
{
DateTime? startDate = DateTime.Now;
bool isNull = startDate == null;
Console.WriteLine("isNull: " + isNull);
}
}
isNull: False

Nullable Types
class Program
{
static void Main()
{
int i = null;
}
}

Nullable Types
class Program
{
static void Main()
{
int i = null;
}
}
Compiler error, Can’t convert from null to type int

using keyword
using Directive - using statement

using Directive
• The using Directive has two uses:
– To permit the use of types in a namespace so you do not have to qualify the use of a type in
that namespace:
– To create an alias for a namespace or a type:
using System.Text;
using Project = PC.MyCompany.Project;

using Directive
namespace PC
{
// Define an alias for the nested namespace.
using Project = PC.MyCompany.Project;
class A
{
void M()
{
// Use the alias
Project.MyClass mc = new Project.MyClass();
}
}
namespace MyCompany
{
namespace Project
{
public class MyClass { }
}
}
}

using statement
• C#, through the.NET Framework common language runtime (CLR), automatically
releases the memory used to store objects that are no longer required.
• The release of memory is non-deterministic; memory is released whenever the
CLR decides to perform garbage collection. However, it is usually best to release
limited resources such as file handles and network connections as quickly as
possible.

using Directive
• Defines a scope, outside of which an object or objects will be disposed.
using (Font font1 = new Font("Arial", 10.0f))
{
// Use font1
}

using Directive
• Defines a scope, outside of which an object or objects will be disposed.
using (Font font1 = new Font("Arial", 10.0f))
{
// Use font1
}
using (Font font3 = new Font("Arial", 10.0f),
font4 = new Font("Arial", 10.0f))
{
// Use font3 and font4.
}

using Directive
class C : IDisposable
{
public void UseLimitedResource()
{
Console.WriteLine("Using limited resource...");
}
void IDisposable.Dispose()
{
Console.WriteLine("Disposing limited resource.");
}
}
class Program
{
static void Main()
{
using (C c = new C())
{
c.UseLimitedResource();
}
Console.WriteLine("Now outside using statement.");
Console.ReadLine();
}
}

using Directive
class C : IDisposable
{
public void UseLimitedResource()
{
Console.WriteLine("Using limited resource...");
}
void IDisposable.Dispose()
{
Console.WriteLine("Disposing limited resource.");
}
}
class Program
{
static void Main()
{
using (C c = new C())
{
c.UseLimitedResource();
}
Console.WriteLine("Now outside using statement.");
Console.ReadLine();
}
}
Using limited resource...
Disposing limited resource.
Now outside using statement.

Type Aliases
• For instant naming we can use this for long type names:
• And then just using it as follow
using SB = System.Text.StringBuilder;
SB stringBuilder = new SB("InitialValue");

Files, One Shot Reading
// Change the file path here to where you want it.
String path = @”C:/Users/Mhd/Desktop/test1.txt”;
string fileContents = File.ReadAllText(path);
string[] fileContentsByLine = File.ReadAllLines(path);

Files, One Shot Writing
string informationToWrite = "Hello world!";
File.WriteAllText(path, informationToWrite);
string[] arrayOfInformation = new string[2];
arrayOfInformation[0] = "This is line 1";
arrayOfInformation[1] = "This is line 2";
File.WriteAllLines(path, arrayOfInformation);

Files
Reading and Writing on a Text-based Files

Files
• StreamWriter
– Object for writing a stream down
• StreamReader
– Object for reading a stream up

using System;
using System.IO;
public partial class Test
{
{
string path = @"c:tempMyTest.txt";
// Create a file to write to.
using (StreamWriter sw = new StreamWriter(path))
{
sw.WriteLine("Hello");
sw.WriteLine("And");
sw.WriteLine("Welcome");
}
// Open the file to read from.
using (StreamReader sr = new StreamReader(path))
{
string s = "";
while ((s = sr.ReadLine())!= null)
{
Console.WriteLine(s);
}
}
}
}

using System;
using System.IO;
public partial class Test
{
{
using (StreamWriter sw = new StreamWriter(path))
{
}
using (StreamReader sr = new StreamReader(path))
{
string s = "";
{
}
}
}
}
Hello
And
Welcome

using System;
using System.IO;
class Test
{
{
if (!File.Exists(path))
{
using (StreamWriter sw = File.CreateText(path))
{
}
}
using (StreamReader sr = File.OpenText(path))
{
string s = "";
{
}
}
}
}

Reading and Writing on a Binary Files
BinaryWriter and BinaryReader
FileStream fileStream = File.OpenWrite(path);
BinaryWriter binaryWriter = new BinaryWriter(fileStream);
binaryWriter.Write(2);
binaryWriter.Write("Hello");
binaryWriter.Flush();
binaryWriter.Close();

To learn more about Windows Forms,
visit my C++.NET course @
http://www.slideshare.net/ZGTRZGTR/
exactly the same as C#

C# Starter L03-Utilities

More Related Content

What's hot (20)

Similar to C# Starter L03-Utilities (20)

More from Mohammad Shaker (20)

Recently uploaded (20)

C# Starter L03-Utilities