static byte[] NumToBytes <T>(string input, TryParseHandler <T> tryParse, Func <T, byte[]> converter, bool reverse)
{
var strs = input.Split(',', ' ', '\t', '\r', '\n').Where(str => !string.IsNullOrWhiteSpace(str)).ToList();
byte[] result = null;
for (var ctr = 0; ctr < strs.Count; ++ctr)
{
T value;
if (!tryParse(strs[ctr], out value))
{
return(null);
}
var bytes = converter(value);
if (reverse)
{
Array.Reverse(bytes);
}
if (result == null)
{
result = new byte[strs.Count * bytes.Length];
}
Array.Copy(bytes, 0, result, ctr * bytes.Length, bytes.Length);
}
return(result ?? new byte[0]);
}
private static T TryParse <T>(object v, int index, TryParseHandler <T> handler)
{
var result = default(T);
if (v == null)
{
return(result);
}
var data = v.ToString().Split(seporator);
if (data.Length != 3)
{
return(result);
}
if (index < 0 || index > 2)
{
return(result);
}
if (string.IsNullOrEmpty(data[index]))
{
return(result);
}
handler(data[index], out result);
return(result);
}
protected bool TryParseValues <T>(string key, TryParseHandler <T> handler, out T[] result)
where T : struct
{
result = null;
if (string.IsNullOrEmpty(key))
{
return(false);
}
if (!TryGetValue(key, out var values))
{
return(false);
}
var results = new List <T>();
foreach (var v in values)
{
if (handler(v, out var value))
{
results.Add(value);
}
}
if (!values.Length.Equals(results.Count))
{
return(false);
}
result = results.ToArray();
return(true);
}
public SwitchProperty(string key, string valueDescription, string description, TryParseHandler parser,
AssignHandler assigner)
{
this.key = key;
this.valueDescription = valueDescription;
this.description = description;
_parser = parser;
_assigner = assigner;
}
public static TryParseHandler <T> GetTryParse()
{
if (tryParser == null)
{
tryParser = GetTryParseMethod();
}
return(tryParser);
}
private T readOrCreateValue <T>(string key, T value, TryParseHandler <T> handler)
{
if (!(GetAppSettingValue(key) != null && handler(GetAppSettingValue(key), out value)))
{
SetAppSetting(key, value);
}
return(value);
}
private T GetAttribute <T>(XmlElement element, string attribute, TryParseHandler <T> handler)
{
T result;
if (!handler(element.GetAttribute(attribute), out result))
{
throw new XmlException("Invalid " + typeof(T).Name + " " + attribute + " for element " + element.Name + "!");
}
return(result);
}
private static T WaitForParse <T>(TryParseHandler <T> handler, string prompt, Func <T, bool> validator = null)
{
T output = default(T);
do
{
InputHelper.Prompt(prompt);
}while (!handler(Console.ReadLine(), out output) || !(validator != null ? validator(output) : true));
return(output);
}
private T GetAttribute <T>(XmlElement element, string attribute, TryParseHandler <T> handler, T defaultValue)
{
T result;
if (handler(element.GetAttribute(attribute), out result))
{
return(result);
}
return(defaultValue);
}
public static bool TryParse <T>(string sval, string name, out T val, TryParseHandler <T> handler) where T : struct
{
bool worked = handler(sval, out val);
if (!worked)
{
Console.WriteLine("Could not parse " + name + " value " + sval);
}
return(worked);
}
private T ParseValue <T>(TryParseHandler <T> handler, string value) where T : struct
{
if (handler(value, out T result))
{
return(result);
}
else
{
throw new ArgumentException();
}
}
private static bool Is <T>(string value, TryParseHandler <T> handler) where T : struct
{
if (string.IsNullOrEmpty(value))
{
return(false);
}
T result;
return(handler(value, out result));
}
/// <summary>
/// Either successfully parses the provided string value or returns specified default value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value">The string value to parse.</param>
/// <param name="tryParseHandler">The try parse handler.</param>
/// <param name="defaultValue">The default value.</param>
/// <returns>T.</returns>
public static T ParseOrDefault <T>(string?value, TryParseHandler <T> tryParseHandler, T defaultValue) where T : struct
{
T?result = StringUtility.Parse <T>(value, tryParseHandler);
if (result.HasValue)
{
return(result.Value);
}
return(defaultValue);
}
private T GetClaim <T>(string claimType, TryParseHandler <T> handler, T @default = default(T))
{
string value = User?.FindFirst(claimType)?.Value;
if (!handler(value, out T result))
{
return(@default);
}
return(result);
}
/// <summary>
/// Считывает с пользовательского интерфейса объект.
/// </summary>
/// <param name="message">Сообщение, которое надо напечатать пользователю.</param>
/// <param name="parse">Метод считывания TryParse, с помощью которого будет преобразована строка в объект.</param>
/// <typeparam name="T">Указывает, в какой тип надо преобразовывать объект.</typeparam>
/// <returns>Считанный объект от пользователя.</returns>
public static T GetNumber <T>(string message, TryParseHandler <T> parse)
{
while (true)
{
Console.Write(message);
if (parse(Console.ReadLine(), out T output))
{
return(output);
}
Console.WriteLine($"\"{output}\" не может быть прочитан с помощью {parse.Method}");
}
}
public static T?TryParse <T>(string value, TryParseHandler <T> handler) where T : struct
{
if (string.IsNullOrEmpty(value))
{
return(null);
}
if (handler(value, out T result))
{
return(result);
}
return(null);
}
public static bool FindParseSuccess <T>(IEnumerable <object> array, TryParseHandler <T> tryParse)
{
foreach (object item in array)
{
T v;
if (!tryParse(item.ToString(), out v))
{
return(false);
}
}
return(true);
}
internal static T TryParseWithDefault <T>(this String value, T defaultValue, TryParseHandler <T> handler)
{
if (String.IsNullOrEmpty(value))
{
return(defaultValue);
}
T result;
return((handler(value, out result))
? result
: defaultValue);
}
protected bool TryParseValue <T>(string key, TryParseHandler <T> handler, out T result)
where T : struct
{
result = default;
if (string.IsNullOrEmpty(key))
{
return(false);
}
if (!TryGetValue(key, out var values))
{
return(false);
}
return(values.Length.Equals(1) && handler(values[0], out result));
}
public static T TryParse <T>(this string s, TryParseHandler <T> handler) where T : struct
{
if (string.IsNullOrEmpty(s))
{
return(default(T));
}
T temp;
if (handler(s, out temp))
{
return(temp);
}
return(default(T));
}
// TODO: add GetRequiredConfigOption which will throw if it is null or empty
public T GetConfigOption <T>(string json, TryParseHandler <T> handler)
{
if (string.IsNullOrEmpty(_config[json]))
{
return(default(T));
}
if (handler(_config[json], out T parsed))
{
return(parsed);
}
return(default(T));
}
private static TypeDonnees Read <TypeDonnees>(TextReader p_tr, TryParseHandler <TypeDonnees> p_handler)
{
string str = Console.In.ReadLine();
TypeDonnees parsedValue = default(TypeDonnees);
if (!p_handler(str, out parsedValue))
{
string methodName = (new StackTrace()).GetFrame(1).GetMethod().Name;
Console.Error.WriteLine($"Impossible de lire le type demandé par la méthode {methodName} !");
Environment.Exit(1);
}
return(parsedValue);
}
public static T TryParse <T>(string value, TryParseHandler <T> handler) where T : struct
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
T result;
if (string.IsNullOrEmpty(value) == false && handler(value, out result))
{
return(result);
}
return(default(T));
}
protected T TryParse <T>(string value, TryParseHandler <T> handler)
{
if (string.IsNullOrEmpty(value))
{
return(default(T));
}
T result;
if (handler(value, out result))
{
return(result);
}
Trace.TraceWarning("Invalid value '{0}'", value);
return(default(T));
}
//http://stackoverflow.com/questions/2961656/generic-tryparse
//Turns the common bool TryParse(string,out T) into a function that returns nullable types.
public static T?TryParse <T>(string value, TryParseHandler <T> handler) where T : struct
{
if (String.IsNullOrEmpty(value))
{
return(null);
}
T result;
if (handler(value, out result))
{
return(result);
}
//Trace.TraceWarning("Invalid value '{0}'", value);
return(null);
}
/// <summary>
/// Either successfully parses the provided string value or returns null.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value">The string value to parse.</param>
/// <param name="tryParseHandler">The try parse handler.</param>
/// <returns>System.Nullable<T>.</returns>
public static T?Parse <T>(string?value, TryParseHandler <T> tryParseHandler) where T : struct
{
if (string.IsNullOrEmpty(value))
{
return(null);
}
if (tryParseHandler(value, out T result))
{
return(result);
}
traceSource.TraceEvent(TraceEventType.Warning, 0, $"Invalid value '{value}'");
return(null);
}
static private TryParseHandler <T> TryGetTryParseHandler <T>(Type t)
{
MemberInfo[] members;
members = t.GetMember("TryParse", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.InvokeMethod);
foreach (MethodInfo mi in members)
{
ParameterInfo[] parameters = mi.GetParameters();
if (parameters[0].ParameterType == typeof(string) &&
parameters[1].ParameterType.FullName == typeof(T).FullName + "&")
{
TryParseHandler <T> parseHandler = (TryParseHandler <T>)Delegate.CreateDelegate(typeof(TryParseHandler <T>), mi);
return((TryParseHandler <T>)parseHandler);
}
}
return(null);
}
private T TryParseValue <T>(XmlNode targetNode, TryParseHandler <T> tryParseHandler)
{
if (string.IsNullOrWhiteSpace(targetNode.InnerText))
{
throw new Exception(
$"XML configuration is invalid: node '{targetNode.LocalName}' must have value.");
}
if (tryParseHandler(targetNode.InnerText, out var valueResult))
{
return(valueResult);
}
throw new Exception(
$"XML configuration is invalid: node '{targetNode.LocalName}' must have type '{typeof(T).FullName}'");
}
private static T GenericTo <T>(object input, T defaultValue, TryParseHandler <T> tryParseMethod)
{
if (input is T t)
{
return(t);
}
if (input == null)
{
return(defaultValue);
}
if (tryParseMethod(input.ToStringSafe(string.Empty), out var parsed))
{
return(parsed);
}
return(defaultValue);
}
void TryStringConversion <T>(ref object obj, TryParseHandler <T> tryParse)
{
if (!(obj is string))
{
return;
}
T value;
if (!tryParse(obj as string, out value))
{
return;
}
obj = value;
}
