Advanced Web Programming_UNIT_1_NewSyllabus.pdf

Awp

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

2. 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

3. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 3

4. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 4

5. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 5

6. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 6

7. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 7

8. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 8

9. 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-2019Ms. Ansari Nusrat, G.M.Momin Women's College 9

10. 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
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 10

11. 1) C# LANGUAGE BASICS
▪Case Sensitivity
▪Commenting
▪Statement Termination
▪Blocks
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 11

12. 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

13. 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;
Ms. Ansari Nusrat, G.M.Momin Women's College
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

14. 2) VARIABLES AND DATA TYPES
▪Assignment and Initializers
▪Strings and Escaped Characters
▪Arrays
▪The ArrayList
▪Enumerations
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 14

15. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 15

16. 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
162018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

17. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
•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

18. 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:\MyApp\MyFiles path.
string path = "c:\\MyApp\\MyFiles";
string path = @"c:\MyApp\MyFiles";
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 18

19. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 19

20. 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("-----------------------------");
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.WriteLine("-----------------------------");
Console.ReadKey();
}
}
}
A
R
R
A
Y
S
202018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

21. 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]);
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 21

22. Ms. Ansari Nusrat, G.M.Momin Women's College
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

23. 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;
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 23

24. 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
{
public static void Main()
{
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
242018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

25. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
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

26. 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)
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 26

27. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
‘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

28. 4) OBJECT-BASED MANIPULATION
▪Every type in the .NET class library includes a ToString() method.
string myString;
int myInteger = 100;
myString = myInteger.ToString();
Ms. Ansari Nusrat, G.M.Momin Women's College
•The String Type
•The DateTime and TimeSpan Types
•The Array Type
2018-2019 28

29. 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"
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 29

30. THE DATETIMEAND TIMESPANTYPES
▪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;
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 30

31. 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
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 31

32. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
•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

33. 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;
}
Ms. Ansari Nusrat, G.M.Momin Women's College
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

34. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
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;
// This code executes ten times.
}
int i = 0;
do
{
i += 1;
// This code executes ten times.
}
while (i < 10);
2018-2019 34

35. 7) METHODS
▪Methods are the most basic building
block you can use to organize your
code.
Ms. Ansari Nusrat, G.M.Momin Women's College
// 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

36. 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);
Ms. Ansari Nusrat, G.M.Momin Women's College
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);
}
public static void Main(string[] args)
{
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

37. 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);
Ms. Ansari Nusrat, G.M.Momin Women's College
•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

38. 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-2019Ms. Ansari Nusrat, G.M.Momin Women's College

39. 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-2019Ms. Ansari Nusrat, G.M.Momin Women's College 39

40. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 40

41. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
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

42. 2) BUILDING A BASIC CLASS.
▪Accessibility Keywords
▪Creating an Object
▪Adding Properties
▪Using Automatic Properties
▪Adding a Method
▪Adding a Constructor
▪Adding an Event
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 42

43. FILE NAME: OOPswithCSharp.ACCESSIBILITY_CLASSES.CS
using System;
namespace OOPswithCSharp
{
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
{
public static void Main(string[] args)
{
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;
namespace OOPswithCSharp
{
class Demo :access
{
public static void Main()
{
access a=new access();
Console.WriteLine(a.sub1);
Console.WriteLine(a.sub2);
Console.WriteLine(a.sub3);
Console.WriteLine(a.sub4);
Console.WriteLine(a.sub5);
Console.ReadKey();
}
}
}
FILE NAME:
Protected_Internal.PROGRAM.CS
using System;
namespace Protected_Internal
{
using OOPswithCSharp;
public class Program:access
{
public static void Main(string[] args)
{
Program p= new Program();
Console.WriteLine(p.sub2);
Console.WriteLine(p.sub3);
Console.WriteLine(p.sub5);
Console.ReadKey();
}
}
}
43
The accessibility keywords
not only apply to variables but
also to methods, properties,
and events.
Accessibility
Keywords
2018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

44. 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-2019Ms. Ansari Nusrat, G.M.Momin Women's College 44

45. 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 class Product
{
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.
Ms. Ansari Nusrat, G.M.Momin Women's College
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 class Product
{
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

46. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 46

47. using System;
namespace OOPswithCSharp
{
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();
}
public static void Main(string[] args)
{

Constructor_Destructor_Demo obj1 = new
Constructor_Destructor_Demo();
Constructor_Destructor_Demo obj2 = new
Constructor_Destructor_Demo(3,17);
Constructor_Destructor_Demo obj3 = new
Constructor_Destructor_Demo(3.55f,17.0f);
Constructor_Destructor_Demoobj4 = new
Constructor_Destructor_Demo("Hi");
Constructor_Destructor_Demo obj5 = new
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 472018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

48. 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-2019Ms. Ansari Nusrat, G.M.Momin Women's College

49. using System;
public delegate void MyEventHandler();//Delegate Declaration
class MyEvent
{
public static event MyEventHandler display;//Event Declaration
public static void Main(string[] args)
{
//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");
}
}
492018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

50. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 50

51. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
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

52. 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);
Console.WriteLine("-------------------------------");
}
public static void Main(string[] args)
{
int x = 100;
Console.WriteLine("-------------------------------");
Console.WriteLine("Before method is invoked:x="+x);
Console.WriteLine("-------------------------------");
change(x);
Console.WriteLine("-------------------------------");
Console.WriteLine("After method is invoked:x=" + x);
Console.WriteLine("-------------------------------");
Console.ReadKey();
}
}
}
using System;
namespace Functions_CSharp
{
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("-------------------------------");
Console.WriteLine("Value of m(Before)=" + m);
m = m + 10;
Console.WriteLine("Value of m(After)m=" + m);
Console.WriteLine("-------------------------------");
}
public static void Main(string[] args)
{
int x = 100;
Console.WriteLine("-------------------------------");
Console.WriteLine("Before method is invoked:x=" + x);
Console.WriteLine("-------------------------------");
change(ref x);
Console.WriteLine("-------------------------------");
Console.WriteLine("After method is invoked:x=" + x);
Console.WriteLine("-------------------------------");
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-2019Ms. Ansari Nusrat, G.M.Momin Women's College

53. using System;
namespace Functions_CSharp
{
class Output_Parameter
{
static void Square(int x, out int y)
{
y = x * x;
}
public static void Main(string[] args)
{
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-2019Ms. Ansari Nusrat, G.M.Momin Women's College

54. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 54

55. 552018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

56. using System;
namespace Functions_CSharp
{
struct student
{
public int sid;
public string sname;
}
class Struct_Keyword
{
public static void Main(string[] args)
{
student[] s = new student[5];
for (int i = 0; i < 5; i++)
{
Console.WriteLine("---------------------------");
Console.WriteLine("Enter Details for {0} Student ", i + 1);
Console.WriteLine("---------------------------");
Console.Write("Enter Student id:");
s[i].sid = int.Parse(Console.ReadLine());
Console.Write("Enter Student Name:");
s[i].sname = Console.ReadLine();
Console.WriteLine("---------------------------");
Console.WriteLine("Student's Details");
Console.WriteLine("---------------------------");
Console.WriteLine("ID:" + s[i].sid);
Console.WriteLine("Name:" + s[i].sname);
}
Console.ReadKey();
}
}
}
562018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

57. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 57

58. 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
{
public class Product
{
// 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
•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

59. 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:\Windows\Assembly.
▪An assembly can contain
multiple namespaces.
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 59

60. 5) ADVANCED CLASS PROGRAMMING
▪Inheritance
▪Static Members
▪Casting Objects
▪Partial Classes
▪Generics
602018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

61. 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)
{
}
Ms. Ansari Nusrat, G.M.Momin Women's College
STATIC METHOD:-----------------
using System;
class Method
{
public static int Cube(int x)
{
return (x * x * x);
}
}
class MethodTest
{
public static void Main(string[] args)
{
//Method M = new Method();
int y = Method.Cube(5);
Console.WriteLine("Cube is:" + y);
Console.ReadKey();
}
}
}
2018-2019 61

62. 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.
Ms. Ansari Nusrat, G.M.Momin Women's College
Boxing
Unboxing
2018-2019 62

63. 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();
}
}
Ms. Ansari Nusrat, G.M.Momin Women's College
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

64. 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);
▪products.Add(product2);
▪products.Add(product3);
▪// Create the List for storing Product objects.
▪List<Product> products = new List<Product>();
Ms. Ansari Nusrat, G.M.Momin Women's College 2018-2019 64

65. 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=newList<T>();
list.Add("Any object");
// Non generic collection
Listlist=newList();
list.Add("Any object");
652018-2019Ms. Ansari Nusrat, G.M.Momin Women's College

66. 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-2019Ms. Ansari Nusrat, G.M.Momin Women's College 66