Class Interface

access to a private field through a property

Posted on by coder

/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa

Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/
//
// Property.cs — Demonstrates access to a private field through a property.
// Compile this program with the following command line:
// C:>csc Property.cs
//
namespace nsProperty
{
using System;
public class Property
{
const double radian = 57.29578;
const double pi = 3.14159;
int Angle
{
get
{
int angle = (int) (fAngle * radian + 0.5);
angle = angle == 360 ? 0 : angle;
return (angle);
}
set
{
double angle = (double) value / radian;
if (angle < (2 * pi)) { fAngle = angle; Console.WriteLine ("fAngle set to {0,0:F5}", fAngle); } else { Console.WriteLine ("fAngle not modified"); } } } double fAngle = 0.0; // Angle in radians static public int Main (string [] args) { int angle; try { angle = int.Parse (args[0]); } catch (IndexOutOfRangeException) { Console.WriteLine ("usage: circle [angle in degrees]"); return (-1); } catch (FormatException) { Console.WriteLine ("Please use a number value for the angle in degrees"); return (-1); } Property main = new Property(); main.Angle = angle; Console.WriteLine ("The angle is {0} degrees", main.Angle); return (0); } } } [/csharp]

The use of an abstract property

Posted on by coder 

   

/*
C# Programming Tips &amp; Techniques
by Charles Wright, Kris Jamsa

Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/

//
// Abstract.cs -- Demonsrates the use of an abstract property.
//
//                Compile this program with the following command line:
//                    C:>csc Abstract.cs
//
namespace nsAbstract
{
    using System;
    using System.Runtime.InteropServices;
    public class AbstractPro
    {
        static public void Main ()
        {
            Console.WriteLine (clsAbstract.StaticMethod());
        }
    }
    //
    // To use the abstract modifier on a method, the class also must
    // be declared as abastract
    abstract class clsAbstract
    {
    //
    // To declare an abstract method, end the declaration with a semicolon.
    // Do not provide a body for the method.
        abstract public int AbstractMethod();
    //
    // An abstract class may contain a static method. You do not have
    // to declare an instance of the class to access a static method
        static public double StaticMethod()
        {
            return (3.14159 * 3.14159);
        }
        abstract public long Prop
        {
            get;
            set;
        }
    }
    //
    // Inherit from the abstract class. The following class implements
    // the AbstractMethod().
    // The access level of the derived class method must be the same
    // as the access level of the base class abstract method.
    class clsDerivedFromAbstract : clsAbstract
    {
        override public int AbstractMethod()
        {
            return (0);
        }
        override public long Prop
        {
            get
            {
                return (val);
            }
            set
            {
                val = value;
            }
        }
        private long val;
    }
}

Illustrates the use of a property

Posted on by coder 

   

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy

Publisher: Sybex;
ISBN: 0782129110
*/
/*
  Example6_4.cs illustrates the use of a property
*/


// declare the Car class
class Car
{

  // declare a private field
  private string make;

  // declare a property
  public string Make
  {
    get
    {
      return make;
    }
    set
    {
      make = value;
    }
  }

}


public class Example6_4
{

  public static void Main()
  {

    // create a Car object
    System.Console.WriteLine("Creating a Car object");
    Car myCar = new Car();

    // set the Car Make
    System.Console.WriteLine("Setting the Car object&#039;s Make property to Porsche");
    myCar.Make = "Porsche";

    System.Console.WriteLine("myCar.Make = " + myCar.Make);

  }

}

Demonstrates the use of properties to control how values are saved in fields

Posted on by coder 

   

/*
C# Programming Tips &amp; Techniques
by Charles Wright, Kris Jamsa

Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/

//  Rect.cs - Demonstrates the use of properties to control how values are
//            saved in fields
//
//            This is a Visual Studio project. To compile outside of Visual
//            Studio, use the following command line:
//                C:>csc rect.cs
//
using System;
using System.Drawing;

namespace nsRect
{
  struct POINT
  {
    public POINT (int x, int y)
    {
      this.cx = x;
      this.cy = y;
    }
    public int cx;
    public int cy;
    public override string ToString ()
    {
      return (String.Format ("({0}, {1})", cx, cy));
    }
  }
  struct RECT
  {
    public RECT (Rectangle rc)
    {
      m_UpperLeft.cx = rc.X;
      m_UpperLeft.cy = rc.Y;
      m_LowerRight.cx = rc.X + rc.Width;
      m_LowerRight.cy = rc.Y + rc.Height;
    }
    // Define constructors
    public RECT (POINT pt1, POINT pt2)
    {
      m_UpperLeft = pt1;
      m_LowerRight = pt2;
    }
    public RECT (int x1, int y1, int x2, int y2)
    {
      m_UpperLeft.cx = x1;
      m_UpperLeft.cy = y1;
      m_LowerRight.cx = x2;
      m_LowerRight.cy = y2;
    }
    public RECT (POINT pt1, int Width, int Height)
    {
      m_UpperLeft.cx = pt1.cx;
      m_UpperLeft.cy = pt1.cy;
      m_LowerRight.cx = pt1.cx + Width;
      m_LowerRight.cy = pt1.cy + Height;
    }
    // Property to get and set the upper left point
    public POINT UpperLeft
    {
      get {return (m_UpperLeft);}
      set {m_UpperLeft = value;}
    }
    // Property to get and set the lower right point
    public POINT LowerRight
    {
      get {return (m_LowerRight);}
      set {m_LowerRight = value;}
    }
    // Property to return a normalized System.Drawing.ectangle object
    public System.Drawing.Rectangle Rectangle
    {
      get
      {
        RECT rc = Normal;
        return (new Rectangle (rc.UpperLeft.cx, rc.UpperLeft.cy,
          rc.LowerRight.cx - rc.UpperLeft.cx,
          rc.LowerRight.cy - rc.UpperLeft.cy));
      }
    }
    // Property to return a normalized copy of this rectangle
    public RECT Normal
    {
      get
      {
        return (new RECT (
          Math.Min (m_LowerRight.cx, m_UpperLeft.cx),
          Math.Min (m_LowerRight.cy, m_UpperLeft.cy),
          Math.Max (m_LowerRight.cx, m_UpperLeft.cx),
          Math.Max (m_LowerRight.cy, m_UpperLeft.cy))
          );

      }
    }
    private POINT m_UpperLeft;
    private POINT m_LowerRight;
    public override string ToString()
    {
      return (String.Format ("Upper left = {0}; Lower right = {1}",
        m_UpperLeft, m_LowerRight));
    }
  }
  public class Rect
  {
    static public void Main ()
    {
      // Define a "normal" rectangle
      POINT pt1 = new POINT (-10,30);
      POINT pt2 = new POINT (100, 100);
      RECT rc = new RECT (pt1, pt2);
      Console.WriteLine ("RECT: " + rc);
      Console.WriteLine ("Normal: " + rc.Normal);
      Console.WriteLine ("Rectangle: " + rc.Rectangle + "
");
      // Define a rectangle with normal x but not y
      pt1.cx = 100;
      pt1.cy = 50;
      pt2.cx = 200;
      pt2.cy = 20;
      rc.UpperLeft = pt1;
      rc.LowerRight = pt2;
      Console.WriteLine ("RECT: " + rc);
      Console.WriteLine ("Normal: " + rc.Normal);
      Console.WriteLine ("Rectangle: " + rc.Rectangle + "
");
      // Define a rectangle with normal y but not x
      pt1.cx = 200;
      pt1.cy = 50;
      pt2.cx = 100;
      pt2.cy = 80;
      rc.UpperLeft = pt1;
      rc.LowerRight = pt2;
      Console.WriteLine ("RECT: " + rc);
      Console.WriteLine ("Normal: " + rc.Normal);
      Console.WriteLine ("Rectangle: " + rc.Rectangle + "
");
      // Define a rectangle with both values of upper left greater than the lower y
      pt1.cx = 225;
      pt1.cy = 180;
      pt2.cx = 25;
      pt2.cy = 35;
      rc.UpperLeft = pt1;
      rc.LowerRight = pt2;
      Console.WriteLine ("RECT: " + rc);
      Console.WriteLine ("Normal: " + rc.Normal);
      Console.WriteLine ("Rectangle: " + rc.Rectangle + "
");
      // Define a rectangle with points equal
      pt1.cx = 75;
      pt1.cy = 150;
      pt2.cx = 75;
      pt2.cy = 150;
      rc.UpperLeft = pt1;
      rc.LowerRight = pt2;
      Console.WriteLine ("RECT: " + rc);
      Console.WriteLine ("Normal: " + rc.Normal);
      Console.WriteLine ("Rectangle: " + rc.Rectangle + "
");
    }
  }
}

Define properties for class

Posted on by coder 

   

/*
Learning C# 
by Jesse Liberty

Publisher: O&#039;Reilly 
ISBN: 0596003765
*/
 using System;

 namespace Properties
 {
     class Time
     {

         // private member variables
         private int year;
         private int month;
         private int date;
         private int hour;
         private int minute;
         private int second;

         // create a property
         public int Hour
         {
             get
             {
                 return hour;
             }

             set
             {
                 hour = value;
             }
         }

         // public accessor methods
         public void DisplayCurrentTime()
         {
             System.Console.WriteLine(
                 "Time: {0}/{1}/{2} {3}:{4}:{5}",
                 month, date, year, hour, minute, second);
         }


         // constructors
         public Time(System.DateTime dt)
         {
             year =      dt.Year;
             month =     dt.Month;
             date =      dt.Day;
             hour =      dt.Hour;
             minute =    dt.Minute;
             second =    dt.Second;
         }


    }
    public class PropertiesTester
    {
       public void Run()
       {
           System.DateTime currentTime = System.DateTime.Now;
           Time t = new Time(currentTime);
           t.DisplayCurrentTime();

           // access the hour to a local variable
           int theHour = t.Hour;

           // display it
           System.Console.WriteLine("Retrieved the hour: {0}",
               theHour);

           // increment it
           theHour++;

           // reassign the incremented value back through
           // the property
           t.Hour = theHour;

           // display the property
           System.Console.WriteLine("Updated the hour: {0}", t.Hour);
       }

       [STAThread]
       static void Main()
       {
          PropertiesTester t = new PropertiesTester();
          t.Run();
       }
    }
 }

Use properties to set and get private members

Posted on by coder 

   

/*
C#: The Complete Reference 
by Herbert Schildt 

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/


// Use properties to set and get private members. 
 
using System; 
 
// A class for two-dimensional objects. 
class TwoDShape { 
  double pri_width;  // now private 
  double pri_height; // now private  
 
  // Properties for width and height. 
  public double width { 
     get { return pri_width; } 
     set { pri_width = value; } 
  } 
 
  public double height { 
     get { return pri_height; } 
     set { pri_height = value; } 
  } 
 
  public void showDim() { 
    Console.WriteLine("Width and height are " + 
                       width + " and " + height); 
  } 
} 
 
// A derived class of TwoDShape for triangles. 
class Triangle : TwoDShape { 
  public string style; // style of triangle 
   
  // Return area of triangle. 
  public double area() { 
    return width * height / 2;  
  } 
 
  // Display a triangle&#039;s style. 
  public void showStyle() { 
    Console.WriteLine("Triangle is " + style); 
  } 
} 
 
public class Shapes2 { 
  public static void Main() { 
    Triangle t1 = new Triangle(); 
    Triangle t2 = new Triangle(); 
 
    t1.width = 4.0; 
    t1.height = 4.0; 
    t1.style = "isosceles"; 
 
    t2.width = 8.0; 
    t2.height = 12.0; 
    t2.style = "right"; 
 
    Console.WriteLine("Info for t1: "); 
    t1.showStyle(); 
    t1.showDim(); 
    Console.WriteLine("Area is " + t1.area()); 
 
    Console.WriteLine(); 
 
    Console.WriteLine("Info for t2: "); 
    t2.showStyle(); 
    t2.showDim(); 
    Console.WriteLine("Area is " + t2.area()); 
  } 
}