Home

Arrays of Class Types

   

An Array of Objects

 

Introduction

As done for primitive types, you can create an array of values where each member of the array is based on a formal class. Of course, you must have a class first. You can use one of the already available classes or you can create your own class. Here is an example:

public enum EmploymentStatus
{
    FullTime,
    PartTime,
    Unknown
};
public class Employee
{
    private long emplNbr;
    private string name;
    private EmploymentStatus st;
    private double wage;

    public long EmployeeNumber
    {
        get { return emplNbr; }
        set { emplNbr = value; }
    }

    public string EmployeeName
    {
        get { return name; }
        set { name = value; }
    }

    public EmploymentStatus Status
    {
        get { return st; }
        set { st = value; }
    }

    public double HourlySalary
    {
        get { return wage; }
        set { wage = value; }
    }
}

ApplicationApplication: Introducing Arrays of Objects

  1. Start Microsoft Visual Studio
  2. To create a new application, on the main menu, click File -> New Project...
  3. In the middle list, click Console Application
  4. Change the name to RentalProperties2
  5. Click OK
  6. To create a new class, in the Solution Explorer, right-click RenatlProperties1 -> Add -> Class...
  7. Set the Name to RentalProperty and press Enter
  8. Change the file as follows:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace RentalProperties2
    {
        public enum PropertyType
        {
            SingleFamily, Townhouse,
            Apartment, Unknown
        };
    
        public class RentalProperty
        {
            private long nbr;
            private PropertyType tp;
            private short bd;
            private float bt;
            private double rnt;
    
            public RentalProperty(long PropNbr = 0,
            		      PropertyType Type = PropertyType.Unknown,
                                  short Beds = 0,
                                  float Baths = 0.0F,
                                  double Rent = 0D)
            {
                PropNbr = nbr;
                Type = PropertyType.Unknown;
                Beds = bd;
                Baths = bt;
                Rent = rnt;
            }
    
            public long propertyNumber
            {
                get { return nbr; }
                set { nbr = value; }
            }
    
            public PropertyType TypeOfProperty
            {
                get { return tp; }
                set { tp = value; }
            }
    
            public short Bedrooms
            {
                get { return bd; }
                set { bd = value; }
            }
    
            public float Bathrooms
            {
                get { return bt; }
                set { bt = value; }
            }
    
            public double MonthlyRent
            {
                get { return rnt; }
                set { rnt = value; }
            }
        }
    }

Creating an Array of Objects

To create an array of objects, you can declare an array variable and use the square brackets to specify its size. Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        Employee[] StaffMembers = new Employee[3];

        return 0;
    }
}

You can also use the var keyword to create the array but omit the first square brackets. Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers = new Employee[3];

        return 0;
    }
}

Initializing an Array of Objects

If you create an array like this, you can then access each member using its index, allocate memory for it using the new operator, then access each of its fields, still using its index, to assign it the desired value. Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers = new Employee[3];

        StaffMembers[0] = new Employee();
        StaffMembers[0].EmployeeNumber = 20204;
        StaffMembers[0].EmployeeName = "Harry Fields";
        StaffMembers[0].Status = EmploymentStatus.FullTime;
        StaffMembers[0].HourlySalary = 16.85;

        StaffMembers[1] = new Employee();
        StaffMembers[1].EmployeeNumber = 92857;
        StaffMembers[1].EmployeeName = "Jennifer Almonds";
        StaffMembers[1].Status = EmploymentStatus.FullTime;
        StaffMembers[1].HourlySalary = 22.25;

        StaffMembers[2] = new Employee();
        StaffMembers[2].EmployeeNumber = 42963;
        StaffMembers[2].EmployeeName = "Sharon Culbritt";
        StaffMembers[2].Status = EmploymentStatus.PartTime;
        StaffMembers[2].HourlySalary = 10.95;

        return 0;
    }
}

As an alternative, you can also initialize each member of the array when creating it. To do this, before the semi-colon of creating the array, open the curly brackets, allocate memory for each member and specify the values of each field. To do this, you must use a constructor that takes each member you want to initialize, as argument. Here is an example:

using System;

public enum EmploymentStatus
{
    FullTime,
    PartTime,
    Unknown
};

public class Employee
{
    private long emplNbr;
    private string name;
    private EmploymentStatus st;
    private double wage;

    public Employee()
    {
    }

    public Employee(long Number, string Name,
                    EmploymentStatus EStatus, double Salary)
    {
        emplNbr = Number;
        name = Name;
        st = EStatus;
        wage = Salary;
    }

    public long EmployeeNumber
    {
        get { return emplNbr; }
        set { emplNbr = value; }
    }

    public string EmployeeName
    {
        get { return name; }
        set { name = value; }
    }

    public EmploymentStatus Status
    {
        get { return st; }
        set { st = value; }
    }

    public double HourlySalary
    {
        get { return wage; }
        set { wage = value; }
    }
}

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers = new Employee[]
        {
            new Employee(20204, "Harry Fields", EmploymentStatus.FullTime, 16.85),
            new Employee(92857, "Jennifer Almonds",
			 EmploymentStatus.FullTime, 22.25),
            new Employee(42963, "Sharon Culbritt", 
			 EmploymentStatus.PartTime, 10.95)
        };

        return 0;
    }
}

If using the var keyword and a constructor to initialize the array, you can omit calling the name of the class before the square brackets. Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers = new[]
        {
            new Employee(20204, "Harry Fields", EmploymentStatus.FullTime, 16.85),
            new Employee(92857, "Jennifer Almonds",
			 EmploymentStatus.FullTime, 22.25),
            new Employee(42963, "Sharon Culbritt", 
			EmploymentStatus.PartTime, 10.95)
        };

        return 0;
    }
}

Accessing the Members of the Array

After creating and initializing the array, you can use it as you see fit. For example, you may want to display its values to the user. You can access any member of the array by its index, then use the same index to get its field(s) and consequently its (their) value(s). Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers = new Employee[]
        {
            new Employee(20204, "Harry Fields", EmploymentStatus.FullTime, 16.85),
            new Employee(92857, "Jennifer Almonds", 
			 EmploymentStatus.FullTime, 22.25),
            new Employee(42963, "Sharon Culbritt", 
			 EmploymentStatus.PartTime, 10.95)
        };

        Console.WriteLine("Employee Record");
        Console.WriteLine("---------------------------");
        Console.WriteLine("Employee #: {0}", StaffMembers[2].EmployeeNumber);
        Console.WriteLine("Full Name:  {0}", StaffMembers[2].EmployeeName);
        Console.WriteLine("Status:     {0}", StaffMembers[2].Status);
        Console.WriteLine("Hourly Wage {0}", StaffMembers[2].HourlySalary);
        Console.WriteLine("---------------------------\n");

        return 0;
    }
}

This would produce:

Employee Record
---------------------------
Employee #: 42963
Full Name:  Sharon Culbritt
Status:     PartTime
Hourly Wage 10.95
---------------------------

Press any key to continue . . .

Once again, remember that the index you use must be higher than 0 but lower than the number of members - 1. Otherwise, the compiler would throw an IndexOutRangeException exception.

In the same way, you can use a for loop to access all members of the array using their index. Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers= new Employee[]
        {
            new Employee(20204, "Harry Fields", EmploymentStatus.FullTime, 16.85),
            new Employee(92857, "Jennifer Almonds",
			 EmploymentStatus.FullTime, 22.25),
            new Employee(42963, "Sharon Culbritt", 
			EmploymentStatus.PartTime, 10.95)
        };

        Console.WriteLine("Employees Records");
        Console.WriteLine("==========================");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Employee #: {0}", StaffMembers[i].EmployeeNumber);
            Console.WriteLine("Full Name:  {0}", StaffMembers[i].EmployeeName);
            Console.WriteLine("Status:     {0}", StaffMembers[i].Status);
            Console.WriteLine("Hourly Wage {0}", StaffMembers[i].HourlySalary);
            Console.WriteLine("---------------------------");
        }

        return 0;
    }
}

To access each member of the array, you can use the foreach operator that allows you to use a name for each member and omit the square brackets. Here is an example:

public static class Exercise
{
    static int Main(string[] args)
    {
        var StaffMembers = new Employee[]
        {
            new Employee(20204, "Harry Fields", EmploymentStatus.FullTime, 16.85),
            new Employee(92857, "Jennifer Almonds", 
                         EmploymentStatus.FullTime, 22.25),
            new Employee(42963, "Sharon Culbritt", 
			 EmploymentStatus.PartTime, 10.95)
        };

        Console.WriteLine("Employees Records");
        Console.WriteLine("==========================");
        foreach(var Member in StaffMembers)
        {
            Console.WriteLine("Employee #: {0}", Member.EmployeeNumber);
            Console.WriteLine("Full Name:  {0}", Member.EmployeeName);
            Console.WriteLine("Status:     {0}", Member.Status);
            Console.WriteLine("Hourly Wage {0}", Member.HourlySalary);
            Console.WriteLine("---------------------------");
        }

        return 0;
    }
}

This would produce:

Employees Records
==========================
Employee #: 20204
Full Name:  Harry Fields
Status:     FullTime
Hourly Wage 16.85
---------------------------
Employee #: 92857
Full Name:  Jennifer Almonds
Status:     FullTime
Hourly Wage 22.25
---------------------------
Employee #: 42963
Full Name:  Sharon Culbritt
Status:     PartTime
Hourly Wage 10.95
---------------------------
Press any key to continue . . .

ApplicationApplication: Using an Array of Objects

  1. In the Solution Explorer, right-click Program.cs and click Rename
  2. Type RentalProperties.cs and press Enter twice
  3. Change it file as follows:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace RentalProperties2
    {
        public class RentalProperties
        {
           public static int Main(string[] args)
            {
                RentalProperty[] Properties = new RentalProperty[8];
    
                Properties[0] = new RentalProperty();
                Properties[0].propertyNumber = 192873;
                Properties[0].TypeOfProperty = PropertyType.SingleFamily;
                Properties[0].Bedrooms = 5;
                Properties[0].Bathrooms = 3.50F;
                Properties[0].MonthlyRent = 2250.00D;
                Properties[1] = new RentalProperty();
                Properties[1].propertyNumber = 498730;
                Properties[1].TypeOfProperty = PropertyType.SingleFamily;
                Properties[1].Bedrooms = 4;
                Properties[1].Bathrooms = 2.50F;
                Properties[1].MonthlyRent = 1885.00D;
                Properties[2] = new RentalProperty();
                Properties[2].propertyNumber = 218502;
                Properties[2].TypeOfProperty = PropertyType.Apartment;
                Properties[2].Bedrooms = 2;
                Properties[2].Bathrooms = 1.00F;
                Properties[2].MonthlyRent = 1175.50D;
                Properties[3] = new RentalProperty();
                Properties[3].propertyNumber = 612739;
                Properties[3].TypeOfProperty = PropertyType.Apartment;
                Properties[3].Bedrooms = 1;
                Properties[3].Bathrooms = 1.00F;
                Properties[3].MonthlyRent = 945.00D;
                Properties[4] = new RentalProperty();
                Properties[4].propertyNumber = 457834;
                Properties[4].TypeOfProperty = PropertyType.Townhouse;
                Properties[4].Bedrooms = 3;
                Properties[4].Bathrooms = 2.50F;
                Properties[4].MonthlyRent = 1750.50D;
                Properties[5] = new RentalProperty();
                Properties[5].propertyNumber = 927439;
                Properties[5].TypeOfProperty = PropertyType.Apartment;
                Properties[5].Bedrooms = 1;
                Properties[5].Bathrooms = 1.00F;
                Properties[5].MonthlyRent = 1100.00D;
                Properties[6] = new RentalProperty();
                Properties[6].propertyNumber = 570520;
                Properties[6].TypeOfProperty = PropertyType.Apartment;
                Properties[6].Bedrooms = 3;
                Properties[6].Bathrooms = 2.00F;
                Properties[6].MonthlyRent = 1245.95D;
                Properties[7] = new RentalProperty();
                Properties[7].propertyNumber = 734059;
                Properties[7].TypeOfProperty = PropertyType.Townhouse;
                Properties[7].Bedrooms = 4;
                Properties[7].Bathrooms = 1.50F;
                Properties[7].MonthlyRent = 1950.25D;
    
                Console.Title = "Solas Property Rental";
    
                Console.WriteLine("Properties Listing");
                Console.WriteLine("=============================================");
                Console.WriteLine("Prop #  Property Type Beds Baths Monthly Rent");
                Console.WriteLine("---------------------------------------------");
                for (int i = 0; i < 8; i++)
                {
                    Console.WriteLine("{0}\t{1}\t{2}  {3:F}{4,12}",
                                      Properties[i].propertyNumber,
                                      Properties[i].TypeOfProperty,
                                      Properties[i].Bedrooms,
                      		  Properties[i].Bathrooms,
                                      Properties[i].MonthlyRent.ToString("F"));
                }
                Console.WriteLine("=============================================");
    
                Console.ReadKey();
                return 0;
            }
        }
    }
  4. To execute the application, press F5
    Properties Listing
    =============================================
    Prop #  Property Type Beds Baths Monthly Rent
    ---------------------------------------------
    192873  SingleFamily    5  3.50     2250.00
    498730  SingleFamily    4  2.50     1885.00
    218502  Apartment       2  1.00     1175.50
    612739  Apartment       1  1.00      945.00
    457834  Townhouse       3  2.50     1750.50
    927439  Apartment       1  1.00     1100.00
    570520  Apartment       3  2.00     1245.95
    734059  Townhouse       4  1.50     1950.25
    =============================================
  5. Press Enter to close the DOS window and return to your programming environment

A Class Array as a Field

 

Introduction

Like a primitive type, an array of objects can be made a field of a class. You can primarily declare the array and specify its size. Here is an example:

public class CompanyRecords
{
    Employee[] Employees = new Employee[2];
}

After doing this, you can then initialize the array from the index of each member. Alternatively, as we saw for field arrays of primitive types, you can declare the array in the body of the class, then use a constructor or another method of the class to allocate memory for it.

To initialize the array, remember that each member is a value that must be allocated on the heap. Therefore, apply the new operator on each member of the array to allocate its memory, and then initialize it. Here is an example:

public class CompanyRecords
{
    Employee[] Employees;

    public CompanyRecords()
    {
        Employees = new Employee[2];

        Employees[0] = new Employee();
        Employees[0].EmployeeNumber = 70128;
        Employees[0].EmployeeName = "Frank Dennison";
        Employees[0].Status = EmploymentStatus.PartTime;
        Employees[0].HourlySalary = 8.65;

        Employees[1] = new Employee();
        Employees[1].EmployeeNumber = 24835;
        Employees[1].EmployeeName = "Jeffrey Arndt";
        Employees[1].Status = EmploymentStatus.Unknown;
        Employees[1].HourlySalary = 16.05;
    }
}

If the class used as field has an appropriate constructor, you can use it to initialize each member of the array. Here is an example:

public class CompanyRecords
{
    Employee[] Employees;

    public CompanyRecords()
    {
         Employees = new Employee[]
	 {
             new Employee(70128, "Justine Hearson", 
			  EmploymentStatus.PartTime, 10.62),
             new Employee(24835, "Bertha Hack", EmploymentStatus.FullTime, 18.94),
             new Employee(70128, "Frank Dennison", 
			  EmploymentStatus.Seasonal, 12.48),
             new Employee(24835, "Jeffrey Arndt", 
			  EmploymentStatus.PartTime, 16.05),
	 };
    }
}

Using the Array

Once you have created and initialized the array, you can use it as you see fit, such as displaying its values to the user. You must be able to access each member of the array, using its index. Once you have accessed member, you can get to its fields or properties. Here is an example:

using System;

public enum EmploymentStatus
{
    FullTime,
    PartTime,
    Seasonal,
    Unknown
};

public class Employee
{
    private long emplNbr;
    private string name;
    private EmploymentStatus st;
    private double wage;

    public Employee()
    {
    }

    public Employee(long Number, string Name,
                    EmploymentStatus EStatus, double Salary)
    {
        emplNbr = Number;
        name = Name;
        st = EStatus;
        wage = Salary;
    }

    public long EmployeeNumber
    {
        get { return emplNbr; }
        set { emplNbr = value; }
    }

    public string EmployeeName
    {
        get { return name; }
        set { name = value; }
    }

    public EmploymentStatus Status
    {
        get { return st; }
        set { st = value; }
    }

    public double HourlySalary
    {
        get { return wage; }
        set { wage = value; }
    }
}

public class CompanyRecords
{
    Employee[] Employees;

    public CompanyRecords()
    {
         Employees = new Employee[]
         {
             new Employee(70128, "Justine Hearson", 
			  EmploymentStatus.PartTime, 10.62),
             new Employee(24835, "Bertha Hack", EmploymentStatus.FullTime, 18.94),
             new Employee(70128, "Frank Dennison", 
			  EmploymentStatus.Seasonal, 12.48),
             new Employee(24835, "Jeffrey Arndt", 
			  EmploymentStatus.PartTime, 16.05),
         };
    }

    public void ShowRecords()
    {
        Console.WriteLine("Employees Records");
        Console.WriteLine("==========================");

        foreach (var Member in Employees)
        {
            Console.WriteLine("Employee #: {0}", Member.EmployeeNumber);
            Console.WriteLine("Full Name:  {0}", Member.EmployeeName);
            Console.WriteLine("Status:     {0}", Member.Status);
            Console.WriteLine("Hourly Wage {0}", Member.HourlySalary);
            Console.WriteLine("---------------------------");
        }
    }
}

public static class Exercise
{
    static int Main(string[] args)
    {
        var Records = new CompanyRecords();
        Records.ShowRecords();

        return 0;
    }
}

This would produce:

Employees Records
==========================
Employee #: 70128
Full Name:  Justine Hearson
Status:     PartTime
Hourly Wage 10.62
---------------------------
Employee #: 24835
Full Name:  Bertha Hack
Status:     FullTime
Hourly Wage 18.94
---------------------------
Employee #: 70128
Full Name:  Frank Dennison
Status:     Seasonal
Hourly Wage 12.48
---------------------------
Employee #: 24835
Full Name:  Jeffrey Arndt
Status:     PartTime
Hourly Wage 16.05
---------------------------
Press any key to continue . . .

Arrays of Objects and Methods

 

Passing an Array of Objects as Argument

As done for an array of a primitive type, you can pass an array of objects as arguments. You follow the same rules we reviewed; that is, in the parentheses of a method, enter the class name, the empty square brackets, and the name of the argument. Here is an example:

public class CompanyRecords
{
    public CompanyRecords(Employee[] Employees)
    {
    }
}

You can then access each member of the argument and do what you judge necessary. For example, you can display the values that the argument is holding. To call a method that takes an array of objects, in its parentheses, just enter the name of the array. Here is an example:

public class CompanyRecords
{
    public CompanyRecords(Employee[] Employees)
    {
         Employees = new Employee[]
         {
             new Employee(70128, "Justine Hearson",
			  EmploymentStatus.PartTime, 10.62),
             new Employee(24835, "Bertha Hack", EmploymentStatus.FullTime, 18.94),
             new Employee(70128, "Frank Dennison", 
			  EmploymentStatus.Seasonal, 12.48),
             new Employee(24835, "Jeffrey Arndt", 
			  EmploymentStatus.PartTime, 16.05),
         };
    }
}

public static class Exercise
{
    static int Main(string[] args)
    {
        var Values = new Employee[4];

        CompanyRecords Records = new CompanyRecords(Values);
        Records.ShowRecords();

        return 0;
    }
}

As stated for an array of primitive type, an array of objects passed as argument is treated as a reference. You can use this characteristic of arrays to initialize the array. You can also indicate that the array is passed by reference by preceding its name with the ref keyword.

Returning an Array of Objects

An array of objects can be returned from a method. To indicate this when defining the method, first type the name of the class followed by square brackets. Here is an example:

public class CompanyRecords
{
    public Employee[] RegisterEmployees()
    {
    }
}

In the body of the method, you can take care of any assignment you want. The major rule to follow is that, before exiting the method, you must return an array of the class indicated on the left side of the method name.

To use the method, you can simply call it. If you want, since the method returns an array, you can retrieve that series and store it in a local array for later use. Here is an example:

using System;

public enum EmploymentStatus
{
    FullTime,
    PartTime,
    Seasonal,
    Unknown
};

public class Employee
{
    private long emplNbr;
    private string name;
    private EmploymentStatus st;
    private double wage;

    public Employee()
    {
    }

    public Employee(long Number, string Name,
                    EmploymentStatus EStatus, double Salary)
    {
        emplNbr = Number;
        name = Name;
        st = EStatus;
        wage = Salary;
    }

    public long EmployeeNumber
    {
        get { return emplNbr; }
        set { emplNbr = value; }
    }

    public string EmployeeName
    {
        get { return name; }
        set { name = value; }
    }

    public EmploymentStatus Status
    {
        get { return st; }
        set { st = value; }
    }

    public double HourlySalary
    {
        get { return wage; }
        set { wage = value; }
    }
}

public class CompanyRecords
{
    public CompanyRecords()
    {
    }
    
    public Employee[] RegisterEmployees()
    {
        var Employees = new Employee[]
        {
             new Employee(70128, "Justine Hearson", 
			  EmploymentStatus.PartTime, 10.62),
             new Employee(24835, "Bertha Hack", EmploymentStatus.FullTime, 18.94),
             new Employee(70128, "Frank Dennison", 
			  EmploymentStatus.Seasonal, 12.48),
             new Employee(24835, "Jeffrey Arndt", 
			  EmploymentStatus.PartTime, 16.05),
        };
        return Employees;
    }

    public void ShowRecords(ref Employee[] Records)
    {
        Console.WriteLine("Employees Records");
        Console.WriteLine("==========================");

        foreach (var Staff in Records)
        {
            Console.WriteLine("Employee #: {0}", Staff.EmployeeNumber);
            Console.WriteLine("Full Name:  {0}", Staff.EmployeeName);
            Console.WriteLine("Status:     {0}", Staff.Status);
            Console.WriteLine("Hourly Wage {0}", Staff.HourlySalary);
            Console.WriteLine("---------------------------");
        }
    }
}

public static class Exercise
{
    static int Main(string[] args)
    {
        var Records = new CompanyRecords();

        var Contractors = Records.RegisterEmployees();
        Records.ShowRecords(ref Contractors);

        return 0;
    }
}

ApplicationApplication: Using Array of Objects With Methods

  1. To apply what we learned in the last few sections, change the file as follows:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace RentalProperties2
    {
        public class RentalProperties
        {
            private static void ShowProperties(RentalProperty[] Properties)
            {
                Console.WriteLine("Properties Listing");
                Console.WriteLine("=============================================");
                Console.WriteLine("Prop #  Property Type Beds Baths Monthly Rent");
                Console.WriteLine("---------------------------------------------");
                for (int i = 0; i < 8; i++)
                {
                    Console.WriteLine("{0}\t{1}\t{2}  {3:F}{4,12}",
                                      Properties[i].propertyNumber,
                                      Properties[i].TypeOfProperty,
                                      Properties[i].Bedrooms,
                      Properties[i].Bathrooms,
                                      Properties[i].MonthlyRent.ToString("F"));
                }
                Console.WriteLine("=============================================");
            }
    
            private static RentalProperty[] CreateListing()
            {
                RentalProperty[] HousesToRent = new RentalProperty[8];
    
                HousesToRent[0] = new RentalProperty();
                HousesToRent[0].propertyNumber = 192873;
                HousesToRent[0].TypeOfProperty = PropertyType.SingleFamily;
                HousesToRent[0].Bedrooms = 5;
                HousesToRent[0].Bathrooms = 3.50F;
                HousesToRent[0].MonthlyRent = 2250.00D;
                HousesToRent[1] = new RentalProperty();
                HousesToRent[1].propertyNumber = 498730;
                HousesToRent[1].TypeOfProperty = PropertyType.SingleFamily;
                HousesToRent[1].Bedrooms = 4;
                HousesToRent[1].Bathrooms = 2.50F;
                HousesToRent[1].MonthlyRent = 1885.00D;
                HousesToRent[2] = new RentalProperty();
                HousesToRent[2].propertyNumber = 218502;
                HousesToRent[2].TypeOfProperty = PropertyType.Apartment;
                HousesToRent[2].Bedrooms = 2;
                HousesToRent[2].Bathrooms = 1.00F;
                HousesToRent[2].MonthlyRent = 1175.50D;
                HousesToRent[3] = new RentalProperty();
                HousesToRent[3].propertyNumber = 612739;
                HousesToRent[3].TypeOfProperty = PropertyType.Apartment;
                HousesToRent[3].Bedrooms = 1;
                HousesToRent[3].Bathrooms = 1.00F;
                HousesToRent[3].MonthlyRent = 945.00D;
                HousesToRent[4] = new RentalProperty();
                HousesToRent[4].propertyNumber = 457834;
                HousesToRent[4].TypeOfProperty = PropertyType.Townhouse;
                HousesToRent[4].Bedrooms = 3;
                HousesToRent[4].Bathrooms = 2.50F;
                HousesToRent[4].MonthlyRent = 1750.50D;
                HousesToRent[5] = new RentalProperty();
                HousesToRent[5].propertyNumber = 927439;
                HousesToRent[5].TypeOfProperty = PropertyType.Apartment;
                HousesToRent[5].Bedrooms = 1;
                HousesToRent[5].Bathrooms = 1.00F;
                HousesToRent[5].MonthlyRent = 1100.00D;
                HousesToRent[6] = new RentalProperty();
                HousesToRent[6].propertyNumber = 570520;
                HousesToRent[6].TypeOfProperty = PropertyType.Apartment;
                HousesToRent[6].Bedrooms = 3;
                HousesToRent[6].Bathrooms = 2.00F;
                HousesToRent[6].MonthlyRent = 1245.95D;
                HousesToRent[7] = new RentalProperty();
                HousesToRent[7].propertyNumber = 734059;
                HousesToRent[7].TypeOfProperty = PropertyType.Townhouse;
                HousesToRent[7].Bedrooms = 4;
                HousesToRent[7].Bathrooms = 1.50F;
                HousesToRent[7].MonthlyRent = 1950.25D;
    
                return HousesToRent;
            }
    
            public static int Main(string[] args)
            {
                RentalProperty[] properties = CreateListing();
    
                Console.Title = "Solas Property Rental";
    
                ShowProperties(properties);
    
                Console.ReadKey();
                return 0;
            }
        }
    }
  2. To execute the application to see the result, on the main menu, click Debug -> Start Debugging
  3. After viewing the result, press Enter to close the DOS window and return to your programming environment
  4. On the main menu, click File -> Close Solution or File -> Close Project
  5. When asked whether you want to save, click Discard
 

Previous Copyright © 2010-2011 FunctionX Next