英文文献及中文翻译_ASP.NET概述ASP.NETOverview

合集下载

ASP.NET是什么？

是什么？简介简单来说，是⼀个使⽤ HTML、CSS、JavaScript 和服务器脚本创建⽹页和⽹站的开发框架。

微软在2001年开发的第⼀个版本的，是⼀种建⽴在.NET之上的Web运⾏环境。

借助于，可以创造出内容丰富的、动态的、个性化的Web站点。

简单易学、功能强⼤、应⽤灵活、扩展性好，可以使⽤任何.NET兼容语⾔。

现在已经更新到4.7的版本了，但只能运⾏在Windows系统上，并不是跨平台的。

所以，微软后续⼜发布了的开源和跨平台版本的 Core（最新版已经更新到2.0）。

虽然⽬前最新技术是 Core，但作为 Core的基⽯，也并没有过时。

所以对于初学者来说，依然是⼀个不错的⼊门⽅向。

特点⼀.Web 控件提供了七⼤类 Web 控件，分别是：1. ⽤于处理静态和动态数据的标准控件2. ⽤于显⽰来⾃数据源控件中指定的数据源数据的数据控件3. ⽤于各种不同类型验证的验证控件4. ⽤于在⽹页上创建菜单和其他导航辅助⼯具的导航控件5. ⽤于为 Web 应⽤程序提供可靠完整且⽆需编程的登录控件6. 使⽤户能够动态地对 Web 应⽤程序进⾏个性化设置的 Web 部件控件7. 在异步回发过程中进⾏部分页更新的 AJAX控件除此之外，还可以使⽤由开发⼈员或第三⽅软件供应商创建的⾃定义的控件。

有了这些控件，会⼤⼤降低开发⼈员的⼯作量。

例如使⽤GridView绑定数据，不⽤再写⼀套复杂的增删改查逻辑，只需要简单⼏步设置就能将数据绑定到控件上，省去了编写⼤量代码的时间。

开发⼈员甚⾄⽆需了解太多的编码知识，只需要将组件拖拉，组合，设计，就能快速开发出⼀个⽹页。

⼆.设计和代码分离采⽤了代码后置技术，将Web界⾯元素和程序逻辑分开显⽰，这样可以使代码更清晰，有利于阅读和维护。

三.⽀持服务器脚本语⾔使⽤⼀种服务端脚本技术（Razor），将服务器端代码同HTML代码结合起来，在⽹页返回给浏览器之前，基于服务器的代码可以创建动态的内容，并且可以运⾏更复杂的任务，使Web开发更加⾼效。

旅行社管理系统中英文对照外文翻译文献

中英文对照外文翻译(文档含英文原文和中文翻译) Overview is a unified Web development model that includes the services necessary for you to build enterprise-class Web applications with a minimum of coding. is part of the .NET Framework, and when coding applications you have access to classes in the .NET Framework. You can code your applications in any language compatible with the common language runtime (CLR), including Microsoft Visual Basic, C#, JScript .NET, and J#. These languages enable you to develop applications that benefit from the common language runtime, type safety, inheritance, and so on. includes:• A page and controls framework•The compiler•Security infrastructure•State-management facilities•Application configuration•Health monitoring and performance features•Debugging support•An XML Web services framework•Extensible hosting environment and application life cycle management•An extensible designer environmentThe page and controls framework is a programming framework that runs on a Web server to dynamically produce and render Web pages. Web pages can be requested from any browser or client device, and renders markup (such as HTML) to the requesting browser. As a rule, you can use the same page for multiple browsers, because renders the appropriate markup for the browser making the request. However, you can design your Web page to target a specific browser, such as Microsoft Internet Explorer 6, and take advantage of the features of that browser. supports mobile controls for Web-enabled devices such as cellular phones, handheld computers, and personal digital assistants (PDAs). Web pages are completely object-oriented. Within Web pages you can work with HTML elements using properties, methods, and events. The page framework removes the implementation details of the separation of client and server inherent in Web-based applications by presenting a unified model for responding to client events in code that runs at the server. The framework also automatically maintains the state of a page and the controls on that page during the page processing life cycle.The page and controls framework also enables you to encapsulate common UI functionality in easy-to-use, reusable controls. Controls are written once, can be used in many pages, and are integrated into the Web page that they are placed in during rendering.The page and controls framework also provides features to control the overall look and feel of your Web site via themes and skins. You can define themes and skins and then apply them at a page level or at a control level.In addition to themes, you can define master pages that you use to create a consistent layout for the pages in your application. A single master page defines the layout and standard behavior that you want for all the pages (or a group of pages) in your application. You can then create individual content pages that contain the page-specific content you want to display. When users request the content pages, they merge with the master pageto produce output that combines the layout of the master page with the content from the content page.All code is compiled, which enables strong typing, performance optimizations, and early binding, among other benefits. Once the code has been compiled, the common language runtime further compiles code to native code, providing improved performance. includes a compiler that will compile all your application components including pages and controls into an assembly that the hosting environment can then use to service user requests.In addition to the security features of .NET, provides an advanced security infrastructure for authenticating and authorizing user access as well as performing other security-related tasks. You can authenticate users using Windows authentication supplied by IIS, or you can manage authentication using your own user database using forms authentication and membership. Additionally, you can manage the authorization to the capabilities and information of your Web application using Windows groups or your own custom role database using roles. You can easily remove, add to, or replace these schemes depending upon the needs of your application. always runs with a particular Windows identity so you can secure your application using Windows capabilities such as NTFS Access Control Lists (ACLs), database permissions, and so on. For more information on the identity of , provides intrinsic state management functionality that enables you to store information between page requests, such as customer information or the contents of a shopping cart. You can save and manage application-specific, session-specific,page-specific, user-specific, and developer-defined information. This information can be independent of any controls on the page. offers distributed state facilities, which enable you to manage state information across multiple instances of the same application on one computer or on several computers. applications use a configuration system that enables you to define configuration settings for your Web server, for a Web site, or for individual applications. You can make configuration settings at the time your applications are deployed and can add or revise configuration settings at any time with minimal impact on operational Web applications and servers. configuration settings are stored in XML-based files. Because these XML files are ASCII text files, it is simple to make configuration changes to your Web applications. You can extend the configuration scheme to suit your requirements. includes features that enable you to monitor health and performance of your application. health monitoring enables reporting of key events that provide information about the health of an application and about error conditions. These events show a combination of diagnostics and monitoring characteristics and offer a high degree of flexibility in terms of what is logged and how it is logged. supports two groups of performance counters accessible to your applications: •The system performance counter group•The application performance counter group takes advantage of the run-time debugging infrastructure to provide cross-language and cross-computer debugging support. You can debug both managed and unmanaged objects, as well as all languages supported by the common language runtime and script languages.In addition, the page framework provides a trace mode that enables you to insert instrumentation messages into your Web pages. supports XML Web services. An XML Web service is a component containing business functionality that enables applications to exchange information across firewalls using standards like HTTP and XML messaging. XML Web services are not tied to a particular component technology or object-calling convention. As a result, programs written in any language, using any component model, and running on any operating system can access XML Web services. includes an extensible hosting environment that controls the life cycle of an application from when a user first accesses a resource (such as a page) in the application to the point at which the application is shut down. While relies on a Web server (IIS) as an application host, provides much of the hosting functionality itself. The architecture of enables you to respond to application events and create custom HTTP handlers and HTTP modules. includes enhanced support for creating designers for Web server controls for use with a visual design tool such as Visual Studio. Designers enable you to build a design-time user interface for a control, so that developers can configure your control's properties and content in the visual design tool.Introduction to the C# Language and the .NET Framework C# is an elegant and type-safe object-oriented language that enables developers to build a wide range of secure and robust applications that run on the .NET Framework. You can use C# to create traditional Windows client applications, XML Web services, distributed components,client-server applications, database applications, and much, much more. Microsoft Visual C# 2005 provides an advanced code editor, convenient user interface designers, integrated debugger, and many other tools to facilitate rapid application development based on version 2.0 of the C# language and the .NET Framework.NoteThe Visual C# documentation assumes that you have an understanding of basic programming concepts. If you are a complete beginner, you might want to explore Visual C# Express Edition, which is available on the Web. You can also take advantage of any of several excellent books and Web resources on C# to learnpractical programming skills.C# syntax is highly expressive, yet with less than 90 keywords, it is also simple and easy to learn. The curly-brace syntax of C# will be instantly recognizable to anyone familiar with C, C++ or Java. Developers who know any of these languages are typically able to begin working productively in C# within a very short time. C# syntax simplifies many of the complexities of C++ while providing powerful features such as nullable value types, enumerations, delegates, anonymous methods and direct memory access, which are not found in Java. C# also supports generic methods and types, which provide increased type safety and performance, and iterators, which enable implementers of collection classes to define custom iteration behaviors that are simple to use by client code.As an object-oriented language, C# supports the concepts of encapsulation, inheritance and polymorphism. All variables and methods, including the Main method, the application's entry point, are encapsulated within class definitions. A class may inherit directly from one parent class, but it may implement any number of interfaces. Methodsthat override virtual methods in a parent class require the override keyword as a way to avoid accidental redefinition. In C#, a struct is like a lightweight class; it is astack-allocated type that can implement interfaces but does not support inheritance.In addition to these basic object-oriented principles, C# facilitates the development of software components through several innovative language constructs, including: •Encapsulated method signatures called delegates, which enable type-safe event notifications.•Properties, which serve as accessors for private member variables. •Attributes, which provide declarative metadata about types at run time.•Inline XML documentation comments.If you need to interact with other Windows software such as COM objects or native Win32 DLLs, you can do this in C# through a process called "Interop." Interop enables C# programs to do just about anything that a native C++ application can do. C# even supports pointers and the concept of "unsafe" code for those cases in which direct memory access is absolutely critical.The C# build process is simple compared to C and C++ and more flexible than in Java. There are no separate header files, and no requirement that methods and types be declared in a particular order. A C# source file may define any number of classes, structs, interfaces, and events.C# programs run on the .NET Framework, an integral component of Windows that includes a virtual execution system called the common language runtime (CLR) and a unified set of class libraries. The CLR is Microsoft's commercial implementation of the common language infrastructure (CLI), an international standard that is the basis for creating execution and development environments in which languages and libraries work together seamlessly.Source code written in C# is compiled into an intermediate language (IL) that conforms to the CLI specification. The IL code, along with resources such as bitmaps and strings, is stored on disk in an executable file called an assembly, typically with an extension of .exe or .dll. An assembly contains a manifest that provides information on the assembly's types, version, culture, and security requirements.When the C# program is executed, the assembly is loaded into the CLR, which might take various actions based on the information in the manifest. Then, if the security requirements are met, the CLR performs just in time (JIT) compilation to convert the IL code into native machine instructions. The CLR also provides other services related to automatic garbage collection, exception handling, and resource management. Code that is executed by the CLR is sometimes referred to as "managed code," in contrast to "unmanaged code" which is compiled into native machine language that targets a specific system. The following diagram illustrates the compile-time and run time relationships of C# source code files, the base class libraries, assemblies, and the CLR.Language interoperability is a key feature of the .NET Framework. Because the IL code produced by the C# compiler conforms to the Common Type Specification (CTS), IL code generated from C# can interact with code that was generated from the .NET versions of Visual Basic, Visual C++, Visual J#, or any of more than 20 otherCTS-compliant languages. A single assembly may contain multiple modules written in different .NET languages, and the types can reference each other just as if they were written in the same language.In addition to the run time services, the .NET Framework also includes an extensive library of over 4000 classes organized into namespaces that provide a wide variety of useful functionality for everything from file input and output to string manipulation to XML parsing, to Windows Forms controls. The typical C# application uses the .NET Framework class library extensively to handle common "plumbing" chores. 概述是一个统一的 Web 开发模型，它包括您使用尽可能少的代码生成企业级 Web 应用程序所必需的各种服务。

物业管理系统论文中英文对照资料外文翻译文献

外文翻译原文1 2.0 Web Pages and Web Controls U ntil now, all of the example applications in this text have focused on console-based and Windows Forms front ends. In this chapter and the next, you’ll explore how the .NET platform facilitates the construction of browser-based presentation layers. To begin, you’ll quickly review a number of key web-centric concepts (HTTP, HTML, client-side, and server-side script) and the role of the web server (including the development server, WebDev.WebServer.exe).With this web primer out of the way, the remainder of this chapter concentrates on the composition of (including the enhanced code-behind model) and how to work with web controls. As you will see, ASP.NE T 2.0 provides a number of new web controls, a new “master page”model, and various customization techniques.The Role of HTTPWeb applications are very different animals from traditional desktop applications (to say the least).The first obvious difference is that a production-level web application will always involve at least two networked machines (of course, during development it is entirely possible to have a single machine play the role of both client and server). Given this fact, the machines in question must agree upon a particular wire protocol to determine how to send and receive data. The wire protocol that connects the computers in question is the Hypertext Transfer Protocol (HTTP).When a client machine launches a web browser (such as Netscape Navigator, Mozilla Firefox,or Microsoft Internet Explorer), an HTTP request is made to access a particular resource (such as an *.aspx or *.htm file) on the remote server machine. HTTP is a text-based protocol that is built upon a standardrequest/response paradigm. For example, if you navigate to www. , the browser software leverages a web technology termed Domain Name Service (DNS) that converts the registered URL into a four-part, 32-bit numerical value (aka an IP address). At this point, the browser opens a socket connection (typically via port 80) and sends the HTTP request for the default page at the website.Once the hosting web server receives the incoming HTTP request, the specified resource may contain logic that scrapes out any client-supplied input values (such as values within a text box) in order to format a proper HTTP response. Web programmers may leverage any number of technologies (CGI, ASP, , Java servlets, etc.) to dynamically generate the content to be emitted into the HTTP response. At this point, the client-side browser renders the HTML emitted from the web server.Another aspect of web development that is markedly different from traditional desktop programming is the fact that HTTP is an essentially stateless wire protocol. As soon as the web server emits a response to the client, everything about the previous interaction is forgotten. Therefore, as a web developer, it is up to you take specific steps to “remember” information (s uch as items in a shopping cart) about the clients who are currently logged on to your site. As you will see in the next chapter, provides numerous ways to handle state, many of which are commonplace to any web platform (session variables, cookies, and application variables) as well as some new techniques (view state, control state, and the cache).Understanding Web Applications and Web ServersA web application can be understood as a collection of files (*.htm, *.asp, *.aspx, image files, etc.) and related components (such as a .NET code library) stored within a particular set of directories on a given web server. As shown in Chapter 24, web applications have a specific life cycle and provide numerous events (such as initial startup or final shutdown) that you can hook into.A web server is a software product in charge of hosting your web applications, and it typically provides a number of related services such as integrated security, File Transfer Protocol (FTP) support, mail exchange services, and so forth. Internet Information Server (IIS) is Microsoft’s enterprise-level web server product, and as you would guess, it has intrinsic support for classic ASP as well as web applications.When you build web applications, you will often need to interact with IIS. Be aware, however, that IIS is not automatically selected when you install the Windows Server 2003 or WindowsXP Professional Edition (you can’t install IIS on the Home editions of Windows). Therefore, depending on the configuration of your development machine, you may be required to manually install IIS before proceeding through this chapter. To do so, simply access the Add/Remove Program applet from the Control Panel folder and select Add/Remove Windows Components.Working with IIS Virtual DirectoriesA single IIS installation is able to host numerous web applications, each of which resides in a virtual directory. Each virtual directory is mapped to a physical directory on the local hard drive. Therefore,if you create a new virtual directory named CarsRUs, the outside world can navigate to this site using a URL such as (assuming your site’s IP address has been registered with the world at large). Under the hood, the virtual directory maps to a physical root directory such as C:\inetpub\wwwroot\AspNetCarsSite, which contains the content of the web application.When you create web applications using Visual Studio 2005, you have the option of generating a new virtual directory for the current website. However, you are also able to manually create a virtual directory by hand. For the sake of illustration, assume you wish to create a simple web application named Cars. The first step is to create a new folder on your machine to hold the collection of files that constitute this new site (e.g., C:\CodeTests\CarsWebSite).Next, you need to create a new virtual directory to host the Cars site. Simply right-click the Default Web Site node of IIS and select New ➤Virtual Directory from the context menu. This menu selection launches an integrated wizard. Skip past the welcome screen and give your website a name (Cars). Next, you are asked to specify the physical folder on your hard drive that contains the various files and images that represent this site (in this case, C:\CodeTests\CarsWebSite).The final step of the wizard prompts you for some basic traits about your new virtual directory (such as read/write access to the files it contains, the ability to view these files from a web browser, the ability to launch executables [e.g., CGI applications], etc.). For this example, the default selections are just fine (be aware that you can always modify your selections after running this tool using variousright-click Property dialog boxes integrated within IIS). 2.0网页和Web控件到现在为止，本书的示例应用程序主要集中在控制台和基于Windows窗体前端。

关于ASP文献综述

基于.NET平台的电力设备管理系统1前言电力建设是国民经济发展中一项重要、复杂的系统工程。

近年来国家一直投入巨资进行的大规模城乡电网改造，无疑显示出了电网建设的重要性，随着电力建设的飞速发展和电力体制改革的不断深入，传统的管理模式和管理方法越来越凸现出其自身的诸多弊端，其中电力设备的管理作为电力系统运行的重要环节，它的发展与现代化对整个电力的发展起着至关重要的作用，但是，由于电力设备数量多、分布地域广、受自然环境和人为因素影响的机会比较多，因此在运行管理工作中存在许多困难。

基于.NET平台的电力设备管理系统是适应当前电力行业设备管理和生产管理需要的信息系统，从而起到充分发挥现有各种信息资源的作用，达到管理行为规范化、管理制度流程化、管理结果信息化，管理手段现代化的最终目的。

2主题平台概述ASP指Active Server Pages（动态服务器页面）。

是新一代Web应用程序开发平台，它为用户提供了完整的可视化开发环境，它利用普通语言CLR运行时（Common Language Runtime）在服务器后端为用户提供建立强大的企业级Web应用服务的编程框架。

ASP．NET是建立在．NET Frame之上，使用Visual Basic、C#这样模块化程序设计语言。

它要第一次使用时进行编译，之后的执行不需要重新编译就可以直接运行，所以速度和效率比ASP提高很多。

同时它还具有代码的可重用性、可维护性和代码量相对较少等诸多优点。

ASP．NET不仅仅是下一版本的Active Senver Page(ASP)；它是统一的Web开发平台，用来提供开发人员快速生成企业级web 应用程序，所需的服务ASP．NET的语法在很大程度上与ASP兼容。

由于ASP本身的局限性使得系统有一些不可克服的缺陷，而采取了ASP．NET技术的系统性能上有了很大的改善：1)ASP．NET页面只需要一次编译后不需要重新编译，直到该页面被修改或WEB应用程序重新启动，极大提升多次访问时的速度；2)ASP．NET通过ADO．NET 提供的DataGrid等数据库元件可以直接和数据库联系；3)ASP．NET采取“code —behind”方式编写代码使得代码易于编写，结构更清晰，降低了系统的开发与维护的复杂度和费用。

asp.net外文文献+翻译

技术1.构建页面和结构是微软.NET framework整体的一部分, 它包含一组大量的编程用的类，满足各种编程需要。

在下列的二个部分中, 你如何学会很适合的放在.NET framework, 和学会能在你的页面中使用语言。

.NET类库假想你是微软。

假想你必须支持大量的编程语言-比如Visual Basic 、C# 和C++. 这些编程语言的很多功能具有重叠性。

举例来说，对于每一种语言，你必须包括存取文件系统、与数据库协同工作和操作字符串的方法。

此外，这些语言包含相似的编程构造。

每种语言,举例来说，都能够使用循环语句和条件语句。

即使用Visual Basic 写的条件语句的语法不与用C++ 写的不一样,程序的功能也是相同的。

最后，大多数的编程语言有相似的数据变量类型。

以大多数的语言，你有设定字符串类型和整型数据类型的方法。

举例来说，整型数据最大值和最小值可能依赖语言的种类，但是基本的数据类型是相同的。

对于多种语言来说维持这一功能需要很大的工作量。

为什么继续再创轮子? 对所有的语言创建这种功能一次，然后把这个功能用在每一种语言中岂不是更容易。

.NET类库不完全是那样。

它含有大量的满足编程需要的类。

举例来说，.NET类库包含处理数据库访问的类和文件协同工作，操作文本和生成图像。

除此之外，它包含更多特殊的类用在正则表达式和处理Web协议。

.NET framework，此外包含支持所有的基本变量数据类型的类，比如：字符串、整型、字节型、字符型和数组。

最重要地, 写这一本书的目的, .NET类库包含构建的页面的类。

然而你需要了解当你构建.NET页面的时候能够访问.NET framework 的任意类。

理解命名空间正如你猜测的, .NET framework是庞大的。

它包含数以千计的类(超过3,400) 。

幸运地，类不是简单的堆在一起。

.NET framework的类被组织成有层次结构的命名空间。

计算机科学与技术英文文献

Introduction to DevelopmentTo overcome the performance and scalability problems that CGI brings, Microsoft developed a new way for developers to build scalable applications. This high performance alternative is called the Internet Server Application Programming Interface(ISAPI). Instead of housing functionality in executable files, ISAPI uses DLLs. Using DLLs instead of executable programs has some definite performance and scalability advantages The ISAPI extension could also be called with arguments that will allow a single ISAPI extension to perform multiple tasks. Just as in the CGI example, the directory must have execute permissions enabled, or the DLL will be downloaded to the client rather than run on the server. ISAPI extensions are typically used to process client requests and output a response as HTML, which is very similar to the way CGI programs are used.ISAPI filters perform a function that can’t be directly duplicated with CGI applications. ISAPI filters are never explicitly called; instead, they are called by IIS in response to certain events in the life of a request. The developer can request that an ISAPI filter be called whenever any of the following events occur:1．When the server has preprocessed the client headers2．When the server authenticates the client3．When the server is mapping a logical URL to a physical URL4．Before raw data is sent from the client to the server5．After raw data is sent from the client to the server but before the server processes it 6．When the server logs information7．When the session is endingAs with any filter, ISAPI filters should request only the notifications it requires and process them as quickly as possible. One of the more common uses of ISAPI filters is to provide custom authentication. Another use is to modify the HTML that will be sent to the client. For example, an ISAPI filter could be used to change the background color of each page. Because ISAPI filters aren’t nearly as common as ISAPI extensions, I won’t cover them any further in this book. If you want to learn more about ISAPI extensions, you can check out my book Inside Server-Based Applications (Microsoft Press, 1999).ISAPI specifies several entry-point functions that must be exported from the DLL. Using these entry points, IIS can load the DLL; call the functions that it implements, passing in parameters as required; and receive the data to write back to the browser. ISAPI requires only two entry-point functions to be implemented these entry points, IIS can load the DLL;call the functions that it implements, passing in parameters as required; and receive the data to write back to the browser. ISAPI requires only two entry-point functions to be implementedA Better Solution: Active Server PagesIf you’re wondering why we’ve dwelt on th e alternatives to in a book about programming , the answer lies in the details of the implementation of and its predecessor, Active Server Pages (ASP). Understanding ISAPI is required for adept understanding of ASP and thus .During the beta of IIS 2.0, which became part of Windows NT 4.0, Microsoft introduced a new technology initially codenamed “Denali.” This was during Microsoft’s “Active” period and so the technology was eventually named Active Server Pages, or ASP. Several versions of have been released, most notably the versions included with Windows NT 4.0 Option Pack (ASP 2.0 and IIS 4.0) and Windows 2000 (ASP 3.0 and IIS 5.0). For the purposes of this discussion, I’ll consider ASP as a whole, without referring t o version differences became an instant hit, in large part because it made something that was difficult(create dynamic Web content) relatively easy. Creating CGI applications and ISAPI applications wasn’t terribly difficult, but using ASP was much simpler By default, ASP uses VBScript. Literally millions of developers are at least somewhat familiar with Visual Basic, Visual Basic for Applications (VBA), or VBScript. For these developers, ASP was the way to enter the Internet age. Certainly the developers could have learned a new programming language, but they didn’t have to with ASP. Partly because of its use of VBScript, ASP became a viable way to build Web applications.Just as important was the relatively easy access to databases allowed through Microsoft ActiveX Data Objects (ADO). When you need to generate dynamic content, that dynamic content obviously needs to come from somewhere, and ADO made it easy to get at that data.Finally, and perhaps most important, the development model allowed developers to essentially write code and run it. There was no need to perform compilation or elaborate installation steps. the architects were careful to capture this same development model, even though what’s going on under the covers is quite a bit different.A New Solution: When version 3.0 of was released along with Windows 2000, it became clearer that the future of software development was closely tied to the future of the Web. As part of its .NET initiative, Microsoft has introduced , a new version of ASP that retains the model of development ASP developers have come to know and love: youcan create the code and place it in the correct directory with the proper permissions, and it will just work. also introduces innovations that allow easier separation of the development of the core of an application and its presentation. adds many features to and enhances many of the capabilities in classic isn’t merely an incremental improvement to ASP; it’s really a completely new product, albeit a new product designed to allow the same development experience that ASP developers have enjoyed. Here are some of the notable features of : .NET Framework: The .NET Framework is an architecture that makes it easier to design Web and traditional applications.Common language runtime: The common language runtime provides a set of services for all languages. If you’re an ASP developer who has had to combine ASP scripting with COM objects, you’ll apprecia te the beauty of a common set of types across many languages.Compiled languages: provides enhanced performance through the use of compiled languages. Compiled languages allow the developer to verify that code is at least syntactically correct. ASP doesn’t provide any such facility, so simple syntax errors might not be caught until the first time the code is executed.Cool new languages Visual Basic: .NET is a completely new version of Visual Basic that provides a new, cleaner syntax. C# is a new language designed to look and feel a lot like C++, but without some of the unsafe features that make C++ difficult to use to create reliable applications. These two languages are available out of the box, but other languages will be available from third parties as well. As of this writing, COBOL and Eiffel implementations should be available for Visual Studio .NET as well.Visual Studio .NET: Visual Studio .NET is a cool new development environment that brings rapid application development (RAD) to the server.Improved components: The .NET Framework supports the use of new types of components that can be conveniently replaced in a running application.Web Forms: Web Forms allow Visual Basic–like development, with event handlers for common HTML widgets.XML Web services: XML Web services enable developers to create services and then make them available using industry standard protocols.: ADO for the .NET Framework is a new version of the technology that allows applications to more conveniently get at data residing in relational databases and in other formats, such as Extensible Markup Language (XML.) ConclusionThis brief history of Web development should provide you with a foundation as youcontinue reading about . Learning a programming language or development environment is much like learning a human language. Although books that cover the syntax and vocabulary are helpful, it’s often just as useful to understand the history of the people who use the language.If you’re an develope r, much of this chapter might be a review for you, but I hope that you’ve added something to your understanding of the history of . If you’re new to ASP and , understanding the history of ASP and what came before it will be useful as you begin to explore the exciting new technologies that make up .About Active Server Aside from the burden is not only (ASP) version of the next; It also provides a unified Web development models, including the development of enterprise-class Web applications generated personnel for the various services. grammar largely compatible with ASP, it also provides a new programming model and structure, flexibility and stability can produce better applications, and to provide better security protection. Through the existing ASP applications, gradually add functions to enhance ASP applications functions.When building applications, developers can use Web or XML Web services, or in any manner they deemed appropriate portfolio. Each functional access to the same support structure, so that you can use as a certification program, buffer frequently used data, or configuration of applications for self definition, only listed a few possibilities here.Y ou can use Web-based generation of powerful the Web page. These generated pages, can be used to build public complaints server UI elements, and programming for the implementation of their common task. Y ou can use these complaints to the building or from reusable components generated Web definition, thus simplifying the code page. For more information, please see Web pages. XML Web services provide a means of remote access server functions. Use XML Web services, enterprises can open data or business logic programming interface, and client-server applications and can acquire and operate these programming interfaces. Through the use of information such as web and XML standards such as the transmission of data across mobile firewall, XML Web services to customers - in-server or server-server programmed for data exchange. XML Web services without relying on specific components or technology transfer targets agreed. Therefore, the use of any language, using any component model, operating system and in any operating procedures can visit XML Web services. and. Net Framework version 1.1 installed, as each part of the Windows Server 2003 series products. Y ou can add it through the control panels for the newprocedures, or use "of your server guide" opening it. In addition, according to this theme later introduced "with Windows XP Professional or Windows 2000 Server computer installed " process downloading 1.0. Installed Visual Studio. Net will also install 1.0.Use "of your server guide," in the operation of the Windows Server 2003 server installed .In the mission column, hit "start" button and then hit the "management of your servers," in the "management of your servers" window, hit "Add or remove players."In the "configuration of your server guide", hit the "next step" in the "server roles", selected "application servers (IIS, )," and then hit "next". "applications server option", hit the "opening " of, hit the "next" and then hit "next". If necessary, inserted in CD-ROM drive Windows Server 2003 installation CD, and then hit the "next step." Installation completed, hit the "completion."The use of "add / delete process" in operating the Windows Server 2003 server installed . In the mission column, hit "start" button, pointing to "control panels" and then hit the "add or delete procedures." "Windows components guides," "components" box, hit the "application server" of, then hit the "next step." When the "Windows components guides" configuration End Windows Server 2003, hit the "completion."In Windows Server 2003 series products in China by opening Server ManagementColumn in the mission, hit "start" button and then hit the "operation." In the "operation open" box, the importation and then hit "determined." ."Server management machine", a "local computer" and then hit "Web service expansion." Panes right, hit "" and then hit "allowed." state then changed to "allow".In operation running Windows XP Professional or Windows 2000 computer, download and install . If necessary, install and start IIS. On the installation, please refer to the operating system files. At /downloads/default.asp, a "Software Development Kits" (software development kits), hit the "Microsoft. net Framework SDK, "and then read the page on the SDK download requests, notes and choice. Hit for download option, and read the end-user licensing agreements, and then hit the "yes" (is). "document downloaded", download options to preserve documents, the choice to install procedures and documents downloaded to personal tale of folder, and then hit the "preservation". Check up on the latest personal tale of any document. Download documents located in the folder, Net Framework installation procedures Setup.exe.If you have IIS installed and activated, the installation of and. Net Framework, deployed applications and requests a page, but received one of the followingerror message, indicating the Web site has not been for the establishment of an appropriate authority or directory :"C:\Inetpub\Wwwroot" catalogue visit was denied. Failure to start monitoring directory changes. Server applications to visit catalogue "C:\Inetpub\Wwwroot\ Virtual Directory Name \". The catalogue does not exist or could not be visited for security establishment.At root Web site or any virtual directory, needs account (Aspnet_wp.exe process account) the retrieval, delivery and set limits. These must be installed, can visit the contents of documents and surveillance document changes. Requests the Executive next steps corrected the problem.Web site or virtual directory in the root of adding account retrieval, delivery and competence listedIn Windows resources management devices, to browse Web sites containing roots(acquiescence to the establishment of : C:\Inetpub\Wwwroot) or the virtual directory folder. In the "safe" choice card, hit "Add". Import Computer Name \ASPNET (for example, in the computer named Web imported Web\ASPNET), and then hit "determined." Allow account the following date: retrieval and implementation, a folder content, retrieval. Attention if the "Everyone" (Everyone) group or "users" group to retrieve root Web site or virtual directory, there would be no need to implement these steps.In Windows 2003 domain controller server, applications to network service identity operation (nothing to do with IIS isolation mode). In some cases, the domain controller function request to take additional steps to make your normal installation. 1.1 operating in the domain controller on the issue of the potential problems more information, Please see Microsoft knowledge base article Q824308 "IWAM Account is Not Granted the Impersonate Privilege for 1.1 on Windows 2000 Domain Controller with SP4" (SP4 installed in the Windows 2000 domain controller, not to IWAM account for 1.1 simulation Privileges), Web site knowledge base for . In the domain controller function. Net Framework 1.0 more information, Please see Microsoft knowledge base article Q315158, " Does Not Work with the Default Account on a Domain Controller" (with the domain controller, not the acquiescence account work), Web site knowledge base for .Author: ouglas J. TomFrom: Microsoft Applications设计应用因特网服务器应用程式介面：CGI具有扩充性能和克服的问题的能力，是微软公司开发的一种新的方式开发建设规模的应用。

ASPNET课件

修改主目录：转到“主目录”窗口，再在“本地路径”输入（或用 “浏览”按钮选择）好自己网页所在的“e:\aspnet”目录。
添加首页文件名：转到“文档”窗口，再按“添加”按钮，根据提示在
“默认文档名”后输入自己网页的首页文件名“default.aspx”。
扩展：IIS服务器组建一览
第二十一页，编辑于星期四：十一点三十四分。
第二十七页，编辑于星期四：十一点三十四分。
HTML服务器控件和Web服务器控件（1）
中有两类控件：HTML服务器控件和Web服务器控件，都可通过工具箱插入。一个位于工具箱的“HTML”选项卡中，一个位于工具箱的“标准”选项卡中。
带三角符的是Web服务器控件
第二十八页，编辑于星期四：十一点三十四分。
第八页，编辑于星期四：十一点三十四分。
1.1 基本概念——静态网页和动态网
页
静态网页，动态网页主要根据网页制作的语言来区分
静态网页使用语言：HTML（超文本标记语言）
动态网页使用语言：HTML＋ASP或HTML＋ PHP或HTML＋JSP等。
第九页，编辑于星期四：十一点三十四分。
静态网页

第一页，编辑于星期四：十一点三十四分。
目录
第一章概述第二章 Web 服务器控件第三章内置对象
第四章类库
第五章使用访问数据库
第二页，编辑于星期四：十一点三十四分。
第一章概述
理解B/S编程相关基本概念
Windows平台下使用IIS的WEB服务器。
第十六页，编辑于星期四：十一点三十四分。
HTTP 的工作原理
页请求
客户端（浏览器）
客户端（浏览器）
请给我发送 “超文本简介”

第一讲ASP.NET概述

配置和部署将配置信息存储在基于 XML 的配置文件中，使得应用程序更易于部署
优点
与浏览器无关将业务逻辑代码与显示逻辑分开新的集成开发环境简单性和易学性用户帐户和角色多处理器环境的可靠性可扩展性高效的可管理性执行效率的大幅提高易于配置和部署
Web 应用程序文件结构
C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统 ,B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小. 7．用户接口不同
C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高,B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本. 8．信息流不同
将程序集引入到当前页面或用户控件中，以便它所包含的类和接口能够适用于页面中的代码
的功能
技术利用面向对象的语言如C＃进行后台开发，它包括一系列很有用的类和命名空间
类 - HtmlControl
相似的功能
命名空间
类 - HtmlAnchor
类 - HtmlForm
在逻辑上将具有相似功能的类进行分组
的功能
服务器控件是在服务器上运行并封装用户界面及其他相关功能的组件，这些控件提供了各种属性、方法和事件，可简化构建强大的 Web 应用程序的过程
代码编译执行
_______ _______ _______ ______
代码
编译
Microsoft 中间语言
（MSIL 或 IL）
机器语言
JIT 编译器
分别编译 IL 的每一部分
的功能

ASPNET毕业论文中英文文献

ASP毕业论文中英文资料外文翻译附件1：外文资料翻译译文概述是一个统一的 Web 开发模型，它包括您使用尽可能少的代码生成企业级 Web 应用程序所必需的各种服务。

作为 .NET Framework 的一部分提供。

当您编写应用程序的代码时，可以访问 .NET Framework 中的类。

您可以使用与公共语言运行库 (CLR) 兼容的任何语言来编写应用程序的代码，这些语言包括 Microsoft Visual Basic、C#、JScript .NET 和 J#。

使用这些语言，可以开发利用公共语言运行库、类型安全、继承等方面的优点的应用程序。

包括：•页和控件框架• 编译器•安全基础结构•状态管理功能•应用程序配置•运行状况监视和性能功能•调试支持•XML Web services 框架•可扩展的宿主环境和应用程序生命周期管理•可扩展的设计器环境页和控件框架是一种编程框架，它在 Web 服务器上运行，可以动态地生成和呈现网页。

可以从任何浏览器或客户端设备请求网页，会向请求浏览器呈现标记（例如 HTML）。

通常，您可以对多个浏览器使用相同的页，因为会为发出请求的浏览器呈现适当的标记。

但是，您可以针对诸如 Microsoft Internet Explorer 6 的特定浏览器设计网页，并利用该浏览器的功能。

支持基于 Web 的设备（如移动电话、手持型计算机和个人数字助理 (PDA)）的移动控件。

网页是完全面向对象的。

在网页中，可以使用属性、方法和事件来处理 HTML 元素。

页框架为响应在服务器上运行的代码中的客户端事件提供统一的模型，从而使您不必考虑基于 Web 的应用程序中固有的客户端和服务器隔离的实现细节。

该框架还会在页处理生命周期中自动维护页及该页上控件的状态。

使用页和控件框架还可以将常用的 UI 功能封装成易于使用且可重用的控件。

控件只需编写一次，即可用于许多页并集成到网页中。

外文翻译---ASPNET介绍以及内联代码和共享

附录 1 英文原文Introduction to Pages and Inline Code and Share[10] The Web Forms page framework is a scalable common language runtime programming model that can be used on the server to dynamically generate Web pages. Intended as a logical evolution of ASP ( provides syntax compatibility with existing pages), the page framework has been specifically designed to address a number of key deficiencies in the previous model. In particular, it provides the ability to create and use reusable UI controls that can encapsulate common functionality and thus reduce the amount of code that a page developer has to write, the ability for developers to cleanly structure their page logic in an orderly fashion (not "spaghetti code"), and the ability for development tools to provide strong WYSIWYG design support for pages (existing classic ASP code is opaque to tools). This section of the QuickStart provides a high-level code walkthrough of some basic page features. Subsequent sections of the QuickStart drill down into more specific details. pages are text files with an .htm file name extension. Pages consist of code and markup and are dynamically compiled and executed on the server to produce a rendering to the requesting client browser (or device). They can be deployed throughout an IIS virtual root directory tree. When a browser client requests .htm resources, the runtime parses and compiles the target file into a .NET Framework class. This class can then be used to dynamically process incoming requests. (Note that the .htm file is compiled only the first time it is accessed; the compiled type instance is then reused across multiple requests).An page can be created simply by taking an existing HTML file and changing its file name extension to .htm (no modification of code is required). For example, the following sample demonstrates a simple HTML page that collects a user's name and category preference and then performs a form postback to the originating page when a button is clicked:Important: Note that nothing happens yet when you click the Lookup button. Thisis because the .htm file contains only static HTML (no dynamic content). Thus, the same HTML is sent back to the client on each trip to the page, which results in a loss of the contents of the form fields (the text box and drop-down list) between requests. provides syntax compatibility with existing ASP pages. This includes support for <% %> code render blocks that can be intermixed with HTML content within an .htm file. These code blocks execute in a top-down manner at page render time.The below example demonstrates how <% %> render blocks can be used to loop over an HTML block (increasing the font size each time):Important: Unlike with ASP, the code used within the above <% %> blocks is actually compiled--not interpreted using a script engine. This results in improved runtime execution performance. page developers can utilize <% %> code blocks to dynamically modify HTML output much as they can today with ASP. For example, the following sample demonstrates how <% %> code blocks can be used to interpret results posted back from a client.Important: While <% %> code blocks provide a powerful way to custom manipulate the text output returned from an page, they do not provide a clean HTML programming model. As the sample above illustrates, developers using only <% %> code blocks must custom manage page state between round trips and custom interpret posted values.In addition to code and markup, pages can contain server controls, which are programmable server-side objects that typically represent a UI element in the page, such as a textbox or image. Server controls participate in the execution of the page and produce their own markup rendering to the client. The principle advantage of server controls is that they enable developers to get complex rendering and behaviors from simple building-block components, dramatically reducing the amount of code it takes to produce a dynamic Web page. Another advantage of server controls is that it is easy to customize theirrendering or behavior. Server controls expose properties that can be set either declaratively (on the tag) or programmatically (in code). Server controls (and the page itself) also expose events that developers can handle to perform specific actions during the page execution or in response to a client-side action that posts the page back to the server (a "postback"). Server controls also simplify the problem of retaining state across round-trips to the server, automatically retaining their values across successive postbacks.Server controls are declared within an .htm file using custom tags or intrinsic HTML tags that contain a runat="server" attribute value. Intrinsic HTML tags are handled by one of the controls in the System.Web.UI.HtmlControls namespace. Any tag that doesn't explicitly map to one of the controls is assigned the type of System.Web.UI.HtmlControls.HtmlGenericControl.Important: Note that these server controls automatically maintain anyclient-entered values between round trips to the server. This control state is not stored on the server (it is instead stored within an <input type="hidden"> form field that is round-tripped between requests). Note also that no client-side script is required.In addition to supporting standard HTML input controls, enables developers to utilize richer custom controls on their pages. For example, the following sample demonstrates how the <asp:adrotator> control can be used to dynamically display rotating ads on a page.Each server control is capable of exposing an object model containing properties, methods, and events. developers can use this object model to cleanly modify and interact with the page.Note, however, how much cleaner and easier the code is in this new server-control-based version. As we will see later in the tutorial, the page Framework also exposes a variety of page-level events that you can handle to write code to execute a specific time during the processing of the page. Examples of these events are Page_Load and Page_Render.The example below demonstrates a simple page with three servercontrols, a TextBox, Button, and a Label. Initially these controls just render their HTML form equivalents. However, when a value is typed in the TextBox and the Button is clicked on the client, the page posts back to the server and the page handles this click event in the code of the page, dynamically updating the Text property of the Label control. The page then re-renders to reflect the updated text. This simple example demonstrates the basic mechanics behind the server control model that has made one of the easiest Web programming models to learn and master.Note that in the preceding example the event handler for the Button was located between <script></script>tags in the same page containing the server controls. calls this type of page programming code-inline, and it is very useful when you want to maintain your code and presentation logic in a single file. However, also supports another way to factor your code and presentation content, called the code-behind model. When using code-behind, the code for handling events is located in a physically separate file from the page that contains server controls and markup. This clear delineation between code and content is useful when you need to maintain these separately, such as when more than one person is involved in creating the application. It is often common in group projects to have designers working on the UI portions of an application while developers work on the behavior or code. The code-behind model is well-suited to that environment. 2.0 introduces an improved runtime for code-behind pages that simplifies the connections between the page and code. In this new code-behind model, the page is declared as a partial class, which enables both the page and code files to be compiled into a single class at runtime. The page code refers to the code-behind file in the CodeFile attribute of the <%@ Page %>directive, specifying the class name in the Inherits attribute. Note that members of the code behind class must be either public or protected (they cannot be private).The advantage of the simplified code-behind model over previous versions is that you do not need to maintain separate declarations of server control variablesin the code-behind class. Using partial classes (new in 2.0) allows the server control IDs of the ASPX page to be accessed directly in the code-behind file. This greatly simplifies the maintenance of code-behind pages.Although you can place code inside each page within your site (using the inline or code-behind separation models described in the previous section), there are times when you will want to share code across several pages in your site. It would be inefficient and difficult to maintain this code by copying it to every page that needs it. Fortunately, provides several convenient ways to make code accessible to all pages in an application.Just as pages can be compiled dynamically at runtime, so can arbitrary code files (for example .cs or .vb files). 2.0 introduces the App_Code directory, which can contain standalone files that contain code to be shared across several pages in your application. Unlike 1.x, which required these files to be precompiled to the Bin directory, any code files in the App_Code directory will be dynamically compiled at runtime and made available to the application. It is possible to place files of more than one language under the App_Code directory, provided they are partitioned in subdirectories (registered with a particular language in Web.config). The example below demonstrates using the App_Code directory to contain a single class file called from the page.By default, the App_Code directory can only contain files of the same language. However, you may partition the App_Code directory into subdirectories (each containing files of the same language) in order to contain multiple languages under the App_Code directory. To do this, you need to register each subdirectory in the Web.config file for the application.<configuration><system.web><compilation><codeSubDirectories><add directoryName="Subdirectory"/></codeSubDirectories></compilation></system.web></configuration>Supported in version 1, the Bin directory is like the Code directory, except it can contain precompiled assemblies. This is useful when you need to use code that is possibly written by someone other than yourself, where you don't have access to the source code (VB or C# file) but you have a compiled DLL instead. Simply place the assembly in the Bin directory to make it available to your site. By default, all assemblies in the Bin directory are automatically loaded in the app and made accessibe to pages. You may need to Import specific namespaces from assemblies in the Bin directory using the @Import directive at the top of the page.The .NET Framework 2.0 includes a number of assemblies that represent the various parts of the Framework. These assemblies are stored in the global assembly cache, which is a versioned repository of assemblies made available to all applications on the machine (not just a specific application, as is the case with Bin and App_Code). Several assemblies in the Framework are automatically made available to applications. You can register additional assemblies by registration in a Web.config file in your application.<configuration><compilation><assemblies><add assembly="System.Data, Version=1.0.2411.0,Culture=neutral,PublicKeyToken=b77a5c561934e089"/></assemblies></compilation></configuration>附录 2 中文译文介绍以及内联代码和共享 Web 窗体页框架是一种可用于在服务器上动态生成网页的可伸缩公共语言运行库编程模型。

外文文献—从经典ASP到ASP.NET

附录Ⅰ英文文献翻译Moving from Classic ASP to ABSTRACT is Microsoft new offering for Web application development, innovation within have resulted in significant industry popularity for this product. Consequently there is an increased need for education. The Web Application Development is a third year undergraduate course. To meet the demands of both industry and students, we have changed the focus of this course from Classic ASP to . This paper reports this move. The significant features of and the motivations for this move are discussed. The process, the problems encountered, and some helpful online learning resources are described.Key words: Web Application Development, Classic ASP, , Move, 1. INTRODUCTION is not just a new version of ASP. It provides innovation for moving Windows applications to Web applications. Web services and the .NET framework have made the vision of the Web as the next generation computing platform a reality. With server controls, Web forms and “code-behind”, we can develop a Web application by using a complete object-oriented programming (OOP) model. This increases the popularity of in industry. The industry project is the final course of the Bachelor of Computing Systems (BCS) degree at UNITEC, in which students undertake a real-world project. We have observed a rapid growth of related industry projects in our school.The Web Application Development (WAD) paper is a third year undergraduate course. It was originally offered using ASP 2.0 and ColdFusion. To meet the demands from both industry and students, we have changed the course content to cover , Visual () and ColdFusion. This change commenced with the first semester of 2003.This paper will examine the features of and explain why these are unique. The motivations for moving to are discussed by analyzing the current situation of related to industry projects in our school, analyzing the results of short surveys on students, andanalyzing whether is a better tool for teaching. Problems encountered during the move are also discussed and some of the learning resources are presented. It is anticipated that these will be helpful for teachers who intend to introduce .2. WHA T MAKES SPECIAL?There are many articles on the Internet discussing the advantages of over Classic Active Server Pages (ASP), such as that introduces an integrated development environment (IDE), a single development library for all types of applications, compiled as well as strongly typed code, and a true OO approach to Web application development (Goodyear, 2002, Bloom, 2002).Traditionally, we have three versions of ASP (ASP 1.0, ASP 2.0 and ASP 3.0), which are called Classic ASP. Although each version provides certain new features to overcome the shortcomings of its predecessors, these versions of ASP follow the same working model and share many limitations. Their successor supports complete new working model while preserving the traditional working model and provides innovative techniques to overcome the limitations of Classic ASP.2.1. Architecture enhances and extends the Windows DNA(Windows Distributed interNet Application). The windows DNA specification is a methodology for building n-tier applications using Microsoft (DCOM/COM) technologies. Breaking applications into functional pieces and deploying these across a network is a strategy to make better use of organizational resources. This needs a well-planned architecture. In the past, usually it was the windows DNA. DCOM communication normally has problems with firewalls and proxy servers. This means Windows DNA usually only works well within an intranet, not on the Internet. DCOM/ COM also need registry entries. makes the process of creating and integrating Web Services easier, which can beused in a similar manner to the Windows DNA. Here DCOM/COM is no longer involved. HTTP (as channels), SOAP (as formatters) and XML are used for communication and data-transfer between distributed components. This overcomes the problem of communicating across the Internet and across corporate firewalls without resorting to proprietary solutions that require additional communications ports to be opened to external access. In addition, URI (uniform resource identifier) and UDDI (Universal Description Discovery and Integration) are used for remote components references instead of registry entries.2.2. Development integrates seamlessly with IDE. includes built-in support for creating and modifying content. This unifies the ASP/VB programming models for the developers. Instead of opening multiple IDEs (as with Classic ASP platform), developers can open a single IDE and do all their work from a clean, consistent interface. is equipped with powerful debugging environment. This means that the powerful debugger for Windows applications is now available to debug Web applications as well. enables programmers to take advantage of the OOP model, for example, code sharing. Under OOP model, one of the most common ways to achieve code sharing is inheritance, which is not available in Classic ASP. Since complete OO features are supported in , developers can transfer their OO design smoothly into code, enabling a software company to keep their Windows application development styles, with which they are familiar, in Web application development; and also they can convert their Windows applications into Web applications without major modifications.’s improved state maintenance features enable us to provide users with Web applications that are richer and faster than Classis ASP (Olges,2002). supports advanced session state management. There are two major problems with session management in Classic ASP: session objects are stored in the Web server memory and session IDs are stored on the client computers as cookies. These prevent session management from being efficiently implemented. solves the se problems in two ways: it provides a “cookieless” option for session objects so that a session ID can be passed via URL; it provides three different session modes (in process, state server, and SQL Server), so that a session object can either be stored on the Web server, a remote server or adatabase.3. THE MOTIV A TIONS FOR MOVING3.1. The industry motivationI’ve checked almost all the industry projects in our school for three semesters on whether they are W AD related, if yes, then what tools they have used. Table 1 shows a brief summary of the results.for these three semesters, the total ASP/ projects are increasing, but slowly. However the Classic ASP projects are dropping quickly and the projects are increasing rapidly (in the speed of more than 12% per semester). This gives us an idea that is preferred over Classic ASP in industry especially given that is only officially first released in 2002. Our student’s feedbacks from their industry communication confirm this view. A huge number of articles on the Internet also support this view. This encourages us to drop Classic ASP and move to in our W AD course. Higher education has over years recognized that it is a service industry and has to revaluate their approach in the industry by placing greater emphasis on meeting the expectations and needs of their stakeholders (Nair, 2002).3.2. The student motivationThe students demand . When students enroll in our W AD course, most of them are aiming to become a professional software developer. As a matter of fact, some of them already are software developers, or they were software developers and are seeking to return to the workplace. Techniques highly demanded in workplace are of great interest to them.A short survey has been given to past students and current students respectively. For the past students, among the 11 responses, 100% students still want to learn ; and if they are given choice, 82% students prefer to learn rather than Classic ASP, 18% students like to learn both. These answers are also supported by comments, such as “I would prefer to know the technology that the industry requires me to work with”, “I would like to work in future as a W AD professional and I think would be useful in t his field.” For the current students, among the 16 responses, 75% students prefer to learn rather than Classic ASP. However, 25% students answered no idea. This could be due to that they lack of knowledge of Classic ASP. This survey is done after 6 weeks of teaching.3.3. The pedagogical motivationPedagogically speaking, a good tool for industry is not necessarily a good tool for teaching. Is a better tool for teaching than Classic ASP? provides much richer language features than Classic ASP. We often have options to perform certain tasks. A key benefit of is that there exists a more gradual transition in programming models from simple to powerful, or from easy to difficult. Although supports OOP model, you don’t hav e to program by using that model. A Web form without “code-behind” will work perfectly. An web page in complete Classic ASP model will still work. Although is integrated with , we are not limited to use . A notepad and a FTP client with a pre-created Web application directory also allow us to develop a reasonably large application. With , we can either develop a large distributed application with numbers of Web services and consumers, or develop a single simple Web application. Therefore, provides sufficient room for us to organize course materials at a suitable level for the students. The challenge for a lecturer is how to settle in at the right balance of power vs. simplicity, or at the right balance of difficulty vs. ease. offers a more conventional approach to programming than does Classic ASP. It possesses all the features of a modern programming language. The Classic ASP programming style favors developers coming from HTML coding background, whereas is more suited to professional software developers. Given our entire W AD students have taken C/Delphi programming courses, and our aim is to output software professionals, is a better teaching tool for us. enhances the programming concepts the students learned from the previous courses and provides a good bridge to Advanced Distributed Computing and Advanced Object- Oriented Programming.4. THE PROCESSOur first step was to learn . After reading books and online tutorials, the next step is practical. We set an implementation server on the laptop in a stand-alone environment. The .NET Framework requires IIS 5 and the above; Windows 2000 or Windows XP professional will work with .NET. However, Windows XP home edition or Win dows 98 won’t work. On the client side, we can either use or WebMatrix. Among these, only costs money. The .NETFramework is included inside the package. We also can download the .NET Framework from the Internet. After the .NET Framework is installed, the QuickStart Tutorial is set up. It is also found on the Internet. This tutorial is a good starting point for experienced developers. It is claimed that the readers “should be fluent in HTML and general Web development terminolog y. …… should be familiar with the concepts behind interactive Web pages, including forms, scripts, and data access.” More complicated examples can be found from Microsoft .NET Framework SDK Documentation or Microsoft V isual Studio .NET Documentation.The second step was to test the teaching environment. A teaching server was set up for the Intranet on campus. It is configured for the client computers in the teaching lab. is installed on the client computers. provides two ways to access the Web server: FrontPage server extensions and File share. The FrontPage server extension is used on our teaching server. Programming testing has been done on all the major aspects of W AD. Except a few special ones, most of the problems occurred during the testing were minor problems which, after the communication with our Web technician, were resolved.Teaching materials have been updated. The major changes have been made on the data interaction, form and controls, application/session management, and error handling. Given that has made XML very practical and the using of Web service much easier. A lecture on XML and Web service has been added. As a result, ColdFusion lectures are reduced. The assessment has been adjusted accordingly.5. THE PROBLEMSWe have to admit that with is a much more complicated client server environment than the Classic ASP environment. This complexity comes from the configuration system and the integration between the client computers and the Web server.On server, each level of the application directory can have a configuration file. All these configuration files are optional except Machine.config. A developer has full control over those optional configuration files. Developers become more involved w ith the server settings via these files. One problem that happened to several students and myself on our home servers is the permission problem. We found our applications didn’t have permission to write todatabase/XML files. Microsoft (2003) provides three solutions to this problem. The simplest one is to change the Machine.config file and set the username attribute to SYSTEM in the <processModel> section.We observed that behave differently in a stand-alone environment, a single user clien t server environment, and a multiple user client server environment. A few problems don’t occur in the first two environments occur frequently in the last environment. The major one is when we try to create a new project or open an existing project, we often get an error message, “The user name or password you entered is incorrect, or you do not have authorization to permit this operation”, even if our user name and password are perfectly correct. This problem seems to be caused by FrontPage server extensions. Regularly cleaning VSWebCache partially solved the problem. This approach is confirmed by Kiely (2003).Another problem is a debug problem. When we try to use Debug|Start or Debug|Start Without Debugging in the multiple user client server environment within , we often get error messages. “…… Unable to start debugging on the web server. ……”. However, we don’t have the same problem for Debug|Start Without Debugging in the single user client server environment. We don’t have any problem in a standal one environment. After adding users to the debugging group on the server, the problem still exists. The reason of this problem is not clear to the author.6. CONCLUSIONMoving from Classic ASP to has proven to be a challenging and exciting process. The author has learned a lot in this process. From the responses to our six-week survey, 100% students feel our W AD course challenging. However, most of them still prefer to learn rather than Classic ASP. We feel confident about the move. The issue is how to organize the course and help the students meet the challenge. is certainly an outstanding tool for both teaching and development. As a new development platform, we do need some time to absorb all the new features.从经典ASP到摘要是微软公司基于网络应用程序新开发出的产品，这个产品的普及在的创新当中具有重大意义，因此在方面的教育有了很大的需求。

ASP.NET2.0数据库外文文献及翻译和参考文献-英语论文

2.0数据库外文文献及翻译和参考文献-英语论文 2.0数据库外文文献及翻译和参考文献参考文献[1] Matthew 高级程序设计[M].人民邮电出版社,2009.[2] 张领项目开发全程实录[M].清华大学出版社,2008.[3] 陈季实例指南与高级应用[M].中国铁道出版社,2008.[4] 郑霞2.0编程技术与实例[M].人民邮电出版社,2009.[5] 李俊民.精通SQL(结构化查询语言详解)[M].人民邮电出版社,2009.[6] 刘辉 .零基础学SQL Server 2005[M].机械工业出版社，2007.[7] 齐文海.ASP与SQL Server站点开发实用教程[M].机械工业出版社，2008.[8] 唐学忠.原文请找SQL Server 2000数据库教程[M]. 电子工业出版社，2005.[9] 王珊、萨师煊.数据库系统概论（第四版）[M].北京：高等教育出版社，2006.[10] Mani work Management Principles and Practive. Higher Education Press,2005,12VS2005中开发 2.0数据库程序一、简介在2005年11月7日，微软正式发行了.NET 2.0(包括 2.0)，Visual Studio 2005和SQL Server 2005。

所有这些部件均被设计为可并肩独立工作。

也就是说，版本1.x和版本2.0可以安装在同一台机器上；你可以既有Visual 2002/2003和Visual Studio 2005，同时又有SQL Server 2000和SQL Server 2005。

而且，微软还在发行Visual Studio 2005和SQL Server 2005的一个 Express式的SKU。

注意，该Express版并不拥有专业版所有的特征。

2.0除了支持1.x风格的数据存取外，自身也包括一些新的数据源控件-它们使得访问和修改数据库数据极为轻松。

asp.net介绍

介绍题外话：去年⾄今年以来，陆续写过⼀些原创的⽂章了，很多是对原来所做项⽬的总结。

所以并不是很系统很全⾯，都是针对某个知识点或者某个具体应⽤写的，有些朋友建议我把⾃⼰的体会写成⼀个系统的，这次算是⼀个尝试吧，写得不好的地⽅请⼤家尽量抛西红柿不要丢砖头。

之所以把这个系列叫做《夜话》，是有⼀些原因的，某不厌酒喜茶，酒越喝越糊涂，茶喝多了也仍然能保持清醒。

⽩天很忙，所以每天回到家之后我会沏⼀壶茶，边喝茶边看书，偶有⼼得体会就会⽤⽂字记录下来，过⼀段时间之后再将这些⽂字整理⼀下，觉得语句还算通畅的就发表在博客上了。

这个关于系列的⽂章将会都在晚上完成，所以我叫它《夜话》。

这个系列偏重于实际于开发实战中的理论和经验⽅⾯的介绍。

本系列⽂章中会⽤到Macromedia Dreamweaver 8中⽂版、Microsoft Visual Studio 2005中⽂版和Microsoft SQL Server 2005中⽂版，请先安装好相关软件。

好了，开始我们的正题。

在今天我主要要介绍的有如下知识点：XHTML语⾔静态⽹页动态⽹页WEB服务器开发的预备知识另外在看本节时，我可能会⽤到Macromedia Dreamweaver 8中⽂版，如果有条件，在⾃⼰的电脑上安装⼀个会获得更好的体验。

XHTML语⾔在⽹页开发的早期，基本上都是使⽤HTML语⾔开发的，它因为语法要求⽐较松散，虽然对开发者来说⽐较⽅便，但是机器处理起来⽐较困难，所以在HTML的基础上增加了XML的要求，这就形成了XHTML语⾔。

XHTML说⽩了就是符合XML标准的HTML语⾔。

当前版本的Macromedia Dreamweaver和Microsoft Visual Studio都⽀持XHTML开发。

以下是Dreamweaver创建的空HTML页⾯：以下是Microsoft Visual Studio2005创建的空⽩aspx页⾯：注意⽤红线标出的部分，上⾯的表⽰我们创建的是符合XHTML标准的页⾯。

毕业论文英文文献及翻译

英文原文 and the .NET Framework is part of Microsoft's overall .NET framework, which contains a vast set of programming classes designed to satisfy any conceivable programming need. In the following two sections, you learn how fits within the .NET framework, and you learn about the languages you can use in your pages.The .NET Framework Class LibraryImagine that you are Microsoft. Imagine that you have to support multiple programming languages—such as Visual Basic, JScript, and C++.A great deal of the functionality of these programming languages overlaps. For example, for each language, you would have to include methods for accessing the file system, working with databases, and manipulating strings.Furthermore, these languages contain similar programming constructs. Every language, for example, can represent loops and conditionals. Even though the syntax of a conditional written in Visual Basic differs from the syntax of a conditional written in C++, the programming function is the same.Finally, most programming languages have similar variable data types. In most languages, you have some means of representing strings and integers, for example. The maximum and minimum size of an integer might depend on the language, but the basic data type is the same.Maintaining all this functionality for multiple languages requires a lot of work. Why keep reinventing the wheel? Wouldn't it be easier to create all this functionality once and use it for every language?The .NET Framework Class Library does exactly that. It consists of a vast set of classes designed to satisfy any conceivable programming need. For example, the .NET framework contains classes for handling database access, working with the file system, manipulating text, and generating graphics. In addition, it contains more specialized classes for performing tasks such as working with regular expressions and handling network protocols.The .NET framework, furthermore, contains classes that represent all the basic variable data types such as strings, integers, bytes, characters, and arrays.Most importantly, for purposes of this book, the .NET Framework Class Library contains classes for building pages. You need to understand, however, that you can access any of the .NET framework classes when you are building your pages.Understanding NamespacesAs you might guess, the .NET framework is huge. It contains thousands of classes (over 3,400). Fortunately, the classes are not simply jumbled together. The classes of the .NET framework are organized into a hierarchy of namespaces.ASP Classic NoteIn previous versions of Active Server Pages, you had access to only five standard classes (the Response, Request, Session, Application, and Server objects). , in contrast, provides you with access to over 3,400 classes!A namespace is a logical grouping of classes. For example, all the classes that relate to working with the file system are gathered together into the System.IO namespace.The namespaces are organized into a hierarchy (a logical tree). At the root of the tree is the System namespace. This namespace contains all the classes for the base data types, such as strings and arrays. It also contains classes for working with random numbers and dates and times.You can uniquely identify any class in the .NET framework by using the full namespace of the class. For example, to uniquely refer to the class that represents a file system file (the File class), you would use the following:System.IO.FileSystem.IO refers to the namespace, and File refers to the particular class.NOTEYou can view all the namespaces of the standard classes in the .NET Framework Class Library by viewing the Reference Documentation for the .NET Framework.Standard NamespacesThe classes contained in a select number of namespaces are available in your pages by default. (You must explicitly import other namespaces.) These default namespaces contain classes that you use most often in your applications:System— Contains all the base data types and other useful classes such as those related to generating random numbers and working with dates and times.System.Collections— Contains classes for working with standard collection types such as hash tables, and array lists.System.Collections.Specialized— Contains classes that represent specialized collections such as linked lists and string collections.System.Configuration— Contains classes for working with configuration files (Web.config files).System.Text— Contains classes for encoding, decoding, and manipulating the contents of strings.System.Text.RegularExpressions— Contains classes for performing regular expression match and replace operations.System.Web— Contains the basic classes for working with the World Wide Web, including classes for representing browser requests and server responses.System.Web.Caching— Contains classes used for caching the content of pages and classes for performing custom caching operations.System.Web.Security— Contains classes for implementing authentication and authorization such as Forms and Passport authentication.System.Web.SessionState—Contains classes for implementing session state.System.Web.UI—Contains the basic classes used in building the user interface of pages.System.Web.UI.HTMLControls— Contains the classes for the HTML controls.System.Web.UI.WebControls— Contains the classes for the Web controls..NET Framework-Compatible LanguagesFor purposes of this book, you will write the application logic for your pages using Visual Basic as your programming language. It is the default language for pages (and the most popular programming language in the world). Although you stick to Visual Basic in this book, you also need to understand that you can create pages by using any language that supports the .NET Common Language Runtime. Out of the box, this includes C# (pronounced See Sharp), (the .NET version of JavaScript), and the Managed Extensions to C++.NOTEThe CD included with this book contains C# versions of all the code samples.Dozens of other languages created by companies other than Microsoft have been developed to work with the .NET framework. Some examples of these other languages include Python, SmallTalk, Eiffel, and COBOL. This means that you could, if you really wanted to, write pages using COBOL.Regardless of the language that you use to develop your pages, you need to understand that pages are compiled before they are executed. This means that pages can execute very quickly.The first time you request an page, the page is compiled into a .NET class, and the resulting class file is saved beneath a special directory on your server named Temporary Files. For each and every page, a corresponding class file appears in the Temporary Files directory. Whenever you request the same page in the future, the corresponding class file is executed.When an page is compiled, it is not compiled directly into machine code. Instead, it is compiled into an intermediate-level language called Microsoft Intermediate Language (MSIL). All .NET-compatible languages are compiled into this intermediate language.An page isn't compiled into native machine code until it is actually requested by a browser. At that point, the class file contained in the Temporary Files directory is compiled with the .NET framework Just in Time (JIT) compiler and executed.The magical aspect of this whole process is that it happens automatically in the background. All you have to do is create a text file with the source code for your page, and the .NET framework handles all the hard work of converting it into compiled code for you.ASP CLASSIC NOTEWhat about VBScript? Before , VBScript was the most popular language for developing Active Server Pages. does not support VBScript, and this is good news. Visual Basic is a superset of VBScript, which means that Visual Basic has all the functionality of VBScript and more. So, you have a richer set of functions and statements with Visual Basic.Furthermore, unlike VBScript, Visual Basic is a compiled language. This means that if you use Visual Basic to rewrite the same code that you wrote with VBScript, you can get better performance.If you have worked only with VBScript and not Visual Basic in the past, don't worry. Since VBScript is so closely related to Visual Basic, you'll find it easy to make the transition between the two languages.NOTE Microsoft includes an interesting tool named the IL Disassembler (ILDASM) with the .NET framework. You can use this tool to view the disassembled code for any of the classes in the Temporary Files directory. It lists all the methods and properties of the class and enables you to view the intermediate-level code.This tool also works with all the controls discussed in this chapter. For example, you can use the IL Disassembler to view the intermediate-level code for the TextBox control (located in a file named System.Web.dll).中文翻译和 .NET Framework是微软.NET框架总体战略的一部分。

ADO NET数据集ASP技术应用程序中英文资料外文翻译文献

中英文资料外文文献及翻译：On the ASP to maintain the security of applicationsabout DataSet and the parallel implementation of 【abstract】 DataSetsTheDataSetobject is central tosupporting disconnected, distributed data scenarios with . TheDataTableCollectionAn DataSetcontains acollection of zero or more tables represent ed byDataTableobjects.Properly configured security settings to protect your ASP applications will not be unauthorized user access and tampering. The ASP provides a wide range of application of safeguard procedures.【keyword】 DataSet，asp,Security,web server DataSetsTheDataSetobject is central tosupporting disconnected, distributed data scenarios with A . TheDataSetis a memory-residentrepresentation of data that provides a consistent relational programming modelregardless of the data source. It can be used with multiple and differing datasources, with XML data, or to manage data local to the application. TheDataSetrepresents acomplete set of data, including related tables, constrai nts, and relationshipsamong the tables. The following illustration shows theDataSetobject model.DataSetobject mo del The methods andobjects in aDataSetare consistent with those in the relational databasemodel.TheDataSetcan al so persist andreload its contents as XML, and its schema as XML schema definition language(XSD) schema.ASP is a server-side scripting environment, through such an environment, users can create and run dynamic, interactive Web server applications. ASP's ActiveX technology is based on the use of open design environment, users can create their own definitions and components by adding them to their own dynamic web site with almost unlimited capacity to expand. ASP can also use ADO to access the database quickly and easily, allowing the development of applications based on the WWW possible. DataSet and the parallel implementation of TheDataTableCollectionAn DataSetcontains acollection of zero or more tables represented byData Tableobjects. TheDataTableCollectioncontains all theDataTableobjects in aDataSet.ADataTableis defined in theSy stem.Datanamespace andrepresents a single table of memory-resident data. It contains a collection ofcolumns represented by aDataColumnCollection, and constraintsrepresented by aConstraintCollection, which together define the schema of thetable.ADataTablealso contains a collection of rows represented by theDataRowCollection, which contains thedata in the table. Along with its current state, aDataRowretains both itscurrent and original versions to identify changes to the values stored in therow. TheDataView ClassADataViewenables you tocreate different views of the data stor ed in aDataTable, a capability thatis often used in data-binding applications. Using aDataView, you can expose the data in a table with different sort orders, and you can filter the data by rowstate or based on a filter expression. Th eDataRelationCollectionADataSetcontains relationshipsin itsDataRelationCollectionobject. A relationship, represe nted bytheDataRelationobject, associates rows inoneDataTablewith rows in anotherDataTable.A relationship isanalogous to a join path that might exist between primary and foreign keycolumns in a relatio nal database. ADataRelationidentifies matchingcolumns in two tables of aDataSet.Relationships enablenavigation from one table to another in aDataSet. The essentialelements of aDataRelationare the name of the relationship, the name of the tablesbeing related, and the related columns in each table. Relationships can bebuilt with more than on e column per table by specifying an array ofDataColumnobjects as the keycolumns. When you add a relationship t o theDataRelationCollection, you can optionallyadd aUniqueKeyConstraintand aForeignKeyConstraintto enforce i ntegrityconstraints when changes are made to related column values. XMLYou can fill aDataSetfrom an XMLstre am or document. You can use the XML stream or document to supply to theDataSeteither data, schemainformation , or both. The information supplied from the XML stream or documentcan be combined with existing data or sche ma information already present in theDataSet. ExtendedPropertiesTheDataSet,DataTable, andDataColumnall hav e anExtendedPropertiesproperty.ExtendedPropertiesis aPropertyCollectionwhere you can placecustom information , such as the SELECT statement that was used to generate theresult set, or the time when the data was generated. T heExtendedPropertiescollection ispersisted with the schema information for theDataSet.LINQ toDataSetLINQ to DataSetprovides language-integrated querying capabilities for disconnected data sto redin a DataSet. LINQ to DataSet uses standard LINQ syntax and providescompile-time syntax checking, static ty ping, and IntelliSense support when youare using the Visual Studio IDE.5、Side-by-Side Execution in Side-by-sideexecution in the .NET Framework is the ability to execute an ap plication on acomputer that has multiple versions of the .NET Framework installed,exclusively using the version f or which the application was compiled.An applicationcompiled by using one version of the .NET Framework can r un on a differentversion of the .NET Framework. However, we recommend that you compile a versionof the applic ation for each installed version of the .NET Framework, and runthem separately. In either scenario, you should be aware of changes in between releases that can affect the forward compatibility or backwardcompatibilit y of your application.ForwardCompatibility and Backward CompatibilityForward compatibilitymeans that an application can be c ompiled with an earlier version of the .NETFramework, but will still run successfully on a later version of the .NETFramework. code written for the .NET Framework version 1.1 is forwardcompatible with later versio ns.Backwardcompatibility means that an application is compiled for a newer version of Framework, but c ontinues to run on earlier versions of the .NET Frameworkwithout any loss of functionality. Of course, this will no t be the case forfeatures introduced in a new version of the .NET Framework. The .NETFramework Data Provider for ODBCStarting with version1.1, the .NET Framework Data Provider for ODBC (System.Data.Odbc) is include d as apart of the .NET Framework. The ODBC data provider is available to .NETFramework version 1.0 developer s as a Web download from theDataAccess andStorageDeveloperCenter.The namespace forthe downloaded .NET Framework Data Provider for ODBC isMicrosoft.Data.Odbc.If you have anapplication developed for the .NET Framework version 1.0 that uses the ODBCdata provider to connect to your data source, and you want to run thatapplication on the .NET Framework version 1.1 or a later version, you m ustupdate the namespace for the ODBC data provider toSystem.Data.Odbc. You then mustrecompile it for the new er version of the .NET Framework.If you have anapplication developed for the .NET Framework version 2.0 or lat er that uses theODBC data provider to connect to your data source, and you want to run thatapplication on the .NE T Framework version 1.0, you must download the ODBC dataprovider and install it on the .NET Framework versi on 1.0 system. You then mustchange the namespace for the ODBC data provider toMicrosoft.Data.Odbc, and reco mpile theapplication for the .NET Framework version 1.0. The .NETFramework Data Provider for OracleStarting with version1.1, the .NET Framework Data Provider for Oracle (System.Data.OracleClient) is included as apart of the .NET Framework. The data provider is available to .NET Frameworkversion 1.0 developers as a Web downloa d from theData AccessandStorageDeveloperCenter.If you have anapplication developed for the .NET Framework version 2.0 or later that uses thedata provider to connect to your data source, and you want to run thatapplication o n the .NET Framework version 1.0, you must download the dataprovider and install it on the .NET Framework ver sion 1.0 system. CodeAccess SecurityThe .NET Frameworkdata providers in the .NET Framework version 1.0 (S ystem.Data.SqlClient,System.Data.OleDb) are required to runwith FullTrust permission. Any attempt to use the .N ET Framework k dataproviders from the .NET Framework version 1.0 in a zone with less thanFullTrust permissio n causes aSecurityException.However, startingwith the .NET Framework version 2.0, all of the .NET Framework data providerscan be used in partially trusted zones. In addition, a new security feature wasadded to the .NET Fram ework data providers in the .NET Framework version 1.1.This feature enables you to restrict what connection strin gs can be used in aparticular security zone. You can also disable the use of blank passwords for aparticular security zone. For more informationBecause eachinstallation of the .NET Framework has a separate Security.config file, th ereare no compatibility issues with security settings. However, if yourapplication depends on the additional securit y capabilities of includedin the .NET Framework version 1.1 and later, you will not be able to distribut eit to a version 1.0 system. SqlCommandExecutionStarting with Framework version 1.1, the way thatEx ecuteReaderexecutes commands atthe data source was changed.In the .NET Frameworkversion 1.0,ExecuteReader executed all commands in the context of thesp_executesqlstored procedure. Asa result, commands that affect the state of the connection (for example, SETNOCOUNT ON), only apply to the execution of the current command. Th e state ofthe connection is not modified for any subsequent commands executed while theconnection is open.In the .NETFramework version 1.1 and later,ExecuteReaderonly executes acommand in the context of thesp_executesqls tored procedure if the command containsparameters, which provides a performance benefit. As a result, if a comm andaffecting the state of the connection is included in a non-parameterizedcommand, it modifies the state of the co nnection for all subsequent commandsexecuted while the connection is open.Consider thefollowing batch of comm ands executed in a call toExecuteReader.In the .NET Frameworkversion 1.1 and later, NOCOUNT will remain ON for any subsequent commandsexecuted while the connection is open. In the .NET Framework version 1.0, NOCO UNTis only ON for the current command execution.This change canaffect both the forward and backward compati bility of your application if youdepend on the behavior ofExecuteReaderfor either version of the .NET Framework. For applications thatrun on both earlier and later versions of the .NET Framework, you can writeyour code to mak e sure that the behavior is the same regardless of the versionyou are running on.If you want to make sure that a command modifies the stateof the connection for all subsequent commands, we recommend that you executeyour command usingExecuteNonQuery. If you want to make sure that a command does not modifythe connection for all subsequent commands, we recommend that you include thecommands to res et the state of the connection in your command. For example: MicrosoftSQL Server Native ClientMicrosoft SQL ServerNative Client contains the SQL OLE DB provider and SQL ODBC driver in onenative dynamic link library (DLL) supporting applications using native-codeAPIs (ODBC, OLE DB andADO)to Microsoft SQL Server. SQL Server Native Client should be used rather thanMicrosoft Data Access Components (MDAC) to create new applica tions or enhanceexisting applications that need to take advantage of features that wereintroduced in SQL Server 20 05, such as Multiple Active Result Sets (MARS),Query Notifications, User-Defined Types (UDT), and XML data type support. MicrosoftData Access Components (MDAC)The .NET Frameworkdata providers for OLE DB and ODBC require MDAC 2.6 or a later version in allversions of the .NET Framework, and MDAC 2.8 SP1 is recomm ended. Although thisrequirement introduces no side-by-side execution issues, notice that MDAC doesnot currently support side-by-side execution.Therefore, it is important toverify that your application will continue to function correctly with the newversio n before upgrading the MDAC components for your installation.For more informationabout MDAC, see theData A ccess andStorageDeveloperCenter. WindowsData Access Components (Windows DAC)Windows Data AccessCo mponents (Windows DAC) 6.0 is a set of technologies included in Windows Vistato provide access to information across the enterprise. These technologiesinclude the latest versions of the data access technologies included in MD AC:Microsoft ActiveX Data Objects (ADO), OLE DB, and Microsoft Open DatabaseConnectivity (ODBC).On the ASP to maintain the security of applicationsDuring the process of the DataSet and the parallel implementation of ,the ASP to maintain the security of applications is especially important.First, NTFS permissionsYou can separate the application of NTFS file and directory access permissions to protect document ASP applications. NTFS permissions We b server is the basis of security, which defines one or a group of users to access files and directories at different levels. When Windo ws NT has a valid account of a user tries to access restricted documents, the computer will check the file access control table. The table definition of the different users and user groups have been given permission. If the user account has permissions to open the file, the computer allows the user to access files.Second, To maintain the security of GlobalasaIn order to fully protect the ASP application, the application must document the Globalasa the appropriate user or group setting NTFS file permissions. If Globalasa contains information to the browser to return to the command and you do not have the protection of Global asa file, then information will be returned to the browser, even if the application of other documents to be protected. Moreover, the application must be on the uniform application of the NTFS file permissions.Third, Web server permissionsCan configure the Web server permissions to restrict users to view all the running and operation of the way ASP pages. Unlike NTFS permissions to control the provision of application-specific user access to files and directories the way, Web server permissions apply to all users, and do not distinguish between the type of user account. To run for your ASP applications users, in the setting Web server permissions must be guided by the following principles:Asp file containing the virtual directory to allow "read" or "script" permissions; of asp file and other script file that contains the virtual directory to allow "read" or "script" permissions; to include asp files and other "executive" privileges to run the virtual directory of the document to allow "read" and "executive" authority.Fourth, Script mapping fileScript mapping applications to ensure that the Web server does not accidentally download the source code asp file. For example, even if your asp file contains a directory set up a "read" permission, as long as the asp file is part of a script mapping applications, then your Web server the file will not return to the source code to the user .Fifth, Cookie securitySessionID cookie to track the use of ASP Application or conversation during the visit to the Webbrowser-specific information. This means that the cookie with the HTTP request is considered to be from the same Web browser. Web Server Se ssionID cookies can be used to configure user-specific session information with the ASP application.However, do not take the correct configuration of the importance of security settings. If you do not correctly configure the security settings, not only make your ASP application to unnecessary tampering, and would hamper legitimate users access to your asp file. Web server to provide a variety of methods to protect your ASPapplications will not be unauthorized user access and tampering. DataSet与的并行执行在ＡＳＰ技术应用程序中的安全性论证【摘要】DataSet包含由DataTable对象表示的零个或多个表的集合。

ASPNET概论

•
NET Framework即以前所谓的NGWS（Next Generation Windows Services），它的目标是成为新一代基于因特网的分布式计算应用开发平台。它的体系结构如下图所示
.NET Framework体系结构
.NET Framework体系结构图
• • • •
通过因特网的标准做整合松散的整合组件支持多种程序语言提高程序开发人员的工作效率
（2）APP_Code文件夹：
包含源代码文件，比如.cs文件。该文件夹中的源代码文件将被动态编译，该文件夹与Bin文件夹有点相似，不同之处在于 Bin放置的是编译好的程序集，而这个文件夹放置的源代码文件
•
•
单击“源”按钮，修改代码，将标签“<h2>”到 “</h2>”中的内容删掉，修改为“这是我的第一个网站”，将两组标签<p></p>中的内容也删掉
•
单击设计视图按钮，敲入“这是我的第一个网站”，“我拖拽的TextBox控件”，之后从工具箱拖拽TextBox控件，再敲入“我拖拽的Button控件”，再从工具箱拖拽Button控件，如图所示。
ASP
•
在ASP的基础上，微软公司推出了ASP. NET，但它并不是ASP的简单升级，它不仅吸收了ASP技术的优点并改正了ASP中的某些错误，更重要的是，它借鉴了Java，VB语言的开发优势，从而成为Microsoft推出的新一代Active Server Pages
ASP. NET
•
• • • •
更好的性能
更好的语言特性更加易于开发更强大的IDE支持更易于配置管理
•
更易于扩展
相对于ASP的优越性

第46讲ASP.NET简介new

它使用站点地图文件可以很方便地在网页上显示导航控件。
.csproj,.vbprojvjs Visual Studio 客户端应用程序项目的项目文件
proj
数据库文件
.mdf.mdb.ldb
数据库信息
Web编程技术
13
(4) 可缩放性和可用性：在设计时考虑了可缩放性，增加了专门用于在聚集环境和多处理器环境中提高性能的功能。另外，进程受到运行库的密切监视和管理，以便当进程行为不正常(泄漏、死锁)时，可就地创建新进程，以帮助保持应用程序始终可用于处理请求。
Web编程技术
9
2. 的优点(4)
Web编程技术
12
4. 应用程序文件
• 在名A称SP中，文文件件类扩展型名只有一种扩展名是.a用s途p的文件，而在 AWSebP窗.体N文件ET中.，aspx由于支持包多含AS种P.N语ET程言序代开码的发文件及，该支文件持可包编含写WebW控e件b和其服他业务逻辑。
• 是一个已编译的、基于.NET 的环境，可以用任何与.NET 兼容的语言(包括 Visual Basic .NET、C# 和 JScript .NET)创作应用程序，而且任何应用程序都可以使用整个.NET Framework。
• 开发人员可以方便地获得这些技术的优点，其中包括托管的公共语言运行库环境、类型安全、继承等等。
Web编程技术
10
3. 的关键技术(1)
完全基于模块与组件，具有更好的可扩展性和定制性，数据处理方面引入了许多新技术。 (1) 事件驱动：允许用服务器控件取代传统的 HTML元素，并充分支持事件驱动机制，不必考虑如何将服务器端的信息回送浏览器，每个控件都有属于自己的事件，每个事件都会触发一个事件处理。 (2) 代码隐藏技术：中引入了代码隐藏 (CodeBehind)技术，通过使用代码隐藏技术、用户控件、自定义控件和组件等方法，可以很好地将程序的执行代码和逻辑代码分开，从而实现了结构化的web页面设计。

ASP[1].net外文翻译

外文文献译文是什么？是一个能在规划好框架的服务器上建造强大的网络应用。

提供几个重要的优于以前的网络发展模型之处："增强的性能。

能在服务器上编译普通语言运行环境不象它的解释前人能利用早的结合、just-in-time编辑，本国的最佳化，贮藏箱的全然的服务。

Unlike its interpreted predecessors, can take advantage of early binding, just-in-time compilation, native optimization, and caching services right out of the box.这数量对戏剧性地较好的性能在你曾写一排密码之前。

"世界第一流水平的工具支持。

的骨架在在视力的电影制片厂整体的发展环境方面的个有钱的工具箱和设计者旁是与补体连结的。

所见即所得编辑、drag-and-drop服务员控制和自动的使用是刚才一特征很少这个强大的工具提供。

"力和柔性。

因为运行时间以普通的语言为基础，完全的台是对网应用启发者有用的力和柔性。

净的骨架类图书馆，通知，数据通道解法从网全部是无缝地可以接近的。

也是语言独立的，因此你能选择语言最好地适用于你的应用或横过许多语言瓜分你的应用。

更多地，普通的语言运行时间相互操作性保证你的现存的对根据COM发展的投资当到移时保存。

"简单性。

使从对使用和地点外形的简单的形式屈服于和顾客证实做普通的任务是容易的。

例如，的页骨架允许你建造使用者界面从表演密码的干净分离的应用逻辑并触摸事件在一简单的，可视化Basic如同形式处理模型。

另外，普通的语言运行时间简化发展，同管理密码服务像自动的提及计算和垃圾收集。

"可管理性。

雇用一个根据正文、hierarchical外形系统，这简化应用对你的服务员环境和网应用安置。

因为外形消息是作为清楚的正文贮藏，新的安置可能没有地方的管理工具的帮助被适用。

网页设计英文翻译

网页设计英文翻译郑州轻工业学院专科毕业设计,论文,英文翻译题目个人博客网站的设计与实现学生姓名吕俊涛专业班级计算机网络技术网页设计09级1班学号 620913510120院 (系) 软件职业技术学院指导教师(职称) 李辉(助教) 完成时间 2011年5月 20日翻译题目: 2.0 专业班级:计算机网络技术(网页设计)09级1班姓名:吕俊涛学号:620913510120英文原文 2.0 is a programming framework built on the common language runtime that can be used on a server to build powerful Web applications. The first version of offered several important advantages over previous Web development models. 2.0 improves upon that foundation by adding support for several new and exciting features in the areas of developer productivity, administration and management, extensibility, and performance:1. Developer Productivity 2.0 encapsulates common Web tasks into application services and controls that can be easily reused across web sites. With thesebasic building blocks, many scenarios can now be implemented with far less custom code than was required in previous versions. With 2.0 it is possible to significantly reduce the amount of code and concepts necessary to build common scenarios on the web.(1)New Server Controls. 2.0 introduces many new server controls that enable powerful declarative support for data access, login security, wizard navigation, menus, tree views, portals, and more. Many of these controls take advantage of core application services in for scenarios like data access, membership and roles, and personalization. Some of the new families of controls in 2.0 are described below.(2)Data Controls. Data access in 2.0 can be accomplished completely declaratively (no code) using the new data-bound and data source controls. There are new data source controls to representdifferent data backbends such as SQL database, business objects, and XML, and there are new data-bound controls for rendering common UI for data, such as grid view, details view, and form view...(3)Navigation Controls. The navigation controls provide common UIfor navigating between pages in your site, such as tree view, menu, and sitemap path. These controls use the site navigation service in 2.0 to retrieve the custom structure you have defined for your site.(4)Login Controls. The new login controls provide the buildingblocks to add authentication and authorization-based UI to your site, such as login forms, create user forms, password retrieval, and customUI for logged in users or roles. These controls use the built-in membership and role services in 2.0 to interact with the userand role information defined for your site.1翻译题目: 2.0 专业班级:计算机网络技术(网页设计)09级1班姓名:吕俊涛学号:620913510120(5)Web Part Controls. Web parts are an exciting new family ofcontrols that enable you to add rich, personalized content and layout to your site, as well as the ability to edit that content and layoutdirectly from your application pages. These controls rely on the personalization services in 2.0 to provide a unique experiencefor each user in your application.(6)Master Pages. This feature provides the ability to define common structure and interface elements for your site, such as a page header, footer, or navigation bar, in a common location called a "master page", to be shared by many pages in your site. In one simple place you can control the look, feel, and much of functionality for an entire Web site. This improves the maintainability of your site and avoids unnecessary duplication of code for shared site structure or behavior.(7)Themes and Skins. The themes and skins features in 2.0 allow for easy customization of your site's look-and-feel. You candefine style information in a common location called a "theme", andapply that style information globally to pages or controls in your site.Like Master Pages, this improves the maintainability of your site and avoids unnecessary duplication of code for shared styles.(8)Personalization. Using the new personalization services in 2.0 you can easily create customized experiences within Web applications. The Profile object enables developers to easily build strongly-typed, sticky data stores for user accounts and build highly customized, relationship based experiences. At the same time, a developer can leverage Web Parts and the personalization service to enable Web site visitors to completely control the layout and behavior of the site, with the knowledge that the site is completely customized for them. Personalization scenarios are now easier to build than ever before and require significantly less code and effort to implement.(9)Localization. Enabling globalization and localization in Websites today is difficult, requiring large amounts of custom code and resources. 2.0 and Visual Studio 2005 provide tools and infrastructure to easily build Localizable sites including the ability to auto-detect incoming locales and display the appropriate locale based UI. Visual Studio 2005 includes built-in tools to dynamically generate resource files and localization references. Together, building localized applications becomes a simple and integrated part of the development experience.2. Administration and Management 2.0 is designed with administration and manageability in mind. We recognize that while simplifying the development experience isimportant, deployment and maintenance in a production environment is also a key component of an application's lifetime. 2.0 introduces several new2翻译题目: 2.0 专业班级:计算机网络技术(网页设计)09级1班姓名:吕俊涛学号:620913510120features that further enhance the deployment, management, and operations of servers.(1)Configuration API. 2.0 contains new configurationmanagement APIs, enabling users to programmatically build programsor scripts that create, read, and update Web.config and machine.config configuration files.(2) MMC Admin Tool. 2.0 provides a newcomprehensive admin tool that plugs into the existing IIS Administration MMC, enabling an administrator to graphically read or change common settings within our XML configuration files.(3)Pre-compilation Tool. 2.0 delivers a new application deployment utility that enables both developers and administrators to precompiled a dynamic application prior to deployment. This recompilation automatically identifies any compilation issues anywhere within the site, as well as enables applications to be deployed without any source being stored on the server (one can optionally removethe content of .asp files as part of the compile phase), further protecting your intellectual property.(4)Health Monitoring and Tracing. 2.0 also provides newhealth-monitoring support to enable administrators to be automatically notified when an application on a server starts to experience problems. New tracing features will enable administrators to capture run-time and request data from a production server to better diagnose issues. 2.0 is delivering features that will enable developers andadministrators to simplify the day-to-day management and maintenance of their Web applications.3. Flexible Extensibility 2.0 is a well-factored and open system, where any component can be easily replaced with a custom implementation. Whether it isserver controls, page handlers, compilation, or core application services, you'll find that all are easily customizable and replaceableto tailor to your needs. Developers can plug in custom code anywhere in the page lifecycle to further customize 2.0 to their needs.(1)Provider-driven Application Services. 2.0 now includesbuilt-in support for membership (user name/password credential storage) and role management services out of the box. The new personalization service enables quick storage/retrieval of user settings and preferences, facilitating rich customization with minimal code. The new site navigation system enables developers to quickly build link structures consistently across a site. As all of these services are provider-driven,they can be easily swapped out and replaced with your own custom implementation. With this extensibility option, you have completecontrol over the data store and schema that drives these richapplication services.3翻译题目: 2.0 专业班级:计算机网络技术(网页设计)09级1班姓名:吕俊涛学号:620913510120(2)0Server Control Extensibility. 2.0 includes improved support for control extensibility, such as more base classes that encapsulate common behaviors, improved designer support, more APIs for interacting with client-side script, metadata-driven support for new features like themes and accessibility verification, better state management, and more.(3)Data Source Controls. Data access in 2.0 is now performed declaratively using data source controls on a page. In this model, support for new data backend storage providers can be easily added by implementing custom data source controls. Additionally, the SqlDataSource control that ships in the box has built-in support for any managed provider that implements the new provider factory model in .(4)Compilation Build Providers. Dynamic compilation in 2.0is now handled by extensible compilation build providers, which associate a particular file extension with a handler that knows how tocompile that extension dynamically at runtime. For example, .rest files can be dynamically compiled to resources, .wsdl files to web service proxies, and .sad files to typed Dataset objects. In addition to the built-in support, it is easy to add support for additional extensions by implementing a custom build provider and registering it in Web.config.(5)Expression Builders. 2.0 introduces a declarative new syntax for referencing code to substitute values into the page, called Expression Builders. 2.0 includes expression builders for referencing string resources for localization, connection strings, application settings, and profile values. You can also write your own expression builders to create your own custom syntax to substitute values in a page rendering.4. Performance and Scalability is built to perform, using a compiled execution model for handling page requests and running on the world's fastest web server, Internet Information Services. 2.0 also introduces key performance benefits over previous versions.(1)64-Bit Support. 2.0 is now 64-bit enabled, meaning it can take advantage of the full memory address space of new 64-bit processors and servers. Developers can simply copy existing 32-bit applications onto a 64-bit 2.0 server and have them automatically be JIT compiled and executed as native 64-bit applications (no source code changes or manual re-compile are required).(2)Caching Improvements. 2.0 also now includes automatic database server cache invalidation. This powerful and easy-to-use feature allows developers to aggressively output cache database-driven page and partial page content within a site and have automatically invalidate these cache4翻译题目: 2.0 专业班级:计算机网络技术(网页设计)09级1班姓名:吕俊涛学号:620913510120entries and refresh the content whenever the back-end database changes. Developers can now safely cache time-critical content for long periods without worrying about serving visitors stale data.The remainder of the Quick Start presents practical examples ofthese and other features in .. NET technologies available to developers to bring a new development framework, it has become an exciting, revolutionary and development of new technologies. . NET is the information technology industry made a thorough solution, regardless of Web developers, component developers, information developers, or any Windows-based developer platform,. NET is a new development model to enable developers better and more quickly to complete the work. SQL Server 2000 is a full support for Web-database product, is a new - generation of Web application development tools, the perfect combination of twodevelopment of the database has become the mainstream Web application direction.译文 2.0是一个编程框架，建立在公共语言运行库，可用于在服务器上建立强大的Web应用程式。