315 lines
13 KiB
C#
315 lines
13 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
|
|
namespace UVC.Extention
|
|
{
|
|
/// <summary>
|
|
/// Dictionary 클래스에 대한 확장 메소드를 제공하는 클래스입니다.
|
|
/// </summary>
|
|
public static class DictionaryEx
|
|
{
|
|
/// <summary>
|
|
/// Dictionary를 JSON 문자열로 변환합니다.
|
|
/// 중첩된 Dictionary 객체도 재귀적으로 처리합니다.
|
|
/// </summary>
|
|
/// <typeparam name="TKey">Dictionary의 키 타입</typeparam>
|
|
/// <typeparam name="TValue">Dictionary의 값 타입</typeparam>
|
|
/// <param name="dict">JSON 문자열로 변환할 Dictionary 객체</param>
|
|
/// <returns>JSON 형식의 문자열</returns>
|
|
/// <example>
|
|
/// <code>
|
|
/// var dict = new Dictionary<string, object>
|
|
/// {
|
|
/// { "name", "홍길동" },
|
|
/// { "age", 30 },
|
|
/// { "address", new Dictionary<string, string> { { "city", "서울" }, { "zip", "12345" } } }
|
|
/// };
|
|
///
|
|
/// string json = dict.ToJson();
|
|
/// // 결과: {"name":"홍길동","age":"30","address":{"city":"서울","zip":"12345"}}
|
|
/// </code>
|
|
/// </example>
|
|
public static string ToJson<TKey, TValue>(this IDictionary<TKey, TValue> dict)
|
|
{
|
|
if (dict == null || dict.Count == 0)
|
|
return "{}";
|
|
var sb = new StringBuilder("{");
|
|
foreach (var kvp in dict)
|
|
{
|
|
sb.Append($"\"{kvp.Key}\":");
|
|
|
|
// 값이 null인 경우 처리
|
|
if (kvp.Value == null)
|
|
{
|
|
sb.Append("null,");
|
|
continue;
|
|
}
|
|
|
|
// 값이 중첩된 Dictionary인 경우 재귀적으로 처리
|
|
if (kvp.Value is IDictionary<object, object> dictObject)
|
|
{
|
|
string nestedJson = ToJson(dictObject);
|
|
sb.Append($"{nestedJson},");
|
|
}
|
|
else if (kvp.Value is IDictionary<string, object> dictStringObject)
|
|
{
|
|
string nestedJson = ToJson(dictStringObject);
|
|
sb.Append($"{nestedJson},");
|
|
}
|
|
else if (kvp.Value is IDictionary<string, string> dictStringString)
|
|
{
|
|
string nestedJson = ToJson(dictStringString);
|
|
sb.Append($"{nestedJson},");
|
|
}
|
|
// 값이 숫자인 경우 따옴표 없이 추가
|
|
else if (IsNumericType(kvp.Value.GetType()))
|
|
{
|
|
sb.Append($"{kvp.Value},");
|
|
}
|
|
// 값이 불리언인 경우 따옴표 없이 추가 (소문자 true/false)
|
|
else if (kvp.Value is bool boolValue)
|
|
{
|
|
sb.Append($"{boolValue.ToString().ToLowerInvariant()},");
|
|
}
|
|
// 그 외의 경우 문자열로 처리
|
|
else
|
|
{
|
|
// 특수 문자를 이스케이프 처리
|
|
string escapedValue = EscapeJsonString(kvp.Value.ToString());
|
|
sb.Append($"\"{escapedValue}\",");
|
|
}
|
|
}
|
|
if (dict.Count > 0)
|
|
{
|
|
sb.Length--; // 마지막 쉼표(,) 제거
|
|
}
|
|
sb.Append("}");
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 주어진 타입이 숫자형인지 확인합니다.
|
|
/// </summary>
|
|
/// <param name="type">검사할 타입</param>
|
|
/// <returns>숫자형이면 true, 아니면 false</returns>
|
|
private static bool IsNumericType(Type type)
|
|
{
|
|
if (type == null)
|
|
return false;
|
|
|
|
switch (Type.GetTypeCode(type))
|
|
{
|
|
case TypeCode.Byte:
|
|
case TypeCode.SByte:
|
|
case TypeCode.Int16:
|
|
case TypeCode.Int32:
|
|
case TypeCode.Int64:
|
|
case TypeCode.UInt16:
|
|
case TypeCode.UInt32:
|
|
case TypeCode.UInt64:
|
|
case TypeCode.Single:
|
|
case TypeCode.Double:
|
|
case TypeCode.Decimal:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// JSON 문자열에서 특수 문자를 이스케이프 처리합니다.
|
|
/// </summary>
|
|
/// <param name="value">이스케이프 처리할 문자열</param>
|
|
/// <returns>이스케이프 처리된 문자열</returns>
|
|
private static string EscapeJsonString(string value)
|
|
{
|
|
if (string.IsNullOrEmpty(value))
|
|
return value;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
foreach (char c in value)
|
|
{
|
|
switch (c)
|
|
{
|
|
case '\\': sb.Append("\\\\"); break;
|
|
case '\"': sb.Append("\\\""); break;
|
|
case '\n': sb.Append("\\n"); break;
|
|
case '\r': sb.Append("\\r"); break;
|
|
case '\t': sb.Append("\\t"); break;
|
|
case '\b': sb.Append("\\b"); break;
|
|
case '\f': sb.Append("\\f"); break;
|
|
default:
|
|
if (c < 32) // 제어 문자
|
|
{
|
|
sb.Append($"\\u{(int)c:X4}");
|
|
}
|
|
else
|
|
{
|
|
sb.Append(c);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 두 사전의 키와 값을 비교하여 두 사전이 같은지 확인합니다.
|
|
/// </summary>
|
|
/// <typeparam name="TKey">사전의 키 유형입니다.</typeparam>
|
|
/// <typeparam name="TValue">사전의 값 유형입니다.</typeparam>
|
|
/// <param name="dic">비교할 첫 번째 사전입니다.</param>
|
|
/// <param name="other">비교할 두 번째 사전입니다.</param>
|
|
/// <paramref name="dic"/>의 모든 키가 <paramref name="other"/>에 존재하고 해당 값이 같으면 <see langword="true"/>를 반환합니다.
|
|
/// 그렇지 않으면 <see langword="false"/>를 반환합니다.</returns>
|
|
public static bool IsSame<TKey, TValue>(this IDictionary<TKey, TValue> dic, IDictionary<TKey, TValue> other)
|
|
{
|
|
return !dic.Keys.Any(key => !object.Equals(dic[key], other[key]));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 두 사전을 비교하여 두 번째 사전의 키와 값을 포함하는 새 사전을 반환합니다.
|
|
/// 두 사전의 값이 첫 번째 사전의 값과 다릅니다.
|
|
/// </summary>
|
|
/// <remarks>이 메서드는 <see
|
|
/// cref="object.Equals(object, object)"/>를 사용하여 얕은 값 비교를 수행합니다. 키가 <paramref name="oldDict"/>에는 있지만 <paramref
|
|
/// name="newDict"/>에는 없는 경우, 또는 그 반대의 경우, 해당 키는 무시됩니다.</remarks>
|
|
/// <typeparam name="TKey">사전에 있는 키의 타입입니다.</typeparam>
|
|
/// <typeparam name="TValue">사전에 있는 값의 타입입니다.</typeparam>
|
|
/// <param name="oldDict">비교할 원본 사전입니다.</param>
|
|
/// <param name="newDict">비교할 업데이트된 사전입니다.</param>
|
|
/// <returns> <paramref name="newDict"/>의 키가 포함된 사전입니다. 해당 키의 값이 <paramref name="oldDict"/>의 해당 값과 다른 경우입니다.
|
|
/// 반환된 사전의 값은 <paramref name="newDict"/>에서 가져옵니다.</returns>
|
|
public static IDictionary<TKey, TValue> Differences<TKey, TValue>(this IDictionary<TKey, TValue> oldDict, IDictionary<TKey, TValue> newDict)
|
|
{
|
|
var result = new Dictionary<TKey, TValue>();
|
|
foreach (var key in oldDict.Keys)
|
|
{
|
|
TValue oldValue = oldDict[key];
|
|
TValue newValue = newDict[key];
|
|
|
|
if (!object.Equals(oldValue, newValue))
|
|
{
|
|
result.Add(key, newValue);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 두 사전을 비교하여 두 번째 사전의 키와 값을 포함하는 새 사전을 반환합니다.
|
|
/// 두 사전의 값이 첫 번째 사전의 값과 다릅니다.
|
|
/// </summary>
|
|
/// <remarks>이 메서드는 심층 비교를 사용하여 값이 다른지 확인합니다. 비교
|
|
/// 로직은 <c>DeepEquals</c> 메서드로 정의됩니다. <paramref name="dict1"/>에는 있지만
|
|
/// <paramref name="dict2"/>에는 없는 키는 결과에 포함되지 않습니다.</remarks>
|
|
/// <typeparam name="TKey">사전에 있는 키의 타입입니다.</typeparam>
|
|
/// <typeparam name="TValue">사전에 있는 값의 타입입니다.</typeparam>
|
|
/// <param name="dict1">비교할 첫 번째 사전입니다.</param>
|
|
/// <param name="dict2">비교할 두 번째 사전입니다.</param>
|
|
/// <returns><paramref name="dict2"/>의 키와 값을 포함하는 사전으로, 값이 <paramref name="dict1"/>의 값과 다른 경우
|
|
/// <paramref name="dict1"/>에 키가 있지만 값이 같지 않으면
|
|
/// <paramref name="dict2"/>의 키와 해당 값이 포함됩니다.</returns>
|
|
public static IDictionary<TKey, TValue> DeepDifferences<TKey, TValue>(this IDictionary<TKey, TValue> dict1, IDictionary<TKey, TValue> dict2)
|
|
{
|
|
var result = new Dictionary<TKey, TValue>();
|
|
foreach (var key in dict1.Keys)
|
|
{
|
|
TValue val1 = dict1[key];
|
|
TValue val2 = dict2[key];
|
|
if (!DeepEquals(val1, val2))
|
|
{
|
|
result.Add(key, val2);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 두 객체의 값, 속성 및 중첩 구조를 비교하여 두 객체가 깊이 동일한지 여부를 확인합니다.
|
|
///
|
|
// </summary>
|
|
/// <remarks>이 메서드는 제공된 객체와 중첩 구조를 재귀적으로 비교합니다.
|
|
/// 기본 유형, 문자열, 소수, 컬렉션(예: 배열,리스트), 사전 및 복합 객체의 비교를 지원합니다.
|
|
/// 컬렉션의 경우, 이 메서드는 요소를 순서대로 비교합니다.
|
|
/// 사전의 경우, 키와 연관된 값을 비교합니다. 객체의 유형이 다르거나 일치하지 않는 구조를 가진 경우,
|
|
/// 이 메서드는 <see langword="false"/>를 반환합니다.</remarks>
|
|
/// <param name="obj1">비교할 첫 번째 객체입니다. null일 수 있습니다.</param>
|
|
/// <param name="obj2">비교할 두 번째 객체입니다. null일 수 있습니다.</param>
|
|
/// 객체가 깊이 동일하면 <returns><see langword="true"/>를 반환하고, 그렇지 않으면 <see langword="false"/>를 반환합니다. 깊이 동일성
|
|
///에는 기본 값, 문자열, 컬렉션, 사전 및 복합 객체의 공개 속성 비교가 포함됩니다.
|
|
///</returns>
|
|
private static bool DeepEquals(object obj1, object obj2)
|
|
{
|
|
if (ReferenceEquals(obj1, obj2))
|
|
return true;
|
|
|
|
if (obj1 == null || obj2 == null)
|
|
return false;
|
|
|
|
if (obj1.Equals(obj2))
|
|
return true;
|
|
|
|
var type1 = obj1.GetType();
|
|
var type2 = obj2.GetType();
|
|
|
|
if (type1 != type2)
|
|
return false;
|
|
|
|
// String or primitive
|
|
if (type1.IsPrimitive || obj1 is string || obj1 is decimal)
|
|
return obj1.Equals(obj2);
|
|
|
|
// List or Array
|
|
if (obj1 is IEnumerable enumerable1 && obj2 is IEnumerable enumerable2)
|
|
{
|
|
var list1 = enumerable1.Cast<object>().ToList();
|
|
var list2 = enumerable2.Cast<object>().ToList();
|
|
|
|
if (list1.Count != list2.Count)
|
|
return false;
|
|
|
|
for (int i = 0; i < list1.Count; i++)
|
|
{
|
|
if (!DeepEquals(list1[i], list2[i]))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Dictionary
|
|
if (obj1 is IDictionary dict1 && obj2 is IDictionary dict2)
|
|
{
|
|
if (dict1.Count != dict2.Count)
|
|
return false;
|
|
|
|
foreach (var key in dict1.Keys)
|
|
{
|
|
if (!dict2.Contains(key)) return false;
|
|
if (!DeepEquals(dict1[key], dict2[key])) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Complex object
|
|
var props = type1.GetProperties(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (var prop in props)
|
|
{
|
|
var val1 = prop.GetValue(obj1);
|
|
var val2 = prop.GetValue(obj2);
|
|
if (!DeepEquals(val1, val2))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|