Types and Members in C# applications
Lesson1
Using Data Types
-
Store and represent data in app
-
Integer types - byte, short, int, long, sbyte, ulong, uint, ulong
-
Floating point - float, double, decimal (latter = for financial apps, can't hold as large a number as double but more accurate - 28 significant digits)
-
Boolean - true or false
-
Char - single Unicode character
-
String - reference to series of Chars
-
Object - super-type of all others. Can assign any object or variable to it. Requires explicit conversion to gain access to stored objects functionality
-
.NET languages strongly typed
- Objects one type can't be freely exchanged with another
- params in method calls must be of correct type
-
Implicit conversion when conversion can be performed without data loss | From | To | | ----- | --- | | byte | short, ushort, int, uint, ulong, float, double, decimal | | short | int, long, float, double, decimal | | int | long, float, double, decimal| | long | float, double, decimal | | float| double | | char | int, uint, long, ulong, float, double, decimal | | sbyte | short, int, long, ulong, float, double, decimal | | ushort | int, uint, long, ulong, float, double, decimal | | uint | long, ulong, float, double, decimal| | ulong | float, double, decimal |
-
Explicit conversion, or cast, where data loss possible. Only use where absolutely necessary. Provide system for handling failed casts
int anInteger = 10000;
short aShort;
aShort = (short) anInteger;
Data Type Functionality
-
All data types have built-in functionality. Minimum (from object type):
- Equals - are 2 instances equal
- GetHashCode - Generate hash code
- GetType - returns object type
- ToString - human readable form of object
-
Small data types support this functionality via boxing
- Implicit conversion of value types to reference types
- Each class derives from object and can be implicitly converted to it
- When call one of above methods the run-time creates temporary reference to object
- Can manually box value types
int I = 100;
object O;
O = I;
- Unboxing = explicit conversion of boxed variable back to value type
- Data types also have methods not derived from object - usually functionality specific to that type
- Parse - create value from string. Supported by all value types. Implemented as static (call from type, not instance)
string S = "1234";
int I = int.Parse(S);
- String manipulation keenly important
- string class exposes variety of methods, divided between instance and static methods
Name | Description |
---|---|
String.Insert | Insert specified string into instance |
String.PadLeft, String.PadRight | Add chars to left or right of instance |
String.Remove | Delete specified number chars from string |
String.Replace | Replace occurrences of char in string |
String.Split | Return substrings delimited by specific char |
String.Substring | Return substring from string |
String.ToCharAray | Returns arrays of chars making up string |
String.ToLower, String.ToUpper | Convert string to lower or upper case |
String.TrimEnd, String.TrimStart, String.Trim | Remove trailing or leading characters |
Name | Description |
---|---|
String.Compare | Compare two string objects |
String.Concat | Concatenate two+ strings |
String.Format | Format a string |
String.Join | Concatenate array of strings with specified separator strings |
Lesson 2
Constants
- Refer to frequently used values by friendly names
- Can not be changed or redefined once set
- Use const keyword
- Can be any intrinsic or enum type, not user-defined or array
public const double Pi = 3.14159265;
Enums
- Work with related sets of constants
- Associate memorable names with constants
public enum DaysOfWeek
{
Monday = 1,
Tuesday = 2,
Wednesday = 3,
Thursday = 4,
Friday = 5,
Saturday = 6,
Sunday = 7
}
- Default type = int - but can be any integral type (byte, short, int, long), specify in declaration line
public enum DaysOfWeek : byte
{
...
}
- Not necessary to specify values for members, by default number incrementally from 0
- Must explicitly convert enums to desired integral type
Public enum Numbers
{
zero,
one,
}
MessageBox.Show((int)Numbers.two * 2).ToString()); // Display 4
- Can create methods accepting enums as values - code less prone to errors from inaccurate typing
public void ScheduleDayOff( DaysOfWeek day )
{
switch( day )
{
...
}
}
Arrays
- Manage groups of similarly typed values or objects, referred to by index
- Array declaration
int[] myIntegers;
- Array initialisation
myIntegers = new int[32];
- In one line
int[] myIntegers = new int[32];
- Change size at runtime by redefining it - note contents will be lost
int[] myIntegers = new int[32];
myIntegers = new int[45];
- Array of reference types, declaring and initialising creates array of null references. Must assign object to each entry
- Rectangular arrays = each member of each dimension extended in each other dimension by same length, e.g. 2D array resembles a table
// Declare 5 by 3 array
int[,] intArray = new int[5,3];
// Decalre 2D array and set initial values
int[,] intArray2 = {{1,2,3},{4,5,6}};
// Declare cubic array
int[,,] cubeArray = {{7,2},{1,4},{3,5}};
- Jagged array = array of arrays, e.g. 2D array is table where each row has different number columns
string[][] Families = new string[3][];
Families[0] = new string[] {"Smith", "Mum", "Dad", "Uncle Phil"};
Families[1] = new string[] {"Jones", "Mum", "Dad", "Suzie", "Bobby"};
Families[2] = new string[] {"Williams", "Earl", "Bob"};
Collections
- Organises and exposes group of objects
- Access by index
- Dynamic resizing
- Addition / removal of members at run time
Class | Description |
---|---|
ArrayList | Array of objects |
BitArray | Compact arrays of bits (0 and 1) |
CollectionBase | Base for implementing own collection class |
Hashtable | Key-value pairs organised by hashed key |
Queue | FIFO group of objects |
SortedList | Access objects by index or key |
Stack | FILO group of objects z |
- Example using ArrayList:
// Create ArrayList
System.Collections.ArrayList myList = new System.Collections.ArrayList;
//Add item
Widget myWidget = new Widget;
myList.Add(myWidget);
// Access item using indexer (note ArrayList is zero-based)
object myObject;
myObject = myList[0];
// Indexer always returns objects. To obtain reference to same type as stored must cast
Widget aWidget;
aWidget = (Widget) myList[0];
// Remove uses reference to object
Widget anotherWidget = new Widget();
myList.Add(anotherWidget);
myList.Remove(anotherWidget);
// RemoveAt uses indexer
myList.RemoveAt(0);
// Count property is number of items in collection (as array zero based the value returned in one more than upper bound)
int arraySize = myList.Count;
- Enumerating collection
- Use foreach statement
- All collection members should be of same type
- If member can not be converted to foreach type get error
- To work with collections of disparate types use object
- foreach returns reference - i.e. can not modify collection entry. To do this use for...next
int[] myArray = new int[] {1,2,3,4,5};
for(int x=0; x <= myArray.GetUpperBound(0), x++)
{
myArray[x]++;
MessageBox(myArray[x].ToString());
}
Lesson 3
Implementing Properties
- Expose member values / objects in more robust way than fields
- Specialist method that looks like field, value set and got like fields
textBox1.Text = "Text property";
string myString;
myString = textBox1.Text;
- Properties have 2 special methods, get and set
private string theText;
public string myText
{
get
{
return theText;
}
set
{
theText = value;
}
}
- value = special keyword of set. Represents value to which property is set
- key advantage = provide additional code to perform calculations / validation
Read Only Properties
- Only provide get method
- Private variable holding value marked with readonly keyword
private readonly int theInt;
public int InstanceNumber
{
get
{
return theInt;
}
}
Write Only Properties
- Used infrequently, e.g. control localisation of form
- Only provide set method
- Private variable holding value declared as usual (i.e. no special keyword)
Indexer
- Specialist property allowing group of objects to be exposed on name of object
- Indexer identified by this
private int[] IntArray;
public int this [int index]
{
get
{
return IntArray[index];
}
set
{
Intarray[index] = value;
}
}
Collection Properties
- Expose undetermined number objects of same type
- Permits control of access to subordinate objects
- Return the collection, usually exposed as read-only to control update as collection will store objects of any type
private readonly System.Collections.ArrayList myWidgets = new System.Collections.ArrayList();
public System.Collections.ArrayList Widgets
{
get
{
return myWidgets;
}
}
- Wrap collection in property, providing conversion and validation code in accessor. Implement as indexer, or pair of methods (C# does not support parameterised properties)
private System.Collections.ArrayList myWidgets = new System.Collections.ArrayList ();
public Widget GetWidget(int I)
{
return (Widget)myWidgets[I];
}
public void SetWidget(int I, Widget Wid)
{
myWidgets[I] = Wid;
}
- Implement own strongly typed collection - derive from System.Collections.CollectionBase. Expose collection directly and ensure only objects of specified type are added
Lesson 4
Delegates and Events
- Event = message indicating interesting occurring in another part of app
- EventHandler responds to event
- EventHandler has same signature as event itself
- Event handled by 1+ EventHandlers
- EventHandler handles 1+ events
Delegates
- Type safe function pointer
- Permits passing of entry point for method or invoke method without making explicit method call
- Declare delegate specify signature of method it can call and return type. Following used to invoke methods that return int and take double as parameter:
public delegate int myDelegate(double D);
// Target method for delegate
public int ReturnInt(double D)
{
}
// Create instance of myDelegate
public void aMethod()
{
myDelegate aDelegate = new myDelegate(ReturnInt);
}
// Use delegate to invoke method
aDelegate(12345);
Declaring and Raising Events
- Directly tied to delegates
- Can use access modifiers (public, private, protected)
// Declare delegate and event
public delegate void calculateDelegate(double D);
public event calculationDelegate CalculationComplete;
// Raise event
CalculationComplete(66532);
Event Handlers
- Once event declared must be associated with event handler prior to being raised otherwise error occurs
- Both instance and static events can exist
- Can return value (like any other function)
- Use += to associate event with delegate instance
// Assume existence of method DisplayResults with signature appropriate for calculationDelegate.
// Create new delegate to create the association.
Account.CalculationComplete += new calculationDelegate(DisplayResults);
// Create association with existing delegate
CalculationDelegate calc = new calculationDelegate(DisplayResults);
Account.CalculationComplete += calc;
- Default delegates provided for .NET Framework base class library events
- To manually add event handler no need to declare new delegate. Create new instance of predefined default delegate
// System.EventHandler is delegate for most controls in System.windows.Formds namespace. Designate event handler for Click event of control called button1
button1.Click += new System.EventHandler(clickHandler);
- Remove event handler with -= operator. May want to do this if want event handler to only be called once.
// Remove association between Account.CalculationComplete and DisplayResults method
Account.CalculatioComplete -= new CalculationDelegate(DisplayResults);
- Event handlers can be associated with multiple events, e.g. single method handles click event for number of buttons. Method distinguishes between source using sender parameter
Button1.Click += new System.EventHandler(ClickHandler);
Button2.Click += new System.EventHandler(ClickHandler);
- Events can be processed by multiple handlers. Order of handler invocation determined by order of association. Value returned by event is that of the last method executed.