Simplified loader a bit and added more docs

docs/docs/quickstart.md

@@ -6,13 +6,19 @@ Install DotTiled from NuGet:
 dotnet add package DotTiled
 ```
 
+Use the `DotTiled` namespace (if you want).
+
+```csharp
+using DotTiled;
+```
+
+Or fully qualify all `DotTiled` types e.g. `DotTiled.Loader`.
+
 ## Loading a map from the file system
 
 This will create a loader that will load files from the underlying file system using <xref:DotTiled.Serialization.FileSystemResourceReader>. It will also be configured to use an in-memory cache to avoid loading the same tileset or template multiple times using <xref:DotTiled.Serialization.DefaultResourceCache>.
 
 ```csharp
-using DotTiled;
-
 var loader = Loader.Default();
 var map = loader.LoadMap("path/to/map.tmx");
 ```
@@ -22,8 +28,6 @@ var map = loader.LoadMap("path/to/map.tmx");
 If you want to load resources (maps, tilesets, templates) from a different source than the underlying file system, you can override the <xref:DotTiled.Serialization.FileSystemResourceReader> that is being used with your own implementation of <xref:DotTiled.Serialization.IResourceReader>.
 
 ```csharp	
-using DotTiled;
-
 var loader = Loader.DefaultWith(
   resourceReader: new MyCustomResourceReader());
 var map = loader.LoadMap("path/to/map.tmx");
@@ -34,8 +38,6 @@ var map = loader.LoadMap("path/to/map.tmx");
 Similarly, you can override the <xref:DotTiled.Serialization.DefaultResourceCache> that is being used with your own implementation of <xref:DotTiled.Serialization.IResourceCache>.
 
 ```csharp
-using DotTiled;
-
 var loader = Loader.DefaultWith(
   resourceReader: new MyCustomResourceReader(),
   resourceCache: new MyCustomResourceCache());
@@ -47,12 +49,21 @@ var map = loader.LoadMap("path/to/map.tmx");
 If you have custom types in your map, you can provide any `IEnumerable<ICustomTypeDefinition>` to the loader. This will allow the loader to deserialize the custom types in your map.
 
 ```csharp
-using DotTiled;
-
 var monsterSpawnerDef = new CustomClassDefinition { ... };
-var chestDef = new CustomClassDefinition { ... };
+var chestDef = new CustomClassDefinition
+{
+  Name = "Chest",
+  UseAs = CustomClassUseAs.All,
+  Members = [
+    new IntProperty { Name = "coins", Value = 0 },
+    new BoolProperty { Name = "locked", Value = true }
+  ]
+};
 
 var loader = Loader.DefaultWith(
   customTypeDefinitions: [monsterSpawnerDef, chestDef]);
 var map = loader.LoadMap("path/to/map.tmx");
+
+var chest = map.GetProperty<CustomClassProperty>("chest").Value;
+var coinsToSpawn = chest.GetProperty<IntProperty>("coins").Value;
 ```

src/DotTiled.Tests/Serialization/LoaderTests.cs

@@ -1,5 +1,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using DotTiled.Serialization;
 using NSubstitute;
 
 namespace DotTiled.Tests;

src/DotTiled/Serialization/Loader.cs

@@ -79,39 +79,41 @@ public class Loader
     return tilesetReader.ReadTileset();
   }
 
-  private Func<string, Tileset> GetTilesetResolver(string basePath)
+  private Func<string, T> GetResolverFunc<T>(
+    string basePath,
+    Func<string, Optional<T>> cacheResolver,
+    Action<string, T> cacheInsert,
+    Func<string, T> resolveFromContent)
   {
     return source =>
     {
-      var tilesetPath = Path.Combine(basePath, source);
-      var cachedTileset = _resourceCache.GetTileset(source);
-      if (cachedTileset.HasValue)
-        return cachedTileset.Value;
+      var resourcePath = Path.Combine(basePath, source);
+      var cachedResource = cacheResolver(resourcePath);
+      if (cachedResource.HasValue)
+        return cachedResource.Value;
 
-      string tilesetContent = _resourceReader.Read(tilesetPath);
-      using var tilesetReader = new TilesetReader(tilesetContent, GetTilesetResolver(basePath), GetTemplateResolver(basePath), CustomTypeResolver);
-      var tileset = tilesetReader.ReadTileset();
-      _resourceCache.InsertTileset(source, tileset);
-      return tileset;
+      string tilesetContent = _resourceReader.Read(resourcePath);
+      var resource = resolveFromContent(tilesetContent);
+      cacheInsert(resourcePath, resource);
+      return resource;
     };
   }
 
-  private Func<string, Template> GetTemplateResolver(string basePath)
-  {
-    return source =>
-    {
-      var templatePath = Path.Combine(basePath, source);
-      var cachedTemplate = _resourceCache.GetTemplate(source);
-      if (cachedTemplate.HasValue)
-        return cachedTemplate.Value;
+  private Func<string, Tileset> GetTilesetResolver(string basePath) =>
+    GetResolverFunc<Tileset>(basePath, _resourceCache.GetTileset, _resourceCache.InsertTileset,
+      tilesetContent =>
+      {
+        using var tilesetReader = new TilesetReader(tilesetContent, GetTilesetResolver(basePath), GetTemplateResolver(basePath), CustomTypeResolver);
+        return tilesetReader.ReadTileset();
+      });
 
-      string templateContent = _resourceReader.Read(templatePath);
-      using var templateReader = new TemplateReader(templateContent, GetTilesetResolver(basePath), GetTemplateResolver(basePath), CustomTypeResolver);
-      var template = templateReader.ReadTemplate();
-      _resourceCache.InsertTemplate(source, template);
-      return template;
-    };
-  }
+  private Func<string, Template> GetTemplateResolver(string basePath) =>
+    GetResolverFunc<Template>(basePath, _resourceCache.GetTemplate, _resourceCache.InsertTemplate,
+      templateContent =>
+      {
+        using var templateReader = new TemplateReader(templateContent, GetTilesetResolver(basePath), GetTemplateResolver(basePath), CustomTypeResolver);
+        return templateReader.ReadTemplate();
+      });
 
   private ICustomTypeDefinition CustomTypeResolver(string name) => _customTypeDefinitions[name];
 }