public ResultSetEnumerator(IDataResultsBase results, IDataReaderAsync reader, IExecutionContext context, Func <IDataRecord, T> read, int set)
{
_results = results;
_reader = reader;
_context = context;
_read = read;
_set = set;
}
/// <summary>
/// Iterate through all remaining rows in the next N result sets, mapping all rows to objects
/// of the given type. Useful only if the next N result sets all represent the same type
/// of object
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="results"></param>
/// <param name="numResultSets">The number of result sets to consume</param>
/// <param name="setup"></param>
/// <returns></returns>
public static IEnumerable <T> AsEnumerableNextSeveral <T>(this IDataResultsBase results, int numResultSets, Action <IMapCompilerSettings> setup = null)
{
Argument.NotNull(results, nameof(results));
if (numResultSets <= 0)
{
yield break;
}
var values = results.AsEnumerable <T>(setup);
var currentSet = results.CurrentSet;
foreach (var value in values)
{
if (currentSet != results.CurrentSet)
{
throw DataReaderException.EnumeratorBroken();
}
yield return(value);
}
numResultSets--;
while (numResultSets > 0)
{
// Make sure we're still where we think we are
if (currentSet != results.CurrentSet)
{
throw DataReaderException.EnumeratorBroken();
}
// Move to the next result set
var hasMore = results.TryAdvanceToNextResultSet();
if (!hasMore)
{
yield break;
}
numResultSets--;
// Make sure the next set is what we expect (no preemption)
var nextSet = results.CurrentSet;
if (nextSet != currentSet + 1)
{
throw DataReaderException.EnumeratorBroken();
}
currentSet = nextSet;
// Enumerate, checking before each value to make sure we are still on the correct
// result set
var nextValues = results.AsEnumerable <T>(setup);
foreach (var value in nextValues)
{
if (currentSet != results.CurrentSet)
{
throw DataReaderException.EnumeratorBroken();
}
yield return(value);
}
}
}
public DataRecordMappingEnumerable(IDataResultsBase results, IDataReaderAsync reader, IExecutionContext context, Func <IDataRecord, T> map)
{
Argument.NotNull(reader, nameof(reader));
Argument.NotNull(context, nameof(context));
Argument.NotNull(map, nameof(map));
_results = results;
_reader = reader;
_context = context;
_map = map;
_currentSet = results.CurrentSet;
_readAttempts = 0;
}
/// <summary>
/// Get all output parameters as a single object, with each parameter being mapped to a
/// property with the same name (case invariant). Parameters will be mapped to property
/// types where possible. Otherwise default values will be assigned.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="results"></param>
/// <returns></returns>
public static T GetOutputParameters <T>(this IDataResultsBase results)
where T : class, new()
{
Argument.NotNull(results, nameof(results));
return(results.GetParameters().GetOutputParameters <T>());
}
/// <summary>
/// Get the value of the output parameter with the given name, attempting to convert it
/// to the specified type if possible. If conversion is not possible, an exception will
/// be thrown.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="results"></param>
/// <param name="name"></param>
/// <returns></returns>
public static T GetOutputParameterOrThrow <T>(this IDataResultsBase results, string name)
{
Argument.NotNull(results, nameof(results));
return(results.GetParameters().GetOutputParameterOrThrow <T>(name));
}
/// <summary>
/// Get the value of the output parameter with the given name
/// </summary>
/// <param name="results"></param>
/// <param name="name"></param>
/// <returns></returns>
public static object GetOutputParameterValue(this IDataResultsBase results, string name)
{
Argument.NotNull(results, nameof(results));
return(results.GetParameters().GetValue(name));
}
/// <summary>
/// Try to advance to the next result set, returning false if the exception fails
/// </summary>
/// <param name="results"></param>
/// <returns></returns>
public static bool TryAdvanceToNextResultSet(this IDataResultsBase results)
{
Argument.NotNull(results, nameof(results));
return(results.TryAdvanceToResultSet(results.CurrentSet + 1));
}
/// <summary>
/// Iterate through all remaining rows in all remaining result sets and map them all to
/// objects of the same type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="results"></param>
/// <param name="setup"></param>
/// <returns></returns>
public static IEnumerable <T> AsEnumerableAll <T>(this IDataResultsBase results, Action <IMapCompilerSettings> setup = null)
{
return(AsEnumerableNextSeveral <T>(results, int.MaxValue, setup));
}
/// <summary>
/// Advance to the next result set and map it to an enumerable of objects using the given mapping
/// compiler and options.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="results"></param>
/// <param name="setup"></param>
/// <returns></returns>
public static IEnumerable <T> GetNextEnumerable <T>(this IDataResultsBase results, Action <IMapCompilerSettings> setup = null)
{
Argument.NotNull(results, nameof(results));
return(results.AdvanceToNextResultSet().AsEnumerable <T>(setup));
}
