fdjkhdjkfhdjkjdkfhkjshfjkhdkjfhdjkhf2124C_2.ppt

Module 1: Overview of
the Microsoft .NET
Platform

Overview
 Introduction to the .NET Platform
 Overview of the .NET Framework
 Benefits of the .NET Framework
 The .NET Framework Components
 Languages in the .NET Framework

Introduction to the .NET Platform
The .NET Framework
.NET My Services
The .NET Enterprise Servers
Visual Studio .NET

Overview of the .NET Framework
Win32
Win32
Message
Message
Queuing
Queuing
COM+
COM+
(Transactions, Partitions,
(Transactions, Partitions,
Object Pooling)
Object Pooling)
IIS
IIS WMI
WMI
Common Language Runtime
.NET Framework Class Library
ADO.NET: Data and XML
XML Web Services
XML Web Services User Interface
User Interface
Visual
Basic
C++ C#
ASP.NET
ASP.NET
Perl J# …

Benefits of the .NET Framework
 Based on Web standards and practices
 Designed using unified application models
 Easy for developers to use
 Extensible classes
Windows API
Windows API
Visual Basic Forms
Visual Basic Forms MFC/ATL
MFC/ATL ASP
ASP
.NET Framework
.NET Framework

 The .NET Framework Components
Web Forms and XML Web Services
User Interface for Windows

Base Class Library Support
Base Class Library Support
Thread Support
Thread Support COM Marshaler
COM Marshaler
Type Checker
Type Checker Exception Manager
Exception Manager
MSIL to Native
MSIL to Native
Compilers
Compilers
Code
Code
Manager
Manager
Garbage
Garbage
Collector
Collector
Security Engine
Security Engine Debug Engine
Debug Engine
Class Loader
Class Loader

System.Globalization
System.Globalization
System.Diagnostics
System.Diagnostics
System.Configuration
System.Configuration
System.Collections
System.Collections
System.IO
System.IO
System.Reflection
System.Reflection
System.Net
System.Net
System
System
System.Threading
System.Threading
System.Text
System.Text
System.Security
System.Security System.Runtime.
System.Runtime.
InteropServices
InteropServices

DataSet
DataSet DataRow
DataRow
DataTable
DataTable DataView
DataView
System.Data
System.Xml.Schema
System.Xml.Schema
System.Xml.Serialization
System.Xml.Serialization
System.Xml

ASP.NET
ASP.NET
Web Forms and XML Web Services
System.Web
System.Web
Configuration
Configuration SessionState
SessionState
Caching
Caching Security
Security
Services
Services
Description
Discovery
Protocols
UI
UI
HtmlControls
WebControls

User Interface for Windows
System.Drawing
System.Drawing
System.Windows.Forms
System.Windows.Forms

Languages in the .NET Framework
 C# – Designed for .NET
New component-oriented language
 Managed Extensions to C++
Enhanced to provide more power and control
 Visual Basic .NET
New version of Visual Basic with substantial language innovations
 JScript .NET
New version of JScript that provides improved performance and productivity
 J# .NET
.NET Java-language support enabling new development and Java migration
 Third-party Languages

Review
 Introduction to the .NET Platform
 Overview of the .NET Framework
 Benefits of the .NET Framework
 The .NET Framework Components
 Languages in the .NET Framework

Overview
 Structure of a C# Program
 Basic Input/Output Operations
 Recommended Practices
 Compiling, Running, and Debugging

 Structure of a C# Program
 Hello, World
 The Class
 The Main Method
 The using Directive and the System Namespace
 Demonstration: Using Visual Studio to Create
a C# Program

Hello, World
using System;
class Hello
{
public static void Main()
{
Console.WriteLine("Hello, World");
}
}

The Class
 A C# application is a collection of classes, structures,
and types
 A class Is a set of data and methods
 Syntax
 A C# application can consist of many files
 A class cannot span multiple files
class name
{
...
}

The Main Method
 When writing Main, you should:
 Use an uppercase “M”, as in “Main”
 Designate one Main as the entry point to the program
 Declare Main as public static void Main
 Multiple classes can have a Main
 When Main finishes, or returns, the application quits

The using Directive and the System Namespace
 The .NET Framework provides many utility classes
 Organized into namespaces
 System is the most commonly used namespace
 Refer to classes by their namespace
 The using directive
System.Console.WriteLine("Hello, World");
using System;
…
Console.WriteLine("Hello, World");

Demonstration: Using Visual Studio to Create a C#
Program

 Basic Input/Output Operations
 The Console Class
 Write and WriteLine Methods
 Read and ReadLine Methods

The Console Class
 Provides access to the standard input, standard output,
and standard error streams
 Only meaningful for console applications
 Standard input – keyboard
 Standard output – screen
 Standard error – screen
 All streams may be redirected

Write and WriteLine Methods
 Console.Write and Console.WriteLine display
information on the console screen
 WriteLine outputs a line feed/carriage return
 Both methods are overloaded

Read and ReadLine Methods
 Console.Read and Console.ReadLine read user input
 Read reads the next character
 ReadLine reads the entire input line

Commenting Applications
 Comments are important
 A well-commented application permits a developer to
fully understand the structure of the application
 Single-line comments
 Multiple-line comments
/* Find the higher root of the
quadratic equation */
x = (…);
// Get the user’s name
Console.WriteLine("What is your name? ");
name = Console.ReadLine( );

Demonstration: Compiling and Running a C#
Program

Module 3: Using Value-
Type Variables

Overview
 Common Type System
 Naming Variables
 Using Built-in Data Types
 Creating User-Defined Data Types
 Converting Data Types

 Common Type System
 Overview of CTS
 Comparing Value and Reference Types
 Comparing Built-in and User-Defined Value Types
 Simple Types

Overview of CTS
 CTS supports both value and reference types
Reference Type
Type
Value Type

Comparing Value and Reference Types
 Value types:
 Directly contain their
data
 Each has its own
copy of data
 Operations on one
cannot affect another
 Reference types:
 Store references to their
data (known as objects)
 Two reference variables
can reference same object
 Operations on one can
affect another

Comparing Built-in and User-Defined Value Types
 Examples of
built-in value types:
 int
 float
 Examples of user-defined
value types:
 enum
 struct
User-Defined
Value Types
Built-in Type

Simple Types
 Identified through reserved keywords
 int // Reserved keyword
- or -
 System.Int32

Simple Types
Reserved keywords Alias for struct type
sbyte
System.SByte
byte
System.Byte
short
System.Int16
ushort
System.UInt16
int
System.Int32
Uint
System.UInt32
long
System.Int64
ulong
System.UInt64
char
System.Char

Rules and Recommendations for Naming Variables
 Rules
 Use letters, the underscore,
and digits
 Recommendations
 Avoid using all
uppercase letters
 Avoid starting with
an underscore
 Avoid using abbreviations
 Use PascalCasing naming
in multiple-word names
different
Different
Answer42
42Answer








BADSTYLE
_poorstyle
BestStyle






Msg
Message





C# Keywords
 Keywords are reserved identifiers
 Do not use keywords as variable names
 Results in a compile-time error
 Avoid using keywords by changing their case sensitivity
abstract, base, bool, default, if, finally
int INT; // Poor style

Declaring Local Variables
 Usually declared by data type and variable name:
 Possible to declare multiple variables in
one declaration:
--or--
int itemCount;
int itemCount, employeeNumber;
int itemCount,
employeeNumber;

Assigning Values to Variables
 Assign values to variables that are already declared:
 Initialize a variable when you declare it:
 You can also initialize character values:
int employeeNumber;
employeeNumber = 23;
int employeeNumber = 23;
char middleInitial = 'J';

Compound Assignment
 Adding a value to a variable is very common
 There is a convenient shorthand
 This shorthand works for all arithmetic operators
itemCount = itemCount + 40;
itemCount += 40;
itemCount -= 24;

Common Operators
Common Operators
Common Operators
• Equality operators
• Relational operators
• Conditional operators
• Increment operator
• Decrement operator
• Arithmetic operators
• Assignment operators
Example
Example
== !=
< > <= >= is
&& || ?:
++
- -
+ - * / %
= *= /= %= += -= <<=
>>= &= ^= |=

Increment and Decrement
 Changing a value by one is very common
 There is a convenient shorthand
 This shorthand exists in two forms
itemCount += 1;
itemCount -= 1;
itemCount++;
itemCount--;
++itemCount;
--itemCount;

 Creating User-Defined Data Types
 Enumeration Types
 Structure Types

Enumeration Types
 Defining an Enumeration Type
 Using an Enumeration Type
 Displaying an Enumeration Variable
enum Color { Red, Green, Blue }
Color colorPalette = Color.Red;
Console.WriteLine(“{0}”, colorPalette); // Displays Red

Structure Types
 Defining a Structure Type
 Using a Structure Type
Employee companyEmployee;
companyEmployee.firstName = "Joe";
companyEmployee.age = 23;
public struct Employee
{
public string firstName;
public int age;
}

 Converting Data Types
 Implicit Data Type Conversion
 Explicit Data Type Conversion

Implicit Data Type Conversion
 To Convert int to long:
 Implicit conversions cannot fail
 May lose precision, but not magnitude
using System;
class Test
{
static void Main( )
{
int intValue = 123;
long longValue = intValue;
Console.WriteLine("(long) {0} = {1}", intValue,
longValue);
}
}

Explicit Data Type Conversion
 To do explicit conversions, use a cast expression:
using System;
class Test
{
static void Main( )
{
long longValue = Int64.MaxValue;
int intValue = (int) longValue;
Console.WriteLine("(int) {0} = {1}", longValue,
intValue);
}
}

Overview
 Overview of Arrays
 Creating Arrays
 Using Arrays

What Is an Array?
 An array is a sequence of elements
 All elements in an array have the same type
 Structs can have elements of different types
 Individual elements are accessed using integer indexes
Integer index 0
(zero)
Integer index 4
(four)

Array Notation in C#
 You declare an array variable by specifying:
 The element type of the array
 The rank of the array
 The name of the variable
This specifies the rank of the array
This specifies the name of the array variable
This specifies the element type of the array
type[ ] name;

Array Rank
 Rank is also known as the array dimension
 The number of indexes associated with each element
Rank 1: One-dimensional
Single index associates with
each long element
Rank 2: Two-dimensional
Two indexes associate with
each int element
long[ ] row; int[,] grid;

Accessing Array Elements
 Supply an integer index for each rank
 Indexes are zero-based
3
3
2
2
1
1
long[ ] row;
...
row[3];
int[,] grid;
...
grid[1,2];

Creating Array Instances
 Declaring an array variable does not create an array!
 You must use new to explicitly create the array instance
 Array elements have an implicit default value of zero
row
0 0 0 0
grid
0 0 0
0 0 0
Variable Instance
long[ ] row = new long[4];
int[,] grid = new int[2,3];

Initializing Array Elements
 The elements of an array can be explicitly initialized
 You can use a convenient shorthand
row
0 1 2 3
Equivalent
long[ ] row = new long[4] {0, 1, 2, 3};
long[ ] row = {0, 1, 2, 3};

Initializing Multidimensional Array Elements
 You can also initialize multidimensional array elements
 All elements must be specified
grid
5 4 3
2 1 0
Implicitly a new int[2,3] array




int[,] grid = {
{5, 4, 3},
{2, 1, 0}
};
int[,] grid = {
{5, 4, 3},
{2, 1 }
};

Creating a Computed Size Array
 The array size does not need to be a compile-time
constant
 Any valid integer expression will work
 Accessing elements is equally fast in all cases
Array size specified by compile-time integer constant:
Array size specified by run-time integer value:
string s = Console.ReadLine();
int size = int.Parse(s);
long[ ] row = new long[size];

Copying Array Variables
 Copying an array variable copies the array variable only
 It does not copy the array instance
 Two array variables can refer to the same array instance
copy
row
0 0 0 0
Variable Instance
long[ ] copy = row;
...
row[0]++;
long value = copy[0];
Console.WriteLine(value);

Module 4: Statements
and Exceptions

Overview
 Introduction to Statements
 Using Selection Statements
 Using Iteration Statements
 Using Jump Statements

 Introduction to Statements
 Statement Blocks
 Types of Statements

Statement Blocks
 Use braces As
block delimiters
{
// code
}
{
int i;
...
{
int i;
...
}
}
{
int i;
...
}
...
{
int i;
...
}
 A block and its
parent block
cannot have a
variable with
the same name
 Sibling blocks
can have
variables with
the same name

Types of Statements
Selection Statements
The if and switch statements
Iteration Statements
The while, do, for, and foreach statements
Jump Statements
The goto, break, and continue statements

The if Statement
 Syntax:
 No implicit conversion from int to bool
int x;
...
if (x) ... // Must be if (x != 0) in C#
if (x = 0) ... // Must be if (x == 0) in C#
if ( Boolean-expression )
first-embedded-statement
else
second-embedded-statement

Cascading if Statements
enum Suit { Clubs, Hearts, Diamonds, Spades }
Suit trumps = Suit.Hearts;
if (trumps == Suit.Clubs)
color = "Black";
else if (trumps == Suit.Hearts)
color = "Red";
else if (trumps == Suit.Diamonds)
color = "Red";
else
color = "Black";

The switch Statement
 Use switch statements for multiple case blocks
 Use break statements to ensure that no fall
through occurs
switch (trumps) {
case Suit.Clubs :
case Suit.Spades :
color = "Black"; break;
case Suit.Hearts :
case Suit.Diamonds :
color = "Red"; break;
default:
color = "ERROR"; break;
}

The while Statement
 Execute embedded statements based on Boolean value
 Evaluate Boolean expression at beginning of loop
 Execute embedded statements while Boolean value
Is True
int i = 0;
while (i < 10) {
Console.WriteLine(i);
i++;
}
0 1 2 3 4 5 6 7 8 9

The do Statement
 Execute embedded statements based on Boolean value
 Evaluate Boolean expression at end of loop
 Execute embedded statements while Boolean value
Is True
int i = 0;
do {
i++;
} while (i < 10);
0 1 2 3 4 5 6 7 8 9

The for Statement
 Place update information at the start of the loop
 Variables in a for block are scoped only within the block
 A for loop can iterate over several values
for (int i = 0; i < 10; i++) {
}
0 1 2 3 4 5 6 7 8 9
for (int i = 0; i < 10; i++)
Console.WriteLine(i); // Error: i is no longer in scope
for (int i = 0, j = 0; ... ; i++, j++)

The foreach Statement
 Choose the type and name of the iteration variable
 Execute embedded statements for each element of the
collection class
ArrayList numbers = new ArrayList( );
for (int i = 0; i < 10; i++ ) {
numbers.Add(i);
}
foreach (int number in numbers) {
Console.WriteLine(number);
}
0 1 2 3 4 5 6 7 8 9

 Using Jump Statements
 The goto Statement
 The break and continue Statements

The goto Statement
 Flow of control transferred to a labeled statement
 Can easily result in obscure “spaghetti” code
if (number % 2 == 0) goto Even;
Console.WriteLine("odd");
goto End;
Even:
Console.WriteLine("even");
End:;

The break and continue Statements
 The break statement jumps out of an iteration
 The continue statement jumps to the next iteration
int i = 0;
while (true) {
i++;
if (i < 10)
continue;
else
break;
}

Module 5: Methods and
Parameters

Overview
 Using Methods
 Using Parameters
 Using Overloaded Methods

Defining Methods
 Main is a method
 Use the same syntax for defining your own methods
using System;
class ExampleClass
{
static void ExampleMethod( )
{
Console.WriteLine("Example method");
}
static void Main( )
{
// ...
}
}

Calling Methods
 After you define a method, you can:
 Call a method from within the same class
Use method’s name followed by a parameter list in
parentheses
 Call a method that is in a different class
You must indicate to the compiler which class contains
the method to call
The called method must be declared with the public
keyword
 Use nested calls
Methods can call methods, which can call other
methods, and so on

Using the return Statement
 Immediate return
 Return with a conditional statement
static void ExampleMethod( )
{
int numBeans;
//...
Console.WriteLine("Hello");
if (numBeans < 10)
return;
Console.WriteLine("World");
}

Using Local Variables
 Local variables
 Created when method begins
 Private to the method
 Destroyed on exit
 Shared variables
 Class variables are used for sharing
 Scope conflicts
 Compiler will not warn if local and class names clash

Returning Values
 Declare the method with non-void type
 Add a return statement with an expression
 Sets the return value
 Returns to caller
 Non-void methods must return a value
static int TwoPlusTwo( ) {
int a,b;
a = 2;
b = 2;
return a + b;
}
int x;
x = TwoPlusTwo( );
Console.WriteLine(x);

Declaring and Calling Parameters
 Declaring parameters
 Place between parentheses after method name
 Define type and name for each parameter
 Calling methods with parameters
 Supply a value for each parameter
static void MethodWithParameters(int n, string y)
{ ... }
MethodWithParameters(2, "Hello, world");

Pass by Value
 Default mechanism for passing parameters:
 Parameter value is copied
 Variable can be changed inside the method
 Has no effect on value outside the method
 Parameter must be of the same type or compatible type
static void AddOne(int x)
{
x++; // Increment x
}
static void Main( )
{
int k = 6;
AddOne(k);
Console.WriteLine(k); // Display the value 6, not 7
}

Pass by Reference
 What are reference parameters?
 A reference to memory location
 Using reference parameters
 Use the ref keyword in method declaration and call
 Match types and variable values
 Changes made in the method affect the caller
 Assign parameter value before calling the method

Output Parameters
 What are output parameters?
 Values are passed out but not in
 Using output parameters
 Like ref, but values are not passed into the method
 Use out keyword in method declaration and call
static void OutDemo(out int p)
{
// ...
}
int n;
OutDemo(out n);

Using Variable-Length Parameter Lists
 Use the params keyword
 Declare as an array at the end of the parameter list
 Always pass by value
static long AddList(params long[ ] v)
{
long total, i;
for (i = 0, total = 0; i < v.Length; i++)
total += v[i];
return total;
}
static void Main( )
{
long x = AddList(63,21,84);
}

Declaring Overloaded Methods
 Methods that share a name in a class
 Distinguished by examining parameter lists
class OverloadingExample
{
static int Add(int a, int b)
{
return a + b;
}
static int Add(int a, int b, int c)
{
return a + b + c;
}
static void Main( )
{
Console.WriteLine(Add(1,2) + Add(1,2,3));
}
}

Method Signatures
 Method signatures must be unique within a class
 Signature definition
 Name of method
 Parameter type
 Parameter modifier
Forms Signature
Forms Signature
Definition
Definition
 Name of parameter
 Return type of method
No Effect on
No Effect on
Signature
Signature

Module 6: Essentials of
Object-Oriented
Programming

Overview
 Classes and Objects
 Using Encapsulation
 C# and Object Orientation
 Defining Object-Oriented Systems

 Classes and Objects
 What Is a Class?
 What Is an Object?
 Comparing Classes to Structs
 Abstraction

What Is a Class?
 For the philosopher…
 An artifact of human classification!
 Classify based on common behavior or attributes
 Agree on descriptions and names of useful classes
 Create vocabulary; we communicate; we think!
 For the object-oriented programmer…
 A named syntactic construct that describes common
behavior and attributes
 A data structure that includes both data and functions
CAR?

What Is an Object?
 An object is an instance of a class
 Objects exhibit:
 Identity: Objects are distinguishable from one another
 Behavior: Objects can perform tasks
 State: Objects store information

Comparing Classes to Structs
 A struct is a blueprint for a value
 No identity, accessible state, no added behavior
 A class is a blueprint for an object
 Identity, inaccessible state, added behavior
struct Time class BankAccount
{ {
public int hour; ...
public int minute; ...
} }

Controlling Access Visibility
 Methods are public, accessible from the outside
 Data is private, accessible only from the inside
Withdraw( )
Deposit( )
balance
Withdraw( )
Deposit( )
balance


BankAccount ?
BankAccount ?

Using Static Data
 Static data describes information for all objects
of a class
 For example, suppose all accounts share the same
interest rate. Storing the interest rate in every account
would be a bad idea. Why?
Withdraw( )
Deposit( )
balance 12.56
interest 7%
Withdraw( )
Deposit( )
balance 99.12
interest 7%

 


Using Static Methods
 Static methods can only access static data
 A static method is called on the class, not the object
InterestRate( )
interest 7%
Withdraw( )
Deposit( )
balance 99.12
owner "Fred"
An account object
The account class
Classes contain static data and
static methods
Objects contain object data and
object methods







Defining Simple Classes
 Data and methods together inside a class
 Methods are public, data is private
class BankAccount
{
public void Withdraw(decimal amount)
{ ... }
public void Deposit(decimal amount)
{ ... }
private decimal balance;
private string name;
}
Public methods
describe
accessible
behaviour
Private fields
describe
inaccessible
state

Instantiating New Objects
 Declaring a class variable does not create an object
 Use the new operator to create an object
class Program
{
static void Main( )
{
Time now;
now.hour = 11;
BankAccount yours = new BankAccount( );
yours.Deposit(999999M);
}
}
hour
minute
now
yours ...
...
new
BankAccount
object

Using the this Keyword
 The this keyword refers to the object used to call the
method
 Useful when identifiers from different scopes clash
class BankAccount
{
...
public void SetName(string name)
{
this.name = name;
}
private string name;
}
If this statement were
name = name;
What would happen?

Creating Nested Classes
 Classes can be nested inside other classes
class Program
{
static void Main( )
{
Bank.Account yours = new Bank.Account( );
}
}
class Bank
{
... class Account { ... }
}
The full name of the nested
class includes the name of
the outer class

Accessing Nested Classes
 Nested classes can also be declared as public or private
class Bank
{
public class Account { ... }
private class AccountNumberGenerator { ... }
}
class Program
{
static void Main( )
{
Bank.Account accessible;
Bank.AccountNumberGenerator inaccessible;
}
}





Inheritance
 Inheritance specifies an “is a kind of" relationship
 Inheritance is a class relationship
 New classes specialize existing classes
Musician
Violin
Player
Base class
Derived class
Generalization
Specialization Is this a good
example of
inheritance ?

Single and Multiple Inheritance
 Single inheritance: deriving from one base class
 Multiple inheritance: deriving from two or more base
classes
Stringed
Instrument
Violin
Musical
Instrument
Stringed
Instrument
Pluckable
Violin has a single direct
base class
Stringed Instrument has
two direct base classes

Polymorphism
 The method name resides in the base class
 The method implementations reside in the
derived classes
String Musician
TuneYourInstrument( )
Guitar Player
Violin Player
A method with no
implementation is
called an operation

Abstract Base Classes
 Some classes exist solely to be derived from
 It makes no sense to create instances of these classes
 These classes are abstract
Stringed Musician
{ abstract }
Guitar Player
« concrete »
Violin Player
« concrete »
You can create instances
of concrete classes
You cannot create instances
of abstract classes

Interfaces
 Interfaces contain only operations, not implementation
String Musician
{ abstract }
Violin Player
« concrete »
Musician
« interface »
Nothing but operations.
of an interface.
May contain some implementation.
of an abstract class.
Must implement all inherited operations.
You can create instances
of a concrete class.

Early and Late Binding
 Normal method calls are resolved at compile time
 Polymorphic method calls are resolved at run time
Musician
« interface »
Violin Player
« concrete »
Late binding
Early binding
runtime

fdjkhdjkfhdjkjdkfhkjshfjkhdkjfhdjkhf2124C_2.ppt

More Related Content

Similar to fdjkhdjkfhdjkjdkfhkjshfjkhdkjfhdjkhf2124C_2.ppt

Recently uploaded

fdjkhdjkfhdjkjdkfhkjshfjkhdkjfhdjkhf2124C_2.ppt