深入理解Microsoft .NET框架编程

需积分: 10 88 浏览量更新于2024-07-28 收藏 10.66MB PDF 举报

“.net框架程序设计是针对已经掌握初级C# .NET开发技术的人群，旨在提升其在微软.NET框架下的编程能力的一本书。书中的内容涵盖了.NET框架的基础、架构、应用程序构建与部署等多个方面。” 在深入探讨.NET框架程序设计之前，我们先要理解.NET框架的核心组成部分。微软.NET倡议的核心包括一个底层操作系统——Windows，一系列有助于企业级服务的产品（如.NET企业服务器），以及微软XML Web服务，这些服务与.NET My Services紧密关联。最重要的是，这一切都建立在.NET框架之上，这是一个用于开发和执行应用程序的平台。同时，Visual Studio.NET作为开发环境，提供了强大的集成开发体验。本书的目标是帮助读者理解.NET框架的基本原理和操作，从架构层面到实际应用的构建、打包、部署和管理。首先，书中详细介绍了.NET框架的架构，包括将源代码编译成托管模块的过程，如何将这些模块组合成程序集，以及如何加载公共语言运行时（CLR）来执行程序集中的代码。IL（中间语言）和验证是这个过程中的关键环节，确保代码的安全性。此外，.NET框架类库是开发者的重要资源，它提供了一套通用的类型系统和公共语言规范，支持不同语言之间的互操作性，使得不同语言开发的应用程序能够无缝协作。接下来，书中转向了应用程序和类型的构建、包装、部署和管理。这部分内容概述了.NET框架部署的目标，旨在确保应用程序能够在各种环境中顺利运行。这包括构建过程，如何打包应用程序以便分发，以及如何在目标系统上安装和管理这些应用程序。管理员的角色在这里显得尤为重要，他们需要确保应用程序的正确配置和性能优化。通过深入学习本书，读者将能够掌握.NET框架的关键概念和技术，从而提升其在C# .NET开发中的专业技能，无论是在创建高效能的桌面应用，还是在构建分布式Web服务，都能得心应手。对于希望进一步提升.NET开发水平的初学者来说，这本书无疑是一份宝贵的资源。

Microsoft BizTalk Server 2000•

Microsoft Commerce Server 2000•

Microsoft Exchange 2000•

Microsoft Host Integration Server 2000•

Microsoft Internet Security and Acceleration (ISA) Server 2000•

Microsoft Mobile Information Server 2002•

Microsoft SQL Server 2000•

It’s likely that each of these products will eventually have a “.NET” added to its name for marketing

purposes. But I’m also sure that over time, these products will integrate more .NET features into

them as Microsoft continues the initiative.

Microsoft XML Web Services: .NET My Services

Certainly, Microsoft wants to do more than just provide the underlying technologies that allow others

to play in this new world. Microsoft wants to play too. So, Microsoft will be building its own set of

XML Web services: some will be free, and others will require some usage fee. Microsoft initially

plans to offer the following .NET My Services:

.NET Alerts•

.NET ApplicationSettings•

.NET Calendar•

.NET Categories•

.NET Contacts•

.NET Devices•

.NET Documents•

.NET FavoriteWebSites•

.NET Inbox•

.NET Lists•

.NET Locations•

.NET Presence•

.NET Profile•

.NET Services•

.NET Wallet•

These consumer−oriented XML Web services are known as Microsoft’s

“.NET My Services.” You can find out more information about them at

http://www.Microsoft.com/MyServices/. Over time, Microsoft will add many more consumer services

and will also be creating business−oriented XML Web services.

In addition to these public Web services, Microsoft will create internal services for sales data and

billing. These internal services will be accessible to Microsoft employees only. I anticipate that

companies will quickly embrace the idea of using Web services on their intranets to make internal

company information available to employees. The implementation of publicly available Internet Web

services and applications that consume them will probably proceed more slowly.

The Development Platform: The .NET Framework

Some of the Microsoft .NET My Services (like Passport) exist today. These services run on

Windows and are built using technologies such as C/C++, ATL, Win32, COM, and so on. As time

goes on, these services and new services will ultimately be implemented using newer technologies,

such as C# (pronounced “C sharp”) and the .NET Framework.

Important Even though this entire introduction has been geared toward building Internet

applications and Web services, the .NET Framework is capable of a lot more. All in all,

the .NET Framework development platform allows developers to build the following

kinds of applications: XML Web services, Web Forms, Win32 GUI applications, Win32

CUI (console UI) applications, services (controlled by the Service Control Manager),

utilities, and stand−alone components. The material presented in this book is applicable

to any and all of these application types.

The .NET Framework consists of two parts: the common language runtime (CLR) and the

Framework Class Library (FCL). The .NET Framework is the part of the initiative that makes

developing services and applications really easy. And, most important, this is what this book is all

about: developing applications and XML Web services for the .NET Framework.

Initially, Microsoft will make the CLR and FCL available in the various versions of Windows,

including Windows 98, Windows 98 Second Edition, and Windows Me as well as Windows NT 4,

Windows 2000, and both 32−bit and 64−bit versions of Windows XP and the Windows .NET Server

Family. A “lite” version of the .NET Framework, called the.NET Compact Framework, is also

available for PDAs (such as Windows CE and Palm) and appliances (small devices). On December

13, 2001, the European Computer Manufacturers Association (ECMA) accepted the C#

programming language, portions of the CLR, and portions of the FCL as standards. It won’t be long

before ECMA−compliant versions of these technologies appear on a wide variety of operating

systems and CPUs.

NoteWindows XP (both Home Edition and Professional) doesn’t ship with the .NET Framework “in

the box.” However, the Windows .NET Server Family (Windows .NET Web Server, Windows

.NET Standard Server, Windows .NET Enterprise Server, and Windows .NET Datacenter

Server) will include the .NET Framework. In fact, this is how the Windows .NET Server Family

got its name. The next version of Windows (code−named “Longhorn”) will include the .NET

Framework in all editions. For now, you’ll have to redistribute the .NET Framework with your

application, and your setup program will have to install it. Microsoft does make a .NET

Framework redistribution file that you’re allowed to freely distribute with your

application:http://go.microsoft.com/fwlink/?LinkId=5584.

Almost all programmers are familiar with runtimes and class libraries. I’m sure many of you have at

least dabbled with the C−runtime library, the standard template library (STL), the Microsoft

Foundation Class library (MFC), the Active Template Library (ATL), the Visual Basic runtime library,

or the Java virtual machine. In fact, the Windows operating system itself can be thought of as a

runtime engine and library. Runtime engines and libraries offer services to applications, and we

programmers love them because they save us from reinventing the same algorithms over and over

again.

The Microsoft .NET Framework allows developers to leverage technologies more than any earlier

Microsoft development platform did. Specifically, the .NET Framework really delivers on code reuse,

code specialization, resource management, multilanguage development, security, deployment, and

administration. While designing this new platform, Microsoft also felt it was necessary to improve on

some of the deficiencies of the current Windows platform. The following list gives you just a small

sampling of what the CLR and the FCL provide:

Consistent programming model Unlike today, where some operating system facilities are

accessed via dynamic−link library (DLL) functions and other facilities are accessed via COM

objects, all application services are offered via a common object−oriented programming

model.

•

Simplified programming model The CLR seeks to greatly simplify the plumbing and

arcane constructs required by Win32 and COM. Specifically, the CLR now frees the

developer from having to understand any of the following concepts: the registry, globally

unique identifiers (GUIDs), IUnknown, AddRef, Release, HRESULTs, and so on. The CLR

doesn’t just abstract these concepts away from the developer; these concepts simply don’t

exist, in any form, in the CLR. Of course, if you want to write a .NET Framework application

that interoperates with existing, non−.NET code, you must still be aware of these concepts.

•

Run once, run always All Windows developers are familiar with “DLL hell” versioning

problems. This situation occurs when components being installed for a new application

overwrite components of an old application, causing the old application to exhibit strange

behavior or stop functioning altogether. The architecture of the .NET Framework now

isolates application components so that an application always loads the components that it

was built and tested with. If the application runs after installation, then the application should

always run. This slams shut the gates of “DLL hell.”

•

Simplified deployment Today, Windows applications are incredibly difficult to set up and

deploy. Several files, registry settings, and shortcuts usually need to be created. In addition,

completely uninstalling an application is nearly impossible. With Windows 2000, Microsoft

introduced a new installation engine that helps with all these issues, but it’s still possible that

a company authoring a Microsoft installer package might fail to do everything correctly. The

.NET Framework seeks to banish these issues into history. The .NET Framework

components (known simply as types) are not referenced by the registry. In fact, installing

most .NET Framework applications requires no more than copying the files to a directory

and adding a shortcut to the Start menu, desktop, or Quick Launch bar. Uninstalling the

application is as simple as deleting the files.

•

Wide platform reach When compiling source code for the .NET Framework, the compilers

produce common intermediate language (CIL) instead of the more traditional CPU

instructions. At run time, the CLR translates the CIL into native CPU instructions. Because

the translation to native CPU instructions is done at run time, the translation is done for the

host CPU. This means that you can deploy your .NET Framework application on any

machine that has an ECMA−compliant version of the CLR and FCL running on it. These

machines can be x86, IA64, Alpha, PowerPC, and so on. Users will immediately appreciate

the value of this broad execution if they ever change their computing hardware or operating

system.

•

Programming language integration COM allows different programming languages to

interoperate with one another. The .NET Framework allows languages to be integrated with

one another so that you can use types of another language as if they are your own. For

example, the CLR makes it possible to create a class in C++ that derives from a class

implemented in Visual Basic. The CLR allows this because it defines and provides a

Common Type System (CTS) that all programming languages that target the CLR must use.

The Common Language Specification (CLS) describes what compiler implementers must do

in order for their languages to integrate well with other languages. Microsoft is itself

providing several compilers that produce code targeting the runtime: C++ with Managed

Extensions, C#, Visual Basic .NET (which now subsumes Visual Basic Scripting Edition, or

VBScript, and Visual Basic for Applications, or VBA), and JScript. In addition, companies

other than Microsoft and academic institutions are producing compilers for other languages

that also target the CLR.

•

Simplified code reuse Using the mechanisms described earlier, you can create your own

classes that offer services to third−party applications. This makes it extremely simple to

reuse code and also creates a large market for component (type) vendors.

•

Automatic memory and management (garbage collection) Programming requires great

skill and discipline, especially when it comes to managing the use of resources such as files,

memory, screen space, network connections, database resources, and so on. One of the

•

most common bugs is neglecting to free one of these resources, ultimately causing the

application to perform improperly at some unpredictable time. The CLR automatically tracks

resource usage, guaranteeing that your application never leaks resources. In fact, there is

no way to explicitly “free” memory. In Chapter 19, “Automatic Memory Management

(Garbage Collection),” I explain exactly how garbage collection works.

Type−safe verification The CLR can verify that all your code is type−safe. Type safety

ensures that allocated objects are always accessed in compatible ways. Hence, if a method

input parameter is declared as accepting a 4−byte value, the CLR will detect and trap

attempts to access the parameter as an 8−byte value. Similarly, if an object occupies 10

bytes in memory, the application can’t coerce the object into a form that will allow more than

10 bytes to be read. Type safety also means that execution flow will transfer only to

well−known locations (that is, method entry points). There is no way to construct an arbitrary

reference to a memory location and cause code at that location to start executing. Together,

these measures ensure type safety eliminating many common programming errors and

classic system attacks (for example, exploiting buffer overruns).

•

Rich debugging support Because the CLR is used for many programming languages, it is

now much easier to implement portions of your application using the language best suited to

a particular task. The CLR fully supports debugging applications that cross language

boundaries.

•

Consistent method failure paradigm One of the most aggravating aspects of Windows

programming is the inconsistent style that functions use to report failures. Some functions

return Win32 status codes, some functions return HRESULTs, and some functions throw

exceptions. In the CLR, all failures are reported via exceptions—period. Exceptions allow the

developer to isolate the failure recovery code from the code required to get the work done.

This separation greatly simplifies writing, reading, and maintaining code. In addition,

exceptions work across module and programming language boundaries. And, unlike status

codes and HRESULTs, exceptions can’t be ignored. The CLR also provides built−in

stack−walking facilities, making it much easier to locate any bugs and failures.

•

Security Traditional operating system security provides isolation and access control based

on user accounts. This model has proven useful, but at its core assumes that all code is

equally trustworthy. This assumption was justified when all code was installed from physical

media (for example, CD−ROM) or trusted corporate servers. But with the increasing reliance

on mobile code such as Web scripts, applications downloaded over the Internet, and e−mail

attachments, we need ways to control the behavior of applications in a more code−centric

manner. Code access security provides a means to do this.

•

Interoperability Microsoft realizes that developers already have an enormous amount of

existing code and components. Rewriting all this code to take full advantage of the .NET

Framework platform would be a huge undertaking and would prevent the speedy adoption of

this platform. So the .NET Framework fully supports the ability for the developer to access

their existing COM components as well as call Win32 functions in existing DLLs.

•

Users won’t directly appreciate the CLR and its capabilities, but they will certainly notice the quality

and features of applications that utilize the CLR. In addition, users and your company’s bottom line

will appreciate how the CLR allows applications to be developed and deployed more rapidly and

with less administration than Windows has ever allowed in the past.

The Development Environment: Visual Studio .NET

The last part of the .NET initiative that I want to mention is Visual Studio .NET. Visual Studio .NET is

Microsoft’s development environment. Microsoft has been working on it for many years and has

incorporated a lot of .NET FrameworkÐspecific features into it. Visual Studio .NET runs on Windows

NT 4, Windows 2000, Windows XP, and the Windows .NET Server Family servers, and it will run on

future versions of Windows. Of course, the code produced by Visual Studio .NET will run on all

these Windows platforms plus Windows 98, Windows 98 Second Edition, and Windows Me.

Like any good development environment, Visual Studio .NET includes a project manager; a source

code editor; UI designers; lots of wizards, compilers, linkers, tools, and utilities; documentation; and

debuggers. It supports building applications for both the 32−bit and 64−bit Windows platforms as

well as for the new .NET Framework platform. Another important improvement is that there is now

just one integrated development environment for all programming languages.

Microsoft also provides a .NET Framework SDK. This free SDK includes all the language compilers,

a bunch of tools, and a lot of documentation. Using this SDK, you can develop applications for the

.NET Framework without using Visual Studio .NET. You’ll just have to use your own editor and

project management system. You also don’t get drag−and−drop Web Forms and Windows Forms

building. I use Visual Studio .NET regularly and will refer to it throughout this book. However, this

book is mostly about programming in general, so Visual Studio .NET isn’t required to learn, use, and

understand the concepts I present in each chapter.

Goal of This Book

The purpose of this book is to explain how to develop applications for the .NET Framework.

Specifically, this means that I intend to explain how the CLR works and the facilities it offers. I’ll also

discuss various parts of the FCL. No book could fully explain the FCL—it contains literally

thousands of types, and this number is growing at an alarming rate. So, here I’m concentrating on

the core types that every developer needs to be aware of. And while this book isn’t specifically

about Windows Forms, XML Web services, Web Forms, and so on, the technologies presented in

the book are applicable to all these application types.

With this book, I’m not attempting to teach you any particular programming language. I’m assuming

that you’re familiar with a programming language such as C++, C#, Visual Basic, or Java. I also

assume that you’re familiar with object−oriented programming concepts such as data abstraction,

inheritance, and polymorphism. A good understanding of these concepts is critical because all .NET

Framework features are offered via an object−oriented paradigm. If you’re not familiar with these

concepts, I strongly suggest you first find a book that teaches these concepts.

Although I don’t intend to teach basic programming, I will spend time on various programming topics

that are specific to the .NET Framework. All .NET Framework developers must be aware of these

topics, which I explain and use throughout this book.

Finally, because this is a book about the .NET Framework’s common language runtime, it’s not

about programming in any one specific programming language. However, I provide lots of code

examples in the book to show how things really work. To remain programming language agnostic,

the best language for me to use for these examples would be IL (intermediate language) assembly

language. IL is the only programming language that the CLR understands. All language compilers

compile source code to IL, which is later processed by the CLR. Using IL, you can access every

feature offered by the CLR.

However, using IL assembly language is a pretty low−level way to write programs and isn’t an ideal

way to demonstrate programming concepts. So I decided to use C# as my programming language

of choice throughout this entire book. I chose C# because it is the language Microsoft designed

specifically for developing code for the .NET Framework. If you’ve decided not to use C# for your

programming projects, that’s OK—I’ll just assume that you can read C# even if you’re not

剩余441页未读，继续阅读

shiwencan

粉丝: 1
资源: 3

深入理解Microsoft .NET框架编程

Microsoft.NET框架程序设计(修订版)

Microsoft.NET框架程序设计(修订版)-中文版

Microsoft.NET框架程序设计

.NET框架跨平台开发

.net 框架和.net core 和 .net framework

vb.net程序设计 pdf 网盘

推荐几本与asp.net程序设计相关书籍

asp.net web开发环境搭建

.net 工控上位机 编程实践 pdf

teigha.net chm

最新资源

.net 工控上位机编程实践 pdf