Kursbeskrivning

MÅL

Du lär dig hur man bygger .NETapplikationer (WinForms och WebForms) samt WCF Services i C#. Denna kurs är en djupdykning i .NET 3.5-utveckling med Visual Studio 2008. Du lär dig använda C# 3.0. Du lär dig också grunderna i de nya teknikerna LINQ, WPF och WCF.

FÖRKUNSKAPER

Du ska ha erfarenhet av objektorientering och programmering i Windows med språk som C#, C++, Java eller Delphi. Du bör känna till begrepp som:
• Objects
• Classes
• Methods
• Inheritance
• Polymorphism
• Type-Safety

KURSLÄRARE

Lärare är experten och “gurun” Richard Hale Shaw från USA. Han är medlem i gruppen INETA (International .NET Association) som talare.

Han har programmerat COM sedan -94 och har stor erfarenhet av programutveckling i C++, MFC, .NET och C#. Richard är medlem i Microsofts C# Customer Council, MVP i C#, konsult och mjukvaruarkitekt. Richard skriver hela sitt utbildningsmaterial själv baserat på praktiska lösningar. Hans eget koncept “Developer BootCamp” bygger på praktiska lösningar och inte så mycket på akademiska studier.
Du läser mer om Richard på:
www.richardhaleshawgroup.com

KURSLÄNGD

5 dagar

KURSDATUM

Linköpig: 2-6 februari
Linköping: 8-12 juni

PRIS

23.950 kr

ANMÄLAN

För att boka kursplats ber vi dig att fylla i ett anmälningformulär och faxa in det till oss på 013-135695.

Klicka här för att ladda hem anmälningsformuläret!

Alternativt så mailar du in en kursförfrågan till vår kursadministratör Gunilla på gunilla.friberg@pc-ware.se eller ringer till henne på 013-4790555.

Kursinnehåll

Introduction to .NET

• What is .NET? How .NET evolved from Windows
  and COM.
• Deficiencies in Windows, COM and other
  preceding technologies 
• Key Elements of the .NET Framework. 
• Binary Compatibility: Cross-language support,
  the Common Type System (CTS). 
• Managed Languages: the Common Language
  Specification (CLS) 
• Benefits of Managed Environments

• An overview of:
- .NET Framework 2.0 
- ADO.NET 2.0 
- Windows Forms 2.0 
- WPF 
- ASP.NET 2.0 Web Forms 
- WCF 
- Platform Interop

Assemblies and the Common Language
Runtime (CLR)

• Manifests, Metadata, MS Intermediate Language Code 
• JIT Compilation and Pre-JIT, JIT verification 
• Memory Management and Indeterministic Finalization 
• How the CLR is loaded; CLR Hosting,
  CLR assembly locating

• AppDomains, using .config files to re-direct CLR look-ups
- Assemblies as Building Blocks

• Building components, not objects, Packaging,
  Deploying, and Administering 
• Side-By-Side Execution, Shared vs. Private Assemblies 
• Deploying to the Global Assembly Cache - and why not to
• .NET versioning: eliminating DLL Hell 
• Application/Assembly Deployment, Debugging
  and Tracing, Remote Debugging

Programming with C#: Fundamentals
and Type Design

• Comparing C# to C++, Java, Delphi and IDL
• C# as a means of scripting the generation of
  MetaData and IL constructs 
• Using the command-line compiler 
• Program structure and keywords, Namespaces and
  Control Flow 
• The .NET Exception Model and C# 
• C# Type Design 
• C# Aliases for Core .NET Types, Using the Built-in Types 
• Type Accessibility, Type Visibility, Member Accessibility 
• Operator Overloading 
• Understanding System.Object, Value Types vs.
  Reference Types 
• Restricting your use of Value Types - and why,
  boxing & unboxing 
• Ref and Out parameters, Variable-parameter methods 
• Properties as Accessor Interfaces, choosing
  Properties vs. Methods 
• Indexers: a special Property, Virtual Functions and
  Member Hiding vs. C++ 
• Microsoft’s Naming conventions; RHS Group
  Naming conventions

Understanding Metadata and Reflection

• Introduction to MetaData: System.Type 
• ConstructorInfo, MethodInfo, FieldInfo, EventInfo,
  PropertyInfo, ParameterInfo 
• Extending MetaData: Attributes; What Attributes
  can do - and what they can’t do 
• Attribute usage: Serialization, Components, Interop,
  runtime discovery

Generics and Managed Collections

• What are Generics? Why bother with Generics? 
• Generic types (classes, structs, interfaces and delegates) 
• How the CLR specializes Generic types; Generics
  in .NET vs. Templates in C++ 
• Performance improvements using Generics 
• Introduction to Collections 
• How Iterators work: IEnumerator and IEnumerable 
• Simple Collections: ICollection 
• Exposing collection-like features from classes: Indexers 
• Read-write Collections: IList 
• Why CollectionBase is Evil, Collection Classes and
  Interfaces in .NET 1.x 
• Implementing Type-Safe Collections in C# 1.0 
• C# 2.0: Generics 
• Implementing Type-Safe Collections with Generics

Delegates and Events

• Introduction to Delegates
- How Delegates are defined: System.Delegate and
  System.MulticastDelegate 
- Delegates are NOT Function Pointers; Delegates
  as out-going interfaces 
- Method Design Patterns: Delegates as
  parameters/return types 
- Asynchronous Delegates: Begin/EndInvoke,
  IAsyncResult and AsyncCallBack 
- The Asynchronous Delegates Patterns

• Introduction to Events
- How Events differ from Delegates: Events are
  Delegates used as Properties! 
- The compiler-generated add/remove methods,
  and overriding them

Implementing Custom Iterators

• Iterators the hard way: C# 1.0; Iterators the
  easy way: C# 2.0 
• Iterators under-the-hood; When to use
  IEnumerable/ vs. IEnumerator/ 
• Applying Iterators to real-world problems

C# 2.0 Additional Features

• Anonymous methods: methods inside of
  methods and method-reference passing 
• Partial Types; Static Classes; Delegate
  CoVariance/ContraVariance/Inference 
• Variable-parameter Generic Methods 
• Global namespace qualifier; Reference aliases 
• Property accessors with differing access specifiers 
• Creating fixed size buffers in unsafe code

• #pragma warning
- C# 2.0 / Framework 2.0: Nullable Types

• Why create value types that can be null? Creating
  Nullable types 
• Using and consuming Nullable types 
• Extensions to C# 2.0 specifically for Nullable types

.NET Components and the DataBindingPattern

• The .NET Component Model 
• The Value of Components 
• Attributes for controlling Component Property Editing 
• The DataBinding Pattern: Combining Collections
  and Reflection

C# 3.0 and LINQ to Objects

• Lambda Expressions 
• Extension Methods 
• Anonymous Types 
• Partial Methods 
• Auto-implemented Properties 
•  Local variable initializers 
• Object initializers 
• Collection Initializers 
• Implicitly Typed Arrays 
• Query expressions 
• Introduction to LINQ 
• Queries as Objects 
• Linq Data Sources: It’s all IEnumerable, Baby 
• Basic Linq Queries 
• The Standard Query Operators API

ADO.NET and LINQ to SQL

• Introduction to ADO.NET
- Database-specific Types and Interfaces: Providers 
- Using DataReaders and the DataTableReader
  for fast, read-only data access 
- Using, creating and querying DataSets: an in-memory
  table cache 
- Creating and managing 1-many and many-1 relations 
- Reading/writing XML documents into/out-of
  ADO.NET databases 
- Async database operations 
- .NET 2.0 Transactions

• Introduction to Linq-to-SQL
- Linq Wrappers around SQL 
- Using, Creating and Querying Databases and Tables 
- Creating/managing 1-many and many-1 relations

Building Windows Client UIs: Windows
Forms and Windows Presentation Foundation

• Windows Forms
- Creating MDI-based Windows Forms apps 
-  Adding event-handlers, toolbars, icons, menus
  and tray icons 
- Creating child dialogs and form-only applications 
- Creating Explorer-style UIs 
- WinForms 2.0 Controls 
- Building and Using Custom controls 
- Multi-language and localization support 
- ClickOnce and Manifest-based Activation 
- Application Settings

• Windows Presentation Foundation (WPF)
- Overview of WPF
- WPF Framework Architecture 
- Introduction to XAML Programming 
- WPF Programming Tools 
- Events and Properties 
- WPF Controls 
- Layout 
- Understanding pages and navigation 
- Data Binding 
- Styling and Templates 
- Graphics 
- Resource Management 
- Building Custom Controls 
- Text, Typography, and Documents 
- Printing

Building Web-Based Front-Ends: ASP.NETWeb
Forms and Controls

• ASP.NET Architecture, ASPNET_WP and the
  Code-Behind Page 
• VS.NET - IIS Coupling in Previous Versions;
  VS 2005 - IIS de-coupling 
• Understanding Postbacks: the Page class lifecycle 
• Adding Event-handling, Debugging Web Forms 
• Web Forms Controls vs. Html Controls 
• 2.0 Master Pages and Themes, Web Parts 
• 1.0 Controls, 2.0 Controls, Custom Controls 
• State Management: ViewState, SessionState
  and ApplicationState 
• Adding client-side validation code 
• Site Navigation and User-customization 
• ViewState, SessionState and ApplicationState 
• DataBinding and the 2.0 Provider Model,
  DataGrid and DataList 
• 2.0 Membership, Roles, Personalization 
• Authentication and Authorization 
• Peformance: Pre-compiling and caching 
• Web Site Administration

Building Platform-Independent Services
with Windows Communication Foundation (WCF)

• Overview of the ASP.NET (.ASMX) Web Services 
• Overview of .NET Remoting

• Fundamentals of WCF
- Service Contracts
- Data Contracts

• How WCF replaces .ASMX and Remoting 
• Building a WCF Service 
• Generating WCF Client Proxy Code 
•  Building a WCF Client 
• Testing and Debugging WCF Services

 Interop Strategies

• Invoking Legacy Code from Managed Code
- Invoking COM servers
  Using Events to Implement Connection Point Callbacks
- Invoking DLLs
  [DLLImport] 
  Creating Managed C++ Wrappers

• Invoking C++ Code through Mixed-Mode Assemblies 
• Using Delegates to Implement CallBack Strategies

• Invoking Managed Code from Legacy Code
- Creating COM Servers with Managed Code
   Implementing Connection Points
- Using Managed C++ Wrappers to Invoke Managed DLLs
   Implementing CallBacks