CNS 3260 C# .NET Software Development C# Datatypes CNS 3260 C# .NET Software Development

Types Simple types Complex types int, uint, float, etc. keywords represent structs in IL Complex types Classes Structs Enums Delegates Everything inherits from System.Object

C# Value vs. Reference Value Types “directly contain” the variable data. Example: int, float, enum, struct... Reference Types contain a reference to the data Reference Type Value Type Memory ref0 ref1 Memory int x int y myObject

class ValueType ValueType is a class that inherits directly from object You cannot inherit from ValueType ValueType overrides System.Object methods so they make sense

value-types value-types inherit directly from ValueType simple types enum types struct types All value-types are sealed value-types cannot be null Assignment of a value-type results in a copy of the variable

value-type Hierarchy value-type struct-type enum-type simple-type type-name type-name numeric-type bool integral-type floating-point-type decimal

Simple Types integral-types Signed Unsigned Unicode Type System Type Description Example sbyte System.SByte 8-bit signed integral type sbyte val = 12; short System.Int16 16-bit signed integral type short val = 12; int System.Int32 32-bit signed integral type int val = 12; long System.Int64 64-bit signed integral type long val1 = 12; long val2 = 34L; byte System.Byte 8-bit unsigned integral type byte val1 = 12; ushort System.UInt16 16-bit unsigned integral type ushort val1 = 12; uint System.UInt32 32-bit unsigned integral type uint val1 = 12; uint val2 = 34U; ulong System.UInt64 64-bit unsigned integral type ulong val1 = 12; ulong val2 = 34U; ulong val3 = 56L; ulong val4 = 78UL; char System.Char 16 bit unicode character char c = ‘a’; char c = 255; Signed Unsigned Unicode

Simple Types (Continued) floating-point-types Type System Type Description Example float System.Single Single-precision floating point type float val = 1.23F; double System.Double Double-precision floating point type double val1 = 1.23; double val2 = 4.56D; Decimal Type System Type Description Example decimal System.Decimal Precise decimal type with 28 significant digits decimal val = 1.23M; Boolean Type System Type Description Example bool System.Boolean Boolean type; a bool value is either true or false bool val1 = true; bool val2 = false;

numeric-type Methods static MinValue static MaxValue static Parse static Parse(string) static Parse(string, NumberStyles) ToString ToString() ToString(string format) int index = 256; index.ToString(“X”);

System.Char (remember it’s 16-bit) Has ingetral-type methods, plus... static IsDigit() static IsLetter() static IsDigitOrLetter() static IsLower() static IsNumber() static IsPunctuation() static IsUpper() static ToUpper() static ToLower() and more...

floating-point-types Have numeric-type methods, plus... static Epsilon static NaN static NegativeInfinity static PositiveInfinity static IsInfinity() static IsNaN() static TryParse() and more...

System.Decimal (decimal) Have numeric-type methods, plus... static Floor static GetBits() static ToDouble() static ToSingle() static ToInt64() static Round() static Truncate() and more...

System.Boolean (bool) Have numeric-type methods, plus... static FalseString static TrueString and (not much) more...

structs and enums An enumeration type is a distinct type with named constants. Every enumeration type has an underlying type, which must be byte, sbyte, short, ushort, int, uint, long or ulong. A struct type is a value type that can declare constants, fields, methods, properties, indexers, operators, instance constructors, static constructors, and nested types. We’ll cover structs and enums later

Reference Types Classes Interfaces Arrays Delegates object (System.Object) string user-defined classes Interfaces Arrays Delegates delegate (System.Delegate)

reference-type Hierarchy class-type interface-type array-type delegate-type type-name object string

String Type String Type (Immutable reference type) Type System Type Description Example string System.String Immutable string of 16-bit Unicode characters. string s1 = “Hello”; string s2 = string.Empty;

System.String (string) static Empty StartsWith(string) EndsWith(string) IndexOf(string) static Join(string, string[]) Split(char[], int) Remove(int, int) Replace(string, string) Insert(int, string) and much more...

Object Four virtual methods: Two static methods: One protected method: Equals(object obj) GetHashCode() GetType() ToString() Two static methods: static Equals(object objA, object objB) static ReferenceEquals(object objA, objB) One protected method: Finalize()

Object Virtual Methods Equals(object obj) Reference types: the default supports reference-equals Value types: the default supports bitwise equality. Can be overridden GetHashCode() Returns a Hash value GetType() Returns the exact runtime type of the calling instance ToString() Returns a string that represents the calling instance

Object Static Methods Equals(object objA, object objB) This method first determines whether both parameters are null references before calling objA.Equals(objB) ReferenceEquals(object objA, object objB) Returns true if objA is the same instance as objB or if both are null references; otherwise, false

Try this: Q: What’s the difference between Equals and ReferenceEquals? class Class1 { [STAThread] static void Main(string[] args) Console.WriteLine(object.Equals(null, null)); Console.WriteLine(object.ReferenceEquals(null, null)); Console.ReadLine(); } Q: What’s the difference between Equals and ReferenceEquals? A: Equals calls objA.Equals(objB). So if objA redefined .Equals(), that overridden method will be invoked. ReferenceEquals will always tell if the references are the same.

Everything derives from object 3.ToString(); “hello”.GetHashCode(); 5.Equals(5); myObject.Equals(yourObject);

Boxing Value Types which are up-cast to a reference type are boxed This is necessary because Collections hold objects Boxing places a copy of the variable in the object Extra information (such as type info) may be stored with the variable, the standard is not explicit

Boxing example class Test { static void Main() int i = 123; object o = i; // boxing int j = (int) o; // unboxing }

Type Conversions Implicit Conversions Implicit conversions will occur when there is no loss of information. Example: using System; class Test { static void Main() int intValue = 123; long longValue = intValue; Console.WriteLine("{0}, {1}", intValue, longValue); }

Conversions Explicit Conversions Explicit conversions are required when there could be loss of information. Example: using System; class Test { static void Main() long longValue = System.Int64.MaxValue; int intValue = (int)longValue; Console.WriteLine(“(int){0} = {1}", longValue, intValue); }

Conversions Explicit or Implicit? float to Int32? Explicit Int32 to float? Implicit decimal to float? Explicit long to decimal? Implicit Int32 to UInt32? Explicit UInt32 to Int32? Explicit (See Conversions Demo)

Local variables must be assigned before they are used no static locals no const locals Example: void fun() { int a, b = 3; int c = a + b; }

Fields static instance public class Rectangle { public int Top = 0; public int Left = 0; public int Height = 100; public int Width = 100; private static int RectangleCount; public Polygon() { ++ RectangleCount; } public ~Polygon() { -- RectangleCount; } }

Local vs. Field class SomeClass { private int index; public SomeClass(int index) { index = index; // WRONG!!! this.index = index; }

Pointers? only in unsafe blocks (we’ll explore these later.)

Passing Parameters: Value class MainClass { static void Main() int i = 0; new MainClass().fun(i); Console.WriteLine(i.ToString()); Console.ReadLine(); } private void fun(int x) x = 5; What does it mean to pass a reference by value? (See PassReference Demo)

Passing references Passing object to a method only passes reference Fast Easy Somewhat misunderstood No implicit deep copy if needed

Passing Parameters: ref class MainClass { static void Main() int i = 0; new MainClass().fun(ref i); Console.WriteLine(i.ToString()); Console.ReadLine(); } private void fun(ref int x) int y = x; // ok x = 5; int z = x; // ok If a reference type is being passed, then it is a reference to the reference.

Passing Parameters: out Similar to passing by ref, but the value is initially unassigned. Also, you must assign to the parameter somewhere in the method. class MainClass { static void Main() int i = 0; new MainClass().fun(out i); Console.WriteLine(i.ToString()); Console.ReadLine(); } private void fun(out int x) // int y = x; // not ok x = 5; int z = x; // ok

Variable Length Arguments Uses params keyword. class Test { static void F(params int[] args) Console.WriteLine("# of arguments: {0}", args.Length); for (int i = 0; i < args.Length; i++) Console.WriteLine("\targs[{0}] = {1}", i, args[i]); } static void Main() F(); F(1); F(1, 2); F(1, 2, 3); F(new int[] {1, 2, 3, 4});

Intro to delegates Think of a delegate as a function pointer that stores a reference to its instance. C++ function pointer: int* (*funPtr)(char arg1, float arg2); C# delegate: public delegate void funDelegate(char arg1, float arg2);

Delegate Syntax Delegate declaration declares a new type. public delegate string FunDelegate(int a, float b); public class MainClass { [STAThread] static void Main() FunDelegate fd = new FunDelegate(fun); fd(5, 3.14159); } private string fun(int x, float f) return (x+f).ToString();

Delegates Why use delegates (or function pointers?) Keeps coupling low Makes code more extensible Asynchronous processing (See SimpleDelegateDemo)