Getupperbound c что это

Array.GetUpperBound

Dimension. Номер измерения, у которого необходимо получить верхнюю границу. Нумерация измерений начинается с единицы.

Описание

Метод GetUpperBound возвращает верхнюю границу измерения, номер которого передается в качестве входного параметра Dimension .

Пример

Upper, i, j: Integer;

For i := -5 To 10 Do

For j := 0 To 14 Do

После выполнения примера в двумерный массив «Ar» записываются данные и в переменной «Upper» будет содержаться верхняя граница 1-го измерения, в данном случае число 10.

Array. Get Upper Bound(Int32) Method

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Gets the index of the last element of the specified dimension in the array.

public: int GetUpperBound(int dimension);

public int GetUpperBound (int dimension);

member this.GetUpperBound : int -> int

Public Function GetUpperBound (dimension As Integer) As Integer

Parameters

A zero-based dimension of the array whose upper bound needs to be determined.

Returns

The index of the last element of the specified dimension in the array, or -1 if the specified dimension is empty.

Exceptions

dimension is less than zero.

dimension is equal to or greater than Rank.

Examples

The following example uses the GetLowerBound and GetUpperBound methods to display the bounds of a one-dimensional and two-dimensional array and to display the values of their array elements.

using namespace System; void main() < // Create a one-dimensional integer array. array^ integers = < 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 >; // Get the upper and lower bound of the array. int upper = integers->GetUpperBound(0); int lower = integers->GetLowerBound(0); Console::WriteLine("Elements from index to :", lower, upper); // Iterate the array. for (int ctr = lower; ctr <= upper; ctr++) Console::Write("", ctr == lower ? " " : "", integers[ctr], ctr < upper ? ", " : Environment::NewLine); Console::WriteLine(); // Create a two-dimensional integer array. array^ integers2d = < , , , , , , , >; // Get the number of dimensions. int rank = integers2d->Rank; Console::WriteLine("Number of dimensions: ", rank); for (int ctr = 0; ctr < rank; ctr++) Console::WriteLine(" Dimension : from to ", ctr, integers2d->GetLowerBound(ctr), integers2d->GetUpperBound(ctr)); // Iterate the 2-dimensional array and display its values. Console::WriteLine(" Values of array elements:"); for (int outer = integers2d->GetLowerBound(0); outer GetUpperBound(0); outer++) for (int inner = integers2d->GetLowerBound(1); inner GetUpperBound(1); inner++) Console::WriteLine(" ,  = ", outer, inner, integers2d->GetValue(outer, inner), ""); > // The example displays the following output: // Elements from index 0 to 9: // 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 // // Number of dimensions: 2 // Dimension 0: from 0 to 7 // Dimension 1: from 0 to 1 // Values of array elements: // = 2 // = 4 // = 3 // = 9 // = 4 // = 16 // = 5 // = 25 // = 6 // = 36 // = 7 // = 49 // = 8 // = 64 // = 9 // = 81 

using System; public class Example < public static void Main() < // Create a one-dimensional integer array. int[] integers = < 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 >; // Get the upper and lower bound of the array. int upper = integers.GetUpperBound(0); int lower = integers.GetLowerBound(0); Console.WriteLine($"Elements from index to :"); // Iterate the array. for (int ctr = lower; ctr " + $"<(ctr < upper ? ", " : Environment.NewLine)>"); Console.WriteLine(); // Create a two-dimensional integer array. int[,] integers2d= < , , , , , , , >; // Get the number of dimensions. int rank = integers2d.Rank; Console.WriteLine($"Number of dimensions: "); for (int ctr = 0; ctr < rank; ctr++) Console.WriteLine($" Dimension : " + $"from to "); // Iterate the 2-dimensional array and display its values. Console.WriteLine(" Values of array elements:"); for (int outer = integers2d.GetLowerBound(0); outer ,  = " + $""); > > // The example displays the following output: // Elements from index 0 to 9: // 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 // // Number of dimensions: 2 // Dimension 0: from 0 to 7 // Dimension 1: from 0 to 1 // Values of array elements: // = 2 // = 4 // = 3 // = 9 // = 4 // = 16 // = 5 // = 25 // = 6 // = 36 // = 7 // = 49 // = 8 // = 64 // = 9 // = 81 

open System // Create a one-dimensional integer array. let integers = [| 2..2..20 |] // Get the upper and lower bound of the array. let upper = integers.GetUpperBound 0 let lower = integers.GetLowerBound 0 printfn $"Elements from index to :" // Iterate the array. for i = lower to upper do if i = lower then printf " " printf $"" if i < upper then ", " else Environment.NewLine |>printf "%s" printfn "" // Create a two-dimensional integer array. let integers2d = array2D [ [ 2; 4 ]; [ 3; 9 ]; [ 4; 16 ]; [ 5; 25 ] [ 6; 36 ]; [ 7; 49 ]; [ 8; 64 ]; [ 9; 81 ] ] // Get the number of dimensions. let rank = integers2d.Rank printfn $"Number of dimensions: " for i = 0 to rank - 1 do printfn $" Dimension : from to " // Iterate the 2-dimensional array and display its values. printfn " Values of array elements:" for outer = integers2d.GetLowerBound 0 to integers2d.GetUpperBound 0 do for inner = integers2d.GetLowerBound 1 to integers2d.GetUpperBound 1 do printfn $" ,  = " // The example displays the following output: // Elements from index 0 to 9: // 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 // // Number of dimensions: 2 // Dimension 0: from 0 to 7 // Dimension 1: from 0 to 1 // Values of array elements: // = 2 // = 4 // = 3 // = 9 // = 4 // = 16 // = 5 // = 25 // = 6 // = 36 // = 7 // = 49 // = 8 // = 64 // = 9 // = 81 

Public Module Example Public Sub Main() ' Create a one-dimensional integer array. Dim integers() As Integer = < 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 >' Get the upper and lower bound of the array. Dim upper As Integer = integers.GetUpperBound(0) Dim lower As Integer = integers.GetLowerBound(0) Console.WriteLine($"Elements from index to :") ' Iterate the array. For ctr As Integer = lower To upper Console.Write("", If(ctr = lower, " ", ""), integers(ctr), If(ctr < upper, ", ", vbCrLf)) Next Console.WriteLine() ' Create a two-dimensional integer array. Dim integers2d(,) As Integer = , , , , , , , > ' Get the number of dimensions. Dim rank As Integer = integers2d.Rank Console.WriteLine($"Number of dimensions: ") For ctr As Integer = 0 To rank - 1 Console.WriteLine($" Dimension : " + $"from to ") Next ' Iterate the 2-dimensional array and display its values. Console.WriteLine(" Values of array elements:") For outer = integers2d.GetLowerBound(0) To integers2d.GetUpperBound(0) For inner = integers2d.GetLowerBound(1) To integers2d.GetUpperBound(1) Console.WriteLine($" ,  = " + $"") Next Next End Sub End Module ' The example displays the following output. ' Elements from index 0 to 9: ' 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 ' ' Number of dimensions: 2 ' Dimension 0: from 0 to 7 ' Dimension 1: from 0 to 1 ' Values of array elements: ' = 2 ' = 4 ' = 3 ' = 9 ' = 4 ' = 16 ' = 5 ' = 25 ' = 6 ' = 36 ' = 7 ' = 49 ' = 8 ' = 64 ' = 9 ' = 81 

Remarks

GetUpperBound(0) returns the last index in the first dimension of the array, and GetUpperBound(Rank — 1) returns the last index of the last dimension of the array.

This method is an O(1) operation.

Getupperbound c что это

В предыдущих частях данной статьи мы начали знакомство с Microsoft .NET Framework — ключевым компонентом Microsoft .NET, представляющим собой платформу для создания, внедрения и выполнения Web-сервисов и приложений. Мы рассказали об основных компонентах Microsoft .NET Framework и кратко описали их назначение. Мы довольно подробно рассмотрели Common Language Runtime (CLR) — среду выполнения .NET-приложений, завершив знакомство с Common Language Runtime описанием Common Type System. После этого мы перешли к библиотеке классов. В этом номере мы продолжим знакомство с библиотекой классов .NET Framework Class Library — рассмотрим массивы (класс System.Array) и коллекции (пространство имен System.Collections).

Массивы

Класс System.Array содержит свойства и методы для работы с массивами. Элемент массива может быть любого типа, так как в .NET все типы — это объекты, базирующиеся на классе System.Object. массив хранит элементы типа System.Object. Для того чтобы найти тип, которым был объявлен массив, мы используем метод GetType. Свойство Length позволяет узнать общее число элементов массива или число элементов, которое он может содержать. Свойство Rank возвращает число измерений массива. Чтобы определить, обладает ли массив фиксированным размером, мы используем свойство IsFixedSize. Массивы с фиксированным размером не позволяют добавлять и удалять элементы — они поддерживают только модификацию существующих элементов. Массивы могут быть только для чтения — чтобы это узнать, нужно использовать свойство IsReadOnly.

• Методы IndexOf(Array, Object) и LastIndexOf(Array, Object) могут быть использованы для нахождения индекса первого и последнего указанного объекта в одномерном массиве.
• Метод Clear(Array, Integer, Integer) обнуляет значения указанного диапазона элементов (для типов со значениями) или присваивает им значение Null (для ссылочных типов).
• Метод Initialize() вызывает конструктор по умолчанию для каждого элемента (для типов со значениями) и, таким образом, инициализирует содержимое массива.
• Методы GetLowerBound(Integer) и GetUpperBound(Integer) используются для нахождения нижней и верхней границ указанного измерения массива. Рекомендуется использовать эти методы при переборе элементов измерения массива, например:

For I = Chars.GetLowerBound(0) to Chars.GetUpperBound(0) ' ' Выполняем операцию над элементами – Chars(I) ' Next 

• Метод GetLength(Integer) возвращает число элементов в указанном измерении массива.
• Методы Reverse(Array) и Reverse(Array, Integer, Integer) используются для изменения порядка следования элементов в одномерном массиве.
• Метод Sort(Array) служит для сортировки элементов одномерного массива. Использовать методы Sort и Reverse можно следующим образом:

'--------------------------------------- ' .NET – пример использования массивов '--------------------------------------- Imports System Imports System.Array Module Module1 Sub Main() Dim Langs() As String = _ ShowArray(Langs, "Original Array") Array.Sort(Langs) ShowArray(Langs, "Sorted Array") Array.Reverse(Langs) ShowArray(Langs, "Reversed Array") End Sub Sub ShowArray(ByVal A As Object, ByVal Title As String) Dim I As Integer Console.WriteLine(Title) For I = A.GetLowerBound(0) To A.GetUpperBound(0) Console.WriteLine(I & ControlChars.Tab & A(I)) Next Console.WriteLine() End Sub End Module 

• Метод GetValue(Integer) используется для того, чтобы найти значение элемента с указанным индексом, а метод SetValue(Object, Integer) — чтобы установить новое значение элемента массива. В следующем примере показано, как использовать эти методы. Отметим, что метод доступа к элементам массива -() реализован на основе методов GetValue/SetValue, как это показано ниже:

'------------------------------------------------------- ' .NET – пример использования методов GetValue/SetValue '------------------------------------------------------- Imports System Imports System.Array Module Module1 Sub Main() Dim I As Integer Dim A() As Integer = With A Console.WriteLine("Original Array:") For I = .GetLowerBound(0) To .GetUpperBound(0) Console.WriteLine("Array(" & I & ")" & " = " & .GetValue(I)) .SetValue(.GetValue(I) * 10, I) Next Console.WriteLine("Modified Array:") For I = .GetLowerBound(0) To .GetUpperBound(0) Console.WriteLine("Array(" & I & ")" & " center">

  
Метод Copy(Array, Array, Integer) используется для копирования части одного массива в другой массив. Метод CopyTo(Array, Integer) копирует все элементы текущего одномерного массива в указанный одномерный массив, начиная с указанного элемента в массиве-приемнике.

Класс Array реализует интерфейсы ICloneable, IList, ICollection и IEnumerable.
 Коллекции
Коллекции в библиотеке классов Microsoft .NET Framework реализованы в пространстве имен System.Collections. Здесь мы можем найти самые различные коллекции объектов — списки, очереди, хэш-таблицы, словари. В этом пространстве имен также определен ряд интерфейсов, задающих базовую функциональность коллекций. На рисунке показаны основные коллекции, реализованные в пространстве имен System.Collections.
 Интерфейсы
Наше знакомство с коллекциями мы начнем с краткого обзора интерфейсов, а затем перейдем к коллекциям. Как мы помним, интерфейсы используются для задания определенной функциональности без ее реализации — классы, которые реализуют интерфейсы, должны реализовать и методы, определенные в интерфейсах.
Интерфейс IEnumerable
Интерфейс IEnumerable описывает энумератор (enumerator), используемый для простой итерации по содержимому коллекции. Этот интерфейс описывает единственный метод — GetEnumerator, который возвращает IEnumerator — энумератор, используемый для итерации. Свойство Current типа Object возвращает текущий элемент коллекции. Метод MoveNext() перемещает нас на следующий элемент коллекции, а метод Reset() устанавливает энумератор в начальную позицию — перед первым элементом коллекции.
Интерфейс ICollection
Этот интерфейс наследует интерфейс IEnumerable и служит базовым интерфейсом для реализации коллекций — все классы в пространстве имен System.Collections реализуют этот интерфейс. Интерфейс ICollection определяет ряд методов, свойственных всем коллекциям, поддержку размера коллекции, энумераторов и синхронизации. Наиболее важным свойством является свойство Count типа Integer, которое возвращает число элементов в данной коллекции. Метод CopyTo(Array, Integer) служит для копирования элементов коллекции в одномерный массив, начиная с указанного индекса.
Интерфейс IDictionary
Данный интерфейс расширяет интерфейс ICollection и описывает доступ к элементам коллекций как к парам «ключ/значение» и позволяет выполнять перечисление пар «ключ/значение». Реализации этого интерфейса могут включать коллекции только для чтения (словарь не может быть модифицирован), коллекции фиксированного размера (не допускается добавление и удаление элементов), а также коллекции переменного размера (поддерживаются операции добавления, удаления и модификации элементов).
Свойства и методы интерфейса IDictonary:

  
Свойства IsFixedSize и IsReadOnly могут быть использованы для того, чтобы узнать, чем является словарь — словарем фиксированного размера или словарем только для чтения.
  
Свойство Item(Object) обеспечивает доступ к элементу с заданным ключом.
  
Свойство Keys типа ICollection возвращает коллекцию ключей в данном словаре.
  
Свойство Values типа ICollection возвращает коллекцию значений в данном словаре.
  
Метод Add(Object, Object) используется для добавления нового элемента (ключ и значение) словаря.
  
Метод Clear() служит для удаления всех элементов словаря.
  
Метод Remove(Object) используется для удаления элемента с указанным ключом.
  
Метод Contains(Object)применяется в случае, если нужно узнать, есть ли в словаре элемент с указанным ключом.
  
Метод GetEnumerator() возвращает энумератор типа IDictionaryEnumerator для данного словаря.

Интерфейс IList
Этот интерфейс наследует от интерфейсов ICollection и IEnumerable и определяет коллекцию значений, которая может быть отсортирована и члены которой могут быть доступны по индексу. Интерфейс IList является базовым интерфейсом для всех классов, реализующих списки. Методы Add(Object) и Remove(Object) используются для добавления и удаления элементов списка. Метод Contains(Object) служит для проверки того, содержит ли список указанное значение. Метод Clear() удаляет все элементы из списка.
 Классы
После того как мы ознакомились с базовой функциональностью коллекций, давайте рассмотрим классы, реализованные в пространстве имен System.Collections.
 Класс ArrayList
Этот класс реализует динамический массив, основанный на интерфейсе IList. В отличие от класса Array, который мы рассмотрели выше, класс ArrayList может увеличиваться и уменьшаться в размерах; кроме того, можно динамически добавлять и удалять его элементы.
Если нам необходим массив фиксированного размера, элементы которого могут быть модифицированы, но не могут быть ни удалены, ни добавлены, мы должны использовать метод FixedSize(ArrayList или IList). Этот метод возвращает список фиксированного размера для данного массива. При создании массивов, доступных только для чтения, мы должны использовать метод ReadOnly(ArrayList или IList) — он возвращает список, доступный только для чтения. Свойство Capacity типа Integer возвращает число элементов, которое может содержать массив. Свойство Count типа Integer возвращает текущее число элементов в массиве, а свойство Item(Integer) типа Object обеспечивает доступ к элементу с указанным индексом.
В следующем примере показано, как использовать класс ArrayList:
'---------------------------------------------- ' .NET – пример использования класса ArrayList '---------------------------------------------- Imports System Imports System.Collections Module Module1 Sub Main() Dim AList As New ArrayList() Dim E As IEnumerator With AList .Add("Microsoft ") .Add(".NET ") .Add("Platform") Console.WriteLine(.Capacity) Console.WriteLine(.Count) E = .GetEnumerator While E.MoveNext() Console.WriteLine(E.Current) End While End With End Sub End Module
Отметим, что в этом примере мы используем интерфейс IEnumerator для перебора элементов массива. Однако тот же самый эффект может быть достигнут с помощью операторов For/Next:
 For I = 0 To .Count - 1 Console.WriteLine(ControlChars.Tab & .Item(I)) Next 
Класс BitArray
Данный класс представляет собой массив битов. Каждый бит может иметь значение типа Boolean и принимать значение true или false. Класс BitArray поддерживает такие логические операции, как Not, Or и Xor.
Методы класса BitArray:

Метод And(BitArray) выполняет логическую операцию И над элементами текущего массива, используя элементы указанного массива, и возвращает результирующий массив типа BitArray.
Метод Not() выполняет операцию инверсии всех элементов текущего массива и возвращает результирующий массив типа BitArray.
Метод Or(BitArray) выполняет логическую операцию ИЛИ над элементами текущего массива, используя элементы указанного массива, и возвращает результирующий массив типа BitArray.
Метод Xor(BitArray) выполняет логическую операцию исключающее ИЛИ над элементами текущего массива, используя элементы указанного массива, и возвращает результирующий массив типа BitArray.
Метод Set(Integer, Boolean) устанавливает бит с указанным индексом в указанное значение.
Метод SetAll(Boolean) устанавливает указанное значение всех битов в данном массиве.

Продемонстрируем использование ряда операций над массивами битов на примере:
'---------------------------------------------- ' .NET – пример использования класса BitArray '---------------------------------------------- Imports System Imports System.Collections Module Module1 Sub Main() Dim Bools() As Boolean = Dim BA As New BitArray(Bools) Dim BA2 As New BitArray(8, False) ShowArray("Original Array:", BA) ShowArray("After NOT:", BA.Not) BA = New BitArray(Bools) ShowArray("After AND:", BA.And(BA2)) BA = New BitArray(Bools) ShowArray("After OR:", BA.Or(BA2)) BA = New BitArray(Bools) ShowArray("After XOR:", BA.Xor(BA2)) End Sub Sub ShowArray(ByVal Header As String, ByVal A As IEnumerable) Dim E As IEnumerator E = A.GetEnumerator Console.WriteLine(ControlChars.NewLine & Header) Console.WriteLine("+-----+-----+-----+-----+" & _ "-----+-----+-----+-----+") While E.MoveNext() Console.Write("|") Console.Write(CType(E.Current, String).PadLeft(5)) End While Console.WriteLine("|") Console.WriteLine("+-----+-----+-----+-----+" & _ "-----+-----+-----+-----+") End Sub End Module 
Класс HashTable
Класс представляет собой хэш-таблицу, реализующую интерфейс IDictionary. Этот класс является коллекцией пар «ключ/значение», которые собраны в хэш-таблицу, где хэш-значение используется в качестве ключа. Класс HashTable может использоваться в тех случаях, когда необходима коллекция пар «ключ/значение».
Ниже показано использование HashTable:
'----------------------------------------------- ' .NET – пример использования класса HashTable '----------------------------------------------- Imports System Imports System.Collections Module Module1 Sub Main() Dim HT As New Hashtable() With HT ' ' Построим хэш-таблицу с телефонными кодами стран ' .Add("Austria", "+43") .Add("France", "+33") .Add("Germany", "+49") .Add("Italy", "+39") .Add("Spain", "+34") .Add("Switzerland", "+41") ShowTable("Original Table", HT) ' ' Удалим Швейцарию, если она есть в таблице ' If .Contains("Switzerland") Then .Remove("Switzerland") End If ShowTable("Modified Table", HT) End With End Sub Sub ShowTable(ByVal Header As String, ByVal T As Hashtable) Dim E As IDictionaryEnumerator E = T.GetEnumerator Console.WriteLine(ControlChars.NewLine & Header) While E.MoveNext() Console.WriteLine(E.Key & " center"> 
  Класс SortedList
 
Как и рассмотренный выше класс HashTable, этот класс реализует интерфейс IDictionary. Но класс SortedList поддерживает коллекцию пар «ключ/значение», используя ключ, а не хэш-значения, в отличие от класса HashTable. Элементы коллекции могут быть доступны как по ключу, так и по индексу.
 
Покажем использование класса SortedList на примере:
 
'------------------------------------------------ ' .NET – пример использования класса SortedList '------------------------------------------------ Imports System Imports System.Collections Module Module1 Sub Main() Dim SL As New SortedList() With SL ' ' Построим отсортированный список кодов стран ' .Add("Austria", "+43") .Add("France", "+33") .Add("Germany", "+49") .Add("Italy", "+39") .Add("Spain", "+34") .Add("Switzerland", "+41") ShowTable("Original Table", SL) ' ' Удалим Швейцарию, если она есть в таблице ' If .Contains("Switzerland") Then .Remove("Switzerland") End If ShowTable2("Modified Table", SL) End With End Sub Sub ShowTable(ByVal Header As String, ByVal L As SortedList) Dim E As IDictionaryEnumerator E = L.GetEnumerator Console.WriteLine(ControlChars.NewLine & Header) While E.MoveNext() Console.WriteLine(E.Key & "=" & E.Value) End While End Sub Sub ShowTable2(ByVal Header As String, ByVal L As SortedList) Dim I As Integer Console.WriteLine(ControlChars.NewLine & Header) For I = 0 To L.Count - 1 Console.WriteLine(L.GetKey(I) & " justify">Следует отметить, что, в отличие от предыдущего примеров, в данном случае мы получаем список элементов, отсортированных по значению ключа, а не по хэш-значению, как в случае с классом HashTable. Также нужно обратить внимание на метод ShowTable2, где показано, как обратиться к элементам класса SortedList по индексу и как найти все ключи (метод GetKey(Integer)) и значения (метод GetByIndex(Integer)). 
 
 
  Класс Stack
 
Этот класс реализует простую очередь объектов типа «последним вошел — первым вышел» (last-in-first-out, LIFO). Класс Stack реализует стек с помощью таких методов, как Push и Pop, для помещения элементов на стек и удаления их с вершины стека. Метод Peek возвращает верхний элемент на стеке без снятия этого элемента со стека. Для копирования элементов стека в новый массив мы можем использовать метод ToArray.
 
Класс Stack также реализует метод GetEnumerator, который можно использовать для получения энумератора для данного стека. Стек реализован как циркулярный буфер. 
 
Использование класса Stack показано в следующем примере:
 
'------------------------------------------- ' .NET – пример использования класса Stack '------------------------------------------- Imports System Imports System.Collections Module Module1 Sub Main() Dim S As New Stack() With S ' ' Поместим на стек 3 элемента ' .Push("Item0") .Push("Item1") .Push("Item2") ShowStack("Original Stack", S) ' ' Снимем верхний элемент ' .Pop() ShowStack("Modified Stack", S) ' ' Поместим один элемент ' .Push("Item3") ' ' Покажем верхний элемент, не удаляя его ' ShowStack("Modified Stack", S) Console.WriteLine("Top item: " & .Peek()) End With End Sub Sub ShowStack(ByVal Header As String, ByVal S As IEnumerable) Dim E As IEnumerator E = S.GetEnumerator Console.WriteLine(ControlChars.NewLine & Header) While E.MoveNext() Console.WriteLine(E.Current) End While End Sub End Module 
Класс Queue
Данный класс реализует коллекцию объектов типа «первым вошел — первым вышел» (first-in-first-out, FIFO). Для добавления и удаления объектов из очереди используются методы Dequeue() и Enqueue(Object). Первый из них удаляет элемент в начале очереди, а второй — добавляет элемент в конец очереди. Для копирования элементов очереди в новый массив можно использовать метод ToArray().
Пример использования класса Queue показан ниже:
'------------------------------------------- ' .NET – пример использования класса Queue '------------------------------------------- Imports System Imports System.Collections Module Module1 Sub Main() Dim Q As New Queue() With Q ' ' Добавим 3 элемента ' .Enqueue("Item0") .Enqueue("Item1") .Enqueue("Item2") ShowQueue("Original Queue", Q) ' ' Удалим первый элемент ' .Dequeue() ShowQueue("Modified Queue", Q) ' ' Добавим один элемент ' .Enqueue("Item3") ShowQueue("Modified Queue", Q) ' ' Покажем первый элемент, не удаляя его ' Console.WriteLine("Top item: " & .Peek()) End With End Sub Sub ShowQueue(ByVal Header As String, ByVal Q As IEnumerable) Dim E As IEnumerator E = Q.GetEnumerator Console.WriteLine(ControlChars.NewLine & Header) While E.MoveNext() Console.WriteLine(E.Current) End While End Sub End Module 
Нужно отметить, что метод Peek() играет такую же роль, что и в классе Stack, — он возвращает верхний элемент, не удаляя его из очереди.
Заключение
Итак, мы ознакомились с массивами (класс System.Array) и коллекциями (пространство имен System.Collections). В следующем номере мы продолжим изучение библиотеки классов .NET Framework Class Library и рассмотрим строки и класс System.String.
Getupperbound c что это
Массив представляет набор однотипных данных. Объявление массива похоже на объявление переменной за тем исключением, что после указания типа ставятся квадратные скобки:
тип_переменной[] название_массива;
Например, определим массив целых чисел:
int[] numbers;
После определения переменной массива мы можем присвоить ей определенное значение:
int[] nums = new int[4];
Здесь вначале мы объявили массив nums, который будет хранить данные типа int . Далее используя операцию new , мы выделили память для 4 элементов массива: new int[4] . Число 4 еще называется длиной массива . При таком определении все элементы получают значение по умолчанию, которое предусмотренно для их типа. Для типа int значение по умолчанию - 0.
Также мы сразу можем указать значения для этих элементов:
int[] nums2 = new int[4] < 1, 2, 3, 5 >; int[] nums3 = new int[] < 1, 2, 3, 5 >; int[] nums4 = new[] < 1, 2, 3, 5 >; int[] nums5 = < 1, 2, 3, 5 >;
Все перечисленные выше способы будут равноценны.
Подобным образом можно определять массивы и других типов, например, массив значений типа string :
string[] people = < "Tom", "Sam", "Bob" >;
Начиная с версии C# 12 для определения массивов можно использовать выражения коллекций , которые предполагают заключение элементов массива в квадратные скобки:
int[] nums1 = [ 1, 2, 3, 5 ]; int[] nums2 = []; // пустой массив
Индексы и получение элементов массива
Для обращения к элементам массива используются индексы . Индекс представляет номер элемента в массиве, при этом нумерация начинается с нуля, поэтому индекс первого элемента будет равен 0, индекс четвертого элемента - 3.
Используя индексы, мы можем получить элементы массива:
int[] numbers = < 1, 2, 3, 5 >; // получение элемента массива Console.WriteLine(numbers[3]); // 5 // получение элемента массива в переменную var n = numbers[1]; // 2 Console.WriteLine(n); // 2
Также мы можем изменить элемент массива по индексу:
int[] numbers = < 1, 2, 3, 5 >; // изменим второй элемент массива numbers[1] = 505; Console.WriteLine(numbers[1]); // 505
И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу. Если мы так попытаемся сделать, то мы получим ошибку во время выполнения:
int[] numbers = < 1, 2, 3, 5 >; Console.WriteLine(numbers[6]); // ! Ошибка - в массиве только 4 элемента
Свойство Length и длина массива
каждый массив имеет свойство Length , которое хранит длину массива. Например, получим длину выше созданного массива numbers:
int[] numbers = < 1, 2, 3, 5 >; Console.WriteLine(numbers.Length); // 4
Для получения длины массива после названия массива через точку указывается свойство Length : numbers.Length .
Получение элементов с конца массива
Благодаря наличию свойства Length , мы можем вычислить индекс последнего элемента массива - это длина массива - 1. Например, если длина массива - 4 (то есть массив имеет 4 элемента), то индекс последнего элемента будет равен 3. И, используя свойство Length , мы можем легко получить элементы с конца массива:
int[] numbers = < 1, 2, 3, 5>; Console.WriteLine(numbers[numbers.Length - 1]); // 5 - первый с конца или последний элемент Console.WriteLine(numbers[numbers.Length - 2]); // 3 - второй с конца или предпоследний элемент Console.WriteLine(numbers[numbers.Length - 3]); // 2 - третий элемент с конца
Однако при подобном подходе выражения типа numbers.Length - 1 , смысл которых состоит в том, чтобы получить какой-то определенный элемент с конца массива, утяжеляют код. И, начиная, с версии C# 8.0 в язык был добавлен специальный оператор ^ , с помощью которого можно задать индекс относительно конца коллекции.
Перепишем предыдущий пример, применяя оператор ^ :
int[] numbers = < 1, 2, 3, 5>; Console.WriteLine(numbers[^1]); // 5 - первый с конца или последний элемент Console.WriteLine(numbers[^2]); // 3 - второй с конца или предпоследний элемент Console.WriteLine(numbers[^3]); // 2 - третий элемент с конца
Перебор массивов
Для перебора массивов мы можем использовать различные типы циклов. Например, цикл foreach :
int[] numbers = < 1, 2, 3, 4, 5 >; foreach (int i in numbers)
Здесь в качестве контейнера выступает массив данных типа int . Поэтому мы объявляем переменную с типом int
Подобные действия мы можем сделать и с помощью цикл for:
int[] numbers = < 1, 2, 3, 4, 5 >; for (int i = 0; i
В то же время цикл for более гибкий по сравнению с foreach . Если foreach последовательно извлекает элементы контейнера и только для чтения, то в цикле for мы можем перескакивать на несколько элементов вперед в зависимости от приращения счетчика, а также можем изменять элементы:
int[] numbers = < 1, 2, 3, 4, 5 >; for (int i = 0; i
Также можно использовать и другие виды циклов, например, while :
int[] numbers = < 1, 2, 3, 4, 5 >; int i = 0; while(i
Многомерные массивы
Массивы характеризуются таким понятием как ранг или количество измерений. Выше мы рассматривали массивы, которые имеют одно измерение (то есть их ранг равен 1) - такие массивы можно представлять в виде ряда (строки или столбца) элемента. Но массивы также бывают многомерными. У таких массивов количество измерений (то есть ранг) больше 1.
Массивы которые имеют два измерения (ранг равен 2) называют двухмерными. Например, создадим одномерный и двухмерный массивы, которые имеют одинаковые элементы:
int[] nums1 = new int[] < 0, 1, 2, 3, 4, 5 >; int[,] nums2 = < < 0, 1, 2 >, < 3, 4, 5 >>;
Визуально оба массива можно представить следующим образом:


Похожие публикации:

Desktop graphics performance как увеличить на windows 10
Package json что это
Как зайти в почту outlook через браузер
Как транспонировать таблицу в excel