using System;

 

namespace OperatorOverloading

{

/// <remarks>

/// Class that implements a simple counter.

/// </remarks>

public class MyCounter

{

private int _counter = 0;

 

/// <value>Get or set the counter value</value>

public int CounterValue

{

get

{

return this._counter;

}

set

{

this._counter = value;

}

}

 

/// <summary>

/// Constructor

/// </summary>

/// <param name ="InitialValue">Initial counter value</param>

public MyCounter(int InitialValue)

{

this.CounterValue = InitialValue;

}

 

/// <summary>

/// Increment the counter by one.

/// </summary>

/// <param name = "Counter">Counter to increment</param>

/// <returns>Incremented counter</returns>

public static MyCounter operator ++(MyCounter Counter)

{

Counter.CounterValue++;

return Counter;

}

 

/// <summary>

/// Decrement the counter by one.

/// </summary>

/// <param name = "Counter">Counter to decrement</param>

/// <returns>Decremented counter</returns>

public static MyCounter operator --(MyCounter Counter)

{

Counter.CounterValue--;

return Counter;

}

}

}

MyCounter count = new MyCounter(5);

Console.WriteLine(count.CounterValue);

count++;

Console.WriteLine(count.CounterValue);

using System;

 

namespace OperatorOverloading

{

/// <remarks>

/// Class representing a standardized test whose score is

/// comprised of the scores from various sections.

/// </remarks>

public class StandardizedTest

{

private int _MathScore = 0;

private int _Reading = 0;

private int _Science = 0;

 

/// <value>Get or set the math score</value>

public int MathScore

{

get

{

return this._MathScore;

}

set

{

this._MathScore = value;

}

}

 

/// <value>Get or set the reading score</value>

public int Reading

{

get

{

return this._Reading;

}

set

{

this._Reading = value;

}

}

 

/// <value>Get or set the science score</value>

public int Science

{

get

{

return this._Science;

}

set

{

this._Science = value;

}

}

 

/// <summary>

/// Constructor

/// </summary>

/// <param name = "math">Math score</param>

/// <param name = "reading">Reading score</param>

/// <param name = "science">Science score</param>

public StandardizedTest(int math, int reading, int science)

{

this.MathScore = math;

this.Reading = reading;

this.Science = science;

}

 

/// <summary>

/// Determine if the first test score is greater.

/// </summary>

/// <param name ="score1"></param>

/// <param name ="test2"></param>

/// <returns></returns>

public static bool operator >(StandardizedTest score1, StandardizedTest score2)

{

if ((score1.MathScore + score1.Reading + score1.Science) > (score2.MathScore + score2.Reading + score2.Science))

{

return true;

}

 

return false;

}

 

/// <summary>

/// Determine if the first test score is less.

/// </summary>

/// <param name ="score1"></param>

/// <param name ="test2"></param>

/// <returns></returns>

public static bool operator <(StandardizedTest score1, StandardizedTest score2)

{

if ((score1.MathScore + score1.Reading + score1.Science) < (score2.MathScore + score2.Reading + score2.Science))

{

return true;

}

 

return false;

}

}

}

StandardizedTest student1 = new StandardizedTest(200, 400, 400);

StandardizedTest student2 = new StandardizedTest(400, 400, 400);

 

if (student1 > student2)

{

Console.WriteLine("Student1 performed better");

}

else

{

Console.WriteLine("Student1 did not do better");

}

using System;

 

namespace OperatorOverloading

{

/// <remarks>

/// File formats may be comma delimited, positional, or XML.

/// </remarks>

public class FileFormat

{

public const string COMMA_DELIMITED = "C";

public const string POSITIONAL = "P";

public const string XML = "X";

 

private string _FileFormatValue;

 

/// <value>Get or set the file format value</value>

public string FileFormatValue

{

get

{

return this._FileFormatValue;

}

set

{

if (value.Equals(FileFormat.COMMA_DELIMITED) || value.Equals(FileFormat.POSITIONAL) || value.Equals(FileFormat.XML))

{

this._FileFormatValue = value;

}

}

}

 

/// <summary>

/// Constructor

/// </summary>

public FileFormat()

{

this._FileFormatValue = "";

}

 

/// <summary>

/// Implicitly convert from a string to FileFormat.

/// </summary>

/// <param name = "v_Value">Value to convert</param>

/// <returns>FileFormat</returns>

public static implicit operator FileFormat(string v_Value)

{

FileFormat f = new FileFormat();

f.FileFormatValue = v_Value;

return f;

}

}

}

string dbFileFormat = "C"; // Assume this is from database

FileFormat fileFormat = new FileFormat();

fileFormat = dbFileFormat;

string dbFileFormat = "C"; // Assume this is from database

FileFormat fileFormat = new FileFormat();

fileFormat = (FileFormat)dbFileFormat;

using System;

 

namespace OperatorOverloading

{

/// <remarks>

/// Custom class for keeping dynamic memory like array.

/// </remarks>

public class MyArray

{

private int[] _Array;

 

/// <summary>

/// Constructor

/// </summary>

public FileFormat()

{

this._Array = {0, 0, 0, 0, 0, 0, 0, 0};

}

 

/// <value>Get or set the array values</value>

public int this[int index]

{

get

{

return this._Array[index];

}

set

{

this._Array[index] = value;

}

}

 

/// <value>Get or set length of the array</value>

public int Length

{

get

{

return this._Array.Length;

}

set

{

this._Array = new int[value];

}

}

}

}