Introduction to .

NET

Name: Deepak Gupta

Organization: Chitkara University
Email: deepak.gupta@chitkarauniversity.com

www.chitkara.edu.in
 Introduction
• .NET provides an environment to develop any
application which can run on Windows.

• .NET is a framework – an API, for programming on

Windows platform.

• .NET emphasize on distributed applications.

S-2 www.chitkara.edu.in
 Significance of .NET and C#
• Windows Technologies – a process of evolving and
extending the API rather than replacing it. E.g.,
• Windows 3.1
• Windows 95
• Windows XP
• Windows 2003
• Windows Vista
• Windows 7
• COM/DCOM/COM+

S-3 www.chitkara.edu.in
 Cont…
• Backward compatibility is the success mantra for
evolutionary approach.
• Advantage:

• Existing code does not break completely.

• Disadvantage:

• Complexity

• Better solution:

• Start from scratch.

S-4 www.chitkara.edu.in
 Cont…
• .NET framework is though a fresh start, but keeps
backward compatibility.

• The communication among Windows software

components happens using COM. So .NET uses
wrappers around existing COM components so that
.NET components can talk to them.

S-5 www.chitkara.edu.in
 Advantages of .NET
• OO programming.

• Good design.

• Language independence:
All languages in .NET compile to common intermediate
language (IL). Thus, languages are interoperable.

• Better support for dynamic web pages:

Avoids messy ASP code in absence of any OO design, instead
used ASP.NET (C# and VB2010 can also be used.)

S-6 www.chitkara.edu.in
 Cont…
• Efficient data access using ADO.NET
Note: XML allows data manipulation, which can be imported from
and exported to non-Windows platforms.

• Code sharing
• Assemblies are used to share code between applications,
replacing DLLs. Different versions of assemblies can exist side
by side.

• Improved security:
• Assemblies have built in security information which describes
which user (s) or process (s) can call which method on which
class.
S-7 www.chitkara.edu.in
 Cont…
• Zero impact installation
• Shared assemblies

• Private assemblies (self contained) – No need for registry entries,

just place the files in appropriate folder.

• Support for web services

• VS 2010

S-8 www.chitkara.edu.in
Microsoft Intermediate Language (IL)
• .NET compilation process has 2 steps:
• Compilation of source code to Microsoft Intermediate Language
(IL).

• Compilation of IL to platform-specific code (using CLR).

• IL is a low level language and uses numeric codes

rather than text.

• IL can be easily translated into native machine code.

• IL can be compared with Java byte code.

S -9 www.chitkara.edu.in
 Benefits of IL
• Platform Independence
• The byte code can be put on any platform at runtime (before
CLR does the final compilation).

• The platform independence is not like Java, as it’s is only meant

for Windows (who knows, what’s there in future !).

• Performance Improvement
• JIT (Just-In-Time) compiler compiles only the portion of code
which is called (NOT the complete code).

• Code compiled once is not compiled again when it runs.

• Execution of managed code should be as fast as machine code.

S -10
(Expected !) www.chitkara.edu.in
Cont…
• Language Interoperability
• Compile source code written in one language supported by .NET
, say C#, to IL

• Compile source code written in another language supported by

.NET , say VB.NET, to IL

• Both compiled codes should be interoperable.

S -11 www.chitkara.edu.in
 First Program

S -12 www.chitkara.edu.in
 Introduction to C#
• A language of it’s own, generating code which
targets .NET framework.

• A few features of C# (like operator overloading) are

not supported by .NET and vice-versa.

• Case sensitive

• Comments:
• //

• /* */

S -13 www.chitkara.edu.in
Cont…
• Using statement is used to locate a namespace
which compiler looks for any class referenced in the
code, but not defined current namespace.

• C# is completely dependent on .NET classes.

• Main () is an entry point and returns either void or

int (Note: C# is case sensitive).

• static is being used as we’re developing an

executable and not a class library.

S -14 www.chitkara.edu.in
 Compile and Run a Program
• Make sure you use command line of VS2010
(automatically sets environmental variables)

• Compile a program
• csc First.cs

• This will create First.exe

• Finally, run a program by simply running First.exe

S -15 www.chitkara.edu.in
 Variables
• datatype identifier

• int x; //declaration

• x = 1; //initialization

• int x =1; // declaration and initialization

• Note:
• Prior to variable usage, its initialization is mandatory. This avoids
retrieval of junk values from memory. (Smartness of C# compiler)

S -16 www.chitkara.edu.in
Variables Initialization
• C# ensures variables initialization using following
approach:
• class / struct variables are initialized to 0 (by default) as these
cannot be initialized explicitly.

• Local method variables must be initialized explicitly.

public static int Main()

int d;

Console.WriteLine(d); // Can't do this! Need to initialize d before use

return 0;

S -17 www.chitkara.edu.in
Cont…
• MyClass objMyClass
• This creates only a reference for a MyClass object, but you
cannot refer to any method inside object.

• The solution is to instantiate the reference object like:

• objMyClass = new MyClass();

• // This creates a MyClass on the heap.

S -18 www.chitkara.edu.in
 Type Inference
• Type inference makes use of the var keyword.

• The compiler “infers” what type the variable is by

what the variable is initialized to.
• E.g., var x = 0;

• The compiler identifies that this is a integer variable,

though it’s never declared as integer.

S -19 www.chitkara.edu.in
Cont…
• using System;

• namespace Wrox {

• class Program {

static void Main(string[] args) {

var name = "Bugs Bunny";

var age = 25;

var isRabbit = true;

Type nameType = name.GetType();

Type ageType = age.GetType();

Type isRabbitType = isRabbit.GetType();

Console.WriteLine("name is type " + nameType.ToString());

Console.WriteLine("age is type " + ageType.ToString());

Console.WriteLine("isRabbit is type " + isRabbitType.ToString());

S -20 • }}} www.chitkara.edu.in

Cont…
• Output:
• name is type System.String

• age is type System.Int32

• isRabbit is type System.Bool

• Rules for realizing type interference:

• The variable must be initialized.

• The initializer cannot be null.

• The initializer must be an expression.

S -21 www.chitkara.edu.in
 Variable Scope
• Rules for finding scope:
• Class / struct scope.

• Block / method scope

• Loop scope (for, while etc.)

• Scope clashes for Local Variable

• Local variables with the same name can’t be declared twice in the same
scope.

• Same variable name can be used in different parts as long as the scope
is different.

S -22 www.chitkara.edu.in
Cont…
• public static int Main() {
for (int i = 0; i < 10; i++)

Console.WriteLine(i);

// i goes out of scope so we can declare a variable i again

for (int i = 9; i >= 0; i--)

Console.WriteLine(i);

} // i goes out of scope here.

return 0;

• }

S -23 www.chitkara.edu.in
Cont…
• What should be output?
public static int Main()

int j = 20;

for (int i = 0; i < 10; i++)

{
// IMP: Can't do this as j is in loop’s scope which is nested into Main() method
// scope.

int j = 30;

Console.WriteLine(j + i);

}
S -24 www.chitkara.edu.in
return 0;
Cont…(Scope clashes for Fields (member) and local
variables
• C# is INTELLIGENT enough to make a distinction between field
and local variables.
using System;

namespace Wrox{
class Scope{

static int j = 20;

public static void Main(){

int j = 30; // Hides class level or field variable

Console.WriteLine(Scope.j); // Displays class level or field variable

return;

}}}

• NOTE: Use this keyword to access an instance field (a field related to a particular
instance of object.)
S -25 www.chitkara.edu.in
 Constants
• const int x = 10;

• Constants are:
• Initialized when they are declared.

• Cannot be overwritten.

• Computable at compile time.

• Implicitly static. (means there is no need to include the static

modifier in declaration.)

S -26 www.chitkara.edu.in
Cont…
• Advantages:
• Enhance readability:
Programs becomes easier to read by replacing magic numbers and
strings with readable names.

• Single point modification:

Constants make your programs easier to modify.

• Prevent mistakes:
You cannot modify a constant variable by mistake.

S -27 www.chitkara.edu.in
 Value and Reference Data Types
• Value type stores data directly (uses Stack).

• Reference type stores a reference to the value (uses

managed Heap).
// Two variables - i and j, having different locations

int i, j;

i = 10;

j = i;

S -28 www.chitkara.edu.in
Cont…
• Consider a class Vector.

• Assume Vector is a reference type and has an int

member variable called Value.
Vector x, y;

x = new Vector ();

x.Value = 30;

y = x;

Console.WriteLine (y.Value);

y.Value = 50;

Console.WriteLine(x.Value);
S -29 www.chitkara.edu.in
Cont…
• Key notes:
• An object is created using new.

• x and y variables are of reference type and both refer to the

same object.

• Changes made to one variable will affect another.

• We don’t use -> to access reference variables. Though behind

the scene, it’s similar to C++ pointers.

• Output:
30

50
S - 30 www.chitkara.edu.in
Cont…
• If x = null;
means reference variable y does not refer to an object and
thus it’s not possible to call nonstatic functions or fields.

• C# makes a provision that the primitive types int

and bool belong to value data type category and
larger types (like classes) are put in second
category.

S - 31 www.chitkara.edu.in
 Predefined Value Types
• The basic data types in C# are not intrinsic to the
language, but are part of the .NET Framework.

• Declaration of an int in C# is like declaration of an

instance of a .NET struct, System.Int32. The advantage
is that you can access class members like:

string s = i.ToString();

• No performance issue as types are stored as primitive

types.
S - 32 www.chitkara.edu.in
 Integer Types

S - 33 www.chitkara.edu.in
Cont…
• 8 predefined integers.

• All data types are defined in a platform

independent manner (for possible future porting
of C# and .NET to other platforms).

S - 34 www.chitkara.edu.in
 Floating Point Types
• double provides twice the precision than float.
• For any non integer number, normally compiler
treat it as a double.

S - 35 www.chitkara.edu.in
 The Decimal Types
• Higher precision floating – point numbers.
• Useful in financial calculations to have greater
accuracy.
• Slow down the performance.

S - 37 www.chitkara.edu.in
 The Boolean Types
• Boolean values are either true or false.
• No implicit conversion of a bool into integer or vice
versa.

S - 38 www.chitkara.edu.in
 The Character Types
• 16-bit characters.
• Enclosed in single quotation mark.

S - 39 www.chitkara.edu.in
 Predefined Reference Types
• object type is the ultimate parent type from which all
other intrinsic and user-defined types are derived.

S - 40 www.chitkara.edu.in
Cont…
• string belongs to reference type.
• One of exception is that the strings are immutable , i.e.,
if you make a change to one string, it’ll create a new
string object and leave another unchanged.
using System;
class StringExample {
public static int Main() {
string s1 = “First String";
string s2 = s1;
Console.WriteLine("s1 is " + s1);
Console.WriteLine("s2 is " + s2);
s1 = “Second String"; // Creates new string object
Console.WriteLine("s1 is now " + s1);
Console.WriteLine("s2 is now " + s2);
return 0;
}}
S - 41 www.chitkara.edu.in
Cont…
• Output:
First String
First String
Second Sting
First String

S - 42 www.chitkara.edu.in
 Flow Control
Conditional Statements
• if
• Switch

S - 43 www.chitkara.edu.in
 The switch Statement
• C#’s switch prohibits fall-through conditions to avoid a lot
of logical errors. The compiler enforces this restriction by
making it mandatory to have break statement in every case
clause.

• One exception to the no-fall-through rule is there when you

can fall through from one case to next if the case is empty.
switch(country)
{
case "india":
case "usa":
case "uk":
language = "English";
break;
}
S - 44 www.chitkara.edu.in
Cont…
• In C#:
• The order of the cases doesn’t matter — you can even put the default
case first.
• switch can test a string as the variable.

S - 45 www.chitkara.edu.in
 Loops
• for
• while
• do-while
• foreach.
• The foreach loop allows you to iterate through each item in a collection,
in one by one mode.

foreach (int value in arrayOfInts)

{
Console.WriteLine(value);
}

S - 46 www.chitkara.edu.in
Cont…
• The value of an item cannot be changed in the collection.

foreach (int value in arrayOfInts)

{
value++; // Cannot do this, compiler will complain.
Console.WriteLine(value);
}

In such cases, you should make usage of for loop.

S - 47 www.chitkara.edu.in
Jump Statements
• The goto statement
goto Label1;
Console.WriteLine("This won't be executed");
Label1:
Console.WriteLine("Continuing execution from here");

• Restrictions:
• Can’t jump into a block of code such as a for loop.
• Can’t jump out of a class.

S - 48 www.chitkara.edu.in
Cont…
• The break statement.
• The continue statement.
• The return statement.

S - 49 www.chitkara.edu.in
 Enumerations

• An enumeration is a user-defined integer type.

• Set of values with user friendly name.
• Advantages:
• Easier to maintain (values are anticipated / legitimate)
• Enhance readability
• Easier to type (usage of IntelliSense in VS 2010 IDE)

public enum TimeOfDay

{
Morning = 0,
Afternoon = 1,
Evening = 2
}
S - 50 www.chitkara.edu.in
Cont…
• How do you access the values?
TimeOfDay.Morning will return the value 0.

• In practice, after your code is compiled, enums will exist as

primitive types, just like int and float.

• Enums are instantiated as structs derived from the base

class, System.Enum. This means you can call methods
against them to perform some useful tasks without
any performance loss.
TimeOfDay time = TimeOfDay.Afternoon;
Console.WriteLine(time.ToString());

S - 51 www.chitkara.edu.in
 Namespace
• A namespace is a logical rather than physical grouping.
• Defining the namespace hierarchy should be planned out
prior to the start of a project.

• namespace Wrox
• {
• namespace ProCSharp
• {
• namespace Basics
• {
• class NamespaceExample
• {
• // Code for the class here...
• }
• }}}

S - 52 www.chitkara.edu.in
Cont…
This can be also written like:

namespace Wrox.ProCSharp.Basics
{
class NamespaceExample
{
// Code for the class here...
}
}

S - 53 www.chitkara.edu.in
 Using Directive
using Wrox.ProCSharp.OOP;

using Wrox.ProCSharp.Basics;

S - 54 www.chitkara.edu.in
 Main () method
• Only one entry point should be there.
• In case, there are two Main () methods. This will give an
error as compiler fails to find the entry point.
o using System;
o namespace Wrox {
o class Client {
o public static int Main() {
o MathExample.Main();
o return 0;
o }}
o class MathExample {
o static int Add(int x, int y) {
o return x + y;
o }
o public static int Main() {
o int i = Add(5,10);
o Console.WriteLine(i);
o return 0;
o }}}
S - 55 www.chitkara.edu.in
Cont…
Better solution:
Specify the entry point using /main switch like

csc DoubleMain.cs /main:Wrox.MathExample

DoubleMain.cs is the name of program file.

S - 56 www.chitkara.edu.in
 Passing arguments to Main()
• The parameter is a string array, traditionally called args

public static int Main(string[] args)

{
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine(args[i]);
}
return 0;
}

S - 57 www.chitkara.edu.in
Cont…
How do you run the program using command line?

ArgsExample A B C

Output
A
B
C

S - 58 www.chitkara.edu.in
 C# Programming Guidelines
• Rules for Identifiers.
o They must begin with a letter or underscore, although they can
contain numeric characters.

o You can’t use C# keywords as identifiers.

o In case, you need to use C# keywords as an dentifier (for example, if

you are accessing a class written in a different language), you can
prefix the identifier with the @ symbol to indicate to the compiler
that what follows is to be treated as an identifier (so abstract is not a
valid identifier, but @ abstract is).

• Naming Conventions.
S - 59 www.chitkara.edu.in