Method RightOuterHashJoin
| Edit this page View SourceRightOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)
Performs a right outer join on two heterogeneous sequences.
Declaration
public static IEnumerable<(TLeft? Left, TRight Right)> RightOuterHashJoin<TLeft, TRight, TKey>(this IEnumerable<TLeft> left, IEnumerable<TRight> right, Func<TLeft, TKey> leftKeySelector, Func<TRight, TKey> rightKeySelector, IEqualityComparer<TKey>? comparer = null)
Parameters
Type | Name | Description |
---|---|---|
IEnumerable<TLeft> | left | The first sequence. |
IEnumerable<TRight> | right | The second sequence. |
Func<TLeft, TKey> | leftKeySelector | A function to extract the join key from each element of the first sequence. |
Func<TRight, TKey> | rightKeySelector | A function to extract the join key from each element of the second sequence. |
IEqualityComparer<TKey> | comparer | An IEqualityComparer<T> to hash and compare keys. |
Returns
Type | Description |
---|---|
IEnumerable<(TLeft Left, TRight Right)> | A sequence containing values from a right outer join of the two input sequences. |
Type Parameters
Name | Description |
---|---|
TLeft | The type of elements in the first sequence. |
TRight | The type of elements in the second sequence. |
TKey | The type of the key returned by the key selector functions. |
Remarks
The result of this method is a `right outer`-join. All elements from right
are returned,
along with any matching elements from left
, if any are present. If no values in left
match, default is returned for the left element.
This method is implemented using a `hash`-join. The sequence right
is cached as an ILookup<TKey, TElement>, and for-each element of left
, the lookup is accessed to
find any matching elements.
This method uses deferred execution and streams its results.
Examples
The following code example demonstrates how to execute an right outer hash join of two sequences using RightOuterHashJoin
.
var people = new Person[]
{
new("John Doe", 1),
new("Jane Doe", 6),
new("Lucy Ricardo", 4),
new("Ricky Ricardo", 2),
new("Fred Mertz", 3),
new("Ethel Mertz", 5),
};
var pets = new Pet[]
{
new("Bear", 8),
new("Polly", 2),
new("Minnie", 2),
new("Mittens", 1),
new("Patches", 1),
new("Paws", 1),
};
var results = people
.RightOuterHashJoin(
pets,
p => p.PersonId,
p => p.PersonId);
foreach (var (person, pet) in results)
{
Console.WriteLine($"({person?.Name ?? "N/A"}, {pet.Name})");
}
// This code produces the following output:
// (John Doe, Mittens)
// (John Doe, Patches)
// (John Doe, Paws)
// (Ricky Ricardo, Polly)
// (Ricky Ricardo, Minnie)
// (N/A, Bear)
record Person(string Name, int PersonId);
record Pet(string Name, int PersonId);
Exceptions
Type | Condition |
---|---|
ArgumentNullException |
|
RightOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)
Performs a right outer join on two heterogeneous sequences.
Declaration
public static IEnumerable<TResult> RightOuterHashJoin<TLeft, TRight, TKey, TResult>(this IEnumerable<TLeft> left, IEnumerable<TRight> right, Func<TLeft, TKey> leftKeySelector, Func<TRight, TKey> rightKeySelector, Func<TRight, TResult> rightResultSelector, Func<TLeft, TRight, TResult> bothResultSelector, IEqualityComparer<TKey>? comparer = null)
Parameters
Type | Name | Description |
---|---|---|
IEnumerable<TLeft> | left | The first sequence. |
IEnumerable<TRight> | right | The second sequence. |
Func<TLeft, TKey> | leftKeySelector | A function to extract the join key from each element of the first sequence. |
Func<TRight, TKey> | rightKeySelector | A function to extract the join key from each element of the second sequence. |
Func<TRight, TResult> | rightResultSelector | A function to create a result element from a |
Func<TLeft, TRight, TResult> | bothResultSelector | A function to create a result element from two matching elements. |
IEqualityComparer<TKey> | comparer | An IEqualityComparer<T> to hash and compare keys. |
Returns
Type | Description |
---|---|
IEnumerable<TResult> | A sequence containing values projected from a right outer join of the two input sequences. |
Type Parameters
Name | Description |
---|---|
TLeft | The type of elements in the first sequence. |
TRight | The type of elements in the second sequence. |
TKey | The type of the key returned by the key selector functions. |
TResult | The type of the result elements. |
Remarks
The result of this method is a `left outer`-join. Values are projected using bothResultSelector
when matching elements are found in both left
and right
sequences. Values are projected using rightResultSelector
when elements in
right
do not have a matching element in left
.
This method is implemented using a `hash`-join. The sequence right
is cached as an ILookup<TKey, TElement>, and for-each element of left
, the lookup is accessed to
find any matching elements.
This method uses deferred execution and streams its results.
Examples
The following code example demonstrates how to execute an right outer hash join of two sequences using RightOuterHashJoin
.
var people = new Person[]
{
new("John Doe", 1),
new("Jane Doe", 6),
new("Lucy Ricardo", 4),
new("Ricky Ricardo", 2),
new("Fred Mertz", 3),
new("Ethel Mertz", 5),
};
var pets = new Pet[]
{
new("Bear", 8),
new("Polly", 2),
new("Minnie", 2),
new("Mittens", 1),
new("Patches", 1),
new("Paws", 1),
};
var results = people
.RightOuterHashJoin(
pets,
p => p.PersonId,
p => p.PersonId,
pet => $"(N/A, {pet.Name})",
(person, pet) => $"({person.Name}, {pet.Name})");
foreach (var str in results)
Console.WriteLine(str);
// This code produces the following output:
// (John Doe, Mittens)
// (John Doe, Patches)
// (John Doe, Paws)
// (Ricky Ricardo, Polly)
// (Ricky Ricardo, Minnie)
// (N/A, Bear)
record Person(string Name, int PersonId);
record Pet(string Name, int PersonId);
Exceptions
Type | Condition |
---|---|
ArgumentNullException |
|