IDictionary Interfaz
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Representa una colección no genérica de pares clave-valor.
public interface class IDictionary : System::Collections::ICollectionpublic interface IDictionary : System.Collections.ICollection[System.Runtime.InteropServices.ComVisible(true)]
public interface IDictionary : System.Collections.ICollectiontype IDictionary = interface
interface ICollection
interface IEnumerable[<System.Runtime.InteropServices.ComVisible(true)>]
type IDictionary = interface
interface ICollection
interface IEnumerablePublic Interface IDictionary
Implements ICollection- Derivado
- Atributos
- Implementaciones
Ejemplos
En el ejemplo de código siguiente se muestra cómo definir una clase de diccionario simple que implementa la IDictionary interfaz .
using namespace System;
using namespace System::Collections;
// This class implements a simple dictionary using an array of
// DictionaryEntry objects (key/value pairs).
public ref class SimpleDictionary : public IDictionary
{
// The array of items
private:
array<DictionaryEntry^>^ items;
private:
int itemsInUse;
// Construct the SimpleDictionary with the desired number of
// items. The number of items cannot change for the life time of
// this SimpleDictionary.
public:
SimpleDictionary(int size)
{
items = gcnew array<DictionaryEntry^>(size);
}
#pragma region IDictionary Members
public:
property virtual bool IsReadOnly
{
bool get()
{
return false;
}
}
public:
virtual bool Contains(Object^ key)
{
int index;
return TryGetIndexOfKey(key, &index);
}
public:
virtual property bool IsFixedSize
{
bool get()
{
return false;
}
}
public:
virtual void Remove(Object^ key)
{
if (key == nullptr)
{
throw gcnew ArgumentNullException("key");
}
// Try to find the key in the DictionaryEntry array
int index;
if (TryGetIndexOfKey(key, &index))
{
// If the key is found, slide all the items down.
Array::Copy(items, index + 1, items, index, itemsInUse -
index - 1);
itemsInUse--;
}
else
{
// If the key is not in the dictionary, just return.
return;
}
}
public:
virtual void Clear()
{
itemsInUse = 0;
}
public:
virtual void Add(Object^ key, Object^ value)
{
// Add the new key/value pair even if this key already exists
// in the dictionary.
if (itemsInUse == items->Length)
{
throw gcnew InvalidOperationException
("The dictionary cannot hold any more items.");
}
items[itemsInUse++] = gcnew DictionaryEntry(key, value);
}
public:
virtual property ICollection^ Keys
{
ICollection^ get()
{
// Return an array where each item is a key.
array<Object^>^ keys = gcnew array<Object^>(itemsInUse);
for (int i = 0; i < itemsInUse; i++)
{
keys[i] = items[i]->Key;
}
return keys;
}
}
public:
virtual property ICollection^ Values
{
ICollection^ get()
{
// Return an array where each item is a value.
array<Object^>^ values = gcnew array<Object^>(itemsInUse);
for (int i = 0; i < itemsInUse; i++)
{
values[i] = items[i]->Value;
}
return values;
}
}
public:
virtual property Object^ default[Object^]
{
Object^ get(Object^ key)
{
// If this key is in the dictionary, return its value.
int index;
if (TryGetIndexOfKey(key, &index))
{
// The key was found; return its value.
return items[index]->Value;
}
else
{
// The key was not found; return null.
return nullptr;
}
}
void set(Object^ key, Object^ value)
{
// If this key is in the dictionary, change its value.
int index;
if (TryGetIndexOfKey(key, &index))
{
// The key was found; change its value.
items[index]->Value = value;
}
else
{
// This key is not in the dictionary; add this
// key/value pair.
Add(key, value);
}
}
}
private:
bool TryGetIndexOfKey(Object^ key, int* index)
{
for (*index = 0; *index < itemsInUse; *index++)
{
// If the key is found, return true (the index is also
// returned).
if (items[*index]->Key->Equals(key))
{
return true;
}
}
// Key not found, return false (index should be ignored by
// the caller).
return false;
}
private:
ref class SimpleDictionaryEnumerator : public IDictionaryEnumerator
{
// A copy of the SimpleDictionary object's key/value pairs.
private:
array<DictionaryEntry^>^ items;
private:
int index;
public:
SimpleDictionaryEnumerator(SimpleDictionary^ sd)
{
// Make a copy of the dictionary entries currently in the
// SimpleDictionary object.
items = gcnew array<DictionaryEntry^>(sd->Count);
Array::Copy(sd->items, 0, items, 0, sd->Count);
index = -1;
}
// Return the current item.
public:
virtual property Object^ Current
{
Object^ get()
{
ValidateIndex();
return items[index];
}
}
// Return the current dictionary entry.
public:
virtual property DictionaryEntry Entry
{
DictionaryEntry get()
{
return (DictionaryEntry) Current;
}
}
// Return the key of the current item.
public:
virtual property Object^ Key
{
Object^ get()
{
ValidateIndex();
return items[index]->Key;
}
}
// Return the value of the current item.
public:
virtual property Object^ Value
{
Object^ get()
{
ValidateIndex();
return items[index]->Value;
}
}
// Advance to the next item.
public:
virtual bool MoveNext()
{
if (index < items->Length - 1)
{
index++;
return true;
}
return false;
}
// Validate the enumeration index and throw an exception if
// the index is out of range.
private:
void ValidateIndex()
{
if (index < 0 || index >= items->Length)
{
throw gcnew InvalidOperationException
("Enumerator is before or after the collection.");
}
}
// Reset the index to restart the enumeration.
public:
virtual void Reset()
{
index = -1;
}
};
public:
virtual IDictionaryEnumerator^ GetEnumerator()
{
// Construct and return an enumerator.
return gcnew SimpleDictionaryEnumerator(this);
}
#pragma endregion
#pragma region ICollection Members
public:
virtual property bool IsSynchronized
{
bool get()
{
return false;
}
}
public:
virtual property Object^ SyncRoot
{
Object^ get()
{
throw gcnew NotImplementedException();
}
}
public:
virtual property int Count
{
int get()
{
return itemsInUse;
}
}
public:
virtual void CopyTo(Array^ array, int index)
{
throw gcnew NotImplementedException();
}
#pragma endregion
#pragma region IEnumerable Members
virtual IEnumerator^ IEnumerable_GetEnumerator()
= IEnumerable::GetEnumerator
{
// Construct and return an enumerator.
return ((IDictionary^)this)->GetEnumerator();
}
#pragma endregion
};
int main()
{
// Create a dictionary that contains no more than three
// entries.
IDictionary^ d = gcnew SimpleDictionary(3);
// Add three people and their ages to the dictionary.
d->Add("Jeff", 40);
d->Add("Kristin", 34);
d->Add("Aidan", 1);
Console::WriteLine("Number of elements in dictionary = {0}",
d->Count);
Console::WriteLine("Does dictionary contain 'Jeff'? {0}",
d->Contains("Jeff"));
Console::WriteLine("Jeff's age is {0}", d["Jeff"]);
// Display every entry's key and value.
for each (DictionaryEntry^ de in d)
{
Console::WriteLine("{0} is {1} years old.", de->Key,
de->Value);
}
// Remove an entry that exists.
d->Remove("Jeff");
// Remove an entry that does not exist, but do not throw an
// exception.
d->Remove("Max");
// Show the names (keys) of the people in the dictionary.
for each (String^ s in d->Keys)
{
Console::WriteLine(s);
}
// Show the ages (values) of the people in the dictionary.
for each (int age in d->Values)
{
Console::WriteLine(age);
}
}
// This code produces the following output.
//
// Number of elements in dictionary = 3
// Does dictionary contain 'Jeff'? True
// Jeff's age is 40
// Jeff is 40 years old.
// Kristin is 34 years old.
// Aidan is 1 years old.
// Kristin
// Aidan
// 34
// 1
using System;
using System.Collections;
// This class implements a simple dictionary using an array of DictionaryEntry objects (key/value pairs).
public class SimpleDictionary : IDictionary
{
// The array of items
private DictionaryEntry[] items;
private Int32 ItemsInUse = 0;
// Construct the SimpleDictionary with the desired number of items.
// The number of items cannot change for the life time of this SimpleDictionary.
public SimpleDictionary(Int32 numItems)
{
items = new DictionaryEntry[numItems];
}
#region IDictionary Members
public bool IsReadOnly { get { return false; } }
public bool Contains(object key)
{
Int32 index;
return TryGetIndexOfKey(key, out index);
}
public bool IsFixedSize { get { return false; } }
public void Remove(object key)
{
if (key == null) throw new ArgumentNullException("key");
// Try to find the key in the DictionaryEntry array
Int32 index;
if (TryGetIndexOfKey(key, out index))
{
// If the key is found, slide all the items up.
Array.Copy(items, index + 1, items, index, ItemsInUse - index - 1);
ItemsInUse--;
}
else
{
// If the key is not in the dictionary, just return.
}
}
public void Clear() { ItemsInUse = 0; }
public void Add(object key, object value)
{
// Add the new key/value pair even if this key already exists in the dictionary.
if (ItemsInUse == items.Length)
throw new InvalidOperationException("The dictionary cannot hold any more items.");
items[ItemsInUse++] = new DictionaryEntry(key, value);
}
public ICollection Keys
{
get
{
// Return an array where each item is a key.
Object[] keys = new Object[ItemsInUse];
for (Int32 n = 0; n < ItemsInUse; n++)
keys[n] = items[n].Key;
return keys;
}
}
public ICollection Values
{
get
{
// Return an array where each item is a value.
Object[] values = new Object[ItemsInUse];
for (Int32 n = 0; n < ItemsInUse; n++)
values[n] = items[n].Value;
return values;
}
}
public object this[object key]
{
get
{
// If this key is in the dictionary, return its value.
Int32 index;
if (TryGetIndexOfKey(key, out index))
{
// The key was found; return its value.
return items[index].Value;
}
else
{
// The key was not found; return null.
return null;
}
}
set
{
// If this key is in the dictionary, change its value.
Int32 index;
if (TryGetIndexOfKey(key, out index))
{
// The key was found; change its value.
items[index].Value = value;
}
else
{
// This key is not in the dictionary; add this key/value pair.
Add(key, value);
}
}
}
private Boolean TryGetIndexOfKey(Object key, out Int32 index)
{
for (index = 0; index < ItemsInUse; index++)
{
// If the key is found, return true (the index is also returned).
if (items[index].Key.Equals(key)) return true;
}
// Key not found, return false (index should be ignored by the caller).
return false;
}
private class SimpleDictionaryEnumerator : IDictionaryEnumerator
{
// A copy of the SimpleDictionary object's key/value pairs.
DictionaryEntry[] items;
Int32 index = -1;
public SimpleDictionaryEnumerator(SimpleDictionary sd)
{
// Make a copy of the dictionary entries currently in the SimpleDictionary object.
items = new DictionaryEntry[sd.Count];
Array.Copy(sd.items, 0, items, 0, sd.Count);
}
// Return the current item.
public Object Current { get { ValidateIndex(); return items[index]; } }
// Return the current dictionary entry.
public DictionaryEntry Entry
{
get { return (DictionaryEntry) Current; }
}
// Return the key of the current item.
public Object Key { get { ValidateIndex(); return items[index].Key; } }
// Return the value of the current item.
public Object Value { get { ValidateIndex(); return items[index].Value; } }
// Advance to the next item.
public Boolean MoveNext()
{
if (index < items.Length - 1) { index++; return true; }
return false;
}
// Validate the enumeration index and throw an exception if the index is out of range.
private void ValidateIndex()
{
if (index < 0 || index >= items.Length)
throw new InvalidOperationException("Enumerator is before or after the collection.");
}
// Reset the index to restart the enumeration.
public void Reset()
{
index = -1;
}
}
public IDictionaryEnumerator GetEnumerator()
{
// Construct and return an enumerator.
return new SimpleDictionaryEnumerator(this);
}
#endregion
#region ICollection Members
public bool IsSynchronized { get { return false; } }
public object SyncRoot { get { throw new NotImplementedException(); } }
public int Count { get { return ItemsInUse; } }
public void CopyTo(Array array, int index) { throw new NotImplementedException(); }
#endregion
#region IEnumerable Members
IEnumerator IEnumerable.GetEnumerator()
{
// Construct and return an enumerator.
return ((IDictionary)this).GetEnumerator();
}
#endregion
}
public sealed class App
{
static void Main()
{
// Create a dictionary that contains no more than three entries.
IDictionary d = new SimpleDictionary(3);
// Add three people and their ages to the dictionary.
d.Add("Jeff", 40);
d.Add("Kristin", 34);
d.Add("Aidan", 1);
Console.WriteLine("Number of elements in dictionary = {0}", d.Count);
Console.WriteLine("Does dictionary contain 'Jeff'? {0}", d.Contains("Jeff"));
Console.WriteLine("Jeff's age is {0}", d["Jeff"]);
// Display every entry's key and value.
foreach (DictionaryEntry de in d)
{
Console.WriteLine("{0} is {1} years old.", de.Key, de.Value);
}
// Remove an entry that exists.
d.Remove("Jeff");
// Remove an entry that does not exist, but do not throw an exception.
d.Remove("Max");
// Show the names (keys) of the people in the dictionary.
foreach (String s in d.Keys)
Console.WriteLine(s);
// Show the ages (values) of the people in the dictionary.
foreach (Int32 age in d.Values)
Console.WriteLine(age);
}
}
// This code produces the following output.
//
// Number of elements in dictionary = 3
// Does dictionary contain 'Jeff'? True
// Jeff's age is 40
// Jeff is 40 years old.
// Kristin is 34 years old.
// Aidan is 1 years old.
// Kristin
// Aidan
// 34
// 1
Imports System.Collections
' This class implements a simple dictionary using an array of DictionaryEntry objects (key/value pairs).
Public Class SimpleDictionary
Implements IDictionary
' The array of items
Dim items() As DictionaryEntry
Dim ItemsInUse As Integer = 0
' Construct the SimpleDictionary with the desired number of items.
' The number of items cannot change for the life time of this SimpleDictionary.
Public Sub New(ByVal numItems As Integer)
items = New DictionaryEntry(numItems - 1) {}
End Sub
' IDictionary Members
Public ReadOnly Property IsReadOnly() As Boolean Implements IDictionary.IsReadOnly
Get
Return False
End Get
End Property
Public Function Contains(ByVal key As Object) As Boolean Implements IDictionary.Contains
Dim index As Integer
Return TryGetIndexOfKey(key, index)
End Function
Public ReadOnly Property IsFixedSize() As Boolean Implements IDictionary.IsFixedSize
Get
Return False
End Get
End Property
Public Sub Remove(ByVal key As Object) Implements IDictionary.Remove
If key = Nothing Then
Throw New ArgumentNullException("key")
End If
' Try to find the key in the DictionaryEntry array
Dim index As Integer
If TryGetIndexOfKey(key, index) Then
' If the key is found, slide all the items up.
Array.Copy(items, index + 1, items, index, (ItemsInUse - index) - 1)
ItemsInUse = ItemsInUse - 1
Else
' If the key is not in the dictionary, just return.
End If
End Sub
Public Sub Clear() Implements IDictionary.Clear
ItemsInUse = 0
End Sub
Public Sub Add(ByVal key As Object, ByVal value As Object) Implements IDictionary.Add
' Add the new key/value pair even if this key already exists in the dictionary.
If ItemsInUse = items.Length Then
Throw New InvalidOperationException("The dictionary cannot hold any more items.")
End If
items(ItemsInUse) = New DictionaryEntry(key, value)
ItemsInUse = ItemsInUse + 1
End Sub
Public ReadOnly Property Keys() As ICollection Implements IDictionary.Keys
Get
' Return an array where each item is a key.
' Note: Declaring keyArray() to have a size of ItemsInUse - 1
' ensures that the array is properly sized, in VB.NET
' declaring an array of size N creates an array with
' 0 through N elements, including N, as opposed to N - 1
' which is the default behavior in C# and C++.
Dim keyArray() As Object = New Object(ItemsInUse - 1) {}
Dim n As Integer
For n = 0 To ItemsInUse - 1
keyArray(n) = items(n).Key
Next n
Return keyArray
End Get
End Property
Public ReadOnly Property Values() As ICollection Implements IDictionary.Values
Get
' Return an array where each item is a value.
Dim valueArray() As Object = New Object(ItemsInUse - 1) {}
Dim n As Integer
For n = 0 To ItemsInUse - 1
valueArray(n) = items(n).Value
Next n
Return valueArray
End Get
End Property
Public Property Item(ByVal key As Object) As Object Implements IDictionary.Item
Get
' If this key is in the dictionary, return its value.
Dim index As Integer
If TryGetIndexOfKey(key, index) Then
' The key was found return its value.
Return items(index).Value
Else
' The key was not found return null.
Return Nothing
End If
End Get
Set(ByVal value As Object)
' If this key is in the dictionary, change its value.
Dim index As Integer
If TryGetIndexOfKey(key, index) Then
' The key was found change its value.
items(index).Value = value
Else
' This key is not in the dictionary add this key/value pair.
Add(key, value)
End If
End Set
End Property
Private Function TryGetIndexOfKey(ByVal key As Object, ByRef index As Integer) As Boolean
For index = 0 To ItemsInUse - 1
' If the key is found, return true (the index is also returned).
If items(index).Key.Equals(key) Then
Return True
End If
Next index
' Key not found, return false (index should be ignored by the caller).
Return False
End Function
Private Class SimpleDictionaryEnumerator
Implements IDictionaryEnumerator
' A copy of the SimpleDictionary object's key/value pairs.
Dim items() As DictionaryEntry
Dim index As Integer = -1
Public Sub New(ByVal sd As SimpleDictionary)
' Make a copy of the dictionary entries currently in the SimpleDictionary object.
items = New DictionaryEntry(sd.Count - 1) {}
Array.Copy(sd.items, 0, items, 0, sd.Count)
End Sub
' Return the current item.
Public ReadOnly Property Current() As Object Implements IDictionaryEnumerator.Current
Get
ValidateIndex()
Return items(index)
End Get
End Property
' Return the current dictionary entry.
Public ReadOnly Property Entry() As DictionaryEntry Implements IDictionaryEnumerator.Entry
Get
Return Current
End Get
End Property
' Return the key of the current item.
Public ReadOnly Property Key() As Object Implements IDictionaryEnumerator.Key
Get
ValidateIndex()
Return items(index).Key
End Get
End Property
' Return the value of the current item.
Public ReadOnly Property Value() As Object Implements IDictionaryEnumerator.Value
Get
ValidateIndex()
Return items(index).Value
End Get
End Property
' Advance to the next item.
Public Function MoveNext() As Boolean Implements IDictionaryEnumerator.MoveNext
If index < items.Length - 1 Then
index = index + 1
Return True
End If
Return False
End Function
' Validate the enumeration index and throw an exception if the index is out of range.
Private Sub ValidateIndex()
If index < 0 Or index >= items.Length Then
Throw New InvalidOperationException("Enumerator is before or after the collection.")
End If
End Sub
' Reset the index to restart the enumeration.
Public Sub Reset() Implements IDictionaryEnumerator.Reset
index = -1
End Sub
End Class
Public Function GetEnumerator() As IDictionaryEnumerator Implements IDictionary.GetEnumerator
'Construct and return an enumerator.
Return New SimpleDictionaryEnumerator(Me)
End Function
' ICollection Members
Public ReadOnly Property IsSynchronized() As Boolean Implements IDictionary.IsSynchronized
Get
Return False
End Get
End Property
Public ReadOnly Property SyncRoot() As Object Implements IDictionary.SyncRoot
Get
Throw New NotImplementedException()
End Get
End Property
Public ReadOnly Property Count() As Integer Implements IDictionary.Count
Get
Return ItemsInUse
End Get
End Property
Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements IDictionary.CopyTo
Throw New NotImplementedException()
End Sub
' IEnumerable Members
Public Function GetEnumerator1() As IEnumerator Implements IEnumerable.GetEnumerator
' Construct and return an enumerator.
Return Me.GetEnumerator()
End Function
End Class
Public NotInheritable Class App
Public Shared Sub Main()
' Create a dictionary that contains no more than three entries.
Dim d As IDictionary = New SimpleDictionary(3)
' Add three people and their ages to the dictionary.
d.Add("Jeff", 40)
d.Add("Kristin", 34)
d.Add("Aidan", 1)
Console.WriteLine("Number of elements in dictionary = {0}", d.Count)
Console.WriteLine("Does dictionary contain 'Jeff'? {0}", d.Contains("Jeff"))
Console.WriteLine("Jeff's age is {0}", d("Jeff"))
' Display every entry's key and value.
Dim de As DictionaryEntry
For Each de In d
Console.WriteLine("{0} is {1} years old.", de.Key, de.Value)
Next
' Remove an entry that exists.
d.Remove("Jeff")
' Remove an entry that does not exist, but do not throw an exception.
d.Remove("Max")
' Show the names (keys) of the people in the dictionary.
Dim s As String
For Each s In d.Keys
Console.WriteLine(s)
Next
' Show the ages (values) of the people in the dictionary.
Dim age As Integer
For Each age In d.Values
Console.WriteLine(age)
Next
End Sub
End Class
' This code produces the following output.
'
' Number of elements in dictionary = 3
' Does dictionary contain 'Jeff'? True
' Jeff's age is 40
' Jeff is 40 years old.
' Kristin is 34 years old.
' Aidan is 1 years old.
' Kristin
' Aidan
' 34
' 1
Comentarios
La IDictionary interfaz es la interfaz base para colecciones no genéricas de pares clave-valor. Para obtener la versión genérica de esta interfaz, vea System.Collections.Generic.IDictionary<TKey,TValue>.
Cada elemento es un par clave-valor almacenado en un DictionaryEntry objeto .
Cada par debe tener una clave única. Las implementaciones pueden variar en si permiten que la clave sea null. El valor puede ser NULL y no tiene que ser único. La IDictionary interfaz permite enumerar las claves y los valores contenidos, pero no implica ningún criterio de ordenación determinado.
IDictionary las implementaciones se dividen en tres categorías: de solo lectura, de tamaño fijo y de variable. No se puede modificar un objeto de solo IDictionary lectura. Un objeto de tamaño IDictionary fijo no permite la adición o eliminación de elementos, pero permite la modificación de los elementos existentes. Un objeto de tamaño IDictionary variable permite agregar, quitar y modificar elementos.
La foreach instrucción del lenguaje C# (For Each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección. Dado que cada elemento del IDictionary objeto es un par clave-valor, el tipo de elemento no es el tipo de la clave o el tipo del valor. En su lugar, el tipo de elemento es DictionaryEntry. Por ejemplo:
for each (DictionaryEntry de in myDictionary)
{
//...
}
foreach (DictionaryEntry de in myDictionary)
{
//...
}
For Each de As DictionaryEntry In myDictionary
'...
Next de
La foreach instrucción es un contenedor alrededor del enumerador, que solo permite leer desde pero no escribir en la colección.
Notas a los implementadores
La clase de implementación debe tener un medio para comparar claves.
Propiedades
| Count |
Obtiene el número de elementos incluidos en ICollection. (Heredado de ICollection) |
| IsFixedSize |
Obtiene un valor que indica si el objeto IDictionary tiene un tamaño fijo. |
| IsReadOnly |
Obtiene un valor que indica si el objeto IDictionary es de solo lectura. |
| IsSynchronized |
Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado (es seguro para subprocesos). (Heredado de ICollection) |
| Item[Object] |
Obtiene o establece el elemento con la clave especificada. |
| Keys |
Obtiene un objeto ICollection que contiene las claves del objeto IDictionary. |
| SyncRoot |
Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection. (Heredado de ICollection) |
| Values |
Obtiene un objeto ICollection que contiene los valores del objeto IDictionary. |
Métodos
| Add(Object, Object) |
Agrega un elemento con la clave y el valor proporcionados al objeto IDictionary. |
| Clear() |
Quita todos los elementos del objeto IDictionary. |
| Contains(Object) |
Determina si el objeto IDictionary contiene un elemento con la clave especificada. |
| CopyTo(Array, Int32) |
Copia los elementos de ICollection en Array, empezando por un índice determinado de Array. (Heredado de ICollection) |
| GetEnumerator() |
Devuelve un objeto IDictionaryEnumerator para el objeto IDictionary. |
| Remove(Object) |
Quita el elemento con la clave especificada del objeto IDictionary. |
Métodos de extensión
| Cast<TResult>(IEnumerable) |
Convierte los elementos de IEnumerable en el tipo especificado. |
| OfType<TResult>(IEnumerable) |
Filtra los elementos de IEnumerable en función de un tipo especificado. |
| AsParallel(IEnumerable) |
Habilita la paralelización de una consulta. |
| AsQueryable(IEnumerable) |
Convierte una interfaz IEnumerable en IQueryable. |
Se aplica a
Consulte también
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de