C# Programming/Classes

publicclassEmployee
{
privateint_Age;
privatestring_Name;
publicintAge
{
get{return_Age;}
set{_Age=value;}
}
publicstringName
{
get{return_Name;}
set{_Name=value;}
}
publicvoidGetPayCheck()
{
}
publicvoidWork()
{
}
}
publicclassSample
{
publicstaticvoidMain()
{
Employeemarissa=newEmployee();
marissa.Work();
marissa.GetPayCheck();
}
}

Methods

voidIncrement(refintx,intdx=1)

Constructors of classes

publicclassEmployee
{
publicEmployee()
{
System.Console.WriteLine("Constructed without parameters");
}
publicEmployee(stringstrText)
{
System.Console.WriteLine(strText);
}
}
publicclassSample
{
publicstaticvoidMain()
{
System.Console.WriteLine("Start");
EmployeeAlfred=newEmployee();
EmployeeBilly=newEmployee("Parameter for construction");
System.Console.WriteLine("End");
}

publicclassEmployee
{
publicEmployee(stringstrText,intiNumber)
{
...
}

publicEmployee(stringstrText)
:this(strText,1234)// calls the above constructor with user-specified text and the default number
{}

publicEmployee()
:this("default text")// calls the above constructor with the default text
{}
}

Finalizers (Destructors)

publicclassEmployee
{
publicEmployee(stringstrText)
{
System.Console.WriteLine(strText);
}
~Employee()
{
System.Console.WriteLine("Finalized!");
}
publicstaticvoidMain()
{
Employeemarissa=newEmployee("Constructed!");
marissa=null;
}
}

Properties

publicclassMyClass
{
privateintm_iField=3;// Sets integerField with a default value of 3
publicintIntegerField
{
get
{
returnm_iField;// get returns the field you specify when this property is assigned
}
set
{
m_iField=value;// set assigns the value assigned to the property of the field you specify
}
}
}

classCulture
{
publicintTalkedCountries{get;set;}
publicstringLanguage{get;set;}
}
classInterculturalDialogue
{
Cultureculture;
culture.Language="Italian";// ==> culture.SetLanguage("Italian");
stringstrThisLanguage=culture.Language;// ==> ... = culture.GetLanguage();
}

publicclassMyProgram
{
MyClassmyClass=newMyClass;
Console.WriteLine(myClass.IntegerField);// Writes 3 to the command line.
myClass.IntegerField=7;// Indirectly assigns 7 to the field myClass.m_iField 
}

Indexers

publicstringthis[stringstrKey]
{
get{returncoll[strKey];}
set{coll[strKey]=value;}
}

EmployeeCollectione=newEmployeeCollection();
.
.
.
strings=e["Jones"];
e["Smith"]="xxx";

Events

usingSystem;
// Note: You need to know some about delegate, properties and methods to understand this sample
namespaceEventSample
{
/// <summary>
/// This delegate defines the signature of the appropriate method
/// </summary>
publicdelegatevoidContractHandler(Employeesender);
/// <summary>
/// Employee class
/// </summary>
publicclassEmployee
{
/// <summary>
/// Field for the info whether or not the Employee is engaged
/// </summary>
privateboolbIsEngaged=false;
/// <summary>
/// Age of the employee
/// </summary>
privateintiAge=-1;
/// <summary>
/// Name of the employee
/// </summary>
privateStringstrName=null;
/// <summary>
/// *** The our event *** 
/// Is a collection of methods that will be called when it fires
/// </summary>
publiceventContractHandlerEngaged;
/// <summary>
/// Standard constructor
/// </summary>
publicEmployee()
{
// Here, we are adding a new method with appropriate signature (defined by delegate)
// note: when an event has no method and it was fired, it causes an exception!
// for all effects when programming with events, assign one private method to event
// or simply do a verification before firing it! --> if (event != null)
this.Engaged+=newContractHandler(this.OnEngaged);
}
/// <summary>
/// Event handler for the "engaged" event
/// </summary>
/// <param name="sender">
/// Sender object
/// </param>
privatevoidOnEngaged(Employeesender)
{
Console.WriteLine("private void OnEngaged was called! this employee is engaged now!");
}
/// <summary>
/// Accessor for the employee name
/// </summary>
publicstringName
{
get
{
returnstrName;
}
set
{
strName=value;
}
}
/// <summary>
/// Accessor for the employee age
/// </summary>
publicintAge
{
get
{
returnm_iAge;
}
set
{
m_iAge=value;
}
}
/// <summary>
/// Accessor for the information about employee engagement
/// </summary>
publicboolIsEngaged
{
get
{
returnbIsEngaged;
}
set
{
if(bIsEngaged==false&&value==true)
{
// here we fires event (call all the methods that it have)
// all times when IsEngaged is false and set to true;
Engaged(this);
}
bIsEngaged=value;
}
}
}
/// <summary>
/// Class for the entry point
/// </summary>
publicclassEntryPointClass
{
staticvoidMain(string[]a_strArgs)
{
EmployeesimpleEmployee=newEmployee();
simpleEmployee.Age=18;
simpleEmployee.Name="Samanta Rock";

// Here...
// This is saying when the event fires, the method added to event are called too.
// note that we cannot use =
// is only += to add methods to event or -= do retire an event
simpleEmployee.Engaged+=newContractHandler(SimpleEmployee_Engaged);

// make attention here...
// when I assign true to this property, 
// the event Engaged will be called
// when event is called, all method that it have, are called!
simpleEmployee.IsEngaged=true;
Console.ReadLine();
return;
}
/// <summary>
/// Event handler for the registered "engaged" event
/// </summary>
/// <param name="sender">
/// Event sender
/// </param>
staticvoidSimpleEmployee_Engaged(Employeesender)
{
Console.WriteLine("The employee {0} is happy!",sender.Name);
}
}
}

Operator overloading

publicclassComplex
{
privatedoublem_dReal,m_dImaginary;

publicdoubleReal
{
get{returnm_dReal;}
set{m_dReal=value;}
}

publicdoubleImaginary
{
get{returnm_dImaginary;}
set{m_dImaginary=value;}
}

// binary operator overloading
publicstaticComplexoperator+(Complexc1,Complexc2)
{
returnnewComplex(){Real=c1.Real+c2.Real,Imaginary=c1.Imaginary+c2.Imaginary};
}

// unary operator overloading
publicstaticComplexoperator-(Complexc)
{
returnnewComplex(){Real=-c.Real,Imaginary=-c.Imaginary};
}

// cast operator overloading (both implicit and explicit)
publicstaticimplicitoperatordouble(Complexc)
{
// return the modulus - sqrt(x^2 + y^2)
returnMath.Sqrt(Math.Pow(c.Real,2)+Math.Pow(c.Imaginary,2));
}

publicstaticexplicitoperatorstring(Complexc)
{
// we should be overloading the ToString() method, but this is just a demonstration
returnc.Real.ToString()+" + "+c.Imaginary.ToString()+"i";
}
}
publicclassStaticDemo
{
publicstaticvoidMain()
{
Complexnumber1=newComplex(){Real=1,Imaginary=2};
Complexnumber2=newComplex(){Real=4,Imaginary=10};
Complexnumber3=number1+number2;// number3 now has Real = 5, Imaginary = 12

number3=-number3;// number3 now has Real = -5, Imaginary = -12
doubletestNumber=number3;// testNumber will be set to the absolute value of number3
Console.WriteLine((string)number3);// This will print "-5 + -12i".
// The cast to string was needed because that was an explicit cast operator.
}
}

Structures

structEmployee
{
publicintm_iAge;
privatestringm_strName;
publicstringName
{
get{returnm_strName;}
set{m_strName=value;}
}
}

structdata
{
intheader;
fixedintvalues[10];
}

Structure constructors

structTimestamp
{
privateushortm_usYear;
privateushortm_usMonth;
privateushortm_usDayOfMonth;
privateushortm_usHour;
privateushortm_usMinute;
privateushortm_usSecond;
publicTimestamp(ushortusYear,
ushortusMonth,
ushortusDay,
ushortusHour,
ushortusMinute,
ushortusSecond)
{
m_usYear=usYear-1900;
m_usMonth=usMonth;
m_usDay=usDay;
m_usHour=usHour;
m_usMinute=usMinute;
m_usSecond=usSecond;
}
}

Static classes

publicstaticclassWriter
{
publicstaticvoidWrite()
{
System.Console.WriteLine("Text");
}
}
publicclassSample
{
publicstaticvoidMain()
{
Writer.Write();
}
}

References