Beginning ASp.NET 4.5 in C# potx

THE EXPERT’S VOICE® IN .NET

For your convenience Apress has placed some of the front

matter material after the index. Please use the Bookmarks

and Contents at a Glance links to access them.

v

Contents at a Glance

About the Author ...................................................................................................... xxvii

About the Technical Reviewers ................................................................................. xxix

Acknowledgments..................................................................................................... xxxi

Introduction............................................................................................................. xxxiii

■Part 1: Introducing .NET............................................................................1

■Chapter 1: The Big Picture...........................................................................................3

■Chapter 2: The C# Language......................................................................................15

■Chapter 3: Types, Objects, and Namespaces .............................................................47

■Part 2: Developing ASP.NET Applications...............................................77

■Chapter 4: Visual Studio ............................................................................................79

■Chapter 5: Web Form Fundamentals .......................................................................121

■Chapter 6: Web Controls..........................................................................................163

■Chapter 7: Error Handling, Logging, and Tracing.....................................................203

■Chapter 8: State Management.................................................................................233

■Part 3: Building Better Web Forms.......................................................269

■Chapter 9: Validation ...............................................................................................271

■Chapter 10: Rich Controls........................................................................................293

■Chapter 11: User Controls and Graphics..................................................................319

■Chapter 12: Styles, Themes, and Master Pages ......................................................345

■Chapter 13: Website Navigation ..............................................................................387

vi

■ Contents AT A GLANCE

■Part 4: Working with Data....................................................................423

■Chapter 14: ADO.NET Fundamentals........................................................................425

■Chapter 15: Data Binding.........................................................................................473

■Chapter 16: The Data Controls.................................................................................511

■Chapter 17: Files and Streams ................................................................................551

■Chapter 18: XML ......................................................................................................581

■Part 5: Website Security.......................................................................615

■Chapter 19: Security Fundamentals ........................................................................617

■Chapter 20: Membership .........................................................................................639

■Chapter 21: Profiles.................................................................................................675

■Part 6: Advanced ASP.NET....................................................................697

■Chapter 22: Component-Based Programming.........................................................699

■Chapter 23: Caching ................................................................................................729

■Chapter 24: LINQ and the Entity Framework ...........................................................753

■Chapter 25: ASP.NET AJAX.......................................................................................791

■Chapter 26: Deploying ASP.NET Applications ..........................................................825

Index...........................................................................................................................867

xxxiii

Introduction

ASP.NET is Microsoft’s platform for developing web applications. Using ASP.NET, you can create e-commerce

shops, data-driven portal sites, and just about anything else you can find on the Internet. Best of all, you don’t

need to paste together a jumble of HTML and script code in order to program the Web. Instead, you can create

full-scale web applications using nothing but code and a design tool such as Visual Studio.

The cost of all this innovation is the learning curve. To master ASP.NET, you need to learn how to use

an advanced design tool (Visual Studio), a toolkit of objects (the .NET Framework), and an object-oriented

programming language (such as C#). Taken together, these topics provide more than enough to overwhelm any

first-time web developer.

Beginning ASP.NET 4.5 in C# assumes you want to master ASP.NET, starting from the basics. Using this

book, you’ll build your knowledge until you understand the concepts, techniques, and best practices for writing

sophisticated web applications. The journey is long, but it’s also satisfying. At the end of the day, you’ll find that

ASP.NET allows you to tackle challenges that are simply out of reach on many other platforms.

About This Book

This book explores ASP.NET, which is a core part of Microsoft’s .NET Framework. The .NET Framework is not

a single application—it’s a collection of technologies bundled into one marketing term. The .NET Framework

includes languages such as C# and VB, an engine for hosting programmable web pages, a model for interacting

with databases (ADO.NET), a higher-level framework for performing queries (LINQ and the Entity Framework),

and a class library stocked with tools for everything from reading files to validating a password. To master ASP.

NET, you need to learn about each of these ingredients.

This book covers all these topics from the ground up. As a result, you’ll find yourself learning many

techniques that will interest any .NET developer, even those who create Windows applications. For example,

you’ll learn about component-based programming, you’ll discover structured error handling, and you’ll see how

to access files, XML, and relational databases. You’ll also learn the key topics you need for web programming,

such as state management, web controls, and caching. By the end of this book, you’ll be ready to create your own

rich web applications and make them available over the Internet.

Who Should Read This Book

This book is aimed at anyone who wants to create dynamic websites with ASP.NET. Ideally, you’ll have experience with

a previous version of a programming language such as C or Java. If not, you should be familiar with basic programming

concepts (loops, conditional structures, arrays, and so on), whether you’ve learned them in Visual Basic, Pascal,

Turing, or a completely different programming language. This is the only requirement for reading this book.

Understanding HTML and XHTML (the markup languages used to write web pages) will help you, but it’s

not required. ASP.NET works at a higher level, allowing you to deal with full-featured web controls instead of raw

web page markup. However, you’ll get a quick overview of HTML5 fundamentals in Chapter 4, and you’ll learn

about CSS, the Cascading Style Sheet standard, in Chapter 12.

This book will also appeal to programmers who have some experience with C# and .NET but haven’t

worked with ASP.NET in the past. However, if you’ve used a previous version of ASP.NET, you’ll probably be more

interested in a faster-paced book such as Pro ASP.NET 4.5 in C# instead.

xxxiv

■ Introduction

■ Note This book begins with the fundamentals: C# syntax, the basics of object-oriented programming, and the

philosophy of the .NET Framework. If you haven’t worked with C# before, you can spend a little more time with the

syntax review in Chapter 2 to pick up everything you need to know. If you aren’t familiar with the ideas of object￾oriented programming, Chapter 3 fills in the blanks with a quick but comprehensive review of the subject. The rest of

the book builds on this foundation, from ASP.NET basics to advanced examples that show the techniques you’ll use

in real-world web applications.

ASP.NET MVC

This book focuses on web forms, which is ASP.NET’s original website-building model. However, in recent

years Microsoft has also added another toolkit, called ASP.NET MVC (ASP.NET Model-View-Controller), which

offers a dramatically different way to build web pages.

The core idea of ASP.NET MVC is that your application is separated into three logical parts. The model

includes the application-specific business code that powers your application. The view creates a suitable

representation of the model, by converting it to the HTML that browsers understand. The controller

coordinates the whole show, handling user interactions, updating the model, and passing the information

to the view. Although this sounds simple enough, the MVC pattern sidelines several traditional ASP.NET

concepts that are discussed in this book, including web forms, web controls, view state, postbacks, and

session state. To some, the MVC pattern is cleaner and more suited to the Web. To others, it’s a whole lot of

extra effort with no clear payoff. Microsoft suggests you consider ASP.NET MVC if you need to implement

test-driven development (which uses automated tests to validate web pages), or if you need complete control

over the URLs and the HTML markup that are used in your web pages.

ASP.NET MVC isn’t discussed in this book (and it’s a bit of a slog for developers who aren’t already familiar with

ASP.NET). However, you can get more information from the official ASP.NET MVC website at www.asp.net/mvc or

the book Pro ASP.NET MVC 4 (Apress, 2012).

What You Need to Use This Book

To develop ASP.NET web pages, you need a computer with Visual Studio 2012. You can use the free Visual

Studio 2012 Express for Web edition (available at http://tinyurl.com/bpjvx7c), which has all the tools and

functionality you’ll use in this book.

To use an ASP.NET web page (in other words, to surf to it over the Internet), you simply need a web browser.

ASP.NET fully supports Microsoft Internet Explorer, Mozilla Firefox, Opera, Apple Safari, Google Chrome, and any

other browser that respects the HTML standard on virtually any operating system. There are a few features that

won’t work with extremely old browsers (such as the ASP.NET AJAX techniques you’ll learn about in Chapter 25),

but 99.9 percent of web surfers can use any ASP.NET page to its fullest.

If you plan to host websites on your computer, you’ll also need to use Internet Information Services (IIS),

the web hosting software that’s part of the Windows operating system. You might also use IIS if you want to test

deployment strategies. You’ll learn how to use and configure IIS in Chapter 26.

xxxv

■ Introduction

Finally, this book includes several examples that use SQL Server. “You can use any version of SQL Server

to try these examples, including SQL Server Express LocalDB, which is included with Visual Studio.”

If you use other relational database engines, the same concepts will apply; you will just need to modify the

example code.

Code Samples

To master ASP.NET, you need to experiment with it. One of the best ways to learn ASP.NET is to try the code

samples for this book, examine them, and dive in with your own modifications. To obtain the sample code, surf to

www.prosetech.com or the publisher’s website at www.apress.com/9781430242512. You’ll also find some links to

additional resources and any updates or errata that affect the book.

Chapter Overview

This book is divided into six parts. Unless you’ve already had experience with the .NET Framework, the most

productive way to read this book is in order from start to finish. Chapters later in the book sometimes incorporate

features that were introduced earlier in order to create more well-rounded and realistic examples. On the other

hand, if you’re already familiar with the .NET platform, C#, and object-oriented programming, you’ll make short

work of the first part of this book.

Part 1: Introducing .NET

You could start coding an ASP.NET application right away by following the examples in the second part of

this book. But to really master ASP.NET, you need to understand a few fundamental concepts about the

.NET Framework.

Chapter 1 sorts through the Microsoft jargon and explains what the .NET Framework really does and why

you need it. Chapter 2 introduces you to C# with a comprehensive language tour. Finally, Chapter 3 explains the

basics of modern object-oriented programming.

Part 2: Developing ASP.NET Applications

The second part of this book delves into the heart of ASP.NET programming and introduces its event-based

model. In Chapter 4, you’ll take a look around the Visual Studio design environment and learn a few

fundamentals about web forms, events, and HTML5. In Chapters 5 and 6, you learn how to program a web

page’s user interface through a layer of objects called server controls.

Next you’ll explore two more essentials of ASP.NET programming. Chapter 7 presents techniques for

handling errors. Chapter 8 describes strategies for state management. Taken together, the chapters in this part

contain all the core concepts you need to design web pages and create a basic ASP.NET website.

Part 3: Building Better Web Forms

The third part of this book explores several topics that can help you transform ordinary web pages into polished

web applications. In Chapter 9, you’ll learn to use the validation controls to catch invalid data before the

user submits it. In Chapter 10, you’ll move on to consider some of ASP.NET’s more advanced controls, such

as the Calendar and Wizard. In Chapter 11, you’ll learn how to build your own reusable blocks of web page

user interface and draw custom graphics on the fly. Finally, Chapter 12 shows how you can standardize the

appearance of an entire website with themes and master pages, and Chapter 13 shows you how to add navigation

to a website.

xxxvi

■ Introduction

Part 4: Working with Data

Almost all software needs to work with data, and web applications are no exception. In Chapter 14, you begin

exploring the world of data by considering ADO.NET—Microsoft’s .NET-powered technology for interacting

with relational databases. Chapters 15 and 16 explain how to use data binding and the advanced ASP.NET data

controls to create web pages that integrate attractive, customizable data displays with automatic support for

paging, sorting, and editing.

Chapter 17 moves out of the database world and considers how to interact with files. Chapter 18 broadens

the picture even further and describes how ASP.NET applications can use the XML support that’s built into the

.NET Framework.

Part 5: Website Security

Every public website needs to deal with security—making sure that sensitive data cannot be accessed by the

wrong users. In Chapter 19, you’ll learn how ASP.NET provides authentication systems for dealing with users. You

can write your own custom logic to verify usernames and passwords, or you can use existing Windows account

information. In Chapter 20, you’ll learn about the membership model, which extends the authentication system

with prebuilt security controls and handy objects that automate common tasks. If you want, you can even get

ASP.NET to create and manage a database with user information automatically. Finally, Chapter 21 deals with

another add-on—the profiles model that lets you store information for each user automatically, without writing

any database code.

Part 6: Advanced ASP.NET

This part includes the advanced topics you can use to take your web applications that extra step. Chapter 22

covers how you can create reusable components for ASP.NET applications. Chapter 23 demonstrates how

careful use of caching can boost the performance of almost any web application. Chapter 24 explores LINQ and

the Entity Framework, two features that let you interact with a database without writing reams of custom code.

Chapter 25 introduces ASP.NET AJAX, which allows you to build responsive web pages that add rich features such

as text autocompletion and drag-and-drop. Finally, Chapter 26 walks you through the steps for deploying your

application to a web server.

Feedback

This book has the ambitious goal of being the best tutorial and reference for ASP.NET. Toward that end, your

comments and suggestions are extremely helpful. You can send complaints, adulation, and everything in

between directly to [email protected]. I can’t solve your ASP.NET problems or critique your code, but I

do benefit from information about what this book did right and wrong (and what it may have done in an utterly

confusing way). You can also send comments about the website support for this book.

PART 1

Introducing .NET

3

Chapter 1

The Big Picture

The Web has now existed for roughly two decades. In that time, the way websites look and work has changed

dramatically. The way people create websites has also evolved. Today web pages can be written by hand (perhaps

with the help of a design tool such as Adobe Dreamweaver), or they can be programmed using any one of a

number of powerful platforms.

ASP.NET is Microsoft’s web programming toolkit. It’s a part of .NET, a cluster of technologies that are

designed to help developers build a variety of applications. Developers can use the .NET Framework to build rich

Windows applications, services that run quietly in the background, and even command-line tools. Developers

write the code in one of several core .NET languages, such as C#, which is the language you’ll use in this book.

In this chapter, you’ll examine the technologies that underlie .NET. First you’ll take a quick look at the history

of web development and learn why the .NET Framework was created. Next you’ll get a high-level overview of the

parts of .NET and see how ASP.NET 4.5 fits into the picture.

The Evolution of Web Development

The Internet began in the late 1960s as an experiment. Its goal was to create a truly resilient information

network—one that could withstand the loss of several computers without preventing the others from

communicating. Driven by potential disaster scenarios (such as a nuclear attack), the US Department of Defense

provided the initial funding.

The early Internet was mostly limited to educational institutions and defense contractors. It flourished

as a tool for academic collaboration, allowing researchers across the globe to share information. In the early

1990s, modems were created that could work over existing phone lines, and the Internet began to open up to

commercial users. In 1993, the first HTML browser was created, and the Internet revolution began.

Basic HTML

It would be difficult to describe early websites as web applications. Instead, the first generation of websites often

looked more like brochures, consisting mostly of fixed HTML pages that needed to be updated by hand.

A basic HTML page is a little like a word-processing document—it contains formatted content that can

be displayed on your computer, but it doesn’t actually do anything. The following example shows HTML at its

simplest, with a document that contains a heading and a single line of text:

<!DOCTYPE html>

<html>

<head>

<title>Sample Web Page</title>

</head>

<body>

CHAPTER 1 ■ The Big Picture

4

<h1>Sample Web Page Heading</h1>

<p>This is a sample web page.</p>

</body>

</html>

Every respectable HTML document should begin with a doctype, a special code that indicates what flavor of

HTML follows. Today the best choice is the following all-purpose doctype, which was introduced with HTML5

but works with even the oldest browsers around:

<!DOCTYPE html>

The rest of the HTML document contains the actual content. An HTML document has two types of content:

the text and the elements (or tags) that tell the browser how to format it. The elements are easily recognizable,

because they are designated with angle brackets (< >). HTML defines elements for different levels of headings,

paragraphs, hyperlinks, italic and bold formatting, horizontal lines, and so on. For example, <h1>Some Text</h1>

uses the <h1> element. This element tells the browser to display Some Text in the Heading 1 style, which uses

a large, bold font. Similarly, <p>This is a sample web page.</p> creates a paragraph with one line of text.

The <head> element groups the header information together and includes the <title> element with the text that

appears in the browser window, while the <body> element groups together the actual document content that’s

displayed in the browser window.

Figure 1-1 shows this simple HTML page in a browser. Right now, this is just a fixed file (named

SampleWebPage.htm) that contains HTML content. It has no interactivity, doesn’t require a web server,

and certainly can’t be considered a web application.

Figure 1-1. Ordinary HTML

■ Tip You don’t need to master HTML to program ASP.NET web pages, although it’s certainly a good start.

For a quick introduction to HTML, refer to one of the excellent HTML tutorials on the Internet, such as

www.w3schools.com/html. You’ll also get a mini-introduction to HTML elements in Chapter 4.

re

5

HTML Forms

HTML 2.0 introduced the first seed of web programming with a technology called HTML forms. HTML forms

expand HTML so that it includes not only formatting tags but also tags for graphical widgets, or controls. These

controls include common ingredients such as drop-down lists, text boxes, and buttons. Here’s a sample web page

created with HTML form controls:

<!DOCTYPE html>

<html>

<head>

<title>Sample Web Page</title>

</head>

<body>

<form>

<input type="checkbox" />

This is choice #1<br />

<input type="checkbox" />

This is choice #2<br /><br />

<input type="submit" value="Submit" />

</form>

</body>

</html>

In an HTML form, all controls are placed between the <form> and </form> tags. The preceding example

includes two check boxes (represented by the <input type="checkbox"/> element) and a button (represented by

the <input type="submit"/> element). The <br /> element adds a line break between lines. In a browser, this page

looks like Figure 1-2.

Figure 1-2. An HTML form

CHAPTER 1 ■ The Big Picture

6

HTML forms allow web developers to design standard input pages. When the user clicks the Submit button

on the page shown in Figure 1-2, all the data in the input controls (in this case, the two check boxes) is patched

together into one long string of text and sent to the web server. On the server side, a custom application receives

and processes the data. In other words, if the user selects a check box or enters some text, the application finds

out about it after the form is submitted.

Amazingly enough, the controls that were created for HTML forms more than ten years ago are still the basic

foundation that you’ll use to build dynamic ASP.NET pages! The difference is the type of application that runs

on the server side. In the past, when the user clicked a button on a form page, the information might have been

e-mailed to a set account or sent to an application on the server that used the challenging Common Gateway

Interface (CGI) standard. Today you’ll work with the much more capable and elegant ASP.NET platform.

■ Note The latest version of the HTML language, HTML5, introduced a few new form controls for the first time

in the history of the language. For the most part, ASP.NET doesn’t use these, because they aren’t supported in all

browsers (and even the browsers that support them aren’t always consistent). However, ASP.NET will use optional

HTML5 frills, such as validation attributes (see Chapter 9), when they’re appropriate. That’s because browsers that

don't support these features can ignore them, and the page will still work.

ASP.NET

Early web development platforms had two key problems. First, they didn’t always scale well. As a result, popular

websites would struggle to keep up with the demand of too many simultaneous users, eventually crashing or

slowing to a crawl. Second, they provided little more than a bare-bones programming environment. If you

wanted higher-level features, such as the ability to authenticate users or read a database, you needed to write

pages of code from scratch. Building a web application this way was tedious and error-prone.

To counter these problems, Microsoft created higher-level development platforms—first ASP and then

ASP.NET. These technologies allow developers to program dynamic web pages without worrying about the

low-level implementation details. Even better, ASP.NET is stuffed full of sophisticated features, including tools

for implementing security, managing data, storing user-specific information, and much more. And amazingly

enough, it’s even possible to program an ASP.NET page without knowing anything about HTML (although a little

bit of HTML smarts will help you build your pages more quickly and effectively).

Server-Side and Client-Side Programming

ASP.NET is designed first and foremost as a server-side programming platform. That means that all ASP.NET

code runs on the web server. When the ASP.NET code finishes running, the web server sends the user the final

result—an ordinary HTML page that can be viewed in any browser.

Server-side programming isn’t the only way to make an interactive web page. Another option is client-side

programming, which asks the browser to download the code and execute it locally, on the client’s computer. Just

as there are a variety of server-side programming platforms, there are also various ways to perform client-side

programming, from snippets of JavaScript code that can be embedded right inside the HTML of a web page, to

plug-ins such as Adobe Flash and Microsoft Silverlight. Figure 1-3 shows the difference between the server-side

and client-side models.

CHAPTER 1 ■ The Big Picture

7

ASP.NET uses server-side programming to avoid several problems:

Isolation: Client-side code can’t access server-side resources. For example, a client￾side application has no easy way to read a file or interact with a database on the server

(at least not without running into problems with security and browser compatibility).

Security: End users can view client-side code. And once malicious users understand

how an application works, they can often tamper with it.

Thin clients: In today’s world, web-enabled devices such as tablets and smartphones

are everywhere. These devices usually have some sort of built-in web browsing

ability, but they may not support client-side programming platforms such as Flash or

Silverlight.

Server Client

Request a web page

Return an HTML document

Run

server-side

application

Run

client-side

application

Return an HTML document

(with embedded applet)

A Server-Side Web Application

A Client-Side Web Application

Request a web page

Client Server

Figure 1-3. Server-side and client-side web applications

CHAPTER 1 ■ The Big Picture

8

In recent years, there’s been a renaissance in client programming, particularly with JavaScript. Nowadays

developers create client-side applications that communicate with a web server to fetch information and perform

tasks that wouldn’t be possible if the applications were limited to the local computer. Fortunately, ASP.NET takes

advantage of this change in two ways:

JavaScript frills: In some cases, ASP.NET allows you to combine the best of client-side

programming with server-side programming. For example, the best ASP.NET controls

can “intelligently” detect the features of the client browser. If the browser supports

JavaScript, these controls will return a web page that incorporates JavaScript for a

richer, more responsive user interface. You’ll see a good example of this technique

with validation in Chapter 9.

ASP.NET’s Ajax features: Ajax is a set of JavaScript techniques used to create fast,

responsive pages with dynamic content. In Chapter 25, you’ll learn how ASP.NET lets

you benefit from many of the advantages of Ajax with none of the complexity.

However, it’s important to understand one fundamental fact. No matter what the capabilities of the browser,

the C# code that you write is always executed on the server. The client-side frills are just the icing on the cake.

■ Tip It’s worth noting that ASP.NET is not the best platform for writing complex, app-like client-side

programs—at least not on its own. For example, ASP.NET isn’t much help to developers who want to build a

real-time browser-based game or the next Google Maps. If this is what you want, it’s largely up to you to add the

huge amounts of complex JavaScript that you need to your ASP.NET web forms. However, if you’d prefer to create

an e-commerce hub or a business site, or a site that displays and manages large amounts of data, ASP.NET is

the perfect fit.

The .NET Framework

As you’ve already learned, the .NET Framework is really a cluster of several technologies:

The .NET languages: These include Visual Basic, C#, F#, and C++, although third-party

developers have created hundreds more.

The Common Language Runtime (CLR): This is the engine that executes all .NET

programs and provides automatic services for these applications, such as security

checking, memory management, and optimization.

The .NET Framework class library: The class library collects thousands of pieces of

prebuilt functionality that you can “snap in” to your applications. These features are

sometimes organized into technology sets, such as ADO.NET (the technology for

creating database applications) and Windows Presentation Foundation (WPF, the

technology for creating desktop user interfaces).

ASP.NET: This is the engine that hosts the web applications you create with .NET, and

supports almost any feature from the .NET Framework class library. ASP.NET also

includes a set of web-specific services, such as secure authentication and data storage.

Visual Studio: This optional development tool contains a rich set of productivity and

debugging features. Visual Studio includes the complete .NET Framework, so you

won’t need to download it separately.