C# ПІДРУЧНИКИ / c# / Premier Press - C# Professional Projects
.pdf
48 |
Part II |
HANDLING DATA |
|
|
|
Constructors
A constructor is a default method that is called when an object is initialized from a class. Each class has a constructor with a name that is the same as that of the class. A constructor does not return a value.However, unlike methods, you do not call a constructor. It is automatically called when you create an object of a class.
It is not necessary to declare a constructor for a class. If you do not explicitly
declare a constructor, C# automatically creates a default constructor for a class with the same name as that of the class.The following is an example of declaring a constructor:
<modifier> <constructor name> |
|
Y |
|
{ |
|
L |
|
|
------------ |
F |
|
|
|
||
} |
|
M |
|
Constructor modifiers include |
|
||
public, private, protected, and internal. Inside |
|||
the block of the constructorAare the statements that are used to initialize the class |
|||
that contains the constructor. |
|
|
|
|
E |
|
|
|
T |
|
|
To initialize the data members of a class, you can declare a constructor for the class and pass parameters to it.The parameters in this case are the initial values of the data members. To understand the concept of passing parameters to constructors, look at the following example:
public class Employee
{
public Employee()
{
string Name = ‘John’;
}
public Employee (string EmployeeName)
{
Name = EmployeeName;
}
}
In the previous code, the constructor with the name Employee() is declared in the class Employee. The constructor takes EmployeeName as the parameter and initializes the value of Name with EmployeeName. Therefore, when you create an instance of the Employee class,the object gets initialized.This prevents any other class from accessing the objects of the Employee class before initializing the object.
Team-Fly®
COMPONENTS OF C# |
Chapter 3 |
49 |
|
|
|
After declaring a constructor, you need to use it to instantiate an object of the class. You use the new keyword to instantiate the object of the class.
Employee employee1 = new Employee (‘Smith’);
When you pass a value as a parameter, the new value overwrites the initial value. Therefore, the name of the employee is changed to Smith. However, if you do not want to change the default value, you can instantiate the constructor without passing a parameter to it, as shown in the following example:
Employee employee1 = new Employee();
As already discussed, if you do not explicitly declare a constructor, C# creates a default constructor. In this case, C# calls the default constructor of the direct base class.The base keyword is used to call the default base class constructor from the derived class. You can also use the this keyword if you want to call any other constructor of the base class.
Therefore, if you derive a class Salary from the class Employee, you can call the constructor of the Employee class from the Salary class.
class Employee
{
public Employee ()
{
--------------
}
}
class Salary : Employee
{
public Salary : base ()
{
--------------
}
}
As you know, it is essential to initialize an instance of a class whenever the instance is created. Similarly, it is also essential to destroy the instance of the class when it goes out of scope. To do this, C# contains destructors that are called when an instance of a class is destroyed.
50 |
Part II |
HANDLING DATA |
|
|
|
Destructors
Destructors are not extensively used in C#. To destroy resources from memory, C# uses the garbage collection mechanism. You have learned about this mechanism in Chapter 1, “Overview of the .NET Framework,” in the section “Garbage Collector.”
Similar to naming a constructor, the destructor takes the same name as that of the class. You can declare a destructor by using the destructor declaration statement. These statements include a tilde (~) sign followed by the name of the class.
public class Employee
{
~ Employee ()
{
-----------------
}
}
In the previous code, Employee() is the destructor of the Employee class. You can include the statements required to uninitialize variables of the class in the body of the destructor.
You cannot explicitly call a destructor. It is automatically invoked when an instance of a class is not used by any program. In addition, if destructors of the base and derived classes are to be invoked, the derived class destructor is invoked first, followed by the base class constructor.
In addition to the garbage collection system, C# provides you with the Finalize(), Dispose(), and Close() methods.These methods are used to clean up the memory after a resource is destroyed.
Finalize() Method
To destroy data members when they are not needed, you can create the Finalize() method. This method is automatically called when the class instance is deleted. The Finalize() method cleans the memory before the garbage collection system dereferences the object. You cannot call the Finalize() method because it gets automatically invoked when you call the destructor of the class.
Similar to a destructor declaration statement, you can declare the Finalize() method by using the tilde (~) sign followed by the name of the containing class.
COMPONENTS OF C# |
Chapter 3 |
51 |
|
|
|
The Finalize() method does not return any value. In addition, you cannot pass parameters to the Finalize() method and directly override it.
Before C# calls the Finalize() method, it waits for some time after the object instance is no longer used by any program code.This unnecessarily blocks memory and destroys resources in longer time duration. To tackle this problem, C# provides you with the Dispose() and Close() methods.
Dispose() and Close() Methods
In C#, you can explicitly call the Dispose() and Close() methods to destroy the resources immediately after the class instance is deleted. These methods are not implicitly invoked. Therefore, if you forget to call the Dispose() or Close() methods, the resources remain in memory until the garbage collection system cleans the memory. To solve this problem, you can use the Dispose() and Close() methods with the Finalize() method. If the Dispose() or Close() method is not explicitly called, the Finalize() method will clean the memory before the garbage collection system is invoked.
Having learned about the Finalize(), Dispose(), and Close() methods, you can take a look at the methods used with classes in detail.
Methods
A method is a logical section of code that can be used to perform a specific operation. An object or a class can call a method to implement the functionality of the method. A method has a return type or can be of the type void.
Declaring a Method
The syntax of method declaration is as shown here:
< modifier> <return type> <method name> (parameter1, parameter2, ........)
{
statements
}
Here, modifier is the access modifier and return type specifies the data type of the value that is returned by the method. The list of parameters that the method takes is specified in the parentheses following the method name.
52 |
Part II |
HANDLING DATA |
|
|
|
Calling a Method
After a method is declared, you can call the method to be used by any class or an object. To call a method, you use the following syntax:
object1.method1 (parameter1, parameter2,...);
Here, object1 is the instance of the class that calls the method, method1 is the name of the method, and the parameter list is specified within parentheses.
Passing Parameters to Methods
While calling a method, you can pass a list of parameters to the method. The types of parameters that can be passed to a method are:
Value parameters
Reference parameters
Output parameter
Parameter arrays
The parameters that are passed by value to a method are called value parameters. When a variable is passed by value, the method changes the value of the variable in a copy. However, the actual value remains unchanged. Therefore, the value parameters are not affected by the changes that are made to the variables in the method. By default, all variables are passed as value parameters.
The value of variables that are passed by reference, known as reference parameters, changes when you modify the variable in a method. When a variable is passed by reference, the variable passes only a reference to the method and not the actual value. Therefore, changes made by the method are made to the original variable and not to its copy. C# overwrites the changes to the original value of the variable. The ref keyword is used to pass a variable to a method by reference.
The syntax of a method to which you pass a parameter by reference is:
object1.method1 (parameter1, ref parameter2,...);
Here, parameter1 is passed by value. However, parameter2 is passed by reference. Therefore, the value of parameter1 will not be affected by the changes made to it during method execution. However, if changes are made to parameter2 in the method body, the changes will get reflected to its original value.
COMPONENTS OF C# |
Chapter 3 |
53 |
|
|
|
TIP
In contrast to variables, strings do not change even when passed by reference. When you make a change to the value of a string, C# creates a new string.
In general, methods return a single value. In C#, you can write methods that return multiple values. To do so, you pass a parameter to the method as an output parameter. An output parameter is passed to a method by using the out keyword.
object1.method1 (out parameter1);
Here, parameter1 is passed to method1 as an output parameter.
In C#, it is essential that you initialize a variable before using it.Therefore, when you pass an output parameter, it already has some value. C# overwrites this value with the value returned by the method. This is a waste and can be avoided by using the out keyword. A variable prefixed with the out keyword is an exception, as you can pass it to a method without initializing it.The output parameter is initialized by the value returned by the method. A variable can store an output value only if you pass the variable to the method by reference.
In addition to variables, you can pass arrays as a parameter to a method. However, only a one-dimensional array can be passed to a method. You use the params keyword to specify a parameter array.
The syntax of passing a parameter array is:
object1.method1 (parameter1, params data type[] parameter2);
In the previous syntax, parameter2 is a one-dimensional array, and its type is specified by the data type.
When you declare a parameter array along with other parameters, you must include the parameter array as the last element in the list. In addition, you cannot include a parameter array with a reference or an output parameter. Therefore, the following code will generate an error:
object1.method1 (params data type[] parameter1, ref parameter2);
54 |
Part II |
HANDLING DATA |
|
|
|
Method Modifiers
Similar to classes, methods in C# also have modifiers. Following are some of the commonly used method modifiers.
static. A static method cannot be called by any particular instance of a class. To call a static method, you need to specify the name of the container class.
new. A new method in C# is used to suppress the compiler’s warning when you try to hide a method of a base class with the same name as the derived class method.
public. Similar to the public modifier of a class, if you declare a method as public, it can be accessed from any location.The method can also be called from outside the class that declares it.
private. A method declared as private is private to the class that declares it. This implies that a private method cannot be called from outside the class that contains the method.
protected. A protected method modifier is similar to a protected class modifier. A method declared as protected can be called from the derived classes of the class that contains the method, in addition to the class that declares the method.
internal. An internal method can be called from anywhere in the assembly.
extern. An extern method in C# has an unlimited scope. You can use a method declared as extern even in a different language.
virtual. A derived class of a class that contains a method can override a virtual method. You can also implement a virtual method dynamically. However, the method that will get invoked will be decided at run time.
A virtual modifier cannot be used with static, override, and abstract modifiers.
abstract. An abstract method is a special type of a virtual method. An abstract method can define a method. However, you cannot implement an abstract method. You can only declare an abstract method in an
abstract class.
override. The override method is used to override an inherited abstract or virtual method.
COMPONENTS OF C# |
Chapter 3 |
55 |
|
|
|
sealed. A sealed method is used with an override method to override an inherited virtual method. However, a class inherited from the class containing this method cannot override a sealed method.
Overloading a Method
Method overloading in C# is similar to method overloading in C++. Overloading a method allows you to declare more than one method with the same name in the same class. However, it is required that all methods with the same name take a different number of parameters or have different parameter types. The methods with the same name are called overloaded methods.
Defining Overloaded Methods
Method overloading is useful when you need to perform the same operation on different parameters. For example, you can overload a method Add() to add two integer numbers and two strings. Look at overloading a method with this example:
public int Add (int x, int y)
{
int z = x + y; return z;
}
public string Add (string string1, string string2)
{
string string3 = string1 + string2; return string3;
}
You will notice that both the methods have the same name, Add(). However, the first Add() method is used to add two integers, x and y, and return an integer z. The second Add() method adds two strings, string1 and string2, and returns a
string type string3.
Calling Overloaded Methods
After declaring a method, you need to call the method. When you call an overloaded method, the C# compiler needs to identify the method that is called. The C# compiler identifies the method based on the type of parameters passed in the method call statement.
56 |
Part II |
HANDLING DATA |
|
|
|
------------
object1.Add (25, 50)
-------------
Because the type of parameters passed to the Add() method in the previous statement are integers, the C# compiler calls the first Add() method.
Default Parameters
Methods are useful if you want certain parameters of a method not to be explicitly initialized.These parameters then take default values as specified in the body of the method.This feature is provided by the default parameters of C++. C# does not support default parameters. However, to overcome this problem, you can overload methods.
In the previous example, you can create overloads of the method Add() to pass default values to it. The code for the Add() method in the previous section does not specify any value for either x or y. However, you can modify the code as shown following to pass a default value to the method.
public int Add (int x)
{
int z = x + 100; return z;
}
The previous code always adds 100 to the value of integer x that is passed as a parameter when the Add() method is called by any class.
You have learned about classes and the methods used with classes. However, when you create an instance of a user-defined class, there may be more than one class with the same name. Therefore, to avoid this confusion, C# provides you with namespaces.
Namespaces
Namespaces are containers that are used to logically group similar classes that have related functionality. You can also use namespaces to group similar data types. Therefore, when you refer a data type or a class, their names are automatically
COMPONENTS OF C# |
Chapter 3 |
57 |
|
|
|
prefixed with the name of the namespace. This helps the compiler to understand which class is being referred in your code.
In C#, you need to declare each class in a namespace. However, if you do not explicitly declare a class in a namespace, C# automatically places the class in the default namespace.The default namespace is automatically created with the same name as that of the project. A namespace in C# can have more than one class.
Declaring Namespaces
C# provides you with several classes that you can use in your program code. Most of these classes are a part of the System namespace. You can also declare namespaces in the program code and then add classes to them. A namespace is declared using the namespace keyword. While declaring a namespace, you do not need to prefix the namespace declaration with an access modifier. All namespaces in C# are implicitly public, as they can be used across all programs.
namespace Employee
{
class Employee
}
You can place the Employee class in the Employee namespace. In addition, you can include other namespaces, classes, structs, enumerations, and interfaces in a namespace. You will learn about structs and enumerations later in this chapter.
C# allows the use of nested namespaces.Therefore, to refer to a namespace within another namespace, you use periods (.) to separate the names of the namespaces. For example,
namespace Employee
{
namespace Salary
{
class Salary
}
}
To refer to the Salary class, you need to refer to it as Employee.Salary.Salary.