Advanced Web Programming_UNIT_1_NewSyllabus.pdf

ADVANCED WEB PROGRAMMING
TYBScIT Sem-5
2018-2019
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019
1

SUMMARY
Chapter 1: Introducing .NET.
The .NET Framework, C#, VB, and the .NET Languages, The Common Language Runtime,
The .NET Class Library.
Chapter 2:The C# Language.
C# Language Basics, Variables and Data Types, Variable Operations, Object-Based
Manipulation, Conditional Logic, Loops, Methods.
Chapter 3:Types, Objects, and Namespaces.
The Basics About Classes, Building a Basic Class, Value Types and Reference Types,
Understanding Namespaces and Assemblies, Advanced Class Programming.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 2

CHAPTER 1: INTRODUCING .NET
1) The .NET Framework
2) C#,VB, and the .NET Languages
3) The Common Language Runtime
4) The .NET Class Library.

THE .NET FRAMEWORK
▪ Definition:
▪ The .NET Framework provides an environment for building, deploying and running web services and other
applications.
▪ The .NET languages:
▪ These include Visual Basic, C# and C++.
▪ The Common Language Runtime (CLR):
▪ It is the heart and soul of .NET Framework. It is the engine that executes all .NET programs and provides
automatic services for these applications, such as security checking, memory management, and
optimization.
▪ The .NET Framework class library:
▪ The class library collects thousands of pieces of prebuilt functionality for your applications. These
features are sometimes organized into technology sets, such as ADO.NET (ActiveX Data Object) and WPF
(Windows Presentation Foundation).
▪ ASP.NET:
▪ This is the engine that hosts the web applications you create with .NET, and supports almost any feature
from the .NET Framework class library. It includes a set of web-specific services, such as secure
authentication and data storage.
▪ Visual Studio:
▪ This optional development tool contains a rich set of productivity and debugging features. Visual Studio
includes the complete .NET Framework, so you won’t need to download it separately.

2) C#,VB, AND THE .NET LANGUAGES
▪ VB and C# use the .NET class library and are supported by the CLR.
Steps for Compilation:
Step 1:
▪ All the .NET languages are compiled into another lower-level language before the
code is executed.
Step 2:
▪ This lower level language is the Common Intermediate Language (CIL, or just IL).
▪ The CLR, the engine of .NET, uses only IL code.
▪ The .NET Framework formalizes this compatibility with something called the
Common Language Specification (CLS).
▪ CLS defines a set of rules and restrictions that every language must follow which
runs under .NET framework. It also defines object-oriented ingredients such as
classes, methods, events, and quite a bit more. It is a subset of CTS.
▪ Common type system (CTS), defines the rules for data types such as strings,
numbers, and arrays that are shared in all .NET languages.
Step 3:
▪ Every EXE or DLL file that you build with a .NET language contains IL code. This is
the file you deploy to other computers.
Step 4:
▪ The CLR takes the IL code and transforms it to native machine language code that’s
appropriate for the current platform.
Step 5:
▪ This step occurs when the application is launched, just before the code is executed.

3) THE COMMON LANGUAGE RUNTIME
▪ The CLR is the engine that supports all the .NET languages.
▪ When a client requests an ASP.NET web page, the ASP.NET service runs inside the CLR environment,
executes your code, and creates a final HTML page to send to the client.
▪ It also provides a whole set of related services such as code verification, optimization, and object
management.
Implications of CLR:
▪ Deep language integration: The CLR makes no distinction between different languages like VB and
C# and compiles it to IL.
▪ Side-by-side execution: The CLR also has the ability to load more than one version of a component at
a time.
▪ Fewer errors: The CLR prevents many memory mistakes that are possible with lower-level languages
such as C++.
Drawbacks of CLR:
▪ Performance: With high-volume web applications, the processor is usually tied to the speed of an
external resource such as a database or the web server’s file system. With ASP.NET caching and some
well-written database code, you can ensure excellent performance for any web application.
▪ Code transparency: If you distribute a compiled application or component, other programmers may
have an easier time determining how your code works, as IL is easier to disassemble.

4) THE .NET CLASS LIBRARY
▪ The .NET class library is a giant repository of classes that provide prefabricated functionality.
▪ Much of the functionality in the base framework classes resides in the vast namespace called System.
▪ It includes:
1. Input/ Output Operations.
2. String Handling.
3. Managing Arrays,Lists, etc.
4. Accessing files and file systems.
5. Security.
6. Windows messages.
7. Database management.
8. Evaluation of mathematical functions.
9. Managing errors and exceptions.
10. Connecting to the Internet.

VISUAL STUDIO
▪ Visual Studio development tool provides a rich environment where you can rapidly create advanced applications.
Features of Visual Studio:
▪ Page design: You can create an attractive page with drag-and-drop ease by using Visual Studio’s integrated web form
designer.
▪ Automatic error detection: You could save hours of work when Visual Studio detects and reports an error before you run
your application.
▪ Debugging tools: Visual Studio allows you to watch your code in action and track the contents of variables. It has a built-in
web server that works just for debugging.
▪ IntelliSense: Visual Studio provides statement completion for recognized objects and automatically lists information such
as function parameters in helpful tooltips.
Visual Studio Editions:
▪ Visual Studio Express for Web: It allows you to build only web applications and components(for example, Windows
applications).
▪ Visual Studio Professional: It has all the features you need to build any type of .NET application (Windows or web).
▪ Visual Studio Premium or Ultimate: They incorporate features for automated testing and version control, which helps team
members coordinate their work on large projects.

QUESTIONS
▪ Write a short note on .NET framework.
▪ What are the steps for Language Compilation in .NET?
▪ What is Common Language Runtime (CLR)? Describe the roles of CLR in .NET
framework.What are its advantages & disadvantages?
▪ Explain framework base/.NET class library.
▪ What are the features of Visual Studio?
2018-2019
Ms. Ansari Nusrat, G.M.Momin Women's College 9

CHAPTER 2: THE C# LANGUAGE.
1) C# Language Basics
2) Variables and Data Types
3) Variable Operations
4) Object-Based Manipulation
5) Conditional Logic
6) Loops
7) Methods

1) C# LANGUAGE BASICS
▪ Case Sensitivity
▪ Commenting
▪ Statement Termination
▪ Blocks

Ms. Ansari Nusrat, G.M.Momin Women's College
CASE SENSITIVITY COMMENTING
▪ C# is a case-sensitive language.
▪ Keywords—such as if, for, foreach, while,
typeof, and so on—are always written in
lowercase letters.
▪ When you define your own variables, you
should give private variables names that start
with a lowercase letter and give public
variables names that start with an initial
capital letter, as used by other C#
programmers and the .NET Framework class
library.
Comments are lines of descriptive text that are ignored by the compiler.
C# provides two basic types of comments.
The first type is the single-line comment. In this case, the comment starts with
two forward slashes and continues for the entire current line:
// A single-line C# comment.
Multiple-line comments are often used to quickly disable an entire block of
code.This trick is called commenting out your code:
/*
... Any code here is ignored ...
*/
C# also includes an XML-based commenting syntax that you can use to
describe your code in a standardized way.
Here’s an example of a comment that provides a summary for an entire
application:
/// <summary>
/// This application provides web pages for my e-commerce site.
/// </summary>
XML comments always start with three slashes.
The benefit of XML-based comments is that automated tools (including Visual
Studio) can extract the comments from your code and use them to build help
references and other types of documentation.
2018-2019 12

STATEMENT TERMINATION BLOCKS
▪ C# uses a semicolon (;) as a statement-termination character.
▪ Every statement in C# code must end with this semicolon, except when you’re defining a block structure.
▪ By omitting the semicolon, you can easily split a statement of code over multiple physical lines. You just
▪ need to put the semicolon at the end of the last line to end the statement.
▪ The following code snippet demonstrates four equivalent ways to perform the same operation (adding three
▪ numbers together):
1) // A code statement on a single line.
myValue = myValue1 + myValue2 + myValue3;
2) // A code statement split over two lines.
myValue = myValue1 + myValue2 +
myValue3;
3) // A code statement split over three lines.
myValue = myValue1 +
myValue2 +
myValue3;
4) // Two code statements in a row.
myValue = myValue1 + myValue2;
myValue = myValue + myValue3;
The C# language rely heavily on curly braces—
parentheses {}.
Curly braces group multiple code statements
together.
You’ll group code statements because you want
them to be repeated in a loop, executed
conditionally, or grouped into a function referred to
as block structures.
{
// Code statements go here.
}
2018-2019 13

2) VARIABLES AND DATA TYPES
▪ Assignment and Initializers
▪ Strings and Escaped Characters
▪ Arrays
▪ The ArrayList
▪ Enumerations

VARIABLES AND DATA TYPES
▪ Variables can store numbers,text, dates, and times, and they
can even point to full-fledged objects.
▪ When you declare a variable, you give it a name and specify
the type of data it will store.
▪ To declare a local variable, you start the line with the data
type, followed by the name you want to use and end by a final
semicolon.
// Declare an integer variable named errorCode.
int errorCode;
// Declare a string variable named myName.
string myName;
▪ You can also declare a variable by using the type name from
the .NET class library.
▪ You can rewrite the earlier example with this code snippet:
class library names:
▪ System.Int32 errorCode;
▪ System.String myName;
▪ This code snippet uses fully qualified type names that
indicate that the Int32 data type and the String data type are
found in the System namespace.

DATATYPES C# Data
Types
Value Types
Simple/
Predefined
Types
Numeric
Integral
Types
Signed
Sbyte
Long
Int
short
Unsigned
byte
ULong
UInt
Ushort
Floating
Point Types
Float
double
Decimal
Types
Boolean Character
User-
Defined/
Complex
Types
Struct
Enum
Pointers
Reference
Types
User
Defined/
Complex
Types
Classes
Interfaces
Delegates
Array
Predefined/
Simple
Types
Object Type
String Type
16
2018-2019

ASSIGNMENT AND INITIALIZERS
▪ After you’ve declared your variables, you can freely assign values to them
by using this two-step process:
// Declare variables.
int errorCode;
string myName;
// Assign values.
errorCode = 10;
myName = "Matthew";
▪ You can also assign a value to a variable in the same line that you declare it:
int errorCode = 10;
string myName = "Matthew";
▪ The following code causes an error when you attempt to compile it:
int number; // Number is uninitialized.
number = number + 1; // This causes a compile error.
▪ The proper way to write this code is to explicitly initialize the number
variable to an appropriate value, such as 0, before using it:
int number = 0; // Number now contains 0.
number = number + 1; // Number now contains 1.
• C# defines a few special characters that you can append to literal
values to indicate their data type so that no conversion will be
required.These characters are as follows:
M (decimal)
D (double)
F (float)
L (long)
• For example: decimal myDecimal = 14.5M;
• You can use the all-purpose var keyword in place of the data type, as
shown:
var myDecimal = 14.5M;
• The myDecimal variable that you create using an inferred data type
behaves in exactly the same way as a myDecimal variable created
with an explicit data type.
2018-2019 17

STRINGS AND ESCAPED CHARACTERS
▪ The most useful character literals are as follows:
" (double quote)
n (new line)
t (horizontal tab)
(backward slash)
▪ You can also insert a special character based on its hex code by using the syntax x250.
This inserts a single character with hex value 250.
▪ Alternatively, you can turn off C# escaping by preceding a string with an @ symbol, as
shown here:
// c:MyAppMyFiles path.
string path = "c:MyAppMyFiles";
string path = @"c:MyAppMyFiles";

ARRAYS
▪ Arrays allow you to store a series of values that have the same data type. Each individual value in the array is accessed by using one or more index numbers. All arrays start at
a fixed lower bound of 0.
▪ When you create an array in C#, you specify the number of elements. Because counting starts at 0, the highest index is actually one less than the number of elements.
// Create an array with four strings (from index 0 to index 3).
string[] stringArray = new string[4];
// Create a 2x4 grid array (with a total of eight integers).
int[,] intArray = new int[2, 4];
▪ If your array includes simple data types, they are all initialized to default values (0 or false). If your array consists of strings or another object type, it’s initialized with null
references.
▪ You can also fill an array with data at the same time that you create it, as shown:
// Create an array with four strings, one for each number from 1 to 4.
string[] stringArray = {"1", "2", "3", "4"};
▪ The same technique works for multidimensional arrays, except that two sets of curly braces are required:
// Create a 4x2 array (a grid with four rows and two columns).
int[,] intArray = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
▪ To access an element in an array, you specify the corresponding index number in square brackets: [].
▪ myArray[0] accesses the first cell in a one-dimensional array, myArray[1] accesses the second cell, and so on.
int[] intArray = {1, 2, 3, 4};
int element = intArray[2]; // element is now set to 3.
▪ In a two-dimensional array, you need two index numbers:
int[,] intArray = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
int element = intArray[0, 1]; // element is now set to 2.

using System;
namespace OOPswithCSharp
{
class Arrays
{
public static void Main(string[] args)
{
Console.WriteLine("Single Dimension Array Sample");
// Single dim array
string[] strArray = new string[] { "ABC", "DEF", "GHI",
"JKL", "MNO" };
// Read array items using foreach loop
foreach (string str in strArray)
{
Console.WriteLine(str);
}
Console.WriteLine("-----------------------------");
Console.WriteLine("Multi-Dimension Array Sample");
string[,] string2DArray = new string[2, 2] { { "A",
"APPLE" }, { "P", "PINEAPPLE" } };
foreach (string str in string2DArray)
{
Console.WriteLine(str);
}
Console.WriteLine("Jagged Array Sample");
int[][] intjag =
{
new int[] {2,12},
new int[] {5, 4,5,3},
new int[] {6, 16, 26, 36, 46, 56}
};
// Loop through all items of a jagged array
for (int i = 0; i < intjag.Length; i++)
{
int[] innerArray = intjag[i];
for (int a = 0; a < innerArray.Length; a++)
{
Console.Write(innerArray[a] + " ");
}
Console.WriteLine();
}
Console.ReadKey();
}
}
}
A
R
R
A
Y
S
20
2018-2019

THE ARRAYLIST
▪ If you need a dynamic array-like list, you can use one of the collection classes
provided to all .NET languages through the .NET class library.
▪ ArrayList supports any type of object and always allows dynamic resizing.
// Create an ArrayList object.
ArrayList dynamicList = new ArrayList();
dynamicList.Add("one");
dynamicList.Add("two");
dynamicList.Add("three");
▪ To retrieve the first string, the object must first be converted to a string, as shown:
string item = Convert.ToString(dynamicList[0]);

int[] intArray = {1, 2, 3, 4};
int element = intArray[2];
// element is now set to 3.
ArrayList dynamicList = new
ArrayList();
dynamicList.Add("one");
dynamicList.Add("two");
Example:
2018-2019 22

ENUMERATIONS
▪ An enumeration is a group of related constants, each of which is given a descriptive name.
▪ Each value in an enumeration corresponds to a preset integer.
▪ // Define an enumeration type named UserType with three possible values.
enum UserType
{
Admin, //0 is automatically assigned to Admin,
Guest, //1 to Guest,
Other //and 2 to Other.
}
▪ Now you can use the UserType enumeration as a special data type that is restricted to one
of three possible values.
▪ You assign or compare the enumerated value by using the dot notation shown in the
following example:
// Create a new value and set it equal to the UserType.Admin constant.
UserType newUserType = UserType.Admin;

enum WeekDays
{
Sunday,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday
}
class Demo
{
public static void Main()
{
System.Console.WriteLine((int)WeekDays.Sunday);
System.Console.WriteLine((int)WeekDays.Monday);
System.Console.WriteLine((int)WeekDays.Tuesday);
System.Console.WriteLine((int)WeekDays.Wednesday);
System.Console.WriteLine((int)WeekDays.Thursday);
System.Console.WriteLine((int)WeekDays.Friday);
System.Console.WriteLine((int)WeekDays.Saturday);
}
}
class Demo
{
{
int Sunday = 0;
int Monday = 1;
int Tuesday = 2;
int Wednesday = 3;
int Thursday = 4;
int Friday = 5;
int Saturday = 6;
System.Console.WriteLine(Sunday);
System.Console.WriteLine(Monday);
System.Console.WriteLine(Tuesday);
System.Console.WriteLine(Wednesday);
System.Console.WriteLine(Thursday);
System.Console.WriteLine(Friday);
System.Console.WriteLine(Saturday);
}
}
enum WeekDays
{
Sunday=10,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday
}
enum WeekDays
{
Sunday,
Monday,
Tuesday,
Wednesday=10,
Thursday,
Friday,
Saturday
}
enum WeekDays
{
Sunday=10,
Monday=10,
Tuesday=10,
Wednesday=10,
Thursday=10,
Friday=10,
Saturday =10
}
enum WeekDays
{
Sunday = 10,
Monday = Sunday,
Tuesday = Monday,
Wednesday = Tuesday,
Thursday = Wednesday,
Friday = Thursday,
Saturday = Friday
}
System.Console.WriteLine(WeekDays.Wednesday.ToString());
E
N
U
M
E
R
A
T
I
O
N
S
24
2018-2019

3) VARIABLE OPERATIONS
▪ C# follows the conventional order of
operations, performing exponentiation first,
followed by multiplication and division and
then addition and subtraction.
▪ You can also control order by grouping
subexpressions with parentheses:
int number;
number = 4 + 2 * 3;
// number will be 10.
number = (4 + 2) * 3;
// number will be 18.
The operators in Table 2-2 are designed for manipulating numbers.
C# also allows you to use the addition operator ( + ) to join two strings:
// Join three strings together.
myName = firstName + " " + lastName;
C# provides special shorthand assignment operators, as shown:
myValue += 10;
myValue *= 3;
myValue /= 12;
• Advanced Math
• Type Conversions
2018-2019 25

ADVANCED MATH
▪ To use the math operations, we invoke the methods of the System.Math class.
▪ These methods are static, which means they are always available and ready to use.
▪ The following code snippet shows some sample calculations that you can perform
with the Math class:
double myValue;
myValue = Math.Sqrt(81); // myValue = 9.0
myValue = Math.Round(42.889, 2); // myValue = 42.89
myValue = Math.Abs(-10); // myValue = 10.0
myValue = Math.Log(24.212);// myValue = 3.18.. (and so on)
myValue = Math.PI; // myValue = 3.14.. (and so on)

TYPE CONVERSIONS
▪ Converting information from one data type to another is a
fairly common programming task.
▪ Conversions are of two types:
A) Widening. (Implicit Conversions)
B) Narrowing. (Explicit Conversions)
A) Implicit Conversion
short b=75;
// implicit conversion
int a=b;
▪ B) Explicit Conversion
▪ int to short, int to uint,
▪ uint to int, float to int,
▪ decimal to any numeric type,
▪ any numeric type to char.
‘Cast’ Operator is used to explicitly carry out
conversions.
The process is known as casting, and is done as
follows:
type variable1=(type) variable2;
Example:
int m=50;
byte n=(byte) m;
long x=1234L;
int y=(int) x;
Casting to convert numbers to strings and vice versa is
done by:
string countString = "10";
int count = Convert.ToInt32(countString);
OR
count = Int32.Parse(countString);
countString = Convert.ToString(count); 2018-2019 27

4) OBJECT-BASED MANIPULATION
▪ Every type in the .NET class library includes a ToString() method.
string myString;
int myInteger = 100;
myString = myInteger.ToString();
• The String Type
• The DateTime and TimeSpan Types
• The Array Type
2018-2019 28

THE STRING TYPE
▪ The following code snippet shows several ways to
manipulate a string by using its object nature:
string myString = "This is a test string ";
myString = myString.Trim(); // = "This is a test string"
myString = myString.Substring(0, 4); // = "This"
myString = myString.ToUpper(); // = "THIS"
myString = myString.Replace("IS", "AT"); // = "THAT"
int length = myString.Length; // = 4
▪ A method is just a procedure that’s hardwired into an
object and a property is similar to a variable.
▪ You can even use the string methods in succession in a
single (rather ugly) line:
myString = myString.Trim().Substring(0,
4).ToUpper().Replace("IS", "AT");
▪ myString = "hello".ToUpper(); // Sets myString to
"HELLO"

THE DATETIME AND TIMESPAN TYPES
▪ The DateTime and TimeSpan data types also have built-in methods and properties, that
allow you to perform three useful tasks:
1. Extract a part of a DateTime (for example, just the year) or convert a TimeSpan to a
specific representation (such as the total number of days or total number of minutes).
2. Easily perform date calculations.
3. Determine the current date and time and other information (such as the day of the week
or whether the date occurs in a leap year).
▪ The following block of code creates a DateTime object, sets it to the current date and
time, and adds a number of days.
DateTime myDate = DateTime.Now;
myDate = myDate.AddDays(100);
string dateString = myDate.Year.ToString();
▪ You can use a TimeSpan object to find the total number of minutes between two
DateTime objects:
DateTime myDate1 = DateTime.Now;
DateTime myDate2 = DateTime.Now.AddHours(3000);
TimeSpan difference;
difference = myDate2.Subtract(myDate1);
double numberOfMinutes;
numberOfMinutes = difference.TotalMinutes;
▪ The DateTime and TimeSpan classes also support the + and – arithmetic operators, as
shown below:
// Adding a TimeSpan to a DateTime creates a new DateTime.
DateTime myDate1 = DateTime.Now;
TimeSpan interval = TimeSpan.FromHours(3000);
DateTime myDate2 = myDate1 + interval;
// Subtracting one DateTime object from another produces a TimeSpan.
TimeSpan difference= myDate2 - myDate1;

THE ARRAY TYPE
▪ Every array is an instance of the System.Array type. If you want
to find out the size of a one-dimensional array, you can use the
Length property or the GetLength() method, both of which
return the total number of elements in an array:
int[] myArray = {1, 2, 3, 4, 5};
int noOfElements;
noOfElements = myArray.Length; // noOfElements= 5
▪ The following code snippet shows GetUpperBound() in action:
int[] myArray = {1, 2, 3, 4, 5};
int bound;
// Zero represents the first dimension of an array.
bound = myArray.GetUpperBound(0); // bound = 4
▪ On a one-dimensional array, GetUpperBound() always returns a
number that’s one less than the length.
▪ The following code snippet uses GetUpperBound() to find the
total number of rows and columns in a two-dimensional array:
// Create a 4x2 array (a grid with four rows and two columns).
int[,] intArray = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
int rows = intArray.GetUpperBound(0) + 1; // rows = 4
int cols = intArray.GetUpperBound(1) + 1; // cols = 2

5) CONDITIONAL LOGIC
▪ Conditional logic decides which action to take
based on user input, external conditions, or other
information.
▪ All conditional logic starts with a condition: a
simple expression that can be evaluated to true or
false.
▪ To build a condition, you can use any combination
of literal values or variables along with logical
operators.
• You can use all the comparison operators with any
numeric types.
• With string data types, you can use only the equality
operators (== and ! = ).
• The String.Compare() method considers that a string is
“less than” another string if it occurs earlier in an
alphabetic sort.
• The return value from String.Compare is 0 if the strings
match, 1 if the first supplied string is greater than the
second, and –1 if the first string is less than the second.
int result;
result = String.Compare("apple", "attach"); // result = -1
result = String.Compare("apple", "all"); // result = 1
result = String.Compare("apple", "apple"); // result = 0
• // Another way to perform string comparisons.
string word = "apple";
result = word.CompareTo("attach"); // result = -1
2018-2019 32

CONDITIONAL LOGIC
The if Statement
▪ The if statement helps to evaluate any
combination of conditions and deal with
multiple and different pieces of data.
if (myNumber > 10)
{ // Do something.}
else if (myString == "hello")
{ // Do something.}
else
{ // Do something.}
The switch Statement
▪ A switch statement is used to evaluate a single
variable or expression for multiple possible
values.
Example 1:
switch (myNumber)
{
case 1:
// Do something.
break;
case 2:
// Do something.
break;
default:
// Do something.
break;
}
Example 2:
switch (myNumber)
{
case 1:
case 2:
// This code executes if myNumber is 1
or 2.
break;
default:
// Do something.
break;
}
2018-2019 33

6) LOOPS
▪ Loops allow you to repeat a segment of code multiple times.
▪ C# has three basic types of loops, as follows:
1. You can loop a set number of times with a for loop.
2. You can loop through all the items in a collection of data by using a foreach loop.
3. You can loop while a certain condition holds true with a while or do...while loop.
for loop
for (int i = 0; i < 10; i++)
{
// This code executes ten times.
System.Diagnostics.Debug.Write(i);
}
OUTPUT:
0 1 2 3 4 5 6 7 8 9
string[] stringArray = {"one", "two", "three"};
for (int i = 0; i < stringArray.Length; i++)
{
System.Diagnostics.Debug.Write(stringArray[
i] + " ");
}
OUTPUT:
one two three
foreach loop
int[] intArray = {1,2,3};
foreach (int num in intArray)
{
num += 1;
}
OUTPUT:
1 2 3
string[] stringArray = {"one", "two", "three"};
foreach (string element in stringArray)
{
System.Diagnostics.Debug.Write(element + " ");
}
OUTPUT:
one two three
while loop
int i = 0;
while (i < 10)
{
i += 1;
}
int i = 0;
do
{
i += 1;
}
while (i < 10);
2018-2019 34

7) METHODS
▪ Methods are the most basic building
block you can use to organize your
code.
// This method doesn’t return any information.
void MyMethodNoReturnedData()
{ // Code goes here.}
// This method returns an integer.
int MyMethodReturnsData()
{
return 10;
}
1. Parameters
2. Method Overloading
3. Optional & Named Parameters
4. Delegates
2018-2019 35

1. PARAMETERS 2. METHOD OVERLOADING
Methods can also accept information
through parameters. They always begin
with a lowercase letter in any language.
//Accepts two parameters and returns their sum
private int AddNumbers(int number1, int number2)
{
return number1 + number2;
}
// Call a method with no parameters.
MyMethodNoReturnedData();
// Call a method that requires two integer parameters.
MyMethodNoReturnedData2(10, 20);
// Call a method with two integer parameters and an integer
return value.
int returnValue = AddNumbers(10, 10);
C# supports method overloading, which allows you to create more than one method with the
same name but
with a different set of parameters.
When you call the method, the CLR automatically chooses the correct version by examining the
parameters you supply.
class Method_Overloading
{
static int volume(int x)
{
return (x * x * x);
}
static double volume(float r, int h)
{
return (3.14519 * r * r*h);
}
static long volume(long l, int b, int h)
{
return (l * b * h);
}
{
Console.WriteLine("Volume is:"+volume(3));
Console.WriteLine("Volume is:" + volume(2.5F,8));
Console.WriteLine("Volume is:" + volume(100L,75,15));
Console.ReadKey();
}
}
2018-2019 36

3. OPTIONAL & NAMED PARAMETERS 4. DELEGATES
An optional parameter is any parameter that has a default value. If your
method has normal parameters and optional parameters, the optional
parameters must be placed at the end of the parameter list.
Example:
private string GetUserName(int ID, bool useShortForm = false)
{ // Code here.}
// Explicitly set the useShortForm parameter.
name = GetUserName(401, true);
// Don't set the useShortForm parameter, and use the default value
(false).
name = GetUserName(401);
Named parameters are used to pick out the parameters you want to set
by name.You have to simply add the parameter name followed by a
colon (:), followed by the value.
Example:
private decimal GetSalesTotalForRegion(int regionID, decimal minSale
= 0,decimal maxSale = Decimal.MaxValue, bool includeTax = false)
{// Code here.}
total = GetSalesTotalForRegion(523, maxSale: 5000);
• Delegates allow you to create a variable that “points” to a
method and can be reused in many situations.
Delegate Declaration.
Delegate Methods/Callable Entities Definition.
delegate double Maths(double x);
public double f1(double a)
{
}
public static double f2(double b)
{
}
Delegate Instantiation.
MyDelegate d1=new MyDelegate(functionname);
Delegate Invocation.
d1();
• A delegate variable can point only to a method that matches its
specific signature, i.e. same return type, the same number of
parameters, and the same data type for each parameter as the
delegate.
2018-2019 37

EXAMPLE: DELEGATES
using System;
public delegate int mydelegate(int p,int q);
namespace Console_PExam
{
class delegate_ams
{
public static int add(int p,int q)
{
return p + q;
}
public static int mul(int p, int q)
{
return p * q;
}
public static int sub(int p, int q)
{
return p - q;
}
}
38
class delegate_test
{
static void Main(string[] args)
{
//create delegate instances
mydelegate var1 = new mydelegate(delegate_ams.add);
mydelegate var2 = new mydelegate(delegate_ams.mul);
mydelegate var3 = new mydelegate(delegate_ams.sub);
Console.WriteLine("Addition of 2 Numbers:" + var1(100, 23));
Console.WriteLine("Multiplication of 2 numbers: " + var2(5, 2));
Console.WriteLine("Subtraction of 2 numbers: " + var3(123, 23));
Console.ReadKey();
}
}
}
2018-2019

QUESTIONS
▪ List & Explain the Data types available in C #.
▪ Write a program to insert and read elements from the Array.
▪ What is Jagged Array? OR Explain Variable-Sized Arrays with suitable example.
▪ Differentiate between Array and ArrayList.
▪ Why is there a necessity of enumerator data type in C#?
▪ What are Implicit Casting and Explicit Casting? What is type casting? Explain the concept of Boxing and Unboxing.
▪ List atleast five methods of the following classes: 1) String 2) DateTime & TimeSpan 3) Array.
▪ Give general form of switch statement. Explain with example.
▪ Explain for/foreach/while loop with proper syntax and example.
▪ What is the difference between for loop and foreach loop?
▪ Explain types of function parameters. (Optional & Named).
▪ Write a program to demonstrate Function Overloading. OR What is method overloading? Explain with examples. What are the steps involved for the
selection of a method in Method Overloading?
▪ Explain reference parameters and output parameters with a program.
▪ What are delegates and why are they required? OR What is delegate? Explain delegate declaration and delegate instantiation with example.
2018-2019

CHAPTER 3: TYPES, OBJECTS, AND NAMESPACES.
1) The Basics About Classes.
2) Building a Basic Class.
3) Value Types and Reference Types.
4) Understanding Namespaces and Assemblies.
5) Advanced Class Programming.

1) THE BASICS ABOUT CLASSES.
▪ Classes are the code definitions for objects.
▪ Classes interact with each other with the help of
three key ingredients:
▪ Properties: Properties allow you to access an
object’s data. Eg: Length.
▪ Methods: Methods allow you to perform an action
on an object. Eg: Open() method
▪ Events: Events provide notification that something
has happened. Eg: if a user clicks a button, the
Button object fires a Click event.
Static Members
Static Members are class members which can be used
without creating an object
Instance members
Instance members are class members which cannot
be used without a valid object.
Example:
DateTime myDate = DateTime.Now;
// Note that you need to use the object name myDate.
myDate = myDate.AddDays(1);
A Simple Class
To create a class, you must define it by using a special block structure:
public class MyClass
{
// Class code goes here.
}
2018-2019 41

2) BUILDING A BASIC CLASS.
▪ Accessibility Keywords
▪ Creating an Object
▪ Adding Properties
▪ Using Automatic Properties
▪ Adding a Method
▪ Adding a Constructor
▪ Adding an Event

FILE NAME: OOPswithCSharp.ACCESSIBILITY_CLASSES.CS
using System;
{
public class access
{
//private
private string sub1="Private:ASP.NET with C#";
//public
public string sub2 = "Public:Network Security";
//protected
protected string sub3="Protected:Linux Administration";
//internal
internal string sub4="Internal:Advanced Java";
// protected internal
protected internal string sub5= "Protected_Internal:Software
Testing";
}
class Accessibility_Classes:access
{
{
Accessibility_Classes ac = new Accessibility_Classes();
Console.WriteLine("Private"+ac.sub1);
Console.WriteLine("Public:t" + ac.sub2);
Console.WriteLine("Protected:t" + ac.sub3);
Console.WriteLine("Internal:t" + ac.sub4);
Console.WriteLine("Protected Internal:t" + ac.sub5);
Console.ReadKey();
}
}
}
FILE NAME: OOPswithCSharp.DEMO.CS
using System;
{
class Demo :access
{
{
access a=new access();
Console.WriteLine(a.sub1);
Console.ReadKey();
}
}
}
FILE NAME:
Protected_Internal.PROGRAM.CS
using System;
namespace Protected_Internal
{
using OOPswithCSharp;
public class Program:access
{
{
Program p= new Program();
Console.WriteLine(p.sub2);
Console.ReadKey();
}
}
}
43
The accessibility keywords
not only apply to variables but
also to methods, properties,
and events.
Accessibility
Keywords
2018-2019

CREATING AN OBJECT ADDING PROPERTIES
When creating an object, you need to specify the new keyword.
The new keyword instantiates the object, which means it grabs on to
a piece of memory and creates the object there.
The following code snippet creates an object based on the Product class
and then releases it:
Product saleProduct = new Product();
// Optionally you could do this in two steps:
// Product saleProduct;
// saleProduct = new Product();
// Now release the object from memory.
saleProduct = null;
You might want to assign an instance that already exists to your object
variable as shown below:
// Declare but don't create the product.
Product saleProduct;
// Call a function that accepts a numeric product ID parameter,
// and returns a product object.
saleProduct = FetchProduct(23);
You can compress this code into one statement:
Product saleProduct = FetchProduct(23);
Accessors are similar to any other type of method in that you can write as much code as you
need. Accessors usually have two parts: The get accessor & The set accessor.
The get accessor allows your code to retrieve data from the object.
The set accessor allows your code to set the object’s data.
public class Product
{
private string name;
private decimal price;
private string imageUrl;
public string Name
{
get
{ return name; }
set
{ name = value; }
}
public decimal Price
{
get
{ return price; }
set
{ price = value; }
}
public string ImageUrl
{
get
{ return imageUrl; }
set
{ imageUrl = value; }
}
}
2018-2019

USING AUTOMATIC PROPERTIES ADDING A METHOD
▪ Automatic properties are properties
without any code.
▪ When you use an automatic property, you
declare it, but you don’t supply the code for
the get and set accessors, and you don’t
declare the matching private variable.
{
public string Name { get; set; }
public decimal Price { get; set; }
public string ImageUrl { get; set; }
}
▪ The only disadvantage to use automatic
properties is that you’ll need to switch them
back to normal properties if you want to
add some more specialized code.
Methods are simply named procedures
that are built into your class.
When you call a method on an object, the
method does something useful, such as
return some calculated data.
{
public string GetHtml()
{
string htmlString;
htmlString = "<h1>" + Name + "</h1><br />";
htmlString += "<h3>Costs: " + Price.ToString() +
"</h3><br />";
htmlString += "<img src='" + ImageUrl + "' />";
return htmlString;
}
}
The GetHtml() method reads the private data
and format it in some attractive way.
2018-2019 45

ADDING A CONSTRUCTOR
Constructors :
▪ Constructors are the special types of methods of a class which get executed when it's
object is created.
▪ Constructors are responsible for object initialization and memory allocation of its class.
Rules for defining Constructors:
1: Constructors are called in descending order.
2:They have the same name as the class itself.
3:They do not specify a return type, not even void, as they do not return any value.

using System;
{
class Constructor_Destructor_Demo
{
public string x = "";
private Constructor_Destructor_Demo()
{
Console.WriteLine("Private Constructor called");
}
public Constructor_Destructor_Demo(int a,int b)
{
Console.WriteLine("Constructor:{0}",(a+b));
}
public Constructor_Destructor_Demo(float a, float b)
{
Console.WriteLine("Constructor:{0}" ,(a + b));
}
public Constructor_Destructor_Demo(string s)
{
this.x = s;
Console.WriteLine(s);
}
public
Constructor_Destructor_Demo(Constructor_Destructor_Demo obj)
{
this.x=obj.x;
}
static Constructor_Destructor_Demo()
{
Console.WriteLine("Static Constructor invoked");
}
~Constructor_Destructor_Demo()
{
Console.WriteLine("Destroyed" );
Console.ReadKey();
}
{
Constructor_Destructor_Demo obj1 = new
Constructor_Destructor_Demo();
Constructor_Destructor_Demo(3,17);
Constructor_Destructor_Demo(3.55f,17.0f);
Constructor_Destructor_Demo("Hi");
Constructor_Destructor_Demo(obj4);
Console.WriteLine(obj5.x);
Console.ReadKey();
}
}
}
O
B
J
E
C
T
L
I
F
E
C
Y
C
L
E 47
2018-2019

ADDING AN EVENT
48
• An event is an automatic notification that some
action has occurred.
• To handle an event, you first create a method called
an event handler.
• The event handler contains the code that should be
executed when the event occurs. Then you connect
the event handler to the event.
2018-2019

using System;
public delegate void MyEventHandler();//Delegate Declaration
class MyEvent
{
public static event MyEventHandler display;//Event Declaration
{
//Add event handlers
display += new MyEventHandler(red);
display += new MyEventHandler(blue);
display += new MyEventHandler(green);
display += new MyEventHandler(red);
//invoke the event
display.Invoke();
Console.ReadKey();
}
static void red()
{
Console.WriteLine("You selected Red");
}
static void blue()
{
Console.WriteLine("You selected Blue");
}
static void green()
{
Console.WriteLine("You selected Green");
}
}
49
2018-2019

3) VALUE TYPES AND REFERENCE TYPES
Value types: Value types directly contain their data, and instances of value types are
either allocated on the stack or allocated inline in a structure.Value types can be built-in
(implemented by the runtime), user-defined, or enumerations.
Reference types: Reference types store a reference to the value's memory address, and
are allocated on the heap. Reference types can be self-describing types, pointer types, or
interface types.
▪ Assignment operations.
▪ Equality Testing.
▪ Passing Parameters by Reference and by Value.
▪ Reviewing .NET Types.

ASSIGNMENT OPERATIONS EQUALITY TESTING
When you assign a simple data variable to another
simple data variable, the contents of the variable
are copied:
varA = varB; // varA has a copy of the
contents of varB.
// Create a new Product object.
Product productVariable1 = new
Product("Kitchen Garbage", 49.99M);
// Declare a second variable.
Product productVariable2;
productVariable2 = productVariable1;
// productVariable1 and productVariable2 now
both point to the same thing.
productVariable2.Price = 25.99M;
//productVariable1.Price is also set to 25.99.
When you compare value types (such as
integers), you’re comparing the contents:
if (varA == varB)
{
// This is true as long as the integers have the same
content.
}
When you compare reference type variables,
you’re actually testing whether they’re the
same instance.
if (productVariable1 == productVariable2)
{
// This is true if both productVariable1 and
productVariable2
// point to the same thing.
// This is false if they are separate, yet identical, objects.
} 2018-2019 51

using System;
namespace Functions_CSharp
{
class PassByValue
//Value of Actual Parameters= Corresponding Formal Parameters
//Refers to the copies of variables
{
static void change(int m)
{
Console.WriteLine("-------------------------------");
Console.WriteLine("Value of m(Before)=" + m);
m = m + 10;
Console.WriteLine("Value of m(After)m=" + m);
}
{
int x = 100;
Console.WriteLine("Before method is invoked:x="+x);
change(x);
Console.WriteLine("After method is invoked:x=" + x);
Console.ReadKey();
}
}
}
using System;
{
class PassByReference
{
//Value of Actual Parameters= (Aliases) Corresponding Formal Parameters
//Refers to the original values of variables
static void change(ref int m)
{
Console.WriteLine("Value of m(Before)=" + m);
m = m + 10;
Console.WriteLine("Value of m(After)m=" + m);
}
{
int x = 100;
Console.WriteLine("Before method is invoked:x=" + x);
change(ref x);
Console.WriteLine("After method is invoked:x=" + x);
Console.ReadKey();
}
}
}
52
When you use pass-by value
parameters, the method
receives a copy of the
parameter data.
If the method modifies the
parameter, this change won’t
affect the code that called the
method.
With pass-by-reference, the
method accesses the
parameter value directly.
If a method changes the value
of a pass-by-reference
parameter, the original object
is also modified.
2018-2019

using System;
{
class Output_Parameter
{
static void Square(int x, out int y)
{
y = x * x;
}
{
int m;
//Console.WriteLine("m=" + m);
Square(10, out m);
Console.WriteLine("m=" + m);
Console.ReadKey();
}
}
}
53
When you use output parameters, the calling code can submit an uninitialized variable as a parameter,
which is otherwise forbidden.
2018-2019

REVIEWING .NET TYPES
▪ The .NET class library is actually composed of types, that
includes several object-like relatives:
1) Classes: This is the most common type in the .NET Framework.
Strings and arrays are two examples of .NET classes.
2) Structures: Structures, like classes, can include fields,
properties, methods, and events. They are value types, and lack
some of the more advanced class features (such as inheritance)
and are generally simpler and smaller. Integers, dates, and chars
are all structures.
3) Enumerations: An enumeration defines a set of integer
constants with descriptive names.
4) Delegates: A delegate is a function pointer that allows you to
invoke a procedure indirectly.
5) Interfaces: Interfaces are an advanced technique of object-
oriented programming, and they’re useful when standardizing
how objects interact.

55
2018-2019

using System;
{
struct student
{
public int sid;
public string sname;
}
class Struct_Keyword
{
{
student[] s = new student[5];
for (int i = 0; i < 5; i++)
{
Console.WriteLine("---------------------------");
Console.WriteLine("Enter Details for {0} Student ", i + 1);
Console.Write("Enter Student id:");
s[i].sid = int.Parse(Console.ReadLine());
Console.Write("Enter Student Name:");
s[i].sname = Console.ReadLine();
Console.WriteLine("Student's Details");
Console.WriteLine("ID:" + s[i].sid);
Console.WriteLine("Name:" + s[i].sname);
}
Console.ReadKey();
}
}
}
56
2018-2019

4) UNDERSTANDING NAMESPACES AND ASSEMBLIES
▪ Namespaces are C# program elements
designed to help you organize your
programs.
▪ The System namespace contains fundamental
classes and base classes that define
commonly-used value and reference data
types.
▪ Using Namespaces.
▪ Importing Namespaces.
▪ Using Assemblies.

USING NAMESPACE IMPORTING NAMESPACES
▪ If you want to organize your code into multiple namespaces, you can
define the namespace by using a simple block structure, as shown here:
namespace MyCompany
{
namespace MyApp
{
{
// Code goes here.
}
}
}
▪ In the preceding example, the Product class is in the namespace
MyCompany.MyApp.
▪ Code inside this namespace can access the Product class by name. Code
outside it needs to use the fully qualified name, as in
MyCompany.MyApp.Product.
• To import a namespace, you use the using statement.
• These statements must appear as the first lines in your code file, outside of
any namespaces or block structures:
using MyCompany.MyApp;
• Consider the situation without importing a namespace:
MyCompany.MyApp.Product salesProduct = new
MyCompany.MyApp.Product(. . .);
• It’s much more manageable when you import the MyCompany.MyApp
namespace.
• When you do, you can use this syntax instead:
Product salesProduct = new Product(. . .);
2018-2019 58

USING ASSEMBLIES
▪ Assemblies are the physical
files that contain compiled
code.
▪ Assembly files have the
extension .exe if they are
stand-alone applications, or
.dll if they’re reusable
components.
▪ When your web application is
compiled, it’s turned into a
DLL file. The ASP.NET engine
executes it when a web
request is received.
▪ You can find the core
assemblies for the .NET
Framework in the folder
C:WindowsAssembly.
▪ An assembly can contain
multiple namespaces.

5) ADVANCED CLASS PROGRAMMING
▪ Inheritance
▪ Static Members
▪ Casting Objects
▪ Partial Classes
▪ Generics
60
2018-2019

INHERITANCE STATIC MEMBERS
Inheritance is a form of code reuse. It allows one class to acquire and
extend the functionality of another class.
public class TaxableProduct : Product
{
}
public TaxableProduct(string name, decimal price, string imageUrl) :
base(name, price, imageUrl)
{
}
STATIC METHOD:-----------------
using System;
class Method
{
public static int Cube(int x)
{
return (x * x * x);
}
}
class MethodTest
{
{
//Method M = new Method();
int y = Method.Cube(5);
Console.WriteLine("Cube is:" + y);
Console.ReadKey();
}
}
} 2018-2019 61

CASTING OBJECTS
▪ Type casting is a way to convert a
variable from one data type to
another data type.
▪ Boxing means the conversion of
a value type on the stack to
object type on the heap.
▪ Unboxing is the process of
converting the object type back
to the value type. We can only
unbox a variable that has
previously been boxed.
Boxing
Unboxing
2018-2019 62

PARTIAL CLASSES
Partial classes give you the ability to
split a single class into more than one
C# source code (.cs) file.
With partial, you can physically
separate a class into multiple files in
the same project.
C# program that uses partial class :
class Program
{
static void Main()
{
A.A1();
A.A2();
}
}
Contents of file A1.cs:
using System;
partial class A
{
public static void A1()
{
Console.WriteLine("A1");
}
}
Contents of file A2.cs:
using System;
partial class A
{
public static void A2()
{
Console.WriteLine("A2");
}
}
Output
A1
A2
2018-2019 63

GENERICS
▪ Generics allow you to create classes that are parameterized by type.
▪ // Create the ArrayList.
▪ ArrayList products = new ArrayList();
▪ // Add several Product objects.
▪ products.Add(product1);
▪ // Create the List for storing Product objects.
▪ List<Product> products = new List<Product>();

DIFFERENCE BETWEEN GENERIC AND NON-GENERIC COLLECTIONS
Generic Collections Non Generic Collections
These are the collections that can
hold data of same type and we can
decide while initializing what type of
data that collections can hold.
They hold elements of different
data types, i.e. object type.
Type Safe. Not Type Safe.
Secure. Not Secure.
Reduced overhead of implicit and
explicit conversions.
It includes overhead of implicit
and explicit conversions.
Namespace:
System.Collections.Generic;
Namespace: System.Collections;
// Generic collection
List<T> list = new List<T>();
list.Add("Any object");
// Non generic collection
List list = new List();
list.Add("Any object");
65
2018-2019

QUESTIONS
▪ Define each of the following terms: A) Static Class. B) Partial Class.
▪ State different types of accessibility keywords.
▪ Differentiate between Properties and Automatic Properties.
▪ Explain the Object Lifecycle.
▪ What is constructor? Is it compulsory to use constructor in a class? OR What are the rules in defining a constructor? Explain static constructor with
example.
▪ Can events be implemented without delegates? Justify the statement.
▪ Explain Value Types & Reference Types.
▪ Explain pass-by-value & pass-by-reference.
▪ Explain output parameters.
▪ Differentiate between Class and Structure.
▪ What is namespace? Explain System namespace.
▪ Write a short note on Assembly.
▪ What is inheritance? What are the different forms of inheritance?
▪ What are the different types of generic collections? Explain with example.
2018-2019

Advanced Web Programming_UNIT_1_NewSyllabus.pdf

More Related Content

Similar to Advanced Web Programming_UNIT_1_NewSyllabus.pdf

More from ansariparveen06

Recently uploaded

Advanced Web Programming_UNIT_1_NewSyllabus.pdf