Object Construction and Destruction
Object Construction and Destruction
The Constructor as a Method
A Constructor with Parameters
In your class, you can create a constructor with as many parameters as you want. Here is an example of a constructor that uses three parameters:
public class Exercise
{
public Exercise(string a, int b, int c)
{
}
}
In the body of the constructor, you can ignore or use the values of the parameters. To create an object of the class, declare a variable of the class and initialize it using the constructor. This means that you must pass an argument for each parameter.
Practical Learning: Introducing Object Construction
namespace Chemistry2.Models
{
internal class Element
{
internal string Symbol { get; set; }
internal string ElementName { get; set; }
internal int AtomicNumber { get; set; }
internal double AtomicWeight { get; set; }
public Element()
{
Symbol = "H";
ElementName = "Hydrogen";
AtomicNumber = 1;
AtomicWeight = 1.008;
}
}
}using Chemistry2.Models; using static System.Console; Element h = new() { ElementName = "Hydrogen", AtomicWeight = 1.008, AtomicNumber = 1, Symbol = "H" }; Element he = new() { ElementName = "Helium", AtomicWeight = 4.002602, AtomicNumber = 2, Symbol = "He" }; Element li = new() { ElementName = "Lithium", AtomicWeight = 6.94, AtomicNumber = 3, Symbol = "Li" }; Element be = new(); be.Symbol = "Be"; be.AtomicNumber = 4; be.ElementName = "Beryllium"; be.AtomicWeight = 9.0121831; Element b = new() { ElementName = "Boron", AtomicWeight = 10.81, AtomicNumber = 5, Symbol = "B" }; Element c = new() { Symbol = "C", AtomicNumber = 6, ElementName = "Carbon", AtomicWeight = 12.011 }; Element n = new() { AtomicNumber = 7, Symbol = "N", ElementName = "Nitrogen", AtomicWeight = 14.007 }; WriteLine("Chemistry"); WriteLine("------------------------"); WriteLine("Symbol: " + n.Symbol); WriteLine($"Atomic Number: {n.AtomicNumber}"); WriteLine("Element Name: " + n.ElementName); WriteLine($"Atomic Weight: " + n.AtomicWeight); Write("========================");
Chemistry ------------------------ Symbol: N Atomic Number: 7 Element Name: Nitrogen Atomic Weight: 14.007 ======================== Press any key to close this window . . .
namespace Chemistry2.Models
{
internal class Element
{
internal string Symbol { get; set; }
internal string ElementName { get; set; }
internal int AtomicNumber { get; set; }
internal double AtomicWeight { get; set; }
public Element(int number, string symbol, string name, double mass)
{
Symbol = symbol;
ElementName = name;
AtomicWeight = mass;
AtomicNumber = number;
}
}
}using Chemistry2.Models; using static System.Console; Element h = new Element(1, "H", "Hydrogen", 1.008); Element he = new Element(2, "He", "Helium", 4.002602); Element li = new Element(3, "Li", "Lithium", 6.94); Element be = new(4, "Be", "Beryllium", 9.0121831); Element b = new(5, "B", "Boron", 10.81); Element n = new(7, "N", "Nitrogen", 14.007); Element o = new(8, "O", "Oxygen", 15.999); WriteLine("Chemistry"); WriteLine("------------------------"); WriteLine("Symbol: " + n.Symbol); WriteLine($"Atomic Number: {n.AtomicNumber}"); WriteLine("Element Name: " + n.ElementName); WriteLine($"Atomic Weight: " + n.AtomicWeight); Write("========================");
Chemistry ------------------------ Symbol: O Atomic Number: 8 Element Name: Oxygen Atomic Weight: 15.999 ======================== Press any key to close this window . . .
Passing an Argument by Name
As seen with methods, if you call a constructor that takes at least one argument, you can access the/each parameter by its name, followed by a colon, and its value. Here is an example:
using static System.Console;
Element c = new(name: "Carbon", mass: 12.011, symbol: "C", number: 6);
Constructor Overloading
In your class, you can create as many constructors as you want. If you decide to create different constructors, they must follow the rules of method overloading. This means that each constructor must be different from the others. To take care of this, each constructor can use a different number of parameters or different data types for parameters compared to other constructors. Here are examples:
public class Exercise
{
public Exercise(string a)
{
}
public Exercise(string a, int b, int c)
{
}
}
If you create different constructors, when creating (an) instance(s) of the class (when declaring a (the) variable(s) of the class), you can choose what constructor is appropriate to initialize the variable.
Consider the following class and its constructor:
public class Element
{
string _name_;
string _symbol_;
int _number_;
double _weight_;
public Element(int number, string symbol, string name, double mass)
{
_name_ = name;
_weight_ = mass;
_symbol_ = symbol;
_number_ = number;
}
}
If you create a class with only one constructor, when declaring an instance of the class, you must use that constructor: you cannot use the default constructor that doesn't use any parameter. When declaring the variable, initialize it with a constructor with parentheses and provide the value(s) in the parentheses of the constructor.
Practical Learning: Overloading a Constructor
namespace Chemistry2.Models
{
internal class Element
{
internal string Symbol { get; set; }
internal string ElementName { get; set; }
internal int AtomicNumber { get; set; }
internal double AtomicWeight { get; set; }
public Element(int number)
{
AtomicNumber = number;
}
public Element(string symbol)
{
Symbol = symbol;
}
public Element(int number, string symbol, string name, double mass)
{
Symbol = symbol;
ElementName = name;
AtomicWeight = mass;
AtomicNumber = number;
}
}
}using Chemistry2.Models;
using static System.Console;
Element h = new Element(1, "H", "Hydrogen", 1.008);
Element he = new Element(2, "He", "Helium", 4.002602);
Element li = new Element(3, "Li", "Lithium", 6.94);
Element be = new(4, "Be", "Beryllium", 9.0121831);
Element b = new(5, "B", "Boron", 10.81);
Element c = new(name: "Carbon", mass: 12.011, symbol: "C", number: 6);
Element n = new(7, "N", "Nitrogen", 14.007);
Element o = new(8, "O", "Oxygen", 15.999);
Element f = new Element(9);
f.Symbol = "F";
f.AtomicWeight = 18.998;
f.ElementName = "Fluorine";
Element ne = new Element("Ne");
ne.AtomicNumber = 10;
ne.AtomicWeight = 20.180;
ne.ElementName = "Neon";
WriteLine("Chemistry");
WriteLine("------------------------");
WriteLine("Symbol: " + f.Symbol);
WriteLine($"Atomic Number: {f.AtomicNumber}");
WriteLine("Element Name: " + f.ElementName);
WriteLine($"Atomic Weight: " + f.AtomicWeight);
WriteLine("========================");
WriteLine("Symbol: " + ne.Symbol);
WriteLine($"Atomic Number: {ne.AtomicNumber}");
WriteLine("Element Name: " + ne.ElementName);
WriteLine($"Atomic Weight: " + ne.AtomicWeight);
Write("========================");Chemistry ------------------------ Symbol: F Atomic Number: 9 Element Name: Fluorine Atomic Weight: 18.998 ======================== Symbol: Ne Atomic Number: 10 Element Name: Neon Atomic Weight: 20.18 ======================== Press any key to close this window . . .
A Boolean Parameter in a Constructor
A constructor can use a Boolean parameter. Here is an example:
public class Contractor
{
public Contractor(bool validated)
{
}
void CalculatePayroll(bool fullTime)
{
}
void ValidateEmploymentStatus()
{
CalculatePayroll(true);
}
}
public class Accountability
{
public Accountability()
{
Contractor empl = new Contractor(true);
var staff = new Contractor(false);
}
}
The Absence of a Default Constructor
If you create a class with only one constructor and that constructor uses at least one parameter, the default constructor would not be available anymore. If you want to access a default constructor of an object, you have two options:
public class Exercise
{
public Exercise()
{
}
public Exercise(string caption)
{
}
public Exercise(string caption, int width, int height)
{
}
}A class is usually made to contain many members. The primary reason you create a constructor is to have a tool to initialize an object of the class with one or some default values. The primary reason you create different constructors is to provide different values to objects depending on what constructor a user (actually a programmer) wants to use to create an object. To make this happen, you can initialize the members with values passed to the parameter(s). Here are examples:
using static System.Console;
WriteLine("Using Constructors");
WriteLine("==================================");
Exercise exo = new Exercise();
exo = new Exercise("C# Programming");
exo = new Exercise("A wondewrful world", 248);
exo = new Exercise("A programming endevour", 557, 3972);
public class Exercise
{
string text;
int wdt, hgt;
public Exercise()
{
text = "Empty";
WriteLine("Default constructor");
WriteLine("----------------------------------");
WriteLine($"Contents: {text}");
WriteLine($"Dimension 1: {wdt}");
WriteLine($"Dimension 2: {hgt}");
WriteLine("==================================");
}
public Exercise(string title)
{
text = title;
WriteLine("A constructor with one argument");
WriteLine("----------------------------------");
WriteLine($"Contents: {text}");
WriteLine($"Dimension 1: {wdt}");
WriteLine($"Dimension 2: {hgt}");
WriteLine("==================================");
}
public Exercise(string title, int width)
{
wdt = width;
text = title;
WriteLine("A constructor with two arguments");
WriteLine("----------------------------------");
WriteLine($"Contents: {text}");
WriteLine($"Dimension 1: {wdt}");
WriteLine($"Dimension 2: {hgt}");
WriteLine("==================================");
}
public Exercise(string title, int width, int height)
{
text = title;
wdt = width;
hgt = height;
WriteLine("A constructor with three arguments");
WriteLine("----------------------------------");
WriteLine($"Contents: {text}");
WriteLine($"Dimension 1: {wdt}");
WriteLine($"Dimension 2: {hgt}");
WriteLine("==================================");
}
}
A Constructor with Default Values
Since a constructor is primarily a method, its parameter(s), if any, can use default values. The rules are exactly the same we reviewed for methods. To provide a default value for the parameter of a constructor, assign the desired but appropriate value to the parameter when creating the constructor. Here is an example:
public class Exercise
{
public Exercise(string caption = "Exercise")
{
}
}
Once again, in the body of the constructor, you can use or ignore the parameter. If you create one constructor and it uses one parameter, when creating an object of the class, that single constructor would act as both (or either) a default constructor and (or) a constructor that uses one parameter. This means that you can declare a variable and use a constructor with empty parentheses. Here is an example:
using static System.Console;
public class Employee
{
public Employee(string name = "John Doe")
{
WriteLine("==================================");
WriteLine($"Employee Name: {name}");
WriteLine("==================================");
}
}
Employee staff = new Employee();
In the same way, you can create a constructor that uses different parameters and some parameters can have default values. When doing this, make sure you follow the rules we reviewed for functions (or methods) that have default values for parameters. Here is an example:
using static System.Console;
public class Employee
{
public Employee(int nbr = 111_111, string fname = "John",
string lname = "Doe", double hsal = 0.00)
{
WriteLine("==================================");
WriteLine($"Employee #: {nbr}");
WriteLine($"Employee Name: {fname} {lname}");
WriteLine($"Hourly Salary: {hsal}");
}
}
// Creating an object without arguments
Employee staff = new Employee();
// Passing one argument
staff = new Employee(283_583);
// Passing three arguments
staff = new Employee(928_495, "James", "Dickson");
// Passing all arguments
staff = new Employee(492_859, "Elisabeth", "Hoppers", 22.28);
// Passing arguments by names
staff = new Employee(lname: "Turner", nbr: 592_804, hsal: 17.85, fname: "Chritian");
WriteLine("==================================");
This would produce:
================================== Employee #: 111111 Employee Name: John Doe Hourly Salary: 0 ================================== Employee #: 283583 Employee Name: John Doe Hourly Salary: 0 ================================== Employee #: 928495 Employee Name: James Dickson Hourly Salary: 0 ================================== Employee #: 492859 Employee Name: Elisabeth Hoppers Hourly Salary: 22.28 ================================== Employee #: 592804 Employee Name: Chritian Turner Hourly Salary: 17.85 ================================== Press any key to close this window . . .
Initializing this Constructor
We have seen that you can create many constructors in the same class, which is referred to as overloading a constructor. Of course, the constructors must vary by their syntaxes. To start, you can overload a constructor with at least two versions. Here is an example:
namespace QuatroGas.Models
{
internal class GasMeter
{
public string MeterNumber { get; set; }
public string Make { get; set; }
public string Model { get; set; }
public GasMeter()
{
}
public GasMeter(string number)
{
MeterNumber = number;
}
}
}
If you create more than one constructor in a class, you can initialize the fields or properties of the class in a constructor that has fewer parameters by using the syntax of a constructor that has more parameters. To do this, you use an object named this. This object is used as if you are calling a constructor that uses the same number and types of parameters as a constructor in your class. To use it, just after the closing parenthesis of the constructor where you are using the this object, type this; precede it with a colon and add some parentheses to this object. In the parentheses, provide a value for each of the parameters of the constructor you are calling. Here is an example:
namespace QuatroGas2.Models
{
internal class GasMeter
{
public string MeterNumber { get; set; }
public string Make { get; set; }
public string Model { get; set; }
/* This is the default constructor.
* Use it to initialize the property
* that is passed to the other constructor. */
public GasMeter()
: this("000-000")
{
}
public GasMeter(string number)
{
MeterNumber = number;
}
}
}
After doing this, you can access the constructor that was initialized and use its values. Here is an example:
GasMeter gasMeter = new GasMeter(); Console.WriteLine("Quatro Gas"); Console.WriteLine("============================================"); Console.WriteLine("Gas Meter Details"); Console.WriteLine("--------------------------------------------"); Console.WriteLine("Meter #: {0}", gasMeter.MeterNumber); Console.WriteLine("Make: {0}", gasMeter.Make); Console.WriteLine("Model: {0}", gasMeter.Model); Console.WriteLine("============================================"); internal class GasMeter { public string MeterNumber { get; set; } public string Make { get; set; } public string Model { get; set; } public GasMeter() : this("888-888") { } public GasMeter(string number) { MeterNumber = number; } }
This would produce:
Quatro Gas ============================================ Gas Meter Details -------------------------------------------- Meter #: 888-888 Make: Model: ============================================
In the same way, if you have many constructors, you can use the syntaxes of some to initialize the properties in others. Here is an example:
namespace QuatroGas.Models
{
internal class Customer
{
public string AccountNumber { get; set; }
public GasMeter GasMeter { get; set; }
public string AccountName { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string County { get; set; }
public string State { get; set; }
// This is a constructor with two parameters.
public Customer(string number, string name)
{
AccountNumber = number;
AccountName = name;
}
// This constructor applies the constructor that has three parameters.
public Customer()
: this("0000-000-0000", "john Doe", "NY")
{
}
// This constructor applies the constructo that uses two parameters.
public Customer(string number)
: this("Jane", "Unknown")
{
AccountNumber = number;
}
// This constructor uses the constructor with one parameter
public Customer(string number, string name, string residence)
: this("TX")
{
AccountNumber = number;
AccountName = name;
State = residence;
}
}
}
With this technique, when creating a constructor, use the this object to access another constructor and initialize the desired properties; then initialize the remaining property (or properties) in the body of the constructor you are accessing. Here are examples:
namespace QuatroGas.Models
{
internal class GasMeter
{
public string MeterNumber { get; set; }
public string Make { get; set; }
public string Model { get; set; }
/* This is the default constructor.
* Initialize it with the three-parameter constructor.*/
public GasMeter()
: this("888-888", "Generic", "AAA")
{
}
/* This is a one-parameter constructor.
* Initialize it with the three-parameter constructor
* but use this constructor's one-parameter for the
* first parameter of the three-parameter constructor. */
public GasMeter(string number)
: this(number, "Generic", "AAA")
{
}
public GasMeter(string number, string make, string model)
{
MeterNumber = number;
Make = make;
Model = model;
}
}
}
After creating the constructors like that, when creating an object, you can call the constructor you want. The property whose value you had provided would be applied. The missing property (properties) would use the value(s) that was (were) provided in the class. Here is one example of creating an object using the default constructor of the above class (which doesn't provide any value for the properties)
using QuatroGas.Models;
/* Provide no value for the Gas Meter object.
* The values will come from the default constructor. */
GasMeter gasMeter = new GasMeter();
Console.WriteLine("Quatro Gas");
Console.WriteLine("============================================");
Console.WriteLine("Gas Meter Details");
Console.WriteLine("--------------------------------------------");
Console.WriteLine("Meter #: {0}", gasMeter.MeterNumber);
Console.WriteLine("Make: {0}", gasMeter.Make);
Console.WriteLine("Model: {0}", gasMeter.Model);
Console.WriteLine("============================================");
This would produce:
Quatro Gas ============================================ Gas Meter Details -------------------------------------------- Meter #: 888-888 Make: Generic Model: AAA ============================================ Press any key to close this window . . .
Here is one example of creating an object using the default constructor of the above class (which doesn't provide any value for the properties)
using QuatroGas.Models;
/* Provide only the Gas Meter #.
* The Make and Model will come from the constructor */
GasMeter gasMeter = new GasMeter("180-700");
Console.WriteLine("Quatro Gas");
Console.WriteLine("============================================");
Console.WriteLine("Gas Meter Details");
Console.WriteLine("--------------------------------------------");
Console.WriteLine("Meter #: {0}", gasMeter.MeterNumber);
Console.WriteLine("Make: {0}", gasMeter.Make);
Console.WriteLine("Model: {0}", gasMeter.Model);
Console.WriteLine("============================================");
This would produce:
Quatro Gas ============================================ Gas Meter Details -------------------------------------------- Meter #: 180-700 Make: Generic Model: AAA ============================================ Press any key to close this window . . .
When using the this object, in its parentheses, to make your code easy to read, you can access a parameter by its name and assign the desired value to it. For each parameter, you must the name of the parameter of the constructor you are using. Consider the following examples:
namespace QuatroGas.Models
{
internal class Customer
{
public string AccountNumber { get; set; }
public string AccountName { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string County { get; set; }
public string State { get; set; }
// This is a constructor with two parameters.
public Customer(string actNbr, string identifier)
{
AccountNumber = actNbr;
AccountName = identifier;
}
// This constructor applies the constructor that has three parameters.
public Customer()
: this(number: "0000-000-0000", name: "john Doe", residence: "NY")
{
}
// This constructor applies the constructo that uses two parameters.
public Customer(string nbr)
: this(actNbr: "Jane", identifier: "Unknown")
{
AccountNumber = nbr;
}
// This constructor uses the constructor with one parameter
public Customer(string number, string name, string residence)
: this(nbr: "TX")
{
AccountNumber = number;
AccountName = name;
State = residence;
}
}
}
Remember that a parameter of a constructor can be an object. You can initialize such a parameter in a this object. Here are two examples:
namespace QuatroGas2.Models
{
internal class Customer
{
public string AccountNumber { get; set; }
public GasMeter GasMeter { get; set; }
public string AccountName { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string County { get; set; }
public string State { get; set; }
// This is a constructor with two parameters.
public Customer(string actNbr, string identifier)
{
AccountNumber = actNbr;
AccountName = identifier;
}
// This constructor applies the constructor that has three parameters.
public Customer()
: this(number: "0000-000-0000", name: "john Doe", residence: "NY")
{
}
// This constructor applies the constructo that uses two parameters.
public Customer(string nbr)
: this(actNbr: "Jane", identifier: "Unknown")
{
AccountNumber = nbr;
}
// This constructor uses the constructor with one parameter
public Customer(string number, string name, string residence)
: this(nbr: "TX")
{
AccountNumber = number;
AccountName = name;
State = residence;
}
// This constructor applies the constructo that uses two parameters.
public Customer(GasMeter gMtr)
: this("1111-222-3333",
new GasMeter("222-444", "Generix", "abc"))
{
}
// This is a constructor with two parameters.
public Customer(string actNbr, GasMeter gm, string identifier)
{
AccountNumber = actNbr;
AccountName = identifier;
GasMeter = gm;
}
// This constructor applies the constructo that uses two parameters.
public Customer(string nbr, GasMeter gm)
: this(actNbr: "Jane",
gm: new GasMeter("555-55", "Supra-Side", "ABC"),
identifier: "John Dryer")
{
AccountNumber = nbr;
}
}
}
A Primary Constructor
Introduction
As we have seen already, the primary way to have a constructor is to create a method that holds the same name as its class. Here is an example:
public class Meter
{
public Meter()
{
}
public string MeterNumber
{
get;
set;
}
}
Actually, the easiest way to create a constructor is to simply add parentheses to the name of the class when creating it. Here is an example:
public class Meter()
{
public string MeterNumber
{
get;
set;
}
}
This type of constructor where you add parentheses to the name of the class is called the primary constructor. As always, there are rules you must follow when creating a primary constructor. Of course, the first rule is that the constructor is created on the name of the class.
A Default Primary Constructor
As you may remember, a default constructor is a constructor created with empty parentheses applied to the name of the class. This is also the case with a primary constructor: you simply leave the parentheses empty as we did above. The rule to observe this time is that you must not create a default constructor in the body of the class.
After creating a primary constructor, you can declare a variable of the class and use the object as we did sinec our instructor to classes. Here is an example:
var exo = new Meter();
exo.MeterNumber = "WKE-158-259";
WriteLine("Electricity Company");
WriteLine("=======================");
WriteLine("Electric Meter Details");
WriteLine("-----------------------");
WriteLine("Meter #: {0}", exo.MeterNumber);
WriteLine("=======================");
public class Meter()
{
public string MeterNumber
{
get;
set;
}
}
This would produce:
Electricity Company ======================= Electric Meter Details ----------------------- Meter #: WKE-158-259 ======================= Press any key to close this window . . .
A Primary Constructor with Parameters
When creating a primary constructor, if you want, you can add one or more parameters to it. Here is an example of a primary constructor with a parameter:
public class Helmet(int nbr)
{
}
In the same way, you can add as many parameters as you want in the parentheses of the constructor. There are no restrictions on the number and type of the parameters, but there are rules you must follow.
Of course there are advantages, disadvantages, and differences among primary constructors and other types of constructors. One of the advantages of a primary constructor is that, if you add a parameter to a primary constructor, that parameter is available to all members of class. This means that the all properties and methods of a class can access a parameter of a primary constructor. Here is an example:
Helmet hlm = new Helmet(294_075, "Large", 4.65, 144.88); hlm.Introduce(); hlm.Describe(); public class Helmet(int nbr, string size, double weight, double price) { public string Introduce() { WriteLine("Cycles Ruler"); WriteLine("=========================="); WriteLine("Helmet Information"); WriteLine("--------------------------"); WriteLine("Item #: {0}", nbr); return "Nothing"; } public void Describe() { WriteLine("Size: {0}", size); WriteLine("Item Weight: {0} pounds", weight); WriteLine("Unit Price: ${0}", price); WriteLine("=========================="); } }
This would produce:
Cycles Ruler ========================== Helmet Information -------------------------- Item #: 294075 Size: Large Item Weight: 4.65 pounds Unit Price: $144.88 ========================== Press any key to close this window . . .
One of the common ways a primary constructor is used to provide (a) value)(s) to a (the) property (properties) of a class. In this case, you create (a) read-only property (propertie) in the class and return a parameter of the primary constructor in the get clause of the property. Here is an example:
Helmet hlm = new Helmet(358_605);
WriteLine("Cycles Ruler");
WriteLine("===========================");
WriteLine("Helmet Information");
WriteLine("---------------------------");
WriteLine("Item #: {0}", hlm.ItemNumber);
WriteLine("===========================");
public class Helmet(int nbr)
{
public int ItemNumber
{
get
{
return nbr;
}
}
}
Remember that not only can a primary constructor take many parameters, each of its parameters is accessible to all members of the class. As a result, you can add many parameters to a primary constructor; In this case, each parameter can be used to initialize a read-only property of the class. Here are example:
Helmet hlm = new Helmet(358_605, "X-Large", 2.25, 167.93);
WriteLine("Cycles Ruler");
WriteLine("===========================");
WriteLine("Helmet Information");
WriteLine("---------------------------");
WriteLine("Item #: {0}", hlm.ItemNumber);
WriteLine("Size: {0}", hlm.Size);
WriteLine("Item Weight: {0} kilograms", hlm.Weight);
WriteLine("Unit Price: ${0}", hlm.UnitPrice);
WriteLine("===========================");
public class Helmet(int nbr, string size, double weight, double price)
{
public int ItemNumber
{
get
{
return nbr;
}
}
public String Size
{
get { return size; }
}
public double Weight
{
get { return weight; }
}
public double UnitPrice
{
get { return price; }
}
}
This would produce:
Cycles Ruler =========================== Helmet Information --------------------------- Item #: 358605 Size: X-Large Item Weight: 2.25 kilograms Unit Price: $167.93 =========================== Press any key to close this window . . .
In the same way, you can create read-write properties in a class that has a primary constructor. The parameter(s) of the primary constructor can be used to pass (a) value(s) to a (the) read/write property. That allows you to create an object by passing values to the primary constructor and to change a (the) value(s) of the property (properties). Here are examples:
Helmet hlm = new Helmet(294_075, "Large", 4.65, 144.88);
WriteLine("Cycles Ruler");
WriteLine("==========================");
WriteLine("Helmet Information");
WriteLine("--------------------------");
WriteLine("Item #: {0}", hlm.ItemNumber);
WriteLine("Size: {0}", hlm.Size);
WriteLine("Item Weight: {0} pounds", hlm.Weight);
WriteLine("Unit Price: ${0}", hlm.UnitPrice);
WriteLine("==========================");
hlm.Size = "Medium";
hlm.ItemNumber = 137_597;
hlm.UnitPrice = 395.97;
hlm.Weight = 6.0;
WriteLine("Helmet Information");
WriteLine("--------------------------");
WriteLine("Item #: {0}", hlm.ItemNumber);
WriteLine("Size: {0}", hlm.Size);
WriteLine("Item Weight: {0} pounds", hlm.Weight);
WriteLine("Unit Price: ${0}", hlm.UnitPrice);
WriteLine("==========================");
public class Helmet(int nbr, string size, double weight, double price)
{
public int ItemNumber
{
get
{
return nbr;
}
set
{
nbr = value;
}
}
public String Size
{
get { return size; }
set { size = value; }
}
public double Weight
{
get { return weight; }
set { weight = value; }
}
public double UnitPrice
{
get { return price; }
set { price = value; }
}
}
This would produce:
Cycles Ruler ========================== Helmet Information -------------------------- Item #: 294075 Size: Large Item Weight: 4.65 pounds Unit Price: $144.88 ========================== Helmet Information -------------------------- Item #: 137597 Size: Medium Item Weight: 6 pounds Unit Price: $395.97 ========================== Press any key to close this window . . .
The Destruction of an Object
A destructor is a special method of a class. While a constructor is called when an object is created, a destructor is called when an object is not used anymore. The job of a destructor is to do the cleaning of the computer memory that an object was occupying when the object was used. Like the default constructor, the compiler always creates a default destructor if you don't create one. Unlike the constructor, the destructor cannot be overloaded. This means that, if you decide to create a destructor, you can have only one. Like the default constructor, a destructor also has the same name as its class. This time, the name of the destructor starts with a tilde "~".
To create a destructor, type ~ followed by the name of the class. Here is an example:
public class Exercise
{
public Exercise(string caption = "Exercise", int width = 640, int height = 480)
{
}
~Exercise()
{
}
}
When you initialize a variable using the new operator, you are in fact reserving some space in the section of memory called the heap. Such memory is "allocated" for the variable. When that variable is no longer needed, such as when your program closes, the variable must be removed from memory and the space it was using should (must) be made available to other variables or other programs. In fact, when an object has been removed from memory, it is replaced by garbage, which is some value but that is of no use (that area of memory becomes filled with garbage). If you program in some languages such as C/C++, Assembly, Pascal, etc, you should (must) find a way to remove that garbage (it is not difficult, sometimes it takes a simple/single line of code, but you should (must) remember to do it); that is, you should (must) free the memory a variable (declared with new, and called a reference) was using. Freeing the memory is referred to as garbage collection. Normally, in languages like C++ or Pascal, that's one of the ways you use a destructor.
The .NET library solves the problem of garbage collection by "cleaning" the memory after you. This is done automatically when necessary so that the programmer doesn't need to worry about this issue.
Practical Learning: Ending the Lesson
|
|
|||
| Previous | Copyright © 2001-2024, FunctionX | Tuesday 28 November 2023 | Next |
|
|
|||