KeyedCollection<TKey,TItem>.Item[TKey] 属性
定义
重要
一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。 对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。
获取具有指定键的元素。
public:
property TItem default[TKey] { TItem get(TKey key); };public TItem this[TKey key] { get; }member this.Item('Key) : 'ItemDefault Public ReadOnly Property Item(key As TKey) As TItem参数
- key
- TKey
要获取的元素的键。
属性值
TItem
具有指定键的元素。 如果未找到具有指定键的元素，则会引发异常。
例外
key 是 null。
集合中不存在具有指定键的元素。
示例
此代码示例演示从中派生集合类 KeyedCollection<TKey,TItem>所需的最小代码：重写 GetKeyForItem 该方法并提供委托基类构造函数的公共构造函数。 该代码示例还演示了继承自 KeyedCollection<TKey,TItem> 和类的许多属性和 Collection<T> 方法。
该代码示例同时调用属性 KeyedCollection<TKey,TItem>.Item[] ，该属性是只读的，按键检索，该 Collection<T>.Item[] 属性是可设置的，并按索引检索。 它显示当派生集合中的对象具有整数键时，如何访问后一个属性，这与用于索引检索的整数不区分。
该 SimpleOrder 类是一个非常简单的申购列表，其中包含 OrderItem 对象，每个对象都按顺序表示一个行项。
OrderItem关键是不可变，这是派生自KeyedCollection<TKey,TItem>的类的重要注意事项。 有关使用可变键的代码示例，请参阅 ChangeItemKey。
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
// This class represents a very simple keyed list of OrderItems,
// inheriting most of its behavior from the KeyedCollection and
// Collection classes. The immediate base class is the constructed
// type KeyedCollection<int, OrderItem>. When you inherit
// from KeyedCollection, the second generic type argument is the
// type that you want to store in the collection -- in this case
// OrderItem. The first type argument is the type that you want
// to use as a key. Its values must be calculated from OrderItem;
// in this case it is the int field PartNumber, so SimpleOrder
// inherits KeyedCollection<int, OrderItem>.
//
public class SimpleOrder : KeyedCollection<int, OrderItem>
{
// This is the only method that absolutely must be overridden,
// because without it the KeyedCollection cannot extract the
// keys from the items. The input parameter type is the
// second generic type argument, in this case OrderItem, and
// the return value type is the first generic type argument,
// in this case int.
//
protected override int GetKeyForItem(OrderItem item)
{
// In this example, the key is the part number.
return item.PartNumber;
}
}
public class Demo
{
public static void Main()
{
SimpleOrder weekly = new SimpleOrder();
// The Add method, inherited from Collection, takes OrderItem.
//
weekly.Add(new OrderItem(110072674, "Widget", 400, 45.17));
weekly.Add(new OrderItem(110072675, "Sprocket", 27, 5.3));
weekly.Add(new OrderItem(101030411, "Motor", 10, 237.5));
weekly.Add(new OrderItem(110072684, "Gear", 175, 5.17));
Display(weekly);
// The Contains method of KeyedCollection takes the key,
// type, in this case int.
//
Console.WriteLine("\nContains(101030411): {0}",
weekly.Contains(101030411));
// The default Item property of KeyedCollection takes a key.
//
Console.WriteLine("\nweekly[101030411].Description: {0}",
weekly[101030411].Description);
// The Remove method of KeyedCollection takes a key.
//
Console.WriteLine("\nRemove(101030411)");
weekly.Remove(101030411);
Display(weekly);
// The Insert method, inherited from Collection, takes an
// index and an OrderItem.
//
Console.WriteLine("\nInsert(2, New OrderItem(...))");
weekly.Insert(2, new OrderItem(111033401, "Nut", 10, .5));
Display(weekly);
// The default Item property is overloaded. One overload comes
// from KeyedCollection<int, OrderItem>; that overload
// is read-only, and takes Integer because it retrieves by key.
// The other overload comes from Collection<OrderItem>, the
// base class of KeyedCollection<int, OrderItem>; it
// retrieves by index, so it also takes an Integer. The compiler
// uses the most-derived overload, from KeyedCollection, so the
// only way to access SimpleOrder by index is to cast it to
// Collection<OrderItem>. Otherwise the index is interpreted
// as a key, and KeyNotFoundException is thrown.
//
Collection<OrderItem> coweekly = weekly;
Console.WriteLine("\ncoweekly[2].Description: {0}",
coweekly[2].Description);
Console.WriteLine("\ncoweekly[2] = new OrderItem(...)");
coweekly[2] = new OrderItem(127700026, "Crank", 27, 5.98);
OrderItem temp = coweekly[2];
// The IndexOf method inherited from Collection<OrderItem>
// takes an OrderItem instead of a key
//
Console.WriteLine("\nIndexOf(temp): {0}", weekly.IndexOf(temp));
// The inherited Remove method also takes an OrderItem.
//
Console.WriteLine("\nRemove(temp)");
weekly.Remove(temp);
Display(weekly);
Console.WriteLine("\nRemoveAt(0)");
weekly.RemoveAt(0);
Display(weekly);
}
private static void Display(SimpleOrder order)
{
Console.WriteLine();
foreach( OrderItem item in order )
{
Console.WriteLine(item);
}
}
}
// This class represents a simple line item in an order. All the
// values are immutable except quantity.
//
public class OrderItem
{
public readonly int PartNumber;
public readonly string Description;
public readonly double UnitPrice;
private int _quantity = 0;
public OrderItem(int partNumber, string description,
int quantity, double unitPrice)
{
this.PartNumber = partNumber;
this.Description = description;
this.Quantity = quantity;
this.UnitPrice = unitPrice;
}
public int Quantity
{
get { return _quantity; }
set
{
if (value<0)
throw new ArgumentException("Quantity cannot be negative.");
_quantity = value;
}
}
public override string ToString()
{
return String.Format(
"{0,9} {1,6} {2,-12} at {3,8:#,###.00} = {4,10:###,###.00}",
PartNumber, _quantity, Description, UnitPrice,
UnitPrice * _quantity);
}
}
/* This code example produces the following output:
110072674 400 Widget at 45.17 = 18,068.00
110072675 27 Sprocket at 5.30 = 143.10
101030411 10 Motor at 237.50 = 2,375.00
110072684 175 Gear at 5.17 = 904.75
Contains(101030411): True
weekly[101030411].Description: Motor
Remove(101030411)
110072674 400 Widget at 45.17 = 18,068.00
110072675 27 Sprocket at 5.30 = 143.10
110072684 175 Gear at 5.17 = 904.75
Insert(2, New OrderItem(...))
110072674 400 Widget at 45.17 = 18,068.00
110072675 27 Sprocket at 5.30 = 143.10
111033401 10 Nut at .50 = 5.00
110072684 175 Gear at 5.17 = 904.75
coweekly[2].Description: Nut
coweekly[2] = new OrderItem(...)
IndexOf(temp): 2
Remove(temp)
110072674 400 Widget at 45.17 = 18,068.00
110072675 27 Sprocket at 5.30 = 143.10
110072684 175 Gear at 5.17 = 904.75
RemoveAt(0)
110072675 27 Sprocket at 5.30 = 143.10
110072684 175 Gear at 5.17 = 904.75
*/
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
' This class represents a very simple keyed list of OrderItems,
' inheriting most of its behavior from the KeyedCollection and
' Collection classes. The immediate base class is the constructed
' type KeyedCollection(Of Integer, OrderItem). When you inherit
' from KeyedCollection, the second generic type argument is the
' type that you want to store in the collection -- in this case
' OrderItem. The first generic argument is the type that you want
' to use as a key. Its values must be calculated from OrderItem;
' in this case it is the Integer field PartNumber, so SimpleOrder
' inherits KeyedCollection(Of Integer, OrderItem).
'
Public Class SimpleOrder
Inherits KeyedCollection(Of Integer, OrderItem)
' This is the only method that absolutely must be overridden,
' because without it the KeyedCollection cannot extract the
' keys from the items. The input parameter type is the
' second generic type argument, in this case OrderItem, and
' the return value type is the first generic type argument,
' in this case Integer.
'
Protected Overrides Function GetKeyForItem( _
ByVal item As OrderItem) As Integer
' In this example, the key is the part number.
Return item.PartNumber
End Function
End Class
Public Class Demo
Public Shared Sub Main()
Dim weekly As New SimpleOrder()
' The Add method, inherited from Collection, takes OrderItem.
'
weekly.Add(New OrderItem(110072674, "Widget", 400, 45.17))
weekly.Add(New OrderItem(110072675, "Sprocket", 27, 5.3))
weekly.Add(New OrderItem(101030411, "Motor", 10, 237.5))
weekly.Add(New OrderItem(110072684, "Gear", 175, 5.17))
Display(weekly)
' The Contains method of KeyedCollection takes TKey.
'
Console.WriteLine(vbLf & "Contains(101030411): {0}", _
weekly.Contains(101030411))
' The default Item property of KeyedCollection takes the key
' type, Integer.
'
Console.WriteLine(vbLf & "weekly(101030411).Description: {0}", _
weekly(101030411).Description)
' The Remove method of KeyedCollection takes a key.
'
Console.WriteLine(vbLf & "Remove(101030411)")
weekly.Remove(101030411)
Display(weekly)
' The Insert method, inherited from Collection, takes an
' index and an OrderItem.
'
Console.WriteLine(vbLf & "Insert(2, New OrderItem(...))")
weekly.Insert(2, New OrderItem(111033401, "Nut", 10, .5))
Display(weekly)
' The default Item property is overloaded. One overload comes
' from KeyedCollection(Of Integer, OrderItem); that overload
' is read-only, and takes Integer because it retrieves by key.
' The other overload comes from Collection(Of OrderItem), the
' base class of KeyedCollection(Of Integer, OrderItem); it
' retrieves by index, so it also takes an Integer. The compiler
' uses the most-derived overload, from KeyedCollection, so the
' only way to access SimpleOrder by index is to cast it to
' Collection(Of OrderItem). Otherwise the index is interpreted
' as a key, and KeyNotFoundException is thrown.
'
Dim coweekly As Collection(Of OrderItem) = weekly
Console.WriteLine(vbLf & "coweekly(2).Description: {0}", _
coweekly(2).Description)
Console.WriteLine(vbLf & "coweekly(2) = New OrderItem(...)")
coweekly(2) = New OrderItem(127700026, "Crank", 27, 5.98)
Dim temp As OrderItem = coweekly(2)
' The IndexOf method, inherited from Collection(Of OrderItem),
' takes an OrderItem instead of a key.
'
Console.WriteLine(vbLf & "IndexOf(temp): {0}", _
weekly.IndexOf(temp))
' The inherited Remove method also takes an OrderItem.
'
Console.WriteLine(vbLf & "Remove(temp)")
weekly.Remove(temp)
Display(weekly)
Console.WriteLine(vbLf & "RemoveAt(0)")
weekly.RemoveAt(0)
Display(weekly)
End Sub
Private Shared Sub Display(ByVal order As SimpleOrder)
Console.WriteLine()
For Each item As OrderItem In order
Console.WriteLine(item)
Next item
End Sub
End Class
' This class represents a simple line item in an order. All the
' values are immutable except quantity.
'
Public Class OrderItem
Public ReadOnly PartNumber As Integer
Public ReadOnly Description As String
Public ReadOnly UnitPrice As Double
Private _quantity As Integer = 0
Public Sub New(ByVal partNumber As Integer, _
ByVal description As String, _
ByVal quantity As Integer, _
ByVal unitPrice As Double)
Me.PartNumber = partNumber
Me.Description = description
Me.Quantity = quantity
Me.UnitPrice = unitPrice
End Sub
Public Property Quantity() As Integer
Get
Return _quantity
End Get
Set
If value < 0 Then
Throw New ArgumentException("Quantity cannot be negative.")
End If
_quantity = value
End Set
End Property
Public Overrides Function ToString() As String
Return String.Format( _
"{0,9} {1,6} {2,-12} at {3,8:#,###.00} = {4,10:###,###.00}", _
PartNumber, _quantity, Description, UnitPrice, _
UnitPrice * _quantity)
End Function
End Class
' This code example produces the following output:
'
'110072674 400 Widget at 45.17 = 18,068.00
'110072675 27 Sprocket at 5.30 = 143.10
'101030411 10 Motor at 237.50 = 2,375.00
'110072684 175 Gear at 5.17 = 904.75
'
'Contains(101030411): True
'
'weekly(101030411).Description: Motor
'
'Remove(101030411)
'
'110072674 400 Widget at 45.17 = 18,068.00
'110072675 27 Sprocket at 5.30 = 143.10
'110072684 175 Gear at 5.17 = 904.75
'
'Insert(2, New OrderItem(...))
'
'110072674 400 Widget at 45.17 = 18,068.00
'110072675 27 Sprocket at 5.30 = 143.10
'111033401 10 Nut at .50 = 5.00
'110072684 175 Gear at 5.17 = 904.75
'
'coweekly(2).Description: Nut
'
'coweekly(2) = New OrderItem(...)
'
'IndexOf(temp): 2
'
'Remove(temp)
'
'110072674 400 Widget at 45.17 = 18,068.00
'110072675 27 Sprocket at 5.30 = 143.10
'110072684 175 Gear at 5.17 = 904.75
'
'RemoveAt(0)
'
'110072675 27 Sprocket at 5.30 = 143.10
'110072684 175 Gear at 5.17 = 904.75
注解
此属性提供使用以下语法访问集合中的特定元素的功能：myCollection[key]（Visual Basic 中的 myCollection(key)）。
注释
此属性不同于继承 Collection<T>.Item[] 的属性，该属性按数值索引获取和设置元素。 但是，如果 TKey 类型为类型 Int32，此属性将屏蔽继承的属性。 在这种情况下，可以通过将继承的属性强制转换为 KeyedCollection<TKey,TItem> 其基类型来访问继承的属性。 例如，KeyedCollection<int, MyType>（Visual Basic 中的 KeyedCollection(Of Integer, MyType)）可以转换为 Collection<MyType>（Visual Basic 中的 Collection(Of MyType)）。
KeyedCollection<TKey,TItem>如果具有查找字典，key则用于从字典中检索元素。 如果没有查找字典，则使用 GetKeyForItem 该方法提取每个元素的键，并与指定的键进行比较。
C# 语言 使用此关键字来 定义索引器，而不是实现 Item[] 属性。 Visual Basic实现 Item[] 作为 default 属性，它提供相同的索引功能。
如果KeyedCollection<TKey,TItem>具有查阅字典，则检索此属性的值是 O（1）运算;否则为 O（n） 操作，其中n。Count