Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

IList (Interfaz)

Representa una colección de objetos no genéricos a los que se puede obtener acceso por índice.

Espacio de nombres:  System.Collections
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IList : ICollection, IEnumerable

El tipo IList expone los siguientes miembros.

  NombreDescripción
Propiedad públicaCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifCountObtiene el número de elementos incluidos en ICollection. (Se hereda de ICollection).
Propiedad públicaCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifIsFixedSizeObtiene un valor que indica si IList tiene un tamaño fijo.
Propiedad públicaCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifIsReadOnlyObtiene un valor que indica si IList es de sólo lectura.
Propiedad públicaCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifIsSynchronizedObtiene un valor que indica si el acceso a ICollection está sincronizado (es seguro para la ejecución de subprocesos). (Se hereda de ICollection).
Propiedad públicaCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifItemObtiene o establece el elemento que se encuentra en el índice especificado.
Propiedad públicaCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifSyncRootObtiene un objeto que se puede utilizar para sincronizar el acceso a ICollection. (Se hereda de ICollection).
Arriba

  NombreDescripción
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifAddAgrega un elemento a la interfaz IList.
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifClearQuita todos los elementos de IList.
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifContainsDetermina si la interfaz IList contiene un valor específico.
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifCopyToCopia los elementos de la interfaz ICollection a un objeto Array, a partir de un índice determinado de la clase Array. (Se hereda de ICollection).
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifGetEnumeratorDevuelve un enumerador que recorre en iteración una colección. (Se hereda de IEnumerable).
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifIndexOfDetermina el índice de un elemento específico en la interfaz IList.
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifInsertInserta un elemento en la interfaz IList, en el índice especificado.
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifRemoveQuita la primera aparición de un objeto específico de la interfaz IList.
Método públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifRemoveAtQuita el elemento de IList en el índice especificado.
Arriba

  NombreDescripción
Método de extensión públicoAsParallelHabilita la paralelización de una consulta. (Definido por ParallelEnumerable).
Método de extensión público30ft6hw7.PortableClassLibrary(es-es,VS.100).gifAsQueryableConvierte una interfaz IEnumerable en IQueryable. (Definido por Queryable).
Método de extensión públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifCast<TResult>Convierte los elementos de IEnumerable en el tipo especificado. (Definido por Enumerable).
Método de extensión públicoCompatible con XNA Framework30ft6hw7.PortableClassLibrary(es-es,VS.100).gifOfType<TResult>Filtra los elementos de IEnumerable en función de un tipo especificado. (Definido por Enumerable).
Arriba

IList es una descendiente de la interfaz ICollection y es la interfaz base de todas las listas no genéricas. Las implementaciones de IList se dividen en tres categorías: de solo lectura, de tamaño fijo y de tamaño variable. Una interfaz IList de sólo lectura no se puede modificar. Una interfaz IList de tamaño fijo no permite agregar o eliminar elementos, pero sí modificar elementos existentes. Una interfaz IList de tamaño variable permite agregar, quitar y modificar elementos.

Para obtener la versión genérica de esta interfaz, vea System.Collections.Generic.IList<T>.

En el ejemplo siguiente, se muestra la implementación de la interfaz IList para crear una lista simple, lista de tamaño fijo.


using System;
using System.Collections;

class Program
{
    static void Main()
    {
        SimpleList test = new SimpleList();

        // Populate the List
        Console.WriteLine("Populate the List");
        test.Add("one");
        test.Add("two");
        test.Add("three");
        test.Add("four");
        test.Add("five");
        test.Add("six");
        test.Add("seven");
        test.Add("eight");
        test.PrintContents();
        Console.WriteLine();

        // Remove elements from the list
        Console.WriteLine("Remove elements from the list");
        test.Remove("six");
        test.Remove("eight");
        test.PrintContents();
        Console.WriteLine();

        // Add an element to the end of the list
        Console.WriteLine("Add an element to the end of the list");
        test.Add("nine");
        test.PrintContents();
        Console.WriteLine();

        // Insert an element into the middle of the list
        Console.WriteLine("Insert an element into the middle of the list");
        test.Insert(4, "number");
        test.PrintContents();
        Console.WriteLine();

        // Check for specific elements in the list
        Console.WriteLine("Check for specific elements in the list");
        Console.WriteLine("List contains \"three\": {0}", test.Contains("three"));
        Console.WriteLine("List contains \"ten\": {0}", test.Contains("ten"));
    }
} // class Program

class SimpleList : IList
{
    private object[] _contents = new object[8];
    private int _count;

    public SimpleList()
    {
        _count = 0;
    }

    // IList Members
    public int Add(object value)
    {
        if (_count < _contents.Length)
        {
            _contents[_count] = value;
            _count++;

            return (_count - 1);
        }
        else
        {
            return -1;
        }
    }

    public void Clear()
    {
        _count = 0;
    }

    public bool Contains(object value)
    {
        bool inList = false;
        for (int i = 0; i < Count; i++)
        {
            if (_contents[i] == value)
            {
                inList = true;
                break;
            }
        }
        return inList;
    }

    public int IndexOf(object value)
    {
        int itemIndex = -1;
        for (int i = 0; i < Count; i++)
        {
            if (_contents[i] == value)
            {
                itemIndex = i;
                break;
            }
        }
        return itemIndex;
    }

    public void Insert(int index, object value)
    {
        if ((_count + 1 <= _contents.Length) && (index < Count) && (index >= 0))
        {
            _count++;

            for (int i = Count - 1; i > index; i--)
            {
                _contents[i] = _contents[i - 1];
            }
            _contents[index] = value;
        }
    }

    public bool IsFixedSize
    {
        get
        {
            return true;
        }
    }

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public void Remove(object value)
    {
        RemoveAt(IndexOf(value));
    }

    public void RemoveAt(int index)
    {
        if ((index >= 0) && (index < Count))
        {
            for (int i = index; i < Count - 1; i++)
            {
                _contents[i] = _contents[i + 1];
            }
            _count--;
        }
    }

    public object this[int index]
    {
        get
        {
            return _contents[index];
        }
        set
        {
            _contents[index] = value;
        }
    }

    // ICollection Members

    public void CopyTo(Array array, int index)
    {
        int j = index;
        for (int i = 0; i < Count; i++)
        {
            array.SetValue(_contents[i], j);
            j++;
        }
    }

    public int Count
    {
        get
        {
            return _count;
        }
    }

    public bool IsSynchronized
    {
        get
        {
            return false;
        }
    }

    // Return the current instance since the underlying store is not
    // publicly available.
    public object SyncRoot
    {
        get
        {
            return this;
        }
    }

    // IEnumerable Members

    public IEnumerator GetEnumerator()
    {
        // Refer to the IEnumerator documentation for an example of
        // implementing an enumerator.
        throw new Exception("The method or operation is not implemented.");
    }

    public void PrintContents()
    {
        Console.WriteLine("List has a capacity of {0} and currently has {1} elements.", _contents.Length, _count);
        Console.Write("List contents:");
        for (int i = 0; i < Count; i++)
        {
            Console.Write(" {0}", _contents[i]);
        }
        Console.WriteLine();
    }
}

// This code produces output similar to the following:
// Populate the List:
// List has a capacity of 8 and currently has 8 elements.
// List contents: one two three four five six seven eight
//
// Remove elements from the list:
// List has a capacity of 8 and currently has 6 elements.
// List contents: one two three four five seven
//
// Add an element to the end of the list:
// List has a capacity of 8 and currently has 7 elements.
// List contents: one two three four five seven nine
//
// Insert an element into the middle of the list:
// List has a capacity of 8 and currently has 8 elements.
// List contents: one two three four number five seven nine
//
// Check for specific elements in the list:
// List contains "three": True
// List contains "ten": False


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Compatible con:

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft