using System;

namespace abstract_method_and_class
{
abstract public class Control
{
protected int top;
protected int left;

//constructor takes two integers to fix locatio on the console
protected Control(int top, int left)
{
this.top = top;
this.left = left;
}

//simulates drawing the window
//notice: no implementation
abstract public void DrawWindow();
}

//ListBox derives from Control
public class ListBox : Control
{
private string listBoxContents; // new member variable

//constructor adds a parameter
public ListBox(int top, int left, string contents)
: base(top, left) //call base constructor
{
listBoxContents = contents;
}

//an overridden version implementing the abstract method

public override void DrawWindow()
{
Console.WriteLine("------------------------");
Console.WriteLine("Writing string to the listbox: {0}", listBoxContents);
Console.WriteLine("------------------------");
}
}

public class Button : Control
{
public Button(int top, int left)
: base(top, left)
{
}

//implement the abstract method
public override void DrawWindow()
{
Console.WriteLine("*************************");
Console.WriteLine("Drawing a button at {0}, {1}\n", top, left);
Console.WriteLine("*************************");
}
}

class Program
{
static void Main(string[] args)
{
Control[] winArray = new Control[3];
winArray[0] = new ListBox(1, 2, "First List Box");
winArray[1] = new ListBox(3, 4, "Second List Box");
winArray[2] = new Button(5, 6);

for (int i = 0; i < 3; i++)
{
winArray[i].DrawWindow();
}
}
} //end class Program
}

---

using System;

namespace Inheriting_From_Object
{
public class SomeClass
{
private int val;
public SomeClass(int someVal)
{
val = someVal;
}

public override string ToString()
{
return val.ToString();
}
}

class Program
{
static void DisplayValue(object o)
{
Console.WriteLine("The value of the object passed in is {0}", o);
}

static void Main(string[] AssemblyLoadEventArgs)
{

int i = 5;
Console.WriteLine("The value of i is: {0}", i.ToString());
DisplayValue(i);

SomeClass s = new SomeClass(7);
Console.WriteLine("The value of s is {0}", s.ToString());
DisplayValue(s);

int x = 11;
Console.WriteLine("The value of x is: {0}", x.ToString());
DisplayValue(x);
}
}
}

---

using System;

namespace Nested_Class
{
public class Fraction
{
private int numerator;
private int denominator;

public Fraction(int numerator, int denominator)
{
this.numerator = numerator;
this.denominator = denominator;
}

public override string ToString()
{
return String.Format("{0}/{1}", numerator, denominator);
}

internal class FractionArtist
{
public void Draw(Fraction f)
{
Console.WriteLine("Drawing the numerator: {0}", f.numerator);
Console.WriteLine("Drawing the denominator: {0}", f.denominator);
}
}
}

class program
{
static void Main(string[] args)
{
Fraction f1 = new Fraction(3, 4);
Console.WriteLine("f1: {0}", f1.ToString());

Fraction.FractionArtist fa = new Fraction.FractionArtist();
fa.Draw(f1);
}
}
}

---

using System;

namespace Conversions
{
public class Fraction
{
private int numerator;
private int denominator;

public Fraction(int numerator, int denominator)
{
Console.WriteLine("In Fraction Constructor(int, int)");
this.numerator = numerator;
this.denominator = denominator;
}

public Fraction(int wholeNumber)
{
Console.WriteLine("In Fraction Constructor(int)");
numerator = wholeNumber;
denominator = 1;
}

public static implicit operator Fraction(int theInt)
{
Console.WriteLine("In implicit conversion to Fraction");
return new Fraction(theInt);
}

public static explicit operator int(Fraction theFraction)
{
Console.WriteLine("In explicit conversion to int");
return theFraction.numerator / theFraction.denominator;
}

public static bool operator ==(Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator==");
if (lhs.denominator == rhs.denominator && lhs.numerator == rhs.numerator)
{
return true;
}
//code here to handle unlike fractions
return false;
}

public static bool operator !=(Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator !=");
return !(lhs == rhs);
}

public override bool Equals(object o)
{
Console.WriteLine("In method Equals");
if (!(o is Fraction))
{
return false;
}
return this == (Fraction)o;
}

public static Fraction operator +(Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator+");
if (lhs.denominator == rhs.denominator)
{
return new Fraction(lhs.numerator + rhs.numerator, lhs.denominator);
}

//simplistic soltion for unlike fractions
//1/2 + 3/4 == (1*4) + (3*2) / (2*4) == 10/8

int firstProduct = lhs.numerator * rhs.denominator;
int secondProduct = rhs.numerator * lhs.denominator;
return new Fraction(firstProduct + secondProduct, lhs.denominator * rhs.denominator);
}

public static Fraction operator -(Fraction lhs, Fraction rhs)
{

Console.WriteLine("In operator-");
if (lhs.denominator == rhs.denominator)
{
return new Fraction(lhs.numerator - rhs.numerator, lhs.denominator);
}

int firstProduct = lhs.numerator * rhs.denominator;
int secondProduct = rhs.numerator * lhs.denominator;
return new Fraction(firstProduct - secondProduct, lhs.denominator - rhs.denominator);
}

public override string ToString()
{
String s = numerator.ToString() + "/" + denominator.ToString();
return s;
}
}

class Program
{
static void Main(string[] args)
{
Fraction f1 = new Fraction(3, 4);
Console.WriteLine("f1: {0}", f1.ToString());

Fraction f2 = new Fraction(2, 4);
Console.WriteLine("f2: {0}", f2.ToString());

Fraction f3 = f1 + f2;
Console.WriteLine("f1 + f2 = f3: {0}", f3.ToString());

Fraction f4 = f3 + 5;
Console.WriteLine("f3+5 = f4: {0}", f4.ToString());

Fraction f5 = new Fraction(2, 4);
if (f5 == f2)
{
Console.WriteLine("f5: {0} == f2: {1}", f5.ToString(), f2.ToString());
}

Console.WriteLine("--------------------------------");
Fraction f6 = new Fraction(5);
Console.WriteLine("f6={0}", f6);

Fraction f7 = new Fraction(7, 2);
Console.WriteLine("f7={0}", f7);

Fraction f8 = f7+8;
Console.WriteLine("f8={0}", f8);

Fraction f9 = new Fraction(5, 2);
Console.WriteLine("f9={0}", f9);

Fraction f10 = f7 - f9;
Console.WriteLine("{0} - {1} = {2}", f7, f9, f10);

}
}
}

---

using System;
namespace CreatingAStruct
{
public struct Location
{
public int X { get; set; }
public int Y { get; set; }

public override string ToString()
{
return (string.Format("{0}, {1}", X, Y));
}
} //end struct Location

public class Tester
{
public void myFunc(Location loc)
{
loc.X = 50;
loc.Y = 100;
Console.WriteLine("in MyFunc: {0}", loc);
}

static void Main()
{
Location loc1 = new Location();
loc1.X = 200;
loc1.Y = 300;
Console.WriteLine("Loc1 location: {0}", loc1);

Tester t = new Tester();
t.myFunc(loc1);
Console.WriteLine("Loc1 location: {0}", loc1);
}
}
}