Saturday, November 13, 2010

Abstract Properties


Please read my previous article on Properties

Now, let’s move on to the second example to demonstrate how to define abstract properties.
Few things to keep in mind while using abstract properties
1.   It does not provide an implementation of the property accessor
2.   It has to be override in subclasses.
Example 2
In this example I am making three files:
  • abstractshape.cs: The abstract Shape class that contains an abstract Perimeter property.
  • shapes.cs: The subclasses of the Shape class.
  • shapetest.cs: A test program to display the areas of some Shape-derived objects.

File 1 - abstractshape.cs
This file declares the Shape class that contains the Perimeter property of the type double

// abstractshape.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    public abstract class Shape
    {
        private int myId;

        //Creating Constroctor with argument to set the id property
        public Shape(int shapeid)
        {
            Id = shapeid;   // calling the set accessor of the Id property
        }

        //craeting Id property for the shape class
        public int Id
        {
            get
            {
                return myId;
            }

            set
            {
                myId = value;
            }
        }

        // Perimeter is a read-only property - only a get accessor is needed:
        public abstract double Perimeter
        {
            get;
        }
        //overriding tostring() method
        public override string ToString()
        {
            return string.Format("{0}", Id) + " Perimeter = " + string.Format("{0:F2}", Perimeter);
        }
    }
}


Code Discussion
  • Property declaration itself contains the modifier, for example:
public abstract double Perimeter

  • While declaring an abstract property (in our example perimeter), we only need to indicate what will be the property accessors, without their implementation. In this example, only a Get accessor is available, so the property is read-only.

File 2 - shapes.cs
The following code shows three subclasses of Shape and how they override the Perimeter property to provide their own implementation.

// shapes.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    public class Square : Shape
    {
        private int Side;

        public Square(int side, int id)
            : base(id)
        {
            Side = side;
        }

        public override double Perimeter
        {
            get
            {
                // Given the side, return the Perimeter of a square:
                return 4 * Side;
            }
        }
    }

    public class Circle : Shape
    {
        private int myRadius;

        public Circle(int radius, int id)
            : base(id)
        {
            myRadius = radius;
        }

        public override double Perimeter
        {
            get
            {
                // Given the radius, return the Perimeter of a circle:
                return 2 * System.Math.PI * myRadius;
            }
        }
    }

    public class Rectangle : Shape
    {
        private int mylength;
        private int mybreadth;

        public Rectangle(int length, int breadth, int id)
            : base(id)
        {
            mylength = length;
            mybreadth = breadth;
        }

        public override double Perimeter
        {
            get
            {
                // Given the length and breadth, return the Perimeter of a rectangle:
                return 2 * mylength * mybreadth;
            }
        }
    }

}
Code Discussion
  • Shape class is Inherited in all three classes Rectangle, circle, square and id is passed to the base class constructor:
public Rectangle(int length, int breadth, int id)
            : base(id)

  • Each Class extending, implementing or inheriting the shape class has overridden and implemented the perimeter property which was read only as only get assessor was set. According to their own needs.
public override double Perimeter
        {
            get
            {
                // Given the length and breadth, return the Perimeter of a rectangle:
                return 2 * mylength * mybreadth;
            }
        }


File 3 - shapetest.cs
This file will contain a test class in which we will implement the classes we have created above and will check their results. By creating no of shape derived objects and calculating their perimeters

// shapetest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class shapetest
    {
        public static void Main()
        {
            //creating an array of shape class
            Shape[] shapes =
         {
             //with an object of each subclass
            new Square(5, 1),
            new Circle(3, 2),
            new Rectangle( 4, 5, 3)
         };

            //writing on the console
            Console.WriteLine("Shapes Collection");
            //going through each object in shape class
            foreach (Shape s in shapes)
            {
                //as we have overriddin the tostring property so we can just write the object in the console.writeline
                Console.WriteLine(s);               
            }
            //waiting for user to press a key so that the screen (console) will be displayed till user press any key
            Console.ReadKey();
        }

    }
}



Output
Shapes Collection
1 Perimeter = 20.00
2 Perimeter = 18.85
3 Perimeter = 40.00



Code Discussion
  • An array of Shape class is created with 3 objects each of 3 different subclasses
Shape[] shapes =
         {
            new Square(5, 1),
            new Circle(3, 2),
            new Rectangle( 4, 5, 3)
         };
·         And then the perimeter property is used by tostring() of shape object to display on the console. Which is used in foreach loop to iterate through all shape objects?

foreach (Shape s in shapes)
            {
         
      Console.WriteLine(s);               
            }


Building and Running the Sample within Visual Studio
To build and run the Properties samples
  1. Open the solution.
  2. In Solution Explorer, right-click the project properties and click Application tab
  3. From Startup object select the shapetest as StartUp class.
  4. From the Debug menu, click Start without Debugging.
  5. Repeat the preceding steps for car class in example one.

No comments:

Post a Comment

Subscribe via email

Enter your email address:

Delivered by FeedBurner

MSDotnetMentor

MSDotnetMentor My Website http://msdotnetmentor.com