434 lines
15 KiB
C#
434 lines
15 KiB
C#
#nullable enable
|
|
|
|
using Newtonsoft.Json.Linq;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
|
|
namespace UVC.Data
|
|
{
|
|
public class DataObject : SortedDictionary<string, object>, IDataObject
|
|
{
|
|
|
|
/// <summary>
|
|
/// 객체의 고유 식별자를 나타내는 속성입니다. DataArray에서 데이터를 식별하는 데 사용됩니다.
|
|
/// </summary>
|
|
public string Id { get => (IdKey != null && ContainsKey(IdKey)) ? this[IdKey].ToString() : this.First().Value.ToString(); }
|
|
|
|
/// <summary>
|
|
/// Id에 해당하는 key 문자열
|
|
/// </summary>
|
|
internal string? IdKey { get; set; } = null;
|
|
|
|
/// <summary>
|
|
/// DataObject의 이름을 나타내는 속성입니다.
|
|
/// </summary>
|
|
public string Name { get; internal set; } = string.Empty;
|
|
|
|
|
|
// 직접적인 변경이 있었던 키를 저장하는 리스트
|
|
protected List<string> changedProperies = new List<string>();
|
|
|
|
/// <summary>
|
|
/// 변경된 속성의 키 목록을 읽기 전용으로 반환합니다.
|
|
/// </summary>
|
|
public ReadOnlyCollection<string> ChangedProperies => changedProperies.AsReadOnly();
|
|
|
|
// 기존에 있던 속성 키를 추적하기 위한 집합
|
|
private HashSet<string> existingProperties = new HashSet<string>();
|
|
|
|
/// <summary>
|
|
/// 기본 생성자입니다. 빈 데이터 객체를 생성합니다.
|
|
/// </summary>
|
|
public DataObject() { }
|
|
|
|
/// <summary>
|
|
/// JObject로부터 데이터 객체를 생성합니다.
|
|
/// </summary>
|
|
/// <param name="other">복사할 JObject 객체</param>
|
|
public DataObject(JObject other)
|
|
{
|
|
// JObject로부터 속성을 복사
|
|
foreach (var prop in other.Properties())
|
|
{
|
|
// JToken을 object로 변환
|
|
this[prop.Name] = ConvertJTokenToObject(prop.Value);
|
|
existingProperties.Add(prop.Name);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dictionary로 데이터 객체를 초기화합니다.
|
|
/// </summary>
|
|
/// <param name="dictionary">초기화에 사용할 Dictionary 객체</param>
|
|
public DataObject(Dictionary<string, object> dictionary) : base(dictionary)
|
|
{
|
|
// 생성자에서 초기 속성들을 기존 속성으로 등록
|
|
foreach (var key in dictionary.Keys)
|
|
{
|
|
existingProperties.Add(key);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// JToken을 적절한 C# 객체 타입으로 변환하는 헬퍼 메서드입니다.
|
|
/// </summary>
|
|
/// <param name="token">변환할 JToken 객체</param>
|
|
/// <returns>변환된 C# 객체</returns>
|
|
private object ConvertJTokenToObject(JToken token)
|
|
{
|
|
switch (token.Type)
|
|
{
|
|
case JTokenType.String:
|
|
return token.ToString();
|
|
case JTokenType.Integer:
|
|
return token.ToObject<int>();
|
|
case JTokenType.Float:
|
|
return token.ToObject<float>();
|
|
case JTokenType.Boolean:
|
|
return token.ToObject<bool>();
|
|
case JTokenType.Object:
|
|
return new DataObject((JObject)token);
|
|
case JTokenType.Array:
|
|
JArray array = (JArray)token;
|
|
return new DataArray(array);
|
|
default:
|
|
return token.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 모든 프로퍼티를 변경된 것으로 표시합니다.
|
|
/// 전체 데이터가 갱신되었을 때 사용합니다.
|
|
/// </summary>
|
|
public void InitData()
|
|
{
|
|
changedProperies.Clear();
|
|
changedProperies.AddRange(this.Keys);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 속성이 변경될 때 호출되는 메서드입니다.
|
|
/// 파생 클래스에서 오버라이드하여 추가 동작을 정의할 수 있습니다.
|
|
/// </summary>
|
|
/// <param name="propertyName">변경된 속성의 이름</param>
|
|
protected virtual void OnPropertyChanged(string propertyName)
|
|
{
|
|
// 기존에 존재하던 속성인 경우에만 변경된 것으로 추적
|
|
if (existingProperties.Contains(propertyName))
|
|
{
|
|
if (!changedProperies.Contains(propertyName))
|
|
{
|
|
changedProperies.Add(propertyName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 새로 추가된 속성은 기존 속성 목록에 추가
|
|
existingProperties.Add(propertyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 새 속성을 추가할 때 이벤트 연결을 처리합니다.
|
|
/// </summary>
|
|
/// <param name="propertyName">추가할 속성의 이름</param>
|
|
/// <param name="value">속성의 값</param>
|
|
public new void Add(string propertyName, object value)
|
|
{
|
|
// 추가하기 전에 확인 - 속성이 이미 있는지 확인
|
|
bool isExisting = ContainsKey(propertyName);
|
|
|
|
// 기본 구현 호출
|
|
base.Add(propertyName, value);
|
|
|
|
// 새로 추가된 속성이면 기존 속성 목록에 추가
|
|
if (!isExisting)
|
|
{
|
|
existingProperties.Add(propertyName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 인덱서를 통한 속성 설정을 처리합니다.
|
|
/// 속성 변경 시 변경 사항을 자동으로 추적합니다.
|
|
/// </summary>
|
|
public new object this[string key]
|
|
{
|
|
get => base[key];
|
|
set
|
|
{
|
|
// 속성 설정 전에 기존에 있는 속성인지 확인
|
|
bool isExisting = ContainsKey(key) || existingProperties.Contains(key);
|
|
|
|
// 기본 구현 호출
|
|
base[key] = value;
|
|
|
|
// 기존 속성이었다면 변경된 것으로 처리
|
|
if (isExisting)
|
|
{
|
|
if (!changedProperies.Contains(key))
|
|
{
|
|
changedProperies.Add(key);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 새로 추가된 속성은 기존 속성으로 등록
|
|
existingProperties.Add(key);
|
|
}
|
|
|
|
OnPropertyChanged(key);
|
|
}
|
|
}
|
|
|
|
|
|
public int GetInt(string propertyName, int defaultValue = 0)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is int intValue)
|
|
return intValue;
|
|
return Convert.ToInt32(value);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public string? GetString(string propertyName, string? defaultValue = null)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
return value.ToString();
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public bool GetBool(string propertyName, bool defaultValue = false)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is bool boolValue)
|
|
return boolValue;
|
|
return Convert.ToBoolean(value);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public float GetFloat(string propertyName, float defaultValue = 0f)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is float floatValue)
|
|
return floatValue;
|
|
return Convert.ToSingle(value);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public double GetDouble(string propertyName, double defaultValue = 0.0)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is double doubleValue)
|
|
return doubleValue;
|
|
return Convert.ToDouble(value);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public DateTime? GetDateTime(string propertyName, DateTime? defaultValue = null)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is DateTime dateTime)
|
|
return dateTime;
|
|
return Convert.ToDateTime(value);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public T GetEnum<T>(string propertyName, T defaultValue = default) where T : Enum
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is T enumValue)
|
|
return enumValue;
|
|
return (T)Enum.Parse(typeof(T), value.ToString());
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public DataArray? GetDataArray(string propertyName, DataArray? defaultValue = null)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is DataArray dataArray)
|
|
return dataArray;
|
|
if (value is JArray jArray)
|
|
return new DataArray(jArray);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
public DataObject? GetDataObject(string propertyName, DataObject? defaultValue = null)
|
|
{
|
|
if (TryGetValue(propertyName, out object value) && value != null)
|
|
{
|
|
if (value is DataObject dataObject)
|
|
return dataObject;
|
|
if (value is JObject jObject)
|
|
return new DataObject(jObject);
|
|
if (value is Dictionary<string, object> dict)
|
|
return new DataObject(dict);
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 속성이 제거될 때 기존 속성 목록에서도 제거합니다.
|
|
/// </summary>
|
|
/// <param name="key">제거할 속성의 키</param>
|
|
/// <returns>제거 성공 여부</returns>
|
|
public new bool Remove(string key)
|
|
{
|
|
bool result = base.Remove(key);
|
|
if (result)
|
|
{
|
|
existingProperties.Remove(key);
|
|
changedProperies.Remove(key);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 모든 속성을 제거할 때 기존 속성 목록과 변경된 키 목록도 초기화합니다.
|
|
/// </summary>
|
|
public void RemoveAll()
|
|
{
|
|
base.Clear();
|
|
existingProperties.Clear();
|
|
changedProperies.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 현재 DataObject를 JObject로 변환합니다.
|
|
/// </summary>
|
|
/// <returns>현재 객체의 데이터를 담은 JObject</returns>
|
|
public JObject ToJObject()
|
|
{
|
|
JObject result = new JObject();
|
|
foreach (var kvp in this)
|
|
{
|
|
result[kvp.Key] = JToken.FromObject(kvp.Value);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 다른 DataObject와 현재 객체를 비교하여 다른 부분만 설정합니다.
|
|
/// 변경된 키는 자동으로 추적됩니다.
|
|
/// </summary>
|
|
/// <param name="other">비교할 DataObject</param>
|
|
public void UpdateDifferent(IDataObject other)
|
|
{
|
|
if (other == null || other is not DataObject) return;
|
|
changedProperies.Clear();
|
|
foreach (var keyValue in (DataObject)other)
|
|
{
|
|
if (!this.ContainsKey(keyValue.Key) || !this[keyValue.Key].Equals(keyValue.Value))
|
|
{
|
|
this[keyValue.Key] = keyValue.Value;
|
|
changedProperies.Add(keyValue.Key);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 업데이트된 속성만 포함하는 새로운 DataObject를 반환합니다.
|
|
/// </summary>
|
|
/// <returns>업데이트 된 항목만 가지고 있는 DataObject</returns>
|
|
public IDataObject GetUpdatedObject()
|
|
{
|
|
DataObject updated = new DataObject();
|
|
foreach (var key in changedProperies)
|
|
{
|
|
if (this.ContainsKey(key))
|
|
{
|
|
updated[key] = this[key];
|
|
}
|
|
}
|
|
return updated;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Join(", ", this.Select(kvp => $"{kvp.Key}:{kvp.Value}"));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// DataObject 인스턴스를 재사용하기 위한 객체 풀 클래스입니다.
|
|
/// 메모리 할당과 가비지 컬렉션을 최소화하기 위해 DataObject 인스턴스를 관리합니다.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 객체 풀링은 자주 생성 및 삭제되는 객체의 성능을 향상시키는 패턴입니다.
|
|
/// 사용이 끝난 객체를 삭제하는 대신 풀에 반환하고, 새 객체가 필요할 때 풀에서 꺼내 재사용합니다.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <code>
|
|
/// // 객체 풀에서 DataObject 가져오기
|
|
/// DataObject obj = DataObjectPool.GetDataObjectFromPool();
|
|
///
|
|
/// // 객체 사용
|
|
/// obj["name"] = "홍길동";
|
|
/// obj["age"] = 30;
|
|
///
|
|
/// // 작업 완료 후 풀에 반환
|
|
/// DataObjectPool.ReturnToPool(obj);
|
|
/// </code>
|
|
/// </example>
|
|
public static class DataObjectPool
|
|
{
|
|
/// <summary>
|
|
/// DataObject 인스턴스를 저장하는 큐입니다.
|
|
/// </summary>
|
|
private static Queue<DataObject> dataObjectPool = new Queue<DataObject>();
|
|
/// <summary>
|
|
/// 풀의 최대 크기입니다. 이 크기를 초과하는 객체는 풀에 저장되지 않습니다.
|
|
/// </summary>
|
|
private static int maxPoolSize = 1000;
|
|
|
|
/// <summary>
|
|
/// 풀에서 DataObject 인스턴스를 가져옵니다.
|
|
/// 풀이 비어있으면 새 인스턴스를 생성하여 반환합니다.
|
|
/// </summary>
|
|
/// <returns>재사용 가능한 DataObject 인스턴스</returns>
|
|
public static DataObject GetDataObjectFromPool()
|
|
{
|
|
if (dataObjectPool.Count > 0)
|
|
{
|
|
return dataObjectPool.Dequeue();
|
|
}
|
|
return new DataObject();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 사용이 완료된 DataObject를 풀에 반환합니다.
|
|
/// 객체는 반환 전에 초기화되어 모든 속성이 제거됩니다.
|
|
/// </summary>
|
|
/// <param name="obj">풀에 반환할 DataObject 인스턴스</param>
|
|
public static void ReturnToPool(DataObject obj)
|
|
{
|
|
if (obj != null && dataObjectPool.Count < maxPoolSize)
|
|
{
|
|
obj.RemoveAll(); // 재사용 전 정리
|
|
dataObjectPool.Enqueue(obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
} |