ASP.NET 4.5入门指南：C#版

需积分: 10 152 浏览量更新于2024-07-23 收藏 19.22MB PDF 举报

" Beginning.ASP.NET.4.5.in.C# 是一本全面且最新的ASP.NET入门教程，专注于C#语言，由知名作者Matthew MacDonald撰写，旨在介绍ASP.NET 4.5技术的最新思想和最佳实践。本书适合没有编程经验的读者，从基础开始，教授成为有效ASP.NET开发人员所需的所有技能，包括布局、数据库查询、AJAX增强布局以及网站部署等。此外，还涵盖了调试和性能优化等高级主题，帮助读者自信地迈出成为成功ASP.NET开发者的第一步。" 本书详细讲解了构建ASP.NET 4.5应用程序所需的一切知识，提供了最深、最广泛的入门覆盖范围。作者将通过逐步进阶的方式，从基础概念到高级技巧，引导读者学习。无论是对.NET开发完全陌生的读者，还是希望深入理解ASP.NET 4.5工作原理的读者，这本书都是理想的选择。书中包含以下内容： 1. **第一章：整体概览** - 介绍.NET框架和ASP.NET 4.5的核心概念，为后续章节奠定基础。 2. **第二章：C#语言** - 学习C#编程语言的基础，包括语法、变量、控制结构等。 3. **第三章：类型、对象和命名空间** - 深入理解.NET中的对象模型和类型系统，以及如何组织代码。 4. **第四章：Visual Studio** - 学习使用Visual Studio作为开发环境，创建和管理ASP.NET项目。 5. **第五章：Web表单基础** - 探索Web表单的概念和工作原理。 6. **第六章：Web控件** - 了解各种内置Web控件的使用，如文本框、按钮和数据绑定控件。 7. **第七章：错误处理、日志记录和跟踪** - 学习如何在遇到问题时诊断和调试代码。 8. **第八章：状态管理** - 理解如何在Web环境中保持用户状态，如视图状态和会话状态。 9. **第九章：验证** - 实现表单验证，确保用户输入的数据有效和安全。 10. **第十章：富控件** - 使用Ajax和其他技术创建交互性强的Web界面。 11. **第十一章：用户控件和图形** - 创建自定义用户控件并添加图形元素。 12. **第十二章：样式、主题和母版页** - 统一网站外观，实现页面布局的重用。 13. **第十三章：网站导航** - 设计和实现网站的导航结构。 14. **第十四章：ADO.NET基础** - 学习如何与数据库进行交互，包括连接、查询和事务处理。 15. **第十五章：数据绑定** - 掌握将数据源与Web控件绑定的技术。通过这些章节，读者将能够构建功能丰富的ASP.NET Web应用程序，并具备解决实际问题的能力。此外，书中的示例和实践项目将帮助读者巩固理论知识，提升实际开发技能。

CHAPTER 1 ■ THE BIG PICTURE

Sometimes the division between these components isn’t clear. For example, the term ASP.NET is sometimes

used in a narrow sense to refer to the portion of the .NET class library used to design web pages. On the other

hand, ASP.NET also refers to the whole topic of .NET web applications, which includes .NET languages and many

fundamental pieces of the class library that aren’t web-speciﬁc. (at’s generally the way we use the term in this

book. Our exhaustive examination of ASP.NET includes .NET basics, the C# language, and topics that any .NET

developer could use, such as component-based programming and database access.)

Figure 1-4 shows the .NET class library and CLR—the two fundamental parts of .NET.

ADO.NET

Data Access

XML

Web Forms

File I/O

Core System Classes (Threading, Serialization, Reflection,

Collections, and So On)

The .NET Class Library

Compiler and Loader

Code Verification and Optimization

Memory Management and Garbage Collection

Code Access Security

(Other Managed Code Services)

The Common Language Runtime

Windows Forms

(And So On)

Figure 1-4. e .NET Framework

CHAPTER 1 ■ THE BIG PICTURE

In the remainder of this chapter, you’ll take a quick look at the ingredients that make up the .NET

Framework.

C#, VB, and the .NET Languages

is book uses the Visual Basic language, which enables you to create readable, modern code. e .NET version

of VB is similar in syntax to older ﬂavors of VB that you may have encountered, including “classic” VB 6 and the

Visual Basic for Applications (VBA) language often used to write macros in Microsoft Ofﬁce programs such as

Word and Excel. However, you cannot convert classic VB into the .NET ﬂavor of Visual Basic, just as you cannot

convert C++ into C#.

is book uses C#, Microsoft’s .NET language of preference. C# resembles Java, JavaScript, and C++ in

syntax, so programmers who have coded in one of these languages will quickly feel at home.

Interestingly, VB and C# are quite similar. ough the syntax is dierent, both VB and C# use the .NET class

library and are supported by the CLR. In fact, almost any block of C# code can be translated, line by line, into an

equivalent block of VB code (and vice versa). An occasional language dierence pops up, but for the most part,

a developer who has learned one .NET language can move quickly and efﬁciently to another. ere are even

software tools that translate C# and VB code automatically (see http://converter.telerik.com or

http://tangiblesoftwaresolutions.com for examples).

In short, both VB and C# are elegant, modern languages that are ideal for creating the next generation of web

applications.

Note ■ .NET 1.0 introduced completely new languages. However, the changes in subsequent versions of .NET

have been more subtle. Although the version of C# in .NET 4.5 adds a few new features, most parts of the

language remain unchanged. In Chapter 2 and Chapter 3, you’ll sort through the syntax of C# and learn the

basics of object-oriented programming.

Intermediate Language

All the .NET languages are compiled into another lower-level language before the code is executed. is lower-

level language is the Common Intermediate Language (CIL, or just IL). e CLR, the engine of .NET, uses only

IL code. Because all .NET languages are based on IL, they all have profound similarities. is is the reason that

the VB and C# languages provide essentially the same features and performance. In fact, the languages are so

compatible that a web page written with C# can use a VB component in the same way it uses a C# component,

and vice versa.

e .NET Framework formalizes this compatibility with something called the Common Language

Speciﬁcation (CLS). Essentially, the CLS is a contract that, if respected, guarantees that a component written in

one .NET language can be used in all the others. One part of the CLS is the common type system (CTS), which

deﬁnes the rules for data types such as strings, numbers, and arrays that are shared in all .NET languages. e

CLS also deﬁnes object-oriented ingredients such as classes, methods, events, and quite a bit more. For the most

part, .NET developers don’t need to think about how the CLS works, even though they rely on it every day.

Figure 1-5 shows how the .NET languages are compiled to IL. Every EXE or DLL ﬁle that you build with a

.NET language contains IL code. is is the ﬁle you deploy to other computers. In the case of a web application,

you deploy your compiled code to a live web server.

CHAPTER 1 ■ THE BIG PICTURE

Note ■ You might wonder why .NET compilers don’t compile straight to machine code. The reason is that the

machine code depends on several factors, including the CPU. If you compile an application to machine code on one

computer, there’s no guarantee that it will work on another computer with a different processor.

e Common Language Runtime

e CLR is the engine that supports all the .NET languages. All .NET code runs inside the CLR. is is true

whether you’re running a Windows application or a web service. For example, when a client requests an ASP.NET

web page, the ASP.NET service runs inside the CLR environment, executes your code, and creates a ﬁnal HTML

page to send to the client.

Not only does the CLR execute code, but it also provides a whole set of related services such as code

veriﬁcation, optimization, and object management. e implications of the CLR are wide-ranging:

Deep language integration: VB and C#, like all .NET languages, compile to IL. In other

words, the CLR makes no distinction between dierent languages—in fact, it has no

way of knowing what language was used to create an executable. is is far more than

mere language compatibility; it’s language integration.

Side-by-side execution: e CLR also has the ability to load more than one version of

a component at a time. In other words, you can update a component many times,

and the correct version will be loaded and used for each application. As a side eect,

multiple versions of the .NET Framework can be installed, meaning that you’re able to

upgrade to new versions of ASP.NET without replacing the current version or needing

to rewrite your applications.

Fewer errors: Whole categories of errors are impossible with the CLR. For example,

the CLR prevents many memory mistakes that are possible with lower-level languages

such as C++.

Along with these truly revolutionary beneﬁts, the CLR has some potential drawbacks. Here are two issues

that are sometimes raised by new developers but aren’t always answered:

Performance: A typical ASP.NET application is extremely fast, because ASP.NET code

is compiled to machine code before it’s executed. However, processor-crunching

algorithms still can’t match the blinding speed of well-written C++ code, because

the CLR imposes some additional overhead. Generally, this is a factor only in a few

performance-critical high-workload applications (such as real-time games). With

high-volume web applications, the potential bottlenecks are rarely processor-related

but are usually tied to the speed of an external resource such as a database or the web

server’s ﬁle system. With ASP.NET caching and some well-written database code, you

can ensure excellent performance for any web application.

Code transparency: IL is much easier to disassemble, meaning that if you distribute

a compiled application or component, other programmers may have an easier

time determining how your code works. is isn’t much of an issue for ASP.NET

applications, which aren’t distributed but are hosted on a secure web server.

CHAPTER 1 ■ THE BIG PICTURE

e .NET Class Library

e .NET class library is a giant repository of classes that provide prefabricated functionality for everything

from reading an XML ﬁle to sending an e-mail message. If you’ve had any exposure to Java, you may already be

familiar with the idea of a class library. However, the .NET class library is more ambitious and comprehensive

than just about any other programming framework. Any .NET language can use the .NET class library’s features

by interacting with the right objects. is helps encourage consistency among dierent .NET languages and

removes the need to install numerous components on your computer or web server.

Some parts of the class library include features you’ll never need to use in web applications (such as the

classes used to create desktop applications with Windows interfaces). Other parts of the class library are targeted

directly at web development. Still more classes can be used in various programming scenarios and aren’t speciﬁc

to web or Windows development. ese include the base set of classes that deﬁne common variable types and

the classes for data access, to name just a few. You’ll explore the .NET Framework throughout this book.

You can think of the class library as a well-stocked programmer’s toolkit. Microsoft’s philosophy is that it will

provide the tedious infrastructure so that application developers need only to write business-speciﬁc code. For

example, the .NET Framework deals with thorny issues such as database transactions and concurrency, making

sure that hundreds or thousands of simultaneous users can request the same web page at once. You just add the

logic needed for your speciﬁc application.

Visual Studio

e last part of .NET is the Visual Studio development tool, which provides a rich environment where you can

rapidly create advanced applications. Although in theory you could create an ASP.NET application without Visual

Studio (for example, by writing all the source code in a text editor and compiling it with .NET’s command-line

compilers), this task would be tedious, painful, and prone to error. For that reason, all professional ASP.NET

developers use a design tool such as Visual Studio.

Some of the features of Visual Studio include the following:

Page design: You can create an attractive page with drag-and-drop ease by using Visual

Studio’s integrated web form designer. You don’t need to understand HTML.

Automatic error detection: You could save hours of work when Visual Studio detects

and reports an error before you run your application. Potential problems are

underlined, just like the “spell-as-you-go” feature found in many word processors.

Debugging tools: Visual Studio retains its legendary debugging tools, which allow you

to watch your code in action and track the contents of variables. And you can test web

applications just as easily as any other application type, because Visual Studio has a

built-in web server that works just for debugging.

IntelliSense: Visual Studio provides statement completion for recognized objects and

automatically lists information such as function parameters in helpful tooltips.

You’ll learn about all these features in Chapter 4, when you consider the latest version of Visual Studio.

It’s also important to note that Visual Studio is available in several editions:

Visual Studio Express for Web: is is a completely free version of Visual Studio that’s

surprising capable. Its main limitation is that it allows you to build web applications

and components only, not other types of .NET programs (for example, Windows

applications).

剩余899页未读，继续阅读

theFates

粉丝: 2
资源: 27

ASP.NET 4.5入门指南：C#版

Wrox.Beginning.ASP.NET.4.5.in.Csharp.and.VB.Nov.2012

Apress.Beginning.ASP.NET4.5.in.C#.201

for {set ii 1} {$ii<=25} {incr ii} { puts "The $ii th Time history analysis is Beginning..............." if {[file exists outputBWPZ[expr $ii]]==0} { file mkdir outputBWPZ[expr $ii];请帮我解释并优化这段代码

jenkins pipeline when

查看kafka的topic数据

Field 'fileurl' doesn't have a default value in

pycharm使用kafka插件

python for beginning

const app = new Vue({

cobol语言编程入门

最新资源