In this course, you will be introduced to the .NET framework through an overview of languages, libraries, services, and tools. You'll then learn the foundations of the C# language. From basics to the newer features such as generics, partial classes, static classes, global namespace qualification, and so forth. are integrated throughout the course.
Want to gain in-depth knowledge of the core C# language
Need a fast introduction to the .NET platform architecture
Would like an overview of how to navigate the .NET Framework class library
Examine core language features such as types, variables, and control constructs
Use object-oriented features such as class, interface, protection, and inheritance
Perform error notification and error handling using exceptions
Use properties to implement the private data/public accessor pattern
Use namespaces to group related types
Use delegates and events to implement callbacks
Override Object class methods such as ToString
Avoid dll conflicts during deployment
Use dynamic binding and polymorphism to write generic code (i.e., less code!)
Distinguish between "implementation inheritance" and "interface inheritance"
Use ADO.NET to connect to SQL Server and run a simple query
Build a basic Windows Forms GUI
Working knowledge of at least one other high–level language.
Note: The difficulty level is ideal for programmers coming from languages like VB6, Pascal, or C. Individuals with a mainframe or scripting background will find the course very challenging—you should study an introductory programming text before attending. If you have some C++ or Java experience, some material will be familiar, but the course will still be beneficial. Experienced C++ or Java programmers should move directly to Essential .NET.
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
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,
If you need training for 3 or more people, you should ask us about onsite training. Putting aside the obvious location benefit, content can be customised to better meet your business objectives and more can be covered than in a public classroom. It's a cost effective option.
Submit an enquiry from any page on this site, and let us know you are interested in the requirements box, or simply mention it when we contact you.