Minor update to handle Xamarin support.

Fe-Bell · Fe-Bell · commit 1176b86b6094 · 2019-04-24T21:16:34.000-03:00
diff --git a/ReflectXMLDB/DatabaseHandler.cs b/ReflectXMLDB/DatabaseHandler.cs
@@ -38,7 +38,7 @@ public class DatabaseHandler : DatabaseHandlerBase
         /// <summary>
         /// Mutex to protect file access from multiple processes.
         /// </summary>
-        protected static Mutex mutex = new Mutex(false, "ReflectXMLDBMutex");
+        protected static Mutex mutex = null;
 
         #endregion
 
@@ -127,6 +127,27 @@ public OnDatabaseExportedEventArgs(string databaseName, DateTime date)
 
         #endregion
 
+        /// <summary>
+        /// Creates a new instance of DatabaseHandler.
+        /// </summary>
+        public DatabaseHandler()
+        {
+            //Xamarin does not currently support mutexes for some mobile platforms.
+            //When a new Mutex instance is created by Xamarin.Forms, a NotSupportedException/NotImplementedException is thrown.
+            //The following code handles this exception. The mutex will be ignored because it is null.
+            try
+            {
+                mutex = new Mutex(false, "ReflectXMLDBMutex");
+            }            
+            catch (Exception ex)
+            {
+                if (ex is NotSupportedException || ex is NotImplementedException)
+                {
+                    Console.WriteLine("Cross-process disabled.");
+                }
+            }
+        }
+
         #region Private methods
 
         /// <summary>
@@ -219,17 +240,30 @@ private string GetDatabasePath(Type type)
         /// <param name="path"></param>
         private void StartMonitoringDirectory(string path)
         {
-            fileSystemWatcher = new FileSystemWatcher
+            //Xamarin does not currently support a unified FileSystemWatcher for mobile platforms.
+            //When a new FileSystemWatcher instance is created by Xamarin.Forms, a NotSupportedException/NotImplementedException is thrown.
+            //The following code handles this exception. The FileSystemWatcher will be ignored because it is null.
+            try
             {
-                Path = path
-            };
-            fileSystemWatcher.Changed += FileSystemWatcher_Changed;
-            fileSystemWatcher.Created += FileSystemWatcher_Created;
-            fileSystemWatcher.Renamed += FileSystemWatcher_Renamed;
-            fileSystemWatcher.Deleted += FileSystemWatcher_Deleted;
+                fileSystemWatcher = new FileSystemWatcher
+                {
+                    Path = path
+                };
+                fileSystemWatcher.Changed += FileSystemWatcher_Changed;
+                fileSystemWatcher.Created += FileSystemWatcher_Created;
+                fileSystemWatcher.Renamed += FileSystemWatcher_Renamed;
+                fileSystemWatcher.Deleted += FileSystemWatcher_Deleted;
 
-            fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite;
-            fileSystemWatcher.EnableRaisingEvents = true;
+                fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite;
+                fileSystemWatcher.EnableRaisingEvents = true;
+            }
+            catch(Exception ex)
+            {
+                if(ex is NotSupportedException || ex is NotImplementedException)
+                {
+                    Console.WriteLine("FileWatcher disabled.");
+                }
+            }
         }
         /// <summary>
         /// Stops monitoring a folder. This disposes the Filewatcher and its events.
@@ -266,7 +300,11 @@ private T GetDatabase<T>() where T : IDatabase
                     {
                         try
                         {
-                            mutex.WaitOne();
+                            if(!mutex.IsNull())
+                            {
+                                mutex.WaitOne();
+                            }
+                            
                             database = path.Deserialize<T>();
                         }
                         catch
@@ -275,7 +313,10 @@ private T GetDatabase<T>() where T : IDatabase
                         }
                         finally
                         {
-                            mutex.ReleaseMutex();
+                            if(!mutex.IsNull())
+                            {
+                                mutex.ReleaseMutex();
+                            }                           
                         }
                     }
                     catch
@@ -402,7 +443,11 @@ public void CreateDatabase<T>() where T : IDatabase
                 {
                     try
                     {
-                        mutex.WaitOne();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.WaitOne();
+                        }
+
                         xml.Save(path);
                     }
                     catch
@@ -411,7 +456,10 @@ public void CreateDatabase<T>() where T : IDatabase
                     }
                     finally
                     {
-                        mutex.ReleaseMutex();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.ReleaseMutex();
+                        }
                     }
                 }
                 catch
@@ -441,7 +489,11 @@ public void DeleteDatabase<T>() where T : IDatabase
                     {
                         try
                         {
-                            mutex.WaitOne();
+                            if (!mutex.IsNull())
+                            {
+                                mutex.WaitOne();
+                            }
+
                             File.Delete(path);
                         }
                         catch
@@ -450,7 +502,10 @@ public void DeleteDatabase<T>() where T : IDatabase
                         }
                         finally
                         {
-                            mutex.ReleaseMutex();
+                            if (!mutex.IsNull())
+                            {
+                                mutex.ReleaseMutex();
+                            }
                         }
                     }
                     catch
@@ -577,16 +632,30 @@ public void Save<T>(ICollection<T> items) where T : ICollectableObject
                 {
                     try
                     {
-                        mutex.WaitOne();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.WaitOne();
+                        }
+
                         xml.Save(path);
+
+                        //Will fire the database changed event when the FileSystemWatcher is unavailable.
+                        //This should happen only when using Xamarin.Forms as there is no native support for that class.
+                        if(fileSystemWatcher.IsNull())
+                        {
+                            OnDatabaseChanged?.Invoke(this, new OnDatabaseChangedEventArgs(dbInfo.DatabaseType.Name, DateTime.Now));
+                        }
                     }
                     catch
                     {
                         throw;
                     }
                     finally
                     {
-                        mutex.ReleaseMutex();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.ReleaseMutex();
+                        }
                     }
                 }
                 catch
@@ -694,7 +763,11 @@ public void ImportDatabase(string fileToImport, string exportPath)
                 {
                     try
                     {
-                        mutex.WaitOne();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.WaitOne();
+                        }
+
                         //Opens the zip file up to be read
                         using (ZipArchive archive = ZipFile.OpenRead(fileToImport))
                         {
@@ -727,7 +800,10 @@ public void ImportDatabase(string fileToImport, string exportPath)
                     }
                     finally
                     {
-                        mutex.ReleaseMutex();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.ReleaseMutex();
+                        }
                     }
                 }
                 catch
@@ -760,7 +836,10 @@ public void ExportDatabase(string pathToSave, string filename, string fileExtens
                 {
                     try
                     {
-                        mutex.WaitOne();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.WaitOne();
+                        }
 
                         if (!Directory.Exists(pathToSave))
                         {
@@ -779,7 +858,10 @@ public void ExportDatabase(string pathToSave, string filename, string fileExtens
                     }
                     finally
                     {
-                        mutex.ReleaseMutex();
+                        if (!mutex.IsNull())
+                        {
+                            mutex.ReleaseMutex();
+                        }
                     }
                 }
                 catch
diff --git a/ReflectXMLDB/ReflectXMLDB.csproj b/ReflectXMLDB/ReflectXMLDB.csproj
@@ -6,14 +6,14 @@
     <Company></Company>
     <Description>Simple database handler based on XML serialization and reflection.
 
-This is a simple project that aims for C#/.NET beginners to achieve database functionality in their applications. The project is written for .NET Standard 2.0, which is compatible with .NET Core 2.0+ and .NET Framework 4.6.1+.</Description>
+This is a simple project that aims for C#/.NET developers to achieve database functionality in their applications. The project is written for .NET Standard 2.0, which is compatible with .NET Core 2.0+ and .NET Framework 4.6.1+.</Description>
     <Copyright>Copyright© ReflectXMLDB 2018</Copyright>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <AssemblyName>ReflectXMLDB</AssemblyName>
     <RootNamespace>ReflectXMLDB</RootNamespace>
     <Product>ReflectXMLDB</Product>
     <PackageId>ReflectXMLDB</PackageId>
-    <Version>0.0.2</Version>
+    <Version>0.0.3</Version>
     <PackageLicenseUrl>https://github.com/Fe-Bell/ReflectXMLDB/blob/master/LICENSE</PackageLicenseUrl>
     <PackageProjectUrl>https://github.com/Fe-Bell/ReflectXMLDB</PackageProjectUrl>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
@@ -28,8 +28,4 @@ This is a simple project that aims for C#/.NET beginners to achieve database fun
     <OutputPath>..\bin\Release\netstandard2.0\</OutputPath>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Folder Include="Interface\" />
-  </ItemGroup>
-
 </Project>

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public class DatabaseHandler : DatabaseHandlerBase`
`38`	`38`	`/// <summary>`
`39`	`39`	`/// Mutex to protect file access from multiple processes.`
`40`	`40`	`/// </summary>`
`41`		`- protected static Mutex mutex = new Mutex(false, "ReflectXMLDBMutex");`
	`41`	`+ protected static Mutex mutex = null;`
`42`	`42`
`43`	`43`	`#endregion`
`44`	`44`
`@@ -127,6 +127,27 @@ public OnDatabaseExportedEventArgs(string databaseName, DateTime date)`
`127`	`127`
`128`	`128`	`#endregion`
`129`	`129`
	`130`	`+ /// <summary>`
	`131`	`+ /// Creates a new instance of DatabaseHandler.`
	`132`	`+ /// </summary>`
	`133`	`+ public DatabaseHandler()`
	`134`	`+ {`
	`135`	`+ //Xamarin does not currently support mutexes for some mobile platforms.`
	`136`	`+ //When a new Mutex instance is created by Xamarin.Forms, a NotSupportedException/NotImplementedException is thrown.`
	`137`	`+ //The following code handles this exception. The mutex will be ignored because it is null.`
	`138`	`+ try`
	`139`	`+ {`
	`140`	`+ mutex = new Mutex(false, "ReflectXMLDBMutex");`
	`141`	`+ }`
	`142`	`+ catch (Exception ex)`
	`143`	`+ {`
	`144`	`+ if (ex is NotSupportedException \|\| ex is NotImplementedException)`
	`145`	`+ {`
	`146`	`+ Console.WriteLine("Cross-process disabled.");`
	`147`	`+ }`
	`148`	`+ }`
	`149`	`+ }`
	`150`	`+`
`130`	`151`	`#region Private methods`
`131`	`152`
`132`	`153`	`/// <summary>`
`@@ -219,17 +240,30 @@ private string GetDatabasePath(Type type)`
`219`	`240`	`/// <param name="path"></param>`
`220`	`241`	`private void StartMonitoringDirectory(string path)`
`221`	`242`	`{`
`222`		`- fileSystemWatcher = new FileSystemWatcher`
	`243`	`+ //Xamarin does not currently support a unified FileSystemWatcher for mobile platforms.`
	`244`	`+ //When a new FileSystemWatcher instance is created by Xamarin.Forms, a NotSupportedException/NotImplementedException is thrown.`
	`245`	`+ //The following code handles this exception. The FileSystemWatcher will be ignored because it is null.`
	`246`	`+ try`
`223`	`247`	`{`
`224`		`- Path = path`
`225`		`- };`
`226`		`- fileSystemWatcher.Changed += FileSystemWatcher_Changed;`
`227`		`- fileSystemWatcher.Created += FileSystemWatcher_Created;`
`228`		`- fileSystemWatcher.Renamed += FileSystemWatcher_Renamed;`
`229`		`- fileSystemWatcher.Deleted += FileSystemWatcher_Deleted;`
	`248`	`+ fileSystemWatcher = new FileSystemWatcher`
	`249`	`+ {`
	`250`	`+ Path = path`
	`251`	`+ };`
	`252`	`+ fileSystemWatcher.Changed += FileSystemWatcher_Changed;`
	`253`	`+ fileSystemWatcher.Created += FileSystemWatcher_Created;`
	`254`	`+ fileSystemWatcher.Renamed += FileSystemWatcher_Renamed;`
	`255`	`+ fileSystemWatcher.Deleted += FileSystemWatcher_Deleted;`
`230`	`256`
`231`		`- fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite;`
`232`		`- fileSystemWatcher.EnableRaisingEvents = true;`
	`257`	`+ fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite;`
	`258`	`+ fileSystemWatcher.EnableRaisingEvents = true;`
	`259`	`+ }`
	`260`	`+ catch(Exception ex)`
	`261`	`+ {`
	`262`	`+ if(ex is NotSupportedException \|\| ex is NotImplementedException)`
	`263`	`+ {`
	`264`	`+ Console.WriteLine("FileWatcher disabled.");`
	`265`	`+ }`
	`266`	`+ }`
`233`	`267`	`}`
`234`	`268`	`/// <summary>`
`235`	`269`	`/// Stops monitoring a folder. This disposes the Filewatcher and its events.`
`@@ -266,7 +300,11 @@ private T GetDatabase<T>() where T : IDatabase`
`266`	`300`	`{`
`267`	`301`	`try`
`268`	`302`	`{`
`269`		`- mutex.WaitOne();`
	`303`	`+ if(!mutex.IsNull())`
	`304`	`+ {`
	`305`	`+ mutex.WaitOne();`
	`306`	`+ }`
	`307`	`+`
`270`	`308`	`database = path.Deserialize<T>();`
`271`	`309`	`}`
`272`	`310`	`catch`
`@@ -275,7 +313,10 @@ private T GetDatabase<T>() where T : IDatabase`
`275`	`313`	`}`
`276`	`314`	`finally`
`277`	`315`	`{`
`278`		`- mutex.ReleaseMutex();`
	`316`	`+ if(!mutex.IsNull())`
	`317`	`+ {`
	`318`	`+ mutex.ReleaseMutex();`
	`319`	`+ }`
`279`	`320`	`}`
`280`	`321`	`}`
`281`	`322`	`catch`
`@@ -402,7 +443,11 @@ public void CreateDatabase<T>() where T : IDatabase`
`402`	`443`	`{`
`403`	`444`	`try`
`404`	`445`	`{`
`405`		`- mutex.WaitOne();`
	`446`	`+ if (!mutex.IsNull())`
	`447`	`+ {`
	`448`	`+ mutex.WaitOne();`
	`449`	`+ }`
	`450`	`+`
`406`	`451`	`xml.Save(path);`
`407`	`452`	`}`
`408`	`453`	`catch`
`@@ -411,7 +456,10 @@ public void CreateDatabase<T>() where T : IDatabase`
`411`	`456`	`}`
`412`	`457`	`finally`
`413`	`458`	`{`
`414`		`- mutex.ReleaseMutex();`
	`459`	`+ if (!mutex.IsNull())`
	`460`	`+ {`
	`461`	`+ mutex.ReleaseMutex();`
	`462`	`+ }`
`415`	`463`	`}`
`416`	`464`	`}`
`417`	`465`	`catch`
`@@ -441,7 +489,11 @@ public void DeleteDatabase<T>() where T : IDatabase`
`441`	`489`	`{`
`442`	`490`	`try`
`443`	`491`	`{`
`444`		`- mutex.WaitOne();`
	`492`	`+ if (!mutex.IsNull())`
	`493`	`+ {`
	`494`	`+ mutex.WaitOne();`
	`495`	`+ }`
	`496`	`+`
`445`	`497`	`File.Delete(path);`
`446`	`498`	`}`
`447`	`499`	`catch`
`@@ -450,7 +502,10 @@ public void DeleteDatabase<T>() where T : IDatabase`
`450`	`502`	`}`
`451`	`503`	`finally`
`452`	`504`	`{`
`453`		`- mutex.ReleaseMutex();`
	`505`	`+ if (!mutex.IsNull())`
	`506`	`+ {`
	`507`	`+ mutex.ReleaseMutex();`
	`508`	`+ }`
`454`	`509`	`}`
`455`	`510`	`}`
`456`	`511`	`catch`
`@@ -577,16 +632,30 @@ public void Save<T>(ICollection<T> items) where T : ICollectableObject`
`577`	`632`	`{`
`578`	`633`	`try`
`579`	`634`	`{`
`580`		`- mutex.WaitOne();`
	`635`	`+ if (!mutex.IsNull())`
	`636`	`+ {`
	`637`	`+ mutex.WaitOne();`
	`638`	`+ }`
	`639`	`+`
`581`	`640`	`xml.Save(path);`
	`641`	`+`
	`642`	`+ //Will fire the database changed event when the FileSystemWatcher is unavailable.`
	`643`	`+ //This should happen only when using Xamarin.Forms as there is no native support for that class.`
	`644`	`+ if(fileSystemWatcher.IsNull())`
	`645`	`+ {`
	`646`	`+ OnDatabaseChanged?.Invoke(this, new OnDatabaseChangedEventArgs(dbInfo.DatabaseType.Name, DateTime.Now));`
	`647`	`+ }`
`582`	`648`	`}`
`583`	`649`	`catch`
`584`	`650`	`{`
`585`	`651`	`throw;`
`586`	`652`	`}`
`587`	`653`	`finally`
`588`	`654`	`{`
`589`		`- mutex.ReleaseMutex();`
	`655`	`+ if (!mutex.IsNull())`
	`656`	`+ {`
	`657`	`+ mutex.ReleaseMutex();`
	`658`	`+ }`
`590`	`659`	`}`
`591`	`660`	`}`
`592`	`661`	`catch`
`@@ -694,7 +763,11 @@ public void ImportDatabase(string fileToImport, string exportPath)`
`694`	`763`	`{`
`695`	`764`	`try`
`696`	`765`	`{`
`697`		`- mutex.WaitOne();`
	`766`	`+ if (!mutex.IsNull())`
	`767`	`+ {`
	`768`	`+ mutex.WaitOne();`
	`769`	`+ }`
	`770`	`+`
`698`	`771`	`//Opens the zip file up to be read`
`699`	`772`	`using (ZipArchive archive = ZipFile.OpenRead(fileToImport))`
`700`	`773`	`{`
`@@ -727,7 +800,10 @@ public void ImportDatabase(string fileToImport, string exportPath)`
`727`	`800`	`}`
`728`	`801`	`finally`
`729`	`802`	`{`
`730`		`- mutex.ReleaseMutex();`
	`803`	`+ if (!mutex.IsNull())`
	`804`	`+ {`
	`805`	`+ mutex.ReleaseMutex();`
	`806`	`+ }`
`731`	`807`	`}`
`732`	`808`	`}`
`733`	`809`	`catch`
`@@ -760,7 +836,10 @@ public void ExportDatabase(string pathToSave, string filename, string fileExtens`
`760`	`836`	`{`
`761`	`837`	`try`
`762`	`838`	`{`
`763`		`- mutex.WaitOne();`
	`839`	`+ if (!mutex.IsNull())`
	`840`	`+ {`
	`841`	`+ mutex.WaitOne();`
	`842`	`+ }`
`764`	`843`
`765`	`844`	`if (!Directory.Exists(pathToSave))`
`766`	`845`	`{`
`@@ -779,7 +858,10 @@ public void ExportDatabase(string pathToSave, string filename, string fileExtens`
`779`	`858`	`}`
`780`	`859`	`finally`
`781`	`860`	`{`
`782`		`- mutex.ReleaseMutex();`
	`861`	`+ if (!mutex.IsNull())`
	`862`	`+ {`
	`863`	`+ mutex.ReleaseMutex();`
	`864`	`+ }`
`783`	`865`	`}`
`784`	`866`	`}`
`785`	`867`	`catch`