3. Data Types

1
3. Data Types
2
Objectives

• .NET is designed around the CTS, or Common Type
  System. The CTS is what allows assemblies,
  written in different languages, to work together.
  To ensure interoperability across languages,
  Microsoft has also defined the CLS, or Common
  Language Specification, a subset of the CTS that
  all languages support. Otherwise, the types in
  C are what you would expect from a modern OOPL
• The Common Type System
• Value vs. reference types
• Arrays
• Namespaces

3
Part 1

• The Common Type System

4
The Common Type System (CTS)

• CTS is based on a hierarchy of classes defined in
  FCL
• all types inherit from Object (all except
  interface types)

5
The Common Language Specification (CLS)

• Not all languages support all CTS types and
  features
• C supports unsigned integer types, VB.NET does
  not
• C is case sensitive, VB.NET is not
• C supports pointer types (in unsafe mode),
  VB.NET does not
• C supports operator overloading, VB.NET does not
• CLS was drafted to promote language
  interoperability
• vast majority of classes within FCL are
  CLS-compliant

6
Mapping C to CTS

• Language keywords map to common CTS classes

Keyword Description Special format for literals
bool Boolean true false
char 16 bit Unicode character 'A' '\x0041' '\u0041'
sbyte 8 bit signed integer none
byte 8 bit unsigned integer none
short 16 bit signed integer none
ushort 16 bit unsigned integer none
int 32 bit signed integer none
uint 32 bit unsigned integer U suffix
long 64 bit signed integer L or l suffix
ulong 64 bit unsigned integer U/u and L/l suffix
float 32 bit floating point F or f suffix
double 64 bit floating point no suffix
decimal 128 bit high precision M or m suffix
string character sequence "hello", _at_"C\dir\file.txt"
7
Example

• An example of using types in C
• declare before you use (compiler enforced)
• initialize before you use (compiler enforced)

public class App public static void Main()
int width, height width 2
height 4 int area width height
int x int y x 2 ...
declarations
decl initializer
error, x not set
8
Type conversion

• Some automatic type conversions available
• from smaller to larger types
• Otherwise you need a cast or an explicit
  conversion
• typecast syntax is type name inside parentheses
• conversion based on System.Convert class

int i 5 double d 3.2 string s
"496" d i i (int) d i
System.Convert.ToInt32(s)
implicit conversion
typecast required
conversion required
9
Part 2

• Value vs. reference types

10
Value vs. reference types

• C separates data types into two categories
• Value types
• variable represents a value ("bits")
• Reference types
• variable represents a reference to a heap-based
  object
• actual data resides in the object

int i i 10
10
string s s "calico"
11
How do you know which types are which?

• Memorization!
• Though it's pretty obvious based on past
  experience
• primitive types like bool, int and double are
  values
• remainder are reference types

int i string s Customer c1, c2 i
23 s "a message" c1 null c2 new
Customer()
12
Boxing and Unboxing

• When necessary, C will auto-convert value ltgt
  object
• value gt object is called "boxing"
• object gt value is called "unboxing"

int i, j object obj string s i
32 obj i // boxed copy! i
19 j (int) obj // unboxed! s
j.ToString() // boxed! s 99.ToString() //
boxed!
13
User-defined reference types

• Classes!
• for example, Customer class we worked with
  earlier

public class Customer public string Name
// fields public int ID public
Customer(string name, int id) // constructor
this.Name name this.ID id
public override string ToString() // method
return "Customer " this.Name
14
Working with reference types

• Creating, assigning, and comparing

Customer c1, c2, c3 string s1, s2 c1 new
Customer("joe hummel", 36259) c2 new
Customer("marybeth lore", 55298) c3 null //
c3 references no object c3 c1 // c3 now
references same obj as c1 if (c1 null) ...
// do I ref an object? if (c1 c2) ...
// compares references if (c1.Equals(c2)) ...
// compares objects if (s1 s2) ... //
exception overloaded to
// compare string data
15
Defining equality

• Classes should override Equals

public class Customer . . . public
override bool Equals(object obj) Customer
other if ((obj null) (!(obj is
Customer))) return false // definitely
not equal other (Customer) obj //
typecast to access return this.ID
other.ID // equal if same id...
16
GetHashCode

• If you override Equals, must also override
  GetHashCode

public class Customer . . . public
override int GetHashCode() return
this.id.GetHashCode()
17
Part 3

• Arrays

18
Arrays

• Arrays are reference types
• based on Array class in FCL
• must be created using new
• 0-based indexing
• assigned default values (0 for numeric, null for
  references, etc.)

int a a new int5 a0 17 a1
32 int x a0 a1 a4 int l a.Length
create
element access
number of elements
19
Multi-dimensional arrays

• C supports arrays as a single object OR array of
  arrays
• latter allows you to implement jagged arrays

Customer, twoD int jagged2D // 2D
array as single object twoD new Customer10,
100 twoD0, 0 new Customer() twoD9, 99
new Customer() // 2D array as array of
arrays jagged2D new int10 jagged2D0
new int10 jagged2D1 new int20 jagged2D9
new int100 jagged2D00
1 jagged2D999 100
20
Part 4

• Namespaces

21
Namespaces

• Namespaces are a means for organizing types
• a namespace N is a set of names scoped by N
• namespaces are often nested

namespace Workshop public class Customer
. . . public class
Product . . .
//namespace
Workshop.Customer
22
Example

• Framework Class Library (FCL) contains 1000's of
  classes
• how to organize?
• how to avoid name collisions?
• with FCL
• within FCL

23
FCL namespaces

• FCL's outermost namespace is "System"
• FCL technologies nested within System

Namespace Purpose Assembly
System Core classes, types mscorlib.dll
System.Collections Data structures mscorlib.dll
System.Data Database access System.Data.dll
System.Windows.Forms GUI System.Windows.Forms.dll
System.XML XML processing System.Xml.dll
24
Namespace ! Assembly

• Orthogonal concepts
• namespace for organization
• assembly for packaging
• One namespace could be spread across multiple
  assemblies
• One assembly may contain multiple namesspaces
• e.g. mscorlib.dll

25
Summary

• CTS is the common type system
• same type system for all languages
• types implemented by classes in FCL
• fundamental difference between value reference
  types
• CLS is the common language specification
• types that are guaranteed to work across
  languages
• Try not to confuse namespaces with assemblies
• namespaces help with organization
• assemblies denote implementation / packaging

26
References

• Books
• I. Pohl, "C by Dissection"
• S. Lippman, "C Primer"
• J. Mayo, "C Unleashed"