Repeater应该不算是和DataGrid和DataList一路的，只不过看上去有一点像而已。
DataGrid/GridView主要是用来显示数据库报表类的数据的，或者说就是用来显示报表的。
DataList（我认为应该叫做ListView）可以用来显示“格子中自有天地”的数据。比如Blog的comments就可以用DataList来做。
A Brief Overview of the DataGrid Web Control
The DataGrid Web control was designed to display data in an HTML . Each row in the DataGrid's DataSource is displayed as a row in the HTML . The DataGrid has an AutoGenerateColumns property, which can be set to either True or False. If AutoGenerateColumns is set to True (the default), each field in the DataSource is displayed as a column in the resulting HTML . If, however, AutoGenerateColumns is set to False, then the developer must explicitly specify what columns should appear.
One downside of a DataGrid is its rather "blocky" display. That is, the DataGrid displays each DataSource record as a row in an HTML , and each field as a column in said table. While the DataGrid allows for the developer to customize the output for a particular column through the DataSource record occupies precisely one HTML row.
Despite its limitations on specifying the display of the DataGrid's data, the DataGrid is the most commonly used data Web control due to its impressive feature list.
A Brief Overview of the DataList Web Control
The DataList Web control is useful for displaying data that can be highly customized in its layout. By default, the DataList displays its data in an HTML . However, unlike the DataGrid, with the DataList you can specify via the RepeatColumns how many DataSource records should appear per HTML row.
RepeatColumns="5" > Question:
<%# DataBinder.Eval(Container.DataItem, "Description") %> Views:
<%# DataBinder.Eval(Container.DataItem, "ViewCount", "{0:#,###}") %> |
[View a Live Demo!] As the code example above shows, DataLists are comprised of a number of templates. Templates can contain a mix of HTML syntax and databinding expressions, as shown in the above ItemTemplate. Databinding expressions are ones delimited by <%# and %>, and contain code that's executed when the DataListItem's DataBind() method is called. The ItemTemplate specifies the template used for each record in the DataSource. The DataList contains other templates, which are listed below:
- AlternatingItemTemplate - if specified, each alternating item in
DataSource uses this template instead of the ItemTemplate. - EditItemTemplate - the template used when a DataList row is in "edit mode".
- HeaderTemplate - the template for the DataList's header item. Precisely one header item is created for the DataList item if the DataList's
ShowHeader property is set to True. - FooterTemplate - the template for the DataList's footer item. Precisely one footer item is created for the DataList item if the DataList's
ShowFooter property is set to True. - SeparatorTemplate - this template, if specified, is applied after each DataListItem has been added.
The DataList is capable of performing sorting, paging, and editing of its data, but to do so requires quite a bit more programming than to accomplish these tasks with the DataGrid. Therefore, if you know you will be needing these functionalities, it is likely best to proceed with the DataGrid. If, however, you will not need these functionalities, but do necessarily need the extra control over the formatting, consider a DataList.
A Brief Overview of the Repeater Control
The Repeater control, unlike the DataGrid and DataList, is not derived from the WebControl class, and therefore does not have the stylistic properties that are common to all Web controls. (These stylistic properties that are common to all Web controls include Font, ForeColor, BackColor, BorderStyle, and so on.)
The Repeater, like the DataList, only supports templates; however, the Repeater has only a subset of the DataList's template options. Specifically, the following templates can be used with the Repeater:
- AlternatingItemTemplate,
- ItemTemplate,
- HeaderTemplate,
- FooterTemplate, and
- SeparatorTemplate
The Repeater control provides the maximum amount of flexibility over the HTML produced. Whereas the DataGrid wraps the DataSource contents in an HTML , and the DataList wraps the contents in either an HTML or
Therefore, the Repeater is a good data Web control choice if you want to display data in, say, an unordered list. As the following code and live demo show, displaying database data in an unordered list using a Repeater is relatively straightforward. All you have to do is add the DataSource field you want to display to the ItemTemplate:
<%# DataBinder.Eval(Container.DataItem, "Description")%> |
[View a Live Demo!] The Repeater is a good choice if you need to display your data in a format different than an HTML . Unfortunately, the Repeater does not provide any built-in means for editing, sorting, or paging of data. However, these mechanisms could be added programmatically, but would result in a lot of code and effort.
Conclusion
This article examined the similarities and differences of the three data Web controls: the DataGrid, DataList, and Repeater. The main similarities between these three controls is in how they iterate through their DataSource, building up a collection of DataWebControlNameItems. Furthermore, the three Web controls all share three events: ItemCreated, ItemDataBound, and ItemCommand.
Each of the data Web controls has its own strengths and weaknesses. The DataGrid, for example, is great for quickly and easily displaying database data in an HTML , and allows for advanced features such as paging, sorting, and in-place editing to be added with little to no programming. However, the DataGrid is quite limited in the general format with which the data is presented. The DataList allows for more freedom. For example, in an earlier live demo we saw that using the DataList's RepeatColumns property, multiple DataSource records could be displayed in a single HTML row. Additionally, the DataList's content is specified via templates, which allows for a high degree of customization. The Repeater allows for the utmost flexibility in its output, since the only HTML rendered from a Repeater is the HTML generated in its templates. That is, no additional HTML output is generated, as is the case with both the DataGrid and DataList. The Repeater, however, does not have any built-in support for sorting, paging, or editing of its data.
Scenario : 判断给定的某年某月有多少天
Essentially, writing some code to determine the number of days in a given month of a given year with javascript is not the worlds most difficult task. The solution normally involves determining if the month is February, an month with 30 days or a month with 31 days, then (if February) checking if the year is a leap year. All these tests add up, however, and add several lines of code to your .js file.
They are unnecessary! Apparently, the javascript Date function allows you to overflow the day number parameter that you pass, creating a date in the next month. Deliberately overflowing the day parameter and checking how far the resulting date overlaps into the next month is a quick way to tell how many days there were in the queried month. Here is a function that does this:
function daysInMonth(iMonth, iYear) {
return 32 - new Date(iYear, iMonth, 32).getDate();
}
iMonth is zero based, so 0 represents January, 1 represents February, 2 represents March and 11 represents December.
iYear is not zero based, this is the actual calendar year number. (2006 is actually 2006)
How does this function work? It is quite simple. When the Date() function is given a day number that is greater than the number of days in the given month of the given year, it wraps the date into the next month. The getDate() function returns the day of the month, starting from the beginning of the month that the date is in. So, day 32 of March is considered to be day 1 of April. Subtracting 1 from 32 gives the correct number of days in March!
Pray that the browser developers know the correct way to determine whether a year is a leap year! (It's more complicated than a simple mod 4 == 0) Here is a quote from Wikipedia's page on leap years: "The Gregorian calendar, the current standard calendar in most of the world, adds a 29th day to February in all years evenly divisible by 4, except for centennial years (those ending in '00'), which receive the extra day only if they are evenly divisible by 400. Thus 1600, 2000 and 2400 are leap years but 1700, 1800, 1900 and 2100 are not."
ASP.NET includes controls and classes to simplify the process of adding login capabilities to your Web application.
The login controls include:
- Login 用户登录框
A user interface that prompts for user names and passwords and (Remember me 记住我) enables users to select whether they want to be automatically authenticated the next time they visit.
You can use the Login control with ASP.NET membership without writing any code, or you can write your own authentication code by adding a handler for the Authenticate event. - LoginStatus 用户登录按钮/链接 & 用户退出按钮/链接
Displays a login link for users who haven’t been authenticated and a logout link for users who are currently logged in. - LoginName 当前用户的username
Displays the current user’s user name, if logged in. - LoginView 登录后才可以看到的内容/链接
Enables you to display different information to users who are logged in.
For example, you could use this link to go to site features that are available only to authenticated users. - PasswordRecovery 找回密码
Enables password retrieval for a user by sending an e-mail message to the user or by having the user answer a security question. - ChangePassword 修改密码
Enables a user who is logged in to change his or her password. - CreateUserWizard 用户注册
Gathers information from a new user and creates a new account. - You can use a ValidationSummary control to display detailed error information provided by some of these controls.
Introduction
Microsoft ASP.NET AJAX enables you to quickly create Web pages that include a rich user experience with responsive and familiar user interface (UI) elements. ASP.NET AJAX provides client-script libraries that incorporate cross-browser ECMAScript (JavaScript) and dynamic HTML (DHTML) technologies, and it integrates them with the ASP.NET 2.0 server-based development platform. Using ASP.NET AJAX, you can improve both the user experience and the efficiency of your Web applications.
Why Use ASP.NET AJAX?
ASP.NET AJAX enables you to build rich Web applications that have many advantages over Web applications that are completely server-based. ASP.NET AJAX applications offer:
- Improved efficiency by performing significant parts of a Web page's processing in the browser.
- Familiar UI elements such as progress indicators, tooltips, and pop-up windows.
- Partial-page updates that refresh only the parts of the Web page that have been updated.
- Client integration with ASP.NET application services for forms authentication and user profiles.
- Integration of data from different sources through calls to Web services.
- A framework that simplifies customization of server controls to include client capabilities.
- Support for the most popular and commonly used browsers, including Microsoft Internet Explorer, Mozilla Firefox, and Apple Safari.
ASP.NET AJAX Architecture
ASP.NET AJAX consists of client-script libraries and of server components that are integrated to provide a robust development framework. In addition to ASP.NET AJAX, you can use the ASP.NET AJAX Control Toolkit and the community-supported features in the ASP.NET AJAX Futures releases.
ASP.NET AJAX Server Components
The ASP.NET AJAX server components consist of ASP.NET controls and components to manage the UI and flow of an application, and to manage serialization, validation, control extensibility, and so on. There are also ASP.NET Web services that enable you to access ASP.NET application services for forms authentication and user profiles.
ASP.NET AJAX Server Controls
The ASP.NET AJAX server controls consist of server and client code that integrate to produce AJAX-like behavior. The following list describes the most frequently used ASP.NET AJAX server controls.
- ScriptManager
Manages script resources for client components, partial-page rendering, localization, globalization, and custom user scripts. The ScriptManager control is required in order to use the UpdatePanel, UpdateProgress, and Timer controls. - UpdatePanel
Enables you to refresh selected parts of the page instead of refreshing the whole page by using a synchronous postback. - UpdateProgress
Provides status information about partial-page updates in UpdatePanel controls. - Timer
Performs postbacks at defined intervals. You can use the Timer control to post the whole page, or together with the UpdatePanel control to perform partial-page updates at a defined interval.
ASP.NET AJAX Web Services
ASP.NET AJAX exposes ASP.NET application services for forms authentication and user profiles to client script by using Web services. This enables you to help protect resources by using forms authentication and to persist user-specific settings on the server by using client script. In addition, ASP.NET AJAX includes network components that make it easy to return results from any Web service call.
For information and examples, see Asynchronous Communication Layer Overview and ASP.NET Application Services Tutorials.
ASP.NET AJAX Server Control Extensibility
ASP.NET AJAX enables you to create custom ASP.NET AJAX server controls that include client behaviors. For information and examples, see the ASP.NET AJAX Extensibility tutorials and the Microsoft ASP.NET AJAX Control Toolkit.
ASP.NET AJAX Client Components
The ASP.NET AJAX client-script libraries consist of JavaScript (.js) files that provide features for object-oriented development. This has not been previously available to JavaScript developers. The object-oriented features included in the ASP.NET AJAX client-script libraries enable a new level of consistency and modularity in client scripting. The following layers are included in the ASP.NET AJAX script libraries:
- A browser compatibility layer.
This provides compatibility across the most frequently used browsers (including Microsoft Internet Explorer, Mozilla Firefox, and Apple Safari) for your ASP.NET AJAX scripts. - ASP.NET AJAX core services,
which include extensions to JavaScript, such as classes, namespaces, event handling, inheritance, data types, and object serialization. - An ASP.NET AJAX base class library,
which includes components such as string builders and extended error handling. - A networking layer
that handles communication with Web-based services and applications, and that manages asynchronous remote method calls.
ASP.NET AJAX Control Toolkit
The ASP.NET AJAX Control Toolkit is a collection of samples and components that show you some of the experiences you can create with rich client ASP.NET AJAX controls and extenders. The Control Toolkit provides both samples and a powerful SDK to simplify creating and reusing your custom controls and extenders.
ASP.NET AJAX Community-supported Futures Releases
The ASP.NET AJAX community-supported Futures releases provide features that extend the core ASP.NET AJAX platform with functionality that remains under development and is not included in the Microsoft ASP.NET AJAX release. This includes additional extender controls, support for client declarative syntax (xml-script), and more.
Introduction
Partial-page rendering removes the need for the whole page to be refreshed as the result of a postback. Instead, only individual regions of the page that have changed are updated. As a result, users do not see the whole page reload with every postback, which makes user interaction with the Web page more seamless. Microsoft ASP.NET 2.0 AJAX Extensions enables you to add partial-page rendering to new or existing ASP.NET Web pages without writing client script.
Scenarios
ASP.NET 2.0 AJAX Extensions enables you to extend existing ASP.NET 2.0 applications and develop new ones that incorporate AJAX (Asynchronous JavaScript and XML) functionality. Use ASP.NET 2.0 AJAX Extensions when you want to do the following:
- Improve the user experience with Web pages that are richer, that are more responsive to user actions, and that behave like traditional client applications.
- Reduce full-page refreshes and avoid page flicker.
- Enable cross-browser compatibility without writing client script.
- Perform AJAX-style client/server communication without writing client script.
- Use the controls and components from the ASP.NET AJAX Control Toolkit.
- Develop custom Microsoft ASP.NET AJAX controls.
Partial-Page Rendering Features
Partial-page rendering relies on server controls in ASP.NET 2.0 AJAX Extensions and on client functions in the Microsoft AJAX Library. You do not have to use the Microsoft AJAX Library to enable partial-page rendering, because this functionality is provided automatically when you use the ASP.NET 2.0 AJAX Extensions server controls.
The primary features of Microsoft ASP.NET AJAX partial-page rendering include the following:
- A declarative model that works like ASP.NET server controls. In many scenarios, you can specify partial-page rendering using only declarative markup.
- Server controls that perform the underlying tasks required for partial-page updates. These include the ScriptManager control and the UpdatePanel control.
- Integration between ASP.NET 2.0 AJAX Extensions server controls and the Microsoft AJAX Library for common tasks. These tasks include enabling users to cancel a postback, displaying custom progress messages during an asynchronous postback, and determining how multiple clicks are processed.
- Error-handling options for partial-page rendering, which enable you to customize how errors are displayed in the browser.
- Cross browser compatibility, which is built into the Microsoft AJAX Library. Simply using the server controls automatically invokes the correct browser functionality.
Server Controls for Partial-Page Updates
To add AJAX functionality to ASP.NET Web pages, you identify individual sections of the page that you want to update. You then put the content of these sections into UpdatePanel controls. The contents of an UpdatePanel control can be HTML or other ASP.NET controls. You can add an UpdatePanel control to the page as you would any other control.
By default, postbacks originating from controls inside the update panel (child controls) automatically initiate asynchronous postbacks and cause a partial-page update. You can also specify that controls outside the UpdatePanel cause an asynchronous postback and that they refresh the UpdatePanel control's content. A control that causes an asynchronous postback is referred to as a trigger.
An asynchronous postback behaves much like a synchronous postback. All the server page life-cycle events occur and view state and form data are preserved. However, in the rendering phase, only the contents of theUpdatePanel control are sent to the browser. The rest of the page remains unchanged.
To support partial-page rendering, you must put a ScriptManager control on the page.
The ScriptManager control:
- keeps track of all the update panels on the page and their triggers.
- coordinates partial-page rendering behavior on the server.
- determines which sections of the page to render as a result of an asynchronous postback.
Enabling Partial-Page Rendering Support
You enable or disable partial-page rendering for a page by setting the EnablePartialRendering property of the ScriptManager control.
You can also specify whether partial-page rendering is supported for a page by setting the SupportsPartialRendering property of the ScriptManager control.
If you do not set the SupportsPartialRendering property and if the EnablePartialRendering property is true (which is the default), the capabilities of the browser are used to determine whether partial-rendering is supported.
If partial-page rendering is not enabled for a page, if it has been disabled, or if it is not supported in a browser, the page uses fallback behavior. Actions that ordinarily would perform an asynchronous postback instead perform a synchronous postback and update the whole page. Any UpdatePanel controls on the page are ignored, and their contents are rendered as if they were not inside an UpdatePanel control.
A control adapter is an optional class that, if present and properly configured, is used to render the Web control instead of using the control's default rendering logic. In short, using control adapters you can take the core functionality of a Web control, but completely customize the markup emitted.
This set of free control adapters, released by Microsoft, provide a set of control adapters that render a variety of built-in ASP.NET controls using preferred CSS techniques.
Moreover, the CSS control adapters ignore any control-level style settings that would get rendered as inline style elements in the rendered markup and instead require that style information be separated out and specified via CSS classes.
While these could be created from scratch, Microsoft has provided the ASP.NET 2.0 CSS Friendly Control Adapters that can be downloaded and plugged into your ASP.NET web applications with minimal effort. Once installed, the control adapters will no longer render inline style attributes (you need to use CSS classes) and replaces the
layouts of the Menu, TreeView, and other controls with CSS techniques.
The presentation settings for these classes can be specified in the page's style element or, ideally, in a separate CSS file.
Indeed, you can modify any ASP.NET control so it produces exactly the HTML you want.
I think Microsoft will build the CSS features into ASP.NET 3.0 as an essence. We won't use inline style anymore, neither table tags for layout, at least I won't. :-)
Actually, I really do not care about what kind of code is beneith the screen/page, I only require it works well as I and users expected. CSS or inline style, table or div, I don't give a fuck. As we get the better one freely and effortlessly, why not better. ;-) That's it.
d Windows authentication is used together with IIS authentication. When IIS authentication is complete, ASP.NET uses the authenticated identitiy to authorize access.
d In a Windows-based authentication model, the requests go directly to IIS to provide the authentication process. IIS first takes the user's credentials from the domain login. If this process fails, IIS desplays a pop-up dialog box so the user can enter his login information.
d Windows authenticaton is quite uesful in an intranet environment where you can let the server deal completely with the authentication process, especially in environments where users are already logged onto a network.
d When your code is excuted by IIS, it executes under the context of ASP.NET Worker Process user account (ASP.NET) , therefore, your application may be restricted by that account's security rights.
d By deafult, the ASP.NET Worker Process does not have rights to write to the local disk.
^ What the ASP.NET Worker Process is allowed to do inside of the IO namespace?
d Someone said: Directory is a static class, while DirectoryInfo can be instantiated. Basically, both work the same.
d The Directory class exposes static methods you can use to create, move, and delete directories. The DirectoryInfo represents a specific directory and lets you perform many of the same actions as the Directory class on the specific directory. Additionally, it enumerates child directoreis and files.
^ 我想尽量兼顾VB.NET和C#。
^ Field/Class Variable: Pascal Case。Always indicate Private, do not use Dim.
^ Property: Pascal Case。
^ Parameter: Camel Case。在method body中，定义一个Local Variable，采用Pascal Case命名，除了首字母其他完全一致，然后把parameter赋值给相应的Local Variable。
^ Property和Method是给“外人”看的，命名要“好看”，所以就要规规矩矩地Pascal Case。Field是自己用的，所以命名可以有点儿“特色”。
d Field: Camel Case with Leading Underscore. In VB.NET, always indicate "Protected" or "Private", do not use "Dim".
Of all the items here, the leading underscore is really the only controversial one. I personally prefer it over straight underscore-less camel case for my private variables so that I don't have to qualify variable names with "this." to distinguish from parameters in constructors or elsewhere where I likely will have a naming collision. With VB.NET's case insensitivity, this is even more important as your accessor properties will usually have the same name as your private member variables except for the underscore.
d Properties: Pascal Case, no underscores. Try to avoid abbreviations. Members must differ by more than case to be usable from case-insensitive languages like Visual Basic .NET.
VB: Public Property RecordID As Integer
C#: public int RecordID
d Parameters: Camel Case. Try to avoid abbreviations. Parameters must differ by more than case to be usable from case-insensitive languages like Visual Basic .NET.
VB: ByRef recordID As Integer
C#: ref int recordID
d What are your thoughts on naming conventions that need to be used to distinguish the class variables, function local variables and method arguments?
d By class variables, I assume you mean fields. Those should be private (use properties for public exposure to provide a level of abstraction). For function locals, those are by definition private. For method arguments, those need to be camelCased. For the privates, I have seen two patterns in the .NET Framework: one is leading underscore, and the other is this.Foo. Either works for me.
d However, I then had to do some VB.NET development and the language isn't case sensitive. I've seen some examples that add a "Field" suffix in VB.NET . I think that is worse than a leading "_". So I came full circle and started using "_" again. :)
e Designing .NET Class Libraries: Naming Conventions (January 26, 2005)
e .NET Programming Standards and Naming Conventions
There are and will be many and many AJAX controls, some of them are the essentials and the mostly used. 主要是关于Panel的“基层”control，我称之为“Panel Group”吧。Thus, learn to use them in the first wave:
d UpdatePanel
这个是最基本的。专门研究吧。
d PopupControl
PopupControl is an ASP.NET AJAX extender that can be attached to any control in order to open a popup window that displays additional content.
This popup window will probably be interactive and will probably be within an ASP.NET AJAX UpdatePanel, so it will be able to perform complex server-based processing (including postbacks) without affecting the rest of the page.
The popup window can contain any content, including ASP.NET server controls, HTML elements, etc..
Once the work of the popup window is done, a simple server-side call dismisses it and triggers any relevant script on the client to run and update the page dynamically.
^ 这是个基本的control，也是比较原始意义的AJAX功能，用途比较广泛。比如填写某个TextBox的时候，可以探出一个小Panel用于选择日期，计算某些数等等。
d HoverMenu
HoverMenu is an ASP.NET AJAX extender that can be attached to any ASP.NET WebControl, and will associate that control with a popup panel to display additional content.
^ 我觉得HoverMenu这个名字起得不好，不如叫HoverPopupPanel。这种功能倒是会用得挺多，比如用于当鼠标滑到某个位置的时候，弹出一个圆角小方框显示文字。
d CollapsiblePanel
The CollapsiblePanel is a very flexible extender that allows you to easily add Collapsible sections to your web page. This extender targets any ASP.NET Panel control.
The page developer specifies which control(s) on the page should be the open/close controller for the panel, or the panel can be set to automatically expand and/or collapse when the mouse cursor moves in or out of it, respectively.
d Accordion
The Accordion is a web control that allows you to provide multiple panes and display them one at a time. It is like having several CollapsiblePanels where only one can be expanded at a time.
The Accordion is implemented as a web control that contains AccordionPane web controls. Each AccordionPane control has a template for its Header and its Content. We keep track of the selected pane so it stays visible across postbacks.
d DynamicPopulate
DynamicPopulate is a simple extender that replaces the contents of a control with the result of a web service or page method call. The method call returns a string of HTML that is inserted as the children of the target element.
^ 这应该最原始意义上的AJAX功能。
非常高兴Microsoft ASP.NET AJAX 1.0 Beta终于发布了。虽然此前基于Altas写了不少代码，我还是很愿意告别Prince Atlas，修改到新的ASP.NET AJAX上来。
我认为，AJAX虽然目前看来似乎是一种新技术，有一点独立性，但最终而且不久就会完全融合进ASP.NET中，成为ASP.NET 3.0，的基本属性。我们不会再特意安装AJAX包，也不需要在aspx文件中特别声明什么，因为它已经是ASP.NET的native and default features。在开发中使用AJAX feature，我们也不会看到很特殊的AJAX的标签，因为提供AJAX功能的标签都会统一在asp下。
其实，在目前的ASP.NET 2.0中，我们就已经能够看到一些默认的AJAX feature了。比如GridView中的sorting，paging等feature。而且会在ASP.NET页面的Page命令中找到一个叫Async的attribute，这就是用来启动Asyncronous功能的。
在未来的版本（ASP.NET 3.0）中，我预计AJAX相关的功能和feature会被统一规划，完全融合进ASP.NET的血液中，消失得无影踪。你将不再能找到AJAX，你只会看到被注入新的血液的ASP.NET。
我非常喜欢Microsoft ASP.NET AJAX的另一个原因是其使用方式。不像Ruby on Rails那样需要在RHTML中写很多看起来有些奇怪的代码，也不需要像Google Web Toolkit那些通过写Java代码来获得AJAX功能。在Microsoft ASP.NET AJAX中，我们只需要通过写标签的方式通过Server Control来实现出色的AJAX功能。也就是通过Declarative Programming的方式来快速地实现AJAX，就如同使用普通的ASP.NET Server Control一样。当然，这个问题实质上是关于Declarative Programming和Imperetive Programming两种开发流派孰优何优。
总之，对于使用过Ruby on Rails，Google Web Toolkit和Microsoft ASP.NET AJAX的我来说，我更喜欢Microsoft ASP.NET AJAX，因为它符合我对Declarative Programming的倾向性以及我对productivity（高生产效率）的强烈需求。
^ What is Interoperation for?
There might be many lines of legacy code left for companies. If they had to rewrite and retest thiese codes prior to launching any new application developed in .NET, they would have never made the switch. Using an "all or nothing" approach with migrating to .NET is simply too expensive and time consuming for many companies with investments in legacy code.
By taking advantage of Interoperation, they are able to migrate their existing applications little by little, in a manner that was virtually transparent to clients. Were it not for Interoperation, they would have never made the migration.
^ Prior to advent of the .NET Framework, the COM Framework was the primary framework for developers to interact with the Windows operating system.
d The mechanism that serves as proxy so that the .NET runtime can communicate with a COM component is known as a Runtime Callable Wrapper (RCW), which handles the majority of the work between .NET and COM for you, including marshaling data types, handling events, and handling interfaces.
d Unlike pure .NET components, COM components must be registered before they can be used.
d Every COM components must have an entry in the Windows registry.
d After importing it, using an object contained in a given COM library is virtually identical to using ne created purely in .NET.
d What is Platform Invoke? and when to use it?
d Use Platform Invoke through the System.Runtime.InteropServices namespace:
- Create a static/shared external method with the name of the function you want to call.
- Decorate it with the DllImport attribute specifying the library that it should call.
- Call the method from your code.
Imports System.Runtime.InteropServices
Public Class InterExample
Private Shared Function GetForeWindow() As IntPtr
End Function
Public Shared Sub GetScreenDemo()
Dim DemoHandle = GetForeWindow()
End Sub
End Class
d Encapsulating DLL Functions: Because Platform Invoke calls is not elegant, it's often beneficial to create a class that exposes them and wraps this functionality. After all, much of the .NET Framework is composed of precisely this methodology.
@ You need to call an unmanaged function from your managed code by using Platform Invoke services. What should you do?
Create a class to hold DLL functions and then create prototype methods by using managed code.
CAS
@ When you run an unmanaged application in Windows 2003, XP or earlier, that code gets all the privileges your user account has. The application can do anything your user account has permissionos to do. so you are forced to log on with minimal privileges to restrict application permissions.
@ Code Access Security (CAS), a concept that .NET Framework introducted into Windows, enables users to restrict on a very granular level what managed application can do.
@ CAS allows administrators and developers to control applicatoin authorization similar to the way they have always been albe to authorize users.
@ Unfortunately, CAS can be applied only to managed applications that use the .NET Framework runtime. Unmanaged applications run without any CAS restrictions and are limited only by the operating system's RBS.
^ ASP.NET中的Membership和Role Management是对“人”（people, user）的权限管理（authentication和authorization）；而CAS则是对“程序”（application，code）进行权限管理。
Evidence
@ Generally, a security system use the username, password, access control lists to identify users and determine what a user can and can't do. However, CAS identifies and assigns permissions to applications ratha than to people, thus, it identifies assembilies using evdience.
@ In CAS, evidence is used just like a person's passport, password, and PIN - information that proves identity and describes an individual as deserving a certain level of trust.
@ Each piece of evidence is a way that an assembly can be identified, such as the location (folder or website) where the assembly is stored and running, a hash of the assembly's code, or the assembly's digital signature.
@ There are 2 types of evidence: host evidence and assembly evidence:
- Host evidence describes the assembly's origin, such as the application directory, URL, or site; and also describes the assembly's identity, such as the hash, pulisher, or strong name.
- Assembly evidence are ones provided by custom user or developer.
^ I think evidence is the Authentication part of the security process for application or code, just like username and password are the Authentication for people or users.
Permission
@ A permission is a CAS access control entry.
^ A permission set is a CAS ACL (Access Control List).
@ Queue your task for execution by passing the WaitCallback delegate to ThreadPool.QueueUserWorkItem. Your callback method executes when a thread pool thread becomes available.
@ In many cases, creating your own thread is not necessary or suggested.
The threading system in .NET supports a built-in thread pool that can be used in many situations where you might expect to create your own threads.
e The Managed Thread Pool
What you should NOT do in cleaning up unmanaged resoures!
- You should prevent users of your application from calling an object's Finalize method directly by limiting its scope to protected.
- You are strongly discouraged from calling a Finalize method for a class other than your base class directly from your application's code.
How to properly clean up unmanaged resources?
@ To properly dispose of unmanaged resources, it is recommended that you implement a public Dispose or Close method that executes the necessary cleanup code for the object.
@ The IDisposable interface provides the Dispose method for resource classes that implement the interface. Because it is public, users of your application can call the Dispose method directly to free memory used by unmanaged resources.
@ When you properly implement a Dispose method, the Finalize method becomes a safeguard to clean up resources in the event that the Dispose method is not called.
@ The
IDisposable Interface defines a method to release allocated unmanaged resources.
Why do we need IDisposable?- The garbage collector automatically releases the memory allocated to a managed object when that object is no longer used, however, it is not possible to predict when garbage collection will occur.
- Furthermore, the garbage collector has no knowledge of unmanaged resources such as window handles, or open files and streams.
@ Thus, we should use the Dispose method of this interface to explicitly release unmanaged resources in conjunction with the garbage collector.
@ The consumer of an object can call this method when the object is no longer needed.
@ When calling a class that implements the IDisposable interface, use the try-finally pattern to make sure that unmanaged resources are disposed of even if an exception interrupts your application.
@ Destructors are used to destruct instances of classes.
Using Destructors to Release Resources
@ In general, C# does not require as much memory management as is needed when developing with a language that does not target a runtime with garbage collection. This is because the .NET Framework garbage collector implicitly manages the allocation and release of memory for your objects.
When your application encapsulates unmanaged resources such as windows, files, and network connections, you should use destructors to free those resources. When the object is eligible for destruction, the garbage collector runs the object's Finalize method.
@ A class can only have one destructor.
@ Destructors cannot be inherited or overloaded.
@ Destructors cannot be called. They are invoked automatically.
@ A destructor does not take modifiers or have parameters.
@ Destructors cannot be defined in structs. They are only used with classes.
@ The programmer has no control over when the destructor is called because this is determined by the garbage collector.
The garbage collector checks for objects that are no longer being used by the application. If it considers an object eligible for destruction, it calls the destructor (if any) and reclaims the memory used to store the object.
Destructors are also called when the program exits.
e Implementing a Dispose Method
e Garbage Collection
e Cleaning Up Unmanaged Resources
@ You need to ascertain wheter a method named OneMethod is accessible to a derived class. What shoud you do?
^ Call the IsFamily property of the MethodInfo Class.
@ The IsFamily property gets a value indicating whether the visibility of this method or constructor is described by MethodAttributes.Family; that is, the method or constructor is visible only within its class and derived classes. (Inherited from MethodBase.)
^ Family Indicates that the method is accessible only to members of this class and its derived classes.
^ The MethodAttribute enumeration also contains:
Abstract Indicates that the class does not provide an implementation of this method.
Assembly Indicates that the method is accessible to any class of this assembly.
Final Indicates that the method cannot be overridden.
Private Indicates that the method is accessible only to the current class.
Virtual Indicates that the method is virtual
Static Indicates that the method is defined on the type; otherwise, it is defined per instance.
e You can read more about MethodAttributes's member here.
e About MethodInfo class
The Type class有什么用？
@ The Type class represents a single type, allowing you to look at the methods, properties, events, interfaces, and inheritance tree of a particular type in the system.
How to get the Type object?
@ You can get Type object in 4 ways:
- From the Assembly class
- From the Module class
- From the instance of an object
- Using keyword typeof in C# or GetType in VB.
@ 1st way: from the Assembly class:
Dim OneAssembly As Assembly = Assembly.GetExecutingAssembly()
Dim AssemblyTypes() As Type = OneAssembly.GetTypes()
@ 2nd way: from the Module class:
Dim AllModulesOfOneAssembly As [Module] = OneAssembly.GetModules()
Dim OneModuleOfOneAssembly As [Module] = AllModulesOfOneAssembly(0)
Dim AllTypesOfOneModuleOfOneAssembly () As Type = OneModuleOfOneAssembly .GetTypes()
@ 3rd way: get the type of the instance of an object by calling its GetType method:
Dim OneObject As New Object()
Dim TypeOfOneObject As Type = OneObject.GetType()
@ 4th way: create a Type object using C# typeof / VB GetType keywork:
Dim OneSpecificType As Type = GetType(Int32) 'VB
Type OneSpecificType = typeof(Int32) //C#
<%-- content to comment --%>
@ Server-side comments allow developers to embed code comments in any part of an ASP.NET application file (except for within script code blocks).
@ Any content between opening and closing tags of server-side comment elements, whether ASP.NET code or literal text, will not be processed on the server or rendered to the resulting page.
@ A compilation error will occur if you use server-side comment blocks within <% %>blocks.
@ Server-side comment blocks cannot be nested.
@ Add a Literal Web server control to your page when you want to set text programmatically without adding extra HTML tags. The Literal control is useful as a way to add text into a page dynamically without adding any elements that are not part of the dynamic text. For example, you can use the Literal control to display HTML that you read from a file or from a stream.
@ If you want to display static text, you can present it using HTML; you do not need a Literal control. Use a Literal control only if you need to render text programmatically.
@ You can use a Literal Web server control as a container for other content on the page. The Literal control is used most frequently when adding content dynamically to the page.
Comparing the Literal Control to Other Options
The Literal control represents one of several options for adding content to a page. For static content, you can add markup directly to a page as HTML, without using a container. However, if you want to add content dynamically, you must add the content to a container. Typical containers are the Label control, the Literal control, the Panel control, and the Placeholder control.
The Literal control differs from the Label control in that the Literal control does not add any HTML elements to the text. (The Label control renders a span element.) As a consequence, the Literal control does not support any style attributes, including position attributes. However, the Literal control allows you to specify whether content is encoded.
The Panel and Placeholder controls render as div elements, which create discrete blocks in the page, unlike rendering in-line the way the Label and Literal controls do.
In general, use a Literal control when you want to render text and controls directly into a page without any additional markup.
e ASP.NET Integration with IIS7 Written by Mike Volodarsky
ASP.NET Enhancements on IIS7
Better ASP.NET integration in IIS7 both enhances existing applications, and allows new applications to take advantage of ASP.NET features in new ways:
- ASP.NET services can be used for all content types.
In the past, ASP.NET functionality such as Forms Authentication, Roles, Url Authorization, and Output Caching were only available to ASP.NET content types (ASPX pages, for example). Static files, ASP pages, and other content types could not benefit from these services.
In IIS7, all ASP.NET services can be provided uniformly to all content. For example, you can protect all of your web content, including images and asp pages, with your existing ASP.NET 2.0 access control solution built on ASP.NET Forms Authentication, Membership and Login controls. - Fully extend IIS with ASP.NET.
Previous versions of IIS frequently required server extensibility to be developed using the native ISAPI filter or extension extensibility mode, due to the runtime limitations of ASP.NET.
IIS7 allows ASP.NET modules to plug in directly into the server pipeline, with the same runtime fidelity as modules developed with the native (C++) server API. ASP.NET modules can execute in all runtime stages of the request processing pipeline, and be executed in any order with respect to native modules. The ASP.NET API has also been expanded to allow more control over request processing then was previously possible. - Unified server runtime.
Tighter ASP.NET integration also allows many of the features between IIS and ASP.NET to be unified. IIS7 features unified configuration for IIS and ASP.NET modules and handlers. Many other features, including custom errors, and tracing, have been unified to allow better management and cohesive application design.
ASP.NET Integration Architecture
In IIS7, the ASP.NET request processing pipeline overlays the IIS pipeline directly, essentially providing a wrapper over it instead of plugging into it.
A request arriving for any content type is processed by IIS, with both native IIS modules and ASP.NET modules being able to provide request processing in all stages. This enables services provided by ASP.NET modules like Forms Authentication or Output Cache to be used for requests to ASP pages, PHP pages, static files, and so on.
The ability to plug in directly into the server pipeline allows ASP.NET modules to replace, run before, or run after any IIS functionality. This enables, for example, a custom ASP.NET basic authentication module written to use the Membership service and SQL Server user database to replace the built in IIS basic authentication feature that works only with Windows accounts.
In addition, the expanded ASP.NET APIs take advantage of direct integration to enable more request processing tasks. For example, ASP.NET modules can modify request headers before other components process the request, inserting an Accept-Language header before ASP applications execute in order to force localized content to be sent back to the client based on user preference.
Because of the runtime integration, IIS and ASP.NET can use the same configuration for enabling and ordering server modules, and configuring handler mappings. Other unified functionality includes tracing, custom errors, and output caching.
Runtime Fidelity
In Integrated mode, the ASP.NET request processing stages exposed to modules are directly connected to the corresponding stages of the IIS pipeline. The complete pipeline contains the following stages, exposed as HttpApplication events in ASP.NET:
- BeginRequest. The request processing is starting.
- AuthenticateRequest. The request is being authenticated. IIS and ASP.NET authentication modules subscribe to this stage to perform authentication.
- PostAuthenticateRequest
- AuthorizeRequest. The request is being authorized. IIS and ASP.NET authorization modules check whether the authenticated user has access to the resource being requested.
- PostAuthorizeRequest
- ResolveRequestCache. Cache modules can check whether the response to this request exists in the cache, and return it instead of proceeding with the rest of the execution path. Both ASP.NET Output Cache and the new IIS Output Cache features execute here.
- PostResolveRequestCache
- MapRequestHandler. This stage is internal in ASP.NET, and is used to determine the request handler.
- PostMapRequestHandler
- AcquireRequestState. The state necessary for the request execution is being fetched. ASP.NET Session State, and Profile modules obtain their data here.
- PostAcquireRequestState
- PreExecuteRequestHandler. Any tasks before the execution of the handler can be performed here.
- ExecuteRequestHandler. The request handler executes here. ASPX pages, ASP pages, CGI programs, and static files are served here.
- PostExecuteRequestHandler
- ReleaseRequestState. The request state changes are saved, and the state is cleaned up here. ASP.NET Session State and Profile modules use this stage for cleanup.
- PostReleaseRequestState
- UpdateRequestCache. The response can be stored in the cache for future use here. The ASP.NET Output Cache and IIS Output Cache modules execute here to save the response to their caches.
- PostUpdateRequestCache
- LogRequest. This stage is used to log the results of the request, and is guaranteed to execute even if errors occur.
- PostLogRequest
- EndRequest. This stage is used to perform any final request cleanup, and is guaranteed to execute even if errors occur.
The ability to execute in the same stages as IIS modules makes many tasks previously only accessible to native ISAPI filters and extensions now possible in managed code, using the familiar ASP.NET APIs and the rich functionality of the .NET platform. For example, you can now write modules that do the following:
- Intercept the request before any processing has taken place, for example for re-writing urls or performing security filtering.
- Replace built in authentication modes.
- Modify the incoming request contents, such as request headers.
- Filter outgoing responses for all content types.
^ 有人说有经验的programmer在VB.NET和C#之间转换只需要一个星期的时间，我也觉得不需要费多久。我现在在一个咨询项目里使用这两种语言，经常是今天VB.NET，明天C#，需要做的就是偶尔查查MSDN上的Language Syntax Reference。写程序，关键的是编程思想，语法差别不是重要的。所以，我很乐意地说：VB.NET和C#我都用得挺好。
^ 我从前写了四五年Java，从Java到C#转换我没有感觉有多少困难。反正我写程序的方式、风格、思路还是一样。并且，我还是可以随时用Java编程。所以，我认为：
最重要的是deep understanding of Object-Oriented。
非常重要的是programming patterns and best practices。
很重要的是very familiar with class library。
也很重要的是experienced with top IDEs。
e How popular is VB .NET versus C#?
e VB.NET and C# Comparison
e Java (J2SE 5.0) and C# Comparison
e VB.NET vs C#: The Great .NET Language Debate
@ Properties can be considered smarter fields in that they can be assigned to or read from (like a field), yet when this happens some code in the class executes, and therefore the author of the class can process the value being assigned or returned.
@ Inside the Property block, you write a Get…End Get block, which defines which value the property returns, and a Set…End Set block, which defines how values are assigned to the property.
@ In most cases, a property simply maps to a Private field, so the code for these two blocks often looks like this:
Dim m_BirthDate As Date
Public Property BirthDate() As Date
Get
Return m_BirthDate
End Get
Set(ByVal value As Date)
m_BirthDate = value
End Set
End Property
By Robert Eckstein, September 27, 2005
Thinking of migrating to the Java 2 Platform, Standard Edition (J2SE) 5.0, code-named Tiger? You're not alone. Thousands of companies all over the world are giving J2SE 5.0 a try, and they like what they see. New language features, enhanced class libraries, better tool support, and desktop enhancements are just some of the reasons why many companies are making the switch.
In this article, we talk with Li Moore, software engineer at Google, Inc., about his company's switch from J2SE version 1.4 to 5.0.
Thanks for talking with me today, Li. Google is, of course, the worldwide search engine of choice. How does Google use Java technology?
Google makes extensive use of the Java platform. Large parts of popular Google products are written in Java. We also use Java in many internal systems and products under development.
Which core and enterprise APIs or technologies are critical to your work?
We make heavy use of core Java APIs including the Collections API, java.util.concurrent, and java.nio. We also make heavy use of the Servlet API.
Did you expect that any changes with the 5.0 version of the JDK might be detrimental to your Java applications at Google?
Nope. Everyone was excited about the new language features, the new concurrency libraries, and the new monitoring and management facilities.
Were there any Tiger features that made you say, "Oh, this is great! We needed this a while ago"?
We've wanted enums and generics at Google for years. Like everyone else, we wrote our own thread pool and work queue classes years ago.
Tell us about the migration process. What sort of issues and surprises did you encounter?
I learned about Tiger in the fall of 2004. I liked what I saw and took it upon myself to convert all of our Java development to JDK 5.0. I worked on the migration as a 20 percent project: Google lets its engineers devote 20 percent of their time to any project that they think is cool and in the company's interest.
We migrated to Tiger in stages. First, we tried it on existing code without using any of the new features. Of course, we ran into the same problem that everyone does -- enum is now a reserved word. That's an easy, if tedious, one to fix. Then we tested the performance of some key applications. We were pleasantly surprised when they ran significantly faster on the new release.
I met with key people from various projects and got buy-in for the transition. We came up with a schedule that culminated in a flag day, when everyone felt comfortable switching. I mapped out a transition plan for each project and created documentation to help people with the transition. We had a little difficulty getting all the tests to pass. We discovered a few minor compatibility issues with the new release, which we reported back to Sun, which has since fixed them.
When it came time to make the actual switch, we had no problems. We were pleasantly surprised by how easy it was. Developers were enthusiastic about the transition and quickly followed flag day with changes that upgraded existing code to use the new language features.
If you could make one change to the Java core or enterprise APIs right now, what would it be? If you could add one feature, what would it be?
It would be nice to add a clone() method to Cloneable, but unfortunately that's not possible at this point. Also, it would be nice to make the byte type unsigned. More realistically, I'd like to see a pluggable file system API like the one that Sun proposed in JSR 203.
Have you tested your applications against the prerelease of Mustang?
No, but we have started using some of the forthcoming concurrency utilities that are already available for use on the JSR 166 interest site.
Is there anything you would like to add?
Our developers were already excited about J2SE 5.0 several weeks before the transition. As soon as we switched, use of the new features just took off. Even something as simple as the new for-each loop makes it so much more fun to write Java programs.
This release is purely an improvement, in terms of language features, libraries, stability, performance, and tools. I can't imagine why anyone would use the 1.4 release at this point.
Article Origine: http://java.sun.com/developer/technicalArticles/J2SE/google/limoore.html
///
/// 把指定栏中的相同内容的cells合并成一个cell。
///
///
///
public void MergeIdenticalCells(int _rowIndexOfStartCell, int _columnIndexOfStartCell)
{
// 首先把returnedEndCell设为与startCell一样。
int rowIndexOfReturnedEndCell = _rowIndexOfStartCell;
int columnIndexOfReturnedEndCell = _columnIndexOfStartCell;
int rowIndexOfWholeColumn = _rowIndexOfStartCell - 1 + oSheet.UsedRange.Rows.Count;
try
{
while(rowIndexOfReturnedEndCell < rowindexofendcell =" _rowIndexOfStartCell;" columnindexofendcell =" _columnIndexOfStartCell;" rangeofstartcell =" (Range)(oSheet.Cells[_rowIndexOfStartCell," i =" _rowIndexOfStartCell;" selectedcell =" (Range)(oSheet.Cells[i," rowindexofendcell =" i;" rangeofendcell =" (Range)(oSheet.Cells[rowIndexOfEndCell," valueofendcell =" rangeOfEndCell.Value2.ToString();" themergedrange =" oSheet.get_Range(rangeOfStartCell," value2 =" Type.Missing;" value2 =" valueOfEndCell;" _rowindexofstartcell =" rangeOfEndCell.Row">
e 4GuysFromRolla Scott Mitchell Displaying a List of Scaled Images
e 4GuysFromRolla Scott Mitchell True Image Resizing, Part 1
e 4GuysFromRolla Scott Mitchell True Image Resizing, Part 2 : About thumbnail
e SmartThumbnail.Net Component
@ The Membership service convered all the details of authentication for an applications, whereas the Role Management service covers authorization.
@ To allow forms authentication in your web application, the 1st step is to turn on this Membership service in the web.config file.
Method 1: Use the <xmp>tage to surround the HTML or XML code to be displayed as plain text. For example: <![CDATA[<xmp>system><display><name>Someone</name></display></system>]]>
Method 2: Convert the <> to <>.
To display a simple link as code: <a href="http://www.simplelink.com">Here</a>
Would show as : <a href="http://www.simplelink.com">Here</a>
@ Simple Code Encoder SUPER great tool, i.e.
<system.web>
<urlMappings enabled="true">
<add url="~/About.aspx" mappedUrl="~/Site_Common/About.aspx"/>
<add url="~/Legal.aspx" mappedUrl="~/Site_common/Legal.aspx"/>
</urlMappings>
</system.web>
e Display Code In Entries
When URL mapping is useful?
URL mapping comes handy in number of situations:
- You want to hide a big URL from the end user and present an easy to remember shorter URL
- You want to pass query string parameters to a page but do not want them to be displayed to the user
- You have changed web form names after the application is deployed
How this works?
In ASP.NET 2.0 there is a configuration section called urlMappings that maps one URL to the other. The following markup shows how this section can be used:
<![CDATA[<br /><system.web><br /><urlmappings enabled="true"><br /><add mappedurl="~/Site_Common/About.aspx" url="~/About.aspx"><br /><add mappedurl="~/Site_common/Legal.aspx" url="~/Legal.aspx"><br /></urlmappings><br /></system.web><br />]]>
The enabled attribute of section enables or disables the URL mapping feature.
The sub section allows you to specify the actual mapping.
The url attribute of section specifies the URL as seen by the end user. It can be from browser address bar, hyper link or Response.Redirect statements.
The mappedUrl attribute species the URL that is actually served in place of the URL specified by url attribute.
You can specify as many URL mappings as you wish using multiple tags.
The Microsoft .NET Framework version 3.0 (formerly known as WinFX) is the new managed-code programming model for Windows. It combines the power of .NET Framework 2.0 with new technologies for building applications that have a visually compelling user experience, seamless communication across technology boundaries, and support for a wide range of business processes.
All of the classes that represent the new components (WPF, WF, WCF, and CardSpace) are part of the System namespace. The core classes of the .NET platform, such as the common language runtime (CLR) and base class libraries (BCL) remain as they are in .NET Framework 2.0.
How .NET Framework 3.0 Relates to .NET Framework 2.0 and Earlier
The .NET Framework 3.0 adds new technologies to the .NET Framework 2.0, which makes the .NET Framework 3.0 a superset of the .NET Framework 2.0. You can think of .NET Framework 3.0 as an "additive" release to the .NET Framework 2.0, as contrasted with a generational release where software is revised across the board. (For example, the .NET Framework 2.0 was a generational release over the .NET Framework 1.0.)
Because .NET Framework 3.0 is an additive release and uses the core run-time components from .NET Framework 2.0, it is completely backward compatible with the earlier version. Your existing .NET Framework 2.0 based-applications will continue to run without any modifications and you can safely continue your investments using the technologies that shipped with .NET Framework 2.0.
Installing the .NET Framework 3.0
The .NET Framework 3.0 is installed by default on Microsoft Windows Vista. On Microsoft Windows Server code-named "Longhorn", you can install the .NET Framework as a Windows Feature using Roles Management tools. On Windows XP and Windows Server 2003, installing .NET Framework 3.0 also adds any .NET Framework 2.0 components that are not already installed.
If .NET Framework 2.0 is already installed, the .NET Framework 3.0 installer adds only the files for Windows Presentation Foundation (WPF), Windows Workflow Foundation (WF), Windows Communication Foundation (WCF), and Windows CardSpace.
Components shared with .NET Framework 2.0 are installed in the following location:%windir%\Microsoft.NET\Framework\V2.0.50727
Components that are new to .NET Framework 3.0 are installed in the following location: %windir%\Microsoft.NET\Framework\V3.0
All components of the .NET Framework 3.0 reference assemblies are installed in the following location: %programfiles%\Reference Assemblies\Microsoft\Framework\v3.0
Uninstalling .NET Framework 3.0 will not remove the components shared with .NET Framework 2.0. To remove those components, you must first uninstall .NET Framework 3.0 and then separately uninstall .NET Framework 2.0.
Version Numbers for .NET Framework Assemblies
The .NET Framework 3.0 shares many components with .NET Framework 2.0, and the common language runtime (CLR) and base class libraries are the same as those in .NET Framework 2.0. Therefore, these shared components stay at version 2.0.
The version number 3.0 applies to all runtime and reference assemblies for Windows Communication Foundation (WCF), Windows Presentation Foundation (WPF), Windows Workflow Foundation (WF), and Windows CardSpace.
^ 基本上对我没有什么影响，因为我目前只关心Internet Application。所以，用好ASP.NET 2.0就是首要的。集中力量，先不去管.NET Framework 3.0的其他部分。
