Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Введение

Коллекция это совокупность объектов, с которыми можно совершать различные действия. Если требуется снизить трудоемкость разработки структур данных именно коллекции приходят на помощь.

Элементы объединяют в коллекции по какому-либо признаку и потом используют их. Это нужно для того, чтобы не приходилось писать код для каждого элемента отдельно. Ведь можно написать один блок, который будет управлять всеми элементами сразу.

Элементы в коллекциях можно изменять, их можно удалять, а также добавлять новые. Размерность коллекций при этом изменяется автоматически, поэтому ее не нужно переопределять, что значительно облегчает работу. В этой работе я рассмотрю основные виды и типы коллекций, а также интерфейсы, используемые коллекциями. Приведу примеры использования коллекций и правила их реализации.



1. Коллекции в .Net

В .NET коллекция представляет собой объект. Даже самый примитивный массив является объектом. Массив можно создать, у него есть методы и свойства, и как все другие классы, он является ссылочным типом.

Ниже представлен пример использования простой коллекции. Сначала создается список строк, а затем просматриваются строки с помощью оператора foreach.

Рассмотрим виды и типы коллекций.

1.1 Виды коллекций

Коллекция - некоторая конечная совокупность объектов, с которой можно совершать те или иные действия. Так, обычно по отношению к коллекции можно осуществлять перебор ее элементов. Физические реализации коллекций могут быть совершенно разными. Во Framework Class Library (FCL) коллекции в основном размещаются в пространстве имен System.Collections. Их список приведен в таблице 1. [1]

интерфейс оператор коллекция итератор



Таблица 1.1 - Коллекции, доступные в .NET Framework

Тип коллекции	Назначение
Встроенные массивы	Обычные массивы, поддерживаемые CLR (Common Language Runtim) напрямую. В совестимых с CLR языках они являются полноценными объектами.
ArrayList	Является реализацией абстракции списка на базе массива, Позволяет динамически изменять размер, добавлять и удалять элементы. По сути, динамический массив, позволяющий хранить ссылки на объекты.
Hashtable	Реализует абстракцию «словарь» (Dictionary, коллекцию пар «ключ-значение») на основе алгоритма хэш-таблицы.
SortedList	Реализация абстракции словаря и списка на базе сортированного массива.
Stack	Реализует абстракцию «стек» - коллекцию, позволяющую осуществлять доступ к элементам по принципу FILO (First In - Last Out, первым пришел - последним ушел). В качестве хранилища используется массив.
Queue	Реализует абстракцию «очередь» - коллекцию, позволяющую осуществлять доступ к элементам по принципу FIFO (First In - First Out, первым пришел - первым ушел). В качестве хранилища используется массив.
BitArray	Позволяет создавать битовые массивы и управлять ими.

В .NET Framework массив не относится к числу коллекций, хотя по своему предназначению массивы тоже являются коллекциями. Массивы отделены от коллекций потому, что они поддерживаются средой исполнения непосредственно. [1]

Типы коллекций.

Главное преимущество коллекций заключается в том, что они стандартизируют обработку групп объектов в программе. Все коллекции разработаны на основе набора четко определенных интерфейсов. Некоторые встроенные реализации таких интерфейсов, в том числе ArrayList, Hashtable, Stack и Queue, могут применяться в исходном виде и без каких-либо изменений. Имеется также возможность реализовать собственную коллекцию, хотя потребность в этом возникает крайне редко. [2]

В среде .NET Framework поддерживаются пять типов коллекций: необобщенные, специальные, с поразрядной организацией, обобщенные и параллельные. [2]

Необобщенные коллекции.

Необобщенные или простые коллекции определены в пространстве имен System.Collections. Их особенность состоит в том, что их функциональность, функциональные возможности описываются в интерфейсах, которые также находятся в этом пространстве имен. [3]

Специальные коллекции.

Оперируют данными конкретного типа или же делают это каким-то особым образом. Например, имеются специальные коллекции для символьных строк, а также специальные коллекции, в которых используется однонаправленный список. Специальные коллекции объявляются в пространстве имен System.Collections.Specialized. [2]

Поразрядная коллекция.

В прикладном интерфейсе Collections API определена одна коллекция с поразрядной организацией -- это BitArray. Коллекция типа BitArray поддерживает поразрядные операции, т.е. операции над отдельными двоичными разрядами, например. И, ИЛИ, исключающее ИЛИ, а, следовательно, она существенно отличается своими возможностями от остальных типов коллекций. Коллекция типа BitArray объявляется в пространстве имен System.Collections. [2]

Обобщенные коллекции.

Классы обобщенных коллекций находятся в пространстве имен System.Collections.Generic. Функционал коллекций также по большей части описывается в обобщенных интерфейсах. [3]

Обеспечивают обобщенную реализацию нескольких стандартных структур данных, включая связные списки, стеки, очереди и словари. Такие коллекции являются типизированными в силу их обобщенного характера. Это означает, что в обобщенной коллекции могут храниться только такие элементы данных, которые совместимы по типу с данной коллекцией. Благодаря этому исключается случайное несовпадение типов. [2]

Параллельные коллекции.

Поддерживают многопоточный доступ к коллекции. Это обобщенные коллекции, определенные в пространстве имен System.Collections.Concurrent.

В листинге 1 (см. Приложение А) представлен пример использования коллекций, работы с элементами, добавление и удаление некоторых элементов. Приведенный пример взят из источника [3]. Результат работы этой программы представлен на рисунке А.1 в приложении А.

В этой программе используются две коллекции: необобщенная - ArrayList и обобщенная - List.

ArrayList objectList = new ArrayList() { 1, 2, "string", 'c', 2.0f };

List<string> countries = new List<string>() { "Россия", "США", "Великобритания", "Китай" };

Большинство коллекций поддерживают добавление элементов. В данном примере добавление производится методом Add, но для других коллекций название метода может отличаться. [3]

objectList.Add("string2");

Также большинство коллекций реализуют удаление, в этом примере удаление производится с помощью метода RemoveAt. [3]

objectList.RemoveAt(0); // удаление первого элемента

С помощью свойства Count у коллекций можно посмотреть количество элементов. [3]

1.2 Интерфейсы, используемые коллекциями

Классы коллекций в FCL в большинстве своем реализуют некоторый набор интерфейсов, представленный в таблице 1.2. [1]

Одной из отличительных особенностей FCL является то, что названия интерфейсов отражают описываемые ими абстракции. Точно так же названия классов отражают реализацию абстракций, определенных интерфейсами.

Например, абстракция «словарь» (по-другому ее еще называют map) описывается интерфейсом IDictionary и реализуется классами Hashtable и SortedList. Название класса Hashtable отражает, что в качестве основного алгоритма реализации в нем используется алгоритм хэш-таблицы, а в SortedList - сортированного массива. [1]

Таблица 1.2

Стандартные интерфейсы, реализуемые коллекциями в .NET

Название	Описание
IEnumerable	Предоставляет итератор, который поддерживает простой перебор элементов коллекции.
ICollection	Определяет методы, позволяющие определить количество элементов в коллекции, а также методы синхронизации для коллекций.
IList	Представляет интерфейс коллекции объектов, каждый из которых может быть получен по индексу. Также определяет методы модификации коллекции.
IDictionary	Представляет интерфейс коллекции пар «ключ-значение».
ICloneable	Определяет метод, позволяющий создать копию объекта.

Кроме непосредственно реализуемых коллекциями интерфейсов, перечисленных в таблице 2, имеется также набор дополнительных интерфейсов, используемых коллекциями или возвращаемых ими. Их список приведен в таблице 1.3. [1]

Таблица 1.3 Дополнительные интерфейсы, используемые коллекциями

Название	Описание
IComparer	Определяет метод, осуществляющий сравнение двух объектов.
IEnumerator	Определяет методы, позволяющие осуществить простой перебор элементов коллекции. Возвращается методом GetEnumerator интерфейса IEnumerable.
IComparable	Используется при поиске и сортировке объектов. Может быть реализован типами, для которых определены операции сравнения.
IDictionaryEnumerator	Позволяет перебрать элементы словаря.
IHashCodeProvider	Определяет метод, позволяющий вычислить хэш-код для объекта.

Интерфейс IEnumerable.

Все коллекции в FCL реализуют интерфейс IEnumerable. Этот интерфейс позволяет перебрать элементы коллекции в цикле. Интерфейс описывает всего один метод:

IEnumerator GetEnumerator();

Этот метод возвращает ссылку на интерфейс IEnumerator (перечислитель), при помощи которого можно осуществить перебор всех элементов коллекции. Для одного экземпляра коллекции можно одновременно запросить несколько перечислителей. Поэтому такого понятия, как «текущий элемент», нет. [1]

Интерфейс IEnumerator.

Этот интерфейс предназначен для перебора значений коллекции. В состав этого интерфейса входят: MoveNext(), Reset() и свойство Current.

Reset() позволяет сбросить состояние перечислителя в начальное состояние. В этом состоянии перечислитель находится сразу после его создания, при этом переход к следующему элементу приведет к тому, что текущим элементом станет первый элемент коллекции. [1]

Метод MoveNext() как раз и осуществляет переход к следующему элементу коллекции. Таким образом, MoveNext() нужно вызывать непосредственно перед обращением к первому или следующему элементу.

Свойство Current предоставляет доступ к текущему элементу. [1]

Ниже представлен пример использования этого интерфейса.

IEnumerator enumerator = ((IEnumerable)someCollection).GetEnumerator();

while (enumerator.MoveNext())

{

ElemType elem = (ElemType)enumerator.Current();

// ... какие-то действия с элементом коллекции.

}

Любое изменение содержимого коллекции или количества ее элементов приводит к тому, что перечислитель становится недействительным. Так что если коллекция изменилась, попытка обратиться к методам или свойствам интерфейса IEnumerator должна вызвать исключение. Но эти интерфейсы - это всего лишь декларация намерений. Реализация интерфейсов целиком и полностью лежит на разработчиках конкретных классов. Так, все коллекции, входящие в пространство имен System.Collections, поддерживают это соглашение. Но IEnumerator реализуется также и встроенными массивами, которые этому правилу не удовлетворяют. [2]

Использовать связку IEnumerable/IEnumerator удобнее всего с помощью оператора foreach. Так, приведенный выше пример можно переписать следующим образом:

foreach (ElemType elem in someCollection)

{

// ... какие-то действия с элементом коллекции.

}

Интерфейс ICollection

Интерфейс ICollection наследуется от IEnumerable:

public interface ICollection: Ienumerable

Он определяет свойство, при помощи которого можно получить число элементов коллекции:

int Count {get;}

Помимо этого свойства, интерфейс определяет метод:

void CopyTo(Array array, int index);

Задачей этого метода является копирование элементов коллекции в массив. Копирование производится, начиная с элемента, индекс которого указан как второй аргумент метода. Ссылка на массив передается в качестве первого параметра. Размер массива должен быть достаточным для размещения копируемых элементов. [1]

Свойство SyncRoot возвращает ссылку на объект, который должен использоваться для синхронизации доступа к объекту. Необходимость в таком объекте возникает при создании сложных коллекций. Ниже представлен пример использования свойства SyncRoot:

lock (myCollection.SyncRoot)

{

myCollection[0] = myCollection[1] + myCollection[2];

}

Для обеспечения корректной работы коллекции в многопоточной среде часто бывает удобно не делать синхронизацию вручную, а воспользоваться оберткой вокруг коллекции, обеспечивающей синхронизацию доступа к коллекции. Свойство IsSynchronized позволяет определить, нужна ли такая обертка имеющейся ссылке на коллекцию, или она уже и так потокобезопасна. [2]

Интерфейс IList.

Описанные выше методы и свойства позволяют просто «гонять» итераторы от одного элемента коллекции к другому, и узнавать количество элементов коллекции. Если не будут реализованы собственные методы доступа к данным коллекции, коллекцией пользоваться не удастся. Так вот, интерфейс IList предоставляет полиморфный механизм манипуляции данными коллекции:

public interface IList : ICollection, Ienumerable

В интерфейсе IList впервые встречается способ получить или присвоить какое-то значение элементу коллекции. Это делается с помощью индексатора:

object this[int index] { get; set; }

Аргументом в данном случае является индекс элемента. [1]

Чтобы добавить элемент в коллекцию, можно воспользоваться методом:

int Add(object value);

Метод должен вернуть индекс добавленного элемента. [1]

Если же необходимо вставить элемент в конкретное место коллекции, то можно использовать метод:

void Insert(int index, object value);

В качестве первого аргумента методу передается позиция, в которую должен быть помещен новый элемент. Все элементы коллекции, идущие за этой позицией, будут сдвинуты назад на одну позицию. [2]

Чтобы удалить элемент, имеющий конкретное значение, можно использовать метод:

void Remove(object value);

Для удаления элемента по его индексу нужно воспользоваться методом:

void RemoveAt(int index);

Очистить коллекцию можно при помощи метода:

void Clear();

Если нужно просто узнать, присутствует ли в коллекции элемент с заданным значением, можно воспользоваться методом:

bool Contains(object value);

Если же возникает задача узнать индекс объекта в коллекции, можно использовать метод IndexOf():

int IndexOf(object value);

Свойство IsReadOnly позволяет узнать, предназначена ли коллекция только для чтения, то есть можно ли изменять число элементов коллекции и значения элементов. Свойство IsFixedSize помогает узнать, можно ли изменять число элементов коллекции после ее создания. [1]

IDictionary

Этот интерфейс описывает методы, которые должны быть у реализаций абстракции «словарь» (ассоциативной коллекции - хранящей пары ключ/значение). Ниже в таблице 1.4 представлены свойства интерфейса IDictionary, в таблице 1.5 - методы интерфейса IDictionary. [1]

Таблица 1.4 - Свойства интерфейса IDictionary

Свойство	Описание
IsFixedSize	Позволяет узнать, имеет ли данная реализация IDictionary фиксированный размер.
IsReadOnly	Позволяет узнать, можно ли модифицировать коллекцию.
Keys	Возвращает ссылку на коллекцию (ICollection), содержащую список ключей словаря.
Values	Возвращает ссылку на коллекцию (ICollection), содержащую список значений словаря.

Таблица 1.5 - Методы интерфейса IDictionary

Метод	Описание
Add	Позволяет добавить пару ключ/значение к словарю.
Clear	Очищает содержимое коллекции.
Contains	Позволяет определить, содержит ли коллекция элемент с заданным ключом.
GetEnumerator	Возвращает ссылку на перечислитель словаря - интерфейс IDictionaryEnumerator.
Remove	Позволяет удалить элемент с заданным ключом.

Хотя интерфейс IDictionary объявляется производным от Enumerable и переход к следующему элементу может осуществляться методом MoveNext, обычно такая возможность не используется -- коллекции, реализующие IDictionary, ориентируются в первую очередь на обращение по ключу, а не на последовательный перебор элементов. По этой причине интерфейс IDictionary зависит от интерфейса IDictionaryEnumerator, который расширяет Enumerator и дополняет его тремя новыми свойствами:

Entry: возвращает пару «ключ/значение» для текущего элемента словаря.

Key: возвращает текущий ключ.

Value: возвращает ссылку на текущее значение.

1 

2. Необобщенные коллекции

Необобщенные коллекции вошли в состав среды .NET Framework еще в версии 1.0. Они определяются в пространстве имен System.Collections.

Необобщенные коллекции представляют собой структуры данных общего назначения, оперирующие ссылками на объекты. Таким образом, они позволяют манипулировать объектом любого типа, хотя и не типизированным способом. В этом состоит их преимущество и в то же время недостаток. Благодаря тому, что необобщенные коллекции оперируют ссылками на объекты, в них можно хранить разнотипные данные. Это удобно в тех случаях, когда требуется манипулировать совокупностью разнотипных объектов или же когда типы хранящихся в коллекции объектов заранее неизвестны. Но если коллекция предназначается для хранения объекта конкретного типа, то необобщенные коллекции не обеспечивают типовую безопасность, которую можно обнаружить в обобщенных коллекциях. [3]

Необобщенные коллекции определены в ряде интерфейсов и классов, реализующих эти интерфейсы. [2]

Интерфейсы необобщенных коллекций

В пространстве имен System.Collections определен целый ряд интерфейсов необобщенных коллекций. Начинать рассмотрение необобщенных коллекций следует именно с интерфейсов, поскольку они определяют функциональные возможности, которые являются общими для всех классов необобщенных коллекций. Интерфейсы, служащие опорой для необобщенных коллекций, сведены в таблице 2. [2]

Таблица 2 - Интерфейсы, используемые в необобщенных коллекциях

Интерфейс	Описание
ICollection	Определяет элементы, которые должны иметь все необобщенные коллекции
IComparer	Определяет метод Compare() для сравнения объектов, хранящихся в коллекции
IDictionary	Определяет коллекцию, состоящую из пар "ключ-значение"
IDictionaryEnumerator	Определяет перечислитель для коллекции, реализующей интерфейс IDictionary
IEnumerable	Определяет метод GetEnumerator (), предоставляющий перечислитель для любого класса коллекции
IEnumerator	Предоставляет методы, позволяющие получать содержимое коллекции по очереди
IEqualityComparer	Сравнивает два объекта на предмет равенства
IHashCodeProvider	Считается устаревшим. Вместо него следует использовать интерфейс IEqualityComparer
IList	Определяет коллекцию, доступ к которой можно получить с помощью индексатора
IStructuraIComparable	Определяет метод CompareTo(), применяемый для структурного сравнения
IStructuralEquatable	Определяет метод Equals(), применяемый для выяснения структурного, а не ссылочного равенства. Кроме того, определяет метод GetHashCode()

Структура DictionaryEntry

В пространстве имен System.Collections определена структура DictionaryEntry. Необобщенные коллекции пар "ключ-значение" сохраняют эти пары в объекте типа DictionaryEntry. В данной структуре определяются два следующих свойства:

public object Key { get; set; }

public object Value { get; set; }

Эти свойства служат для доступа к ключу или значению, связанному с элементом коллекции. Объект типа DictionaryEntry может быть сконструирован с помощью конструктора:

public DictionaryEntry(object key, object value)

где key обозначает ключ, a value -- значение. [2]

Классы необобщенных коллекций

Ниже приведены классы необобщенных коллекций: [2]

ArrayList

Определяет динамический массив, т.е. такой массив, который может при необходимости увеличивать свой размер.

Hashtable

Определяет хеш-таблицу для пар "ключ-значение".

Queue

Определяет очередь, или список, действующий по принципу "первым пришел -- первым обслужен".

SortedList

Определяет отсортированный список пар "ключ-значение".

Stack

Определяет стек, или список, действующий по принципу "первым пришел -- последним обслужен".



3. Обобщенные коллекции

Обобщенные коллекции - это те же самые обобщенные классы. Использование их перед необобщенными коллекциями имеет следующие преимущества: повышение производительности (не надо тратить время на упаковку и распаковку объекта) и повышенная безопасность. Классы обобщенных коллекций находятся в пространстве имен System.Collections. Generic. Функционал коллекций по большей части описывается в обобщенных интерфейсах. [4]

Необобщенные коллекции обычно предназначены для оперирования над типами System.Object и, таким образом, являются слабо типизированными контейнерами (тем не менее, некоторые необобщенные коллекции работают только со специфическим типом данных, таким как объекты string). В противоположность этому, обобщенные коллекции являются намного более безопасными к типам, учитывая, что требуется указывать “тип типа”, который они будут содержать после создания. Признаком любого обобщенного элемента является наличие “параметра типа”, обозначаемого с помощью угловых скобок (например, List<T>). [6]

Параметр T в угловых скобках называется универсальным параметром, так как вместо него можно подставить любой тип. [3]

Интерфейсы обобщенных коллекций отличаются от необобщенных двойников не только наличием универсального параметра T, но и самой функциональностью. В таблице 2 представлены основные интерфейсы обобщенных коллекций.[2]

Таблица 2 - Интерфейсы обобщенных коллекций

Название	Описание
IEnumerable<T>	Определяет метод GetEnumerator, с помощью которого можно получать элементы любой коллекции. Реализация данного интерфейса позволяет перебирать элементы коллекции с помощью цикла foreach
IEumerator<T>	Определяет методы, с помощью которых потом можно получить содержимое коллекции по очереди
ICollection<T>	Представляет ряд общих свойств и методов для всех необобщенных коллекций (например, методы CopyTo, Add, Remove, Contains, свойство Count)
IList<T>	Предоставляет функционал для создания последовательных списков
IComparer<T>	Определяет метод Compare для сравнения двух однотипных объектов
IDictionary<TKey, TValue>	Определяет поведение коллекции, при котором она должна хранить объекты в виде пар ключ-значение: для каждого объекта определяется уникальный ключ типа, указанного в параметре TKey, и этому ключу соответствует определенное значение, имеющее тип, указанный в параметре TValue
IEqualityComparer<T>	Определяет методы, с помощью которых два однотипных объекта сравниваются на предмет равенства

Ниже, в таблице 3, представлены классы коллекций в пространстве имен System.Collections.Generic, которые реализуют интерфейсы, описанные в предыдущей таблице. [4]

Таблица 3 - Классы коллекций

Название	Описание
List<T>	Класс, представляющий последовательный список. Реализует интерфейсы IList<T>, ICollection<T>, IEnumerable<T>
Dictionary<TKey, TValue>	Класс коллекции, хранящей наборы пар "ключ-значение". Реализует интерфейсы icollection<T>, ienumerable<T>, idictionary<tkey, tvalue>
LinkedList<T>	Класс двух связанного списка. Реализует интерфейсы icollection<t> и ienumerable<t>
Queue<T>	Класс очереди объектов, работающей по алгоритму LIFO("первый вошел - первый вышел"). Реализует интерфейсы icollection, ienumerable<T>
SortedSet<T>	Класс отсортированной коллекции однотипных объектов. Реализует интерфейсы ICollection<T>, ISet<T>, IEnumerable<T>
SortedList<TKey, TValue>	Класс коллекции, хранящей наборы пар "ключ-значение", отсортированных по ключу. Реализует интерфейсы ICollection<T>, IEnumerable<T>, IDictionary<TKey, TValue>
SortedDictionary<TKey, TValue>	Класс коллекции, хранящей наборы пар "ключ-значение", отсортированных по ключу. Похож на класс SortedList<TKey, TValue>. Основные отличия состоят лишь в использовании памяти и в скорости вставки и удаления
Stack<T>	Класс стека однотипных объектов. Реализует интерфейсы ICollection<T> и IEnumerable<T>

Большинство обобщенных классов коллекций дублируют необобщенные классы коллекций. Но если не надо хранить объекты разных типов, то предпочтительнее использовать обобщенные коллекции.[3]

3.1 Основные обобщенные коллекции

Список List<T>

Класс List<T> представляет простейший список однотипных объектов.

Среди его методов можно выделить следующие:

1) void Add(T item): добавление нового элемента в список;

2) void AddRange(ICollection collection): добавление в список коллекции или массива;

3) int BinarySearch(T item): бинарный поиск элемента в списке. Если элемент найден, то метод возвращает индекс этого элемента в коллекции. При этом список должен быть отсортирован;

4) int IndexOf(T item): возвращает индекс первого вхождения элемента в списке;

5) void Insert(int index, T item): вставляет элемент item в списке на позицию index;

6) bool Remove(T item): удаляет элемент item из списка, и если удаление прошло успешно, то возвращает true;

7) void RemoveAt(int index): удаление элемента по указанному индексу index;

8) void Sort(): сортировка списка.

В листинге 2 (см. Приложение А) представлен пример программы, реализующей список List <T> заимствованный из источника [3].

В нем создаются два списка: один для объектов типа int, а другой - для объектов Person. В первом случае выполняется начальная инициализация списка: List numbers = new List<int>() {1, 2, 3, 45};

Во втором случае используется другой конструктор, в который передается начальная емкость списка: List<Person> persons = new List<Person>(3) [3].

Указание начальной емкости списка (capacity) позволяет в будущем увеличить производительность и уменьшить издержки на выделение памяти при добавлении элементов. Также начальную емкость можно установить с помощью свойства Capacity, которое имеется у класса List. [3]

Очередь Queue<T>

Класс Queue<T> представляет обычную очередь, работающую по алгоритму FIFO ("первый вошел - первый вышел"). [3]

У класса Queue<T> можно отметить следующие методы:

1) Dequeue: извлекает и возвращает первый элемент очереди;

2) Enqueue: добавляет элемент в конец очереди;

3) Peek: просто возвращает первый элемент из начала очереди без его удаления.

В листинге 3 представлен пример программы из источника [3], использующей класс Queue<T>. Результат работы программы представлен на рисунке А.2. На рисунке 1 показано представление очереди.

Рисунок 1 - Очередь Queue<T>

Стек Stack<T>

Класс Stack<T> представляет коллекцию, которая использует алгоритм LIFO ("последний вошел - первый вышел"). При такой организации каждый следующий добавленный элемент помещается поверх предыдущего. Извлечение из коллекции происходит в обратном порядке - извлекается тот элемент, который находится выше всех в стеке. [3]

В классе Stack можно выделить два основных метода, которые позволяют управлять элементами. [3]

1) Push: добавляет элемент в стек на первое место;

2) Pop: извлекает и возвращает первый элемент из стека;

3) Peek: просто возвращает первый элемент из стека без его удаления.

Работу стека можно представить следующей иллюстрацией, представленной на рисунке 2.

Рисунок 2 - Стек Stack<T>

Двухсвязный список LinkedList<T>

Класс LinkedList<T> представляет двухсвязный список, в котором каждый элемент хранит ссылку одновременно на следующий и на предыдущий элемент. [3]

Если в простом списке List<T> каждый элемент представляет объект типа T, то в LinkedList<T> каждый узел представляет объект класса LinkedListNode<T>.

Этот класс имеет следующие свойства: [3]

Value: само значение узла, представленное типом T

Next: ссылка на следующий элемент типа LinkedListNode<T> в списке. Если следующий элемент отсутствует, то имеет значение null

Previous: ссылка на предыдущий элемент типа LinkedListNode<T> в списке. Если предыдущий элемент отсутствует, то имеет значение null

Используя методы класса LinkedList<T>, можно обращаться к различным элементам, как в конце, так и в начале списка: [3]

1) AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode): вставляет узел newNode в список после узла node;

2) AddAfter(LinkedListNode<T> node, T value): вставляет в список новый узел со значением value после узла node;

3) AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode): вставляет в список узел newNode перед узлом node;

4) AddBefore(LinkedListNode<T> node, T value): вставляет в список новый узел со значением value перед узлом node;

5) AddFirst(LinkedListNode<T> node): вставляет новый узел в начало списка;

6) AddFirst(T value): вставляет новый узел со значением value в начало списка;

7) AddLast(LinkedListNode<T> node): вставляет новый узел в конец списка;

8) AddLast(T value): вставляет новый узел со значением value в конец списка;

9) RemoveFirst(): удаляет первый узел из списка. После этого новым первым узлом становится узел, следующий за удаленным;

10) RemoveLast(): удаляет последний узел из списка.

Пример использования списка LinkedList<T>, заимствованный из источника [3], представлен в листинге 4 (см. Приложении А).

В нем создаются и используются два списка: для чисел и для объектов класса Person. [3]

Класс LinkedList<T> представляет собой двухсвязный список, в котором каждый элемент ссылается на следующий и предыдущий, как показано на рисунке 1.



Рисунок 3 - Класс LinkedList<T>

Словарь Dictionary<T, V>

Еще один распространенный тип коллекции представляют словари. Словарь хранит объекты, которые представляют пару ключ-значение. Каждый такой объект является объектом класса KeyValuePair<TKey, TValue>. Благодаря свойствам Key и Value, которые есть у данного класса, мы можем получить ключ и значение элемента в словаре. [2]

Пример использования словарей из источника [1] представлен в листинге 5 (см Приложение А).

Класс словарей также как и другие коллекции, предоставляет методы Add и Remove для добавления и удаления элементов. Только в случае словарей в метод Add передаются два параметра: ключ и значение. А метод Remove удаляет не по индексу, а по ключу. [6]

На рисунке 4 представлена упрощенная модель словаря. Здесь ключами словаря служат идентификаторы сотрудников, такие как В4711. Ключ трансформируется в хеш. В хеше создается число для ассоциации индекса со значением. После этого индекс содержит ссылку на значение. Изображенная модель является упрощенной, поскольку существует возможность того, что единственное вхождение индекса может быть ассоциировано с несколькими значениями, и индекс может храниться в виде дерева.



Рисунок 4 - Модель словаря

Тип ключа

Тип, используемый в качестве ключа словаря, должен переопределять метод GetHashCode() класса Object. Всякий раз, когда класс словаря должен найти местоположение элемента, он вызывает метод GetHashCode().

Целое число, возвращаемое этим методом, используется словарем для вычисления индекса, куда помещен элемент. [2]

Реализация метода GetHashCode() должна удовлетворять перечисленным ниже требованиям:

1) Один и тот же объект должен всегда возвращать одно и то же значение;

2) Разные объекты могут возвращать одно и то же значение;

3) Он должен выполняться насколько возможно быстро, не требуя значительных вычислительных затрат;

4) Он не должен генерировать исключений;

5) Он должен использовать как минимум одно поле экземпляра;

6) Значения хеш-кода должны распределяться равномерно по всему диапазону чисел, которые может хранить int;

7) Хеш-код не должен изменяться на протяжении времени существования объекта.

Хорошая производительность словаря основана на хорошей реализации метода GetHashCode(). [2]

Если два ключа возвращают хеш-значения, дающие один и тот же индекс, класс словаря вынужден искать ближайшее доступное свободное место для сохранения второго элемента, к тому же ему придется выполнять некоторый поиск, чтобы впоследствии извлечь требуемое значение. Это наносит ущерб производительности, и если множество ключей дают одни и те же индексы, куда их следует поместить, вероятность конфликтов значительно возрастает. Однако благодаря способу, которым работает часть алгоритма, принадлежащая Microsoft, риск снижается до минимума, когда вычисляемое значение хеш-кода равномерно распределено между int.MinValue и int.MaxValue. [2]

Помимо реализации GetHashCode() тип ключа также должен реализовывать метод IEquatable<T>.Equals() либо переопределять метод Equals() класса Object. Поскольку разные объекты ключа могут возвращать один и тот же хеш-код, метод Equals() используется при сравнении ключей словаря. Словарь проверяет два ключа А и В на эквивалентность, вызывая A.Equals(В). Это означает, что потребуется обеспечить истинность следующего утверждения:

Если истинно А.Equals(В), значит, А.GetHashCode() и В.GetHashCode() всегда должны возвращать один и тот же хеш-код. [2]

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

По этой причине компилятор С# будет отображать предупреждение, если вы переопределите Equals (), но не представите переопределения GetHashCode(). [3]

Для System. Object это условие истинно, поскольку Equals () просто сравнивает ссылки, a GetHashCode () в действительности возвращает хеш-код, основанный исключительно на адресе объекта. Это означает, что хеш-таблицы, основанные на ключе, не переопределяющем эти методы, будут работать корректно. Однако проблема такого подхода заключается в том, что ключи трактуются как эквивалентные только в том случае, если они представляют один и тот же объект. Это значит, что когда при помещении объекта в словарь, обязательно нужно обращаться к ссылкам на ключ. Возможности просто позднее создать экземпляр другого ключевого объекта с тем же значением нет. Если не переопределить Equals() и GetHashCode(), то тип будет не слишком удобным для использования в словаре. [6]

System.String реализует интерфейс IEquatable и соответственно переопределяет GetHashCode(). Equals() обеспечивает сравнение значений, а GetHashCode() возвращает хеш-код, основанный на значении строки. Строки с успехом могут использоваться в качестве ключей в словарях. [6]

Числовые типы, такие как Int32, также реализуют интерфейс IEquatable и перегружают GetHashCode(). Однако хеш-код, возвращаемый этими типами, просто отображает значение. Если число, которое нужно использовать в качестве ключа, само по себе не распределено по всему диапазону возможных целочисленных значений, применение целых в качестве ключей не отвечает правилу равномерного распределения ключевых значений для получения наилучшей производительности. Int32 не предназначен для использования в словаре. [3]

Если нужно использовать тип ключа, который не реализует IEquatable и не переопределяет GetHashCode соответственно значениям ключа, сохраняемым в словаре, то есть возможность создать компаратор, реализующий интерфейс IEqualityComparer<T>. IEqualityComparer<T> определяет методы GetHashCode() и Equals() с аргументом -- переданным объектом, так что вы можете предоставить реализацию, отличающуюся от типа самого объекта. Перегрузка конструктора Dictionary<TKey, TValue> позволяет передать объект, реализующий IEqualityComparer<T>. Если такой объект присвоен словарю, этот класс используется для генерации хеш-кодов и сравнения ключей. [3]

Класс Dictionary<TKey, TValue>

В классе Dictionary<TKey, TValue> реализуются интерфейсы IDictionary, IDictionary<TKey, TValue>, ICollection, ICollection<KeyValue Pair<TKey, TValue>>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, ISerializable и IDeserializationCallback. В двух последних интерфейсах поддерживается сериализация списка. Словари имеют динамический характер, расширяясь по мере необходимости. [2]

В классе Dictionary<TKey, TValue> предоставляется немало конструкторов. Ниже перечислены наиболее часто используемые из них:

public Dictionary()

public Dictionary(IDictionary<TKey, TValue> dictionary)

public Dictionary(int capacity)

В первом конструкторе создается пустой словарь с выбираемой по умолчанию первоначальной емкостью. Во втором конструкторе создается словарь с указанным количеством элементов dictionary. А в третьем конструкторе с помощью параметра capacity указывается емкость коллекции, создаваемой в виде словаря. Если размер словаря заранее известен, то, указав емкость создаваемой коллекции, можно исключить изменение размера словаря во время выполнения, что, как правило, требует дополнительных затрат вычислительных ресурсов. [2]

В классе Dictionary<TKey, TValue> определяется также ряд методов:

Add()

Добавляет в словарь пару "ключ-значение", определяемую параметрами key и value. Если ключ key уже находится в словаре, то его значение не изменяется, и генерируется исключение ArgumentException

ContainsKey()

Возвращает логическое значение true, если вызывающий словарь содержит объект key в качестве ключа; а иначе -- логическое значение false

ContainsValue()

Возвращает логическое значение true, если вызывающий словарь содержит значение value; в противном случае -- логическое значение false

Remove()

Удаляет ключ key из словаря. При удачном исходе операции возвращается логическое значение true, а если ключ key отсутствует в словаре -- логическое значение false. [2]

Кроме того, в классе Dictionary<TKey, TValue> определяются собственные свойства, помимо тех, что уже объявлены в интерфейсах, которые в нем реализуются. Эти свойства приведены ниже, в таблице 4. [5]

Таблица 4 - Собственные свойства класса Dictionary<TKey, TValue>

Название	Описание
Comparer	Получает метод сравнения для вызывающего словаря
Keys	Получает коллекцию ключей
Values	Получает коллекцию значений

Следует иметь в виду, что ключи и значения, содержащиеся в коллекции, доступны отдельными списками с помощью свойств Keys и Values. В коллекциях типа Dictionary<TKey, TValue>.KeyCollection и Dictionary<TKey, TValue>.ValueCollection реализуются как обобщенные, так и необобщенные формы интерфейсов ICollection и IEnumerable.

И наконец, в классе Dictionary<TKey, TValue> реализуется приведенный ниже индексатор, определенный в интерфейсе IDictionary<TKey, TValue>

public TValue this[TKey key] { get; set; }



Этот индексатор служит для получения и установки значения элемента коллекции, а также для добавления в коллекцию нового элемента. Но в качестве индекса в данном случае служит ключ элемента, а не сам индекс. При перечислении коллекции типа Dictionary<TKey, TValue> из нее возвращаются пары "ключ-значение" в форме структуры KeyValuePair<TKey, TValue>. Напомним, что в этой структуре определяются два поля. [4]

public TKey Key;

public TValue Value;

В этих полях содержится ключ или значение соответствующего элемента коллекции. Как правило, структура KeyValuePair<TKey, TValue> не используется непосредственно, поскольку средства класса Dictionary<TKey, TValue> позволяют работать с ключами и значениями по отдельности. Но при перечислении коллекции типа Dictionary<TKey, TValue>, например, в цикле foreach перечисляемыми объектами являются пары типа KeyValuePair.

Классы HashSet<T> и SortedSet<T>

Класс SortedSet<T> удобен тем, что при вставке или удалении элементов он автоматически обеспечивает сортировку элементов в наборе. Класс SortedSet<T> понадобится информировать о том, как должны сортироваться объекты, за счет передачи его конструктору аргумента -- объекта, реализующего обобщенный интерфейс IComparer<T>.

Коллекция, содержащая только отличающиеся элементы, называется множеством (set). В составе .NET 4 имеются два множества -- HashSet<T> и SortedSet<T>. Оба они реализуют интерфейс ISet<T>. Класс HashSet<T> содержит неупорядоченный список различающихся элементов, а в SortedSet<T> элементы упорядочены. [6]

Интерфейс ISet<T> предоставляет методы для создания объединения нескольких множеств, пересечения множеств и определения, является ли одно множество надмножеством или подмножеством другого. [2]

Ниже перечислены наиболее употребительные конструкторы, определенные в классе HashSet<T>:

public HashSet ()

public HashSet(IEnumerable<T> collection)

public HashSet(IEqualityCompare comparer)

public HashSet(IEnumerable<T> collection, IEqualityCompare comparer)

В первой форме конструктора создается пустое множество, а во второй форме -- множество, состоящее из элементов указываемой коллекции collection. В третьей форме конструктора допускается указывать способ сравнения с помощью параметра comparer. А в четвертой форме создается множество, состоящее из элементов указываемой коллекции collection, и используется заданный способ сравнения comparer. Имеется также пятая форма конструктора данного класса, в которой допускается инициализировать множество последовательно упорядоченными данными.

В этом классе предоставляется также метод RemoveWhere(), удаляющий из множества элементы, удовлетворяющие заданному условию, или предикату. Помимо свойств, определенных в интерфейсах, которые реализуются в классе HashSet<T>, в него введено дополнительное свойство Comparer, приведенное ниже:

public IEqualityComparer<T> Comparer { get; }

Оно позволяет получать метод сравнения для вызывающего хеш-множества. [4]

Ниже перечислены четыре наиболее часто используемых конструкторов, определенных в классе SortedSet<T>:

public SortedSet()

public SortedSet(IEnumerable<T> collection)

public SortedSet(IComparer comparer)

public SortedSet(IEnumerable<T> collection, IComparer comparer)

В первой форме конструктора создается пустое множество, а во второй форме -- множество, состоящее из элементов указываемой коллекции collection. В третьей форме конструктора допускается указывать способ сравнения с помощью параметра comparer. А в четвертой форме создается множество, состоящее из элементов указываемой коллекции collection, и используется заданный способ сравнения comparer. Имеется также пятая форма конструктора данного класса, в которой допускается инициализировать множество последовательно упорядоченными данными.

В этом классе предоставляется также метод GetViewBetween(), возвращающий часть множества в форме объекта типа SortedSet<T>, метод RemoveWhere(), удаляющий из множества элементы, не удовлетворяющие заданному условию, или предикату, а также метод Reverse(), возвращающий объект типа IEnumerable<T>, который циклически проходит множество в обратном порядке. [6]

Помимо свойств, определенных в интерфейсах, которые реализуются в классе SortedSet<T>, в него введены дополнительные свойства, приведенные ниже:

public IComparer<T> Comparer { get; }

public T Max { get; }

public T Min { get; }

Свойство Comparer получает способ сравнения для вызывающего множества. Свойство Мах получает наибольшее значение во множестве, а свойство Min -- наименьшее значение во множестве.

Класс SortedDictionary<TKey, TValue>

Класс SortedDictionary<TKey, Tvalue> представляет дерево бинарного поиска, в котором все элементы отсортированы на основе ключа. Тип ключа должен реализовать интерфейс IComparable<TKey>. Если тип ключа не сортируемый, компаратор можно также создать, реализовав IComparer<TKey> и указав его в качестве аргумента конструктора сортированного словаря. [2]

Классы SortedDictionary<TKey, Tvalue> и SortedList<TKey, TValue> имеют схожую функциональность. Но поскольку SortedList<TKey, TValue> реализован в виде списка, основанного на массиве, a SortedDictionary<TKey, Tvalue> реализован как словарь, эти классы обладают разными характеристиками:

SortedList<TKey, TValue> использует меньше памяти, чем SortedDictionary<TKey, TValue>

SortedDictionary<TKey, TValue> быстрее вставляет и удаляет элементы.

При наполнении коллекции отсортированными данными SortedList<TKey,TValue> работает быстрее, если при этом не требуется изменение емкости. [6]

В классе SortedDictionary<TKey, TValue> реализуются интерфейсы IDictionary, IDictionary<TKey, TValue>, ICollection, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable и IEnumerable<KeyValuePair<TKey, TValue>>. В классе SortedDictionary<TKey, TValue> предоставляются также следующие конструкторы:

public SortedDictionary()

public SortedDictionary(IDictionary<TKey, TValue> dictionary)

public SortedDictionary(IComparer<TKey> comparer)

public SortedDictionary(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer)



В первом конструкторе создается пустой словарь, во втором конструкторе -- словарь с указанным количеством элементов dictionary. В третьем конструкторе допускается указывать с помощью параметра comparer типа IComparer способ сравнения, используемый для сортировки, а в четвертом конструкторе -- инициализировать словарь, помимо указания способа сравнения. [2]

В классе SortedDictionary<TKey, TValue> определен ряд методов. Некоторые наиболее часто используемые методы этого класса приведены ниже: [2]

Add()

Добавляет в словарь пару "ключ-значение", определяемую параметрами key и value. Если ключ key уже находится в словаре, то его значение не изменяется, и генерируется исключение ArgumentException

ContainsKey()

Возвращает логическое значение true, если вызывающий словарь содержит объект key в качестве ключа; в противном случае -- логическое значение false

ContainsValue()

Возвращает логическое значение true, если вызывающий словарь содержит значение value, в противном случае -- логическое значение false

Remove()

Удаляет ключ key из словаря. При удачном исходе операции возвращается логическое значение true, а если ключ key отсутствует в словаре -- логическое значение false

Следует иметь в виду, что ключи и значения, содержащиеся в коллекции, доступны отдельными списками с помощью свойств Keys и Values. В коллекциях типа SortedDictionary<TKey, TValue>.KeyCollection и SortedDictionary<TKey, TValue>.ValueCollection реализуются как обобщенные, так и необобщенные формы интерфейсов ICollection и IEnumerable. [6]

И наконец, в классе SortedDictionary<TKey, TValue> реализуется приведенный ниже индексатор, определенный в интерфейсе IDictionary<TKey, TValue>:

public TValue this[TKey key] { get; set; }

Этот индексатор служит для получения и установки значения элемента коллекции, а также для добавления в коллекцию нового элемента. Но в данном случае в качестве индекса служит ключ элемента, а не сам индекс.



4. Параллельные коллекции

В версию 4.0 среды .NET Framework добавлено новое пространство имен System.Collections.Concurrent. Оно содержит коллекции, которые являются потокобезопасными и специально предназначены для параллельного программирования. Это означает, что они могут безопасно использоваться в многопоточной программе, где возможен одновременный доступ к коллекции со стороны двух или больше параллельно исполняемых потоков. Для безопасного в отношении потоков доступа к коллекциям определен интерфейс IProducerConsumerCollection<T>. Наиболее важными методами этого интерфейса являются TryAdd() и TryTake(). Метод TryAdd() пытается добавить элемент в коллекцию, но это может не получиться, если коллекция заблокирована от добавления элементов. Метод возвращает булевское значение, сообщающее об успехе или неудаче операции. [2]

TryTake() работает аналогичным образом, информируя вызывающий код об успехе или неудаче, и в случае успеха возвращает элемент из коллекции. Ниже перечислены классы из пространства имен System.Collections.Concurrent с кратким описанием их функциональности:

ConcurrentQueue<T>

Этот класс коллекции реализован со свободным от блокировок алгоритмом и использует 32 массива, которые внутренне скомбинированы в связный список. Для доступа к элементам очереди применяются методы Enqueue(), TryDequeue() и TryPeek(). Имена этих методов очень похожи на уже известные методы Queue<T>, но с добавлением префикса Try к тем из них, которые могут дать сбой. Поскольку этот класс реализует интерфейс IProducerConsumerCollection<T>, методы TryAdd() и TryTake() просто вызывают Enqueue() и TryDequeue(). [6]

ConcurrentStack<T>

Очень похож на ConcurrentQueue<T>, но с другими методами доступа к элементам. Класс ConcurrentStack<T> определяет методы Push(), PushRange(), TryPeek(), TryPop() и TryPopRange(). Внутри этот класс использует связный список для хранения элементов. [2]

ConcurrentBag<T>

Этот класс не определяет никакого порядка для добавления или извлечения элементов. Он реализует концепцию отображения потоков на используемые внутренне массивы, и старается избежать блокировок. Для доступа к элементам применяются методы Add(), TryPeek() и TryTake(). [2]

ConcurrentDictionary<TKey, TValue>

Безопасная в отношении потоков коллекция ключей и значений. Для доступа к членам в неблокирующем режиме служат методы TryAdd(), TryGetValue(), TryRemove() и TryUpdate(). Поскольку элементы основаны на ключах и значениях, ConcurrentDictionary<TKey, TValue> не реализует интерфейс IProducerConsumerCollection<T>. [2]

ConcurrentXXX. Эти коллекции безопасны к потокам в том смысле, что возвращают false, если какое-то действие над ними невозможно при текущем состоянии потоков. Прежде чем предпринимать какие-то дальнейшие действия, всегда следует проверять успешность добавления или извлечения элементов. Полностью доверять коллекции решение задачи нельзя. [2]

BlockingCollection<T>

Коллекция, которая осуществляет блокировку и ожидает, пока не появится возможность выполнить действие по добавлению или извлечению элемента. BlockingCollection<T> предлагает интерфейс для добавления и извлечения элементов методами Add() и Take(). Эти методы блокируют поток и затем ожидают, пока не появится возможность выполнить задачу. [2]

Метод Add() имеет перегрузку, которой можно также передать CancellationToken. Эта лексема всегда отменяет блокирующий вызов. Если не нужно, чтобы поток ожидал бесконечное время, без отмены вызова, доступны также методы TryAdd() и TryTake(). В них можно указать значение таймаута -- максимального периода времени, в течение которого вы готовы блокировать поток и ждать, пока вызов не даст сбой. [2]

5. Специальные и наблюдаемые коллекции

5.1 Специальные коллекции

В среде .NET Framework предусмотрен ряд специальных коллекций, оптимизированных для работы с данными конкретного типа или для их обработки особым образом. Классы этих необобщенных коллекций определены в пространстве имен System.Collections.Specialized и перечислены в таблице 5. [3]

Таблица 5 - Специальные коллекции C#

Класс специальной коллекции	Описание
CollectionsUtil	Содержит фабричные методы для создания коллекций
HybridDictionary	Предназначен для коллекций, в которых для хранения небольшого количества пар "ключ-значение" используется класс ListDictionary. При превышении коллекцией определенного размера автоматически используется класс Hashtable для хранения ее элементов
ListDictionary	Предназначен для коллекций, в которых для хранения пар "ключ-значение" используется связный список. Такие коллекции рекомендуются только для хранения небольшого количества элементов

Подобные документы

• Проектирование программной коллекции "Простой, статический граф"

  Разработка и реализация универсальной программной коллекции для абстрактного типа данных (АТД) "Простой статический граф" с графическим интерфейсом. Особенности использование ее для решения задач для неориентированных, ориентированных и взвешенных графов.
  
  курсовая работа [502,3 K], добавлен 24.09.2013
  

• Организация интерфейса пользователя

  Совокупность программных и аппаратных средств, обеспечивающих взаимодействие пользователя с компьютером. Классификация интерфейсов, текстовый режим работы видеоадаптера. Функции текстового режима. Реализация пользовательского интерфейса в BORLAND C++.
  
  лабораторная работа [405,1 K], добавлен 06.07.2009
  

• Интерфейсы информационных систем

  Стандартный интерфейс IEC 625-1 для программируемых приборов. Логическая организация интерфейса. Протокол сигналов для установления связи по магистрали IEC. Условия функционирования приборов в системе. Коды и форматы, физическая реализация интерфейса.
  
  контрольная работа [102,4 K], добавлен 23.01.2014
  

• Основные интерфейсы, применяемые в компьютерной технике

  Основные понятия, применяемые при описании интерфейсов, их классификация. Обзор применяемых в компьютерной технике интерфейсов по их характеристикам и области применения. Описание и основные характеристики интерфейсов IDE, IEEE-1394, HDMI 1.4 и SATA.
  
  курсовая работа [183,3 K], добавлен 25.04.2012
  

• Разработка и реализация графического интерфейса для СПП СБкЗ_ПП с использованием системы автоматической генерации интерфейсов OntoDev

  Анализ графических пользовательских интерфейсов современных систем оптимизации программ. Создание математической модели и алгоритма системы управления СБкЗ_ПП, ее архитектурно-контекстная диаграмма. Техническая документация программного средства.
  
  дипломная работа [1,1 M], добавлен 18.04.2012
  

• Последовательные интерфейсы

  Сущность и предназначение последовательных интерфейсов. Формат асинхронной и синхронной посылки. Функциональные возможности и схема соединения по интерфейсу RS-232C. Назначение сигналов интерфейса. Понятие, конфигурирование и использование СОМ-портов.
  
  контрольная работа [175,2 K], добавлен 09.11.2010
  

• Размещение графики в документе

  Вставка объекта, созданного в другом графическом редакторе. Рисование в документе. Вставка рисунка из коллекции Clipart и размещение поверх него текста. Создание визитной карточки. Создание визитной карточки, заключенной в рамку из коллекции Clipart.
  
  лабораторная работа [555,8 K], добавлен 10.03.2007
  

• Разработка интерфейса социальной сети "Ученые Украины"

  Понятие социальной сети, определение основных целей и задач ее создания, распространенность и значение в современном обществе. Модели влияния в социальных сетях. Выбор средств проектирования и программная реализация, разработка и реализация интерфейса.
  
  дипломная работа [1,5 M], добавлен 11.09.2012
  

• Основы работы в С++

  Основные приемы работы с классами и объектами. Перегрузка функций и операторов. Массивы объектов. Реализация одиночного наследования. Множественное наследование. Виртуальные функции. Шаблоны: понятие и функциональные особенности, свойства и применение.
  
  методичка [1,1 M], добавлен 16.04.2012
  

• Создание информационного ресурса и реализация алгоритма сортировки данных

  Аппаратные характеристики системы, использованной для разработки информационного ресурса "Сортировка слиянием". Проектирование логической и физической структуры ресурса, реализация его интерфейса. Основные функции программы, ее тестирование и отладка.
  
  курсовая работа [2,1 M], добавлен 26.11.2012
  

• главная
• рубрики
• по алфавиту
• вернуться в начало страницы
• вернуться к началу текста
• вернуться к подобным работам