IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] Property

정의

지정한 인덱스에 있는 요소를 가져오거나 설정합니다.Gets or sets the element at the specified index.

public:
 property System::Object ^ default[int] { System::Object ^ get(int index); void set(int index, System::Object ^ value); };
public object this[int index] { get; set; }
member this.Item(int) : obj with get, set
Default Public Property Item(index As Integer) As Object

매개 변수

index
Int32 Int32 Int32 Int32

가져오거나 설정할 요소의 인덱스(0부터 시작)입니다.The zero-based index of the element to get or set.

속성 값

지정한 인덱스의 요소입니다.The element at the specified index.

예외

indexIList의 유효한 인덱스가 아닌 경우index is not a valid index in the IList.

속성이 설정되어 있으며 IList가 읽기 전용인 경우The property is set and the IList is read-only.

예제

다음 예제에서는 구현의 IList 만들기 단순 목록, 고정 크기 목록에 대 한 인터페이스입니다.The following example demonstrates the implementation of the IList interface to create a simple list, fixed-size list. 이 코드는에 대 한 보다 큰 예제의 일부는 IList 인터페이스입니다.This code is part of a larger example for the IList interface.

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();
    }
}
Public Class SimpleList
    Implements IList

    Private _contents(8) As Object
    Private _count As Integer

    Public Sub New()

        _count = 0
    End Sub

    ' IList Members
    Public Function Add(ByVal value As Object) As Integer Implements IList.Add

        If (_count < _contents.Length - 1) Then

            _contents(_count) = value
            _count = _count + 1

            Return (_count - 1)

        Else

            Return -1
        End If
    End Function

    Public Sub Clear() Implements IList.Clear
        _count = 0
    End Sub

    Public Function Contains(ByVal value As Object) As Boolean Implements IList.Contains

        Dim inList As Boolean = False

        Dim i As Integer
        For i = 0 To Count

            If _contents(i) = value Then

                inList = True
                Exit For

            End If

        Next i

        Return inList
    End Function

    Public Function IndexOf(ByVal value As Object) As Integer Implements IList.IndexOf

        Dim itemIndex As Integer = -1

        Dim i As Integer
        For i = 0 To Count

            If _contents(i) = value Then

                itemIndex = i
                Exit For

            End If

        Next i

        Return itemIndex
    End Function

    Public Sub Insert(ByVal index As Integer, ByVal value As Object) Implements IList.Insert

        If (_count + 1) <= (_contents.Length - 1) And (index < Count) And (index >= 0) Then

            _count = _count + 1

            Dim i As Integer
            For i = Count - 1 To index

                _contents(i) = _contents(i - 1)
            Next i

            _contents(index) = value
        End If
    End Sub

    Public ReadOnly Property IsFixedSize() As Boolean Implements IList.IsFixedSize
        Get
            Return True
        End Get
    End Property

    Public ReadOnly Property IsReadOnly() As Boolean Implements IList.IsReadOnly

        Get
            Return False
        End Get
    End Property

    Public Sub Remove(ByVal value As Object) Implements IList.Remove
        RemoveAt(IndexOf(value))
    End Sub

    Public Sub RemoveAt(ByVal index As Integer) Implements IList.RemoveAt

        If index >= 0 And index < Count Then

            Dim i As Integer
            For i = index To Count - 1

                _contents(i) = _contents(i + 1)
            Next i
            _count = _count - 1

        End If
    End Sub

    Public Property Item(ByVal index As Integer) As Object Implements IList.Item

        Get
            Return _contents(index)
        End Get

        Set(ByVal value As Object)
            _contents(index) = value
        End Set
    End Property

    ' ICollection Members

    Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements ICollection.CopyTo
        Dim j As Integer = index
        Dim i As Integer
        For i = 0 To Count
            array.SetValue(_contents(i), j)
            j = j + 1
        Next i
    End Sub

    Public ReadOnly Property Count() As Integer Implements ICollection.Count
        Get
            Return _count
        End Get
    End Property

    Public ReadOnly Property IsSynchronized() As Boolean Implements ICollection.IsSynchronized
        Get
            Return False
        End Get
    End Property

    ' Return the current instance since the underlying store is not
    ' publicly available.
    Public ReadOnly Property SyncRoot() As Object Implements ICollection.SyncRoot
        Get
            Return Me
        End Get
    End Property

    ' IEnumerable Members
    Public Function GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator

        ' Refer to the IEnumerator documentation for an example of
        ' implementing an enumerator.
        Throw New Exception("The method or operation is not implemented.")
    End Function

    Public Sub PrintContents()

        Console.WriteLine("List has a capacity of {0} and currently has {1} elements.", _contents.Length - 1, _count)
        Console.Write("List contents:")

        Dim i As Integer
        For i = 0 To Count

            Console.Write(" {0}", _contents(i))
        Next i

        Console.WriteLine()

    End Sub
End Class

설명

이 속성은 myCollection[index] 구문을 사용하여 컬렉션의 특정 요소에 액세스하는 기능을 제공합니다.This property provides the ability to access a specific element in the collection by using the following syntax: myCollection[index].

C# 언어를 사용 하는 구현 하는 대신 인덱서를 정의 하는 키워드는 Item[Int32] 속성입니다.The C# language uses the this keyword to define the indexers instead of implementing the Item[Int32] property. Visual Basic에서는 동일한 인덱싱 기능을 제공하는 Item[Int32]을 기본 속성으로 구현합니다.Visual Basic implements Item[Int32] as a default property, which provides the same indexing functionality.

적용 대상