KeyedCollection<TKey,TItem> Sınıf
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Anahtarları değerlere eklenmiş bir koleksiyon için soyut temel sınıfı sağlar.
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)
Tür Parametreleri
- TKey
Koleksiyondaki anahtarların türü.
- TItem
Koleksiyondaki öğelerin türü.
- Devralma
- Türetilmiş
- Öznitelikler
Örnekler
Bu bölüm iki kod örneği içerir. İlk örnek, 'den KeyedCollection<TKey,TItem>türetmek için gereken en düşük kodu gösterir ve devralınan yöntemlerin çoğunu gösterir. İkinci örnekte, özel davranış sağlamak için korumalı yöntemlerinin KeyedCollection<TKey,TItem> nasıl geçersiz kılınduğu gösterilmektedir.
1. Örnek
Bu kod örneği, öğesinden KeyedCollection<TKey,TItem>bir koleksiyon sınıfı türetmek için gereken en düşük kodu gösterir: yöntemini geçersiz kılma GetKeyForItem ve bir temel sınıf oluşturucusunun temsilcisi olan bir ortak oluşturucu sağlama. Kod örneği ayrıca ve Collection<T> sınıflarından devralınan özelliklerin ve yöntemlerin KeyedCollection<TKey,TItem> çoğunu gösterir.
SimpleOrder
sınıfı, her biri sırayla bir satır öğesini temsil eden nesneleri içeren OrderItem
çok basit bir talep listesidir. anahtarı OrderItem
sabittir ve sınıfından KeyedCollection<TKey,TItem>türetilen sınıflar için önemli bir noktadır. Değiştirilebilir anahtarlar kullanan bir kod örneği için bkz 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
Örnek 2
Aşağıdaki kod örneği korumalı , , ClearItemsRemoveItemve SetItem yöntemlerini geçersiz kılmayıInsertItem, , Removeve yöntemleri için özel davranış sağlamayı Addve Clear varsayılan Item[] özelliği (C# dilinde dizin oluşturucu) ayarlamayı gösterir. Bu örnekte sağlanan özel davranış, geçersiz kılınan yöntemlerin her birinin sonunda oluşturulan adlı Changed
bir bildirim olayıdır.
Kod örneği, basit bir sipariş formundan SimpleOrder
türetilen KeyedCollection<TKey,TItem> ve temsil eden sınıfını oluşturur. Sipariş formu, sıralanmış öğeleri temsil eden nesneler içerir OrderItem
. Kod örneği ayrıca olay bilgilerini içeren bir SimpleOrderChangedEventArgs
sınıf ve değişiklik türünü tanımlamak için bir numaralandırma oluşturur.
Kod örneği, Main
sınıfın yönteminde Demo
türetilmiş sınıfın özelliklerini ve yöntemlerini çağırarak özel davranışı gösterir.
Bu kod örneği sabit anahtarlara sahip nesneleri kullanır. Değiştirilebilir anahtarlar kullanan bir kod örneği için bkz 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.
Açıklamalar
sınıfı hem KeyedCollection<TKey,TItem> O(1) dizinli alma hem de O(1'e yaklaşan anahtarlı alma sağlar. Bu bir soyut türdür veya daha doğrusu soyut türlerin sonsuz bir kümesidir, çünkü kendi oluşturulmuş genel türlerinin her biri soyut bir temel sınıftır. kullanmak KeyedCollection<TKey,TItem>için, koleksiyon türünüzü uygun yapı türünden türetin.
KeyedCollection<TKey,TItem> sınıfı, genel arabirimini temel alan IList<T> bir koleksiyon ile genel arabirimi temel alan bir koleksiyon arasındaki karmadırIDictionary<TKey,TValue>. Genel arabirimi temel alan koleksiyonlar IList<T> gibi, KeyedCollection<TKey,TItem> öğelerin dizine alınan bir listesidir. Genel arabirimi temel alan koleksiyonlar IDictionary<TKey,TValue> gibi, KeyedCollection<TKey,TItem> her öğeyle ilişkilendirilmiş bir anahtarı vardır.
Sözlüklerden farklı olarak öğesi KeyedCollection<TKey,TItem> anahtar/değer çifti değildir; bunun yerine öğenin tamamı değerdir ve anahtar değerin içine eklenir. Örneğin, bir koleksiyonun öğesinden türetilmiş KeyedCollection\<String,String>
(KeyedCollection(Of String, String)
Visual Basic'te) "John Doe Jr." olabilir; burada değer "John Doe Jr." ve anahtar "Doe" olabilir veya tamsayı anahtarları içeren bir çalışan kayıtları koleksiyonu öğesinden KeyedCollection\<int,Employee>
türetilebilir. soyut GetKeyForItem yöntemi, öğesinden anahtarı ayıklar.
Varsayılan olarak, KeyedCollection<TKey,TItem> özelliğiyle Dictionary edinebileceğiniz bir arama sözlüğü içerir. öğesine bir öğe eklendiğinde KeyedCollection<TKey,TItem>, öğenin anahtarı bir kez ayıklanır ve daha hızlı aramalar için arama sözlüğüne kaydedilir. Bu davranış, oluştururken bir sözlük oluşturma eşiği belirtilerek geçersiz kılınabilir KeyedCollection<TKey,TItem>. Arama sözlüğü, öğe sayısı bu eşiği ilk kez aştığında oluşturulur. Eşik olarak -1 belirtirseniz, arama sözlüğü hiçbir zaman oluşturulmaz.
Not
İç arama sözlüğü kullanıldığında, başvuru türüyse TItem
koleksiyondaki tüm öğelere başvurular veya değer türündeyse TItem
koleksiyondaki tüm öğelerin kopyalarını içerir. Bu nedenle, bir değer türü ise TItem
arama sözlüğü kullanmak uygun olmayabilir.
özelliğini kullanarak bir öğeye dizinine veya anahtarına Item[] göre erişebilirsiniz. Anahtar içermeyen öğeler ekleyebilirsiniz, ancak bu öğelere daha sonra yalnızca dizinle erişilebilir.
Oluşturucular
KeyedCollection<TKey,TItem>() |
Sınıfının varsayılan eşitlik karşılaştırıcısını KeyedCollection<TKey,TItem> kullanan yeni bir örneğini başlatır. |
KeyedCollection<TKey,TItem>(IEqualityComparer<TKey>) |
Belirtilen eşitlik karşılaştırıcısını KeyedCollection<TKey,TItem> kullanan sınıfının yeni bir örneğini başlatır. |
KeyedCollection<TKey,TItem>(IEqualityComparer<TKey>, Int32) |
Belirtilen eşitlik karşılaştırıcısını KeyedCollection<TKey,TItem> kullanan sınıfının yeni bir örneğini başlatır ve belirtilen eşik aşıldığında bir arama sözlüğü oluşturur. |
Özellikler
Comparer |
Koleksiyondaki anahtarların eşitliğini belirlemek için kullanılan genel eşitlik karşılaştırıcısını alır. |
Count |
içinde gerçekte bulunan Collection<T>öğelerin sayısını alır. (Devralındığı yer: Collection<T>) |
Dictionary |
öğesinin arama sözlüğünü KeyedCollection<TKey,TItem>alır. |
Item[Int32] |
Belirtilen dizindeki öğeyi alır veya ayarlar. (Devralındığı yer: Collection<T>) |
Item[TKey] |
Belirtilen anahtarla öğesini alır. |
Items |
çevresinde Collection<T>bir IList<T> sarmalayıcı alır. (Devralındığı yer: Collection<T>) |
Yöntemler
Add(T) |
sonuna bir nesne Collection<T>ekler. (Devralındığı yer: Collection<T>) |
ChangeItemKey(TItem, TKey) |
Arama sözlüğünde belirtilen öğeyle ilişkili anahtarı değiştirir. |
Clear() |
Tüm öğeleri Collection<T> koleksiyonundan kaldırır. (Devralındığı yer: Collection<T>) |
ClearItems() |
Tüm öğeleri KeyedCollection<TKey,TItem> koleksiyonundan kaldırır. |
Contains(TKey) |
Koleksiyonun belirtilen anahtara sahip bir öğe içerip içermediğini belirler. |
CopyTo(T[], Int32) |
Hedef dizinin belirtilen dizininden başlayarak tamamını Collection<T> uyumlu bir tek boyutlu Arrayöğesine kopyalar. (Devralındığı yer: Collection<T>) |
Equals(Object) |
Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object) |
GetEnumerator() |
aracılığıyla Collection<T>yineleyen bir numaralandırıcı döndürür. (Devralındığı yer: Collection<T>) |
GetHashCode() |
Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object) |
GetKeyForItem(TItem) |
Türetilmiş bir sınıfta uygulandığında, anahtarı belirtilen öğeden ayıklar. |
GetType() |
Type Geçerli örneğini alır. (Devralındığı yer: Object) |
IndexOf(T) |
Belirtilen nesneyi arar ve içindeki Collection<T>ilk oluşumun sıfır tabanlı dizinini döndürür. (Devralındığı yer: Collection<T>) |
Insert(Int32, T) |
Belirtilen dizinde öğesine Collection<T> bir öğe ekler. (Devralındığı yer: Collection<T>) |
InsertItem(Int32, T) |
Belirtilen dizinde öğesine Collection<T> bir öğe ekler. (Devralındığı yer: Collection<T>) |
InsertItem(Int32, TItem) |
Belirtilen dizinde öğesine KeyedCollection<TKey,TItem> bir öğe ekler. |
MemberwiseClone() |
Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object) |
Remove(TKey) |
öğesinden KeyedCollection<TKey,TItem>belirtilen anahtara sahip öğesini kaldırır. |
RemoveAt(Int32) |
öğesinin belirtilen dizinindeki Collection<T>öğesini kaldırır. (Devralındığı yer: Collection<T>) |
RemoveItem(Int32) |
öğesinin belirtilen dizinindeki KeyedCollection<TKey,TItem>öğesini kaldırır. |
SetItem(Int32, T) |
Belirtilen dizindeki öğeyi değiştirir. (Devralındığı yer: Collection<T>) |
SetItem(Int32, TItem) |
Belirtilen dizindeki öğeyi belirtilen öğeyle değiştirir. |
ToString() |
Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object) |
TryGetValue(TKey, TItem) |
Belirtilen anahtarı kullanarak koleksiyondan bir öğe almaya çalışır. |
Belirtik Arabirim Kullanımları
ICollection.CopyTo(Array, Int32) |
öğesinin öğelerini ICollection belirli Array bir Arraydizinden başlayarak öğesine kopyalar. (Devralındığı yer: Collection<T>) |
ICollection.IsSynchronized |
erişimin ICollection eşitlenip eşitlenmediğini belirten bir değer alır (iş parçacığı güvenli). (Devralındığı yer: Collection<T>) |
ICollection.SyncRoot |
erişimi ICollectioneşitlemek için kullanılabilecek bir nesnesi alır. (Devralındığı yer: Collection<T>) |
ICollection<T>.IsReadOnly |
ICollection<T> öğesinin salt okunur olup olmadığını belirten bir değer alır. (Devralındığı yer: Collection<T>) |
IEnumerable.GetEnumerator() |
Bir toplulukta tekrarlanan bir numaralandırıcı döndürür. (Devralındığı yer: Collection<T>) |
IList.Add(Object) |
öğesine IListbir öğe ekler. (Devralındığı yer: Collection<T>) |
IList.Contains(Object) |
öğesinin IList belirli bir değer içerip içermediğini belirler. (Devralındığı yer: Collection<T>) |
IList.IndexOf(Object) |
içindeki belirli bir öğenin dizinini IListbelirler. (Devralındığı yer: Collection<T>) |
IList.Insert(Int32, Object) |
Belirtilen dizinde öğesine IList bir öğe ekler. (Devralındığı yer: Collection<T>) |
IList.IsFixedSize |
değerinin sabit bir boyuta sahip olup olmadığını IList belirten bir değer alır. (Devralındığı yer: Collection<T>) |
IList.IsReadOnly |
IList öğesinin salt okunur olup olmadığını belirten bir değer alır. (Devralındığı yer: Collection<T>) |
IList.Item[Int32] |
Belirtilen dizindeki öğeyi alır veya ayarlar. (Devralındığı yer: Collection<T>) |
IList.Remove(Object) |
Belirli bir nesnenin ilk oluşumunu öğesinden IListkaldırır. (Devralındığı yer: Collection<T>) |
Uzantı Metotları
ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Belirtilen anahtar seçici işlevine göre işlevinden bir FrozenDictionary<TKey,TValue>IEnumerable<T> oluşturur. |
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Belirtilen anahtar seçici ve öğe seçici işlevlerine göre öğesinden bir FrozenDictionary<TKey,TValue>IEnumerable<T> oluşturur. |
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>) |
Belirtilen değerlerle bir FrozenSet<T> oluşturur. |
AsReadOnly<T>(IList<T>) |
Belirtilen liste için salt ReadOnlyCollection<T> okunur bir sarmalayıcı döndürür. |
ToImmutableArray<TSource>(IEnumerable<TSource>) |
Belirtilen koleksiyondan sabit bir dizi oluşturur. |
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Var olan bir öğe koleksiyonundan sabit bir sözlük oluşturur ve kaynak anahtarlara bir dönüştürme işlevi uygular. |
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Bir dizinin bazı dönüşümlerini temel alan sabit bir sözlük oluşturur. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Bir diziyi numaralandırır ve dönüştürür ve içeriğinin sabit bir sözlüğünü üretir. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) |
Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriğinin sabit bir sözlüğünü üretir. |
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) |
Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar ve değer karşılaştırıcılarını kullanarak içeriğinin sabit bir sözlüğünü üretir. |
ToImmutableHashSet<TSource>(IEnumerable<TSource>) |
Bir diziyi numaralandırır ve içeriğinin sabit bir karma kümesini oluşturur. |
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Bir diziyi numaralandırır, içeriğini sabit bir karma kümesi oluşturur ve küme türü için belirtilen eşitlik karşılaştırıcısını kullanır. |
ToImmutableList<TSource>(IEnumerable<TSource>) |
Bir diziyi numaralandırır ve içeriğinin sabit bir listesini oluşturur. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Bir diziyi numaralandırır ve dönüştürür ve içindekiler için sabit bir sıralanmış sözlük oluşturur. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) |
Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriğinin sabit bir sıralanmış sözlüğü oluşturur. |
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) |
Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar ve değer karşılaştırıcılarını kullanarak içeriğinin sabit bir sıralanmış sözlüğü oluşturur. |
ToImmutableSortedSet<TSource>(IEnumerable<TSource>) |
Bir diziyi numaralandırır ve içeriğinin sabit sıralı bir kümesini oluşturur. |
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Bir diziyi numaralandırır, içeriğinin sabit bir sıralanmış kümesini oluşturur ve belirtilen karşılaştırıcıyı kullanır. |
CopyToDataTable<T>(IEnumerable<T>) |
DataTable Genel parametrenin DataRowDataRow |
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) |
DataRow Genel parametresinin |
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) |
DataRow Genel parametresinin |
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) |
Bir dizi üzerinde bir biriktirici işlevi uygular. |
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) |
Bir dizi üzerinde bir biriktirici işlevi uygular. Belirtilen çekirdek değeri ilk biriktirici değeri olarak kullanılır. |
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) |
Bir dizi üzerinde bir biriktirici işlevi uygular. Belirtilen çekirdek değeri ilk biriktirici değeri olarak kullanılır ve belirtilen işlev sonuç değerini seçmek için kullanılır. |
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>) |
Anahtarları değerlere eklenmiş bir koleksiyon için soyut temel sınıfı sağlar. |
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>) |
Anahtarları değerlere eklenmiş bir koleksiyon için soyut temel sınıfı sağlar. |
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bir dizinin tüm öğelerinin bir koşulu karşılayıp karşılamadığını belirler. |
Any<TSource>(IEnumerable<TSource>) |
Bir dizinin herhangi bir öğe içerip içermediğini belirler. |
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bir dizi öğesinin bir koşulu karşılayıp karşılamayacağını belirler. |
Append<TSource>(IEnumerable<TSource>, TSource) |
Sıranın sonuna bir değer ekler. |
AsEnumerable<TSource>(IEnumerable<TSource>) |
olarak IEnumerable<T>yazılan girişi döndürür. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Giriş dizisinin Decimal her öğesinde bir dönüştürme işlevi çağrılarak elde edilen bir değer dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Giriş dizisinin Double her öğesinde bir dönüştürme işlevi çağrılarak elde edilen bir değer dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Giriş dizisinin Int32 her öğesinde bir dönüştürme işlevi çağrılarak elde edilen bir değer dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Giriş dizisinin Int64 her öğesinde bir dönüştürme işlevi çağrılarak elde edilen bir değer dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Decimal değerler dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Double değerler dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Int32 değerler dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Int64 değerler dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Single değerler dizisinin ortalamasını hesaplar. |
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Giriş dizisinin Single her öğesinde bir dönüştürme işlevi çağrılarak elde edilen bir değer dizisinin ortalamasını hesaplar. |
Cast<TResult>(IEnumerable) |
öğesinin IEnumerable öğelerini belirtilen türe atar. |
Chunk<TSource>(IEnumerable<TSource>, Int32) |
Bir dizinin öğelerini en fazla |
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
İki diziyi birleştirir. |
Contains<TSource>(IEnumerable<TSource>, TSource) |
Varsayılan eşitlik karşılaştırıcısını kullanarak bir dizinin belirtilen öğeyi içerip içermediğini belirler. |
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) |
Belirtilen öğesini kullanarak IEqualityComparer<T>bir dizinin belirtilen öğeyi içerip içermediğini belirler. |
Count<TSource>(IEnumerable<TSource>) |
Bir dizideki öğelerin sayısını döndürür. |
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen dizideki bir koşulu karşılayan öğe sayısını temsil eden bir sayı döndürür. |
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Anahtarları değerlere eklenmiş bir koleksiyon için soyut temel sınıfı sağlar. |
DefaultIfEmpty<TSource>(IEnumerable<TSource>) |
Belirtilen dizinin öğelerini veya dizi boşsa bir singleton koleksiyonundaki tür parametresinin varsayılan değerini döndürür. |
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) |
Dizi boşsa, belirtilen dizinin öğelerini veya bir singleton koleksiyonundaki belirtilen değeri döndürür. |
Distinct<TSource>(IEnumerable<TSource>) |
Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcısını kullanarak bir diziden farklı öğeler döndürür. |
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> kullanarak bir diziden farklı öğeler döndürür. |
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Belirtilen anahtar seçici işlevine göre bir diziden farklı öğeler döndürür. |
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Belirtilen anahtar seçici işlevine göre ve anahtarları karşılaştırmak için belirtilen karşılaştırıcıyı kullanarak bir diziden ayrı öğeler döndürür. |
ElementAt<TSource>(IEnumerable<TSource>, Index) |
Bir dizideki belirtilen dizindeki öğesini döndürür. |
ElementAt<TSource>(IEnumerable<TSource>, Int32) |
Bir dizideki belirtilen dizindeki öğesini döndürür. |
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index) |
Belirtilen dizindeki öğeyi bir dizide veya dizin aralık dışındaysa varsayılan bir değerle döndürür. |
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) |
Belirtilen dizindeki öğeyi bir dizide veya dizin aralık dışındaysa varsayılan bir değerle döndürür. |
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcısını kullanarak iki dizinin küme farkını üretir. |
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> öğesini kullanarak iki dizinin küme farkını üretir. |
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Belirtilen anahtar seçici işlevine göre iki sıranın küme farkını üretir. |
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Belirtilen anahtar seçici işlevine göre iki sıranın küme farkını üretir. |
First<TSource>(IEnumerable<TSource>) |
Bir dizinin ilk öğesini döndürür. |
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen koşulu karşılayan bir dizideki ilk öğeyi döndürür. |
FirstOrDefault<TSource>(IEnumerable<TSource>) |
Bir dizinin ilk öğesini veya dizide öğe yoksa varsayılan değeri döndürür. |
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Bir dizinin ilk öğesini veya dizide öğe yoksa belirtilen varsayılan değeri döndürür. |
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Böyle bir öğe bulunamazsa, bir koşulu veya varsayılan değeri karşılayan dizinin ilk öğesini döndürür. |
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Bir koşulu karşılayan dizinin ilk öğesini veya böyle bir öğe bulunamazsa belirtilen varsayılan değeri döndürür. |
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın. |
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Bir dizinin öğelerini belirtilen bir anahtar seçici işlevine göre gruplandırır ve belirtilen bir karşılaştırıcıyı kullanarak anahtarları karşılaştırır. |
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Bir dizinin öğelerini belirtilen bir anahtar seçici işlevine göre gruplandırın ve belirtilen bir işlevi kullanarak her grubun öğelerini projeler. |
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Bir dizinin öğelerini bir anahtar seçici işlevine göre gruplandırın. Anahtarlar bir karşılaştırıcı kullanılarak karşılaştırılır ve her grubun öğeleri belirtilen bir işlev kullanılarak yansıtılır. |
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) |
Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. |
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) |
Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. Anahtarlar, belirtilen bir karşılaştırıcı kullanılarak karşılaştırılır. |
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) |
Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. Her grubun öğeleri, belirtilen bir işlev kullanılarak yansıtılır. |
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>) |
Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. Anahtar değerleri belirtilen bir karşılaştırıcı kullanılarak karşılaştırılır ve her grubun öğeleri belirtilen bir işlev kullanılarak yansıtılır. |
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>) |
Anahtarların eşitliğine göre iki dizinin öğelerini ilişkilendirir ve sonuçları gruplandırir. Varsayılan eşitlik karşılaştırıcısı anahtarları karşılaştırmak için kullanılır. |
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>) |
Anahtar eşitliğine göre iki dizinin öğelerini ilişkilendirir ve sonuçları gruplandırir. Anahtarları karşılaştırmak için belirtilen IEqualityComparer<T> bir kullanılır. |
Index<TSource>(IEnumerable<TSource>) |
Anahtarları değerlere eklenmiş bir koleksiyon için soyut temel sınıfı sağlar. |
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcısını kullanarak iki dizinin küme kesişimini üretir. |
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> öğesini kullanarak iki dizinin küme kesişimini üretir. |
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Belirtilen anahtar seçici işlevine göre iki dizinin küme kesişimini üretir. |
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Belirtilen anahtar seçici işlevine göre iki dizinin küme kesişimini üretir. |
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) |
eşleşen anahtarlara göre iki dizinin öğelerini ilişkilendirir. Varsayılan eşitlik karşılaştırıcısı anahtarları karşılaştırmak için kullanılır. |
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) |
eşleşen anahtarlara göre iki dizinin öğelerini ilişkilendirir. Anahtarları karşılaştırmak için belirtilen IEqualityComparer<T> bir kullanılır. |
Last<TSource>(IEnumerable<TSource>) |
Bir dizinin son öğesini döndürür. |
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen koşulu karşılayan bir dizinin son öğesini döndürür. |
LastOrDefault<TSource>(IEnumerable<TSource>) |
Bir dizinin son öğesini veya dizi öğe içermiyorsa varsayılan değeri döndürür. |
LastOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Bir dizinin son öğesini veya dizide öğe yoksa belirtilen varsayılan değeri döndürür. |
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bir koşulu karşılayan bir dizinin son öğesini veya böyle bir öğe bulunamazsa varsayılan değeri döndürür. |
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Bir koşulu karşılayan bir dizinin son öğesini veya böyle bir öğe bulunamazsa belirtilen varsayılan değeri döndürür. |
LongCount<TSource>(IEnumerable<TSource>) |
Bir Int64 dizideki öğelerin toplam sayısını temsil eden bir döndürür. |
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bir Int64 dizideki kaç öğenin koşulu karşıladığını temsil eden bir döndürür. |
Max<TSource>(IEnumerable<TSource>) |
Genel bir dizideki en büyük değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Genel bir dizideki en büyük değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Decimal değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Double değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Int32 değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Int64 değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Decimal en yüksek değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Double en yüksek değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int32 en yüksek değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int64 en yüksek değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Single en yüksek değeri döndürür. |
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Single değeri döndürür. |
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Genel bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve sonuçta elde edilen en yüksek değeri döndürür. |
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Belirtilen anahtar seçici işlevine göre genel bir dizideki en büyük değeri döndürür. |
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Belirtilen anahtar seçici işlevine ve anahtar karşılaştırıcısına göre genel bir dizideki en büyük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>) |
Genel bir dizideki en küçük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Genel bir dizideki en küçük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Decimal değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Double değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Int32 değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Int64 değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Decimal en düşük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Double en düşük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int32 en düşük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int64 en düşük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Single en düşük değeri döndürür. |
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Single değeri döndürür. |
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Genel bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve sonuçta elde edilen en düşük değeri döndürür. |
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Belirtilen anahtar seçici işlevine göre genel bir dizideki en düşük değeri döndürür. |
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Belirtilen anahtar seçici işlevine ve anahtar karşılaştırıcısına göre genel bir dizideki en düşük değeri döndürür. |
OfType<TResult>(IEnumerable) |
Öğesinin IEnumerable öğelerini belirtilen türe göre filtreler. |
Order<T>(IEnumerable<T>) |
Bir dizinin öğelerini artan düzende sıralar. |
Order<T>(IEnumerable<T>, IComparer<T>) |
Bir dizinin öğelerini artan düzende sıralar. |
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Bir dizinin öğelerini bir anahtara göre artan düzende sıralar. |
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Belirtilen karşılaştırıcıyı kullanarak bir dizinin öğelerini artan düzende sıralar. |
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Bir dizinin öğelerini bir anahtara göre azalan düzende sıralar. |
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Belirtilen bir karşılaştırıcıyı kullanarak bir dizinin öğelerini azalan düzende sıralar. |
OrderDescending<T>(IEnumerable<T>) |
Bir dizinin öğelerini azalan düzende sıralar. |
OrderDescending<T>(IEnumerable<T>, IComparer<T>) |
Bir dizinin öğelerini azalan düzende sıralar. |
Prepend<TSource>(IEnumerable<TSource>, TSource) |
Sıranın başına bir değer ekler. |
Reverse<TSource>(IEnumerable<TSource>) |
Bir dizideki öğelerin sırasını ters çevirir. |
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Bir dizinin her öğesini yeni bir forma projeler. |
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) |
Öğenin dizinini birleştirerek bir dizinin her öğesini yeni bir forma projeler. |
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) |
Bir dizinin her öğesini öğesine IEnumerable<T> projeler ve sonuçta elde edilen dizileri tek bir sırayla düzleştirir. |
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) |
Bir dizinin her öğesini öğesine IEnumerable<T>projeler ve sonuçta elde edilen dizileri tek bir sırayla düzleştirir. Her kaynak öğenin dizini, bu öğenin öngörülen biçiminde kullanılır. |
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Bir dizinin her öğesini bir IEnumerable<T>öğesine projeler, sonuçta elde edilen dizileri tek bir sırayla düzleştirir ve buradaki her öğede bir sonuç seçici işlevi çağırır. |
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Bir dizinin her öğesini bir IEnumerable<T>öğesine projeler, sonuçta elde edilen dizileri tek bir sırayla düzleştirir ve buradaki her öğede bir sonuç seçici işlevi çağırır. Her kaynak öğenin dizini, bu öğenin ara öngörülen formunda kullanılır. |
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Türleri için varsayılan eşitlik karşılaştırıcısını kullanarak öğeleri karşılaştırarak iki dizinin eşit olup olmadığını belirler. |
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Belirtilen IEqualityComparer<T>bir kullanarak öğelerini karşılaştırarak iki dizinin eşit olup olmadığını belirler. |
Single<TSource>(IEnumerable<TSource>) |
Bir dizinin tek öğesini döndürür ve dizide tam olarak bir öğe yoksa bir özel durum oluşturur. |
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen koşulu karşılayan bir dizinin tek öğesini döndürür ve birden fazla öğe varsa bir özel durum oluşturur. |
SingleOrDefault<TSource>(IEnumerable<TSource>) |
Bir dizinin tek öğesini veya dizi boşsa varsayılan değeri döndürür; bu yöntem, dizide birden fazla öğe varsa bir özel durum oluşturur. |
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Bir dizinin tek öğesini veya dizi boşsa belirtilen varsayılan değeri döndürür; bu yöntem, dizide birden fazla öğe varsa bir özel durum oluşturur. |
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen koşulu karşılayan bir dizinin tek öğesini veya böyle bir öğe yoksa varsayılan değeri döndürür; Bu yöntem, koşulu birden fazla öğe karşılarsa bir özel durum oluşturur. |
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Belirtilen koşulu karşılayan bir dizinin tek öğesini veya böyle bir öğe yoksa belirtilen varsayılan değeri döndürür; Bu yöntem, koşulu birden fazla öğe karşılarsa bir özel durum oluşturur. |
Skip<TSource>(IEnumerable<TSource>, Int32) |
Bir dizideki belirtilen sayıda öğeyi atlar ve sonra kalan öğeleri döndürür. |
SkipLast<TSource>(IEnumerable<TSource>, Int32) |
Kaynak koleksiyonun son |
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen koşul true olduğu sürece bir dizideki öğeleri atlar ve sonra kalan öğeleri döndürür. |
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Belirtilen koşul true olduğu sürece bir dizideki öğeleri atlar ve sonra kalan öğeleri döndürür. Öğenin dizini koşul işlevinin mantığında kullanılır. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Decimal toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Double toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Int32 toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Int64 toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Decimal dizisinin toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Double dizisinin toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Int32 dizisinin toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Int64 dizisinin toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Single dizisinin toplamını hesaplar. |
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Single toplamını hesaplar. |
Take<TSource>(IEnumerable<TSource>, Int32) |
Bir dizinin başlangıcından belirtilen sayıda bitişik öğe döndürür. |
Take<TSource>(IEnumerable<TSource>, Range) |
Bir diziden belirli bir bitişik öğe aralığını döndürür. |
TakeLast<TSource>(IEnumerable<TSource>, Int32) |
öğesinden |
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Belirtilen koşul true olduğu sürece bir diziden öğe döndürür. |
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Belirtilen koşul true olduğu sürece bir diziden öğe döndürür. Öğenin dizini koşul işlevinin mantığında kullanılır. |
ToArray<TSource>(IEnumerable<TSource>) |
bir dizininden bir IEnumerable<T>dizi oluşturur. |
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Dictionary<TKey,TValue> Belirtilen anahtar seçici işlevine göre bir'den IEnumerable<T> bir oluşturur. |
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Dictionary<TKey,TValue> Belirtilen bir anahtar seçici işlevine ve anahtar karşılaştırıcısına göre'den IEnumerable<T> bir oluşturur. |
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Belirtilen anahtar seçici ve öğe seçici işlevlerine göre öğesinden bir Dictionary<TKey,TValue>IEnumerable<T> oluşturur. |
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Dictionary<TKey,TValue> Belirtilen anahtar seçici işlevine, karşılaştırıcıya ve öğe seçici işlevine göre öğesinden IEnumerable<T> bir oluşturur. |
ToHashSet<TSource>(IEnumerable<TSource>) |
bir 'den bir HashSet<T>IEnumerable<T>oluşturur. |
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
anahtarları karşılaştırmak için kullanarak |
ToList<TSource>(IEnumerable<TSource>) |
bir 'den bir List<T>IEnumerable<T>oluşturur. |
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Lookup<TKey,TElement> Belirtilen anahtar seçici işlevine göre bir'den IEnumerable<T> bir oluşturur. |
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Lookup<TKey,TElement> Belirtilen bir anahtar seçici işlevine ve anahtar karşılaştırıcısına göre'den IEnumerable<T> bir oluşturur. |
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Belirtilen anahtar seçici ve öğe seçici işlevlerine göre öğesinden bir Lookup<TKey,TElement>IEnumerable<T> oluşturur. |
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Lookup<TKey,TElement> Belirtilen bir anahtar seçici işlevine, bir karşılaştırıcıya ve öğe seçici işlevine göre öğesinden IEnumerable<T> bir oluşturur. |
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32) |
Bir numaralandırmayı zorlamadan bir dizideki öğelerin sayısını belirlemeye çalışır. |
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Varsayılan eşitlik karşılaştırıcısını kullanarak iki dizinin küme birleşimini üretir. |
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Belirtilen IEqualityComparer<T>bir kullanarak iki dizinin küme birleşimini üretir. |
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>) |
Belirtilen anahtar seçici işlevine göre iki dizinin küme birleşimini üretir. |
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Belirtilen anahtar seçici işlevine göre iki dizinin küme birleşimini üretir. |
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bir koşula göre bir değer dizisini filtreler. |
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Bir koşula göre bir değer dizisini filtreler. Her öğenin dizini koşul işlevinin mantığında kullanılır. |
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) |
Belirtilen iki dizideki öğelerle bir tanımlama grubu dizisi oluşturur. |
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) |
Belirtilen üç dizideki öğelerle bir tanımlama grubu dizisi oluşturur. |
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) |
Belirtilen bir işlevi, sonuçların bir dizisini oluşturan iki dizinin karşılık gelen öğelerine uygular. |
AsParallel(IEnumerable) |
Sorgunun paralelleştirilmesini etkinleştirir. |
AsParallel<TSource>(IEnumerable<TSource>) |
Sorgunun paralelleştirilmesini etkinleştirir. |
AsQueryable(IEnumerable) |
bir IEnumerable öğesini öğesine IQueryabledönüştürür. |
AsQueryable<TElement>(IEnumerable<TElement>) |
Genel bir öğesini genel IEnumerable<T> bir IQueryable<T>öğesine dönüştürür. |
Ancestors<T>(IEnumerable<T>) |
Kaynak koleksiyondaki her düğümün üst öğelerini içeren bir öğe koleksiyonu döndürür. |
Ancestors<T>(IEnumerable<T>, XName) |
Kaynak koleksiyondaki her düğümün üst öğelerini içeren filtrelenmiş bir öğe koleksiyonu döndürür. Yalnızca eşleştirmesi XName olan öğeler koleksiyona dahil edilir. |
DescendantNodes<T>(IEnumerable<T>) |
Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinden oluşan bir koleksiyon döndürür. |
Descendants<T>(IEnumerable<T>) |
Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerini içeren bir öğe koleksiyonu döndürür. |
Descendants<T>(IEnumerable<T>, XName) |
Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerini içeren filtrelenmiş bir öğe koleksiyonu döndürür. Yalnızca eşleştirmesi XName olan öğeler koleksiyona dahil edilir. |
Elements<T>(IEnumerable<T>) |
Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerinin bir koleksiyonunu döndürür. |
Elements<T>(IEnumerable<T>, XName) |
Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerinin filtrelenmiş bir koleksiyonunu döndürür. Yalnızca eşleştirmesi XName olan öğeler koleksiyona dahil edilir. |
InDocumentOrder<T>(IEnumerable<T>) |
Kaynak koleksiyondaki tüm düğümleri içeren ve belge düzenine göre sıralanmış bir düğüm koleksiyonu döndürür. |
Nodes<T>(IEnumerable<T>) |
Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinden oluşan bir koleksiyon döndürür. |
Remove<T>(IEnumerable<T>) |
Kaynak koleksiyondaki her düğümü üst düğümünden kaldırır. |
Şunlara uygulanır
Ayrıca bkz.
Geri Bildirim
https://aka.ms/ContentUserFeedback.
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz.Gönderin ve geri bildirimi görüntüleyin