.Net to Print

8/3/2019 .Net to Print

1/12

Basic Input & output with the Console Class:Many of the example applications make use of the System.Console class. Console is one

ofmany types defined in the System namespace. As its name implies, this class encapsulates

input, output, and error stream manipulations. Thus, this type is mostly useful when creating

console-based applications rather than Windows based or Web-based applications.

Principal among the methods of System.Console are Read( ), ReadLine( ) Write( ) and

WriteLine( ), all of which are defined as static.Prep By: Sunitha Pramod Page 8

WriteLine( ) pumps a text string (including a carriage return) to the output stream.

The Write( ) method pumps text to the output stream without a carriage return. ReadLine( ) allows you to receive information from the input stream up until the carriagereturn, while

Read( ) is used to capture a single character from the input stream.// Make use of the Console class to perform basic IO.

using System;

class helloclass

{

static int Main(string[] args)

{Console.Write("\n\nEnter your name: ");

string s = Console.ReadLine();

Console.WriteLine("Name is {0}\n", s);

Console.Write("Enter your age: ");s = Console.ReadLine();

Console.WriteLine("you are {0} years old: ", s);

Console.ReadLine();

return 0;

}

}

Output:

Enter your name: smithName is smith

Enter your age: 25

you are 25 years old:

```````````````````````````````````````````````````

1. The Default Parameter Passing BehaviorThe default manner in which a parameter is sent into a function is by value. Simply put, if

you do not mark an argument with a parameter-centric keyword, a copy of the data is passed into

the function:

using System;

class Program{

public static int Add(int x, int y)

{

int ans = x + y;

// Caller will not see these changes as you are modifying a copy// of the original data

x = 1000;

y = 2000;


2/12

return ans;

}

static void Main(string[] args)

{

int x=5,y=7;

Console.WriteLine("Before call: X:{0},y:{1}",x,y);

Console.WriteLine("Answer is: {0}",Add(x,y));Console.WriteLine("After call: X: {0},y:{1}",x,y);

Console.ReadLine();

}

Prep By: Sunitha Pramod Page 20

}

Output:

Before call: X:5,y:7

Answer is: 12

After call: X: 5,y:7

2. The Reference (ref) parametersReference parameters don't pass the values of the variables used in the function member

invocation - they use the variables themselves. Rather than creating a new storage location forthe variable in the function member declaration, the same storage location is used, so the value of

the variable in the function member and the value of the reference parameter will always be the

same. Reference parameters need the ref modifier as part of both the declaration and the

invocation - that means it's always clear when you're passing something by reference.using System;

class Program

{

public static void swap(ref string st1,ref string st2)

{

string temp;

temp = st1;

st1 = st2;st2 = temp;

}


{

string s1 = "First string";

string s2 = "second string";

Console.WriteLine("Before: {0},{1}", s1, s2);

swap(refs1, refs2);

Console.WriteLine("After: {0},{1}", s1, s2);

Console.ReadLine();

}

Output: Before: First string,second stringAfter: second string,First string

Here, the caller has assigned an initial value to local string data (s1 and s2). Once the call

to swap returns, s1 now contains the values second string, while s2 contains the values First

string.

3. The Output (out) parametersPrep By: Sunitha Pramod Page 21

Like reference parameters, output parameters don't create a new storage location, but

use the storage location of the variable specified on the invocation. Output parameters need the


3/12

out modifier as part of both the declaration and the invocation - that means it's always clear

when you're passing something as an output parameter.

Output parameters are very similar to reference parameters. The only differences are:

The variable specified on the invocation doesn't need to have been assigned a value

before it is passed to the function member. If the function member completes normally,

the variable is considered to be assigned afterwards (so you can then "read" it).

The parameter is considered initially unassigned (in other words, you must assign it avalue before you can "read" it in the function member).

The parametermustbe assigned a value before the function member completes normally.

using System;

class Program

{

public static void Add(int x, int y, out int ans)

{

ans = x + y;

}


{

int ans;Add(90, 90, out ans);

Console.WriteLine("90+90={0}", ans);

Console.ReadLine();

}}

OutPut: 90+90=180

//Returning multiple output parameters

using System;

class Program

{

public static void FillTheseValues(out int a, out string b, out bool c)

{a=10;

b="hello";

c = true;

}


{


int i;

string str;

bool b;

FillTheseValues(out i, out str, out b);

Console.WriteLine("int is: {0}", i);Console.WriteLine("String is: {0}", str);

Console.WriteLine("Bool is :{0}", b);

Console.ReadLine();

}

}

Output:

int is: 10

String is: hello


4/12

Bool is :True

4. The Params Modifier:In C# 'params' parameter allows us to create a method that may be sent to a set of

identically typed arguments as a single logical parameter. To better understand this situation

let us see a program that calculates the average of any number of integers.

using System;

class Program{

public static int Average(params int[] values)

{

int sum = 0;

for (int i = 0; i < values.Length; i++)

sum = sum + values[i];

return (sum / values.Length);

}


{

//pass int values in comma separated form

int average;average = Average(30, 40, 70);

Console.WriteLine("The average is: {0}", average);


//Pass an array of intint[] data ={ 30, 40, 70 };

average=Average(data);

Console.WriteLine("The avearge of the int array ele:{0}",average);

Console.ReadLine();

}

}

Output:

The average is: 46The avearge of the int array ele:46

555555555555555

\Differences between value type and Reference type:

Value types are stored in stack

Reference types are stored in heap When we assign one value type to another value type, it is cloned and the two instancesoperate independently.

For eg, a=b; A new memory ;location is allocated for a and it is hold the valueindividually. Changing the value ofb does not affect a.

When reference type is assigned to another reference type, the two reference share thesame instance and change made by the one instance affects the other.

For eg, a=b; a reference (pointer) is created for a and both a and b now points to same

address. Any alteration made to b will affect a. Value types cannot be set to null

Reference types can be set to null Converting value type to reference type is called boxing.

Converting reference type to value type to called unboxing.

Value types are by default passed by value to other methods.


5/12

Reference types are by default passed by reference to other methods.

The stack holds value type variables plus return addresses for functions. All numeric types, ints, floats a

```````````````````````````````````````Passing Reference Types by Value:using System;

class person

{public string fullName;

public int age;

public person() { }

public person(string n, int a)

{

fullName = n;

age = a;

}

public void printInfo()

{

Console.WriteLine("{0} is {1} years old", fullName, age);

}}

class program

{

public static void SendAPersonByValue(person p){

//change the age of p

p.age = 99;


//will the caller see this reassignment

p = new person("nikki", 25);

}

public static void Main(string[] args){

//passing reference types by value

Console.WriteLine("******passing person object by value********");

person smith = new person("smith", 10);

Console.WriteLine("Before by value call, person is:");

smith.printInfo();

SendAPersonByValue(smith);

Console.WriteLine("After by value call, person is:");

smith.printInfo();

Console.ReadLine();

}

}Output:

******passing person object by value********

Before by value call, person is:

smith is 10 years old

After by value call, person is:

smith is 99 years old

Passing Reference Types by Reference:using System;


6/12

class person

{

public string fullName;

public int age;

public person() { }

public person(string n, int a)

{fullName = n;

age = a;

}

public void printInfo()

{

Console.WriteLine("{0} is {1} years old", fullName, age);

}

}


class program

{

public static void SendAPersonByReference(refperson p){

//change the age of p

p.age = 99;

//will the caller see this reassignmentp = new person("nikki", 25);

}

public static void Main(string[] args)

{

//passing reference types by value

Console.WriteLine("******passing person object by

reference********");

person smith = new person("smith", 10);Console.WriteLine("Before by ref call, person is:");

smith.printInfo();

SendAPersonByReference(refsmith);

Console.WriteLine("After by ref call, person is:");

smith.printInfo();

Console.ReadLine();

}

}

Output:

******passing person object by reference********

Before by ref call, person is:

smith is 10 years oldAfter by ref call, person is:

nikki is 25 years old

77777777777777777

Understanding Boxing and Unboxing Operations:Boxing and unboxing is a essential concept in C# type system. With Boxing and unboxing

one can link between value-types and reference-types by allowing any value of a value-type to


7/12

be converted to and from type object. Boxing and unboxing enables a unified view of the type

system wherein a value of any type can ultimately be treated as an object.


Converting value type to reference type is called boxing by storing the variable in a

System.Object.

Converting reference type to value type to called unboxing

The following example shows both boxing and unboxing:class Test

{

Public static void Main()

{

int i=1;

object o = i; //boxing

int j=(int) o; //unboxing

}

}

An int value can be converted to object and back again to int When a variable of a value type needs to be converted to a reference type, an object box is

allocated to hold the value, and the value is copied into the box. Unboxing is just opposite. When an object box is cast back to its original value type, thevalue is coped out of the box and into the appropriate storage location.

using System;

class program{


{

Int32 x1 = 10;

object o1 = x1;// Implicit boxing

Console.WriteLine("The Object o1 = {0}", o1);// prints out 10

//-----------------------------------------------------------

Int32 x2 = 10;object o2 = (object)x2;// Explicit Boxing

Console.WriteLine("The object o2 = {0}", o2);// prints out 10

Console.ReadLine();

}

}

Output:


The Object o1 = 10

The object o2 = 10

Unboxing Custom Value Types:using System;

struct Mypoint{

public int x, y;

}

class program

{

//compiler error, since to access the field data of Mypoint, you must

//first unbox the parameter. This is done in the following method.

/*static void UseBoxedMypoint(object o)


8/12

{

Console.WriteLine({0},{1}},o.x,o.y);

}*/

static void UseBoxedMypoint(object o)

{

if(o is Mypoint)

{Mypoint p = (Mypoint)o;

Console.WriteLine("{0},{1}", p.x, p.y);

}

else

Console.WriteLine("You did not send a Mypoint");

}


{

Mypoint p;

p.x = 10;

p.y = 20;

UseBoxedMypoint(p);Console.ReadLine();

}

}

Output:10,20

55555555555

Method Purposepublic virtual bool Equals(object ob)

whether the object is the same as the one referred

to by ob.public static bool Equals(object ob1, whether ob1 is the same as ob2.


object ob2)

protected Finalize()

Performs shutdown actions prior to garbagecollection.

public virtual int GetHashCode() Returns the hash code.

public Type GetType() Return the type of an object.

protected object MemberwiseClone()

Makes a "shallow copy" of the object. (The

members are copied, but objects referred to by

members are not.)public static bool

ReferenceEquals(object ob1, object

ob2)

whether ob1 and ob2 refer to the same object.

public virtual string ToString()Returns a string that describes the object. It is

automatically called when an object is output

using WriteLine().


9/12

6666666666666

.NET Array Types:In C#, an array index starts at zero. That means, first item of an array will be stored at 0th

position. The position of the last item on an array will total number of items - 1.

In C#, arrays can be declared as fixed length or dynamic. Fixed length array can stores a

predefined number of items, while size of dynamic arrays increases as you add new items to thearray. You can declare an array of fixed length or dynamic.

For example, the following like declares a dynamic array of integers.

int [] intArray;

The following code declares an array, which can store 5 items starting from index 0 to 4.

int [] intArray;

intArray = new int[5];

The following code declares an array that can store 100 items starting from index 0 to 99.

int [] intArray;

intArray = new int[100];

Arrays can be divided into four categories. These categories are single-dimensional

arrays, multidimensional arrays or rectangular arrays, jagged arrays, and mixed arrays.

In C#, arrays are objects. That means declaring an array doesn't create an array. Afterdeclaring an array, you need to instantiate an array by using the "new" operator


The following code declares and initializes an array of three items of integer type.

int [] intArray;

intArray = new int[3] {0, 1, 2};

The following code declares and initializes an array of 5 string items.

string[] strArray = new string[5] {"Ronnie", "Jack", "Lori", "Max", "Tricky"};

You can even direct assign these values without using the new operator.

string[] strArray = {"Ronnie", "Jack", "Lori", "Max", "Tricky"};

You can initialize a dynamic length array as following

string[] strArray = new string[] {"Ronnie", "Jack", "Lori", "Max", "Tricky"};

Arrays As Parameters (and Return Values):Once you created an array, you are free to pass it as a parameter and receive it as a

member return vales.

Example:

using System;

class program

{

static void PrintArrays(int[] MyInt){

Console.WriteLine("The int array is");

for (int i = 0; i < MyInt.Length; i++)

Console.WriteLine(MyInt[i]);

}static string[] GetStringArray()

{

string[] TheStrings = { "Hello", "What", "That", "stringarray" };

return TheStrings;//return a string array

}


{

int[] ages ={ 10, 20, 30, 40 };


10/12

PrintArrays(ages);//passing an array as parameter

string[] strs = GetStringArray(); //Receiving a string array in a var strs

Console.WriteLine("The string array is");

foreach (string s in strs)

Console.WriteLine(s);

Console.ReadLine();

Prep By: Sunitha Pramod Page 42}

}

Output:

The int array is

10

20

30

40

The string array is

Hello

What

Thatstringarray

Working with Multidimensional Arrays:using System;

class program{


{

//A rectangular MD array

int[,] a;

a = new int[3, 3];

//populate (3*3) array.

for (int i = 0; i


11/12

Array class is an abstract base class but it provides CreateInstance method to construct an array.

The Array class provides methods for creating, manipulating, searching, and sorting arrays.

Table 1 describes Array class properties.

IsFixedSize Return a value indicating if an array has a fixed size or not.

IsReadOnly Returns a value indicating if an array is read-only or not.

Length Returns the total number of items in all the dimensions of an array.

Rank Returns the number of dimensions of an array.Table 1: The System.Array Class Properties

Table 2 describes some of the Array class methods.

BinarySearch This method searches a one-dimensional sorted Array for a value, using abinary search algorithm.

Clear This method removes all items of an array and sets a range of items in the array

to 0.

Copy This method copies a section of one Array to another Array and performs

type casting and boxing as required.

CopyTo This method copies all the elements of the current one-dimensional Array to

the specified one-dimensional Array starting at the specified destinationArray index.

CreateInstance This method initializes a new instance of the Array class.GetLength This method returns the number of items in an Array.Reverse This method reverses the order of the items in a one-dimensional Array or in a

portion of the Array.Prep By: Sunitha Pramod Page 44Sort This method sorts the items in one-dimensional Array objects.

Write C# program to demonstrate the methods of Array class i,e copy, sort, reverse, and clearusing System;

class program

{


{

//Array of stringstring[] names = { "amir", "sharuk", "salman", "Hrithik" };

//print the names

Console.WriteLine("\nNames are");

for(int i=0;i


12/12

Console.WriteLine("{0}",names[i]);

//clear out all except hrithik

Array.Clear(names,1,3);

Console.WriteLine("\nclear out all except hrithik");

for(int i=0;i

.Net to Print

Documents

Transcript of .Net to Print