3. Data Types
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
Microsoft
2
Part 1
• The Common Type System…
Microsoft
3
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)
System-defined types
Object
User-defined types
String
Array
Primitive types
Microsoft
Boolean
Single
Byte
Double
Int16
Decimal
Int32
DateTime
Int64
TimeSpan
Char
Guid
ValueType
Exception
Delegate
Class1
Enum
Structure1
Multicast
Delegate
Class2
Delegate1
Class3
Enum1
4
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
Microsoft
5
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
character sequence
"hello", @"C:\dir\file.txt"
string
Microsoft
6
Example
• An example of using types in C#
– declare before you use (compiler enforced)
– initialize before you use (compiler enforced)
declarations
public class App
{
public static void Main()
{
int width, height;
width = 2;
height = 4;
decl + initializer
int area = width * height;
error, x not set
int x;
int y = x * 2;
...
}
Microsoft
}
7
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
double
string
implicit conversion
typecast required
conversion required
Microsoft
i = 5;
d = 3.2;
s = "496";
d = i;
i = (int) d;
i = System.Convert.ToInt32(s);
8
Part 2
• Value vs. reference types…
Microsoft
9
Value vs. reference types
• C# separates data types into two categories
• Value types:
– variable represents a value ("bits")
int i;
i = 10;
10
• Reference types:
– variable represents a reference to a heap-based object
– actual data resides in the object
"calico"
string s;
s = "calico";
Microsoft
10
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
string
Customer
i;
s;
c1, c2;
i = 23;
s = "a message";
c1 = null;
c2 = new Customer(…);
Microsoft
11
Boxing and Unboxing
• When necessary, C# will auto-convert value <==> object
– value ==> object is called "boxing"
– object ==> value is called "unboxing"
int
object
string
i
obj
i
j
=
=
=
=
i, j;
obj;
s;
32;
i;
19;
(int) obj;
s = j.ToString();
s = 99.ToString();
Microsoft
// boxed copy!
// unboxed!
// boxed!
// boxed!
12
User-defined reference types
• Classes!
– for example, Customer class we worked with earlier…
public class Customer
{
public string Name;
public int
ID;
// fields
public Customer(string name, int id)
{
this.Name = name;
this.ID
= id;
}
// constructor
public override string ToString()
{ return "Customer: " + this.Name; }
// method
}
Microsoft
13
Working with reference types…
• Creating, assigning, and comparing:
Customer
string
c1, c2, c3;
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) ...
if (c1 == c2) ...
if (c1.Equals(c2)) ...
if (s1 == s2) ...
Microsoft
// do I ref an object?
// compares references
// compares objects
// exception: == overloaded to
//
compare string data
14
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;
return this.ID == other.ID;
// typecast to access
// equal if same id...
}
Microsoft
15
GetHashCode
• If you override Equals, must also override GetHashCode:
public class Customer
{
.
.
.
public override int GetHashCode()
{
return this.id.GetHashCode();
}
Microsoft
16
Part 3
• Arrays…
Microsoft
17
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.)
create
element access
number of elements
Microsoft
int[] a;
a = new int[5];
a[0] = 17;
a[1] = 32;
int x = a[0] + a[1] + a[4];
int l = a.Length;
18
Multi-dimensional arrays
• C# supports arrays as a single object OR array of arrays
– latter allows you to implement jagged arrays
Customer[,]
int[][]
twoD;
jagged2D;
// 2D array as single object
twoD = new Customer[10, 100];
twoD[0, 0] = new Customer(…);
twoD[9, 99] = new Customer(…);
// 2D array as array of arrays
jagged2D = new int[10][];
jagged2D[0] = new int[10];
jagged2D[1] = new int[20];
jagged2D[9] = new int[100];
jagged2D[0][0] = 1;
jagged2D[9][99] = 100;
Microsoft
19
Part 4
• Namespaces…
Microsoft
20
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
{
.
.
.
}
Workshop.Customer
public class Product
{
.
.
.
}
}//namespace
Microsoft
21
Example
• Framework Class Library (FCL)
contains 1000's of classes
– how to organize?
– how to avoid name collisions?
• with FCL
• within FCL
Microsoft
22
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
Microsoft
23
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
Microsoft
24
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
Microsoft
25
References
• Books:
– I. Pohl, "C# by Dissection"
– S. Lippman, "C# Primer"
– J. Mayo, "C# Unleashed"
Microsoft
26