v1.0.6

birdnamoo · birdnamoo · commit 8d775c7e8277 · 2024-06-05T11:56:00.000+09:00
diff --git a/README.md b/README.md
@@ -17,7 +17,7 @@ ObjectPath allows you to access values within objects using string path expressi
 ### Basic Usage
 
 ```csharp
-using ObjectPath;
+using ObjectPathLibrary;
 
 // Example object
 var obj = new 
@@ -32,15 +32,15 @@ var obj = new
 };
 
 // Access values using path expressions
-var name = ObjectPath.GetValue(obj, "Name"); // John
-var city = ObjectPath.GetValue(obj, "Address.City"); // New York
+var name = obj.GetValueByPath("Name"); // John
+var city = obj.GetValueByPath("Address.City"); // New York
 ```
 
 ### JSON Example
 
 ```csharp
 using System.Text.Json;
-using ObjectPath;
+using ObjectPathLibrary;
 
 // JSON string
 var json = @"
@@ -57,16 +57,16 @@ var jsonDocument = JsonDocument.Parse(json);
 var jsonElement = jsonDocument.RootElement;
 
 // Access values using path expressions
-var name = ObjectPath.GetValue(jsonElement, "name"); // John
-var street = ObjectPath.GetValue(jsonElement, "address.street"); // 123 Main St
+var name = jsonElement.GetValueByPath("name"); // John
+var street = jsonElement.GetValueByPath("address.street"); // 123 Main St
 ```
 
 ### Array Example
 
 ObjectPath supports accessing array and list elements using index notation.
 
 ```csharp
-using ObjectPath;
+using ObjectPathLibrary;
 
 // Example object with arrays and lists
 var obj = new 
@@ -80,8 +80,8 @@ var obj = new
 };
 
 // Access array elements
-var firstNumber = ObjectPath.GetValue(obj, "Numbers[0]"); // 1
-var secondPersonName = ObjectPath.GetValue(obj, "People[1].Name"); // Jane
+var firstNumber = obj.GetValueByPath("Numbers[0]"); // 1
+var secondPersonName = obj.GetValueByPath("People[1].Name"); // Jane
 ```
 
 ### Case Sensitivity
@@ -102,10 +102,104 @@ var age = ObjectPath.GetValue(obj, "age", ignoreCase: false); // 30
 var invalid = ObjectPath.GetValue(obj, "name", ignoreCase: false);
 ```
 
+### Dictionary Access
+
+You can also access values in dictionaries using path expressions.
+
+```csharp
+using ObjectPathLibrary;
+using Xunit;
+
+[Fact]
+public void DictionaryAccessTest()
+{
+    var dic = new Dictionary<string, object>
+    {
+        ["Name"] = "John",
+        ["Age"] = 30,
+        ["Address"] = new Dictionary<string, object>
+        {
+            ["City"] = "New York",
+            ["Street"] = "123 Main St"
+        }
+    };
+
+    // Act
+    var name = dic.GetValueByPath("Name");
+    var age = dic.GetValueByPath("Age");
+    var city = dic.GetValueByPath("Address.City");
+    var street = dic.GetValueByPath("Address.Street");
+
+    var address = dic.GetValueByPath("Address") as IDictionary<string, object>;
+    var addressExpando = address!.ToExpando();
+
+    // Assert
+    Assert.Equal("John", name);
+    Assert.Equal(30, age);
+    Assert.Equal("New York", city);
+    Assert.Equal("123 Main St", street);
+
+    Assert.Equal("New York", address["City"]);
+    Assert.Equal("123 Main St", address["Street"]);
+
+    Assert.Equal("New York", addressExpando?.City);
+    Assert.Equal("123 Main St", addressExpando?.Street);
+}
+```
+
+### Handling Exceptions
+
+Use `GetValueByPathOrNull` to safely get values without throwing exceptions.
+
+```csharp
+using ObjectPathLibrary;
+
+var obj = new 
+{
+    Name = "John",
+    Address = new 
+    {
+        City = "New York"
+    }
+};
+
+// Access values using path expressions
+var name = obj.GetValueByPathOrNull("Name"); // John
+var nonExistent = obj.GetValueByPathOrNull("NonExistentProperty"); // null
+```
+
+## ObjectPathExtensions.cs
+
+```csharp
+namespace ObjectPathLibrary
+{
+    public static class ObjectPathExtensions
+    {
+        public static object? GetValueByPath(this object obj, string path)
+        {
+            return ObjectPath.GetValue(obj, path);
+        }
+
+        public static object? GetValueByPathOrNull(this object obj, string path)
+        {
+            try
+            {
+                return ObjectPath.GetValue(obj, path);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+    }
+}
+```
+
 ## Features
 
 - Access nested properties and fields.
 - Supports JSON elements.
 - Supports array and list index access.
 - Case-insensitive by default, with an option for case sensitivity.
 - Handles complex nested structures.
+- Provides safe access with `GetValueByPathOrNull`.
diff --git a/src/ObjectPath.Tests/ObjectPathTests.cs b/src/ObjectPath.Tests/ObjectPathTests.cs
@@ -542,5 +542,190 @@ public void GetValue_ReturnsCorrectValue_ForVariousDataTypes()
             Assert.Equal("Hello", stringValue);
             Assert.True((bool)boolValue);
         }
+
+
+        [Fact]
+        public void DynamicAccessTest()
+        {
+            // Arrange
+            var people = new Person[]
+            {
+                new Person
+                {
+                    Name = "John",
+                    Age = 30,
+                    Address = new Address
+                    {
+                        City = "New York",
+                        Street = "123 Main St"
+                    }
+                },
+                new Person
+                {
+                    Name = "Jane",
+                    Age = 25,
+                    Address = new Address
+                    {
+                        City = "London",
+                        Street = "456 Oxford St"
+                    }
+                }
+            };
+
+            // Act
+            var person1 = ObjectPath.GetValue(people, "[0]") as dynamic;
+
+            // Assert
+            Assert.Equal("John", person1.Name);
+            Assert.Equal(30, person1.Age);
+            Assert.Equal("New York", person1.Address.City);
+        }
+
+        [Fact]
+        public void DictionaryAccessTest()
+        {
+            var dic = new Dictionary<string, object>
+            {
+                ["Name"] = "John",
+                ["Age"] = 30,
+                ["Address"] = new Dictionary<string, object>
+                {
+                    ["City"] = "New York",
+                    ["Street"] = "123 Main St"
+                }
+            };
+
+            // Act
+            var name = ObjectPath.GetValue(dic, "Name");
+            var age = ObjectPath.GetValue(dic, "Age");
+            var city = ObjectPath.GetValue(dic, "Address.City");
+            var street = ObjectPath.GetValue(dic, "Address.Street");
+
+            var address = ObjectPath.GetValue(dic, "Address") as IDictionary<string, object>;
+            var addressExpando = address!.ToExpando();
+
+            // Assert
+            Assert.Equal("John", name);
+            Assert.Equal(30, age);
+            Assert.Equal("New York", city);
+            Assert.Equal("123 Main St", street);
+
+            Assert.Equal("New York", address["City"]);
+            Assert.Equal("123 Main St", address["Street"]);
+
+            Assert.Equal("New York", addressExpando?.City);
+            Assert.Equal("123 Main St", addressExpando?.Street);
+        }
+
+
+        [Fact]
+        public void GetValueByPath_ValidPath_ReturnsValue()
+        {
+            var obj = new
+            {
+                Name = "John",
+                Age = 30,
+                Address = new
+                {
+                    City = "New York",
+                    Street = "123 Main St"
+                }
+            };
+
+            var name = obj.GetValueByPath("Name");
+            var city = obj.GetValueByPath("Address.City");
+
+            Assert.Equal("John", name);
+            Assert.Equal("New York", city);
+        }
+
+        [Fact]
+        public void GetValueByPath_InvalidPath_ThrowsException()
+        {
+            var obj = new
+            {
+                Name = "John",
+                Age = 30
+            };
+
+            Assert.Throws<InvalidObjectPathException>(() => obj.GetValueByPath("NonExistentProperty"));
+        }
+
+        [Fact]
+        public void GetValueByPathOrNull_ValidPath_ReturnsValue()
+        {
+            var obj = new
+            {
+                Name = "John",
+                Age = 30,
+                Address = new
+                {
+                    City = "New York",
+                    Street = "123 Main St"
+                }
+            };
+
+            var name = obj.GetValueByPathOrNull("Name");
+            var city = obj.GetValueByPathOrNull("Address.City");
+
+            Assert.Equal("John", name);
+            Assert.Equal("New York", city);
+        }
+
+        [Fact]
+        public void GetValueByPathOrNull_InvalidPath_ReturnsNull()
+        {
+            var obj = new
+            {
+                Name = "John",
+                Age = 30
+            };
+
+            var value = obj.GetValueByPathOrNull("NonExistentProperty");
+
+            Assert.Null(value);
+        }
+
+        [Fact]
+        public void GetValueByPath_DictionaryAccess_ReturnsValue()
+        {
+            var dic = new Dictionary<string, object>
+            {
+                ["Name"] = "John",
+                ["Age"] = 30,
+                ["Address"] = new Dictionary<string, object>
+                {
+                    ["City"] = "New York",
+                    ["Street"] = "123 Main St"
+                }
+            };
+
+            var name = dic.GetValueByPath("Name");
+            var city = dic.GetValueByPath("Address.City");
+
+            Assert.Equal("John", name);
+            Assert.Equal("New York", city);
+        }
+
+        [Fact]
+        public void GetValueByPathOrNull_DictionaryAccess_ReturnsValue()
+        {
+            var dic = new Dictionary<string, object>
+            {
+                ["Name"] = "John",
+                ["Age"] = 30,
+                ["Address"] = new Dictionary<string, object>
+                {
+                    ["City"] = "New York",
+                    ["Street"] = "123 Main St"
+                }
+            };
+
+            var name = dic.GetValueByPathOrNull("Name");
+            var city = dic.GetValueByPathOrNull("Address.City");
+
+            Assert.Equal("John", name);
+            Assert.Equal("New York", city);
+        }
     }
 }
diff --git a/src/ObjectPath/DictionaryExtensions.cs b/src/ObjectPath/DictionaryExtensions.cs
@@ -0,0 +1,27 @@
+﻿using System.Dynamic;
+
+namespace ObjectPathLibrary
+{
+    public static class DictionaryExtensions
+    {
+        public static dynamic ToExpando(this IDictionary<string, object?> dictionary)
+        {
+            var expando = new ExpandoObject();
+            var expandoDict = (IDictionary<string, object?>)expando!;
+
+            foreach (var kvp in dictionary)
+            {
+                if (kvp.Value is IDictionary<string, object?> dict)
+                {
+                    expandoDict.Add(kvp.Key, dict.ToExpando());
+                }
+                else
+                {
+                    expandoDict.Add(kvp.Key, kvp.Value);
+                }
+            }
+
+            return expando;
+        }
+    }
+}
diff --git a/src/ObjectPath/ObjectPath.cs b/src/ObjectPath/ObjectPath.cs
@@ -1,7 +1,5 @@
-﻿using System;
-using System.Collections;
+﻿using System.Collections;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Reflection;
 using System.Text.Json;
 
diff --git a/src/ObjectPath/ObjectPathExtensions.cs b/src/ObjectPath/ObjectPathExtensions.cs
