> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Working with Collections
C# samples and information are applicable only to FRE for Windows.
There are three major types of collections in ABBYY FineReader Engine:
* temporary collections (collections of references to existing objects)
* collections of child objects
* read-only collections of child objects
On this page, you can find information on the following:
* how to work with each type of collection
* how to view the list of all available collections
* how to work with collections in .NET in FRE for Windows
## Temporary collections
This type of collection represents a collection of references to existing objects. These are temporary collections; usually, they are used to pass various sets of parameters into methods that require them. You create this collection, add elements to it (elements are added as references to existing objects), pass to the required method, and then destroy the collection while the objects that were added to it remain. Such collections have Collection postfix in their names (e.g., StringsCollection, IntsCollection).
To work with a collection of such type:
1. Create the collection using the corresponding creation method of the [Engine](/fine-reader/engine/api-reference/engine-object-iengine-interface) object. For example, for the IntsCollection object, it is the [CreateIntsCollection](/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) method. These collections can also be return values of some methods.
2. Add existing objects to the collection using its [Add](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/add-method) method. You can iterate through the collection using its read-only Count property, read-write [Element](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/element-property) property, and [Item](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/item-method) method. The first one gets the number of elements actually contained in the collection, the second and third ones provide access to the element at the specified index. The Element property allows you to access an element of the collection using the \[] operator in C#.
3. If necessary, modify the collection using other methods of the collection: [InsertAt](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/insertat-method), [DeleteAt](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/deleteat-method), [DeleteAll](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/deleteall-method) methods.
4. Pass the collection to the method that requires it as a parameter.
An example of using the IntsCollection object in C#:
```csharp theme={null}
for( int i = 0; i < Document.Pages.Count; i++ )
{
if( Document.Pages[i].PageStructureOutOfDate )
{
pageIndices.Add( i );
}
}
// Pass the created collection of page indices to a processing method
if( pageIndices.Count > 0 || Document.DocumentStructureOutOfDate )
{
Document.SynthesizePages( pageIndices, null );
}
```
## Collections of child objects
Another type represents a collection of child objects of some parent object. These collections exist while their parent object exists. Via such collections, you can add or remove child objects of the parent object. When you add an element into the collection, a new object is created internally and then added to the collection. Examples of such collections: DictionaryDescriptions – a collection of dictionary description objects, BaseLanguages – a collection of base languages.
To use such collections:
1. Obtain the collection via the property of its parent object. For example, if you want to access the collection of base languages of a recognition language, use the [DictionaryDescriptions](/fine-reader/engine/api-reference/language-related-objects/baselanguage#dictionarydescriptions) property of the BaseLanguage object.
2. Iterate through the collection using the read-only Count and [Element](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/element-property) properties and the [Item](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/item-method) method. The first one gets the number of elements actually contained in the collection, the second and third ones get the element at the specified index. The Element property allows you to access an element of the collection using the \[] operator in C#.
3. If necessary, add new elements to the collection using its AddNew method. The AddNew methods of different collections can have slightly different syntax, but all these methods do the same: create a new collection element and add it into the collection. You can delete elements using the [DeleteAt](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/deleteat-method), [DeleteAll](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/deleteall-method) methods.
An example of working with the DictionaryDescriptions object in C#:
```csharp theme={null}
FREngine.IEngine Engine = null;
FREngine.IBaseLanguage baseLanguage = null;
// Initialize Engine and obtain a base language of a text language
...
// Get collection of dictionary descriptions of a base language and remove all items
IDictionaryDescriptions dictionaryDescriptions = baseLanguage.DictionaryDescriptions;
dictionaryDescriptions.DeleteAll();
// Create a user dictionary description and add it to the collection
IDictionaryDescription dictionaryDescription = dictionaryDescriptions.AddNew( DictionaryTypeEnum.DT_UserDictionary );
```
## Read-only collections
Some collections of child objects are read-only. This means that they do not have editing methods, you can only iterate and view their elements. Examples of such collections are: PredefinedLanguages – a collection of predefined languages, Paragraphs – a collection of paragraphs of a text.
To view the elements of such collections:
1. Obtain the collection via the property of its parent object. For example, if you want to access the collection of paragraphs of a text, use the [Paragraphs](/fine-reader/engine/api-reference/text-related-objects/text#paragraphs) property of the Text object.
2. Iterate through the collection using the read-only Count and [Element](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/element-property) properties and the [Item](/fine-reader/engine/visual-components-reference/supplementary-objects/spellwordcollection/item-method) method. The first one gets the number of elements actually contained in the collection, the second and third ones get the element at the specified index. The Element property allows you to access an element of the collection using the \[] operator in C#.
An example of working with the Paragraphs object in C#:
```csharp theme={null}
FREngine.IEngine Engine = null;
FREngine.IBlock block = null;
// Initialize Engine, recognize a document and obtain a text block of a layout
...
FREngine.ITextBlock textBlock = block.GetAsTextBlock();
// Iterate paragraphs of the text of the block
int paragraphsCount = textBlock.Text.Paragraphs.Count;
for (int iPar = 0; iPar < paragraphsCount; iPar++)
{
FREngine.IParagraph par = textBlock.Text.Paragraphs[iPar];
string text = par.Text;
}
```
## All available collections
Below is the full list of the collections available in FineReader Engine. Some of the collections provide additional methods for working with elements. See details in the table below.
DocumentInformationDictionary – this collection is also a dictionary, therefore the Element property is replaced with the Value property.
FRPages – this collection of child objects differs from others of the same type. It does not have the AddNew method, instead you can use the AddPage method of the parent FRDocument object. It also does not have DeleteAll method and has additional IndexOf, Remove and Swap methods.
OfficeConverters (Linux and Windows only) – This collection differs from all others in that it contains enumeration constants, not objects. It also has an additional Find method.
Toolbar – this collection has additional Delete, Has methods.
PopupMenu – this collection has additional Delete, Has methods, CustomMenuEnabled, StandardMenuEnabled properties.
## Working with collections in .NET
All collection interfaces are derived from the IEnumerable interface. This means that you can use the foreach statement in C# (for each in Visual Basic) to manipulate collections. Note that working with collections using foreach has some specifics, e.g., enumerators cannot be used to modify the collection, but only to read the data in it. See remarks on [msdn.microsoft.com](http://msdn.microsoft.com/en-us/library/system.collections.ienumerator.aspx).
An example of using foreach with the FRPages collection in C#:
```csharp theme={null}
FREngine.IFRDocument document;
// We presume that the document contains some pages
...
foreach( FREngine.IFRPage page in document.Pages ) {
// do something with the page
}
```