Chapter 2 Types

1
Chapter 2Types Exceptions

• Yingcai Xiao

2

• Part I
• Moving from Java to C

3
Data Structures Algorithms

• What you should do to design a language? How can
  you design a language?
• Computer a device for data processing
• storing and processing data
• Programming Data Structures Algorithms
• Computer Languages tools for users to define
  data structures to store the data and to develop
  algorithms to process the data.
• Data Types System-defined Types User-defined
  Types

4
Common Type System (CTS)

• .NET Frameworks Data Types CTS
• Six categories of data types in CTS
• system-defined
• Primitives (int, float, )
• user-defined
• Classes
• Structs
• Interfaces
• Enumerations
• Delegates

5
Common Type System (CTS)

• Named Space
• grouped code, used to resolve naming conflicts.
• namespace mine
• int i10
• namespace his
• int i20
• mine.i his.i

6
Named Space Example
namespace WP1.CS.UA class Hello
public Hello() System.Console.WriteL
ine("Hello, world.") namespace
WP2.CS class Hello public
Hello() System.Console.WriteLine("Hello
, again!")
7
Named Space Example

• namespace WP
• class Test
• public static void Main()
• WP1.CS.UA.Hello mc new
  WP1.CS.UA.Hello()
• WP2.CS.Hello mc2 new
  WP2.CS.Hello()

8

• Classes

• Class a group of code and data to be
  instantiated to form objects.
• Four categories of class members
• Fields member variables
• Methods member functions
• Properties fields exposed using accessor (get
  and set) methods
• Events notifications a class is capable of firing

9
Example How to define a class (user-defined data
type)

• class Rectangle
• // Fields
• protected int width 1
• protected int height 1
• // Methods
• public Rectangle ()
• public Rectangle (int cx, int cy)
• width cx
• height cy

10
Example How to define a class (user-defined data
type)

• // Accessor Methods
• public void setWidth(int w) width w
• public int getWidth() return width
• public void setHeight(int h) height h
• public int getHeight() return height
• // End of Rectangle class

11
Example How to use a class (user-defined data
type)
Rectangle rect new Rectangle(2,4) rect.setHei
ght(8) rect.setWidth(rect.getWidth() 2)
double darea (double) (rect.getWidth()
rect.getHeight() ) We protected member fields
width and height. (Encapsulation) (1) Securer
code. Methods not belonging to the class
hierarchy cant access protected members. If we
dont want anyone change the value of width, we
just dont provide the setWidth() method. (2)
Easier to maintain the code. We can rename
width to w without impacting the users of the
Rectangle class. (3) Tedious to implement and
use. If we define the member fields as public,
the usage would be much easier. rect.width 2
12
Property
Can we make the member fields secure and easy
to use at the same time?
13
Example How to define properties
// Properties defined as grouped accessor
methods // in the Rectangle class
public int Width // group name get
return width set // the input
parameter is implicit value
if (value gt 0) width
value else throw new
ArgumentOutOfRangeException (
"Width must be 1 or higher")
14
Example How to define properties

• public int Height // a field defined by type and
  accessor code
• get return height
• set
• if (value gt 0)
• height value
• else
• throw new ArgumentOutOfRangeExcept
  ion (
• "Height must be 1 or
  higher")

15
Example How to define properties
public int Area // a property of only get method
get return width height
16
Defining Properties

• Properties are defined in the following format
• protected type field-name
• public type property-name
• get / return the field value /
• set / reset the field value /

• A property definition is composed of
• a protected or private field
• a property to expose the field
• which in turn consists of at least one accessor
  (get()/set()).

17
Using Properties

• Properties are used the same way as public
  fields.
• Rectangle rect new Rectangle(2,4)
• rect.Width 7
• rect.Width 2 // Double the rectangle's
  width
• int area rect.Area // Get the rectangle's
  new area
• //Typecast a property value from int to
  double
• double darea (double) rect.Area
• Advantage of Properties allow users to access
  private/protected fields as if they were public
  fields.

18
Notes on Properties

• Properties are public methods (set and get) used
  like fields. Data is secured (encapsulated) and
  access is simplified.
• (2) The set and get methods are called accessors.
  A property may not have the set (read-only
  properties) or the get (write-only properties),
  but can not miss both.
• (3) The implicit input argument, value, for the
  set method has the same type as the property.
• (4) The type of a property must be the same as
  the type of the field member it protects.
• (5) A property cant be overloaded, e.g., we
  cant define a public double Area after
  defining public int Area . You have to use
  a different property name, e.g. doubleArea, to
  define the area property of type double.

19

• Why we have to name properties of different types
  differently?

• Signature of a method name, number of
  arguments, types of the arguments. Return type
  is not part of the signature.

• Overloading two or more methods have the same
  name but different arguments.

• Name Mangling encodes the name of an overloaded
  method with its signature (by the compiler). The
  internal names of the methods are unique (no
  internal overloading).

• Property do not have any arguments, so the only
  way to differentiate properties of different type
  is by their names.

20

• DLL

• What is it?
• How to create one?
• How to use one?
• Whats inside?

21

• DLL

• Dynamic Linking Write a Library for Others to
  Use/Link
• DLL (Dynamically Linked Libraries)
• gt Shared by multiple applications Dynamically
  loaded as needed
• gt Save disk and memory space
• Understanding by Examples (C2\Weak).
• Creating a DLL in .NET as a Multi-file Assembly
  (Math.dll)
• The example assembly
• two classes (SimpleMath in Visual Basic
  ComplexMath in C)
• three files (Simple.netmodule
  Complex.netmodule Math.dll (assembly manifest))

22

• Steps for DLL

(1) Create source Complex.cs. and compile it
csc /targetmodule Complex.cs gt
Complex.netmodule (2) Create source Simple.vb
and compile it vbc /targetmodule Simple.vb gt
Simple.netmodule (3) Create the assembly
(Math.DLL) using AL (Assembly Linker) al
/targetlibrary /outMath.dll Simple.netmodule
Complex.netmodule
23

• Linking Assembly

• Dynamically Linking of an Assembly to an
  Application
• Create the source to use the dll MathDemo.cs
• Compile it to create the exe
• csc /targetexe /referencemath.dll MathDemo.cs
• (csc /texe /rmath.dll MathDemo.cs)
• Installation and Uninstallation of the
  Application
• (1) To install copy all needed files to the
  installation directory.
• MathDemo.exe, math.dll, Simple.netmodule,
  Complex.netmodule
• (2) To uninstall remove the installed directory.

24

• An Example Assembly Math.dll

Math.dll
Simple.netmodule
Complex.netmodule
25

• Interfaces

• Interfaces
• An interface is a group of zero or more abstract
  methods
• Abstract methods have no default implementation.
• Abstract methods are to be implemented in a
  child class or child struct.
• Subclassing an interface by a class or struct is
  called implementation of the interface.
• An interface can be implemented but not
  instantiated.
• You cant use an interface class to create an
  object.
• Interfaces can also include properties and
  events, but no data.
• An interface defines a contract between a type
  and users of that type. Used to define software
  interface standards.
• All interface methods are public, no
  specifiers needed.
• A class can implement multiple interfaces.

26

• Interface Example

interface ISecret void Encrypt (byte inbuf,
byte outbuf, Key key) void Unencrypt (byte
inbuf, byte outbuf, Key key) //no
implementation, just prototyping. class Message
ISecret public void Encrypt (byte inbuf,
byte outbuf, Key key) / implementation
here / public void Unencrypt(byte inbuf,
byte outbuf, Key key) / implementation
here / Message msg new Message() //
e.g. check if object msg implements interface
ISecret if (msg is ISecret) // type checking,
// an object of a child type is also an object
of the parent type, but not the other way around
ISecret secret (ISecret) msg // from child
to parent, explicit cast secret.Encrypt
(...)
27

• Abstract Class

• An abstract class is a class that cant be
  instantiated, i.e., one cant use an abstract
  class to create an object.
• The definition of an abstract class looks like a
  regular class except the preceding keyword
  abstract.
• It can have member fields and methods.
• It can only be used as a base class for
  subclassing.
• Its subclasses can inherit its methods as
  default implementation. (They can overwrite those
  methods too.)
• It is not allowed to inherit from multiple
  abstract classes.

28

• Abstract Class vs. Interface Classes

• Both cant be instantiated.
• Both defines standards for their subclass to
  implement.
• An abstract class defines the minimal
  implementation of its subclasses.
• An interface has no implementation at all.
• A child class cant subclass from more than one
  abstract classes. No multiple inheritance for
  abstract classes.
• A child class can implement more than one
  interfaces. Multiple inheritance allowed for
  interfaces.
• Abstract classes and interfaces can be used
  together.

29

• Abstract Class Interface Examples

abstract class DefaultTokenImpl private
readonly string name public string ToString()
return name protected DefaultTokenImpl(stri
ng name) this.name name interface
IToken string ToString() interface
IVisitable void Accept(ITokenVisitor visitor)
interface IVisitableToken IVisitable, IToken
class KeywordToken DefaultTokenImpl,
IVisitableToken public KeywordToken(string
name) base(name) void IVisitable.Accept(IT
okenVisitor visitor) visitor.VisitKeyword(ToS
tring())
30

• Abstract Class Interface Examples

• KeywordToken subclasses the abstract class
  DefaultTokenImpl
• It also implements the interface IVisitableToken
  (which implements interfaces IVisitable and
  IToken)
• It implements the Accept abstract method
  specified in interface IVisitable (a parent of
  IVisitableToken)
• It inherits the default implementation of
  ToString from the abstract class DefaultTokenImpl
  to implement the ToString abstract method
  specified in interface IToken (the other parent
  of IVisitableToken).

31

• Exception

32

• Exception Handling

Exception Handling (object-oriented event-driven
runtime error handling) An exception is thrown
when a run-time error occurs. The CLR defines
how exceptions are thrown and how theyre
handled. (How exception events are generated
and how theyre handled by exception event
handlers). You can throw an exception in any
language and catch it in any other. You can
throw exceptions across machines
33

• Exception Handling

• CLRs Exception Handling Mechanism try, catch,
  finally, and throw
• File file null // Do not define it in the try
  block. Why?
• try
• file new File ("Readme.txt")
• if(file ! null) / Do the work here. /
• catch (FileNotFoundException e)
  Console.WriteLine (e.Message)
• catch ( )
• catch ( )
• finally // Always come here even if there were
  exceptions.
• if (file ! null)
• file.Close ()

34

• Exception Handling

The CLR calls the handler that most closely
matches the type of exception thrown. All of
the exception types defined in the FCL are
derived directly or indirectly from
System.Exception. FCL exception classes contain
a Message property, which holds an error message
describing what went wrong, and a StackTrace
property, which details the call chain leading
up to the exception. Exception handlers can be
nested. Code in a finally block is guaranteed
to execute, whether an exception is thrown or
not. An exception that is best handled by the
caller rather than the callee. Programmers can
throw exceptions defined in FCL or their own
exceptions derived from System.ApplicationExcepti
on. if (value gt 0) width value
else throw new ArgumentOutOfRangeExcept
ion ( "Width cant be negative.")
35

• The Object Class System.Object

• System.Object root class for all other classes.
  
• Every class inherits the Finalize( ) method from
  System.Object.
• It is called just before an object is destroyed
  by the garbage collector of CLR.
• The time of call is determined by CLR not by the
  program.
• Use System.GC.Collect() to force a garbage
  collection (system wide, time consuming).
• Destructor in C is called just before an
  object is destroyed by the program, when the
  object is freed (for heap objects) or out of
  scope (for stack objects).

36

• C
• Part II
• Beyond Java

37

• Internal Memory Structures of Data Store

38

• Instantiating a Class (in C)

Class Name
In C Rectangle rect declares an object of
class Rectangle.
rect
rect is the name of a memory space that stores
a Rectangle object.
39

• Instantiating a Class (in CTS)

Class Name
In CTS Rectangle rect declares a reference of
class Rectangle.
rect
rect is the name of a memory space that stores
a reference. This is similar to Java.
A reference is an internal pointer, it needs to
point to an object before being dereferenced.
40

• References

Rectangle rect  int area rect.Area // will
not compile in C Rectangle rect  new Rectangle 
(3, 4) // Use the second constructor
rect
0x12345678

• Dereferencing is automatic for a reference. (No
  rect or rect-gt)
• int area rect.Area

• Please note the notation difference between a
  pointer/reference and a name in this lecture.

41

• Value Types

int i In CTS is i a reference to an integer or
just an integer? In CTS i is an int (a system
defined primitive type), not a reference to an
integer. i is the name of a memory space that
stores an integer value. int i 8 i is a
value type, for which we can directly store an
integer value into the memory named as i.
Compiler already allocated memory to store the
value and we dont need to new to allocate
memory to store the value.
i
42

• Value Types

• Fields of value types have the object (not
  reference) memories allocated by the compiler and
  can be used as an object directly without new.
• Can we define user types behave like value types?
• Class is used to define user types, but need to
  be newed before using. Memories are allocated
  at runtime. gt Tedious and Slow.

43

• Structs

• Structs user-defined value types, less overhead
  and easier to use than classes.
• struct Point
• public int x
• public int y
• public Point () x 0 y 0
• public Point (int x, int y)
• this.x x
• this.y y
• Point pnt1 // pnt1 is an object, not a
  reference. x 0, y 0
• Point pnt2 new Point () // pnt2 is an
  object, not a reference. x 0, y 0
• Point pnt3 new Point (3, 4) // pnt3 is an
  object, not a reference. x 3, y 4
• // The compiler uses new to initialize an
  object.
• Point pnt4(3,4) is not allowed in CTS.

44

• Summary Value and Reference Types in CTS

• In CTS, Value Types are Stack Objects
• memory allocated at compile time on the stack
• auto destruction, no garbage collection needed
• less overhead, code runs faster
• less flexible, sizes need to be known at compile
  time
• In CTS, Reference Types are Heap Objects
• memory allocated at run time on the heap
• garbage collected
• more flexible, sizes need not to be known at
  compile time
• more overhead, code runs slower
• Class defines reference types (heap objects)
• Struct defines value types (stack objects), even
  though new is used to create struct objects.
  Value types cant derive from other types except
  interfaces.

45

• Class Code

class Point public int x public int
y Point p1 new Point () p1.x 1 p1.y
2 Point p2 p1 // Copies the underlying
pointer p2.x 3 p2.y 4 Console.WriteLine
("p1 (0, 1)", p1.x, p1.y) // Writes "(3,
4)" Console.WriteLine ("p2 (0, 1)", p2.x,
p2.y) // Writes "(3, 4)" Point p3//Creats a
reference(pointer), no memory allocated p3.x
5 // Will not compile p3.y 6 // Will not
compile
46

• Struct Code

struct Point public int x public int
y Point p1 new Point() //Creates a value
object on stack. p1.x 1 p1.y 2 Point p2
p1//Makes a new copy of the object on the
stack p2.x 3 p2.y 4 Console.WriteLine ("p1
(0, 1)", p1.x, p1.y) // Writes "(1,
2)" Console.WriteLine ("p2 (0, 1)", p2.x,
p2.y) // Writes "(3, 4)" Point p3 //Creates a
value object on the stack p3.x 5 // It
works. p3.y 6 Console.WriteLine ("p3 (0,
1)", p3.x, p3.y) // Writes "(5, 6)"
47
Arrays in C
int a2 a0 5 a1 10 // stack
objects , size has to be known at compile time
and cant be changed at runtime. int size
2 int p // a pointer p new intsize
p0 5 p1 10 // heap objects
dynamically allocated at runtime, size can be a
variable delete p // free the memory.
a
p
48

• Arrays in CTS

• Array (same syntax for both class and struct)
• Point pa new Point2
• pa0 new Point()
• pa1 new Point()
• Console.WriteLine ("pa0 (0, 1)",
  pa0.x, pa0.y)
• Console.WriteLine ("pa1 (0, 1)",
  pa1.x, pa1.y)
• Challenges
• (1) Draw pictures to show the memory layout of pa
  for Point as a class and a struct.
• (2) What will happen when lines 2 and 3 are
  removed. Explain what will happen for Point as a
  class and then as a struct.

49

• Boxing and Unboxing

• Boxing creates a copy of a value type on the
  managed heap (converts from value type to
  reference type)
• Unboxing duplicates a reference type on the
  stack
• (converts from reference type to value type)
• int val  1      // Declare an instance of a valu
  e type object 
• Object obj  val  // Box it, inexplicit cast,
• an object containing value 1 is created on the
  heap and pointed to by reference obj.
• int val3  (int) obj // This will work, explicit
  cast.
• int val2  obj        // This won't compile. Why
  ?

50

• Boxing Unboxing

Typecast converting data/objects from one type
to another type. Widening copying from a memory
space of smaller value range to a memory space
of larger value range. Narrowing copying from a
memory space of larger value range to a memory
space of smaller value range. Boxing is
widening and can be implicitly casted. Unboxing
is narrowing and has to be explicitly casted.
51

• Enumerations

Enumerations a set of named constants
similar to enum in C (not defined in Java
until JDK 1.5) implicitly derives from
System.Enum enum Color Red, Green,
Blue Color.Red // Red Color.Green //
Green Color.Blue // Blue Color
mycolor mycolor Color.Green Console.WriteLine(
mycolor) // Green
52

• Enumerations

• Inside Enumerations
• Defining a set of named constants.
• By default, it starts with 0 can be changed to
  any number.
• enum Color
• Red 10, Green, Blue
• By default, it increments by 1 for each
  subsequent name.
• You can sign a value to each name.
• enum Color
• Red 10, Green 20, Blue 21
• You can increment a enum variable.
• Color mycolor mycolor Color.Green mycolor
  1
• Console.WriteLine(mycolor) // Blue

53

• Events

• A menu in C
• char c
• bool done false
• while(!done)
• cout ltlt Please make your selection, q to end
• cin gtgt c
• switch(c)
• case
• add( )
• break
• case -
• sub( )
• break
• case q
• done true
• break

Event Loop
Event
Event Mapping
Event Handler
54

• Events Delegates

• .NET supports the development of GUI (Graphical
  User Interface) based EDPs (event-driven
  programs).
• Event loop and event mapping for such
  applications can be very complicate.
• .NET internally implemented the event loop and
  event mapping mechanism for such applications.
• The development of GUI-based applications in .NET
  needs only to design the GUI and write event
  handlers.

55

• Events Delegates

• How can we register event handlers written by
  us to the event loop written by Microsoft?
• The system event loop was implemented before
  the application event handlers and the names of
  the handlers are not pre-specified.
• Event handlers are also called callback
  methods. Events are also called messages.
• .NET implement this by using event delegate
  constructs.

56

• Events Delegates

• A delegate is a type-safe wrapper around a
  callback method.
• Callback methods are used to respond to events.
• Three steps to understand events delegates
  using an example
• Define a callback method to use a predefined
  Timer class
• Exam the Timer class which uses event delegate
• Analyze the internal code of delegate

57

• Usage of a Predefined Timer Class

// Call this callback method every 6
seconds. void UpdateData (Object sender,
ElapsedEventArgs e) // Update Data every 6
seconds. // A Timer class has been implemented
for us to use. // It has an event Elapsed. Timer
timer new Timer (6000) timer.Elapsed new
ElapsedEventHandler (UpdateData) We registered
a function pointer, UpdateData, as a callback,
created a new instance of ElapsedEventHandler (a
delegate) that wraps around (delegates to)
UpdateData (a callback method) to respond to the
Elapsed event.
58

• Defining Events Delegates

Inside the Timer class public delegate void
ElapsedEventHandler (Object sender,
ElapsedEventArgs e) // specifies arguments for
the callback public class Timer public event
ElapsedEventHandler Elapsed // Calling the
callback methods when the event occurs if
(Elapsed ! null) // Make sure somebody's
listening, use Elapsed as a reference. Elapsed
(this, new ElapsedEventArgs (...)) // Fire! Use
Elapsed as a method, its arguments are sent to
the callback methods.
59

• Events Delegates cont.

A delegate is defined by placing the key word,
delegate, in front of a global method. The
arguments of the method in the declaration are
those of the callback functions. The real
argument of a delegate is always a pointer (to
the callback function). In the declaration of
an event object, the type specifier between the
event key word and the object name specifies
the delegate to be used by the event to invoke
event handlers. An event object can be used as
a reference and a method. When an event object
is used as a method, its arguments are sent to
the callback methods, which are specified by the
related delegate.
60

• Whats Inside Events Delegates?

public delegate void ElapsedEventHandler (Object
sender, ElapsedEventArgs e) Compiles to public
class ElapsedEventHandler MulticastDelegate
// System.MulticastDelegate public
ElapsedEventHandler (object target, int method)
... public virtual void Invoke(object
sender,ElapsedEventArgs e) ... ... Use
an events instance name as a method, actually
call the Invoke method. It is a better way (a
type safe way) to implement function pointers.
(http//www.cs.uakron.edu/xiao/ics/fun-ptrs.html)
.
61

• C and CLR Generics

• Generics parameterized types
• According to Microsoft
• (http//msdn2.microsoft.com/en-us/library/512aeb7t
  (VS.80).aspx)
• Use generic types to maximize code reuse, type
  safety, and performance.
• The most common use of generics is to create
  collection classes.
• The .NET Framework class library contains
  several new generic collection classes in the
  System.Collections.Generic namespace. These
  should be used whenever possible in place of
  classes such as ArrayList in the
  System.Collections namespace.
• You can create your own generic interfaces,
  classes, methods, events and delegates.
• Generic classes may be constrained to enable
  access to methods on particular data types.
• Information on the types used in a generic data
  type may be obtained at run-time by means of
  reflection.

62

• NDD

• Nondeterministic Destruction (NDD) due to
  garbage collection.
• No destructors in C and Java (programmers dont
  have to free memory).
• Finalize() method (inherited from Object class)
  is called during garbage collection.
• System decides when to perform garbage
  collection.
• File file new File ("Readme.txt") // file
  locked
• // Cant delete file to release the file.
• file.Close () // use close() to release the
  file in the Finalize().

63

• NDD

• The Problem we dont know when file.Close()
  will not be called.
• Solution One
• Call Close() whenever you know the file is not
  needed, instead of in the Finalize().
• Solution Two
• Force a garbage collection by calling
  GC.Collect ().
• Very expansive. Finalize() for all not used
  objects in all applications will be called.
• Solution Three Implement a Dispose method and
  call it when needed. (Read)

64

• DLL Miss-matching

• The problem
• Many applications may share the same DLL, but may
  use different versions of the same DLL. A new
  application may not run correctly when linked
  into an older version of the DLL. The problem is
  solved in .NET.
• In .NET, one can use CLRs Versioning, Strong
  Naming (SN), to avoid DLL miss-matching.

65

• SN Assembly

To Create a Strongly Named Assembly (1) Create
a key file for strong naming using the sn command
in SDK. sn /k Keyfile.snk (2) Create the
modules csc /targetmodule /outComplex.netmodule
Complex.cs vbc /targetmodule /outSimple.netmod
ule Simple.vb (3) Use AL to create a strongly
named assembly (version 1.0.0.0) that uses the
keys found in Keyfile.snk (version and key are
written into the manifest). al /keyfileKeyfile.
snk /targetlibrary /outMath.dll
/version1.0.0.0 simple.netmodule complex.netmodu
le (typo in the book space missing between
/targetlibrary and /outMath.dll) (4) Create the
application bound to the version 1.0.0.0
Math.dll. csc /targetexe /referenceMath.dll Ma
thdemo.cs
66

• SN Assembly

• To install the application
• Copy all needed files to the installation
  directory.
• MathDemo.exe, math.dll, Simple.netmodule, and
  Complex.netmodule
• run MathDemo.exe
• To verify that versioning is working,
• Create another version of Math.dll
• al /keyfilekeyfile.snk /targetlibrary
  /outMath.dll /version2.0.0.0 simple.netmodule co
  mplex.netmodule
• Copy the new Math.dll to the installation
  directory and run MathDemo.exe again.
• Will get System.IO.FileLoadException error.

67

• Inside .NET Versioning

(1) Versions are dynamically checked at runtime
before loading DLLs. (2) Versions are strictly
enforced. (3) To update a DLL you need use
binding redirect. (5) Use binding redirect to
link with different versions of DLLs and use sn
/T math.dll to find the hash value of the dlls
to be linked to. (all specified in
MathDemo.exe.config)
68

• Versioning in .NET

// Versioning info can be specified in the config
file for an application // MathDemo.exe.config
ltconfigurationgt ltruntimegt ltassemblyBinding
xmlns"urnschemas-microsoft-comasm.v1"gt
ltdependentAssemblygt ltassemblyIdentity
name"Math" publicKeyToken"cd16a90001d3
13af" /gt ltbindingRedirect
oldVersion"1.0.0.0" newVersion"1.1.0.0" /gt
lt/dependentAssemblygt ltprobing
privatePath"bin" /gt lt/assemblyBindinggt
lt/runtimegt lt/configurationgt
69

• GAC

• The Global Assembly Cache (GAC) is a repository
  for sharing (strong named) assemblies on an
  individual system.
• (1) Move math.dll and related files to any
  directory, say, Shared.
• (2) MathDemo will not run anymore.
• (3) Go to Shared gacutil /i math.dll
• (4) MathDemo will run now.
• (5) To un-share (note no dll extension) gacutil
  /u math

70
Applying Strong Names Using Attributes in the
Source Code (An easier way to produce a strongly
named assembly). Add to Complex.cs Using
System.Reflection assemblyAssemblyKeyFile ("Keyf
ile.snk") assemblyAssemblyVersion ("1.0.0.0")
Add to Simple.vb Imports System.Reflection ltAss
emblyAssemblyKeyFile ("Keyfile.snk")gt ltAssemblyA
ssemblyVersion ("1.0.0.0")gt The Version Number
major-version.minor-version.build.revision
71

• Delayed Signing to install and use a strongly
  named assembly without the private key.
• (for development use only, not for release).
• al /keyfilepublic.snk /delaysign
  /targetlibrary /outMath.dll
• /version1.1.0.0 simple.netmodule
  complex.netmodule
• or
• assemblyAssemblyKeyFile ("Public.snk")
• assemblyAssemblyVersion ("1.0.0.0")
• assemblyDelaySign (true)

72

• The Fundamentals in Chapter Two

Basic CTS Types Class, Struct, Enum, Property,
Event, Delegate, Value Type, Reference Type,
Basic .NET Concepts Garbage Collection, DLL,
Versioning, Strong Name, GAC, Exception Handling,
Try, Catch, Finally, Throw. What is it? How to
define and use it? Can you write a program? Can
you trace a program? Do you know what going on
inside?