Introducing .NET 4.0 - With Visual Studio 2010

Title Page

Copyright Page

Contents at a Glance

Table of Contents

About the Author

About the Technical Reviewer

Acknowledgments

Contributors

Introduction

…But We Will Give You All This!

Code Examples

Danger—Work in Progress!

Chapter 1: Introduction

Versions

What Is .NET 4.0 and VS2010 All About?

Efficiency

Maturation of Existing Technologies

Extensibility

Influence of Current Trends

Multicore Shift

Unit Testing and Test-Driven Development

Cloud Computing

What Do Others Think About .NET 4.0?

Mike Ormond (Microsoft Evangelist)

Eric Nelson (Microsoft Evangelist)

Craig Murphy (MVP and developer community organizer)

Phil Whinstanley (ASP.NET MVP and author)

Dave Sussman (MVP and author)

Matt Lacey (Devevening.co.uk organizer)

Alex Mackey (Author of this book and MVP)

Future Trends

My Own Subjective Opinion

Summary

Chapter 2: Visual Studio IDE and MEF

General Improvements

Improved Multitargeting Support

Intellisense

Add References

Web Development (Code-Optimized Profile)

Zoom

Highlight References

Navigate To

Box Selection

Call Hierarchy

Code Generation

Consume First Mode

Breakpoints

Toolbox

Code Snippets

Loading the Snippet into Visual Studio

Using Snippets

Creating Custom Start Pages

T4 (Text Template Transformation Toolkit) Files

VS2010 Premium and Ultimate

Generate Sequence Diagram

Historical Debugging (Team System Edition Only)

Static Analysis of Code Contracts

Customization of IDE

MEF (Managed Extensibility Framework)

Why Use MEF?

Hello MEF

How Did This Example Work?

MEF Catalogs

Metadata

What’s This All Got to Do with Visual Studio Extensibility?

Visual Studio Extensibility

Editor Margin

Distributing Extensions

Extension Gallery

Visual Studio Shell

Dotfuscator Changes

Conclusion

Chapter 3: Language and Dynamic Changes

Future Co-evolution of VB and C#

C# Enhancements

Named and Optional Parameters

Rules (Non-Optional)

VB.NET Changes

Line Continuation

Inferred Line Continuation Rules

Anonymous Method Support

Auto-Implemented Properties

Collection Initializes/From Keyword

Array Literals

New Syntax for Creating Jagged Arrays

Nullable Optional Parameters

Easier COM Interoperability

We’re Out of PIA

Variance

The Long Version for Everyone Else

Bad Arrays of Animals and Elephants

So, What’s the Problem?

Out

Contravariance

Example of Contravariance

Further Reading

Dynamic Enhancements

Can’t We Do This Kind of Thing Already in .NET?

Static Languages

Dynamic Languages

Dynamic Dangers

Type Dynamic

Is dynamic the Same as Var?

Why Type Variables as Dynamic?

System.Dynamic.ExpandoObject

System.Dynamic.DynamicObject

IDynamicMetaObjectProvider

Dynamic Limitations

Dynamic IL

Dynamic Language Runtime (DLR)

Expression/Abstract Syntax Trees (AST)

Dynamic Dispatch

Binders

IDynamicObject

Callsite Caching

IronPython

Embedding Dynamic Languages

Calling IronPython from .NET

Red Gate Reflector Add-In

ResolverOne

Michael Foord

F#

Jon Skeet

Future of C#

Chapter 4: CLR and BCL Changes

New CLR

ASP.NET

What Version of the CLR Does My Application Use?

Specifying the Framework to Use

VB.NET Command-Line Compiler

Improved Client Profile

In-Process Side-by-Side Execution

Garbage Collection

Garbage Collection Prior to .NET 4.0

Garbage Collection in .NET 4.0

GC.RegisterForFullGCNotification()

Threading

Globalization

Globalization Changes in .NET 4.0

TimeSpan Globalized Formatting and Parsing

Security

Transparency Model

Safe Critical Code

Critical Code

Safe Critical Gatekeeper

Why Does It Matter?

Security Changes

SecAnnotate

APTCA and Evidence

Monitoring and Profiling

Native Image Generator (NGen)

Native Code Enhancements

Exception Handling

New Types

BigInteger

Lazy

Memory Mapping Files

SortedSet

ISet Interface

Tuple

System.Numerics.Complex

System.IntPtr and System.UIntPtr

Tail Recursion

Changes to Existing Functionality

Action and Func Delegates

Compression Improvements

File IO

Path.Combine()

Isolated Storage

Registry Access Changes

Stream.CopyTo()

Guid.TryParse(), Version.TryParse(), and Enum.TryParse()

Enum.HasFlag()

String.Concat() and String.Join() support IEnumerable

String.IsNullOrWhiteSpace()

StringBuilder.Clear

Environment.SpecialFolder Enum Additions

Environment.Is64BitProcess and Environment.Is64BitOperatingSystem

Stopwatch.Restart()

ServiceProcessInstaller.DelayedAutoStart

Observable collection refactoring

IObservable

Network Class Libraries (NCLs)

Windows 7 Only

System.Device.Location

ExtendedProtection

Deprecated APIs

System.Data.OracleClient

Global Static Hosting Functions

Code Contracts

Hello Code Contracts

Installing Code Contracts

Example Code Contract

Enabling Code Contract Static Verification (Premium/Ultimate Edition Only)

Contract Inheritance

Architecture

Conditions

Preconditions

Post Conditions

Object Invariants

Code Contract Values

Contract.Result

Contract.OldValue

Pure

Interface Contracts

PEX

Conclusion

Further Reading

Chapter 5: Parallelization and Threading Enhancements

Parallelization Overview

Important Concepts

Why Do I Need These Enhancements?

Concurrent!= Parallel

Warning: Threading and Parallelism Will Increase Your Application's Complexity

Crap Code Running in Parallel is Just Parallelized Crap Code

What Applications Benefit from Parallelism?

I Have Only a Single Core Machine; Can I Run These Examples?

Can the Parallelization Features Slow Me Down?

Performance

Parallel Loops

Parallel.For()

An Unrealistic Example?

ParallelOptions

Parallel.ForEach()

Warning: Parallelization Can Hurt Performance

Parallel.Invoke()

Tasks

Task Scheduler

Creating a New Task

Task.Wait() and Task.WaitAll()

Task.WaitAny()

IsCompleted

ContinueWith()

Do Parallel Loops Create a Thread for Each Iteration?

Returning Values from Tasks

What if the Task Does Not Yet Have a Result?

Task Creation Options

Task Status

Overriding TaskScheduler

Scheduling on UI thread

Parallel Debugging Enhancements

Parallel Task Window

Parallel Stacks Window

PLINQ (Parallel LINQ)

Why Not Parallelize All LINQ Queries Automatically?

Hello PLINQ

Ordering Results

ForAll Operator()

AsSequential()

WithMergeOptions

PLINQ performance

Cancelling a PLINQ Query

Exceptions and Parallel LINQ

Coordination Data Structures (CDS) and Threading Enhancements

Thread Pool Enhancements

Thread.Yield()

Monitor.Enter()

Concurrent Collections

ConcurrentStack

ConcurrentQueue

ConcurrentDictionary

ConcurrentBag

BlockingCollection

Synchronization Primitives

Barrier

Cancellation Tokens

CountDownEvent

ManualResetEventSlim and SemaphoreSlim

SpinLock

ThreadLocal

Future Considerations

Danny Shih Interview

Phil Whinstanley

Conclusion

Further Reading

Chapter 6: Windows Workflow Foundation 4

Why Use WF?

What Can Windows Workflow Do for Me?

What Is Windows Workflow Foundation?

Workflow Instance/Runtime

Activities

Workflow Designer

Existing WF3 Users

Statemachine Workflow Has Gone

Upgrade White Papers

WF3 Runtime

Interop Activity

Is It Worth the Upgrade?

All Change

Hello WF 4

Hello WF

Arguments and Variables

Creating an Argument

WriteLine

Creating Another Sequence Activity

Checking Number of Tickets with an If Activity

Booking Unsuccessful and Assign activity

Booking Succssful and Parallel Activity

Displaying the Output of the Booking

Supplying Arguments to a Workflow

Creating Your Own Activities

Creating an Activity Composed of Other Activities

Creating Activities Purely in Code

Pure XAML Workflows

Invoking Workflows

Flowchart

WCF/Messaging Improvements

Correlation

WCF Workflow Service Applications

Activities

WF3 Activity Replacements

New Activities

Misc Improvements

John Mcloughlin

Summary

Chapter 7: Windows Communication Foundation

Configless WCF

Default Binding, behavior, and Endpoints

Default Binding and Behaviors

Standard Endpoints

No svc File

Router Service

Routing Example

Routing Filters

Multicast Support

Bridging Protocols

Redundancy

WS-Discovery

Managed Mode

Adhoc Mode

Service Announcement Events

WCF Starter Kit Integration

Help Pages

HTTP Caching

Misc Changes

Improved Integration with WF

Default Performance-Related Settings Changed

Low Memory

Other changes

Dublin/Windows Application Server

Further reading

Chapter 8: Entity Framework

EF and LINQ to SQL

Is LINQ to SQL Dead?

LINQ to SQL changes

Why Use EF?

Abstraction

Code Generation

Support for Different Databases

Design Time Support

Utilize LINQ

N-Tier Application Development

Where is EF Used?

EF 101

Entity Data Model

Creating an EDM

EdmGen.exe

Creating an Entity Data Model in Visual Studio

Navigating the EF model

Viewing How Entities Are Mapped

What Happens If My Database Structure Changes?

Querying Data

LINQ to Entities

ObjectQuery

Entity SQL

CRUD Operations in EF

Creating

Updating

Deleting

EFv1 Criticisms

Entity Framework 4

EDM Designer Changes

Performance

Pluralization

Deferred/Lazy Loading

Eager Loading

Complex Type Designer Support

Complex Types from Stored Procedures

Model Defined Functions

Model First Generation

Foreign Keys

Code Only/POCO

POCO in EF4

Code Generation Templates

Julie Lerman (Author of Programming Entity Framework and MVP)

Dane Morgridge

Conclusion

References/Further reading

Chapter 9: WCF Data Services

Hello WCF Data Services

Entity Framework

Creating a Data Service

IE Content Settings

Hello WDS

Querying WCF Data Services

Security in WCF Data Services

Query Interceptors

Returning Results in Different Formats

Using JSON with JavaScript

Using JSON with C#

WDS Proxy Classes

Retrieving Items with Proxy Classes

Adding a New Item with Proxy Classes

Update an Item

Delete an Item

WDS 1.5

RowCount and Server-Driven Paging

$count

$inlinecount=allpages

Limiting Number of Results Returned

Projections

Friendly Feeds

Miscellaneous Improvements

What’s the Relationship Between WDS and WCF RIA Services?

Conclusion

Further Reading

Chapter 10: ASP.NET

Project Templates

Web.config

IDE Changes

Code Snippets

ASP.NET Code Snippets

Using Snippets

Deployment

Web.config Transformation

Creating a New Deployment Configuration

Transforming Web.config from the Command Line

Web.config Transformation Options

Web Packages

One-Click Publishing

ViewState

ClientIDMode

Response.RedirectPermanent()

Meta-tags

URL Routing

HTML Encoding

HtmlString

Custom Request Validation

Custom Encoders

URL and Query String Length

Valid URL Characters

Accessibility and Standards

controlRenderingCompatibilityVersion

RenderOuterTable

CheckBoxList and RadioButtonList

ASP.NET Menu control

Browser Capability Files

Further Control Enhancements

Wizard Control

ListView Enhancements

GridView

CompareValidator

Query Extender

Browser capability files

Auto-Start Web Applications

Compress Session State

Caching

Velocity

System.Runtime.Caching

Resource Monitoring

Charting Controls

Dynamic Data Framework

Conclusion

Further Reading

Chapter 11: Microsoft AJAX Library

Architecture Changes

Compatibility

A pageLoad Problem Fixed

Installation

Adding Microsoft AJAX Libraries to Your Project

Client Script Loader

Referencing jQuery Scripts

Specifying Script Directories

Loading Custom Scripts

Lazy Loading

AJAX Libraries Now Hosted by Microsoft

ScriptManager EnableCDN

AJAX Toolkit Integration

Controls Now Exposed as jQuery Plug-ins

DataView

XHTML-Compliant?

Hello, Microsoft AJAX

sys-template CSS rule

DataView Binding

Declarative Binding

Programmatic Binding

A Cleaner Programmatic Binding

Master Detail Binding

Binding to External Services

WebService (.asmx)

WCF Binding

JSONP

Advanced Binding

Conditional Rendering

sys:if

$dataItem

$index

sys:codebefore and sys:codeafter

sys:innertext and sys:innerhtml

Binding Converters

Two-way Binding

Sys.Observer

WCF Data Services Data Context

Conclusion

Further Reading

Chapter 12: jQuery

jQuery or Microsoft AJAX libraries?

jQuery Overview

Downloading jQuery

IntelliSense

Script Hosting

Hello jQuery

How Does It All Work?

Selecting Elements

CSS Selectors

jQuery Selectors

Working with Sets

.each() method

Working with Attribute Values and CSS

Writing Elements Dynamically

Running a Script on Page Load

Adding Functions

Animation/Effects

Effect Overloads

Core Library Effects

Additional Effects

Glimmer

jQuery Tools

Chaining Events

Customizing jQuery

AJAX Methods

Load and Run JavaScript File

Submitting Data

Getting the Latest Version of a Page

Retrieving a JSON Object

A Better Way

Utility Methods

jQuery Additions

Summary

Further Reading

Chapter 13: ASP.NET MVC

MVC History

So Why MVC?

An Existing MVC application

What a State

Type Initialization

Installing MVC

Creating the MVC Application

Project Structure

Changing the Layout of MVC Pages

Creating the Model

Creating EF Entities

Repository Pattern

Creating Validation for Data Model

Creating a Controller

Adding a View

Running the application

A Closer Look at Routing

Returning Views

ViewData and TempData

Displaying a List of Data

Have We Gone Back to 1998?

Creating a Detail Page

HtmlHelper Methods

Strongly Typed Views

Creating a Strongly Typed View

Creating an Add New and Delete Functionality

Accepting Data from Users

Specify individual properties

Form Collection

Bind Attributes

Attributes

AcceptVerbs

OutputCache

Authorization

ASP.NET MVC and JavaScript

Custom Routing

ASP.NET MVC and Security

Extending MVC

Extension Methods

Filters

Testing

Creating a Fake Film Repository

Creating a Test

Modify Film Controller

Running Tests

ASP.NET MVC V2

ASP.NET MVC in the real world

What’s Next?

ASP.NET MVC Highlights

Considerations

Summary

Further Reading

Chapter 14: Silverlight Introduction

Silverlight versus Flash

Silverlight in the Real World

WPF

XAML

Silverlight Requirements and Installation

Expression Blend

Creating a New Silverlight Project

Project Structure

Hi Yo, Silver!

Understanding the Basics

Adding Content

Adding Silverlight to your Application

Object Tag

Pages in Silverlight

Creating a Silverlight User Control

App.xaml

Styles

Positioning Elements

Attached and Dependency Properties

Layout Controls

Canvas

Stack Panel

Grid

Simple Animation

Creating Animation Programmatically

Responding to User Events

Declarative Animation

HTML Integration

Calling a JavaScript Function from Silverlight

Changing DOM Element Values from Silverlight

Calling a Silverlight Function from JavaScript

Passing Parameters into Silverlight

InitParams

Query String

Embedding Content in a Silverlight application

Loading XAML Dynamically

Media

Additional Controls

Data Binding

DataBinding Modes

Data Binding and Dependency Properties

Two-Way Binding

Binding ListBox

DataTemplates

DataGrid

Network Communications

Summary

Further Reading

Chapter 15: WPF 4.0 and Silverlight 3.0

IDE Enhancements

VS2010 WPF/Silverlight Designer

Sort by Property Source

Property Icons

Style

Brushes

Binding Window

Design Time Data Binding

New Image Picker

Improved Grid Designer

Improved Error Handling for User Controls

Static Resource and Designer Fix

Drag-and-Drop Data Binding

Improved XAML Intellisense

New Controls

Ribbon Control and Bag O’Tricks

Windows 7 Integration

Jump Lists

Task Bar

Multitouch Functionality

Binding Changes

Run.text

Dynamic Binding Support

Input Bindings Now Support Bindings

Text-Rendering Improvements

TextOptions.TextFormattingMode

TextOptions.TextRenderingMode

RenderOptions.ClearTypeHint

East Asian Bitmap font support

Layout Rounding

Cached Composition

Animation Easing

Pixel Shader 3.0 Support

Visual State Manager Integration

HTML-XBAP Script Interop

Full-Trust XBAP Deployment

Client Profile

Miscellaneous Changes

Silverlight 3.0

Upgrading from Silverlight 2

Offline Applications

Creating an Offline Application

Uninstalling Offline Silverlight Applications

Detaching Manually

Retrieving Attachment State

Detecting Connection Status

Autoupdate

Deep Linking and Browser History

Navigation Application

Local Connections

Styles

Applying Styles Dynamically

Style Inheritance

Merge Dictionary Support

Save File Dialog

Filtering Files in SaveDialog

Element to Element Binding

Effects and Transformations

Plane Projection

Easing Effects

Pixel Shaders

Creating Your Own Pixel Shaders

Media

New Formats

Silverlight DRM

Performance

Binary XML Support

Enhanced Deep Zoom performance

Improved XAP Compression

Silverlight.js

Assembly Caching

GPU Acceleration

Miscellaneous Enhancements

Controls

Listbox

TextBox Cursor Styling

Accessibility

Browser Zoom Support

Slsvcutil.exe

WCF RIA Services

Blend 3/SketchFlow

Silverlight 4.0

Silverlight in the Real World

Rusty Johnson and Andy Britcliffe, SharpCloud

Summary

Further Reading

Chapter 16: Windows Azure

Azure Overview

Architecture

Will I Be Able to Install My Own Version of Windows Azure?

Before You Begin

Installation

Web Roles

Hello Azure

Chapter16.WebRole

Chapter16.HelloAzure

Azure and Configuration Settings

Logging and Debugging

Testing Azure Applications

Creating Development Storage

Service Details Node

Chapter16.HelloAzure Node

Chapter16.WebRole Node

Green Globes

Viewing Azure Logs

Deployment

Deploying Hello Azure Application

Application Package Section

Configuration Settings Section

Staging

Production URLs

Analytical Data

Local Storage

Worker Roles

Storage in Azure

Azure Storage

Working with Azure Storage

Azure API or REST Requests?

Let's REST for a Minute

Azure Storage Names

Blobs (Binary Large Object)

Blob Example

Accessing REST API Directly

How Do We Work with the REST API?

Working with Azure Storage with Raw HTTP Requests

Queues

Table Storage

Other Azure Services

Microsoft.NET Services

Windows Live Services

Pricing and SLA

Real World Azure

Ray Booysen

Rusty Johnson and Andy Britcliffe, SharpCloud

Advantages

Disadvantages

Conclusion

Further Reading

Index