26601445198

Committed 28 May 2026 08:50PM UTC coverage: 55.738% (+0.1%) from 55.595%

Build # 26601445198

Build Type

push

github

Committed by

pwelter34

Commit Message

Normalize enums and add enum data readers

Coverage Stats

1381 of 3245 branches covered (42.56%)

Branch coverage included in aggregate %.

38 of 58 new or added lines in 7 files covered. (65.52%)

3 existing lines in 1 file now uncovered.

4438 of 7195 relevant lines covered (61.68%)

311.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.86

/src/FluentCommand/DataParameterHandlers.cs

using System.Collections.Concurrent;
using System.Data.Common;

using FluentCommand.Extensions;
using FluentCommand.Handlers;

namespace FluentCommand;

/// <summary>
/// Provides a registry for associating .NET types with custom data parameter handlers used to set database parameter values and types.
/// </summary>
/// <remarks>
/// This class enables registration and retrieval of type-specific handlers that control how values are
/// assigned to database parameters, supporting extensibility for custom or non-standard data types. Handlers can be
/// added for new types at runtime. Thread-safe for concurrent access.
/// </remarks>
public static class DataParameterHandlers
{
    private static readonly ConcurrentDictionary<Type, IDataParameterHandler> _dataTypeHandlers;

    static DataParameterHandlers()
    {
        _dataTypeHandlers = new ConcurrentDictionary<Type, IDataParameterHandler>();
        _dataTypeHandlers.TryAdd(typeof(ConcurrencyToken), new ConcurrencyTokenHandler());

#if NET6_0_OR_GREATER
        // once ADO supports DateOnly & TimeOnly, this can be removed
        _dataTypeHandlers.TryAdd(typeof(DateOnly), new DateOnlyHandler());
        _dataTypeHandlers.TryAdd(typeof(TimeOnly), new TimeOnlyHandler());
#endif
    }

    /// <summary>
    /// Adds the data type handler.
    /// </summary>
    /// <typeparam name="THandler">The type of the handler.</typeparam>
    public static void AddTypeHandler<THandler>()
        where THandler : IDataParameterHandler, new()
    {
        var handler = new THandler();
        AddTypeHandler(handler);
    }

    /// <summary>
    /// Adds the data type handler.
    /// </summary>
    /// <typeparam name="THandler">The type of the handler.</typeparam>
    /// <param name="handler">The handler.</param>
    public static void AddTypeHandler<THandler>(THandler handler)
        where THandler : IDataParameterHandler
    {
        _dataTypeHandlers.TryAdd(handler.ValueType, handler);
    }

    /// <summary>
    /// Gets the type handler for the specified <paramref name="type"/>.
    /// </summary>
    /// <param name="type">The type to get a handler for.</param>
    /// <returns>The <see cref="IDataParameterHandler"/> for the specified type; otherwise null if not found</returns>
    public static IDataParameterHandler? GetTypeHandler(Type type)
    {
        var underlyingType = type.GetUnderlyingType();
        return _dataTypeHandlers.TryGetValue(underlyingType, out var handler) ? handler : null;
    }


    /// <summary>
    /// Sets the Value and DbType on the specified <paramref name="parameter"/> using the registered type handlers.
    /// </summary>
    /// <param name="parameter">The parameter to set the value on.</param>
    /// <param name="value">The value to set.</param>
    /// <param name="type">The data type to use.</param>
    /// <remarks>
    /// Enum and nullable enum values are converted to their numeric underlying type before mapping.
    /// </remarks>
    public static void SetValue(DbParameter parameter, object? value, Type type)
    {
        var valueType = type.GetUnderlyingType();
        if (valueType.IsEnum)
        {
            valueType = Enum.GetUnderlyingType(valueType);
            if (value is not null && value != DBNull.Value)
                value = Convert.ChangeType(value, valueType);
        }

        var handler = GetTypeHandler(valueType);

        value ??= DBNull.Value;

        if (handler != null)
        {
            handler.SetValue(parameter, value);
            return;
        }

        parameter.Value = value;
        parameter.DbType = valueType.ToDbType();
    }
}

1	using System.Collections.Concurrent;
2	using System.Data.Common;
3
4	using FluentCommand.Extensions;
5	using FluentCommand.Handlers;
6
7	namespace FluentCommand;
8
9	/// <summary>
10	/// Provides a registry for associating .NET types with custom data parameter handlers used to set database parameter values and types.
11	/// </summary>
12	/// <remarks>
13	/// This class enables registration and retrieval of type-specific handlers that control how values are
14	/// assigned to database parameters, supporting extensibility for custom or non-standard data types. Handlers can be
15	/// added for new types at runtime. Thread-safe for concurrent access.
16	/// </remarks>
17	public static class DataParameterHandlers
18	{
19	private static readonly ConcurrentDictionary<Type, IDataParameterHandler> _dataTypeHandlers;
20
21	static DataParameterHandlers()
22	{
23	_dataTypeHandlers = new ConcurrentDictionary<Type, IDataParameterHandler>();	3✔
24	_dataTypeHandlers.TryAdd(typeof(ConcurrencyToken), new ConcurrencyTokenHandler());	3✔
25
26	#if NET6_0_OR_GREATER
27	// once ADO supports DateOnly & TimeOnly, this can be removed
28	_dataTypeHandlers.TryAdd(typeof(DateOnly), new DateOnlyHandler());	3✔
29	_dataTypeHandlers.TryAdd(typeof(TimeOnly), new TimeOnlyHandler());	3✔
30	#endif
31	}	3✔
32
33	/// <summary>
34	/// Adds the data type handler.
35	/// </summary>
36	/// <typeparam name="THandler">The type of the handler.</typeparam>
37	public static void AddTypeHandler<THandler>()
38	where THandler : IDataParameterHandler, new()
39	{
40	var handler = new THandler();	×
41	AddTypeHandler(handler);	×
42	}	×
43
44	/// <summary>
45	/// Adds the data type handler.
46	/// </summary>
47	/// <typeparam name="THandler">The type of the handler.</typeparam>
48	/// <param name="handler">The handler.</param>
49	public static void AddTypeHandler<THandler>(THandler handler)
50	where THandler : IDataParameterHandler
51	{
52	_dataTypeHandlers.TryAdd(handler.ValueType, handler);	×
53	}	×
54
55	/// <summary>
56	/// Gets the type handler for the specified <paramref name="type"/>.
57	/// </summary>
58	/// <param name="type">The type to get a handler for.</param>
59	/// <returns>The <see cref="IDataParameterHandler"/> for the specified type; otherwise null if not found</returns>
60	public static IDataParameterHandler? GetTypeHandler(Type type)
61	{
62	var underlyingType = type.GetUnderlyingType();	553✔
63	return _dataTypeHandlers.TryGetValue(underlyingType, out var handler) ? handler : null;	553✔
64	}
65
66
67	/// <summary>
68	/// Sets the Value and DbType on the specified <paramref name="parameter"/> using the registered type handlers.
69	/// </summary>
70	/// <param name="parameter">The parameter to set the value on.</param>
71	/// <param name="value">The value to set.</param>
72	/// <param name="type">The data type to use.</param>
73	/// <remarks>
74	/// Enum and nullable enum values are converted to their numeric underlying type before mapping.
75	/// </remarks>
76	public static void SetValue(DbParameter parameter, object? value, Type type)
77	{
78	var valueType = type.GetUnderlyingType();	542✔
79	if (valueType.IsEnum)	542!
80	{
NEW 81	valueType = Enum.GetUnderlyingType(valueType);	×
NEW 82	if (value is not null && value != DBNull.Value)	×
NEW 83	value = Convert.ChangeType(value, valueType);	×
84	}
85
86	var handler = GetTypeHandler(valueType);	542✔
87
88	value ??= DBNull.Value;	542✔
89
90	if (handler != null)	542✔
91	{
92	handler.SetValue(parameter, value);	4✔
93	return;	4✔
94	}
95
96	parameter.Value = value;	538✔
97	parameter.DbType = valueType.ToDbType();	538✔
98	}	538✔
99	}

loresoft / FluentCommand / 26601445198

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous