/// <summary>
/// Given type is Nullable{T}, get type {T}
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Type GetNullableBaseType(this Type type)
{
Expect.IsNotNull(type, nameof(type));
Expect.That(type.IsNullableType(), string.Format(FrameworkStrings.ErrorTypeNotNullable, type.FullName));
return(type.GetGenericArguments()[0]);
}
/// <summary>
/// Check if member has specified attribute
/// </summary>
/// <param name="member"></param>
/// <param name="attrType"></param>
/// <returns></returns>
public static bool HasAttribute(this MemberInfo member, Type attrType)
{
Expect.IsNotNull(member, nameof(member));
Expect.IsNotNull(attrType, nameof(attrType));
return(member.GetCustomAttribute(attrType, true) != null);
}
/// <summary>
/// Convert value type to Nullable{T}, origin type for reference types
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Type MakeNullableType(this Type type)
{
Expect.IsNotNull(type, nameof(type));
Expect.That(type.IsValueType && !type.IsNullableType(), string.Format(FrameworkStrings.ErrorTypeNotValueType, type.FullName));
return(typeof(Nullable <>).MakeGenericType(type));
}
/// <summary>
/// Check if member has specified attribute
/// </summary>
/// <typeparam name="T">Attribute type</typeparam>
/// <param name="member"></param>
/// <returns></returns>
public static bool HasAttribute <T>(this MemberInfo member)
where T : Attribute
{
Expect.IsNotNull(member, nameof(member));
return(HasAttribute(member, typeof(T)));
}
/// <summary>
/// Convert to xml string
/// </summary>
/// <param name="doc"></param>
/// <param name="xmlHeader"></param>
/// <param name="format"></param>
/// <returns></returns>
public static string ToXmlString(this XmlDocument doc, bool xmlHeader = true, bool format = true)
{
Expect.IsNotNull(doc, nameof(doc));
var sb = new StringBuilder();
var settings = new XmlWriterSettings
{
Encoding = new UTF8Encoding(false),
ConformanceLevel = ConformanceLevel.Document,
};
if (xmlHeader)
{
var instruction = doc.CreateProcessingInstruction("xml", "version='1.0' encoding='utf-8'");
doc.PrependChild(instruction);
}
else
{
settings.OmitXmlDeclaration = true;
}
if (format)
{
settings.Indent = true;
settings.IndentChars = " ";
}
using (var writer = XmlWriter.Create(sb, settings))
{
doc.WriteTo(writer);
}
return(sb.ToString());
}
/// <summary>
/// Convert bytes content to hex string
/// </summary>
/// <param name="data">Bytes data</param>
/// <param name="upperCase">If result in upper case</param>
/// <returns>Hex string</returns>
public static string ToHex(this byte[] data, bool upperCase = false)
{
Expect.IsNotNull(data, nameof(data));
string format = upperCase ? "X2" : "x2";
return(string.Join("", data.Select(b => b.ToString(format))));
}
/// <summary>
/// Set attribute in fluent mode
/// </summary>
/// <param name="elem"></param>
/// <param name="attrName"></param>
/// <param name="value"></param>
/// <returns></returns>
public static XmlElement SetAttr(this XmlElement elem, string attrName, string value)
{
Expect.IsNotNull(elem, nameof(elem));
Expect.IsNotBlank(attrName, nameof(attrName));
elem.SetAttribute(attrName, value);
return(elem);
}
/// <summary>
/// Check if a type is nullable{T}
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static bool IsNullableType(this Type type)
{
Expect.IsNotNull(type, nameof(type));
return(type.IsGenericType &&
!type.IsGenericTypeDefinition &&
type.GetGenericTypeDefinition() == typeof(Nullable <>));
}
/// <summary>
/// Return attribute value if attribute <paramref name="attrName"/>
/// exist, on <paramref name="defaultValue"/> if not exist.
/// </summary>
/// <param name="elem"></param>
/// <param name="attrName"></param>
/// <param name="defaultValue"></param>
/// <returns></returns>
public static string GetAttr(this XmlElement elem, string attrName, string defaultValue = null)
{
Expect.IsNotNull(elem, nameof(elem));
Expect.IsNotBlank(attrName, nameof(attrName));
return(elem.HasAttribute(attrName) ? elem.Attributes[attrName].Value
: defaultValue);
}
/// <summary>
/// Perform <paramref name="action"/> for each element in <paramref name="collection"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
/// <param name="action"></param>
public static void Each <T>(this IEnumerable <T> collection, Action <T> action)
{
Expect.IsNotNull(collection, nameof(collection));
Expect.IsNotNull(action, nameof(action));
foreach (var item in collection)
{
action(item);
}
}
/// <summary>
/// Read stream to end
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static byte[] ReadToEnd(this Stream stream)
{
Expect.IsNotNull(stream, nameof(stream));
var bytesToRead = (int)(stream.Length - stream.Position);
var buf = new byte[bytesToRead];
stream.Read(buf, 0, bytesToRead);
return(buf);
}
/// <summary>
/// Add multiple items to collection
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
/// <param name="items"></param>
public static void AddRange <T>(this ObservableCollection <T> collection, IEnumerable <T> items)
{
Expect.IsNotNull(collection, nameof(collection));
Expect.IsNotNull(items, nameof(items));
foreach (var item in items)
{
collection.Add(item);
}
}
/// <summary>
/// Create child element
/// </summary>
/// <param name="parent">Parent element</param>
/// <param name="name">Name of child element</param>
/// <param name="xmlns">Child namespace</param>
/// <returns></returns>
public static XmlElement AppendElement(this XmlElement parent, string name, string xmlns = null)
{
Expect.IsNotNull(parent, nameof(parent));
Expect.IsNotBlank(name, nameof(name));
var elem = (xmlns != null) ? parent.OwnerDocument.CreateElement(name, xmlns)
: parent.OwnerDocument.CreateElement(name);
parent.AppendChild(elem);
return(elem);
}
/// <summary>
/// Deserialize
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="xaml"></param>
/// <returns></returns>
public static T Deserialize <T>(string xaml)
where T : class
{
Expect.IsNotNull(xaml, nameof(xaml));
using (var reader = new StringReader(xaml))
{
var result = (T)XamlReader.Load(XmlReader.Create(reader));
return(result);
}
}
/// <summary>
/// Sort items
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
public static void Sort <T>(this ObservableCollection <T> collection)
where T : IComparable
{
Expect.IsNotNull(collection, nameof(collection));
var array = collection.ToArray();
Array.Sort(array);
collection.Clear();
collection.AddRange(array);
}
/// <summary>
/// Append exception detail to log file.
/// </summary>
/// <param name="exp">Exception to log</param>
/// <param name="logPath">Log file path. </param>
public static void LogToFile(this Exception exp, string logPath)
{
Expect.IsNotNull(exp, nameof(exp));
Expect.IsNotBlank(logPath, nameof(logPath));
try
{
File.AppendAllText(logPath, exp.GetFullTrace(), Encoding.UTF8);
}
catch (Exception inner)
{
Debug.WriteLine(inner.Message);
Debug.WriteLine(inner.StackTrace);
}
}
/// <summary>
/// Find first matched elements
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
/// <param name="predicate"></param>
public static T Find <T>(this IEnumerable <T> collection, Predicate <T> predicate)
where T : class
{
Expect.IsNotNull(collection, nameof(collection));
Expect.IsNotNull(predicate, nameof(predicate));
foreach (var item in collection)
{
if (predicate(item))
{
return(item);
}
}
return(null);
}
/// <summary>
/// Get full stack trace for the exception, including inner exception details.
/// </summary>
/// <param name="exp">Exception to trace</param>
/// <returns>Exception trace message, includes all inner exceptions</returns>
/// <remarks>This method can be used for logging and tracing to dump all exception details.</remarks>
public static string GetFullTrace(this Exception exp)
{
Expect.IsNotNull(exp, nameof(exp));
var sb = new StringBuilder();
while (exp != null)
{
sb.AppendFormat(FrameworkStrings.ExceptionTraceFormat,
DateTime.Now,
exp.Message,
exp.GetType().FullName,
exp.StackTrace);
exp = exp.InnerException;
}
return(sb.ToString());
}
/// <summary>
/// Given string in hex format (<see cref="ToHex(byte[], bool)"/>),
/// convert back to bytes
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static byte[] Parse(string str)
{
Expect.IsNotNull(str, nameof(str));
if (str.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase))
{
str = str.Substring(2);
}
Expect.That(str.Length % 2 == 0, () => new FormatException(FrameworkStrings.ErrorBytesFormat));
var bytes = new List <byte>();
for (int i = 0; i < str.Length / 2; i++)
{
bytes.Add(byte.Parse(str.Substring(i * 2, 2), NumberStyles.AllowHexSpecifier));
}
return(bytes.ToArray());
}
/// <summary>
/// Find index of first matched element, or -1 if not found.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public static int FindIndex <T>(this IEnumerable <T> collection, Predicate <T> predicate)
{
Expect.IsNotNull(collection, nameof(collection));
Expect.IsNotNull(predicate, nameof(predicate));
int index = 0;
foreach (var item in collection)
{
if (predicate(item))
{
return(index);
}
else
{
index++;
}
}
return(-1);
}
/// <summary>
/// Serialize object
/// </summary>
/// <param name="obj"></param>
/// <param name="formatted"></param>
public static string Serialize(object obj, bool formatted = false)
{
Expect.IsNotNull(obj, nameof(obj));
var xmlSettings = new XmlWriterSettings
{
Encoding = new UTF8Encoding(false),
ConformanceLevel = ConformanceLevel.Document,
};
if (formatted)
{
xmlSettings.Indent = true;
xmlSettings.IndentChars = " ";
}
using (var stream = new MemoryStream())
using (var writer = XmlWriter.Create(stream, xmlSettings))
{
XamlWriter.Save(obj, new XamlDesignerSerializationManager(writer));
return(xmlSettings.Encoding.GetString(stream.ToArray()));
}
}
/// <summary>
/// Get all compiled resources in assembly
/// </summary>
/// <param name="assembly"></param>
/// <returns></returns>
public static IEnumerable <AssemblyResource> GetAllResources(this Assembly assembly)
{
Expect.IsNotNull(assembly, nameof(assembly));
return(AssemblyResource.FindAll(assembly));
}