saherelm/xCommons
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial Commit ...

Browse Source
This commit is contained in:
saherelm
2024-01-25 04:39:39 +03:30
commit c743026b3c
42 changed files with 3954 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Helpers/ObjectHelper.cs
+99
View File
@@ -0,0 +1,99 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace xCommons.Helpers {
public partial class ObjectHelper {
/// <summary>
/// Convert Enum Keys to Array
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Array GetKeys<T> () {
//
ValidateEnumbType<T> ();
var type = typeof (T);
//
var result = Enum.GetNames (type);
//
return result;
}
/// <summary>
/// Convert EnumValues to Array
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Array GetValues<T> () {
//
ValidateEnumbType<T> ();
var type = typeof (T);
//
var result = Enum.GetValues (type);
//
return result;
}
/// <summary>
/// Convert an Enum to IEnumerable of it's Childs
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IEnumerable<T> ToEnumerableValues<T> () {
//
ValidateEnumbType<T> ();
var type = typeof (T);
//
var result = GetValues<T> ()
.Cast<T> ();
//
return result;
}
/// <summary>
/// Retrieve Keys of an Enumerable
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IEnumerable<string> ToEnumerableKeys<T> () {
//
ValidateEnumbType<T> ();
var type = typeof (T);
//
var result = GetKeys<T> ()
.Cast<string> ();
//
return result;
}
public static IDictionary<string, int> ToDictionary<T> () {
//
ValidateEnumbType<T> ();
//
var result = new Dictionary<string, int> ();
foreach (var name in Enum.GetNames (typeof (T))) {
result.Add (name, (int) Enum.Parse (typeof (T), name));
}
//
return result;
}
private static void ValidateEnumbType<T> () {
//
var type = typeof (T);
if (!type.IsEnum) {
throw new InvalidCastException ();
}
}
}
}
Helpers/XDateHelper.cs
+16
View File
@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace xCommons.Helpers {
public partial class XDateHelper {
/// <summary>
/// retrieve utc now timestam unix like representation ...
/// </summary>
/// <returns></returns>
public static long UtcNowTimespan () {
return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds ();
}
}
}
Helpers/XMLToJSONHelper.cs
+178
View File
@@ -0,0 +1,178 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
namespace xCommons.Helpers {
public partial class XMLToJSONHelper {
//
#region Actions ...
public static string ToJSON (string xml) {
//
XmlDocument doc = new XmlDocument ();
doc.LoadXml (xml);
//
return XmlToJSON (doc);
}
public static string XmlToJSON (XmlDocument xmlDoc) {
//
StringBuilder sbJSON = new StringBuilder ();
//
sbJSON.Append ("{ ");
XmlToJSONnode (sbJSON, xmlDoc.DocumentElement, true);
sbJSON.Append ("}");
//
return sbJSON.ToString ();
}
#endregion
//
#region Private ...
//
private static void XmlToJSONnode (StringBuilder sbJSON, XmlElement node, bool showNodeName) {
//
if (showNodeName) {
sbJSON.Append ("\"" + SafeJSON (node.Name) + "\": ");
}
//
sbJSON.Append ("{");
//
// Build a sorted list of key-value pairs
// where key is case-sensitive nodeName
// value is an ArrayList of string or XmlElement
// so that we know whether the nodeName is an array or not.
SortedList<string, object> childNodeNames = new SortedList<string, object> ();
//
// Add in all node attributes
if (node.Attributes != null)
foreach (XmlAttribute attr in node.Attributes)
StoreChildNode (childNodeNames, attr.Name, attr.InnerText);
//
// Add in all nodes
foreach (XmlNode cnode in node.ChildNodes) {
//
if (cnode is XmlText) {
StoreChildNode (childNodeNames, "value", cnode.InnerText);
} else if (cnode is XmlElement) {
StoreChildNode (childNodeNames, cnode.Name, cnode);
}
}
//
// Now output all stored info
foreach (string childname in childNodeNames.Keys) {
//
List<object> alChild = (List<object>) childNodeNames[childname];
if (alChild.Count == 1) {
OutputNode (childname, alChild[0], sbJSON, true);
} else {
//
sbJSON.Append (" \"" + SafeJSON (childname) + "\": [ ");
//
foreach (object Child in alChild) {
OutputNode (childname, Child, sbJSON, false);
}
//
sbJSON.Remove (sbJSON.Length - 2, 2);
sbJSON.Append (" ], ");
}
}
//
sbJSON.Remove (sbJSON.Length - 2, 2);
sbJSON.Append (" }");
}
//
// StoreChildNode: Store data associated with each nodeName
// so that we know whether the nodeName is an array or not.
private static void StoreChildNode (SortedList<string, object> childNodeNames, string nodeName, object nodeValue) {
//
// Pre-process contraction of XmlElement-s
if (nodeValue is XmlElement) {
//
// Convert <aa></aa> into "aa":null
// <aa>xx</aa> into "aa":"xx"
XmlNode cnode = (XmlNode) nodeValue;
if (cnode.Attributes.Count == 0) {
//
XmlNodeList children = cnode.ChildNodes;
if (children.Count == 0) {
nodeValue = null;
} else if (children.Count == 1 && (children[0] is XmlText)) {
nodeValue = ((XmlText) (children[0])).InnerText;
}
}
}
//
// Add nodeValue to ArrayList associated with each nodeName
// If nodeName doesn't exist then add it
List<object> ValuesAL;
//
if (childNodeNames.ContainsKey (nodeName)) {
ValuesAL = (List<object>) childNodeNames[nodeName];
} else {
//
ValuesAL = new List<object> ();
childNodeNames[nodeName] = ValuesAL;
}
//
ValuesAL.Add (nodeValue);
}
//
private static void OutputNode (string childname, object alChild, StringBuilder sbJSON, bool showNodeName) {
if (alChild == null) {
if (showNodeName)
sbJSON.Append ("\"" + SafeJSON (childname) + "\": ");
sbJSON.Append ("null");
} else if (alChild is string) {
if (showNodeName)
sbJSON.Append ("\"" + SafeJSON (childname) + "\": ");
string sChild = (string) alChild;
sChild = sChild.Trim ();
sbJSON.Append ("\"" + SafeJSON (sChild) + "\"");
} else
XmlToJSONnode (sbJSON, (XmlElement) alChild, showNodeName);
sbJSON.Append (", ");
}
//
// Make a string safe for JSON
private static string SafeJSON (string sIn) {
//
StringBuilder sbOut = new StringBuilder (sIn.Length);
foreach (char ch in sIn) {
//
if (Char.IsControl (ch) || ch == '\'') {
//
int ich = (int) ch;
sbOut.Append (@"\u" + ich.ToString ("x4"));
continue;
} else if (ch == '\"' || ch == '\\' || ch == '/') {
sbOut.Append ('\\');
}
//
sbOut.Append (ch);
}
//
return sbOut.ToString ();
}
#endregion
}
}
Helpers/XNetworkHelper.cs
+81
View File
@@ -0,0 +1,81 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Threading.Tasks;
using xCommons.Models;
namespace xCommons.Helpers {
public static class XNetworkHelper {
/// <summary>
/// Retrieve Application Host's Machin IP Addresses ...
/// </summary>
/// <returns>string</returns>
public static string GetIp () {
//
var name = Dns.GetHostName (); // get container id
var result = Dns.GetHostEntry (name)
.AddressList
.FirstOrDefault (
x => x.AddressFamily == AddressFamily.InterNetwork
)
.MapToIPv4 ()
.ToString ();
//
return result;
}
/// <summary>
/// Retrieve All Available IP's in Application Host's Machin ...
/// </summary>
/// <returns>a Collection of XNetworkInfo class instances</returns>
public static IEnumerable<XNetworkInfo> GetNetworkInfos () {
//
var result = System.Net.NetworkInformation.NetworkInterface
.GetAllNetworkInterfaces ()
.Where (
ni =>
!ni.IsReceiveOnly &&
ni.OperationalStatus == OperationalStatus.Up &&
ni.NetworkInterfaceType != NetworkInterfaceType.Loopback
)
.SelectMany (ni =>
ni
.GetIPProperties ()
.GatewayAddresses
.Select (ga =>
new {
Name = ni.Name,
Description = ni.Description,
Gateway = ga.Address
.MapToIPv4 ()
.ToString (),
NI = ni
}
)
)
.SelectMany (data =>
data.NI
.GetIPProperties ()
.UnicastAddresses
.Select (ip =>
new XNetworkInfo {
Name = data.Name,
Gateway = data.Gateway,
Description = data.Description,
NetworkInterface = data.NI,
IP = ip.Address
.MapToIPv4 ()
.ToString ()
}
)
);
//
return result;
}
}
}
Helpers/XReflectionHelper.cs
+70
View File
@@ -0,0 +1,70 @@
using System;
using System.Reflection;
namespace xCommons.Helpers {
public static class XReflectionHelper {
public static object GetFieldValue (this object obj, string fieldName) {
if (obj == null)
throw new ArgumentNullException (nameof (obj));
Type objType = obj.GetType ();
var fieldInfo = GetFieldInfo (objType, fieldName);
if (fieldInfo == null)
throw new ArgumentOutOfRangeException (fieldName,
$"Couldn't find field {fieldName} in type {objType.FullName}");
return fieldInfo.GetValue (obj);
}
public static void SetFieldValue (this object obj, string fieldName, object val) {
if (obj == null)
throw new ArgumentNullException (nameof (obj));
Type objType = obj.GetType ();
var fieldInfo = GetFieldInfo (objType, fieldName);
if (fieldInfo == null)
throw new ArgumentOutOfRangeException (fieldName,
$"Couldn't find field {fieldName} in type {objType.FullName}");
fieldInfo.SetValue (obj, val);
}
private static FieldInfo GetFieldInfo (Type type, string fieldName) {
FieldInfo fieldInfo = null;
do {
fieldInfo = type.GetField (fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
type = type.BaseType;
} while (fieldInfo == null && type != null);
return fieldInfo;
}
public static object GetPropertyValue (this object obj, string propertyName) {
if (obj == null)
throw new ArgumentNullException (nameof (obj));
Type objType = obj.GetType ();
var propertyInfo = GetPropertyInfo (objType, propertyName);
if (propertyInfo == null)
throw new ArgumentOutOfRangeException (propertyName,
$"Couldn't find property {propertyName} in type {objType.FullName}");
return propertyInfo.GetValue (obj, null);
}
public static void SetPropertyValue (this object obj, string propertyName, object val) {
if (obj == null)
throw new ArgumentNullException (nameof (obj));
Type objType = obj.GetType ();
var propertyInfo = GetPropertyInfo (objType, propertyName);
if (propertyInfo == null)
throw new ArgumentOutOfRangeException (propertyName,
$"Couldn't find property {propertyName} in type {objType.FullName}");
propertyInfo.SetValue (obj, val, null);
}
private static PropertyInfo GetPropertyInfo (Type type, string propertyName) {
PropertyInfo propertyInfo = null;
do {
propertyInfo = type.GetProperty (propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
type = type.BaseType;
} while (propertyInfo == null && type != null);
return propertyInfo;
}
}
}