Modify your Person class, providing an automatic implementation for the Name property and removing the data member.

Build and run the application, which should work exactly the same as before.

Because you used the property in the constructor rather than assigning to the data member, changing to an auto-implemented property still works.

Either start a new CLR Console Application project or modify the one from the previous exercise.

Type or edit the definition of the Person class so that it looks like the following code. Place it after the using namespace System; line and before the main method.

ref class Person
{
    int dd, mm, yyyy;

public:
    // Person class constructor
    Person(String ^n, int d, int m, int y)
    {
        Name = n;
        dd = d; mm = m; yyyy = y;
    }

    // Auto implementation of the Name property
    property String ^Name;

    // The read-only Age property
    property int Age
    {
        int get() {
            DateTime now = DateTime::Now;
            return now.Year - yyyy;
        }
    }
};

The class now has three integer data members to hold the date of birth, initialized in the constructor.

The Age property now has only a get method, which retrieves a DateTime object representing the current date and time and then calculates the age from the difference between the current year and the stored year.

Use the Name and Age properties as you did in the previous example.

int main(array<String ^> ^args)
{
    // Create a Person object
    Person ^p = gcnew Person("fred", 4,9,1955);

    // Access the Name and Age properties
    Console::WriteLine("Age of {0} is {1}", p->Name, p->Age);
    return 0;
}

You can’t set the Age property because you haven’t provided a setter. This will result in a compiler error if you try to assign to the Age property.

Build and run the application.

Create a new CLR Console Application project named PropertyInheritance.

Immediately after the using namespace System; line, define an abstract class called Shape.

public ref class Shape abstract
{
public:
    virtual property double Area;
};

This class defines a property called Area that is virtual and which can be overridden by subclasses.

Add the definition for a Circle class, which inherits from Shape and which also implements the Area property.

public ref class Circle : Shape
{
    double radius;
public:
    Circle(double r)
    {
        radius = r;
    }

    virtual property double Area
    {
        double get() override {
            return Math::PI * radius * radius;
        }
    }
};

The constructor for Circle takes a value for the radius, which is used in the Area property to calculate the area of the circle. Note the placement of the modifiers on the Area property declaration: It is declared as virtual, and the get is declared as an override.

Add a simple function to take a Shape and print out its area.

void printArea(Shape ^s)
{
    Console::WriteLine("Area is {0}", s->Area);
}

Create a Circle in main and pass it to the printArea function.

Circle ^c = gcnew Circle(4.0);
printArea(c);

Build and run the application.

You will see that even though the printArea function has a Shape as its argument type, it will use the Circle implementation of Area at run time.

Add a public property to Account.h to allow read-only access to the account number, as shown here:

property long AccountNumber
{
    long get() { return accNumber; }
}

You can add the function definition inline in the class definition. Remember to put it in the public section.

You also need to add a read-only property for the balance member, because in real life, you don’t want people simply modifying the balances in their accounts from code.

property double Balance
{
    double get() { return balance; }
}

Add a read/write property for the overdraft limit because it’s quite possible that the limit might be changed from time to time.

property double OverdraftLimit
{
    double get() { return limit; }
    void set(double value) {
        if (value < 0)
            throw gcnew ArgumentException("Limit can't be negative");

        limit = value;
    }
}

If you choose to implement these properties inline in the class definition, you’ll need to add a using namespace System; line or fully qualify the name of ArgumentException before the code will compile.

Test out your implementation by adding some code to the main function in Banker.cpp to create a new Account object and access its properties. Include the Account.h file, and then add code to create an Account object, as demonstrated here:

// Create an Account object
Account ^theAccount = gcnew Account(123456, 0.0, 0.0);

Build and run the application and check the output.

Open the Bank.h header file. Add the following two lines of code immediately after the #pragma once line at the top of the file:

using namespace System::Collections::Generic;
#include "Account.h"

The using declaration will make it easier to use a List in the Bank class, and you’ll need to reference the Account class later.

Add a List variable to the Bank class, ensuring that it’s private.

List<Account^> ^accounts;

Because List is a generic collection, you need to specify what it is going to hold. In this case, the List is going to hold Account handles.

Add the code for the public AddAccount method inline in the header file as follows:

bool AddAccount(Account ^acc)
{
    // check if the account is already in the list
    if (accounts->Contains(acc))
        return false;
    else
        accounts->Add(acc);
    return true;
}

AddAccount takes a handle to an Account object and then uses the List::Contains method to check whether the account already exists in the collection. If it doesn’t, the Account is added to the collection.

Add code for the RemoveAccount function, which works in a very similar way.

bool RemoveAccount(Account ^acc)
{
    // check if the account is already in the list
    if (accounts->Contains(acc))
    {
        accounts->Remove(acc);
        return true;
    }
    else
        return false;
}

RemoveAccount checks whether an Account is in the list and, if present, removes it. It isn’t necessary to call Contains because RemoveAccount will silently do nothing if you try to remove an item that isn’t in the list. However, users might be interested in knowing that the account they’re trying to remove isn’t in the collection already.

Add the following line of code to the Bank constructor to create the List member:

accounts = gcnew List<Account^>();

Build the application to ensure that there are no errors.

Open the Bank.h header file.

Add the following code to implement the property:

// Indexed property to return an account
property Account ^default[long]
{
    Account ^get(long num)
    {
        for each(Account ^acc in accounts)
        {
            if (acc->AccountNumber == num)
                return acc;
        }
        throw gcnew ArgumentOutOfRangeException("No such account");
    }
}

// Get account 12345
Account ^acc = myBank[12345];

When you find an account whose number matches the one passed in, its handle is returned. If no such account is found, an exception is thrown because trying to access a nonexistent account is equivalent to reading off the end of an array: It’s a serious error that should be signaled to the caller.

Test out the Bank class by adding some code to the main function in Banker.cpp. You’ll need to start by ensuring that the Bank.h and Account.h header files are included. Next add some code so that your main function is similar to the following:

int main(array<String ^> ^args)
{
    Console::WriteLine("Bank example");

    // Create a bank
    Bank ^theBank = gcnew Bank();

    // Create some accounts
    Account ^accountOne = gcnew Account(123456, 100.0, 0.0);
    Account ^accountTwo = gcnew Account(234567, 1000.0, 100.0);
    Account ^accountThree = gcnew Account(345678, 10000.0, 1000.0);

    // Add them to the Bank
    theBank->AddAccount(accountOne);
    theBank->AddAccount(accountTwo);
    theBank->AddAccount(accountThree);

    // Use the indexed property to access an account
    Account ^pa = theBank[234567];
    Console::WriteLine("Account Number is {0}", pa->AccountNumber);

    return 0;
}

After creating a Bank and a number of Account objects, you add the Account objects to the Bank collection by calling Add. You can then use the indexed property to access an account by number and use that pointer to display the balance. Test the property by passing in an account number that doesn’t exist and check that an exception is thrown.

Build and run the application and then check the output.