aspnet外文翻译--常见的ASPNET代码技术

https://www.360docs.net/doc/f013370143.html,外文翻译

译文：

常见的https://www.360docs.net/doc/f013370143.html,代码技术

https://www.360docs.net/doc/f013370143.html,：技巧，教程，代码——Scott Mitchell

利用集合

大多数现代编程语言提供支持某种类型的对象,可以容纳一个可变数目的元素。这些对象被称为集合,他们可以轻易地添加和删除元素,而不必担心适当的内存分配。如果你使用经典ASP编程之前,你就可能已经熟悉了脚本，字典对象,采集对象的每个元素包含一个参考文本的关键。这种方式存储对象的集合被称为一个哈希表。

有许多类型的集合，除了哈希表。每一种类型的集合是相似的目的:它作为一种手段来存储不同数量的元素,提供一种简单的方法,在最小程度上添加和删除元素。每一个不同类型的集合是唯一的方法储存、检索并借鉴它的各种因素，而.NET框架提供了很多的集合类型为开发人员使用。事实上,整个的命名空间系统集合是专门从事集合类型和辅助课程。

这些类型的集合都可以存储对象类型的元素。因为在.NET中所有的原始数据类型的字符串，整数，日期/时间，阵列，都是从目标类派生的，这些集合可以从字面上存储任何东西。例如，你可以使用一个单一的收集，存储一个整数，一个典型的COM组件，字符串，日期/时间，和自定义编写的.NET组件的两个实例，一个实例的组合。大多数的例子在本节中使用集合来容纳原始数据类型（字符串，整数，双打）。然而，集合表明集合类型存储为它的每个元素的整个集合。

在本节中，我们将研究5个集合的.NET框架为开发人员提供数组列表，哈希表，可排序列表，队列，堆栈。当你学习这些集合时，就会意识到他们有许多相似之处。例如，每一个类型的集合可以通过元素与元素的迭代使用每个在VB中的下一个循环（或在C＃中的每一个循环）。每个集合类型都有一定数量的同样的函数名执行同样的任务。例如，每个集合类型都有一个明确的方法，从集合中移除所有元素集和属性来返回集合中的元素的数量。事实上，过去的”相似性的集合类型”的共同特点就是来考察所发现的集合类型。

使用数组列表

第一种收集我们要看的是数组列表。有了一个数组列表，每个项目就能顺序存储和索引数值。在下面的例子中，请记住开发者不必担心自己的内存分配。与标准阵列相比，开发人员可以轻松地添加和删除他不关心的数组元素。与所有的集合相比，我们将在这一章探讨的已不再是一个问题。

将元素添加到一个数组列表

我们创建两个数组类的实例，aTerritories和aStates，上线分别为5和6。然后，我们采用与美国的50个国家使用的添加方法填充aStates的数组列表。添加方法以一个参数，将该元素添加到数组中，这需要类型的对象。然后该对象的实例添加到数据列表的末尾。在这个例子中，我们只需添加数组列表aStates和aTerritories 线性类型的元素。

该添加方法是一次添加一个元素在数组的末尾，是一种非常有用的添加方法。但是如果我们想一次将一个包含所有元素的数量组添加到一个数组列表中该如何解决？数组类提供的添加值域方法是这样做的。添加值域需要一个参数，来支持ICollection接口。大量的数组，数组列表，数据视图，数据集合视图和其他支持此接口的类来支持.NET框架。我们使用添加值域方法添加的aStates 数组列表的每个元素到aTerritories 数组列表的末端，添加一系列元素在数组中的特定索引开始，使用插入值域方法，我们就可以添加两个字符串的aTerritories 数组列表到结束。因为数组列表顺序排列的，可能有很多时候我们要添加一个元素到一个特定的位置，数组列表类的插入方法提供了这种能力，使开发人员可以将元素添加到数组列表集合的特定位置。插入的方法有两个参数：一个整数，代表想要在数组列表中添加新的元素的索引，新的元素必须是目标类型。例如，我们添加了一个新的字符串的aTerritories数组列表的开始。注意，如果我们只是用添加的方法，目标参数将被添加到结束的区域，使用插入我们就可以指定正是这个新元素应驻留在数组列表相应位置中。

从一个数组列表中删除元素

数组列表类还提供了很多的删除元素的方法。我们可以使用移除方法从一个数组列表删除特定元素。如果你尝试删除一个元素不存在，将抛出路径异常问题。删除操作使你可以从一个数组列表的特定元素，移除至允许开发人员在删除一个元素在数组列表中的具体位置。

Remove和RemoveAt解剖都只有一个元素从数组列表的一段时间。我们可以通过使用移除范围的方法删除大部分的元素。这种方法需要两个参数：一个索引开始时的总要素和总元素的计数删除。最后，要删除一个数组列表中的所有内容，使用清除方法。

使用哈希表

大多数开发人员使用的集合类型是哈希表集合。鉴于数组列表的每个元素的索引数值，每个元素由一个字母数字键组成作为哈希表的索引。在收集数据类型的视觉基本是一个哈希表,脚本，字典对象,常用在经典ASP页面,是一个简单的哈希表了。为.NET框架的开发人员提供了一个强大的哈希表类。

当与哈希表类的工作时，请记住元素的输入顺序在排序集合中是部分先后的。哈希表类采用其自己的哈希算法，有效地命令集合中的键/值对。如果它是必不可少的，责令其键的值按字母顺序集合的元素，使用可排序列表类，这将在下一节讨论，“与可排序列表类的工作。”

可排序列表类的工作

到目前为止，我们已经研究了.NET框架提供了两个集合：哈希表类和数组列表类。每个这些集合索引元素以不同的方式实现。数组列表的指标以每个元素的数值索引，而哈希表的每个元素用一个字母键索引。适用于数组列表的每个元素的顺序，根据其数值指标; 哈希表的实行随机排序（因为顺序取决于一个散列算法）。

如果你需要一个集合，但是允许一个字母键和数字索引访问元素？.NET框架中包含一个类，它允许访问可排序列表类两种类型。这个类将在两个数组内部保持:一个排序的数组的数组键和值。

在可排序列表中添加，删除和索引在一个元素

由于在可排序列表命令及其关键要素的基础上，并没有方法在一个特定的位置插入元素。相反，类似的哈希表类只是一个单独的方法收集添加元素。然而，由于可排序列表可以由索引键和值，所以该类包含Remove和RemoveAt方法。与所有其他集合类型，可排序列表中也包含了一个清楚的方法来删除所有元素。

因为一个可排序列表封装的哈希表和数组列表的功能类，这也难怪，这个类提供了许多方法来访问它的元素。作为一个哈希表，可排序列表的元素，可通过他们的钥匙访问。一个存储整型值可以有一个元素访问类似以下的可排序列表：

Dim SortedListValue as Integer

SortedListValue = slSortedListInstance(key)

可排序列表也可以通过一个整数索引访问元素，如在数组列表类，为了获得在某一特定指数的价值，你可以使用GetByIndex方法如下：

Dim SortedListValue as Integer

SortedListValue = slSortedListInstance.GetByIndex(iPosition)

iPosition代表基于零的序号索引元素检索slSortedListInstance。此外，元素可以通过使用索引访问GetValueList方法返回一个值的集合，然后可以通过索引访问：

Dim SortedListValue as Integer

SortedListVluae = slSortedListInstance.GetValueList(iPosition)

队列工作

所有的数组列表，哈希表，和可排序列表都有一个共同点，它们允许随机访问其元素。也就是说，开发人员可以通过编程方式读取、写入或删除集合中的任何元素，而不顾它的位置。然而，队列和栈类（余下的两个集合我们将探讨）是独一无二的，他们只提供顺序访问而已。具体来说，队列类只能访问和删除元素在它们被插入的顺序。

添加，删除和访问队列中的元素

队列的先进先出（FIFO）的数据结构通常被称为第一，因为第n个元素插入删除或访问将是第n个元素，它有助于觉得作为一个人行队列数据结构。有两部分到队列中有任何线两部分组成:尾部的队列，在新的路线的人开始等待，队列的头，线下的人在那里等待被送达。在一条线上，排队的人谁是第一个将是先到先得;人站在第二将担任第二，等等;在队列中，添加的第一个元素将被删除或访问的第一个元素，而第二个元素的补充将成为第二个元素删除或访问。

.NET框架中提供的队列类的数据结构支持，在队列尾部添加一个元素，使用Enqueue方法。检索和删除元素从队列头，使用Dequeue方法。像其他集合类型，我们已经研究迄今队列类包含一个明确的方法来删除所有元素。简单地研究在不改变队列的头元素，使用Peek方法。像所有其他集合，队列的元素可以通过使用一个枚举迭代或用于下一个循环。

堆栈类工作

堆栈是一种数据结构类似于一个队列在那只支持顺序存储。然而,一个堆栈并承担从队列中最主要的区别在于，不是存储元素的先进先出（FIFO），堆栈使用后进先出（LIFO）。拥挤的电梯的

行为类似于堆栈的第一人进入拥挤的电梯，但是最后一个人离开，而最后一个登上电梯的人，确实第一个到达目的地。

添加，删除和访问堆栈中的元素

.NET框架提供了一个堆栈类的数据类型的实现。堆栈有两个基本操作：将一个元素添加进入栈顶，这是用推进方法完成的，并通过流行的方法完成从堆栈的顶部移除一个元素。类似于队列类，堆栈类还包含了Peek方法允许开发人员访问堆栈的顶部而没有删除元素。

各集合类型的异同

因为每个集合有相同的基本功能，作为一个可变大小的存储介质对象的集合类型彼此有很多共同点，这并不奇怪。他们都从集合中添加和删除元素的方法。计数属性返回集合中元素的总数，是常见的所有集合类型之间。

结论

.NET框架为开发人员提供了强大的集合类型的类的数量，大大扩展功能的脚本。字典对象、收集类型，可用于传统的ASP开发的唯一的集合类型的功能。这些集合，虽然各有各独特的功能，更像超过它们不同的特点。他们都有着相似的方法和属性，都能通过他们的元素迭代使用许多的技巧。

原文：

Common https://www.360docs.net/doc/f013370143.html, Code Techniques

https://www.360docs.net/doc/f013370143.html,: Tips, Tutorials,and Code—Scott Mitchell

Using Collections

Most modern programming languages provide support for some type of object that can hold a variable number of elements. These objects are referred to as collections, and they can have elements added and removed with ease without having to worry about proper memory allocation.If you’ve programmed with classic ASP before, you’re probably familiar with the Scripting.Dictionary object, a collection object that references each element with a textual key. A collection that stores objects in this fashion is known as a hash table.

There are many types of collections in addition to the hash table. Each type of collection is similar in purpose: it serves as a means to store a varying number of elements, providing an easy way, at a minimum, to add and remove elements. Each different type of collection is unique in its method of storing, retrieving, and referencing its various elements.

The .NET Framework provides a number of collection types for the developer to use. In fact, an entire namespace, System.Collections, is dedicated to collection types and helper classes.

Each of these collection types can store elements of type Object. Because in .NET all primitive data types—string, integers, date/times, arrays, and so on—are derived from the Object class, these collections can literally store anything! For example, you could use a single collection to store a couple of integers, an instance of a classic COM component, a string, a date/time, and two instances of a custom-written .NET component. Most of the examples in this section use collections to house primitive data types (strings, integers, doubles). However, Illustrates a collection of collections—that is, a collection type that stores entire collections as each of its elements!

Throughout this section we’ll examine five collections the .NET Frame work offers developers: the ArrayList, the Hashtable, the SortedList, the Queue, and the Stack. As you study each of these collections, realize that they all have many similarities. For example, each type of collection can be iterated through element-by-element using a For Each ... Next loop in VB (or a foreach loop in C#). Each collection type has a number of similarly named functions that perform the same tasks. For example, each collection type has a Clear method that removes all elements from the collection, and a Count property that returns the number of elements in the collection. In fact, the last subsection “Similarities Among the Collection Types” examines the common traits found among the collection types.

Working with the ArrayList Class

The firs t type of collection we’ll look at is the ArrayList. With an ArrayList, each item is

stored in sequential order and is indexed numerically. In our following examples, keep in mind that the developer need not worry himself with memory allocation. With the standard array, the developer cannot easily add and remove elements without concerning himself with the size and makeup of the array. With all the collections we’ll examine in this chapter，this is no longer a concern.

Adding Elements to an ArrayList

We create two ArrayList class instances, aTerritories and aStates, on lines

5 and 6, respectively. We then populate the aStates ArrayList with a small subset of the 50 states of the United States using the Add method. The Add method takes one parameter, the element to add to the array, which needs to be of type Object. This Object instance is then appended to the end of the ArrayList. In this example we are simply adding elements of type String to the ArrayList aStates and aTerritories.

The Add method is useful for adding one element at a time to the end of the array, but what if we want to add a number of elements to an ArrayList at once. The ArrayList class provides the AddRange method to do just this. AddRange expects a single parameter that supports the ICollection interface. A wide number of .NET Framework classes—such as the Array, ArrayList, DataView, DataSetView, and others—support this interface. We use the AddRange method to add each element of the aStates ArrayList to the end of the aTerritories ArrayList. (To add a range of elements starting at a specific index in an ArrayList, use the InsertRange method.) We add two more strings to the end of the aTerritories ArrayList.

Because ArrayLists are ordered sequentially, there might be times when we want to add an element to a particular position. The Insert method of the ArrayList class provides this capability, allowing the developer to add an element to a specific spot in the ArrayList collection. The Insert method takes two parameters: an integer representing the index in which you want to add the new element, and the new element, which needs to be of type Object. In line 23 we add a new string to the start of the aTerritories ArrayList. Note that if we had simply used the Add method, “District of Columbia” would have been added to the end of a Territories. Using Insert, however, we can specify exactly where in the ArrayList this new element should reside.

Removing Elements from an ArrayList

The ArrayList class also provides a number of methods for removing elements. We can

remove a specific element from an ArrayList with the Remove method. If you attempt to remove an element that does not exist, an ArgumentException exception will be thrown.Remove allows you to take out a particular element from an ArrayList; RemoveAt, allows the developer to remove an element at a specific position in the ArrayList.

Both Remove and RemoveAt dissect only one element from the ArrayList at a time. We can

remove a chunk of elements in one fell swoop by using the RemoveRange method. This method expects two parameters: an index to start at and a count of total elements to remove. Finally, to remove all the contents of an ArrayList, use the Clear method .

Working with the Hashtable Class

The type of collection most developers are used to working with is the hash table collection. Whereas the ArrayList indexes each element numerically, a hash table indexes each element by an alphanumeric key. The Collection data type in Visual Basic is a hash table; the Scripting.Dictionary object, used commonly in classic ASP pages, is a simple hash table. The .NET Framework provides developers with a powerful hash table class, Hashtable.

When working with the Hashtable class, keep in mind that the ordering of elements in the collection

are irrespective of the order in which they are entered. The Hashtable class employs its own hashing algorithm to efficiently order the key/value pairs in the collection. If it is essential that a collection’s elements be ordered alphabetically by the value of their keys, use the SortedList class, which is discussed in the next section, “Working with the SortedList Class.”

Working with the SortedList Class

So far we’ve examined two collections provided by the .NET Framework: the Hashtable class and the ArrayList class. Each of these collections indexes elements in a different manner. The ArrayList indexes each element numerically, whereas the Hashtable indexes each element with an alphanumeric key. The ArrayList orders each element sequentially, based on its numerical index; the Hashtable applies a seemingly random ordering (because the order is determined by a hashing algorithm).

What if you need a collection, though, that allows access to elements by both an alphanumeric key and a numerical index? The .NET Framework includes a class that permits both types of access, the SortedList class. This class internally maintains two arrays: a sorted array of the keys and an array of the values.

Adding, Removing, and Indexing Elements in a SortedList

Because the SortedList orders its elements based on the key, there are no methods that insert elements in a particular spot. Rather, similar to the Hashtable class, there is only a single method to add elements to the collection: Add. However, because the SortedList can be indexed by both key and value, the class contains both Remove and RemoveAt methods. As with all the other collection types, the SortedList also contains a Clear method that removes all elements.

Because a SortedList encapsulates the functionality of both the Hashtable and ArrayList

classes, it’s no wonder that the class provides a number of methods to access its elements. As with a Hashtable, SortedList elements can be accessed via their keys. A SortedList that stored Integer values could have an element accessed similar to the following:

Dim SortedListValue as Integer

SortedListValue = slSortedListInstance(key)

The SortedList also can access elements through an integral index, like with the ArrayList

class. To get the value at a particular index, you can use the GetByIndex method as follows:

Dim SortedListValue as Integer

SortedListValue = slSortedListInstance.GetByIndex(iPosition)

iPosition represents the zero-based ordinal index for the element to retrieve from slSortedListInstance. Additionally, elements can be accessed by index using the

GetValueList method to return a collection of values, which can then be accessed by index:

Dim SortedListValue as Integer

SortedListVluae = slSortedListInstance.GetValueList(iPosition)

Working with the Queue Class

ArrayLists, Hashtables, and SortedLists all have one thing in common—they allow random

access to their elements. That is, a developer can programmatically read, write, or remove any element in the collection, regardless of its position. However, the Queue and Stack classes (the remaining two collections we’ll examine) are unique in that they provide sequential access only. Specifically, the Queue class can only access and remove elements in the order they were inserted.

Adding, Removing, and Accessing Elements in a Queue

Queues are often referred to as First In, First Out (FIFO) data structures because the Nth element inserted will be the Nth element removed or accessed. It helps to think of the queue data structure as a line of people. There are two parts to a queue as there are two parts to any line up: the tail of the queue, where people new to the line start waiting, and the head of the queue, where the next person in line waits to be served. In a line, the person who is standing in line first will be first served; the person standing second will be served second, and so on; in a queue, the element that is added first will be the element that is removed or accessed first, whereas the second element added will be the second element removed or accessed.

The .NET Framework provides support for the queue data structure with the Queue class. To add an element to the tail, use the Enqueue method. To retrieve and remove an element from the head of a queue, use Dequeue. As with the other collection types we’ve examined thus far, t he Queue class contains a Clear method to remove all elements. To simply examine the element at the head without altering the queue, use the Peek method. As with all the other collections, the elements of a Queue can be iterated through using an enumerator or a For Each Next loop.

Working with the Stack Class

A stack is a data structure similar to a queue in that is supports only sequential access.However, a stack does bear one major difference from a queue: rather than storing elements with a First In, First Out (FIFO) semantic, a stack uses Last In, First Out (LIFO). A crowded elevator behaves similar to a stack: the first person who enters the crowded elevator is the last person to leave, whereas the last person to board the elevator is the first out when it reaches its destination.

Adding, Removing, and Accessing Elements in a Stack

The .NET Framework provides an implementation of the stack data type with the Stack class. A stack has two basic operations: adding an element to the top of the stack, which is accomplished with the Push method, and removing an element from the top of the stack, accomplished via the Pop method. Similar to the Queue class, the Stack class also contains a Peek method to permit developers to access the top of the stack without removing the element.

Similarities Among the Collection Types

Because each collection has the same basic functionality—to serve as a variable-sized storage medium for Objects—it is not surprising that the collection types have much in common with one another. All have methods to add and remove elements from the collection. The Count property, which returns the total number of elements in the collection, is common among all collection types.

Conclusion

The .NET Framework provides developers with a number of powerful collection-type classes, greatly extending the functionality of the Scripting.Dictionary object, the sole collection type available for classic ASP developers. These collections, although each have unique capabilities, are more alike than they are different. All of them share similar methods and properties, and can all have their elements iterated through using a number of techniques.