We begin with a brief overview of the languages, libraries, servers, services, and tools
that make up the Microsoft .NET platform.
.NET Execution Model
This module examines the .NET software development model: C# source code, compiler,
intermediate language, .exe/.dll files, and the Common Language Runtime execution
Here we see how to build and run the simplest type of .NET executable: a console
application. Console applications are common for development tools such as compilers
and linkers. They also work well for utilities like ftp, ipconfig, etc.
Here we create and use a dynamic-link library. Libraries let you split an application into
pieces that you build and version separately. They help eliminate repeated code since
multiple executables can share a library.
This section covers the core C# features that will be used by almost every program:
application entry point, predefined data types, variables, basic input and output,
operators, arrays, control constructs, comments, etc.
A class is a key object-oriented programming concept and the primary unit of coding in
C#. This section introduces classes with coverage of instance fields and methods,
access control, and object creation.
Initialization of variables is important for program correctness. C# provides excellent
support for initialization through well-defined default values, variable initializers, and
Properties model the characteristics or traits of a type. They make the client code clean
and simple while allowing class designers to maintain encapsulation and execute
The static keyword is used with fields, methods, and types. Static fields are used to
implement shared resources. Static methods are useful as utilities where the full power of
“When searching for group training we have struggled due to our location, but you guys have made it so easy to arrange training”
an instance method is not required. Static types are convenient containers for static fields
and methods. Here we discuss how to declare and use static types and members. We
cover the three initialization options for static fields (default values, static variable
initializers, and static constructor).
Reference types are implemented as reference/object pairs. An object is created using
the "new" operator and is subsequently accessed through a reference. Here we discuss
a number of issues surrounding references: assignment, parameter passing,
aggregation, array, null, and garbage collection.
Implementation Inheritance 1
Inheritance provides a powerful tool for object-oriented programmers to model their
application domain. Here we discuss the syntax and the meaning of inheritance: placing
common code in the base class, adding new members to the derived class, access within
an inheritance hierarchy, and constructor chaining.
Implementation Inheritance 2
This section covers many issues that arise in the presence of inheritance: type
compatibility, type conversion, method binding, method overriding, and abstract methods.
We discuss how to use dynamic binding to achieve polymorphic behavior.
An interface defines a contract that types can agree to support. Here we discuss the
details of defining and implementing interfaces, including how to write generic code
against an interface and how to use inheritance with interfaces.
C# has a unified type system: all types inherit from the library class Object. This section
discusses the details of the Object class including a survey of the methods provided,
when and how to override those methods, and how to use an Object reference as a
This module describes the C# error notification mechanism of exceptions. We show how
to generate an exception, how to handle an exception, control flow when an exception is
thrown, services offered by the exception classes in the .NET Framework class library,
and how to implement a custom exception type.