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.

Properties in C#


Today my friend asked me a question for which i provided a solution using properties of the class. but then he asked me what are these properties, why to use them and how to Implement them To answer these questions

Definition:
Properties are named members of classes, structs, and interfaces. They provide a flexible mechanism to read, write, or compute the values of private fields through accessors. or we can say Properties equip a class with a public way to expose its private members or to get and set values for those private members, while hiding implementation or verification code.
A property has two accessors
  • Get
  • Set

The get keyword
with the help of this keyword we can define an accessor method for a property or an indexer which retrieves the value of the property or the indexer element.
The Set Keyword
With the help of this keyword we can define which accessor is used to assign a new value to the property or indexer.
The value keyword is used to define the value being assigned by the set accessor. Properties which do not implement a set accessor are termed as read only Properties.

Let’s take the first example to demonstrate how to declare and use read/write properties.

Example 1
This sample shows a Car class that has two properties: Name (string) and Model (int). Both properties have read/write attributes.


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

namespace ConsoleApplication1
{
classCar
    {
privatestring CarName = "N/A";
privateint CarModelNo = 0;
// Declare a Name property of type string:
publicstring Name
        {
get
            {
//returns the Carname
return CarName;
            }
set
            {
//set the value od carname provided by the user
                CarName = value;
            }
        }
// Declare an Age property of type int:
publicint ModelNo
        {
get
            {
//returns the CarModelNo
return CarModelNo;
            }
set
            {
//sets the value for CarModelNo
                CarModelNo = value;
            }
        }
//Overriding the ToString function of the class for demonstration
publicoverridestring ToString()
        {
return"Name = " + Name + ", ModelNo = " + ModelNo;
        }
publicstaticvoid Main()
        {
Console.WriteLine("Simple Properties");
// Create a new Car object:
Car mycar = newCar();
// Print out the name and the modelno associated with the car:
Console.WriteLine("Car details - {0}", mycar);
// Set some values on the car object:
            mycar.Name = "Maurti";
            mycar.ModelNo = 1;
Console.WriteLine("Car details - {0}", mycar);
// Increment the modelno property:
            mycar.ModelNo += 1;
Console.WriteLine("Car details - {0}", mycar);
Console.Read();
        }

    }
}
Output
Simple Properties
Car details - Name = N/A, ModelNo = 0
Car details - Name = Maruti, ModelNo =
Person details - Name = Joe, ModelNo = 100

Code Discussion
  • Notice the way that the properties are declared, for example, consider the Name property:

publicstring Name
        {
get
            {
return CarName;
            }
set
            {
                              CarName = value;
            }
        }
  • After declaring the property Set and Get methods are contained inside the declaration. We can control a property is read/write, read-only, or write-only by controlling Get or Set methods. If we only include Get Method the property will be read only if only set method is used the property will be write only (Although very less scenarios I have seen this), and as in our example if both Get and Set are used that means property is read/write.
  • Once the properties are created or declared, they can be used as if they are the members of that class. The following statementssows both getting and setting the value of a property

mycar.Name = "Maurti";
mycar.ModelNo = 1;

  • If you have noticed that in a property’s Set method a special value variable is available which we have not declared anywhere. This variable contains the value that the user has specified, for example:

CarName = value;

  • You can see that these properties are used as other variables only see how we have incremented the ModelNo property

mycar.ModelNo += 1;

  • The ToString() method is overridden in this example:
publicoverridestring ToString()
        {
return"Name = " + Name + ", ModelNo = " + ModelNo;
}
Check that I have not used the ToString() explicitly. It is invoked by default by the WriteLine calls.


In my next article I will  discus Abstract Properties

you can read Properties in C# here

Subscribe via email

Enter your email address:

Delivered by FeedBurner

MSDotnetMentor

MSDotnetMentor My Website http://msdotnetmentor.com