Sela

C# Programming in the .NET Framework

Description
This six-day instructor-led course provides students with the knowledge and skills to develop applications in the .NET Framework using the C# programming language. C# is one of the most popular programming languages in existence, and the recent revisions introduce new productivity, performance, and convenience features into the language. This course features an overview of all language-related features, as well as an introduction to general .NET Framework features such as garbage collection, assembly loading, Reflection, Language-Integrated Query (LINQ), Asynchronous prgramming and many others.
Intended audience
This course is intended for developers with good knowledge of object-oriented principles and practical experience of at least 6 months with an object-oriented programming language (C++ preferred).

Topics

Introduction to the .NET Framework
Common Language Runtime Components – Garbage collector (GC), Common Type System (CTS), Just-in-Time compiler (JIT)
An Overview of Managed Languages
Microsoft Intermediate Language (IL)
Native Image Generator (NGEN)
An Overview of the Framework Class Library (FCL)
.NET Version Evolution – from .NET 1.0 to .NET 4.5
C# 5.0: Overview and Design Goals
The Visual Studio Integrated Development Environment
"Hello World" in C#
Namespaces and References – Importing types, multi-targeting support, target platform
Console Operations
String Formatting
Disassembling .NET – ILDASM, .NET Reflector
Lab 1: Basic Operations
The Common Type System
The Common Language Specification
Primitives and Built-in Types
Value Types and Reference Types
Boxing and Unboxing
System.Object Class Members
Type Conversions
Lab 2: Reviewing Reference Types and Value Types
Lab 3: Reviewing Object Equality
Class Members
Access Modifiers
Nested Types
Fields
Constructors and Static Constructors
Constants and Readonly Fields
Properties and Automatic Properties
Object Initializer Syntax
Methods and Static Methods
Optional and Named Parameters
Static Classes
Extension Methods
Partial Types and Partial Methods
The new Operator
Parameter Modifiers
Variable Parameter Lists
The Entry Point and its Parameters
Destructors
Lab 4: Basic Class
Destructor and Finalization
Tracing Garbage Collection
Interacting with the Garbage Collector
Generations
Weak References
XML Overview
XML Documentation in Comments
Auxiliary Tools – Sandcastle, DocumentX!
Array Definition and Usage – Multi-dimensional, jagged, System.Array
Casting and Enumerating Arrays
String Class Members
String Immutability
StringBuilder
String Literals
Lab 5: Name Processing
Inheritance and Polymorphism
Up Casts and Down Casts
Inheritance and Overriding Subtleties
Lab 6: Shapes
User-Defined Value Types
Field Initialization
Nullable Types
Enumerations and Flags
Indexers
Consuming Indexers from Other .NET Languages
Lab 7: Receptionist Scheduling
Error Reporting Alternatives
Throwing and Catching Exceptions
Exception Types and Objects
Inner Exceptions
User-Defined Exceptions
Resource Management
Checked and Unchecked Arithmetic
Exception Design Guidelines and Performance
Lab 8: Incorporating Exception Handling
Interface Declaration and Implementation
Explicit Interface Implementation
System Interfaces
Extending Interfaces using Extension Methods
Lab 9: Enumeration Capabilities
Overloading Operators
Operator Names in the CLS
User-Defined Conversions – Implicit and explicit, sequence of conversions
Delegate Definition and Usage
Delegate Implementation
Multi-cast Delegates
Anonymous Methods
Lambda Functions
Events
Event Design Patterns
Lab 10: Sorting with Delegates
Lab 11: Event-Based Chat System
Preprocessing Directives
Defining and Undefining Preprocessor Directives
Control Flow Statements
Switch Blocks
Metadata Tables
Reflection Types
System.Activator
Lab 12: Self-Registration with Interfaces
Attribute Class
Attribute Examples
Applying Attributes
User-Defined Attributes and Attribute Usage
Querying Attributes with Reflection
Lab 13: Logging with Attributes
Lab 14: Self-Registration with Attributes
Motivation for Generics
Generic Constraints
Generic Interfaces, Methods and Delegates
.NET Generics vs. C++ Templates
Generics and Reflection
Built-in Generic Collections
Generic System Interfaces
Collection Initializers
Lab 15: Implementing a Generic Collection
Deployment and Versioning of .NET Assemblies
Private and Shared Assemblies – The Global Assembly Cache (GAC)
Application Configuration Files
Versioning Policies
Friend Assemblies
Multi-Module Assemblies
Lab 16: Creating and Registering Assemblies
.NET Interoperability Options
Introduction to Platform Invoke (P/Invoke)
Unsafe Code – C# Pointers
Lab 17: Calling Exported C Functions from C#
Anonymous Types and Implicit Variables
Expression Trees
Query Operators and the Query Pattern
Language-Integrated Query Keywords and Query Translation
LINQ to Objects
Lab 18: Using LINQ
Introduction to Covariance and Covariance
Evolution of Covariance and Contravariance—from C# 1.0 to C# 5.0
Covariant and Contravariant Delegates and Interfaces in C# 5.0
Static and Dynamic Languages
Dynamic Method Invocation
Circumventing Generic Constraints
Introduction to Dynamic Language Runtime
Extending Class Definitions with DynamicObject
Lab 19 - Dynamic
History of Asynchronous Programming
Tasks
Tasks vs. APM
async/await syntax
Exceptions flow
Limitation
C# 6 main features
C# 7 main features

רוצה לדבר עם יועץ?

האם אתה בטוח שאתה רוצה לסגור את הטופס ולאבד את כל השינויים?