From 41cd87b2f4d161c3984b8645af3c24af42c65090 Mon Sep 17 00:00:00 2001 From: MattMo Date: Fri, 27 Jan 2023 11:34:31 -0800 Subject: [PATCH] Working on initial project structure. --- .gitignore | 263 +++++++++++++++++ Logo_Symbol_Black_Outline.png | Bin 0 -> 9759 bytes MySqlPlus.Example/MySqlPlus.Example.csproj | 16 + MySqlPlus.Example/Program.cs | 34 +++ MySqlPlus.Tests/MySqlPlus.Tests.csproj | 30 ++ MySqlPlus.sln | 37 +++ MySqlPlus/GlobalTimeStamp.cs | 165 +++++++++++ MySqlPlus/MySqlColumn.cs | 22 ++ MySqlPlus/MySqlColumnAlias.cs | 18 ++ MySqlPlus/MySqlManagedConnection.cs | 324 +++++++++++++++++++++ MySqlPlus/MySqlPlus.csproj | 15 + MySqlPlus/MySqlRow.cs | 12 + MySqlPlus/MySqlRowId.cs | 13 + MySqlPlus/MySqlSession.cs | 128 ++++++++ MySqlPlus/MySqlSessionCache.cs | 264 +++++++++++++++++ 15 files changed, 1341 insertions(+) create mode 100644 .gitignore create mode 100644 Logo_Symbol_Black_Outline.png create mode 100644 MySqlPlus.Example/MySqlPlus.Example.csproj create mode 100644 MySqlPlus.Example/Program.cs create mode 100644 MySqlPlus.Tests/MySqlPlus.Tests.csproj create mode 100644 MySqlPlus.sln create mode 100644 MySqlPlus/GlobalTimeStamp.cs create mode 100644 MySqlPlus/MySqlColumn.cs create mode 100644 MySqlPlus/MySqlColumnAlias.cs create mode 100644 MySqlPlus/MySqlManagedConnection.cs create mode 100644 MySqlPlus/MySqlPlus.csproj create mode 100644 MySqlPlus/MySqlRow.cs create mode 100644 MySqlPlus/MySqlRowId.cs create mode 100644 MySqlPlus/MySqlSession.cs create mode 100644 MySqlPlus/MySqlSessionCache.cs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2f5fbf7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,263 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ + +# Visual Studio 2015 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# DNX +project.lock.json +project.fragment.lock.json + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# TODO: Comment the next line if you want to checkin your web deploy settings +# but database connection strings (with potential passwords) will be unencrypted +#*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config +# NuGet v3's project.json files produces more ignoreable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +node_modules/ +orleans.codegen.cs + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# JetBrains Rider +.idea/ +*.sln.iml + +# CodeRush +.cr/ + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +#Mac Store files +.DS_Store diff --git a/Logo_Symbol_Black_Outline.png b/Logo_Symbol_Black_Outline.png new file mode 100644 index 0000000000000000000000000000000000000000..b30f9bc2731ad8e94d686738bf0a3a67be881d06 GIT binary patch literal 9759 zcmXY1cQ~8h+mBUA%_L@x7$J5OiWIfgrbg{e@wK&ft!j$cMeVKBF0D}%r9p>UrPQcB zYP3?Lw)fHB`$w)k=Q-y-_c-_Xocnt4cl6Y0u3oze0)c2WHB=2jAQA-d69iuY-c0rW6q#)CaDKJy9P9EZH_&RX42lXOF*BIQQ%1yMi3@ZxCGcF7I|8jH9%|GS|O zPNdpR45~=CuoYo?SQq%A>S%0aPUBOPWkg>1$jR@Hm_UxmY!#Vz;32Qvor>mX`f3IY zlzUfQ%g(X2;jWD2pezJZrf~x^`L$=aew)TzE0lp847%f3u~Q+oSjx^>)ZyJ}aB=Xu zuu?slb72yMCM$?I58hXZIDc&sydk*TYhlBQ$S0^PMS`*4sxjOU)|Q@AL<{rmI9iYN=nP9|mNbh(%L%fyl-w0XpR#mG@5 z7k^NU`e58m0?Jk{bh#bGxiJ*seFaaa6ARMG<>v2^x-uJZ_Z=DeyFKv23K6P$sbZui z)H29egJ`e=B0)oxLxMxe84(mDq+ITOFiu95PzHe5Nz)Z>&!%FzErRAIO<~69;5=2$ zkBr~pvZVcZQo9~!EDl|)t0zt<3!5MBe$1DBlV1S3Ttr|(=qL}+Z}<%(R-K%n_5o zHLB$nd_AZud?WqH>7!~8x_qYsLs0J~OQ-NIyjeO}a1*{Yk-l~O+4hrTd`OCpAr)N%;C^}~pe2U@skD5|(2UzmIR zO+d(sU7`buunG5EoL}Ihbe`eAYDaC&-AOHmvj0P`0R?N1m^1 zW9LjwxQG9=ziC9ri|UznUOA|666@zZqR)&M$MUbg`{GBa+x>swRTSB4S6yBfS#GX< z`{rW>H_QfS>y=9kVv)xOr%JV}?Ot)o*Gju=7sR;@+nESUf?*Ul-V}KkZuGyf;CUHR zK>at2au453$MH4L$13en2y{?=F zCC0eBV_!iu?(rC(4;{9-do!QC*Txj4|Itw~9NOOA0w!{`iVtz2%N^Kjtv8^V73+ zi#w&3&07I9^jBaUeH~WeKW+^|ZkQrvYTqwu z5Tlk#cY*>c+B;C-8#HByl$p?V(-{%8Z@iv$s-cC*r*@G@OAq>CXN#Hyk8Cx z+H}p?mfpYX08TSd_ym7tiHo2*88G2A5t_Bqc4NK*s(OmBnhtnPFS{ae)57Hy_UVbyd7}2#WosrSG)SLO5q;N;~kDA zpV2~$t-5e-oF>Z8@ZvYKZTfzpcjr<0X-;d8;lzN)cj-3g_JIuuHOeH5eVj;{%SXH!unNaMPO z^pxxFQF<;(<*iR1TD){AaUC^ZTWr~8UL^^wXOWF@RMDaP|3n#lwzR!JZk{-g?ybVi z#o#E}wBPfLs7~H{5LA6AAgbs$ba8Zc;>?$?H}$YV_@^Y?K_zm%b@&f$8h!ij-B38QHYe zUZ3on?!)nM;VQLNVK;Z!A4bc(*P+Gs%xZlVopfjjvY`4JEq`V2LjP-3CY00NmSsFH zG@N^wMrJPCT!(NF+w)!zxzbi5CiCRVsOX?DO3x?4-=Co5l!apfS>Vx4a%xbYyZ*DXkY=9y`kqSYBs#Q3>aDLB-f`Ls#*6n_&f zuDUgC#BSy04Uze`qBW$T2j<@o;NLP!oR^u4{yfFL_f* zfj_@!VB&B;jUFvd(I}%)PXcO4NPO~r7q15G*BTx^WS_IeKs$=0e(O8-bytiVO4?2P zo4Cw53*ufa`TjwUx{{?<S0fk9?K0vXdOxbYCg~L+(1g$2I)w znLN_5({(aHO+zOLW&;F5@>ls)K_Mz@s985%VEVQX(Eyko&d$It ziRc1F52z||9#DP}$|4f>~)o1G>}`7i=sb?Blj&}1OtM)J&Xr*GJLdJ zA*=TZ5Yct9)J~b)&IBO64OC`0PZs8Z1hg5`b|{cV-%Xue3Q!^ct&woNJfBp2auftQ zfNRYGPiy?s2<^M-0mw2bSJ1H2a|!tFamf1n1)Qb^LbUH)%8)u2a92Z;o0LAqJR7{}W9@|bceo^A z!j=w>@nzS+wTYi;zSDPKh;xf`pxnCEZC{N-N=l<5V7q_!?8cuxqqw$}LqkrYdYwby z5x??XN$;&c6tjP~BvSMi2}bBk`SqY2CoLQyyTY_4i&25Oa47Cp%a5(EC8vsx|DTo<+Y zWGxS6az&X@9h|Y)(P1BrUQk`O|8?SGS_oik!>7(X9^d8M{h#*6C&SPXDCj?p8&Jc? zvCx8;@|`=0aWbFGW0PUPAt+u2cqKh0j2|wBx%Co53F?qbKy>0eh~?-}ohS z{J%XSjh&o%8gcz1NiHaPt#?ROP#?bv+};sIYRW!jc!{d)ZZEs>)Xc{%3AtQ4P1KQH zHrRWvmG_5g1$!?suBKPL8wci3`mCCz71Wjmwg%p9^-}VyqVL|9g0{si`M+ZR=M7w9 zaPHcm`)KHWNue~&*vrG$0T<%Y&oW=c;Om=yO0fRh9x`8*HXMhNhTBsx_TNN|J_i64 z4lLg1!t*xlBp{VpilACy5x11~&!<1oPi$W;O9uq>5KhwnCoUInD1VPJQA0%+_nDy| zC43nwDRgP#P%%sP!p2KqeB@K^%45}xl@BI9f#lWK+J%TKYUdh&u zXX^?fhJ;^rm@y07PDbvcM-KMB?QmEDQV)MEp;w3PP-86zNQl{7b^$bFLU_ z0py<0voXQC#~9)D{jVn}SF^w|Bt&ykZhnGgn|1>oBRrWyR%-NRCPjyrI%fYHi~bE1 zyx7pK{X8;#5le8^-^E$`!!fG^zE0+ggLOak10gKl!=*l|zkx$xX4Lj3UF@u!Ja zRgB~n)*Nu)CY_dWl1gZZqV`z)0nGmf-LOML(e%r{n8aWEpBcMVDJryqmD$-~X(W&> zBMwHQSt$Y&*`VIF>(`UaDI<(N{8ulKdl5J?h_9YTLvImnk?9b);4 zds7@AcLJamzx$-d0sBdul8EL2Cv_w1x7`xtCyPBxjEx4YFwH)Up>(4VOEp<Mh8#1#W`Y-p%db`<{3Q7wsEu^dG+0I5?Ij%JFb3nV^>GQ~e`u(jA$88?gj8lyF8 z82a78O(d=)=-s%c&8jq1J;vl};at~macGVWX9K@-l*#LXeB;&}QSbJ>Ge5^{8%CiQ zo#q%RH23i%eEr9C9h{$mJ|xZQSla5qYY1kR&_V>iM;P5Lt)`Io=uS2?4T9_U}gUdP^e zAjRGDKL%@)Ha;Ado6Xfp?!h7JI}7)VWY+2YgV}q(xx6s*V07RK9T?X%3=XbOR8WQW|+Q5fTHigWaNk^g(gc+UKOKZmA@3baw>rFT8*M$mU$IFy9p10YtJU|1? zF176WJNGb|%FAkFQmnnfZ`z~#;X!^RtU^@_IWSu=qcg#Whb#a4|zj^%k6lmLv)lEDop)lnzfV1e46Gf4Hf=f&a z0J{}`G1kEqgp3DdI=1h9dZ8@*=kc*)>Mx}S&O)oQfGd?d@H`)9%LZ3^-Lo67o?4gF z(Gg~IH+C$bUw;Q=Z@_5)0AV&OC0_WT+NO!RgP(OHZC!Z@Urd3(<>~&L{|{EY)J!y) zYjauyU`AaOXEuE|`o6?Jv+}|1soM!ftb@nT-59da(Y(~H+4S~29^!m(ZoD3KyJ{@S zpUrZRt{_H&ua$t|9enfAcroEwyE`l4g``>N9(*##!J(Y|dG7xc*>9aTDoGZ~h#8F) zGutRqg>xC|#`;+O)UA(ez?v9MEaH85+-M#u5F;fR;y+{6rPu-OLYCHg@srmSN zn8EEJv6wB3D>O7?`ZdJcYcMkuN2Tw;l~@U{)O&eE^@*45Cf=U?UGQ$W_I{YB$s_+( zt`VFW8GjGI7<@tZqi>%l9*`ZDx#jj%+*x=Sisx6&0?THDlgAKgPCS0G>s~dhN&__k z)w-6P6@P!k9}2HMs>eDLSf_n_`!bQa;9ERxV?hb>uX7o+}4@O z6C~_i>NC!t#U4ℜ6$HvR5k)tOw?>(G;#JCtx)W$ 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 z + + + Exe + net6.0 + disable + disable + MontoyaTech.MySqlPlus.Example + MontoyaTech.MySqlPlus.Example + + + + + + + diff --git a/MySqlPlus.Example/Program.cs b/MySqlPlus.Example/Program.cs new file mode 100644 index 0000000..ae34b7e --- /dev/null +++ b/MySqlPlus.Example/Program.cs @@ -0,0 +1,34 @@ +using System; + +namespace MontoyaTech.MySqlPlus.Example +{ + public class Program + { + public class Car : MySqlRow + { + [MySqlRowId] + [MySqlColumn] + public ulong Id = 0; + + [MySqlColumn("make")] + [MySqlColumnAlias("Make")] + public string Make = null; + + [MySqlColumn("mode")] + public string Model = null; + + [MySqlColumn("dateCreated", typeof(DateTime2UnixConverter))] + public DateTime DateCreated = DateTime.UtcNow; + } + + public class DateTime2UnixConverter + { + + } + + public static void Main(string[] args) + { + Console.WriteLine("Hello, World!"); + } + } +} \ No newline at end of file diff --git a/MySqlPlus.Tests/MySqlPlus.Tests.csproj b/MySqlPlus.Tests/MySqlPlus.Tests.csproj new file mode 100644 index 0000000..6183c01 --- /dev/null +++ b/MySqlPlus.Tests/MySqlPlus.Tests.csproj @@ -0,0 +1,30 @@ + + + + net6.0 + disable + disable + false + MontoyaTech.MySqlPlus.Tests + MontoyaTech.MySqlPlus.Tests + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + + diff --git a/MySqlPlus.sln b/MySqlPlus.sln new file mode 100644 index 0000000..221c398 --- /dev/null +++ b/MySqlPlus.sln @@ -0,0 +1,37 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33213.308 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MySqlPlus", "MySqlPlus\MySqlPlus.csproj", "{EC8F451D-E711-4FF2-87F5-B65F21570785}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MySqlPlus.Example", "MySqlPlus.Example\MySqlPlus.Example.csproj", "{2DC4B2B2-D391-475C-A792-D451A765259E}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MySqlPlus.Tests", "MySqlPlus.Tests\MySqlPlus.Tests.csproj", "{D10C9285-D11A-43FC-A234-1D5846CD97F8}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {EC8F451D-E711-4FF2-87F5-B65F21570785}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EC8F451D-E711-4FF2-87F5-B65F21570785}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EC8F451D-E711-4FF2-87F5-B65F21570785}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EC8F451D-E711-4FF2-87F5-B65F21570785}.Release|Any CPU.Build.0 = Release|Any CPU + {2DC4B2B2-D391-475C-A792-D451A765259E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2DC4B2B2-D391-475C-A792-D451A765259E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2DC4B2B2-D391-475C-A792-D451A765259E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2DC4B2B2-D391-475C-A792-D451A765259E}.Release|Any CPU.Build.0 = Release|Any CPU + {D10C9285-D11A-43FC-A234-1D5846CD97F8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D10C9285-D11A-43FC-A234-1D5846CD97F8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D10C9285-D11A-43FC-A234-1D5846CD97F8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D10C9285-D11A-43FC-A234-1D5846CD97F8}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {AC9C73B2-A516-4430-9434-CB2AF7B47147} + EndGlobalSection +EndGlobal diff --git a/MySqlPlus/GlobalTimeStamp.cs b/MySqlPlus/GlobalTimeStamp.cs new file mode 100644 index 0000000..648cd8f --- /dev/null +++ b/MySqlPlus/GlobalTimeStamp.cs @@ -0,0 +1,165 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + /// + /// This timestamp runs on its own and it + /// uses very little CPU usage to keep track of time. This is a very + /// useful system. This timestamp is in elapsed miliseconds. + /// + internal class GlobalTimeStamp : IDisposable + { + /// + /// This is the instance of the time stamp which is used + /// to auto start this. + /// + public static GlobalTimeStamp instance = new GlobalTimeStamp(); + + /// + /// The Current Timestamp, elapsed time since the begining in Miliseconds. + /// + public static ulong Current + { + get + { + return instance._Current; + } + } + + /// + /// The StopWatch that the TimeStamp uses + /// + private Stopwatch Watch = null; + + /// + /// Whether or not this Timestamp Is Running. + /// + private bool Running = false; + + /// + /// The Refresh Thread for this GlobalTimeStamp. + /// + private Thread RefreshThread = null; + + /// + /// The Current Timestamp, elapsed time since the begining in Miliseconds. + /// + public ulong _Current = 777; //Initialize this value so we have something. + + /// + /// A new instance of the GlobalTimeStamp + /// + public GlobalTimeStamp() + { + //Start the watch. + this.Watch = new Stopwatch(); + this.Watch.Start(); + + //Setup the Refresh Thread + this.Running = true; + this.RefreshThread = new Thread(Refresh); + this.RefreshThread.IsBackground = true; + this.RefreshThread.Start(); + } + + /// + /// The method that handles Refreshing the TimeStamp. + /// + private void Refresh() + { + while (this.Running) + { + //Get the elapsed miliseconds from the watch + this._Current = (ulong)this.Watch.ElapsedMilliseconds; + + //Now sleep 1MS + Thread.Sleep(1); + } + } + + /// + /// Returns the Difference between two TimeStamps in miliseconds. + /// Note: + /// We needed this function because sometimes we + /// store a timestamp of when an event occured but when + /// using multi threading if this is greater than the last + /// time we got the current time, then we need to select the bigger one. + /// + /// + /// + /// The difference in miliseconds. + public static ulong GetDifference(ulong a, ulong b) + { + if (a > b) + return (a - b); + + return (b - a); + } + + /// + /// Returns the Difference in miliseconds between the Current Time and the passed + /// Time stamp. + /// Note: + /// We needed this function because sometimes we + /// store a timestamp of when an event occured but when + /// using multi threading if this is greater than the last + /// time we got the current time, then we need to select the bigger one. + /// + /// + /// The difference in miliseconds. + public static ulong GetDifference(ulong b) + { + //Get the current timestamp + ulong current = instance._Current; + //Compare it. + if (current > b) + return (current - b); + + return (b - current); + } + + /// + /// Disposes this GlobalTimeStamp if its Running. + /// + public void Dispose() + { + try + { + if (this.Running) + { + this.Running = false; + + this.Watch.Stop(); + + this.RefreshThread = null; + } + } + catch { } + } + + /// + /// Called when this GlobalTimeStamp is going to be destroyed. + /// + ~GlobalTimeStamp() + { + try + { + if (this.Running) + { + this.Running = false; + + this.Watch.Stop(); + + this.RefreshThread = null; + } + } + catch { } + } + } +} diff --git a/MySqlPlus/MySqlColumn.cs b/MySqlPlus/MySqlColumn.cs new file mode 100644 index 0000000..aacbffa --- /dev/null +++ b/MySqlPlus/MySqlColumn.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + public class MySqlColumn : Attribute + { + public string Name = null; + + public Type Converter = null; + + public MySqlColumn(string name = null, Type converter = null) + { + this.Name = name; + + this.Converter = converter; + } + } +} diff --git a/MySqlPlus/MySqlColumnAlias.cs b/MySqlPlus/MySqlColumnAlias.cs new file mode 100644 index 0000000..d825c3a --- /dev/null +++ b/MySqlPlus/MySqlColumnAlias.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + public class MySqlColumnAlias : Attribute + { + public string Alias = null; + + public MySqlColumnAlias(string alias) + { + this.Alias = alias; + } + } +} diff --git a/MySqlPlus/MySqlManagedConnection.cs b/MySqlPlus/MySqlManagedConnection.cs new file mode 100644 index 0000000..8a874b1 --- /dev/null +++ b/MySqlPlus/MySqlManagedConnection.cs @@ -0,0 +1,324 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using MySql.Data.MySqlClient; + +namespace MontoyaTech.MySqlPlus +{ + /// + /// The outline of a managed MySqlConnection that adds extra functionality like automatic + /// query retrying and reconnecting if the remote DB goes away or becomes busy. + /// + public class MySqlManagedConnection : IDisposable + { + /// + /// The Internal MySqlConnection for this managed copy. + /// + public MySqlConnection Internal = null; + + /// + /// The connection string that is used to repoen the connection. + /// + private string ConnectionString = null; + + /// + /// Wether or not we are connected to the remote server. + /// + public bool IsConnected + { + get + { + try + { + if (this.Internal == null || this.Internal.State != System.Data.ConnectionState.Open || !this.Internal.Ping()) + return false; + } + catch + { + return false; + } + + return true; + } + } + + /// + /// Creates a new managed MySqlConnection and sets its internal + /// MySql connection. + /// + /// + public MySqlManagedConnection(MySqlConnection conn) + { + if (string.IsNullOrWhiteSpace(conn.ConnectionString)) + throw new Exception("Connection string must be set on MySqlConnection."); + + this.Internal = conn; + this.ConnectionString = conn.ConnectionString; + } + + /// + /// Creates a new managed MySqlConnection and setups up the internal connection string and gets everything ready. + /// + /// + public MySqlManagedConnection(string conn) + { + if (string.IsNullOrWhiteSpace(conn)) + throw new Exception("Invalid connection string passed, it must not be null or empty."); + + this.Internal = new MySqlConnection(conn); + this.ConnectionString = conn; + } + + /// + /// Attempts to reconnect to the server and retrys if needed. + /// + public void Reconnect(int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true) + { + int backoffSleep = 2000; + for (int i = 0; i < maxRetrys; i++) + { + try + { + if (Internal == null) + { + Internal = new MySqlConnection(this.ConnectionString); + } + else + { + try { Internal.Close(); } catch { } + + try { Internal.Dispose(); } catch { } + + Internal = new MySqlConnection(this.ConnectionString); + } + + Internal.Open(); + + //If we are now connected then stop trying. + if (this.IsConnected) + break; + else + throw new Exception("Failed to open a valid MySqlConnection."); + } + catch (Exception ex) + { + //See if we have reached our max retry. + if (i + 1 >= maxRetrys || !retry) + throw; + + //If not backoff for a bit and see if the server comes back online. + if (exponentialBackoff) + { + Thread.Sleep(backoffSleep); + backoffSleep *= 2; + } + } + } + } + + /// + /// Opens a connection the remote server if we can. + /// + public void Open() + { + //Just invoke reconnect it handles everything for us. + this.Reconnect(); + } + + /// + /// Closes this managed connection. + /// + public void Close() + { + if (Internal != null) + { + try { Internal.Close(); } catch { } + } + } + + /// + /// Executes a data reader for a command and retrys + /// + /// + /// + /// + /// + /// + public MySqlDataReader ExecuteReader(MySqlCommand command, int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true) + { + int backoffSleep = 2000; + command.CommandTimeout = 60; //Time in seconds + + for (int i = 0; i < maxRetrys; i++) + { + ulong startTimestamp = GlobalTimeStamp.Current; + + try + { + command.Connection = this.Internal; + return command.ExecuteReader(); + } + catch (Exception ex) + { + //Get the inner most exception. + var innerException = ex; + while (innerException.InnerException != null) + innerException = innerException.InnerException; + + //Try to get the MySql error code + int code = -1; + if (ex is MySqlException) + code = ((MySqlException)ex).Number; + + //See if we have reached our max retry. + if (i + 1 >= maxRetrys || !retry) + throw; + + //See if the connection was invalid + if (innerException.GetType().IsAssignableFrom(typeof(System.Net.Sockets.SocketException)) || + innerException.GetType().IsAssignableFrom(typeof(MySqlConnection)) || + ex.GetType().IsAssignableFrom(typeof(MySqlConnection)) || + ex.Message.ToLower().Contains("connection must be valid and open") || + ex.Message.ToLower().Contains("a connection attempt failed because the connected party did not properly respond after a period of time") || + ex.Message.ToLower().Contains("an existing connection was forcibly closed by the remote host")) + { + //Attempt to reopen the connection. + this.Reconnect(maxRetrys, exponentialBackoff); + } + + //See if we should retry or just throw. + if (!ShouldRetryBasedOnMySqlErrorNum(code)) + throw; + + //If the operation took less than 5 seconds, then sleep. Otherwise continue right away. This is to prevent OpenRetry from making us wait even longer. + if (GlobalTimeStamp.GetDifference(startTimestamp) <= 5000 && exponentialBackoff) + { + Thread.Sleep(backoffSleep); + backoffSleep *= 2; + } + } + } + + throw new Exception($"MySql ExecuteReader failed. Max timeout reached. Query: {command.CommandText}"); + } + + /// + /// Executes a mysql command without a reader. + /// + /// + /// + /// + /// + public int ExecuteNonQuery(MySqlCommand command, int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true) + { + int backoffSleep = 2000; + command.CommandTimeout = 60; // time in seconds + + for (int i = 0; i < maxRetrys; i++) + { + ulong startTimestamp = GlobalTimeStamp.Current; + + try + { + command.Connection = this.Internal; + + return command.ExecuteNonQuery(); + } + catch (Exception ex) + { + //Get the inner most exception. + var innerException = ex; + while (innerException.InnerException != null) + innerException = innerException.InnerException; + + //Try to get the MySql error code if we can + int code = -1; + if (ex is MySqlException) + code = ((MySqlException)ex).Number; + + //See if we have reached our max retry. + if (i + 1 >= maxRetrys || !retry) + throw; + + //See if the connection was invalid + if (innerException.GetType().IsAssignableFrom(typeof(System.Net.Sockets.SocketException)) || + innerException.GetType().IsAssignableFrom(typeof(MySqlConnection)) || + ex.GetType().IsAssignableFrom(typeof(MySqlConnection)) || + ex.Message.ToLower().Contains("connection must be valid and open") || + ex.Message.ToLower().Contains("a connection attempt failed because the connected party did not properly respond after a period of time") || + ex.Message.ToLower().Contains("an existing connection was forcibly closed by the remote host")) + { + this.Reconnect(maxRetrys, exponentialBackoff); + } + + //See if we should retry or just throw. + if (!ShouldRetryBasedOnMySqlErrorNum(code)) + throw; + + //If the operation took less than 5 seconds, then sleep. Otherwise continue right away. + if (GlobalTimeStamp.GetDifference(startTimestamp) <= 5000 && exponentialBackoff) + { + Thread.Sleep(backoffSleep); + backoffSleep *= 2; + } + } + } + + throw new Exception($"MySql ExecuteNonQuery failed. Max timeout reached. Query: {command.CommandText}"); + } + + /// + /// Returns whether or not we should retry a query based on the MySql error number. + /// + /// + /// + private static bool ShouldRetryBasedOnMySqlErrorNum(int number) + { + //List of codes here: https://www.briandunning.com/error-codes/?source=MySQL + if (number >= 1044 && number <= 1052) + return false; + else if (number >= 1054 && number <= 1075) + return false; + else if (number == 1265) + return false; //Data truncation (Don't try again) + + return true; + } + + /// + /// Disposes this managed connection and releases all resources. + /// + public void Dispose() + { + if (Internal != null) + { + try { Internal.Close(); } catch { } + + try { Internal.Dispose(); } catch { } + + Internal = null; + } + } + + /// + /// Called when this managed connections needs to be deallocated. + /// + /// + ~MySqlManagedConnection() + { + Dispose(); + } + + /// + /// Allows the exposal of the internal MySqlConnection from the managed version. + /// + /// + public static implicit operator MySqlConnection(MySqlManagedConnection connection) + { + return connection.Internal; + } + } +} diff --git a/MySqlPlus/MySqlPlus.csproj b/MySqlPlus/MySqlPlus.csproj new file mode 100644 index 0000000..5b99c77 --- /dev/null +++ b/MySqlPlus/MySqlPlus.csproj @@ -0,0 +1,15 @@ + + + + net6.0 + disable + disable + MontoyaTech.MySqlPlus + MontoyaTech.MySqlPlus + + + + + + + diff --git a/MySqlPlus/MySqlRow.cs b/MySqlPlus/MySqlRow.cs new file mode 100644 index 0000000..c8f17e5 --- /dev/null +++ b/MySqlPlus/MySqlRow.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + public class MySqlRow + { + } +} diff --git a/MySqlPlus/MySqlRowId.cs b/MySqlPlus/MySqlRowId.cs new file mode 100644 index 0000000..6ca10da --- /dev/null +++ b/MySqlPlus/MySqlRowId.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + public class MySqlRowId : Attribute + { + public MySqlRowId() { } + } +} diff --git a/MySqlPlus/MySqlSession.cs b/MySqlPlus/MySqlSession.cs new file mode 100644 index 0000000..983e7d2 --- /dev/null +++ b/MySqlPlus/MySqlSession.cs @@ -0,0 +1,128 @@ +using Microsoft.VisualBasic; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + /// + /// The outline of a MySqlSession which contains a MySqlManagedConnection + /// and a few other help functions. + /// + public class MySqlSession : IDisposable + { + /// + /// Returns whether or not this MySqlSession has a valid connection. + /// + public bool IsConnected + { + get + { + try + { + if (this.Connection == null || !this.Connection.IsConnected) + return false; + } + catch + { + return false; + } + + return true; + } + } + + /// + /// The underlying MySql Connection that this Session is using. + /// + public MySqlManagedConnection Connection = null; + + /// + /// The raw connection string used to open a MySqlConnection. + /// + protected string ConnectionStr = null; + + /// + /// Creates a new MySqlSession with a connection string. + /// + /// + public MySqlSession(string connectionStr) + { + if (string.IsNullOrWhiteSpace(this.ConnectionStr)) + throw new Exception("Must provide a valid non null or empty MySql connection string."); + + this.ConnectionStr = connectionStr; + } + + /// + /// Attempts to connect to the MySql Server using the connection information. + /// + /// + public void Connect() + { + lock (this) + { + //Dont connect again if we are already connected. + if (this.Connection == null) + { + if (!string.IsNullOrWhiteSpace(this.ConnectionStr)) + { + try + { + //Setup the mysql connection. + this.Connection = new MySqlManagedConnection(this.ConnectionStr); + + //Attempt to open the connection, this will make sure its valid and works for us. + this.Connection.Open(); + } + catch (Exception ex) + { + throw new Exception("Failed to connect to MySql database.", ex); + } + } + else + { + throw new Exception("Missing connection details to connect to MySql database."); + } + } + } + } + + /// + /// Disconnects from the MySql Server this Session is connected to. + /// + public void Disconnect() + { + lock (this) + { + try + { + if (this.Connection != null) + { + try { this.Connection.Close(); } catch { } + + try { this.Connection.Dispose(); } catch { } + + this.Connection = null; + } + } + catch + { + this.Connection = null; + } + } + } + + ~MySqlSession() + { + this.Disconnect(); + } + + public virtual void Dispose() + { + this.Disconnect(); + } + } +} diff --git a/MySqlPlus/MySqlSessionCache.cs b/MySqlPlus/MySqlSessionCache.cs new file mode 100644 index 0000000..c5966f7 --- /dev/null +++ b/MySqlPlus/MySqlSessionCache.cs @@ -0,0 +1,264 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace MontoyaTech.MySqlPlus +{ + /// + /// The outline of a MySqlSession Cache which will cache and automatically free MySql Sessions + /// in order to speed up query times. + /// + public class MySqlSessionCache + { + /// + /// The outline of a cached MySqlSession. + /// + public class CachedMySqlSession : MySqlSession + { + /// + /// The Last Time this cached API Session was used. + /// + public DateTime LastUse = DateTime.MinValue; + + /// + /// The method that requested this cache. + /// + public string CallerMethod = ""; + + /// + /// The line of code that requested this cache. + /// + public string CallerLine = ""; + + /// + /// The Id of this CachedAPISession. + /// + public string Id = ""; + + /// + /// Whether or not this Cached API Session is in use. + /// + public bool InUse = false; + + /// + /// Creates a new default CachedAPISession. + /// + public CachedMySqlSession(string connectionStr) : base(connectionStr) + { + this.Id = Guid.NewGuid().ToString(); + } + + /// + /// Dont allow the Session to be killed. Instead set in use to false. + /// + public override void Dispose() + { + InUse = false; + + //Set this again because we just stopped using this cached session. + this.LastUse = DateTime.UtcNow; + } + } + + /// + /// The connection string to use when creating MySqlSessions. + /// + private static string ConnectionStr = null; + + /// + /// The list of Cached Sessions currently being maintained by the Cache. + /// + private static List Sessions = new List(); + + /// + /// The Thread that will handle uncaching. + /// + private static Thread UnCacheThread = null; + + /// + /// The amount of time in minutes that a cached api session is allowed to live. + /// + private static int CacheLifeTime = 20; + + /// + /// The amount of time in minutes before a cache is considered to be a zombie + /// and the result of a code bug somewhere. + /// + private static int ZombieCacheLifeTime = 5; + + /// + /// The amount of time in seconds before we are allowed to attempt to uncache sessions. + /// + private static int UnCacheFrequency = 30; + + /// + /// Whether or not the API Session Cache is running. + /// + private static bool Running = false; + + /// + /// Starts this MySqlSessionCache with a given MySqlConnectionString. + /// + /// + public static void Start(string connectionStr) + { + ConnectionStr = connectionStr; + + lock (Sessions) + { + if (!Running) + { + Running = true; + + UnCacheThread = new Thread(UnCache); + UnCacheThread.IsBackground = true; + UnCacheThread.Start(); + } + } + } + + /// + /// Stops the APISessionCache Service. + /// + public static void Stop() + { + lock (Sessions) + { + if (Running) + { + UnCacheThread = null; + + try + { + for (int i = 0; i < Sessions.Count; i++) + { + Sessions[i].Disconnect(); + } + } + catch { } + + Sessions = null; + + Running = false; + } + } + } + + /// + /// Kills all the cached api sessions if we can. + /// + public static void KillCache() + { + lock (Sessions) + { + for (int i = 0; i < Sessions.Count; i++) + { + var session = Sessions[i]; + + //Remove the sessions not in use and the ones who are zombies. + + if (session.InUse == false) + { + Sessions.RemoveAt(i); + session.Disconnect(); + i--; + } + else if (session.InUse && (DateTime.UtcNow - session.LastUse).Minutes >= ZombieCacheLifeTime) + { + Sessions.RemoveAt(i); + session.Disconnect(); + i--; + } + } + } + } + + /// + /// Returns a APISession that is either new or cached depending on whats available. + /// + /// + public static CachedMySqlSession Get() + { + if (!Running) + throw new Exception("API Session Cache is not running!"); + + lock (Sessions) + { + CachedMySqlSession result = null; + + //See if we can find an existing session to use. + foreach (var cached in Sessions) + { + if (cached.InUse == false) + { + result = cached; + break; + } + } + + //Create a new Session if we didnt find one. + if (result == null) + { + result = new CachedMySqlSession(ConnectionStr); + result.Connect(); + Sessions.Add(result); + } + + result.InUse = true; + result.LastUse = DateTime.UtcNow; + + //Get the caller information + var trace = new StackTrace(); + + var method = trace.GetFrame(1).GetMethod(); + var methodName = method.Name; + var className = method.ReflectedType.Name; + var currNamespace = method.ReflectedType.Namespace; + + result.CallerMethod = $"{currNamespace}.{className}.{methodName}()"; + result.CallerLine = trace.GetFrame(1).GetFileLineNumber().ToString(); + + return result; + } + } + + /// + /// The code that handles uncaching api sessions. + /// + private static void UnCache() + { + while (Running) + { + lock (Sessions) + { + for (int i = 0; i < Sessions.Count; i++) + { + var session = Sessions[i]; + + //If this session is older than it's lifetime and it's not in use, kill it. + if (session.InUse == false && (DateTime.UtcNow - session.LastUse).Minutes >= CacheLifeTime) + { + Sessions.RemoveAt(i); + session.Disconnect(); + i--; + } + //If this session is in use but it appears to be a zombie session, kill it. + else if (session.InUse && (DateTime.UtcNow - session.LastUse).Minutes >= ZombieCacheLifeTime) + { + Sessions.RemoveAt(i); + session.Disconnect(); + i--; + } + } + } + + Thread.Sleep(1000 * UnCacheFrequency); + } + } + } +}