9343360009

Committed 26 May 2024 02:03PM UTC coverage: 82.867% (-0.1%) from 82.999%

Build # 9343360009

Build Type

push

github

Committed by

web-flow

Commit Message

Housecleaning  (#1108)

* Housecleaning - step 1

* More small fixes

Run Details

863 of 1189 branches covered (72.58%)

Branch coverage included in aggregate %.

29 of 34 new or added lines in 23 files covered. (85.29%)

6 existing lines in 2 files now uncovered.

3224 of 3743 relevant lines covered (86.13%)

81.64 hits per line

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

84.19

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

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

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 7 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;

        // If we came this far and it is readonly collection
        // it means that the collection was already initialized
        // that is not a valid operation
        ThrowIfReadonlyCollection(instance);

        foreach (var property in GetAllProperties(instance.GetType().GetTypeInfo()))
            BindProperty(property, instance, configuration);
    }

    private static void ThrowIfReadonlyCollection(object? instance)
    {
        var typ = instance?.GetType()!;

        if (FindOpenGenericInterface(typeof(IEnumerable<>), typ) != null)
        {
            throw new InvalidOperationException("Read-only collections cannot be initialized and needs to be nullable!");
        }

        if (FindOpenGenericInterface(typeof(IReadOnlyCollection<>), typ) != null)
        {
            throw new InvalidOperationException("Read-only collections cannot be initialized and needs to be nullable!");
        }
    }

    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 var convertedValue, out var 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(
                valueType,
                null,
                child);
            if (item == null) continue;
            if (keyType == typeof(string))
            {
                var key = child.Key;
                setter.SetValue(dictionary, item, [key]);
            }
            else if (keyTypeIsEnum)
            {
                var key = Convert.ToInt32(Enum.Parse(keyType, child.Key), CultureInfo.InvariantCulture);
                setter.SetValue(dictionary, item, [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(
                    itemType,
                    null,
                    section);
                if (item != null) addMethod.Invoke(collection, [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 (var i = 0; i < children.Length; i++)
            try
            {
                var item = BindInstance(
                    elementType,
                    null,
                    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

        try
        {
            result = ActivatorUtilities.CreateInstance(_provider, type, value);
        }
        catch (Exception e)
        {
            throw new InvalidOperationException($"Failed to convert from string to type {type.FullName}, please check you have one string in constructor!", e);
        }

        return true;
    }

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

        return actualTypeInfo.ImplementedInterfaces.FirstOrDefault(interfaceType =>
            interfaceType.GetTypeInfo().IsGenericType && interfaceType.GetGenericTypeDefinition() == expected);
    }

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

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

        return allProperties;
    }
}

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

net-daemon / netdaemon / 9343360009

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