KeyedCollection<TKey,TItem> Třída
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Poskytuje abstraktní základní třídu pro kolekci, jejíž klíče jsou vloženy v hodnotách.
generic <typename TKey, typename TItem>
public ref class KeyedCollection abstract : System::Collections::ObjectModel::Collection<TItem>
public abstract class KeyedCollection<TKey,TItem> : System.Collections.ObjectModel.Collection<TItem>
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public abstract class KeyedCollection<TKey,TItem> : System.Collections.ObjectModel.Collection<TItem>
type KeyedCollection<'Key, 'Item> = class
inherit Collection<'Item>
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type KeyedCollection<'Key, 'Item> = class
inherit Collection<'Item>
Public MustInherit Class KeyedCollection(Of TKey, TItem)
Inherits Collection(Of TItem)
Parametry typu
- TKey
Typ klíčů v kolekci.
- TItem
Typ položek v kolekci.
- Dědičnost
- Odvozené
- Atributy
Příklady
Tato část obsahuje dva příklady kódu. První příklad ukazuje minimální kód potřebný k odvození z KeyedCollection<TKey,TItem>a ukazuje mnoho zděděných metod. Druhý příklad ukazuje, jak přepsat chráněné metody z KeyedCollection<TKey,TItem> , aby poskytovaly vlastní chování.
Příklad 1
Tento příklad kódu ukazuje minimální kód potřebný k odvození třídy kolekce z KeyedCollection<TKey,TItem>: přepsání GetKeyForItem metody a poskytnutí veřejného konstruktoru, který deleguje na konstruktor základní třídy. Příklad kódu také ukazuje mnoho vlastností a metod zděděných z KeyedCollection<TKey,TItem> tříd a Collection<T> .
Třída SimpleOrder
je velmi jednoduchý seznam žádanek, který obsahuje OrderItem
objekty, z nichž každý představuje položku řádku v pořadí. Klíč je OrderItem
neměnný, důležitý faktor pro třídy, které jsou odvozeny z KeyedCollection<TKey,TItem>. Příklad kódu, který používá proměnlivé klíče, najdete v tématu ChangeItemKey.
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Collections::ObjectModel;
// This class represents a simple line item in an order. All the
// values are immutable except quantity.
//
public ref class OrderItem
{
private:
int _quantity;
public:
initonly int PartNumber;
initonly String^ Description;
initonly double UnitPrice;
OrderItem(int partNumber, String^ description,
int quantity, double unitPrice)
{
this->PartNumber = partNumber;
this->Description = description;
this->Quantity = quantity;
this->UnitPrice = unitPrice;
}
property int Quantity
{
int get() { return _quantity; }
void set(int value)
{
if (value < 0)
throw gcnew ArgumentException("Quantity cannot be negative.");
_quantity = value;
}
}
virtual String^ ToString() override
{
return String::Format(
"{0,9} {1,6} {2,-12} at {3,8:#,###.00} = {4,10:###,###.00}",
PartNumber, _quantity, Description, UnitPrice,
UnitPrice * _quantity);
}
};
// 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 ref class SimpleOrder : KeyedCollection<int, OrderItem^>
{
// The parameterless constructor of the base class creates a
// KeyedCollection with an internal dictionary. For this code
// example, no other constructors are exposed.
//
public:
SimpleOrder() {}
// 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:
virtual int GetKeyForItem(OrderItem^ item) override
{
// In this example, the key is the part number.
return item->PartNumber;
}
};
public ref class Demo
{
public:
static void Main()
{
SimpleOrder^ weekly = gcnew SimpleOrder();
// The Add method, inherited from Collection, takes OrderItem.
//
weekly->Add(gcnew OrderItem(110072674, "Widget", 400, 45.17));
weekly->Add(gcnew OrderItem(110072675, "Sprocket", 27, 5.3));
weekly->Add(gcnew OrderItem(101030411, "Motor", 10, 237.5));
weekly->Add(gcnew 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, gcnew 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] = gcnew OrderItem(...)");
coweekly[2] = gcnew 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();
for each( OrderItem^ item in order )
{
Console::WriteLine(item);
}
}
};
void main()
{
Demo::Main();
}
/* 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] = gcnew 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
*/
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
Příklad 2
Následující příklad kódu ukazuje, jak přepsat chráněné InsertItemmetody , RemoveItem, ClearItemsa SetItem k poskytnutí vlastního Addchování pro metody , Removea Clear a pro nastavení výchozí Item[] vlastnosti (indexer v jazyce C#). Vlastní chování uvedené v tomto příkladu je událost oznámení s názvem Changed
, která je vyvolána na konci každé přepsané metody.
Příklad kódu vytvoří SimpleOrder
třídu, která je odvozena z KeyedCollection<TKey,TItem> a představuje jednoduchý formulář objednávky. Formulář objednávky obsahuje OrderItem
objekty představující položky seřazené. Příklad kódu také vytvoří SimpleOrderChangedEventArgs
třídu, která obsahuje informace o události, a výčet pro identifikaci typu změny.
Příklad kódu demonstruje vlastní chování voláním vlastností a metod odvozené třídy v Main
metodě Demo
třídy .
Tento příklad kódu používá objekty s neměnnými klíči. Příklad kódu, který používá proměnlivé klíče, najdete v tématu ChangeItemKey.
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Collections::ObjectModel;
public enum class ChangeTypes
{
Added,
Removed,
Replaced,
Cleared
};
ref class SimpleOrderChangedEventArgs;
// This class represents a simple line item in an order. All the
// values are immutable except quantity.
//
public ref class OrderItem
{
private:
int _quantity;
public:
initonly int PartNumber;
initonly String^ Description;
initonly double UnitPrice;
OrderItem(int partNumber, String^ description, int quantity,
double unitPrice)
{
this->PartNumber = partNumber;
this->Description = description;
this->Quantity = quantity;
this->UnitPrice = unitPrice;
};
property int Quantity
{
int get() { return _quantity; };
void set(int value)
{
if (value < 0)
throw gcnew ArgumentException("Quantity cannot be negative.");
_quantity = value;
};
};
virtual String^ ToString() override
{
return String::Format(
"{0,9} {1,6} {2,-12} at {3,8:#,###.00} = {4,10:###,###.00}",
PartNumber, _quantity, Description, UnitPrice,
UnitPrice * _quantity);
};
};
// Event argument for the Changed event.
//
public ref class SimpleOrderChangedEventArgs : EventArgs
{
public:
OrderItem^ ChangedItem;
initonly ChangeTypes ChangeType;
OrderItem^ ReplacedWith;
SimpleOrderChangedEventArgs(ChangeTypes change,
OrderItem^ item, OrderItem^ replacement)
{
this->ChangeType = change;
this->ChangedItem = item;
this->ReplacedWith = replacement;
}
};
// This class derives from KeyedCollection and shows how to override
// the protected ClearItems, InsertItem, RemoveItem, and SetItem
// methods in order to change the behavior of the default Item
// property and the Add, Clear, Insert, and Remove methods. The
// class implements a Changed event, which is raised by all the
// protected methods.
//
// SimpleOrder is a collection of OrderItem objects, and its key
// is the PartNumber field of OrderItem-> PartNumber is an Integer,
// so SimpleOrder inherits KeyedCollection<int, OrderItem>.
// (Note that the key of OrderItem cannot be changed; if it could
// be changed, SimpleOrder would have to override ChangeItemKey.)
//
public ref class SimpleOrder : KeyedCollection<int, OrderItem^>
{
public:
event EventHandler<SimpleOrderChangedEventArgs^>^ Changed;
// This parameterless constructor calls the base class constructor
// that specifies a dictionary threshold of 0, so that the internal
// dictionary is created as soon as an item is added to the
// collection.
//
SimpleOrder() : KeyedCollection<int, OrderItem^>(nullptr, 0) {};
// This is the only method that absolutely must be overridden,
// because without it the KeyedCollection cannot extract the
// keys from the items.
//
protected:
virtual int GetKeyForItem(OrderItem^ item) override
{
// In this example, the key is the part number.
return item->PartNumber;
}
virtual void InsertItem(int index, OrderItem^ newItem) override
{
__super::InsertItem(index, newItem);
Changed(this, gcnew SimpleOrderChangedEventArgs(
ChangeTypes::Added, newItem, nullptr));
}
virtual void SetItem(int index, OrderItem^ newItem) override
{
OrderItem^ replaced = this->Items[index];
__super::SetItem(index, newItem);
Changed(this, gcnew SimpleOrderChangedEventArgs(
ChangeTypes::Replaced, replaced, newItem));
}
virtual void RemoveItem(int index) override
{
OrderItem^ removedItem = Items[index];
__super::RemoveItem(index);
Changed(this, gcnew SimpleOrderChangedEventArgs(
ChangeTypes::Removed, removedItem, nullptr));
}
virtual void ClearItems() override
{
__super::ClearItems();
Changed(this, gcnew SimpleOrderChangedEventArgs(
ChangeTypes::Cleared, nullptr, nullptr));
}
// This method uses the internal reference to the dictionary
// to test fo
public:
void AddOrMerge(OrderItem^ newItem)
{
int key = this->GetKeyForItem(newItem);
OrderItem^ existingItem = nullptr;
// The dictionary is not created until the first item is
// added, so it is necessary to test for null. Using
// AndAlso ensures that TryGetValue is not called if the
// dictionary does not exist.
//
if (this->Dictionary != nullptr &&
this->Dictionary->TryGetValue(key, existingItem))
{
existingItem->Quantity += newItem->Quantity;
}
else
{
this->Add(newItem);
}
}
};
public ref class Demo
{
public:
static void Main()
{
SimpleOrder^ weekly = gcnew SimpleOrder();
weekly->Changed += gcnew
EventHandler<SimpleOrderChangedEventArgs^>(ChangedHandler);
// The Add method, inherited from Collection, takes OrderItem->
//
weekly->Add(gcnew OrderItem(110072674, "Widget", 400, 45.17));
weekly->Add(gcnew OrderItem(110072675, "Sprocket", 27, 5.3));
weekly->Add(gcnew OrderItem(101030411, "Motor", 10, 237.5));
weekly->Add(gcnew OrderItem(110072684, "Gear", 175, 5.17));
Display(weekly);
// The Contains method of KeyedCollection takes TKey.
//
Console::WriteLine("\nContains(101030411): {0}",
weekly->Contains(101030411));
// The default Item property of KeyedCollection takes the key
// type, Integer. The property is read-only.
//
Console::WriteLine("\nweekly[101030411]->Description: {0}",
weekly[101030411]->Description);
// The Remove method of KeyedCollection takes a key.
//
Console::WriteLine("\nRemove(101030411)");
weekly->Remove(101030411);
// The Insert method, inherited from Collection, takes an
// index and an OrderItem.
//
Console::WriteLine("\nInsert(2, gcnew OrderItem(...))");
weekly->Insert(2, gcnew OrderItem(111033401, "Nut", 10, .5));
// 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] = gcnew OrderItem(...)");
coweekly[2] = gcnew 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);
Console::WriteLine("\nRemoveAt(0)");
weekly->RemoveAt(0);
weekly->AddOrMerge(gcnew OrderItem(110072684, "Gear", 1000, 5.17));
Display(weekly);
Console::WriteLine();
weekly->Clear();
}
private:
static void Display(SimpleOrder^ order)
{
Console::WriteLine();
for each( OrderItem^ item in order )
{
Console::WriteLine(item);
}
}
static void ChangedHandler(Object^ source,
SimpleOrderChangedEventArgs^ e)
{
OrderItem^ item = e->ChangedItem;
if (e->ChangeType == ChangeTypes::Replaced)
{
OrderItem^ replacement = e->ReplacedWith;
Console::WriteLine("{0} (quantity {1}) was replaced " +
"by {2}, (quantity {3}).", item->Description,
item->Quantity, replacement->Description,
replacement->Quantity);
}
else if(e->ChangeType == ChangeTypes::Cleared)
{
Console::WriteLine("The order list was cleared.");
}
else
{
Console::WriteLine("{0} (quantity {1}) was {2}.",
item->Description, item->Quantity, e->ChangeType);
}
}
};
void main()
{
Demo::Main();
}
/* This code example produces the following output:
Widget (quantity 400) was Added.
Sprocket (quantity 27) was Added.
Motor (quantity 10) was Added.
Gear (quantity 175) was Added.
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)
Motor (quantity 10) was Removed.
Insert(2, gcnew OrderItem(...))
Nut (quantity 10) was Added.
coweekly[2].Description: Nut
coweekly[2] = gcnew OrderItem(...)
Nut (quantity 10) was replaced by Crank, (quantity 27).
IndexOf(temp): 2
Remove(temp)
Crank (quantity 27) was Removed.
RemoveAt(0)
Widget (quantity 400) was Removed.
110072675 27 Sprocket at 5.30 = 143.10
110072684 1175 Gear at 5.17 = 6,074.75
The order list was cleared.
*/
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
// This class derives from KeyedCollection and shows how to override
// the protected ClearItems, InsertItem, RemoveItem, and SetItem
// methods in order to change the behavior of the default Item
// property and the Add, Clear, Insert, and Remove methods. The
// class implements a Changed event, which is raised by all the
// protected methods.
//
// SimpleOrder is a collection of OrderItem objects, and its key
// is the PartNumber field of OrderItem. PartNumber is an Integer,
// so SimpleOrder inherits KeyedCollection<int, OrderItem>.
// (Note that the key of OrderItem cannot be changed; if it could
// be changed, SimpleOrder would have to override ChangeItemKey.)
//
public class SimpleOrder : KeyedCollection<int, OrderItem>
{
public event EventHandler<SimpleOrderChangedEventArgs> Changed;
// This parameterless constructor calls the base class constructor
// that specifies a dictionary threshold of 0, so that the internal
// dictionary is created as soon as an item is added to the
// collection.
//
public SimpleOrder() : base(null, 0) {}
// This is the only method that absolutely must be overridden,
// because without it the KeyedCollection cannot extract the
// keys from the items.
//
protected override int GetKeyForItem(OrderItem item)
{
// In this example, the key is the part number.
return item.PartNumber;
}
protected override void InsertItem(int index, OrderItem newItem)
{
base.InsertItem(index, newItem);
EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
if (temp != null)
{
temp(this, new SimpleOrderChangedEventArgs(
ChangeType.Added, newItem, null));
}
}
protected override void SetItem(int index, OrderItem newItem)
{
OrderItem replaced = Items[index];
base.SetItem(index, newItem);
EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
if (temp != null)
{
temp(this, new SimpleOrderChangedEventArgs(
ChangeType.Replaced, replaced, newItem));
}
}
protected override void RemoveItem(int index)
{
OrderItem removedItem = Items[index];
base.RemoveItem(index);
EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
if (temp != null)
{
temp(this, new SimpleOrderChangedEventArgs(
ChangeType.Removed, removedItem, null));
}
}
protected override void ClearItems()
{
base.ClearItems();
EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
if (temp != null)
{
temp(this, new SimpleOrderChangedEventArgs(
ChangeType.Cleared, null, null));
}
}
}
// Event argument for the Changed event.
//
public class SimpleOrderChangedEventArgs : EventArgs
{
private OrderItem _changedItem;
private ChangeType _changeType;
private OrderItem _replacedWith;
public OrderItem ChangedItem { get { return _changedItem; }}
public ChangeType ChangeType { get { return _changeType; }}
public OrderItem ReplacedWith { get { return _replacedWith; }}
public SimpleOrderChangedEventArgs(ChangeType change,
OrderItem item, OrderItem replacement)
{
_changeType = change;
_changedItem = item;
_replacedWith = replacement;
}
}
public enum ChangeType
{
Added,
Removed,
Replaced,
Cleared
};
public class Demo
{
public static void Main()
{
SimpleOrder weekly = new SimpleOrder();
weekly.Changed += new
EventHandler<SimpleOrderChangedEventArgs>(ChangedHandler);
// 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("\nContains(101030411): {0}",
weekly.Contains(101030411));
// The default Item property of KeyedCollection takes the key
// type, Integer. The property is read-only.
//
Console.WriteLine("\nweekly[101030411].Description: {0}",
weekly[101030411].Description);
// The Remove method of KeyedCollection takes a key.
//
Console.WriteLine("\nRemove(101030411)");
weekly.Remove(101030411);
// 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));
// 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);
Console.WriteLine("\nRemoveAt(0)");
weekly.RemoveAt(0);
// Increase the quantity for a line item.
Console.WriteLine("\ncoweekly(1) = New OrderItem(...)");
coweekly[1] = new OrderItem(coweekly[1].PartNumber,
coweekly[1].Description, coweekly[1].Quantity + 1000,
coweekly[1].UnitPrice);
Display(weekly);
Console.WriteLine();
weekly.Clear();
}
private static void Display(SimpleOrder order)
{
Console.WriteLine();
foreach( OrderItem item in order )
{
Console.WriteLine(item);
}
}
private static void ChangedHandler(object source,
SimpleOrderChangedEventArgs e)
{
OrderItem item = e.ChangedItem;
if (e.ChangeType==ChangeType.Replaced)
{
OrderItem replacement = e.ReplacedWith;
Console.WriteLine("{0} (quantity {1}) was replaced " +
"by {2}, (quantity {3}).", item.Description,
item.Quantity, replacement.Description,
replacement.Quantity);
}
else if(e.ChangeType == ChangeType.Cleared)
{
Console.WriteLine("The order list was cleared.");
}
else
{
Console.WriteLine("{0} (quantity {1}) was {2}.",
item.Description, item.Quantity, e.ChangeType);
}
}
}
// This class represents a simple line item in an order. All the
// values are immutable except quantity.
//
public class OrderItem
{
private int _partNumber;
private string _description;
private double _unitPrice;
private int _quantity;
public int PartNumber { get { return _partNumber; }}
public string Description { get { return _description; }}
public double UnitPrice { get { return _unitPrice; }}
public int Quantity { get { return _quantity; }}
public OrderItem(int partNumber, string description, int quantity,
double unitPrice)
{
_partNumber = partNumber;
_description = description;
_quantity = quantity;
_unitPrice = unitPrice;
}
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:
Widget (quantity 400) was Added.
Sprocket (quantity 27) was Added.
Motor (quantity 10) was Added.
Gear (quantity 175) was Added.
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)
Motor (quantity 10) was Removed.
Insert(2, new OrderItem(...))
Nut (quantity 10) was Added.
coweekly[2].Description: Nut
coweekly[2] = new OrderItem(...)
Nut (quantity 10) was replaced by Crank, (quantity 27).
IndexOf(temp): 2
Remove(temp)
Crank (quantity 27) was Removed.
RemoveAt(0)
Widget (quantity 400) was Removed.
coweekly(1) = New OrderItem(...)
Gear (quantity 175) was replaced by Gear, (quantity 1175).
110072675 27 Sprocket at 5.30 = 143.10
110072684 1175 Gear at 5.17 = 6,074.75
The order list was cleared.
*/
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
' This class derives from KeyedCollection and shows how to override
' the protected ClearItems, InsertItem, RemoveItem, and SetItem
' methods in order to change the behavior of the default Item
' property and the Add, Clear, Insert, and Remove methods. The
' class implements a Changed event, which is raised by all the
' protected methods.
'
' SimpleOrder is a collection of OrderItem objects, and its key
' is the PartNumber field of OrderItem. PartNumber is an Integer,
' so SimpleOrder inherits KeyedCollection(Of Integer, OrderItem).
' (Note that the key of OrderItem cannot be changed; if it could
' be changed, SimpleOrder would have to override ChangeItemKey.)
'
Public Class SimpleOrder
Inherits KeyedCollection(Of Integer, OrderItem)
Public Event Changed As EventHandler(Of SimpleOrderChangedEventArgs)
' This parameterless constructor calls the base class constructor
' that specifies a dictionary threshold of 0, so that the internal
' dictionary is created as soon as an item is added to the
' collection.
'
Public Sub New()
MyBase.New(Nothing, 0)
End Sub
' This is the only method that absolutely must be overridden,
' because without it the KeyedCollection cannot extract the
' keys from the items.
'
Protected Overrides Function GetKeyForItem( _
ByVal item As OrderItem) As Integer
' In this example, the key is the part number.
Return item.PartNumber
End Function
Protected Overrides Sub InsertItem( _
ByVal index As Integer, ByVal newItem As OrderItem)
MyBase.InsertItem(index, newItem)
RaiseEvent Changed(Me, New SimpleOrderChangedEventArgs( _
ChangeType.Added, newItem, Nothing))
End Sub
Protected Overrides Sub SetItem(ByVal index As Integer, _
ByVal newItem As OrderItem)
Dim replaced As OrderItem = Items(index)
MyBase.SetItem(index, newItem)
RaiseEvent Changed(Me, New SimpleOrderChangedEventArgs( _
ChangeType.Replaced, replaced, newItem))
End Sub
Protected Overrides Sub RemoveItem(ByVal index As Integer)
Dim removedItem As OrderItem = Items(index)
MyBase.RemoveItem(index)
RaiseEvent Changed(Me, New SimpleOrderChangedEventArgs( _
ChangeType.Removed, removedItem, Nothing))
End Sub
Protected Overrides Sub ClearItems()
MyBase.ClearItems()
RaiseEvent Changed(Me, New SimpleOrderChangedEventArgs( _
ChangeType.Cleared, Nothing, Nothing))
End Sub
End Class
' Event argument for the Changed event.
'
Public Class SimpleOrderChangedEventArgs
Inherits EventArgs
Private _changedItem As OrderItem
Private _changeType As ChangeType
Private _replacedWith As OrderItem
Public ReadOnly Property ChangedItem As OrderItem
Get
Return _changedItem
End Get
End Property
Public ReadOnly Property ChangeType As ChangeType
Get
Return _changeType
End Get
End Property
Public ReadOnly Property ReplacedWith As OrderItem
Get
Return _replacedWith
End Get
End Property
Public Sub New(ByVal change As ChangeType, ByVal item As OrderItem, _
ByVal replacement As OrderItem)
_changeType = change
_changedItem = item
_replacedWith = replacement
End Sub
End Class
Public Enum ChangeType
Added
Removed
Replaced
Cleared
End Enum
Public Class Demo
Public Shared Sub Main()
Dim weekly As New SimpleOrder()
AddHandler weekly.Changed, AddressOf ChangedHandler
' 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. The property is read-only.
'
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)
' 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))
' 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)
Console.WriteLine(vbLf & "RemoveAt(0)")
weekly.RemoveAt(0)
' Increase the quantity for a line item.
Console.WriteLine(vbLf & "coweekly(1) = New OrderItem(...)")
coweekly(1) = New OrderItem(coweekly(1).PartNumber, _
coweekly(1).Description, coweekly(1).Quantity + 1000, _
coweekly(1).UnitPrice)
Display(weekly)
Console.WriteLine()
weekly.Clear()
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
Private Shared Sub ChangedHandler(ByVal source As Object, _
ByVal e As SimpleOrderChangedEventArgs)
Dim item As OrderItem = e.ChangedItem
If e.ChangeType = ChangeType.Replaced Then
Dim replacement As OrderItem = e.ReplacedWith
Console.WriteLine("{0} (quantity {1}) was replaced " & _
"by {2}, (quantity {3}).", item.Description, _
item.Quantity, replacement.Description, replacement.Quantity)
ElseIf e.ChangeType = ChangeType.Cleared Then
Console.WriteLine("The order list was cleared.")
Else
Console.WriteLine("{0} (quantity {1}) was {2}.", _
item.Description, item.Quantity, e.ChangeType)
End If
End Sub
End Class
' This class represents a simple line item in an order. All the
' values are immutable except quantity.
'
Public Class OrderItem
Private _partNumber As Integer
Private _description As String
Private _unitPrice As Double
Private _quantity As Integer
Public ReadOnly Property PartNumber As Integer
Get
Return _partNumber
End Get
End Property
Public ReadOnly Property Description As String
Get
Return _description
End Get
End Property
Public ReadOnly Property UnitPrice As Double
Get
Return _unitPrice
End Get
End Property
Public ReadOnly Property Quantity() As Integer
Get
Return _quantity
End Get
End Property
Public Sub New(ByVal partNumber As Integer, _
ByVal description As String, _
ByVal quantity As Integer, _
ByVal unitPrice As Double)
_partNumber = partNumber
_description = description
_quantity = quantity
_unitPrice = unitPrice
End Sub
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:
'
'Widget (quantity 400) was Added.
'Sprocket (quantity 27) was Added.
'Motor (quantity 10) was Added.
'Gear (quantity 175) was Added.
'
'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)
'Motor (quantity 10) was Removed.
'
'Insert(2, New OrderItem(...))
'Nut (quantity 10) was Added.
'
'coweekly(2).Description: Nut
'
'coweekly(2) = New OrderItem(...)
'Nut (quantity 10) was replaced by Crank, (quantity 27).
'
'IndexOf(temp): 2
'
'Remove(temp)
'Crank (quantity 27) was Removed.
'
'RemoveAt(0)
'Widget (quantity 400) was Removed.
'
'coweekly(1) = New OrderItem(...)
'Gear (quantity 175) was replaced by Gear, (quantity 1175).
'
'110072675 27 Sprocket at 5.30 = 143.10
'110072684 1175 Gear at 5.17 = 6,074.75
'
'The order list was cleared.
Poznámky
Třída KeyedCollection<TKey,TItem> poskytuje indexované načtení O(1) i klíčové načtení, které se blíží O(1). Je to abstraktní typ, přesněji nekonečná sada abstraktních typů, protože každý z jeho vytvořených obecných typů je abstraktní základní třída. Pokud chcete použít KeyedCollection<TKey,TItem>, odvozujte typ kolekce z příslušného vytvořeného typu.
Třída KeyedCollection<TKey,TItem> je hybridní mezi kolekcí založenou IList<T> na obecném rozhraní a kolekcí založenou na obecném IDictionary<TKey,TValue> rozhraní. Podobně jako kolekce založené na obecném IList<T> rozhraní KeyedCollection<TKey,TItem> je indexovaný seznam položek. Podobně jako kolekce založené na obecném IDictionary<TKey,TValue> rozhraní KeyedCollection<TKey,TItem> má klíč přidružený ke každému prvku.
Na rozdíl od slovníků není prvek páru KeyedCollection<TKey,TItem> klíč/hodnota. Místo toho je celý prvek hodnotou a klíč je vložený do hodnoty. Například prvek kolekce odvozený z KeyedCollection\<String,String>
(KeyedCollection(Of String, String)
v jazyce Visual Basic) může být "John Doe Jr.", kde hodnota je "John Doe Jr." a klíč je "Doe"; nebo kolekce záznamů zaměstnanců obsahující celočíselné klíče může být odvozena z KeyedCollection\<int,Employee>
. Abstraktní GetKeyForItem metoda extrahuje klíč z elementu .
Ve výchozím nastavení KeyedCollection<TKey,TItem> obsahuje vyhledávací slovník, který můžete získat pomocí Dictionary vlastnosti . Po přidání položky do objektu KeyedCollection<TKey,TItem>se klíč položky extrahuje jednou a uloží se do vyhledávacího slovníku pro rychlejší hledání. Toto chování je přepsáno zadáním prahové hodnoty vytvoření slovníku při vytváření objektu KeyedCollection<TKey,TItem>. Vyhledávací slovník se vytvoří, když počet prvků poprvé překročí tuto prahovou hodnotu. Pokud jako prahovou hodnotu zadáte -1, vyhledávací slovník se nikdy nevytvořil.
Poznámka
Při použití interního vyhledávacího slovníku obsahuje odkazy na všechny položky v kolekci, pokud TItem
je typ odkazu, nebo kopie všech položek v kolekci, pokud TItem
je typ hodnoty. Proto použití vyhledávacího slovníku nemusí být vhodné, pokud TItem
je typ hodnoty.
K položce můžete přistupovat pomocí jejího indexu Item[] nebo klíče pomocí vlastnosti . Můžete přidávat položky bez klíče, ale k těmto položkám je následně možné přistupovat pouze pomocí indexu.
Konstruktory
KeyedCollection<TKey,TItem>() |
Inicializuje novou instanci KeyedCollection<TKey,TItem> třídy, která používá výchozí porovnávač rovnosti. |
KeyedCollection<TKey,TItem>(IEqualityComparer<TKey>) |
Inicializuje novou instanci KeyedCollection<TKey,TItem> třídy, která používá zadaný porovnávač rovnosti. |
KeyedCollection<TKey,TItem>(IEqualityComparer<TKey>, Int32) |
Inicializuje novou instanci KeyedCollection<TKey,TItem> třídy, která používá zadaný porovnávač rovnosti a vytvoří vyhledávací slovník při překročení zadané prahové hodnoty. |
Vlastnosti
Comparer |
Získá obecný porovnávač rovnosti, který se používá k určení rovnosti klíčů v kolekci. |
Count |
Získá počet prvků skutečně obsažených v objektu Collection<T>. (Zděděno od Collection<T>) |
Dictionary |
Získá vyhledávací slovník objektu KeyedCollection<TKey,TItem>. |
Item[Int32] |
Získá nebo nastaví prvek u zadaného indexu. (Zděděno od Collection<T>) |
Item[TKey] |
Získá element se zadaným klíčem. |
Items |
Získá obálku IList<T> kolem objektu Collection<T>. (Zděděno od Collection<T>) |
Metody
Add(T) |
Přidá objekt na konec objektu Collection<T>. (Zděděno od Collection<T>) |
ChangeItemKey(TItem, TKey) |
Změní klíč přidružený k zadanému prvku ve vyhledávacím slovníku. |
Clear() |
Odebere všechny elementy z kolekce Collection<T>. (Zděděno od Collection<T>) |
ClearItems() |
Odebere všechny elementy z kolekce KeyedCollection<TKey,TItem>. |
Contains(TKey) |
Určuje, zda kolekce obsahuje prvek se zadaným klíčem. |
CopyTo(T[], Int32) |
Zkopíruje celek Collection<T> do kompatibilního jednorozměrného Arrayobjektu počínaje zadaným indexem cílového pole. (Zděděno od Collection<T>) |
Equals(Object) |
Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object) |
GetEnumerator() |
Vrátí enumerátor, který iteruje přes Collection<T>. (Zděděno od Collection<T>) |
GetHashCode() |
Slouží jako výchozí hashovací funkce. (Zděděno od Object) |
GetKeyForItem(TItem) |
Při implementaci v odvozené třídě extrahuje klíč ze zadaného prvku. |
GetType() |
Type Získá z aktuální instance. (Zděděno od Object) |
IndexOf(T) |
Vyhledá zadaný objekt a vrátí index prvního výskytu v rámci celého Collection<T>objektu od nuly. (Zděděno od Collection<T>) |
Insert(Int32, T) |
Vloží prvek do objektu Collection<T> v zadaném indexu. (Zděděno od Collection<T>) |
InsertItem(Int32, T) |
Vloží prvek do objektu Collection<T> v zadaném indexu. (Zděděno od Collection<T>) |
InsertItem(Int32, TItem) |
Vloží prvek do objektu KeyedCollection<TKey,TItem> v zadaném indexu. |
MemberwiseClone() |
Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object) |
Remove(TKey) |
Odebere prvek se zadaným klíčem z objektu KeyedCollection<TKey,TItem>. |
RemoveAt(Int32) |
Odebere prvek v zadaném indexu objektu Collection<T>. (Zděděno od Collection<T>) |
RemoveItem(Int32) |
Odebere prvek v zadaném indexu objektu KeyedCollection<TKey,TItem>. |
SetItem(Int32, T) |
Nahradí element v zadaném indexu. (Zděděno od Collection<T>) |
SetItem(Int32, TItem) |
Nahradí položku v zadaném indexu zadanou položkou. |
ToString() |
Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object) |
TryGetValue(TKey, TItem) |
Pokusí se získat položku z kolekce pomocí zadaného klíče. |
Explicitní implementace rozhraní
ICollection.CopyTo(Array, Int32) |
Zkopíruje prvky objektu ICollectionArraydo , počínaje konkrétním Array indexem. (Zděděno od Collection<T>) |
ICollection.IsSynchronized |
Získá hodnotu označující, zda přístup k objektu ICollection je synchronizován (bezpečný pro přístup z více vláken). (Zděděno od Collection<T>) |
ICollection.SyncRoot |
Získá objekt, který lze použít k synchronizaci přístupu k .ICollection (Zděděno od Collection<T>) |
ICollection<T>.IsReadOnly |
Získá hodnotu, která určuje, zda je ICollection<T> určena jen pro čtení. (Zděděno od Collection<T>) |
IEnumerable.GetEnumerator() |
Vrací enumerátor procházející kolekci. (Zděděno od Collection<T>) |
IList.Add(Object) |
Přidá položku do IList. (Zděděno od Collection<T>) |
IList.Contains(Object) |
Určuje, zda obsahuje IList konkrétní hodnotu. (Zděděno od Collection<T>) |
IList.IndexOf(Object) |
Určuje index konkrétní položky v objektu IList. (Zděděno od Collection<T>) |
IList.Insert(Int32, Object) |
Vloží položku do objektu IList v zadaném indexu. (Zděděno od Collection<T>) |
IList.IsFixedSize |
Získá hodnotu označující, zda IList má pevnou velikost. (Zděděno od Collection<T>) |
IList.IsReadOnly |
Získá hodnotu, která určuje, zda je IList určena jen pro čtení. (Zděděno od Collection<T>) |
IList.Item[Int32] |
Získá nebo nastaví prvek u zadaného indexu. (Zděděno od Collection<T>) |
IList.Remove(Object) |
Odebere první výskyt konkrétního objektu z objektu IList. (Zděděno od Collection<T>) |
Metody rozšíření
ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
FrozenDictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů. |
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
FrozenDictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků. |
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>) |
Vytvoří se FrozenSet<T> zadanými hodnotami. |
AsReadOnly<T>(IList<T>) |
Vrátí obálku jen ReadOnlyCollection<T> pro čtení pro zadaný seznam. |
ToImmutableArray<TSource>(IEnumerable<TSource>) |
Vytvoří neměnné pole ze zadané kolekce. |
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Vytvoří neměnný slovník z existující kolekce prvků a použije transformační funkci na zdrojové klíče. |
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Vytvoří neměnný slovník na základě určité transformace sekvence. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) |
Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaného porovnávače klíčů. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) |
Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaných porovnávačů klíčů a hodnot. |
ToImmutableHashSet<TSource>(IEnumerable<TSource>) |
Vytvoří výčet sekvence a vytvoří neměnnou sadu hodnot hash jejího obsahu. |
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Vytvoří výčet sekvence, vytvoří neměnnou sadu hodnot hash jejího obsahu a použije zadaný porovnávací nástroj rovnosti pro typ sady. |
ToImmutableList<TSource>(IEnumerable<TSource>) |
Vytvoří výčet sekvence a vytvoří neměnný seznam jejího obsahu. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího obsahu. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) |
Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího obsahu pomocí zadaného porovnávače klíčů. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) |
Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího obsahu pomocí zadaných porovnávačů klíčů a hodnot. |
ToImmutableSortedSet<TSource>(IEnumerable<TSource>) |
Vytvoří výčet sekvence a vytvoří neměnnou seřazenou sadu jejího obsahu. |
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Vytvoří výčet sekvence, vytvoří neměnnou seřazenou sadu jejího obsahu a použije zadaný porovnávací nástroj. |
CopyToDataTable<T>(IEnumerable<T>) |
Vrátí hodnotu , DataTable která obsahuje kopie DataRow objektů vzhledem ke vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr |
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) |
Zkopíruje DataRow objekty do zadaného DataTableobjektu , který je vstupním objektemIEnumerable<T>, kde je DataRowobecný parametr |
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) |
Zkopíruje DataRow objekty do zadaného DataTableobjektu , který je vstupním objektemIEnumerable<T>, kde je DataRowobecný parametr |
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) |
Použije na sekvenci funkci akumulátoru. |
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) |
Použije na sekvenci funkci akumulátoru. Zadaná počáteční hodnota se použije jako počáteční hodnota akumulátoru. |
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) |
Použije na sekvenci funkci akumulátoru. Zadaná počáteční hodnota se použije jako počáteční hodnota akumulátoru a zadaná funkce se použije k výběru výsledné hodnoty. |
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>) |
Poskytuje abstraktní základní třídu pro kolekci, jejíž klíče jsou vloženy v hodnotách. |
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>) |
Poskytuje abstraktní základní třídu pro kolekci, jejíž klíče jsou vloženy v hodnotách. |
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Určuje, zda všechny prvky sekvence splňují podmínku. |
Any<TSource>(IEnumerable<TSource>) |
Určuje, zda sekvence obsahuje nějaké prvky. |
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Určuje, zda některý prvek sekvence splňuje podmínku. |
Append<TSource>(IEnumerable<TSource>, TSource) |
Připojí hodnotu na konec sekvence. |
AsEnumerable<TSource>(IEnumerable<TSource>) |
Vrátí vstup zadaný jako IEnumerable<T>. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Vypočítá průměr posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Vypočítá průměr posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Vypočítá průměr posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Vypočítá průměr posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Vypočítá průměr posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Vypočítá průměr posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Vypočítá průměr posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Vypočítá průměr posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Vypočítá průměr posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Vypočítá průměr posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Cast<TResult>(IEnumerable) |
Přetypuje prvky objektu na IEnumerable zadaný typ. |
Chunk<TSource>(IEnumerable<TSource>, Int32) |
Rozdělí prvky sekvence na bloky o velikosti nejvýše |
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Zřetězí dvě sekvence. |
Contains<TSource>(IEnumerable<TSource>, TSource) |
Určuje, zda sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti. |
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) |
Určuje, zda sekvence obsahuje zadaný prvek pomocí zadaného IEqualityComparer<T>prvku . |
Count<TSource>(IEnumerable<TSource>) |
Vrátí počet prvků v sekvenci. |
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí číslo, které představuje, kolik prvků v zadané sekvenci splňuje podmínku. |
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Poskytuje abstraktní základní třídu pro kolekci, jejíž klíče jsou vloženy v hodnotách. |
DefaultIfEmpty<TSource>(IEnumerable<TSource>) |
Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v kolekci singleton, pokud je posloupnost prázdná. |
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) |
Vrátí prvky zadané sekvence nebo zadanou hodnotu v jednoúčelové kolekci, pokud je posloupnost prázdná. |
Distinct<TSource>(IEnumerable<TSource>) |
Vrátí odlišné prvky ze sekvence pomocí výchozího porovnávače rovnosti k porovnání hodnot. |
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Vrátí odlišné prvky ze sekvence pomocí zadaného IEqualityComparer<T> k porovnání hodnot. |
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíčů. |
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíčů a pomocí zadaného porovnávače k porovnání klíčů. |
ElementAt<TSource>(IEnumerable<TSource>, Index) |
Vrátí prvek v zadaném indexu v sekvenci. |
ElementAt<TSource>(IEnumerable<TSource>, Int32) |
Vrátí prvek v zadaném indexu v sekvenci. |
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index) |
Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah. |
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) |
Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah. |
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Vytvoří rozdíl sady dvou sekvencí pomocí výchozího porovnávače rovnosti pro porovnání hodnot. |
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Vytvoří rozdíl množiny dvou sekvencí pomocí zadané IEqualityComparer<T> hodnoty pro porovnání hodnot. |
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Vytvoří rozdíl množiny dvou sekvencí podle zadané funkce selektoru klíčů. |
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Vytvoří rozdíl množiny dvou sekvencí podle zadané funkce selektoru klíčů. |
First<TSource>(IEnumerable<TSource>) |
Vrátí první prvek sekvence. |
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí první prvek v sekvenci, který splňuje zadanou podmínku. |
FirstOrDefault<TSource>(IEnumerable<TSource>) |
Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky. |
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Vrátí první prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky. |
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí první prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud není nalezen žádný takový prvek. |
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Vrátí první prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud není nalezen žádný takový prvek. |
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů. |
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů a porovná klíče pomocí zadaného porovnávače. |
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů a pomocí zadané funkce promítne elementy pro každou skupinu. |
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Seskupí prvky sekvence podle funkce selektoru klíčů. Klíče se porovnávají pomocí porovnávače a prvky každé skupiny se promítají pomocí zadané funkce. |
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. |
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Klíče se porovnávají pomocí zadaného porovnávače. |
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Prvky každé skupiny jsou projektovány pomocí zadané funkce. |
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>) |
Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Hodnoty klíčů se porovnávají pomocí zadaného porovnávače a prvky každé skupiny se promítají pomocí zadané funkce. |
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>) |
Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupuje výsledky. Výchozí porovnávače rovnosti se používá k porovnání klíčů. |
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>) |
Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupuje výsledky. Zadaný parametr IEqualityComparer<T> se používá k porovnání klíčů. |
Index<TSource>(IEnumerable<TSource>) |
Poskytuje abstraktní základní třídu pro kolekci, jejíž klíče jsou vloženy v hodnotách. |
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Vytvoří průnik sady dvou sekvencí pomocí výchozího porovnávače rovnosti pro porovnání hodnot. |
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Vytvoří množinu průniku dvou sekvencí pomocí zadaného IEqualityComparer<T> pro porovnání hodnot. |
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Vytvoří množinu průniku dvou sekvencí podle zadané funkce selektoru klíčů. |
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Vytvoří množinu průniku dvou sekvencí podle zadané funkce selektoru klíčů. |
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) |
Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. Výchozí porovnávače rovnosti se používá k porovnání klíčů. |
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) |
Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. Zadaný parametr IEqualityComparer<T> se používá k porovnání klíčů. |
Last<TSource>(IEnumerable<TSource>) |
Vrátí poslední prvek sekvence. |
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí poslední prvek sekvence, která splňuje zadanou podmínku. |
LastOrDefault<TSource>(IEnumerable<TSource>) |
Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky. |
LastOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Vrátí poslední prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky. |
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí poslední prvek sekvence, která splňuje podmínku nebo výchozí hodnotu, pokud není nalezen žádný takový prvek. |
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Vrátí poslední prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud není nalezen žádný takový prvek. |
LongCount<TSource>(IEnumerable<TSource>) |
Vrátí hodnotu Int64 , která představuje celkový počet prvků v sekvenci. |
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí hodnotu Int64 , která představuje, kolik prvků v sekvenci splňuje podmínku. |
Max<TSource>(IEnumerable<TSource>) |
Vrátí maximální hodnotu v obecné sekvenci. |
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Vrátí maximální hodnotu v obecné sekvenci. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Decimal hodnotou null. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Double hodnotou null. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Int32 hodnotou null. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Int64 hodnotou null. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Single hodnotou null. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu. |
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Vyvolá transformační funkci na každý prvek obecné sekvence a vrátí maximální výslednou hodnotu. |
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů. |
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů. |
Min<TSource>(IEnumerable<TSource>) |
Vrátí minimální hodnotu v obecné sekvenci. |
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Vrátí minimální hodnotu v obecné sekvenci. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Decimal hodnotu. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Double hodnotu. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Int32 hodnotu. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Int64 hodnotu. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Decimal hodnotou null. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Double hodnotou null. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Int32 hodnotou null. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Int64 hodnotou null. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Single hodnotou null. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Single hodnotu. |
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Vyvolá transformační funkci pro každý prvek obecné sekvence a vrátí minimální výslednou hodnotu. |
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů. |
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů. |
OfType<TResult>(IEnumerable) |
Filtruje prvky objektu IEnumerable na základě zadaného typu. |
Order<T>(IEnumerable<T>) |
Seřadí prvky sekvence ve vzestupném pořadí. |
Order<T>(IEnumerable<T>, IComparer<T>) |
Seřadí prvky sekvence ve vzestupném pořadí. |
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Seřadí prvky sekvence ve vzestupném pořadí podle klíče. |
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Seřadí prvky sekvence ve vzestupném pořadí pomocí zadaného porovnávače. |
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Seřadí prvky sekvence v sestupném pořadí podle klíče. |
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Seřadí prvky sekvence v sestupném pořadí pomocí zadaného porovnávače. |
OrderDescending<T>(IEnumerable<T>) |
Seřadí prvky sekvence v sestupném pořadí. |
OrderDescending<T>(IEnumerable<T>, IComparer<T>) |
Seřadí prvky sekvence v sestupném pořadí. |
Prepend<TSource>(IEnumerable<TSource>, TSource) |
Přidá hodnotu na začátek sekvence. |
Reverse<TSource>(IEnumerable<TSource>) |
Invertuje pořadí prvků v sekvenci. |
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Promítá každý prvek sekvence do nového formuláře. |
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) |
Projektuje každý prvek sekvence do nové podoby začleněním indexu elementu. |
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) |
Promítá každý prvek sekvence do objektu IEnumerable<T> a výsledné sekvence zploštědí do jedné sekvence. |
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) |
Každý prvek sekvence se promítá do objektu IEnumerable<T>a výsledné sekvence zploštědí do jedné sekvence. Index každého zdrojového prvku se používá v projektované podobě tohoto elementu. |
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Promítne každý prvek sekvence na IEnumerable<T>, zploštědí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků pro každý prvek v této sekvenci. |
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Promítne každý prvek sekvence na IEnumerable<T>, zploštědí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků pro každý prvek v této sekvenci. Index každého zdrojového prvku se používá v přechodné projektované podobě tohoto prvku. |
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Určuje, zda jsou dvě sekvence rovny porovnáním prvků pomocí výchozího porovnávače rovnosti pro jejich typ. |
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Určuje, zda jsou dvě sekvence rovny porovnáním jejich prvků pomocí zadaného IEqualityComparer<T>objektu . |
Single<TSource>(IEnumerable<TSource>) |
Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není právě jeden prvek. |
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí jediný prvek sekvence, která splňuje zadanou podmínku, a vyvolá výjimku, pokud existuje více než jeden takový prvek. |
SingleOrDefault<TSource>(IEnumerable<TSource>) |
Vrátí jediný prvek sekvence, nebo výchozí hodnotu, pokud sekvence je prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek. |
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Vrátí jediný prvek sekvence, nebo zadaná výchozí hodnota, pokud sekvence je prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek. |
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí jediný prvek sekvence, která splňuje zadanou podmínku nebo výchozí hodnotu, pokud žádný takový prvek neexistuje; Tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínku. |
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Vrátí jediný prvek sekvence, která splňuje zadanou podmínku, nebo zadanou výchozí hodnotu, pokud neexistuje žádný takový prvek; Tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínku. |
Skip<TSource>(IEnumerable<TSource>, Int32) |
Obchází zadaný počet prvků v sekvenci a pak vrátí zbývající prvky. |
SkipLast<TSource>(IEnumerable<TSource>, Int32) |
Vrátí novou výčtovou kolekci, která obsahuje elementy z |
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Obchází elementy v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky. |
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Obchází elementy v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky. Index elementu se používá v logice funkce predikátu. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Vypočítá součet posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Vypočítá součet posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Vypočítá součet posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Vypočítá součet posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence. |
Take<TSource>(IEnumerable<TSource>, Int32) |
Vrátí zadaný počet souvislých prvků od začátku sekvence. |
Take<TSource>(IEnumerable<TSource>, Range) |
Vrátí zadaný rozsah souvislých prvků ze sekvence. |
TakeLast<TSource>(IEnumerable<TSource>, Int32) |
Vrátí novou výčtovou kolekci, která obsahuje poslední |
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá. |
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá. Index elementu se používá v logice funkce predikátu. |
ToArray<TSource>(IEnumerable<TSource>) |
Vytvoří pole z objektu IEnumerable<T>. |
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů. |
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů a porovnávače klíčů. |
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků. |
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků. |
ToHashSet<TSource>(IEnumerable<TSource>) |
Vytvoří z HashSet<T> objektu IEnumerable<T>. |
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
HashSet<T> Vytvoří z objektu IEnumerable<T> |
ToList<TSource>(IEnumerable<TSource>) |
Vytvoří z List<T> objektu IEnumerable<T>. |
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů. |
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů a porovnávače klíčů. |
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků. |
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků. |
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32) |
Pokusí se určit počet prvků v sekvenci bez vynucení výčtu. |
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Vytvoří sjednocení sady dvou sekvencí pomocí výchozího porovnávače rovnosti. |
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Vytvoří sjednocení sady dvou sekvencí pomocí zadaného IEqualityComparer<T>. |
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>) |
Vytvoří sjednocení sady dvou sekvencí podle zadané funkce selektoru klíčů. |
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Vytvoří sjednocení sady dvou sekvencí podle zadané funkce selektoru klíčů. |
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Filtruje posloupnost hodnot na základě predikátu. |
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Filtruje posloupnost hodnot na základě predikátu. Index každého prvku se používá v logice funkce predikátu. |
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) |
Vytvoří sekvenci řazených kolekcí členů s prvky ze dvou zadaných sekvencí. |
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) |
Vytvoří sekvenci řazených kolekcí členů s prvky ze tří zadaných sekvencí. |
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) |
Použije zadanou funkci na odpovídající prvky dvou sekvencí a vytvoří sekvenci výsledků. |
AsParallel(IEnumerable) |
Umožňuje paralelizaci dotazu. |
AsParallel<TSource>(IEnumerable<TSource>) |
Umožňuje paralelizaci dotazu. |
AsQueryable(IEnumerable) |
Převede objekt na IEnumerableIQueryable. |
AsQueryable<TElement>(IEnumerable<TElement>) |
Převede obecný IEnumerable<T> na obecný IQueryable<T>. |
Ancestors<T>(IEnumerable<T>) |
Vrátí kolekci prvků, která obsahuje nadřazené prvky každého uzlu ve zdrojové kolekci. |
Ancestors<T>(IEnumerable<T>, XName) |
Vrátí filtrovanou kolekci prvků, která obsahuje nadřazené prvky každého uzlu ve zdrojové kolekci. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající XName hodnoty. |
DescendantNodes<T>(IEnumerable<T>) |
Vrátí kolekci následnických uzlů každého dokumentu a prvku ve zdrojové kolekci. |
Descendants<T>(IEnumerable<T>) |
Vrátí kolekci elementů, která obsahuje následné prvky každého prvku a dokumentu ve zdrojové kolekci. |
Descendants<T>(IEnumerable<T>, XName) |
Vrátí filtrovanou kolekci elementů, která obsahuje následníky prvků každého prvku a dokumentu ve zdrojové kolekci. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající XName hodnoty. |
Elements<T>(IEnumerable<T>) |
Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci. |
Elements<T>(IEnumerable<T>, XName) |
Vrátí filtrovanou kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající XName hodnoty. |
InDocumentOrder<T>(IEnumerable<T>) |
Vrátí kolekci uzlů, která obsahuje všechny uzly ve zdrojové kolekci seřazené podle dokumentu. |
Nodes<T>(IEnumerable<T>) |
Vrátí kolekci podřízených uzlů každého dokumentu a prvku ve zdrojové kolekci. |
Remove<T>(IEnumerable<T>) |
Odebere každý uzel ve zdrojové kolekci z nadřazeného uzlu. |
Platí pro
Viz také
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro