1644285159

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/net-daemon/netdaemon/commit/<a class=hub.com/net-daemon/netdaemon/commit/a7170c5f4bf3873398ef8a8a2f7e85c29b0f15d4">a7170c5f4<a href="https://github.com/net-daemon/netdaemon/commit/a7170c5f4bf3873398ef8a8a2f7e85c29b0f15d4">">Merge </a><a class="double-link" href="https://github.com/net-daemon/netdaemon/commit/<a class="double-link" href="https://github.com/net-daemon/netdaemon/commit/cf0bf69031e980063e29d6aabd88215b08cfe9b2">cf0bf6903</a>">cf0bf6903</a><a href="https://github.com/net-daemon/netdaemon/commit/a7170c5f4bf3873398ef8a8a2f7e85c29b0f15d4"> into be3fac486">be3fac486</a>

Pull Request Pull Request #566: Added AssemblyResolver instead of advanced type resolvers

Run Details

1310 of 2505 branches covered (52.3%)

Branch coverage included in aggregate %.

134 of 134 new or added lines in 9 files covered. (100.0%)

4461 of 6638 relevant lines covered (67.2%)

88.14 hits per line

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

84.56

/src/AppModel/NetDaemon.AppModel/Internal/Config/ConfigurationBinding.cs

using Microsoft.Extensions.Configuration;
using System.ComponentModel;
using System.Reflection;

namespace NetDaemon.AppModel.Internal.Config;

internal interface IConfigurationBinding
{
    T? ToObject<T>(IConfiguration configuration);
}

/// <summary>
/// Class that allows binding strongly typed objects to configuration values.
/// </summary>
/// <remarks>
/// This is a scaled down and modified version of .NET 6 implementation.
/// </remarks>
internal class ConfigurationBinding : IConfigurationBinding
{
    private readonly IServiceProvider _provider;

    public ConfigurationBinding(IServiceProvider provider)
    {
        _provider = provider;
    }

    /// <summary>
    /// Attempts to bind the configuration instance to a new instance of type T.
    /// If  configuration section has a value, that will be used.
    /// Otherwise binding by matching property names against configuration keys recursively.
    /// </summary>
    /// <typeparam name="T">The type of the new instance to bind.</typeparam>
    /// <param name="configuration">The configuration instance to bind.</param>
    /// <returns>The new instance of T if successful, default(T) otherwise.</returns>
    public T? ToObject<T>(IConfiguration configuration)
    {
        var result = GetObject(configuration, typeof(T));
        if (result == null)
        {
            return default;
        }
        return (T)result;
    }

    /// <summary>
    /// Attempts to bind the configuration instance to a new instance of type T.
    /// If  configuration section has a value, that will be used.
    /// Otherwise binding by matching property names against configuration keys recursively.
    /// </summary>
    /// <param name="configuration">The configuration instance to bind.</param>
    /// <param name="type">The type of the new instance to bind.</param>
    /// <returns>The new instance if successful, null otherwise.</returns>
    private object? GetObject(IConfiguration configuration, Type type)
    {
        return BindInstance(type, null, configuration);
    }

    private void BindNonScalar(IConfiguration configuration, object? instance)
    {
        if (instance == null) return;
        foreach (var property in GetAllProperties(instance.GetType().GetTypeInfo()))
        {
            BindProperty(property, instance, configuration);
        }
    }

    private void BindProperty(PropertyInfo property, object? instance, IConfiguration config)
    {
        // We don't support set only, non public, or indexer properties
        if (property.GetMethod?.IsPublic != true ||
            property.GetMethod.GetParameters().Length > 0)
        {
            return;
        }

        var propertyValue = property.GetValue(instance);
        var hasSetter = property.SetMethod?.IsPublic == true;

        if (propertyValue == null && !hasSetter)
        {
            // Property doesn't have a value and we cannot set it so there is no
            // point in going further down the graph
            return;
        }

        propertyValue = BindInstance(property.PropertyType, propertyValue, config.GetSection(property.Name));

        if (propertyValue != null && hasSetter)
        {
            property.SetValue(instance, propertyValue);
        }
    }

    private object BindToCollection(TypeInfo typeInfo, IConfiguration config)
    {
        var type = typeof(List<>).MakeGenericType(typeInfo.GenericTypeArguments[0]);
        var instance = Activator.CreateInstance(type) ??
            throw new InvalidOperationException();
        BindCollection(instance, type, config);
        return instance;
    }

    // Try to create an array/dictionary instance to back various collection interfaces
    private object? AttemptBindToCollectionInterfaces(Type type, IConfiguration config)
    {
        var typeInfo = type.GetTypeInfo();

        if (!typeInfo.IsInterface)
        {
            return null;
        }

        var collectionInterface = FindOpenGenericInterface(typeof(IReadOnlyList<>), type);
        if (collectionInterface != null)
        {
            // IEnumerable<T> is guaranteed to have exactly one parameter
            return BindToCollection(typeInfo, config);
        }

        collectionInterface = FindOpenGenericInterface(typeof(IReadOnlyDictionary<,>), type);
        if (collectionInterface != null)
        {
            var dictionaryType = typeof(Dictionary<,>).MakeGenericType(typeInfo.GenericTypeArguments[0], typeInfo.GenericTypeArguments[1]);
            var instance = Activator.CreateInstance(dictionaryType);
            BindDictionary(instance, dictionaryType, config);
            return instance;
        }

        collectionInterface = FindOpenGenericInterface(typeof(IDictionary<,>), type);
        if (collectionInterface != null)
        {
            var instance = Activator.CreateInstance(typeof(Dictionary<,>).MakeGenericType(typeInfo.GenericTypeArguments[0], typeInfo.GenericTypeArguments[1]));
            BindDictionary(instance, collectionInterface, config);
            return instance;
        }

        collectionInterface = FindOpenGenericInterface(typeof(IReadOnlyCollection<>), type);
        if (collectionInterface != null)
        {
            // IReadOnlyCollection<T> is guaranteed to have exactly one parameter
            return BindToCollection(typeInfo, config);
        }

        collectionInterface = FindOpenGenericInterface(typeof(ICollection<>), type);
        if (collectionInterface != null)
        {
            // ICollection<T> is guaranteed to have exactly one parameter
            return BindToCollection(typeInfo, config);
        }

        collectionInterface = FindOpenGenericInterface(typeof(IEnumerable<>), type);
        return collectionInterface != null ? BindToCollection(typeInfo, config) : null;
    }

    private object? BindInstance(Type type, object? instance, IConfiguration config)
    {
        // if binding IConfigurationSection, break early
        if (type == typeof(IConfigurationSection))
        {
            return config;
        }

        var section = config as IConfigurationSection;
        var configValue = section?.Value;
        if (configValue != null && TryConvertValue(type, configValue, out object? convertedValue, out Exception? error))
        {
            if (error != null)
            {
                throw error;
            }

            // Leaf nodes are always reinitialized
            return convertedValue;
        }

        if (config.GetChildren().Any() != true) return instance;

        // If we don't have an instance, try to create one
        if (instance == null)
        {
            // We are already done if binding to a new collection instance worked
            instance = AttemptBindToCollectionInterfaces(type, config);
            if (instance != null)
            {
                return instance;
            }

            instance = CreateInstance(type);
        }

        // See if its a Dictionary
        var collectionInterface = FindOpenGenericInterface(typeof(IDictionary<,>), type);
        if (collectionInterface != null)
        {
            BindDictionary(instance, collectionInterface, config);
        }
        else if (type.IsArray)
        {
            instance = BindArray((Array)instance, config);
        }
        else
        {
            // See if its an ICollection
            collectionInterface = FindOpenGenericInterface(typeof(ICollection<>), type);
            if (collectionInterface != null)
            {
                BindCollection(instance, collectionInterface, config);
            }
            // Something else
            else
            {
                BindNonScalar(config, instance);
            }
        }

        return instance;
    }

    private static object CreateInstance(Type type)
    {
        var typeInfo = type.GetTypeInfo();

        if (typeInfo.IsInterface || typeInfo.IsAbstract)
        {
            throw new InvalidOperationException();
        }

        if (type.IsArray)
        {
            if (typeInfo.GetArrayRank() > 1)
            {
                throw new InvalidOperationException();
            }
            var typ = typeInfo.GetElementType()!;
            return Array.CreateInstance(typ, 0);
        }

        var hasDefaultConstructor = typeInfo.DeclaredConstructors.Any(ctor => ctor.IsPublic && ctor.GetParameters().Length == 0);
        if (!hasDefaultConstructor)
        {
            throw new InvalidOperationException();
        }

        try
        {
            return Activator.CreateInstance(type)!;
        }
        catch (Exception)
        {
            throw new InvalidOperationException();
        }
    }

    private void BindDictionary(object? dictionary, Type dictionaryType, IConfiguration config)
    {
        var typeInfo = dictionaryType.GetTypeInfo();

        // IDictionary<K,V> is guaranteed to have exactly two parameters
        var keyType = typeInfo.GenericTypeArguments[0];
        var valueType = typeInfo.GenericTypeArguments[1];
        var keyTypeIsEnum = keyType.GetTypeInfo().IsEnum;

        if (keyType != typeof(string) && !keyTypeIsEnum)
        {
            // We only support string and enum keys
            return;
        }

        var setter = typeInfo.GetDeclaredProperty("Item") ??
            throw new InvalidOperationException();

        foreach (var child in config.GetChildren())
        {
            var item = BindInstance(
                type: valueType,
                instance: null,
                config: child);
            if (item == null) continue;
            if (keyType == typeof(string))
            {
                var key = child.Key;
                setter.SetValue(dictionary, item, new object[] { key });
            }
            else if (keyTypeIsEnum)
            {
                var key = Convert.ToInt32(Enum.Parse(keyType, child.Key));
                setter.SetValue(dictionary, item, new object[] { key });
            }
        }
    }

    private void BindCollection(object collection, Type collectionType, IConfiguration config)
    {
        var typeInfo = collectionType.GetTypeInfo();

        // ICollection<T> is guaranteed to have exactly one parameter
        var itemType = typeInfo.GenericTypeArguments[0];
        var addMethod = typeInfo.GetDeclaredMethod("Add") ??
            throw new InvalidOperationException();

        foreach (var section in config.GetChildren())
        {
            try
            {
                var item = BindInstance(
                    type: itemType,
                    instance: null,
                    config: section);
                if (item != null)
                {
                    addMethod.Invoke(collection, new[] { item });
                }
            }
            catch
            {
                // ignored
            }
        }
    }

    private Array BindArray(Array source, IConfiguration config)
    {
        var children = config.GetChildren().ToArray();
        var arrayLength = source.Length;
        var elementType = source.GetType().GetElementType() ??
            throw new InvalidOperationException();

        var newArray = Array.CreateInstance(elementType, arrayLength + children.Length);

        // binding to array has to preserve already initialized arrays with values
        if (arrayLength > 0)
        {
            Array.Copy(source, newArray, arrayLength);
        }

        for (int i = 0; i < children.Length; i++)
        {
            try
            {
                var item = BindInstance(
                    type: elementType,
                    instance: null,
                    config: children[i]);
                if (item != null)
                {
                    newArray.SetValue(item, arrayLength + i);
                }
            }
            catch
            {
                // ignored
            }
        }

        return newArray;
    }

    private bool TryConvertValue(Type type, string value, out object? result, out Exception? error)
    {
        error = null;
        result = null;
        if (type == typeof(object))
        {
            result = value;
            return true;
        }

        if (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            if (string.IsNullOrEmpty(value))
            {
                return true;
            }
            var typ = Nullable.GetUnderlyingType(type) ??
                throw new InvalidOperationException();

            return TryConvertValue(typ, value, out result, out error);
        }
        var converter = TypeDescriptor.GetConverter(type);
        if (converter.CanConvertFrom(typeof(string)))
        {
            try
            {
                result = converter.ConvertFromInvariantString(value);
            }
            catch (Exception)
            {
                error = new InvalidOperationException();
            }
            return true;
        }

        // No standard converter is available so lets´s try find
        // a registered service that converts to the type from string

        // Construct ´Converter<T, string>´
        var genConverterEmptyType = typeof(Converter<,>);
        Type[] typeArgs = { typeof(string), type };
        var converterType = genConverterEmptyType.MakeGenericType(typeArgs);

        if (_provider.GetService(converterType) is not Converter<string, object> conv)
            return false;

        result = conv(value);

        return true;
    }

    private static Type? FindOpenGenericInterface(Type expected, Type actual)
    {
        var actualTypeInfo = actual.GetTypeInfo();
        if (actualTypeInfo.IsGenericType &&
            actual.GetGenericTypeDefinition() == expected)
        {
            return actual;
        }

        foreach (var interfaceType in actualTypeInfo.ImplementedInterfaces)
        {
            if (interfaceType.GetTypeInfo().IsGenericType &&
                interfaceType.GetGenericTypeDefinition() == expected)
            {
                return interfaceType;
            }
        }
        return null;
    }

    private static IEnumerable<PropertyInfo> GetAllProperties(TypeInfo type)
    {
        var allProperties = new List<PropertyInfo>();

        TypeInfo currentType = type;
        do
        {
            allProperties.AddRange(currentType.DeclaredProperties);
            currentType = currentType.BaseType?.GetTypeInfo() ??
                throw new InvalidOperationException();
        }
        while (currentType != typeof(object).GetTypeInfo());

        return allProperties;
    }
}

1	using Microsoft.Extensions.Configuration;
2	using System.ComponentModel;
3	using System.Reflection;
4
5	namespace NetDaemon.AppModel.Internal.Config;
6
7	internal interface IConfigurationBinding
8	{
9	T? ToObject<T>(IConfiguration configuration);
10	}
11
12	/// <summary>
13	/// Class that allows binding strongly typed objects to configuration values.
14	/// </summary>
15	/// <remarks>
16	/// This is a scaled down and modified version of .NET 6 implementation.
17	/// </remarks>
18	internal class ConfigurationBinding : IConfigurationBinding
19	{
20	private readonly IServiceProvider _provider;
21
22	public ConfigurationBinding(IServiceProvider provider)	20✔
23	{	20✔
24	_provider = provider;	20✔
25	}	20✔
26
27	/// <summary>
28	/// Attempts to bind the configuration instance to a new instance of type T.
29	/// If configuration section has a value, that will be used.
30	/// Otherwise binding by matching property names against configuration keys recursively.
31	/// </summary>
32	/// <typeparam name="T">The type of the new instance to bind.</typeparam>
33	/// <param name="configuration">The configuration instance to bind.</param>
34	/// <returns>The new instance of T if successful, default(T) otherwise.</returns>
35	public T? ToObject<T>(IConfiguration configuration)
36	{	20✔
37	var result = GetObject(configuration, typeof(T));	20✔
38	if (result == null)	15!
39	{	×
40	return default;	×
41	}
42	return (T)result;	15✔
43	}	15✔
44
45	/// <summary>
46	/// Attempts to bind the configuration instance to a new instance of type T.
47	/// If configuration section has a value, that will be used.
48	/// Otherwise binding by matching property names against configuration keys recursively.
49	/// </summary>
50	/// <param name="configuration">The configuration instance to bind.</param>
51	/// <param name="type">The type of the new instance to bind.</param>
52	/// <returns>The new instance if successful, null otherwise.</returns>
53	private object? GetObject(IConfiguration configuration, Type type)
54	{	20✔
55	return BindInstance(type, null, configuration);	20✔
56	}	15✔
57
58	private void BindNonScalar(IConfiguration configuration, object? instance)
59	{	8✔
60	if (instance == null) return;	8✔
61	foreach (var property in GetAllProperties(instance.GetType().GetTypeInfo()))	62✔
62	{	19✔
63	BindProperty(property, instance, configuration);	19✔
64	}	19✔
65	}	8✔
66
67	private void BindProperty(PropertyInfo property, object? instance, IConfiguration config)
68	{	19✔
69	// We don't support set only, non public, or indexer properties
70	if (property.GetMethod?.IsPublic != true \|\|	19!
71	property.GetMethod.GetParameters().Length > 0)	19✔
72	{	1✔
73	return;	1✔
74	}
75
76	var propertyValue = property.GetValue(instance);	18✔
77	var hasSetter = property.SetMethod?.IsPublic == true;	18!
78
79	if (propertyValue == null && !hasSetter)	18!
80	{	×
81	// Property doesn't have a value and we cannot set it so there is no
82	// point in going further down the graph
83	return;	×
84	}
85
86	propertyValue = BindInstance(property.PropertyType, propertyValue, config.GetSection(property.Name));	18✔
87
88	if (propertyValue != null && hasSetter)	18✔
89	{	15✔
90	property.SetValue(instance, propertyValue);	15✔
91	}	15✔
92	}	19✔
93
94	private object BindToCollection(TypeInfo typeInfo, IConfiguration config)
95	{	9✔
96	var type = typeof(List<>).MakeGenericType(typeInfo.GenericTypeArguments[0]);	9✔
97	var instance = Activator.CreateInstance(type) ??	9!
98	throw new InvalidOperationException();	9✔
99	BindCollection(instance, type, config);	9✔
100	return instance;	9✔
101	}	9✔
102
103	// Try to create an array/dictionary instance to back various collection interfaces
104	private object? AttemptBindToCollectionInterfaces(Type type, IConfiguration config)
105	{	31✔
106	var typeInfo = type.GetTypeInfo();	31✔
107
108	if (!typeInfo.IsInterface)	31✔
109	{	14✔
110	return null;	14✔
111	}
112
113	var collectionInterface = FindOpenGenericInterface(typeof(IReadOnlyList<>), type);	17✔
114	if (collectionInterface != null)	17✔
115	{	1✔
116	// IEnumerable<T> is guaranteed to have exactly one parameter
117	return BindToCollection(typeInfo, config);	1✔
118	}
119
120	collectionInterface = FindOpenGenericInterface(typeof(IReadOnlyDictionary<,>), type);	16✔
121	if (collectionInterface != null)	16✔
122	{	1✔
123	var dictionaryType = typeof(Dictionary<,>).MakeGenericType(typeInfo.GenericTypeArguments[0], typeInfo.GenericTypeArguments[1]);	1✔
124	var instance = Activator.CreateInstance(dictionaryType);	1✔
125	BindDictionary(instance, dictionaryType, config);	1✔
126	return instance;	1✔
127	}
128
129	collectionInterface = FindOpenGenericInterface(typeof(IDictionary<,>), type);	15✔
130	if (collectionInterface != null)	15✔
131	{	6✔
132	var instance = Activator.CreateInstance(typeof(Dictionary<,>).MakeGenericType(typeInfo.GenericTypeArguments[0], typeInfo.GenericTypeArguments[1]));	6✔
133	BindDictionary(instance, collectionInterface, config);	6✔
134	return instance;	6✔
135	}
136
137	collectionInterface = FindOpenGenericInterface(typeof(IReadOnlyCollection<>), type);	9✔
138	if (collectionInterface != null)	9✔
139	{	1✔
140	// IReadOnlyCollection<T> is guaranteed to have exactly one parameter
141	return BindToCollection(typeInfo, config);	1✔
142	}
143
144	collectionInterface = FindOpenGenericInterface(typeof(ICollection<>), type);	8✔
145	if (collectionInterface != null)	8✔
146	{	4✔
147	// ICollection<T> is guaranteed to have exactly one parameter
148	return BindToCollection(typeInfo, config);	4✔
149	}
150
151	collectionInterface = FindOpenGenericInterface(typeof(IEnumerable<>), type);	4✔
152	return collectionInterface != null ? BindToCollection(typeInfo, config) : null;	4✔
153	}	31✔
154
155	private object? BindInstance(Type type, object? instance, IConfiguration config)
156	{	74✔
157	// if binding IConfigurationSection, break early
158	if (type == typeof(IConfigurationSection))	74!
159	{	×
160	return config;	×
161	}
162
163	var section = config as IConfigurationSection;	74✔
164	var configValue = section?.Value;	74!
165	if (configValue != null && TryConvertValue(type, configValue, out object? convertedValue, out Exception? error))	74✔
166	{	40✔
167	if (error != null)	40!
168	{	×
169	throw error;	×
170	}
171
172	// Leaf nodes are always reinitialized
173	return convertedValue;	40✔
174	}
175
176	if (config.GetChildren().Any() != true) return instance;	37✔
177
178	// If we don't have an instance, try to create one
179	if (instance == null)	31✔
180	{	31✔
181	// We are already done if binding to a new collection instance worked
182	instance = AttemptBindToCollectionInterfaces(type, config);	31✔
183	if (instance != null)	31✔
184	{	16✔
185	return instance;	16✔
186	}
187
188	instance = CreateInstance(type);	15✔
189	}	10✔
190
191	// See if its a Dictionary
192	var collectionInterface = FindOpenGenericInterface(typeof(IDictionary<,>), type);	10✔
193	if (collectionInterface != null)	10!
194	{	×
195	BindDictionary(instance, collectionInterface, config);	×
196	}	×
197	else if (type.IsArray)	10✔
198	{	1✔
199	instance = BindArray((Array)instance, config);	1✔
200	}	1✔
201	else
202	{	9✔
203	// See if its an ICollection
204	collectionInterface = FindOpenGenericInterface(typeof(ICollection<>), type);	9✔
205	if (collectionInterface != null)	9✔
206	{	1✔
207	BindCollection(instance, collectionInterface, config);	1✔
208	}	1✔
209	// Something else
210	else
211	{	8✔
212	BindNonScalar(config, instance);	8✔
213	}	8✔
214	}	9✔
215
216	return instance;	10✔
217	}	69✔
218
219	private static object CreateInstance(Type type)
220	{	15✔
221	var typeInfo = type.GetTypeInfo();	15✔
222
223	if (typeInfo.IsInterface \|\| typeInfo.IsAbstract)	15✔
224	{	2✔
225	throw new InvalidOperationException();	2✔
226	}
227
228	if (type.IsArray)	13✔
229	{	2✔
230	if (typeInfo.GetArrayRank() > 1)	2✔
231	{	1✔
232	throw new InvalidOperationException();	1✔
233	}
234	var typ = typeInfo.GetElementType()!;	1✔
235	return Array.CreateInstance(typ, 0);	1✔
236	}
237
238	var hasDefaultConstructor = typeInfo.DeclaredConstructors.Any(ctor => ctor.IsPublic && ctor.GetParameters().Length == 0);	23✔
239	if (!hasDefaultConstructor)	11✔
240	{	1✔
241	throw new InvalidOperationException();	1✔
242	}
243
244	try
245	{	10✔
246	return Activator.CreateInstance(type)!;	10✔
247	}
248	catch (Exception)	1✔
249	{	1✔
250	throw new InvalidOperationException();	1✔
251	}
252	}	10✔
253
254	private void BindDictionary(object? dictionary, Type dictionaryType, IConfiguration config)
255	{	7✔
256	var typeInfo = dictionaryType.GetTypeInfo();	7✔
257
258	// IDictionary<K,V> is guaranteed to have exactly two parameters
259	var keyType = typeInfo.GenericTypeArguments[0];	7✔
260	var valueType = typeInfo.GenericTypeArguments[1];	7✔
261	var keyTypeIsEnum = keyType.GetTypeInfo().IsEnum;	7✔
262
263	if (keyType != typeof(string) && !keyTypeIsEnum)	7✔
264	{	1✔
265	// We only support string and enum keys
266	return;	1✔
267	}
268
269	var setter = typeInfo.GetDeclaredProperty("Item") ??	6!
270	throw new InvalidOperationException();	6✔
271
272	foreach (var child in config.GetChildren())	44✔
273	{	13✔
274	var item = BindInstance(	13✔
275	type: valueType,	13✔
276	instance: null,	13✔
277	config: child);	13✔
278	if (item == null) continue;	13✔
279	if (keyType == typeof(string))	13!
280	{	13✔
281	var key = child.Key;	13✔
282	setter.SetValue(dictionary, item, new object[] { key });	13✔
283	}	13✔
284	else if (keyTypeIsEnum)	×
285	{	×
286	var key = Convert.ToInt32(Enum.Parse(keyType, child.Key));	×
287	setter.SetValue(dictionary, item, new object[] { key });	×
288	}	×
289	}	13✔
290	}	7✔
291
292	private void BindCollection(object collection, Type collectionType, IConfiguration config)
293	{	10✔
294	var typeInfo = collectionType.GetTypeInfo();	10✔
295
296	// ICollection<T> is guaranteed to have exactly one parameter
297	var itemType = typeInfo.GenericTypeArguments[0];	10✔
298	var addMethod = typeInfo.GetDeclaredMethod("Add") ??	10!
299	throw new InvalidOperationException();	10✔
300
301	foreach (var section in config.GetChildren())	72✔
302	{	21✔
303	try
304	{	21✔
305	var item = BindInstance(	21✔
306	type: itemType,	21✔
307	instance: null,	21✔
308	config: section);	21✔
309	if (item != null)	21✔
310	{	21✔
311	addMethod.Invoke(collection, new[] { item });	21✔
312	}	21✔
313	}	21✔
314	catch	×
315	{	×
316	// ignored
317	}	×
318	}	21✔
319	}	10✔
320
321	private Array BindArray(Array source, IConfiguration config)
322	{	1✔
323	var children = config.GetChildren().ToArray();	1✔
324	var arrayLength = source.Length;	1✔
325	var elementType = source.GetType().GetElementType() ??	1!
326	throw new InvalidOperationException();	1✔
327
328	var newArray = Array.CreateInstance(elementType, arrayLength + children.Length);	1✔
329
330	// binding to array has to preserve already initialized arrays with values
331	if (arrayLength > 0)	1!
332	{	×
333	Array.Copy(source, newArray, arrayLength);	×
334	}	×
335
336	for (int i = 0; i < children.Length; i++)	6✔
337	{	2✔
338	try
339	{	2✔
340	var item = BindInstance(	2✔
341	type: elementType,	2✔
342	instance: null,	2✔
343	config: children[i]);	2✔
344	if (item != null)	2✔
345	{	2✔
346	newArray.SetValue(item, arrayLength + i);	2✔
347	}	2✔
348	}	2✔
349	catch	×
350	{	×
351	// ignored
352	}	×
353	}	2✔
354
355	return newArray;	1✔
356	}	1✔
357
358	private bool TryConvertValue(Type type, string value, out object? result, out Exception? error)
359	{	43✔
360	error = null;	43✔
361	result = null;	43✔
362	if (type == typeof(object))	43!
363	{	×
364	result = value;	×
365	return true;	×
366	}
367
368	if (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))	43!
369	{	×
370	if (string.IsNullOrEmpty(value))	×
371	{	×
372	return true;	×
373	}
374	var typ = Nullable.GetUnderlyingType(type) ??	×
375	throw new InvalidOperationException();	×
376
377	return TryConvertValue(typ, value, out result, out error);	×
378	}
379	var converter = TypeDescriptor.GetConverter(type);	43✔
380	if (converter.CanConvertFrom(typeof(string)))	43✔
381	{	39✔
382	try
383	{	39✔
384	result = converter.ConvertFromInvariantString(value);	39✔
385	}	39✔
386	catch (Exception)	×
387	{	×
388	error = new InvalidOperationException();	×
389	}	×
390	return true;	39✔
391	}
392
393	// No standard converter is available so lets´s try find
394	// a registered service that converts to the type from string
395
396	// Construct ´Converter<T, string>´
397	var genConverterEmptyType = typeof(Converter<,>);	4✔
398	Type[] typeArgs = { typeof(string), type };	4✔
399	var converterType = genConverterEmptyType.MakeGenericType(typeArgs);	4✔
400
401	if (_provider.GetService(converterType) is not Converter<string, object> conv)	4✔
402	return false;	3✔
403
404	result = conv(value);	1✔
405
406	return true;	1✔
407	}	43✔
408
409	private static Type? FindOpenGenericInterface(Type expected, Type actual)
410	{	88✔
411	var actualTypeInfo = actual.GetTypeInfo();	88✔
412	if (actualTypeInfo.IsGenericType &&	88✔
413	actual.GetGenericTypeDefinition() == expected)	88✔
414	{	16✔
415	return actual;	16✔
416	}
417
418	foreach (var interfaceType in actualTypeInfo.ImplementedInterfaces)	457✔
419	{	121✔
420	if (interfaceType.GetTypeInfo().IsGenericType &&	121✔
421	interfaceType.GetGenericTypeDefinition() == expected)	121✔
422	{	1✔
423	return interfaceType;	1✔
424	}
425	}	120✔
426	return null;	71✔
427	}	88✔
428
429	private static IEnumerable<PropertyInfo> GetAllProperties(TypeInfo type)
430	{	8✔
431	var allProperties = new List<PropertyInfo>();	8✔
432
433	TypeInfo currentType = type;	8✔
434	do
435	{	8✔
436	allProperties.AddRange(currentType.DeclaredProperties);	8✔
437	currentType = currentType.BaseType?.GetTypeInfo() ??	8!
438	throw new InvalidOperationException();	8✔
439	}	8✔
440	while (currentType != typeof(object).GetTypeInfo());	8✔
441
442	return allProperties;	8✔
443	}	8✔
444	}

net-daemon / netdaemon / 1644285159

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