Connected.Components/Utilities/BindingConverters/Converter.cs

using System.Globalization;

namespace Connected;

public class Converter<TSourceType, TDestinationType>
{
	public event EventHandler<string?>? ErrorOccured;

	/// <summary>
	/// The culture info being used for decimal points, date and time format, etc.
	/// </summary>
	public CultureInfo Culture { get; set; } = Converters.DefaultCulture;

	public TDestinationType? Convert(TSourceType value)
	{
		try
		{
			return ConvertValue(value);
		}
		catch (Exception e)
		{
			TriggerError($"Conversion from {typeof(TSourceType).Name} to {typeof(TDestinationType).Name} failed: {e.Message}", e);
		}

		return default;
	}

	protected virtual TDestinationType? ConvertValue(TSourceType? value)
	{
		return default;
	}

	public TSourceType? ConvertBack(TDestinationType value)
	{
		try
		{
			return ConvertValueBack(value);
		}
		catch (Exception e)
		{
			TriggerError($"Conversion from {typeof(TDestinationType).Name} to {typeof(TSourceType).Name} failed: {e.Message}", e);
		}

		return default;
	}

	protected virtual TSourceType? ConvertValueBack(TDestinationType? value)
	{
		return default;
	}

	protected void TriggerError(string? msg, Exception? e = null)
	{
		ErrorOccured?.Invoke(this, msg);

		OnErrorOccured(msg, e);
	}

	protected virtual void OnErrorOccured(string? msg, Exception? e)
	{

	}
}

/// <summary>
/// Converts values using the supplied lambda functions.
/// </summary>
/// <typeparam name="TSourceType">The source type</typeparam>
/// <typeparam name="TDestinationType">The destination type</typeparam>
public class LambdaConverter<TSourceType, TDestinationType> : Converter<TSourceType, TDestinationType>
{
	private readonly Func<TSourceType, TDestinationType?>? _convertFunction;
	private readonly Func<TDestinationType, TSourceType?>? _convertBackFunction;

	public LambdaConverter(Func<TSourceType, TDestinationType?>? convertFunction = null, Func<TDestinationType, TSourceType?>? convertBackFunction = null)
	{
		_convertFunction = convertFunction;
		_convertBackFunction = convertBackFunction;
	}

	protected override TDestinationType? ConvertValue(TSourceType? value)
	{
		if (_convertFunction is null)
			return base.ConvertValue(value);

		return _convertFunction.Invoke(value);
	}

	protected override TSourceType? ConvertValueBack(TDestinationType? value)
	{
		if (_convertFunction is null)
			return base.ConvertValueBack(value);

		return _convertBackFunction.Invoke(value);
	}
}

/// <summary>
/// Converter from T to string
///
/// Set converts to string
/// Get converts from string
/// </summary>
public class ToStringConverter<T> : Converter<T, string>
{

	/// <summary>
	/// Custom Format to be applied on bidirectional way.
	/// </summary>
	public string? Format { get; set; } = null;
}