Modified: 2021-11-06
.LINK
http://www.jocys.com
.REMARKS
Requires Installation of InkScape 1.2 from https://inkscape.org/release/
https://inkscape.org/release/inkscape-1.2.2/windows/64-bit/compressed-7z/dl/
How to include icons resource into App.xaml file:
How to display image inside the XAML with style:
How to set image to Content control from code behind:
MyIcon.Content = Icons_Default.Current[Icons_Default.Icon_IconFileName];
#>
using namespace System;
using namespace System.IO;
using namespace System.Linq;
using namespace System.Xml.Linq;
using namespace System.Text.RegularExpressions;
using namespace System.Collections.Generic;
[Reflection.Assembly]::LoadWithPartialName("System.Xml.Linq") | Out-Null;
Clear-Host;
# ----------------------------------------------------------------------------
# Get current command path.
[string]$current = $MyInvocation.MyCommand.Path;
# Get calling command path.
[string]$calling = @(Get-PSCallStack)[1].InvocationInfo.MyCommand.Path;
# If executed directly then...
if ($calling -ne "") {
$current = $calling;
}
# ----------------------------------------------------------------------------
[FileInfo]$file = New-Object FileInfo($current);
# Set public parameters.
$global:scriptName = $file.Basename;
$global:scriptPath = $file.Directory.FullName;
# Change current directory.
[Console]::WriteLine("Script Path: {0}", $scriptPath);
[Environment]::CurrentDirectory = $scriptPath;
Set-Location $scriptPath;
# ----------------------------------------------------------------------------
[DirectoryInfo]$root = New-Object DirectoryInfo($scriptPath);
# ----------------------------------------------------------------------------
function RemoveAttributes
{
param([XElement]$Node,[string]$Name);
#----------------------------------------------------------
foreach ($attr in $Node.Attributes())
{
if ($attr.Name -eq $Name)
{
$attr.Remove();
}
}
foreach ($child in $Node.Descendants())
{
RemoveAttributes -Node $child -Name $Name;
}
}
# ----------------------------------------------------------------------------
function FindParentFile
{
[OutputType([FileInfo[]])] param([string]$pattern);
#----------------------------------------------------------
[DirectoryInfo]$di = new-Object DirectoryInfo $scriptPath;
do
{
$files = $di.GetFiles($pattern);
# Return if project files were found.
if ($files.Count -gt 0)
{
return $files;
}
# Continue to parent.
$di = $di.Parent;
} while($null -ne $di);
return $null;
}
# ----------------------------------------------------------------------------
function GetProjectValue
{
[OutputType([string])] param([string]$path, [string]$name);
#----------------------------------------------------------
[string]$content = [File]::ReadAllText($path);
[Regex]$rx = New-Object Regex("(?<$name>)(?[^<]*)(?<\/$name>)");
$match = $rx.Match($content);
if ($match.Success -eq $true) {
return $match.Groups["v"].Value;
}
return $null;
}
# ----------------------------------------------------------------------------
function FindExistingFile
{
[OutputType([string])] param([string]$path);
#----------------------------------------------------------
[FileInfo]$fi = $null;
# Paths to look for executable.
$ps = @(
$path,
"${env:ProgramFiles}\$path",
"${env:ProgramFiles(x86)}\$path",
"D:\Program Files\$path",
"D:\Program Files (x86)\$dfe"
);
foreach ($p in $ps) {
# Fix dot notations.
$fullPath = [Path]::GetFullPath($p);
#Write-Host "Check... $fullPath";
if ([File]::Exists($fullPath)) {
$fi = new-Object FileInfo $fullPath;
break;
}
}
return $fi;
}
# ----------------------------------------------------------------------------
function SHA256CheckSum
{
param($filePath);
#----------------------------------------------------------
$SHA256 = [System.Security.Cryptography.SHA256Managed]::Create();
$fileStream = [System.IO.File]::OpenRead($filePath);
$bytes = $SHA256.ComputeHash($fileStream);
$hash = ($bytes|ForEach-Object ToString X2) -join '';
$fileStream.Dispose();
$SHA256.Dispose();
return $hash;
}
# ----------------------------------------------------------------------------
function FindProjectFile
{
[FileInfo[]]$list = FindParentFile "*.*proj";
if ($list -ne $null -and $list.Count -gt 0){
# Order by date descendign to most recent file.
$list = [Enumerable]::OrderByDescending($list, [Func[object,object]]{ param($x) $x.LastWriteTime });
$list = [Enumerable]::ToArray($list);
return $list[0];
}
return $null;
}
# ----------------------------------------------------------------------------
# Show menu
# ----------------------------------------------------------------------------
function ShowOptionsMenu
{
param($items);
#----------------------------------------------------------
# Get local configurations.
$keys = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Write-Host "Options:";
Write-Host;
for ($i = 0; $i -lt $items.Count; $i++)
{
$item = $items[$i];
Write-Host " $($keys[$i]) - $($item)";
}
Write-Host;
$m = Read-Host -Prompt "Type option and press ENTER to continue";
$m = $m.ToUpper();
$keyIndex = $keys.IndexOf($m);
# If wrong choice then...
if ($keyIndex -eq -1)
{
return $null;
}
return $items[$keyIndex];
}
# ----------------------------------------------------------------------------
Write-Host;
#------------------------------
# Inkscape program location, which will be used for conversion from SVG format to XAML format.
#------------------------------
$inkscape = FindExistingFile "Inkscape\bin\inkscape.exe";
if ($null -eq $inkscape) {
Write-Host "Inkscape program not found!";
Write-Host "Download from https://inkscape.org/release/";
return;
}
Write-Host "Inkscape: $($inkscape.FullName)";
#------------------------------
# Get Project file.
#------------------------------
[FileInfo]$project = FindProjectFile;
if ($null -eq $project) {
Write-Host "Project file not found.";
return;
}
Write-Host "Project: $($project.FullName)";
#------------------------------
# Get Default namespace.
#------------------------------
# Get from project file.
$defaultNamespace = GetProjectValue $project.FullName "RootNamespace";
# If default namespace not found.
if ("" -eq "$defaultNamespace") {
# Visual studio use Project file name as default assembly and root namespace.
$defaultNamespace = $project.BaseName;
}
# If namespace not found then...
if ("" -eq "$defaultNamespace") {
Write-Host "Please provide default namespace";
$defaultNamespace = Host-Read;
}
#Write-Host "Default Namespace: $defaultNamespace";
# Get Relative namespace.
$relativeNamespace = $scriptPath.Substring($project.Directory.FullName.Length).Replace("\", ".");
#Write-Host "Relative Namespace: $relativeNamespace";
$namespace = $defaultNamespace + $relativeNamespace;
Write-Host;
Write-Host "Namespace: $namespace";
#------------------------------
# Get Class Name
#------------------------------
# Get forders with *.svg files inside.
$dirs = $file.Directory.GetDirectories();
$dirNames = new-Object List[string];
foreach ($dir in $dirs) {
$filePattern = "*.svg";
# If folder contains images then...
$dirFiles = $dir.GetFiles($filePattern);
if ($dirFiles.Length -gt 0){
$dirNames.Add($dir.Name);
}
#Write-Host "Source: $($dir.Name), $filePattern Files: $($dirFiles.Length)";
}
[string]$className = $null;
if ($dirNames.Count -eq 1){
$className = $dirNames[0];
} elseif ($dirNames.Count -gt 1){
$className = ShowOptionsMenu $dirNames;
}
if ($null -eq $className){
Write-Host "Folder with images not found!";
return;
}
$sourceDir = New-Object DirectoryInfo($root.FullName + "\" + $className);
Write-Host "Class: $className";
Write-Host;
Write-Host "Source: $($sourceDir.Name)\";
Write-Host "Target: $className.xaml + $className.xaml.cs";
Write-Host;
pause;
#------------------------------
# Generate images.
#------------------------------
Write-Host;
#Write-Host "Done. Press any key to continue...";
#$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown");
# Get files.
$files = $sourceDir.GetFiles("*.svg");
# If no SVG images found then skip.
if ($files.Length -eq 0){
continue;
}
# Create regular expressions for key and names generation.
$RxAllExceptNumbersAndLetters = New-Object Regex("[^a-zA-Z0-9]", [RegexOptions]::IgnoreCase);
$UsRx = New-Object Regex("_+");
# Crate output file name.
$fileName = $RxAllExceptNumbersAndLetters.Replace($sourceDir.Name, "_");
$fileName = $UsRx.Replace($fileName, "_");
$fileName = "$className.xaml";
$fileNameCs = "$className.xaml.cs";
if ($files.Length -eq 1){
Write-Host "Convert $($files.Length) image:";
}else{
Write-Host "Convert $($files.Length) images:";
}
# Start .xaml file.
$xNs = "http://schemas.microsoft.com/winfx/2006/xaml";
if ([File]::Exists($fileName) -ne $true)
{
[File]::WriteAllText($fileName, "');
[File]::AppendAllText($fileName,"`r`n`r`n");
}
[XDocument]$xaml = [XDocument]::Load($fileName);
# Create list from existing nodes.
$nodes = $xaml.Root.Nodes();
#$nodes = $xaml.Root.Elements("Viewbox").ToArray();
#$nodes = $xaml.DocumentElement.SelectNodes("/*[local-name() = 'ResourceDictionary']/*[local-name() = 'Viewbox']");
$nodeList = new-Object System.Collections.Generic.Dictionary[string`,object];
[XElement]$node = $null;
foreach ($node in $nodes)
{
$nodeKey = $node.Attribute([XName]::Get("Key", $xNs)).Value;
$nodeList.Add($nodeKey, $node);
#Write-Host "Key $nodeKey";
}
# Cleanup old nodes.
$xaml.Root.RemoveNodes();
# Start .xaml.cs file.
[File]::WriteAllText($fileNameCs, "using System.Windows;`r`n");
[File]::AppendAllText($fileNameCs, "`r`n");
[File]::AppendAllText($fileNameCs, "namespace $namespace`r`n");
[File]::AppendAllText($fileNameCs, "{`r`n");
[File]::AppendAllText($fileNameCs, "`tpartial class $className : ResourceDictionary`r`n");
[File]::AppendAllText($fileNameCs, "`t{`r`n");
[File]::AppendAllText($fileNameCs, "`t`tpublic $className()`r`n");
[File]::AppendAllText($fileNameCs, "`t`t{`r`n");
[File]::AppendAllText($fileNameCs, "`t`t`tInitializeComponent();`r`n");
[File]::AppendAllText($fileNameCs, "`t`t}`r`n");
[File]::AppendAllText($fileNameCs, "`r`n");
[File]::AppendAllText($fileNameCs, "`t`tpublic static $className Current => _Current = _Current ?? new $className();`r`n");
[File]::AppendAllText($fileNameCs, "`t`tprivate static $className _Current;`r`n");
[File]::AppendAllText($fileNameCs, "`r`n");
Write-Host;
# Process files.
for ($f = 0; $f -lt $files.Length; $f++) {
$file = $files[$f];
$fileHash = SHA256CheckSum -filePath $file.FullName;
$fileHashNodeName = "Tag";
$nodeXml = $null;
# Create unique key.
$key = "Icon_$($file.BaseName)";
# Get existing node or create new.
$action = "Insert:";
if ($nodeList.ContainsKey($key))
{
$action = "Update:";
[XElement]$oldNode = $nodeList[$key];
# Get hash of current node.
$oldHash = $oldNode.Attribute([XName]::Get($fileHashNodeName)).Value;
if ($oldHash -eq "SHA256_$fileHash")
{
$nodeXml = $oldNode;
$action = "Keep: ";
}
}
$isNew = ($null -eq $nodeXml);
if ($isNew)
{
$nodeXml = Get-Content "$($file.FullName)" | & $inkscape --pipe --export-type=xaml | Out-String;
}
# Show file name.
Write-Host "`t$action $($sourceDir.Name)\$($file.Name)";
# Remove name attributes.
[XDocument]$node = [XDocument]::Parse($nodeXml);
# Remove "Name" attributes.
RemoveAttributes -Node $node.Root -Name "Name";
RemoveAttributes -Node $node.Root -Name "Key";
RemoveAttributes -Node $node.Root -Name "Shared";
# Add image XML to XAML document.
$xaml.Root.Add($node.Root);
# Remove old attributes.
if ($isNew)
{
# Get node which was just added.
$ln = $xaml.Root.LastNode;
# Give node unique name.
$ln.SetAttributeValue([XName]::Get("Key", $xNs), $key);
# Make sure that image copy is made when it is used.
$ln.SetAttributeValue([XName]::Get("Shared", $xNs), "False");
# Set file hash.
$ln.SetAttributeValue([XName]::Get($fileHashNodeName), "SHA256_$fileHash");
}
# Write unique name to code file.
[File]::AppendAllText($fileNameCs, "`t`tpublic const string $key = nameof($key);`r`n");
}
# Save XAML file.
$xaml.Save($fileName);
# End .xaml.cs file.
[File]::AppendAllText($fileNameCs, "`r`n");
[File]::AppendAllText($fileNameCs, "`t}`r`n");
[File]::AppendAllText($fileNameCs, "}`r`n");
Write-Host;
Write-Host "Done. Press any key to continue...";
$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown");
================================================
FILE: FocusLogger/JocysCom/Controls/Themes/Default.xaml
================================================
#ff000000
#FFE6E6
#FFF2E6
#FFFFE6
#F2FFE6
#E6FFE6
#E6FFF2
#E6FFFF
#E6F2FF
#E6E6FF
#F2E6FF
#FFE6FF
#FFE6F2
#D60000
#D66700
#D6D600
#67D600
#00D600
#00D667
#00D6D6
#0067D6
#0000D6
#6700D6
#D600D6
#D60067
-->
================================================
FILE: FocusLogger/JocysCom/Controls/Themes/Default_MultiReplace.ps1
================================================
<#
.SYNOPSIS
Replace in multiple files.
.NOTES
Author: Evaldas Jocys
Modified: 2021-04-14
.LINK
http://www.jocys.com
#>
using namespace System;
using namespace System.IO;
using namespace System.Text;
using namespace System.Text.RegularExpressions;
# ----------------------------------------------------------------------------
# Get current command path.
[string]$current = $MyInvocation.MyCommand.Path;
# Get calling command path.
[string]$calling = @(Get-PSCallStack)[1].InvocationInfo.MyCommand.Path;
# If executed directly then...
if ($calling -ne "") {
$current = $calling;
}
# ----------------------------------------------------------------------------
[FileInfo]$file = New-Object FileInfo($current);
# Set public parameters.
$global:scriptName = $file.Basename;
$global:scriptPath = $file.Directory.FullName;
# Change current directory.
[Console]::WriteLine("Path: {0}", $scriptPath);
[Environment]::CurrentDirectory = $scriptPath;
Set-Location $scriptPath;
# ----------------------------------------------------------------------------
Function DoReplace
{
# Parameters.
param ([string]$path, [string]$filesPattern, [string]$pattern, [string]$replacement);
Write-Output "`"$path`" `"$filesPattern`" `"$pattern`" `"$replacement`"";
# Function.
$di = new-Object DirectoryInfo($path);
[FileInfo[]]$files = $di.GetFiles($filesPattern, [SearchOption]::AllDirectories);
$rx = new-Object Regex($pattern);
foreach ($file in $files)
{
[string]$oldContent = [File]::ReadAllText($file.FullName);
$newContent = $rx.Replace($oldContent, $replacement);
if ($oldContent -ne $newContent)
{
$subName = $file.FullName.Substring($di.FullName.Length + 1);
Write-Output " $subName";
[File]::WriteAllText($file.FullName, $newContent);
}
}
}
# Replace default padding and margin from 4 to 3.
DoReplace "." "*.xaml" "(4),([034]),([034]),([034])" "3,`$2,`$3,`$4";
DoReplace "." "*.xaml" "([034]),(4),([034]),([034])" "`$1,3,`$3,`$4";
DoReplace "." "*.xaml" "([034]),([034]),(4),([034])" "`$1,`$2,3,`$4";
DoReplace "." "*.xaml" "([034]),([034]),([034]),(4)" "`$1,`$2,`$3,3";
pause;
================================================
FILE: FocusLogger/JocysCom/Controls/Themes/Icons.xaml
================================================
================================================
FILE: FocusLogger/JocysCom/Controls/Themes/Icons.xaml.cs
================================================
using System.Windows;
namespace JocysCom.ClassLibrary.Controls.Themes
{
partial class Icons : ResourceDictionary
{
public Icons()
{
InitializeComponent();
}
public static Icons Current => _Current = _Current ?? new Icons();
private static Icons _Current;
public const string Icon_Add = nameof(Icon_Add);
public const string Icon_Cancel = nameof(Icon_Cancel);
public const string Icon_Cleanup = nameof(Icon_Cleanup);
public const string Icon_Delete = nameof(Icon_Delete);
public const string Icon_Edit = nameof(Icon_Edit);
public const string Icon_Error = nameof(Icon_Error);
public const string Icon_Exit = nameof(Icon_Exit);
public const string Icon_Export = nameof(Icon_Export);
public const string Icon_FolderOpen = nameof(Icon_FolderOpen);
public const string Icon_Ignore = nameof(Icon_Ignore);
public const string Icon_Import = nameof(Icon_Import);
public const string Icon_Information = nameof(Icon_Information);
public const string Icon_InformationGrey = nameof(Icon_InformationGrey);
public const string Icon_Maximize = nameof(Icon_Maximize);
public const string Icon_MediaPlay = nameof(Icon_MediaPlay);
public const string Icon_MediaStop = nameof(Icon_MediaStop);
public const string Icon_Minimize = nameof(Icon_Minimize);
public const string Icon_OK = nameof(Icon_OK);
public const string Icon_Play = nameof(Icon_Play);
public const string Icon_ProcessLeft = nameof(Icon_ProcessLeft);
public const string Icon_ProcessRight = nameof(Icon_ProcessRight);
public const string Icon_Question = nameof(Icon_Question);
public const string Icon_Record = nameof(Icon_Record);
public const string Icon_Refresh = nameof(Icon_Refresh);
public const string Icon_Remove = nameof(Icon_Remove);
public const string Icon_Reset = nameof(Icon_Reset);
public const string Icon_Save = nameof(Icon_Save);
public const string Icon_SelectAll = nameof(Icon_SelectAll);
public const string Icon_SelectInverse = nameof(Icon_SelectInverse);
public const string Icon_SelectNone = nameof(Icon_SelectNone);
public const string Icon_Stop = nameof(Icon_Stop);
public const string Icon_ToggleOff = nameof(Icon_ToggleOff);
public const string Icon_ToggleOn = nameof(Icon_ToggleOn);
public const string Icon_Warning = nameof(Icon_Warning);
}
}
================================================
FILE: FocusLogger/JocysCom/Controls/ToolStripBorderlessRenderer.cs
================================================
using System.Windows.Forms;
namespace JocysCom.ClassLibrary.Controls
{
///
/// Remove white borders from toolstrip.
/// How to use:
/// toolStrip.Renderer = new ToolStripBorderlessRenderer();
///
public class ToolStripBorderlessRenderer : ToolStripSystemRenderer
{
protected override void OnRenderToolStripBorder(ToolStripRenderEventArgs e)
{
if (e.ToolStrip.GetType() == typeof(ToolStrip))
{
// skip render border
}
else
{
// do render border
base.OnRenderToolStripBorder(e);
}
}
}
}
================================================
FILE: FocusLogger/JocysCom/Data/SqlHelper.Types.cs
================================================
using System;
#if NETFRAMEWORK
using System.Data.SqlClient;
#else
#endif
namespace JocysCom.ClassLibrary.Data
{
public partial class SqlHelper
{
/// Determines whether the given SQL type string supports a size specification (e.g. CHAR, VARCHAR, BINARY).
public static bool HaveSize(string sqlType)
{
var name = sqlType.ToLower();
return name.Contains("char") || name.Contains("binary");
}
/// Determines whether the given SQL type string represents a Unicode type (e.g. NCHAR, NVARCHAR).
public static bool IsUnicode(string sqlType)
{
var name = sqlType.ToLower();
return name.Contains("nchar") || name.Contains("nvarchar");
}
/// Maps a SQL Server type name to its Visual Basic built-in type alias (e.g. Date, Integer) or returns the CLR type name if no VB alias exists.
public static string ToSystemTypeVB(string sqlType)
{
var t = ToSystemType(sqlType);
if (t == typeof(DateTime)) return "Date";
if (t == typeof(Int16)) return "Short";
if (t == typeof(Int32)) return "Integer";
if (t == typeof(Int64)) return "Long";
if (t == typeof(UInt16)) return "UShort";
if (t == typeof(UInt32)) return "UInteger";
if (t == typeof(UInt64)) return "ULong";
return t.Name;
}
/// Maps a SQL Server type name to its C# built-in type alias (e.g. int, string) or returns the CLR type name if no alias exists.
public static string ToSystemTypeCS(string sqlType)
{
var t = ToSystemType(sqlType);
var name = ClassLibrary.Runtime.RuntimeHelper.GetBuiltInTypeNameOrAlias(t);
return name;
}
/// Infers the CLR System.Type for the specified SQL Server data type name.
public static Type ToSystemType(string sqlTypeSring)
{
var sqlType = (SqlDataType)Enum.Parse(typeof(SqlDataType), sqlTypeSring, true);
var t = typeof(String);
switch (sqlType)
{
case SqlDataType.BigInt:
t = typeof(Int64);
break;
case SqlDataType.Bit:
t = typeof(Boolean);
break;
case SqlDataType.Char:
case SqlDataType.VarChar:
case SqlDataType.VarCharMax:
t = typeof(String);
break;
case SqlDataType.Date:
case SqlDataType.DateTime:
case SqlDataType.DateTime2:
case SqlDataType.SmallDateTime:
t = typeof(DateTime);
break;
case SqlDataType.DateTimeOffset:
t = typeof(DateTimeOffset);
break;
case SqlDataType.Time:
t = typeof(TimeSpan);
break;
case SqlDataType.Decimal:
case SqlDataType.Money:
case SqlDataType.SmallMoney:
t = typeof(Decimal);
break;
case SqlDataType.Int:
t = typeof(Int32);
break;
case SqlDataType.NChar:
case SqlDataType.NText:
case SqlDataType.NVarChar:
case SqlDataType.NVarCharMax:
case SqlDataType.Text:
t = typeof(String);
break;
case SqlDataType.Real:
case SqlDataType.Numeric:
case SqlDataType.Float:
t = typeof(Double);
break;
case SqlDataType.Timestamp:
case SqlDataType.Binary:
t = typeof(Byte[]);
break;
case SqlDataType.TinyInt:
t = typeof(Byte);
break;
case SqlDataType.SmallInt:
t = typeof(Int16);
break;
case SqlDataType.UniqueIdentifier:
t = typeof(Guid);
break;
case SqlDataType.UserDefinedDataType:
case SqlDataType.UserDefinedType:
case SqlDataType.Variant:
case SqlDataType.Image:
t = typeof(Object);
break;
default:
t = typeof(String);
break;
}
return t;
}
/// Infers the SqlDataType for a given CLR TypeCode.
///
/// Chooses VarBinary or VarChar when min != max to indicate variable-length;
/// uses NChar/NVarChar instead of Char/VarChar when isUnicode is true.
///
public static SqlDataType GetSqlDataType(TypeCode code, int min = 0, int max = 0, bool isUnicode = false)
{
var v = min != max;
switch (code)
{
case TypeCode.Empty: return SqlDataType.None;
case TypeCode.Object: return v ? SqlDataType.VarBinary : SqlDataType.Binary;
case TypeCode.DBNull: return SqlDataType.None;
case TypeCode.Boolean: return SqlDataType.Bit;
case TypeCode.Char: return isUnicode ? SqlDataType.NChar : SqlDataType.Char;
case TypeCode.SByte: return SqlDataType.None;
case TypeCode.Byte: return SqlDataType.TinyInt;
case TypeCode.Int16: return SqlDataType.SmallInt;
case TypeCode.UInt16: return SqlDataType.SmallInt;
case TypeCode.Int32: return SqlDataType.Int;
case TypeCode.UInt32: return SqlDataType.Int;
case TypeCode.Int64: return SqlDataType.BigInt;
case TypeCode.UInt64: return SqlDataType.BigInt;
case TypeCode.Single: return SqlDataType.Real;
case TypeCode.Double: return SqlDataType.Float;
case TypeCode.Decimal: return SqlDataType.Money;
case TypeCode.DateTime: return SqlDataType.DateTime;
case TypeCode.String: return v
? isUnicode ? SqlDataType.NVarChar : SqlDataType.VarChar
: isUnicode ? SqlDataType.NChar : SqlDataType.Char;
default: return SqlDataType.None;
}
}
//public static SqlDataType GetSqlDataType(Type giveType)
//{
// // Allow nullable types to be handled
// giveType = Nullable.GetUnderlyingType(giveType) ?? giveType;
// return GetSqlDataType(giveType);
//}
//public static SqlDataType GetSqlDataType()
//{
// return GetSqlDataType(typeof(T));
//}
/// Enumerates SQL Server data types used for mapping between SQL and CLR types.
public enum SqlDataType
{
BigInt = 1,
Binary = 2,
Bit = 3,
Char = 4,
Date = 36,
DateTime = 6,
DateTime2 = 39,
DateTimeOffset = 38,
Decimal = 7,
Float = 8,
Geography = 43,
Geometry = 42,
HierarchyId = 41,
Image = 9,
Int = 10,
Money = 11,
NChar = 12,
None = 0,
NText = 13,
Numeric = 35,
NVarChar = 14,
NVarCharMax = 15,
Real = 16,
SmallDateTime = 17,
SmallInt = 18,
SmallMoney = 19,
SysName = 34,
Text = 20,
Time = 37,
Timestamp = 21,
TinyInt = 22,
UniqueIdentifier = 23,
UserDefinedDataType = 24,
UserDefinedTableType = 40,
UserDefinedType = 25,
VarBinary = 28,
VarBinaryMax = 29,
VarChar = 30,
VarCharMax = 31,
Variant = 32,
Xml = 33
}
}
}
================================================
FILE: FocusLogger/JocysCom/IO/PathHelper.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace JocysCom.ClassLibrary.IO
{
///
/// Summary description for PathConvert.
///
public static partial class PathHelper
{
const string nullOrEmpty = "Input cannot be null or empty";
public static void ValidateFileName(string name)
{
if (name is null)
throw new ArgumentNullException(nameof(name));
var invalid = name.Intersect(System.IO.Path.GetInvalidFileNameChars());
if (invalid.Any())
throw new ArgumentException(string.Format("Invalid file name chars found: {0}", string.Join(", ", invalid)), nameof(name));
}
///
/// Method used to protect from
/// SUPPRESS: CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
/// https://cwe.mitre.org/data/definitions/78.html
///
///
public static void ValidatePath(string path)
{
var d = System.IO.Path.GetDirectoryName(path);
var invalid = d.Intersect(System.IO.Path.GetInvalidPathChars());
if (invalid.Any())
throw new ArgumentException(string.Format("Invalid path chars found: {0}", string.Join(", ", invalid)), nameof(path));
var name = System.IO.Path.GetFileName(path);
ValidateFileName(name);
}
#region Detect Type of Path
///
/// Virtual path starts from "/" or "\"
///
public static bool IsPathVirtual(string path)
{
if (string.IsNullOrEmpty(path))
throw new ArgumentException(nullOrEmpty, nameof(path));
var newPath = path.Trim();
return
newPath.StartsWith("/") ||
newPath.StartsWith("\\");
}
///
/// A physical path is how the OS locates the resource.
///
///
///
public static bool IsPathPhysical(string path)
{
if (string.IsNullOrEmpty(path))
throw new ArgumentException(nullOrEmpty, nameof(path));
var newPath = path.Trim();
return
newPath.Contains(':') ||
newPath.Contains("\\");
}
#endregion
// Get Physical path from any type of path.
public static string GetPathPhysical(string relativeTo, string path)
{
if (path is null)
throw new ArgumentNullException(nameof(path));
string physicalPath;
// If path is Physical.
if (IsPathPhysical(path))
{
// Return current path
physicalPath = path;
}
else
{
// Convert to physical.
physicalPath = relativeTo + "/" + path;
// Convert "/" separator to "\".
physicalPath = physicalPath.Replace("/", "\\");
// Remove double "\\".
physicalPath = physicalPath.Replace("\\\\", "\\");
}
// Return results.
return physicalPath;
}
// Get Rooted path.
public static string GetPathRooted(string relativeTo, string path)
{
if (path is null) throw new ArgumentNullException(nameof(path));
//if path already rooted then...
if (System.IO.Path.IsPathRooted(path))
return path;
// Combine path.
#if NETFRAMEWORK
var combined = System.IO.Path.Combine(relativeTo, path);
#else
var combined = System.IO.Path.GetFullPath(path, relativeTo);
#endif
// Fix dot notations.
combined = Path.GetFullPath(combined);
return combined;
}
///
/// root parent
/// ----------- --------
/// ..\..\..
/// c:\r1\r2\r3\p1\p2\p3\\
/// c:\r1\r2\r3\a1\file.ext
/// -----------
/// append
/// Important: if relative is directory then path must end with '\' or '/'.
///
///
///
///
///
public static string GetRelativePath(string relativeTo, string path, bool addCurrentDir = true)
{
if (string.IsNullOrEmpty(relativeTo))
throw new ArgumentException(nullOrEmpty, nameof(relativeTo));
if (string.IsNullOrEmpty(path))
throw new ArgumentException(nullOrEmpty, nameof(path));
var containsPrimarySeparator = relativeTo.Contains(Path.DirectorySeparatorChar);
relativeTo = Path.GetFullPath(relativeTo);
path = Path.GetFullPath(path);
var relativeToUri = new Uri(relativeTo);
var pathUri = new Uri(path);
var relativeUri = relativeToUri.MakeRelativeUri(pathUri).ToString();
var relativePath = Uri.UnescapeDataString(relativeUri);
// Add current folder prefix if output does not contain separators.
if (addCurrentDir && !relativePath.Contains(Path.DirectorySeparatorChar) && !relativePath.Contains(Path.AltDirectorySeparatorChar))
relativePath = "." + Path.AltDirectorySeparatorChar + relativePath;
// Make sure that output contains same separator type as input.
if (containsPrimarySeparator)
relativePath = relativePath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
return relativePath;
}
// Get Relative path from any type of path.
public static string GetPathVirtual(string relativeTo, string path)
{
if (path is null) throw new ArgumentNullException(nameof(path));
// If path is not physical then just return.
if (!IsPathPhysical(path))
return path;
// Convert to virtual path by cropping root part.
var virtualPath = "/" + path.Substring(relativeTo.Length);
// Convert "\" separator to "/".
virtualPath = virtualPath.Replace("\\", "/");
// Remove double "//".
virtualPath = virtualPath.Replace("//", "/");
// Return results.
return virtualPath;
}
// Get parent folder from path.
public static string GetParentFolderPhysical(string relativeTo, string path)
{
if (path is null)
throw new ArgumentNullException(nameof(path));
// Get physical path.
var physicalPath = GetPathPhysical(relativeTo, path);
// Get folder only.
var folderPath = System.IO.Path.GetDirectoryName(physicalPath);
// Return results.
return folderPath;
}
// Get parent folder from path.
public static string GetParentFolderVirtual(string relativeTo, string path)
{
if (path is null)
throw new ArgumentNullException(nameof(path));
// Get physical parent folder path.
var folderPath = GetParentFolderPhysical(relativeTo, path);
// Convert to virtual path.
var virtualPath = GetPathVirtual(relativeTo, folderPath);
// Return results.
return virtualPath;
}
public static string GetFileName(string relativeTo, string path)
{
if (path is null)
throw new ArgumentNullException(nameof(path));
// Make sure that path is physical.
var physicalPath = GetPathPhysical(relativeTo, path);
return System.IO.Path.GetFileName(physicalPath);
}
#region Path Converter
static object SpecialFoldersLock = new object();
static Dictionary _SpecialFolders;
public static Dictionary SpecialFolders
{
get
{
lock (SpecialFoldersLock)
{
if (_SpecialFolders is null)
{
var keys = (System.Environment.SpecialFolder[])Enum.GetValues(typeof(System.Environment.SpecialFolder));
var items = new List>();
foreach (var key in keys)
{
var item = new KeyValuePair($"{key}", System.Environment.GetFolderPath(key));
// Make sure all values are not empty and unique.
if (!string.IsNullOrEmpty(item.Key) && !string.IsNullOrEmpty(item.Value))
items.Add(item);
}
_SpecialFolders = new Dictionary();
// Order folders descending.
var list = items.OrderByDescending(x => x.Value).ToArray();
foreach (var listItem in list)
{
// If list doesn't contains key then...
if (!_SpecialFolders.ContainsKey(listItem.Key))
_SpecialFolders.Add(listItem.Key, listItem.Value);
}
}
}
return _SpecialFolders;
}
}
#endregion
}
}
================================================
FILE: FocusLogger/JocysCom/MakeLinks_Ref.ps1
================================================
<#
.SYNOPSIS
Thin wrapper that calls the original MakeLinks.ps1 from the Core library.
Place this file in external JocysCom folders instead of duplicating the full script.
#>
$paths = @(
"d:\Projects\Jocys.com\ClassLibrary\Core\_Resources\MakeLinks.ps1",
"c:\Projects\Jocys.com\ClassLibrary\Core\_Resources\MakeLinks.ps1"
);
foreach ($p in $paths) {
if (Test-Path $p) { & $p; return; }
}
Write-Host "ERROR: MakeLinks.ps1 not found in any known location." -ForegroundColor Red;
================================================
FILE: FocusLogger/JocysCom/Runtime/RuntimeHelper.cs
================================================
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Json;
using System.Text;
namespace JocysCom.ClassLibrary.Runtime
{
public static partial class RuntimeHelper
{
/*
public static bool IsKnownType(Type type)
{
if (type is null)
throw new ArgumentNullException(nameof(type));
return
type == typeof(string)
// Note: Every Primitive type (such as int, double, bool, char, etc.) is a ValueType.
|| type.IsValueType
|| type.IsSerializable;
}
*/
private static readonly HashSet numericTypes = new HashSet
{
typeof(int), typeof(double), typeof(decimal),
typeof(long), typeof(short), typeof(sbyte),
typeof(byte), typeof(ulong), typeof(ushort),
typeof(uint), typeof(float),
};
public static bool IsNumeric(Type type)
{
return numericTypes.Contains(type);
}
/// Built-in types
public static readonly Dictionary TypeAliases = new Dictionary
{
{ typeof(bool), "bool" },
{ typeof(byte), "byte" },
{ typeof(char), "char" },
{ typeof(decimal), "decimal" },
{ typeof(double), "double" },
{ typeof(float), "float" },
{ typeof(int), "int" },
{ typeof(long), "long" },
{ typeof(object), "object" },
{ typeof(sbyte), "sbyte" },
{ typeof(short), "short" },
{ typeof(string), "string" },
{ typeof(uint), "uint" },
{ typeof(ulong), "ulong" },
{ typeof(ushort), "ushort" },
{ typeof(void), "void" }
};
public static string GetBuiltInTypeNameOrAlias(Type type)
{
if (type is null)
throw new ArgumentNullException(nameof(type));
var elementType = type.IsArray
? type.GetElementType()
: type;
// Lookup alias for type
string alias;
if (TypeAliases.TryGetValue(elementType, out alias))
return alias + (type.IsArray ? "[]" : "");
// Note: All Nullable are value types.
if (type.IsValueType)
{
var underType = Nullable.GetUnderlyingType(type);
if (underType != null)
return GetBuiltInTypeNameOrAlias(underType) + "?";
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
{
var itemType = type.GetGenericArguments()[0];
return string.Format("List<{0}>", GetBuiltInTypeNameOrAlias(itemType));
}
// Default to CLR type name
return type.Name;
}
private static Type GetFirstArgumentOfGenericType(Type type)
{
return type.GetGenericArguments()[0];
}
public static bool IsNullableType(Type type)
{
if (type is null)
throw new ArgumentNullException(nameof(type));
return type.IsGenericType
? type.GetGenericTypeDefinition() == typeof(Nullable<>)
: false;
}
public static BindingFlags DefaultBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
#region Copy Fields
///
/// Get source intersecting fields.
///
private static FieldInfo[] GetItersectingFields(object source, object target)
{
var targetNames = target.GetType().GetFields(DefaultBindingFlags).Select(x => x.Name).ToArray();
var sourceFields = source
.GetType()
.GetFields(DefaultBindingFlags)
.Where(x => targetNames.Contains(x.Name))
.ToArray();
return sourceFields;
}
/// Cache data for speed.
/// Cache allows for this class to work 20 times faster.
private static ConcurrentDictionary Fields { get; } = new ConcurrentDictionary();
private static FieldInfo[] GetFields(Type t, bool cache = true)
{
var items = cache
? Fields.GetOrAdd(t, x => t.GetFields(DefaultBindingFlags))
: t.GetFields(DefaultBindingFlags);
return items;
}
/// Cache data for speed.
/// Cache allows for this class to work 20 times faster.
private static ConcurrentDictionary Properties { get; } = new ConcurrentDictionary();
private static PropertyInfo[] GetProperties(Type t, bool cache = true)
{
var items = cache
? Properties.GetOrAdd(t, x => t.GetProperties(DefaultBindingFlags))
: t.GetProperties(DefaultBindingFlags);
return items;
}
public static void CopyFields(object source, object target, bool onlyNonByRef = false)
{
if (source is null)
throw new ArgumentNullException(nameof(source));
if (target is null)
throw new ArgumentNullException(nameof(target));
// Get Field Info.
var sourceFields = GetFields(source.GetType());
var targetFields = GetFields(target.GetType());
foreach (var sm in sourceFields)
{
var tm = targetFields.FirstOrDefault(x => x.Name == sm.Name);
bool useJson;
if (!CanCopy(sm.FieldType, tm.FieldType, onlyNonByRef, out useJson))
continue;
// Get source value.
var sValue = sm.GetValue(source);
if (useJson)
sValue = Serialize(sValue);
var update = true;
// Get target value.
var dValue = tm.GetValue(target);
if (useJson)
dValue = Serialize(dValue);
// Update only if values are different.
update = !Equals(sValue, dValue);
if (update)
{
if (useJson)
sValue = Deserialize(sValue as string, tm.FieldType);
tm.SetValue(target, sValue);
}
}
}
#endregion
#region Serializer
/// Cache data for speed.
/// Cache allows for this class to work 20 times faster.
private static ConcurrentDictionary JsonSerializers = new ConcurrentDictionary();
static DataContractJsonSerializer GetJsonSerializer(Type type, DataContractJsonSerializerSettings settings = null)
{
if (type == null)
return null;
return JsonSerializers.GetOrAdd(type, x => new DataContractJsonSerializer(type, settings));
}
private static string Serialize(object o)
{
if (o is null)
return null;
var serializer = GetJsonSerializer(o.GetType());
var ms = new MemoryStream();
lock (serializer) { serializer.WriteObject(ms, o); }
var json = Encoding.UTF8.GetString(ms.ToArray());
ms.Close();
return json;
}
private static object Deserialize(string json, Type type)
{
if (json is null)
return null;
var serializer = GetJsonSerializer(type);
var bytes = Encoding.UTF8.GetBytes(json);
var ms = new MemoryStream(bytes);
object o;
lock (serializer) { o = serializer.ReadObject(ms); }
ms.Close();
return o;
}
#endregion
#region Copy Properties
///
/// Get information about different and intersecting properties.
///
public static string GetPropertyDiffInfo()
{
var sType = typeof(TSource);
var tType = typeof(TTarget);
var sProperties = sType.GetProperties(DefaultBindingFlags);
var tProperties = tType.GetProperties(DefaultBindingFlags);
var sNames = sProperties.Select(x => x.Name).ToArray();
var tNames = tProperties.Select(x => x.Name).ToArray();
var targetOnly = tProperties.Where(x => !sNames.Contains(x.Name)).OrderBy(x => x.Name).ToArray();
var sourceOnly = sProperties.Where(x => !tNames.Contains(x.Name)).OrderBy(x => x.Name).ToArray();
var sourceSame = sProperties.Where(x => tNames.Contains(x.Name)).OrderBy(x => x.Name).ToArray();
var sb = new StringBuilder();
var targetOnlyLines = targetOnly.Select(x => string.Format("{0} {1}", GetBuiltInTypeNameOrAlias(x.PropertyType), x.Name));
if (targetOnly.Length > 0)
{
sb.AppendFormat("// ---- Target Only [{0}] - {1}\r\n\t", targetOnly.Length, tType.Name);
sb.Append(string.Join("\r\n\t", targetOnlyLines));
sb.AppendLine();
}
var sourceOnlyLines = sourceOnly.Select(x => string.Format("{0} {1}", GetBuiltInTypeNameOrAlias(x.PropertyType), x.Name));
if (sourceOnly.Length > 0)
{
sb.AppendFormat("// ---- Source Only [{0}] - {1}\r\n\t", sourceOnly.Length, sType.Name);
sb.Append(string.Join("\r\n\t", sourceOnlyLines));
sb.AppendLine();
}
if (sourceSame.Length > 0)
{
sb.AppendFormat("// ---- Intersects [{0}]:\r\n\t", sourceSame.Length);
var intesectsLines = sourceSame.Select(s =>
string.Format("{0} {1}{2}",
GetBuiltInTypeNameOrAlias(s.PropertyType),
s.Name,
(GetBuiltInTypeNameOrAlias(tProperties.First(t => t.Name == s.Name).PropertyType) == GetBuiltInTypeNameOrAlias(s.PropertyType))
? ""
: " // " + GetBuiltInTypeNameOrAlias(tProperties.First(t => t.Name == s.Name).PropertyType)
)
);
sb.Append(string.Join("\r\n\t", intesectsLines));
sb.AppendLine();
}
return sb.ToString();
}
///
/// Retur true if can copy.
///
public static bool CanCopy(Type source, Type target, bool onlyNonByRef, out bool useJson)
{
useJson = false;
// If target property don't exists.
if (target == null)
return false;
// If target property can't be assigned.
if (!source.IsAssignableFrom(source))
return false;
// If only non reference properties can be compied.
if (onlyNonByRef && source.IsByRef)
return false;
// Use JSON to clone referenced values.
useJson = source.IsByRef;
return true;
}
public static void CopyProperties(object source, object target, bool onlyNonByRef = false)
{
if (source is null)
throw new ArgumentNullException(nameof(source));
if (target is null)
throw new ArgumentNullException(nameof(target));
// Get type of the destination object.
var sourceProperties = GetProperties(source.GetType());
var targetProperties = GetProperties(target.GetType());
foreach (var sm in sourceProperties)
{
// Get destination property and skip if not found.
var tm = targetProperties.FirstOrDefault(x => Equals(x.Name, sm.Name));
if (!sm.CanRead || !tm.CanWrite)
continue;
bool useJson;
if (!CanCopy(sm.PropertyType, tm.PropertyType, onlyNonByRef, out useJson))
continue;
// Get source value.
var sValue = sm.GetValue(source, null);
if (useJson)
sValue = Serialize(sValue);
var update = true;
// If can read target value.
if (tm.CanRead)
{
// Get target value.
var dValue = tm.GetValue(target, null);
if (useJson)
dValue = Serialize(dValue);
// Update only if values are different.
update = !Equals(sValue, dValue);
}
if (update)
{
if (useJson)
sValue = Deserialize(sValue as string, tm.PropertyType);
tm.SetValue(target, sValue, null);
}
}
}
///
/// Returns true if all properties with the same name are equal.
///
public static bool EqualProperties(object source, object target, bool onlyNonByRef = false)
{
if (source is null)
throw new ArgumentNullException(nameof(source));
if (target is null)
throw new ArgumentNullException(nameof(target));
// Get type of the destination object.
var sourceProperties = GetProperties(source.GetType());
var targetProperties = GetProperties(target.GetType());
foreach (var sm in sourceProperties)
{
// Get destination property and skip if not found.
var tm = targetProperties.FirstOrDefault(x => Equals(x.Name, sm.Name));
if (!sm.CanRead)
continue;
bool useJson;
if (!CanCopy(sm.PropertyType, tm.PropertyType, onlyNonByRef, out useJson))
continue;
// Get source value.
var sValue = sm.GetValue(source, null);
if (useJson)
sValue = Serialize(sValue);
var update = true;
// If can read target value.
if (tm.CanRead)
{
// Get target value.
var dValue = tm.GetValue(target, null);
if (useJson)
dValue = Serialize(dValue);
// Update only if values are different.
update = !Equals(sValue, dValue);
}
// If update needed then not equal.
if (update)
return false;
}
return true;
}
#endregion
#region Convert: Object <-> Bytes
// Note: Similar as "Structure <-> Bytes", but with ability to convert variable strings.
public static byte[] ObjectToBytes(T o)
{
using (var ms = new MemoryStream())
{
var flags = BindingFlags.Instance | BindingFlags.Public;
var props = typeof(T).GetProperties(flags);
using (var writer = new BinaryWriter(ms))
{
foreach (var p in props)
{
var value = p.GetValue(o);
switch (value)
{
case bool v:
writer.Write(v); break;
case byte v:
writer.Write(v); break;
case byte[] v:
writer.Write(v); break;
case char[] v:
writer.Write(v); break;
case char v:
writer.Write(v); break;
case decimal v:
writer.Write(v); break;
case double v:
writer.Write(v); break;
case float v:
writer.Write(v); break;
case int v:
writer.Write(v); break;
case long v:
writer.Write(v); break;
case sbyte v:
writer.Write(v); break;
case short v:
writer.Write(v); break;
case string v:
writer.Write(v); break;
case uint v:
writer.Write(v); break;
case ulong v:
writer.Write(v); break;
case ushort v:
writer.Write(v); break;
default:
break;
}
}
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
return ms.ToArray();
}
}
}
public static T BytesToObject(byte[] bytes)
{
using (var ms = new MemoryStream(bytes))
{
var o = Activator.CreateInstance();
var flags = BindingFlags.Instance | BindingFlags.Public;
var props = typeof(T).GetProperties(flags);
using (var reader = new BinaryReader(ms))
{
foreach (var p in props)
{
var typeCode = Type.GetTypeCode(p.PropertyType);
object v;
switch (typeCode)
{
case TypeCode.Boolean:
v = reader.ReadBoolean();
break;
case TypeCode.Char:
v = reader.ReadChar();
break;
case TypeCode.DBNull:
v = DBNull.Value;
break;
case TypeCode.DateTime:
v = new DateTime(reader.ReadInt64());
break;
case TypeCode.Decimal:
v = reader.ReadDecimal();
break;
case TypeCode.Double:
v = reader.ReadDouble();
break;
case TypeCode.Empty:
v = null;
break;
case TypeCode.SByte:
v = reader.ReadSByte();
break;
case TypeCode.Int16:
v = reader.ReadInt16();
break;
case TypeCode.Int32:
v = reader.ReadInt32();
break;
case TypeCode.Int64:
v = reader.ReadInt64();
break;
case TypeCode.Single:
v = reader.ReadSingle();
break;
case TypeCode.String:
v = reader.ReadString();
break;
case TypeCode.Byte:
v = reader.ReadByte();
break;
case TypeCode.UInt16:
v = reader.ReadUInt16();
break;
case TypeCode.UInt32:
v = reader.ReadUInt32();
break;
case TypeCode.UInt64:
v = reader.ReadUInt64();
break;
default:
throw new Exception("Non Serializable Object: " + p.PropertyType);
}
p.SetValue(o, v);
}
}
return o;
}
}
#endregion
#region Convert: Structure <-> Bytes
///
/// Convert structure to byte array (unmanaged block of memory).
///
public static byte[] StructureToBytes(T value) where T : struct
{
var size = Marshal.SizeOf(value);
var bytes = new byte[size];
var handle = default(GCHandle);
try
{
handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
Marshal.StructureToPtr(value, handle.AddrOfPinnedObject(), false);
}
finally
{
if (handle.IsAllocated)
handle.Free();
}
return bytes;
}
public static T BytesToStructure(byte[] bytes) where T : struct
{
return (T)BytesToStructure(bytes, typeof(T));
}
///
/// Convert byte array (unmanaged block of memory) to structure.
///
public static object BytesToStructure(byte[] bytes, Type type)
{
if (type is null)
throw new ArgumentNullException(nameof(type));
var value = type.IsValueType ? Activator.CreateInstance(type) : null;
var handle = default(GCHandle);
try
{
handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
value = Marshal.PtrToStructure(handle.AddrOfPinnedObject(), type);
}
finally
{
if (handle.IsAllocated)
handle.Free();
}
return value;
}
#endregion
#region Try Parse
///
/// Tries to convert the specified string representation of a logical value to
/// its type T equivalent. A return value indicates whether the conversion
/// succeeded or failed.
///
/// A string containing the value to try and convert.
/// target type
/// If the conversion was successful, the converted value of type T.
/// If value was converted successfully, true; otherwise false.
public static bool TryParse(object value, Type t, out object result)
{
if (IsNullable(t))
t = Nullable.GetUnderlyingType(t) ?? t;
//var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
//if (converter.IsValid(value))
//{
// result = (T)converter.ConvertFromString(value);
// return true;
//}
if (t == typeof(string))
{
result = value;
return true;
}
if (t.IsEnum)
{
var retValue = value is null ? false : Enum.IsDefined(t, value?.ToString());
result = retValue ? Enum.Parse(t, value?.ToString()) : default;
return retValue;
}
var tryParseMethod = t.GetMethod("TryParse",
BindingFlags.Static | BindingFlags.Public, null,
new[] { typeof(string), t.MakeByRefType() }, null);
var parameters = new object[] { value, null };
var retVal = (bool)tryParseMethod.Invoke(null, parameters);
result = parameters[1];
return retVal;
}
///
/// Tries to convert the specified string representation of a logical value to
/// its type T equivalent. A return value indicates whether the conversion
/// succeeded or failed.
///
/// The type to try and convert to.
/// A string containing the value to try and convert.
/// If the conversion was successful, the converted value of type T.
/// If value was converted successfully, true; otherwise false.
public static bool TryParse(string value, out T result)
{
var t = typeof(T);
object o;
var success = TryParse(value, t, out o);
result = (T)o;
return success;
}
///
/// Tries to convert the specified string representation of a logical value to
/// its type T equivalent. Returns default value if conversion failed.
///
public static T TryParse(string value, T defaultValue = default(T))
{
var result = default(T);
return TryParse(value, out result)
? result
: defaultValue;
}
///
/// Tries to convert the specified string representation of a logical value to
/// its type T equivalent. Returns default value if conversion failed.
///
public static bool CanParse(string value)
{
T result;
return TryParse(value, out result);
}
public static bool IsNullable(Type t)
{
// Throw exception if type not supplied.
if (t is null)
throw new ArgumentNullException(nameof(t));
// Special Handling - known cases where Exceptions would be thrown
else if (t == typeof(void))
throw new Exception("There is no Nullable version of void");
// If this is not a value type, it is a reference type, so it is automatically nullable.
// (NOTE: All forms of Nullable are value types)
if (!t.IsValueType)
return true;
// Return true if underlying Type exists (this is faster than line above).
return Nullable.GetUnderlyingType(t) != null;
}
#endregion
///
/// Convert year values from 0 to 99 to the years xx00 to yy99 with appropriate century.
///
/// A two-digit or four-digit integer that represents the year to convert.
/// The last year of a 100-year range that can be represented by a 2-digit year.
/// An integer that contains the four-digit representation of year.
///
/// Use C# solution from System.Globalization.Calendar.ToFourDigitYear(System.Int32 year).
/// For example, if TwoDigitYearMax is set to 2029, the 100-year range is from 1930 to 2029:
/// a 2-digit value of 30 is interpreted as 1930
/// a 2-digit value of 29 is interpreted as 2029
///
public static int ToFourDigitYear(int year, int? twoDigitYearMax = null)
{
// If year is outside of the range then return.
if (year < 0 && year > 99)
return year;
// Convert year from 2 to 4 digits with the correct century (-50/+50 rule).
// JavaScript: By default, new Date(..) convert values from 0 to 99 to the years 1900 to 1999.
//var twoDigitYearMax = new Date().getFullYear() + 50;
var fullYearMax = twoDigitYearMax ?? DateTime.Now.Year + 50;
var yearMax = fullYearMax % 100;
var century = (fullYearMax - yearMax) / 100;
var fullYear = (century - (year > yearMax ? 1 : 0)) * 100 + year;
return fullYear;
}
}
}
================================================
FILE: FocusLogger/JocysCom/Runtime/Serializer.cs
================================================
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
namespace JocysCom.ClassLibrary.Runtime
{
public static class Serializer
{
#region Helper Functions
///
/// Read file content in multiple attempts.
///
/// The file to open for reading.
/// Number of attempts to read from the file. Default 2 times.
/// Wait time between attempts. Default 500ms.
/// A byte array containing the contents of the file.
public static byte[] ReadFile(string path, int attempts = 2, int waitTime = 500)
{
while (true)
{
attempts -= 1;
try
{
// SUPPRESS: CWE-73: External Control of File Name or Path
// Note: False Positive. File path is not externally controlled by the user.
return System.IO.File.ReadAllBytes(path);
}
catch (Exception)
{
if (attempts > 0)
{
new System.Threading.ManualResetEvent(false).WaitOne(waitTime);
continue;
}
throw;
}
}
}
///
/// Write file content in multiple attempts.
///
/// The file to open for writing.
/// The bytes to write to the file.
/// Number of attempts to write into the file. Default 2 times.
/// Wait time between attempts. Default 500ms.
public static void WriteFile(string path, byte[] bytes, int attempts = 2, int waitTime = 500)
{
while (true)
{
attempts -= 1;
try
{
// WriteAllBytes will lock file for writing and reading.
// SUPPRESS: CWE-73: External Control of File Name or Path
// Note: False Positive. File path is not externally controlled by the user.
System.IO.File.WriteAllBytes(path, bytes);
return;
}
catch (Exception)
{
if (attempts > 0)
{
new System.Threading.ManualResetEvent(false).WaitOne(waitTime);
continue;
}
throw;
}
}
}
#endregion
#region JSON
#if NETFRAMEWORK
/// Cache data for speed.
/// Cache allows for this class to work 20 times faster.
private static ConcurrentDictionary JsonSerializers = new ConcurrentDictionary();
static DataContractJsonSerializer GetJsonSerializer(Type type, DataContractJsonSerializerSettings settings = null)
{
if (type == null)
return null;
return JsonSerializers.GetOrAdd(type, x => new DataContractJsonSerializer(type, settings));
}
#endif
public static Func _SerializeToJson;
public static Func _DeserializeFromJson;
#if !NETFRAMEWORK
private static System.Text.Json.JsonSerializerOptions GetJsonOptions()
{
var options = new System.Text.Json.JsonSerializerOptions();
options.DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull;
options.PropertyNamingPolicy = null;
options.WriteIndented = true;
options.MaxDepth = 64;
// Add support for de-serializing enumeration strings.
options.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter());
return options;
}
#endif
///
/// Serialize object to JSON string.
///
/// The object to serialize.
/// JSON string encoding.
/// JSON string.
public static string SerializeToJson(object o, Encoding encoding = null)
{
if (_SerializeToJson != null)
return _SerializeToJson(o, encoding);
if (o is null)
return null;
#if NETFRAMEWORK
var serializer = GetJsonSerializer(o.GetType());
var ms = new MemoryStream();
lock (serializer) { serializer.WriteObject(ms, o); }
if (encoding is null)
encoding = Encoding.UTF8;
var json = encoding.GetString(ms.ToArray());
ms.Close();
return json;
#else
var options = GetJsonOptions();
var json = System.Text.Json.JsonSerializer.Serialize(o, o.GetType(), options);
return json;
#endif
}
///
/// De-serialize object from JSON string.
///
/// JSON string representing object.
/// Type of object.
/// JSON string encoding.
/// The de-serialized object.
public static object DeserializeFromJson(string json, Type type, Encoding encoding = null)
{
if (_DeserializeFromJson != null)
return _DeserializeFromJson(json, type, encoding);
if (json is null)
return null;
#if NETFRAMEWORK
var serializer = GetJsonSerializer(type);
if (encoding is null)
encoding = Encoding.UTF8;
var bytes = encoding.GetBytes(json);
var ms = new MemoryStream(bytes);
object o;
lock (serializer) { o = serializer.ReadObject(ms); }
ms.Close();
return o;
#else
var options = GetJsonOptions();
var o = System.Text.Json.JsonSerializer.Deserialize(json, type, options);
return o;
#endif
}
///
/// De-serialize object from JSON string.
///
/// JSON string representing object.
/// JSON string encoding.
/// The de-serialized object.
public static T DeserializeFromJson(string json, Encoding encoding = null)
{
return (T)DeserializeFromJson(json, typeof(T), encoding);
}
// Created by: https://stackoverflow.com/users/17211/vince-panuccio
// https://stackoverflow.com/questions/4580397/json-formatter-in-c
public static string FormatJson(string json, string indent = "\t")
{
var indentation = 0;
var quoteCount = 0;
var escapeCount = 0;
var result =
from ch in json ?? string.Empty
let escaped = (ch == '\\' ? escapeCount++ : escapeCount > 0 ? escapeCount-- : escapeCount) > 0
let quotes = ch == '"' && !escaped ? quoteCount++ : quoteCount
let unquoted = quotes % 2 == 0
let colon = ch == ':' && unquoted ? ": " : null
let nospace = char.IsWhiteSpace(ch) && unquoted ? string.Empty : null
let lineBreak = ch == ',' && unquoted ? ch + Environment.NewLine + string.Concat(Enumerable.Repeat(indent, indentation)) : null
let openChar = (ch == '{' || ch == '[') && unquoted ? ch + Environment.NewLine + string.Concat(Enumerable.Repeat(indent, ++indentation)) : ch.ToString()
let closeChar = (ch == '}' || ch == ']') && unquoted ? Environment.NewLine + string.Concat(Enumerable.Repeat(indent, --indentation)) + ch : ch.ToString()
select colon ?? nospace ?? lineBreak ?? (openChar.Length > 1 ? openChar : closeChar);
return string.Concat(result);
}
//public static string FormatJson(string json, bool indent = true)
//{
// using document = JsonDocument.Parse(json);
// using var stream = new MemoryStream();
// using var writer = new Utf8JsonWriter(stream, new JsonWriterOptions() { Indented = indent });
// document.WriteTo(writer);
// writer.Flush();
// return Encoding.UTF8.GetString(stream.ToArray());
//}
#endregion
#region XML
///
/// Reformat XML document.
///
///
///
public static string XmlFormat(string xml)
{
var xd = new XmlDocument();
xd.XmlResolver = null;
xd.LoadXml(xml);
var sb = new StringBuilder();
var xws = new XmlWriterSettings();
xws.Indent = true;
xws.CheckCharacters = true;
// XmlReader normalizes all newlines and converts '\r\n' to '\n'.
// This requires to save NewLines with option which
// "Entitize" option replace '\r' with '
' in text node values.
xws.NewLineHandling = NewLineHandling.Entitize;
var xw = XmlWriter.Create(sb, xws);
xd.WriteTo(xw);
xw.Close();
return sb.ToString();
}
static object XmlSerializersLock = new object();
static Dictionary XmlSerializers;
public static XmlSerializer GetXmlSerializer(Type type)
{
lock (XmlSerializersLock)
{
if (XmlSerializers is null)
XmlSerializers = new Dictionary();
if (!XmlSerializers.ContainsKey(type))
{
var extraTypes = new Type[] { typeof(string) };
XmlSerializers.Add(type, new XmlSerializer(type, extraTypes));
}
}
return XmlSerializers[type];
}
#endregion
#region XML: Serialize
///
/// Serialize object to XML document.
///
/// The object to serialize.
/// XML document
public static XmlDocument SerializeToXml(object o)
{
if (o is null)
return null;
var serializer = GetXmlSerializer(o.GetType());
var ms = new MemoryStream();
lock (serializer) { serializer.Serialize(ms, o); }
ms.Seek(0, SeekOrigin.Begin);
var doc = new XmlDocument();
doc.XmlResolver = null;
// Settings used to protect from:
// SUPPRESS: CWE-611: Improper Restriction of XML External Entity Reference('XXE')
// https://cwe.mitre.org/data/definitions/611.html
var settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Ignore;
settings.XmlResolver = null;
settings.CloseInput = false;
var reader = XmlReader.Create(ms, settings);
doc.Load(reader);
reader.Dispose();
ms.Close();
return doc;
}
static T SeriallizeToXml(object o, Encoding encoding = null, bool omitXmlDeclaration = false, string comment = null, bool indent = true)
{
if (o is null)
return default(T);
// Create serialization settings.
encoding = encoding ?? Encoding.UTF8;
var settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = omitXmlDeclaration;
settings.Encoding = encoding;
settings.Indent = indent;
// XmlReader normalizes all newlines and converts '\r\n' to '\n'.
// This requires to save NewLines with option which
// "Entitize" option replace '\r' with '
' in text node values.
settings.NewLineHandling = NewLineHandling.Entitize;
// Serialize.
var serializer = GetXmlSerializer(o.GetType());
// Serialize in memory first, so file will be locked for shorter times.
var ms = new MemoryStream();
var xw = XmlWriter.Create(ms, settings);
try
{
lock (serializer)
{
if (!string.IsNullOrEmpty(comment))
{
xw.WriteStartDocument();
xw.WriteComment(comment);
}
if (omitXmlDeclaration)
{
//Create our own namespaces for the output
var ns = new XmlSerializerNamespaces();
//Add an empty namespace and empty value
ns.Add("", "");
serializer.Serialize(xw, o, ns);
}
else
{
serializer.Serialize(xw, o);
}
if (!string.IsNullOrEmpty(comment))
{
xw.WriteEndDocument();
}
// Make sure that all data flushed into memory stream.
xw.Flush();
}
}
catch (Exception)
{
throw;
}
finally
{
// This will close underlying MemoryStream too.
xw.Close();
}
// ToArray will return all bytes from memory stream despite it being closed.
// Bytes will start with Byte Order Mark(BOM) and are ready to write into file.
var xmlBytes = ms.ToArray();
// If string must be returned then...
if (typeof(T) == typeof(string))
{
// Use StreamReader to remove Byte Order Mark(BOM).
var ms2 = new MemoryStream(xmlBytes);
var sr = new StreamReader(ms2, true);
var xmlString = sr.ReadToEnd();
// This will close underlying MemoryStream too.
sr.Close();
return (T)(object)xmlString;
}
else
{
return (T)(object)xmlBytes;
}
}
///