# GroupProcessor

 The `GroupProcessor` class is a generic class that provides parallel processing functionality for collections of elements. It allows users to easily perform parallel operations on a group of items and return the results as different types of collections, such as `ConcurrentBag`, `ConcurrentDictionary`, or a `List`.

The "Group" Processor is for a selection where more than one item can be matched for the given selector, also known as a **GroupBy**. If you're looking for a single item in and out without grouping, use the [SingleProcessor](https://docs.perigee.software/core-modules/perigee-in-parallel/singleprocessor).

## ParallelProcess

This method processes the collection in parallel and invokes the provided callback for each group of items with the same key.

#### Example:

```csharp
var groupProcessor = new GroupProcessor<Item, Category>(items, item => item.Category);
groupProcessor.ParallelProcess((group, category) => {
    Console.WriteLine($"Processing category: {category}");
    foreach (var item in group)
    {
        Console.WriteLine($"  - {item.Name}");
    }
});
```

## ParallelProcessToBag

This method processes the collection in parallel and adds the results to a `ConcurrentBag` by invoking the provided callback for each group of items with the same key.

#### Example:

```csharp
var groupProcessor = new GroupProcessor<Item, Category>(items, item => item.Category);
ConcurrentBag<string> resultBag = groupProcessor.ParallelProcessToBag((group, category) => {
    int itemCount = group.Count;
    return $"Category: {category}, Item Count: {itemCount}";
});

```

## ParallelProcessToDictionary

This method processes the collection in parallel and adds the results to a `ConcurrentDictionary` by invoking the provided callback for each group of items with the same key.

#### Example:

```csharp
var groupProcessor = new GroupProcessor<Item, Category>(items, item => item.Category);
ConcurrentDictionary<Category, int> resultDictionary = groupProcessor.ParallelProcessToDictionary((group, category) => {
    int itemCount = group.Count;
    return new KeyValuePair<Category, int>(category, itemCount);
});
```

## ParallelProcessKeys

This method processes the keys of the collection in parallel and invokes the provided callback for each key.

#### Example:

```csharp
var singleProcessor = new SingleProcessor<Item, Category>(items, item => item.Category);
singleProcessor.ParallelProcessKeys(key => {
    Console.WriteLine($"Processing key: {key}");
});
```

## ParallelProcessKeysToBag

This method processes the keys of the collection in parallel and adds the results to a `ConcurrentBag` by invoking the provided callback for each key.

#### Example:

```csharp
var singleProcessor = new SingleProcessor<Item, Category>(items, item => item.Category);
ConcurrentBag<string> resultBag = singleProcessor.ParallelProcessKeysToBag(key => {
    return $"Key: {key}";
});
```

## ParallelProcessKeysToDictionary

This method processes the keys of the collection in parallel and adds the results to a `ConcurrentDictionary` by invoking the provided callback for each key.

#### Example:

```csharp
var singleProcessor = new SingleProcessor<Item, Category>(items, item => item.Category);
ConcurrentDictionary<Category, int> resultDictionary = singleProcessor.ParallelProcessKeysToDictionary(key => {
    return new KeyValuePair<Category, int>(key, 1);
});
```

## ParallelToNewSingleProcessor

This method processes the keys of the collection in parallel and returns a new `SingleProcessor` instance containing the results.

#### Example:

```csharp
var singleProcessor = new SingleProcessor<Item, Category>(items, item => item.Category);
SingleProcessor<string, Category> newSingleProcessor = singleProcessor.ParallelToNewSingleProcessor(key => {
    return new KeyValuePair<Category, string>(key, $"New {key}");
});
```

## ParallelToNewGroupedProcessor

This method processes the keys of the collection in parallel and returns a new `GroupProcessor` instance containing the results, grouped by the provided expression.

#### Example:

```csharp
var singleProcessor = new SingleProcessor<Item, Category>(items, item => item.Category);
GroupProcessor<string, Category> newGroupProcessor = singleProcessor.ParallelToNewGroupedProcessor(key => {
    return new KeyValuePair<Category, string>(key, $"New {key}");
}, group => group.Category);
```

## AllKeys

Returns all keys in the processor as an enumerable.

#### Example:

```csharp
var allKeys = processor.AllKeys();
foreach (var key in allKeys)
{
    Console.WriteLine(key);
}
```