khi/XRLib
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

DataArray, DataObject pool 적용. 버그 수정. AGV 움직임 튀는 거 수정 필요

Browse Source
This commit is contained in:
logonkhi
2025-06-26 19:46:13 +09:00
parent aa9caab761
commit ad034d8246
19 changed files with 1420 additions and 497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

361
Assets/Scripts/UVC/Data/DataArray.cs
View File

@@ -11,6 +11,13 @@ namespace UVC.Data
/// </summary>
public class DataArray : List<DataObject>, IDataObject
{
/// <summary>
/// 이 객체가 객체 풀에 있는지 여부를 나타냅니다.
/// 중복 반환을 방지하기 위해 DataArrayPool에서 내부적으로 사용됩니다.
/// </summary>
internal bool IsInPool { get; set; } = false;
// 추가 된 항목 목록
protected List<DataObject> addedList = new List<DataObject>();
// 제거 된 항목 목록
@@ -28,12 +35,6 @@ namespace UVC.Data
// 제거된 항목에 접근할 수 있는 읽기 전용 컬렉션
public ReadOnlyCollection<DataObject> ModifiedList => modifiedList.AsReadOnly();
/// <summary>
/// 변경 추적 활성화 여부
/// </summary>
public bool IsChangeTracking { get; set; } = false;
/// <summary>
/// 기본 생성자
/// </summary>
@@ -82,13 +83,43 @@ namespace UVC.Data
/// <param name="jArray">JSON 배열</param>
public DataArray(JArray jArray) : base()
{
if (jArray != null)
FromJArray(jArray);
}
public DataArray FromCapacity(int capacity)
{
Capacity = capacity;
return this;
}
public DataArray FromCollection(IEnumerable<DataObject> collection)
{
if (collection == null) return this;
foreach (var item in collection)
{
foreach (var item in jArray)
{
Add(ConvertToDataObject(item));
}
// base.Add를 사용하여 추적 로직을 우회하고 직접 추가합니다.
base.Add(item);
}
return this;
}
/// <summary>
/// JArray로부터 DataArray의 내용을 채웁니다.
/// </summary>
/// <param name="jArray">JSON 배열</param>
public DataArray FromJArray(JArray jArray)
{
if (jArray == null) return this;
foreach (var item in jArray)
{
// base.Add를 사용하여 추적 로직을 우회하고 직접 추가합니다.
base.Add(ConvertToDataObject(item));
}
return this;
}
/// <summary>
@@ -98,12 +129,15 @@ namespace UVC.Data
{
if (token.Type == JTokenType.Object)
{
return new DataObject((JObject)token);
// 풀에서 객체를 가져와 JObject로 초기화합니다.
var dataObject = DataObjectPool.Get();
dataObject.FromJObject((JObject)token);
return dataObject;
}
else
{
// JObject가 아닌 경우, 새 DataObject를 만들고 값을 넣어줍니다
var dataObject = new DataObject();
// JObject가 아닌 경우, 풀에서 새 DataObject를 가져와 값을 넣어줍니다.
var dataObject = DataObjectPool.Get();
dataObject.Add("value", ConvertJTokenToObject(token));
return dataObject;
}
@@ -122,10 +156,14 @@ namespace UVC.Data
case JTokenType.Boolean:
return token.ToObject<bool>();
case JTokenType.Object:
return new DataObject((JObject)token);
var dataObject = DataObjectPool.Get();
dataObject.FromJObject((JObject)token);
return dataObject;
case JTokenType.Array:
JArray array = (JArray)token;
return new DataArray(array);
var dataArray = DataArrayPool.Get();
dataArray.FromJArray(array);
return dataArray;
default:
return token.ToString();
}
@@ -135,7 +173,7 @@ namespace UVC.Data
/// 모든 아이템이 추가 된것으로 표시합니다.
/// 전체 데이터가 갱신되었을 때 사용합니다.
/// </summary>
public void InitData()
public void MarkAllAsUpdated()
{
addedList.Clear();
addedList.AddRange(this);
@@ -149,56 +187,57 @@ namespace UVC.Data
public void UpdateDifferent(IDataObject other)
{
if (other == null) return;
if (other is DataArray otherArray)
if (!(other is DataArray otherArray)) return;
// 기존 변경 추적 목록을 초기화합니다.
ClearTrackedChanges();
// 성능 향상을 위해 ID를 키로 사용하는 사전을 생성합니다.
var thisDict = this.ToDictionary(item => item.Id);
var otherDict = otherArray.ToDictionary(item => item.Id);
var thisIds = new HashSet<string>(thisDict.Keys);
var otherIds = new HashSet<string>(otherDict.Keys);
// 제거된 항목 확인 (현재 배열에는 있지만 다른 배열에는 없는 항목)
foreach (var id in thisIds.Where(id => !otherIds.Contains(id)))
{
addedList.Clear();
removedList.Clear();
modifiedList.Clear();
removedList.Add(thisDict[id]);
}
// Id 기준으로 객체들을 비교하기 위한 사전 생성
var thisDict = this.ToDictionary(item => item.Id, item => item);
var otherDict = otherArray.ToDictionary(item => item.Id, item => item);
// 추가된 항목 확인 (다른 배열에는 있지만 현재 배열에는 없는 항목)
foreach (var id in otherIds.Where(id => !thisIds.Contains(id)))
{
addedList.Add(otherDict[id]);
}
// 제거된 항목 확인 (현재 배열에는 있지만 other에는 없는 항목)
foreach (var id in thisDict.Keys.Where(id => !otherDict.ContainsKey(id)))
// 수정된 항목 확인 (양쪽 모두에 있지만 내용이 다른 항목)
foreach (var id in thisIds.Where(id => otherIds.Contains(id)))
{
var thisItem = thisDict[id];
var otherItem = otherDict[id];
// [성능 개선] ToString() 비교는 매우 비효율적입니다.
// DataObject.UpdateDifferent를 직접 호출하여 변경 사항을 적용하고,
// UpdatedCount를 통해 실제 변경 여부를 확인합니다.
thisItem.UpdateDifferent(otherItem);
if (thisItem.UpdatedCount > 0)
{
removedList.Add(thisDict[id]);
modifiedList.Add(thisItem);
}
}
// 추가된 항목 확인 (other에는 있지만 현재 배열에는 없는 항목)
foreach (var id in otherDict.Keys.Where(id => !thisDict.ContainsKey(id)))
{
addedList.Add(otherDict[id]);
}
// [성능 개선] RemoveAll과 HashSet을 사용하여 제거 작업의 효율성을 높입니다.
if (removedList.Count > 0)
{
var removedItemIds = new HashSet<string>(removedList.Select(i => i.Id));
this.RemoveAll(item => removedItemIds.Contains(item.Id));
}
// 수정된 항목 확인 (양쪽 모두에 있지만 내용이 다른 항목)
foreach (var id in thisDict.Keys.Where(id => otherDict.ContainsKey(id)))
{
var thisItem = thisDict[id];
var otherItem = otherDict[id];
if (!thisItem.ToString().Equals(otherItem.ToString()))
{
modifiedList.Add(thisItem);
thisItem.UpdateDifferent(otherItem);
}
}
// 실제 컬렉션 업데이트
// 현재 배열에서 제거된 항목들을 제거
for (int i = this.Count - 1; i >= 0; i--)
{
if (removedList.Contains(this[i]))
{
this.RemoveAt(i);
}
}
// 추가된 항목들을 현재 배열에 추가
foreach (var item in addedList)
{
this.Add(item);
}
// [성능 개선] base.AddRange를 사용하여 추적 로직을 우회하고 효율적으로 추가합니다.
if (addedList.Count > 0)
{
base.AddRange(addedList);
}
}
@@ -209,7 +248,34 @@ namespace UVC.Data
/// <returns></returns>
public IDataObject GetUpdatedObject()
{
return this;
// 풀에서 새 DataArray 인스턴스를 가져옵니다.
var clone = DataArrayPool.Get();
clone.FromCapacity(this.Count);
// 배열의 모든 DataObject를 순회하며 각각을 복제합니다.
foreach (var item in this)
{
// DataObject의 Clone 메서드를 호출하여 깊은 복사를 수행하고,
// base.Add를 사용해 추적 로직 없이 직접 추가합니다.
if (item.GetUpdatedObject() is DataObject updatedObject)
{
clone.Add(updatedObject);
if (addedList.Contains(item))
{
clone.addedList.Add(updatedObject);
}
else if (removedList.Contains(item))
{
clone.removedList.Add(updatedObject);
}
else if (modifiedList.Contains(item))
{
clone.modifiedList.Add(updatedObject);
}
}
}
return clone;
}
/// <summary>
@@ -217,57 +283,6 @@ namespace UVC.Data
/// </summary>
/// <returns>업데이트된 속성의 총 개수입니다. 업데이트된 속성이 없으면 0을 반환합니다.</returns>
public int UpdatedCount { get => addedList.Count + modifiedList.Count + removedList.Count; }
/// <summary>
/// 항목을 추가합니다.
/// </summary>
/// <param name="item">추가할 항목</param>
public new void Add(DataObject item)
{
base.Add(item);
// 변경 사항을 추적하고 이벤트 발생
if (IsChangeTracking)
{
int index = Count - 1;
addedList.Add(item);
}
}
/// <summary>
/// 항목을 제거합니다.
/// </summary>
/// <param name="item">제거할 항목</param>
/// <returns>제거 성공 여부</returns>
public new bool Remove(DataObject item)
{
int index = IndexOf(item);
if (index >= 0)
{
RemoveAt(index);
return true;
}
return false;
}
/// <summary>
/// 지정된 인덱스의 항목을 제거합니다.
/// </summary>
/// <param name="index">제거할 항목의 인덱스</param>
public new void RemoveAt(int index)
{
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException(nameof(index));
DataObject removedItem = this[index];
base.RemoveAt(index);
if (IsChangeTracking)
{
removedList.Add(removedItem);
}
}
/// <summary>
/// 컬렉션의 모든 항목을 제거합니다.
@@ -276,101 +291,87 @@ namespace UVC.Data
{
if (Count > 0)
{
var oldItems = new List<DataObject>(this);
ReturnToDataObjectPool();
base.Clear();
if (IsChangeTracking)
{
// 모든 항목을 제거 목록에 추가
removedList.AddRange(oldItems);
}
}
}
/// <summary>
/// 지정된 인덱스에 항목을 삽입합니다.
/// 객체를 풀에 반환하기 전에 초기 상태로 리셋합니다.
/// </summary>
/// <param name="index">삽입할 위치</param>
/// <param name="item">삽입할 항목</param>
public new void Insert(int index, DataObject item)
public void Reset()
{
base.Insert(index, item);
// 포함된 DataObject들을 먼저 풀에 반환합니다.
ReturnToDataObjectPool();
if (IsChangeTracking)
{
addedList.Add(item);
}
// 내부 리스트와 변경 추적 리스트를 모두 비웁니다.
base.Clear();
ClearTrackedChanges();
}
public void ReturnToPool()
{
DataArrayPool.Return(this);
}
/// <summary>
/// 지정된 인덱스의 항목을 교체합니다.
/// 이 DataArray에 포함된 모든 DataObject를 풀에 반환하고 리스트를 비웁니다.
/// DataArray의 사용이 끝났을 때 호출해야 합니다.
/// </summary>
/// <param name="index">교체할 위치</param>
/// <param name="item">새 항목</param>
public new DataObject this[int index]
private void ReturnToDataObjectPool()
{
get { return base[index]; }
set
foreach (var item in this)
{
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException(nameof(index));
DataObject oldItem = base[index];
base[index] = value;
if (IsChangeTracking)
{
addedList.Add(value);
removedList.Add(oldItem);
}
DataObjectPool.Return(item);
}
}
/// <summary>
/// 범위의 항목을 추가합니다.
/// </summary>
/// <param name="collection">추가할 항목의 컬렉션</param>
public new void AddRange(IEnumerable<DataObject> collection)
{
if (collection == null)
throw new ArgumentNullException(nameof(collection));
int startIndex = Count;
base.AddRange(collection);
if (IsChangeTracking)
{
var items = collection.ToList();
for (int i = 0; i < items.Count; i++)
{
addedList.Add(items[i]);
}
}
}
/// <summary>
/// 변경된 인덱스 목록을 초기화합니다.
/// </summary>
public void ResetChangedIndices()
public void ClearTrackedChanges()
{
addedList.Clear();
removedList.Clear();
modifiedList.Clear();
}
/// <summary>
/// 변경 내역을 저장하지 않고 항목을 추가합니다.
/// 동일한 상태와 값을 가진 현재 데이터 객체의 새 인스턴스를 생성합니다.
/// </summary>
/// <param name="item">추가할 항목</param>
public void AddWithoutTracking(DataObject item)
/// <remarks>복제된 객체는 원본 객체와 독립적이므로, 한 객체를 변경해도 다른 객체에는 영향을 미치지 않습니다.
///</remarks>
/// <returns>현재 객체의 복사본인 새 <see cref="IDataObject"/> 인스턴스를 반환합니다.</returns>
public IDataObject Clone()
{
bool oldTracking = IsChangeTracking;
IsChangeTracking = false;
Add(item);
IsChangeTracking = oldTracking;
// 풀에서 새 DataArray 인스턴스를 가져옵니다.
var clone = DataArrayPool.Get();
clone.FromCapacity(this.Count);
// 배열의 모든 DataObject를 순회하며 각각을 복제합니다.
foreach (var item in this)
{
// DataObject의 Clone 메서드를 호출하여 깊은 복사를 수행하고,
// base.Add를 사용해 추적 로직 없이 직접 추가합니다.
if (item.Clone() is DataObject clonedItem)
{
clone.Add(clonedItem);
if (addedList.Contains(item))
{
clone.addedList.Add(clonedItem);
}
else if (removedList.Contains(item))
{
clone.removedList.Add(clonedItem);
}
else if (modifiedList.Contains(item))
{
clone.modifiedList.Add(clonedItem);
}
}
}
return clone;
}
@@ -400,7 +401,9 @@ namespace UVC.Data
/// </summary>
public static implicit operator DataArray(JArray jArray)
{
return new DataArray(jArray);
var dataArray = DataArrayPool.Get();
dataArray.FromJArray(jArray);
return dataArray;
}
}
}

111
Assets/Scripts/UVC/Data/DataArrayPool.cs Normal file
View File

@@ -0,0 +1,111 @@
using RTG;
using System.Collections.Concurrent;
using UnityEngine;
namespace UVC.Data
{
/// <summary>
/// DataArray 객체의 재사용을 위한 풀링 클래스입니다.
/// </summary>
public static class DataArrayPool
{
private static readonly ConcurrentQueue<DataArray> _pool = new ConcurrentQueue<DataArray>();
private static int _maxPoolSize = 500; // DataArray는 DataObject보다 수가 적을 것이므로 기본값 조정
// --- 통계용 필드 ---
private static int _inUseCount = 0;
private static int _peakUsage = 0;
private static int _poolMisses = 0;
private static readonly object _statsLock = new object();
/// <summary>
/// 풀의 최대 크기를 설정합니다.
/// </summary>
/// <param name="size">설정할 최대 크기</param>
public static void SetMaxPoolSize(int size)
{
_maxPoolSize = size > 0 ? size : 500;
}
/// <summary>
/// 풀에서 DataArray 객체를 가져옵니다. 풀이 비어있으면 새로 생성합니다.
/// </summary>
/// <returns>재사용 가능한 DataArray 객체</returns>
public static DataArray Get()
{
bool fromPool = _pool.TryDequeue(out var array);
lock (_statsLock)
{
_inUseCount++;
if (_inUseCount > _peakUsage)
{
_peakUsage = _inUseCount;
}
if (!fromPool)
{
_poolMisses++;
if (_inUseCount > _maxPoolSize)
{
int oldSize = _maxPoolSize;
_maxPoolSize += 100; // 증가량 조정
Debug.Log($"DataArrayPool size automatically increased from {oldSize} to {_maxPoolSize}. Peak usage: {_peakUsage}");
}
}
}
if(_peakUsage % 100 == 0) Debug.Log($"DataArrayPool stats: {GetStats()}");
if (fromPool)
{
array.IsInPool = false;
array.Reset();
}
return fromPool ? array : new DataArray();
}
/// <summary>
/// 사용이 끝난 DataArray 객체를 풀에 반환합니다.
/// </summary>
/// <param name="array">반환할 DataArray 객체</param>
public static void Return(DataArray array)
{
if (array == null || array.IsInPool) return;
lock (_statsLock)
{
_inUseCount--;
}
if (_pool.Count < _maxPoolSize)
{
array.Reset();
array.IsInPool = true;
_pool.Enqueue(array);
}
}
/// <summary>
/// 풀의 현재 성능 통계를 문자열로 반환합니다.
/// </summary>
/// <returns>풀 통계 (최대 사용량, 현재 사용량, 풀 비어있을 때 생성 횟수, 현재 풀 크기)</returns>
public static string GetStats()
{
return $"Peak Usage: {_peakUsage}, In Use: {_inUseCount}, Misses: {_poolMisses}, Pooled: {_pool.Count}, Max Size: {_maxPoolSize}";
}
/// <summary>
/// 풀 통계를 초기화합니다.
/// </summary>
public static void ResetStats()
{
lock (_statsLock)
{
_peakUsage = 0;
_poolMisses = 0;
}
}
}
}

2
Assets/Scripts/UVC/Data/DataArrayPool.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: b61a9a50cc22ac946aa9e175cb06451c

63
Assets/Scripts/UVC/Data/DataMapper.cs
View File

@@ -249,12 +249,21 @@ namespace UVC.Data
/// </example>
private DataObject MapObject(JObject sourceObject, DataMask maskObject, int depth = 0, string path = "")
{
if (maskObject == null) return new DataObject(sourceObject);
if (maskObject == null)
{
var dataObj = DataObjectPool.Get();
dataObj.FromJObject(sourceObject);
return dataObj;
}
// Mask가 비어있으면 원본 객체를 그대로 사용, 깊이 제한에 도달하면 간소화된 처리
if (maskObject.Count == 0 || depth >= maxRecursionDepth)
{
DataObject dObj = new DataObject() { IdKey = maskObject.ObjectIdKey, Name = maskObject.ObjectName };
DataObject dObj = DataObjectPool.Get();
dObj.IdKey = maskObject.ObjectIdKey;
dObj.Name = maskObject.ObjectName;
// 속성 이름 변환 처리
foreach (var property in sourceObject.Properties())
{
@@ -268,7 +277,9 @@ namespace UVC.Data
return dObj;
}
DataObject target = new DataObject() { IdKey = maskObject.ObjectIdKey, Name = maskObject.ObjectName };
DataObject target = DataObjectPool.Get();
target.IdKey = maskObject.ObjectIdKey;
target.Name = maskObject.ObjectName;
foreach (var property in sourceObject.Properties())
{
@@ -352,11 +363,11 @@ namespace UVC.Data
}
else if (maskValue is DataMask)
{
target[propertyName] = new DataObject();
target[propertyName] = DataObjectPool.Get();
}
else if (maskValue is List<DataMask>)
{
target[propertyName] = new DataArray();
target[propertyName] = DataArrayPool.Get();
}
else
{
@@ -380,12 +391,14 @@ namespace UVC.Data
switch (token.Type)
{
case JTokenType.Object:
return new DataObject((JObject)token);
var dataObject = DataObjectPool.Get();
dataObject.FromJObject((JObject)token);
return dataObject;
case JTokenType.Array:
JArray array = (JArray)token;
if (array.All(item => item.Type == JTokenType.Object))
{
return new DataArray(array);
return DataArrayPool.Get().FromJArray(array);
}
return array.ToObject<object[]>();
case JTokenType.Integer:
@@ -445,7 +458,7 @@ namespace UVC.Data
private DataArray MapArray(JArray sourceArray, List<DataMask> maskTemplates, string path = "")
{
// 빠른 초기 크기 할당으로 재할당 방지
DataArray targetArray = new DataArray(sourceArray.Count);
DataArray targetArray = DataArrayPool.Get().FromCapacity(sourceArray.Count);
// 특정 크기 이상일 경우 병렬 처리 적용
if (sourceArray.Count > parallelProcessingThreshold && maskTemplates.Count <= 1)
@@ -465,12 +478,14 @@ namespace UVC.Data
{
if (sourceItem.Type == JTokenType.Object)
{
targetArray.Add(new DataObject((JObject)sourceItem));
var dataObject = DataObjectPool.Get();
dataObject.FromJObject((JObject)sourceItem);
targetArray.Add(dataObject);
}
else
{
// DataObject가 아닌 경우, 새 DataObject를 만들고 값을 넣어줍니다
var dataObject = new DataObject();
var dataObject = DataObjectPool.Get();
dataObject.Add("value", ConvertJTokenToObject(sourceItem));
targetArray.Add(dataObject);
}
@@ -481,7 +496,7 @@ namespace UVC.Data
ULog.Warning($"배열 항목 변환 오류 - 경로: {itemPath}", ex);
// 오류 발생 시 빈 객체 추가
targetArray.Add(new DataObject());
targetArray.Add(DataObjectPool.Get());
}
}
return targetArray;
@@ -524,14 +539,14 @@ namespace UVC.Data
{
// DataArray는 DataObject만 담을 수 있으므로, 배열을 처리하는 방식을 변경해야 함
var nestedArray = MapArray((JArray)sourceItem, maskTemplates, itemPath);
var container = new DataObject();
var container = DataObjectPool.Get();
container.Add("items", nestedArray);
targetArray.Add(container);
}
else
{
// 단순 값을 DataObject로 래핑
var dataObject = new DataObject();
var dataObject = DataObjectPool.Get();
dataObject.Add("value", ConvertJTokenToObject(sourceItem));
targetArray.Add(dataObject);
}
@@ -542,7 +557,7 @@ namespace UVC.Data
ULog.Warning($"배열 항목 변환 오류 - 경로: {itemPath}", ex);
// 오류 발생 시 빈 객체 추가
targetArray.Add(new DataObject());
targetArray.Add(DataObjectPool.Get());
}
}
@@ -554,7 +569,7 @@ namespace UVC.Data
/// </summary>
private DataArray MapArrayInParallel(JArray sourceArray, List<DataMask> maskTemplates, string path)
{
DataArray targetArray = new DataArray(sourceArray.Count);
DataArray targetArray = DataArrayPool.Get().FromCapacity(sourceArray.Count);
DataMask maskTemplate = maskTemplates.Count > 0 ? maskTemplates[0] : new DataMask();
var parallelOptions = new ParallelOptions
@@ -581,7 +596,7 @@ namespace UVC.Data
else
{
// 단순 값 처리
var dataObject = new DataObject();
var dataObject = DataObjectPool.Get();
dataObject.Add("value", ConvertJTokenToObject(sourceItem));
results[i] = dataObject;
}
@@ -595,7 +610,7 @@ namespace UVC.Data
ULog.Warning($"병렬 배열 처리 오류 - 경로: {itemPath}", ex);
// 오류 발생 시 빈 객체 생성
results[i] = new DataObject();
results[i] = DataObjectPool.Get();
}
});
@@ -618,7 +633,7 @@ namespace UVC.Data
/// </summary>
private DataArray MapArraySequential(JArray sourceArray, List<DataMask> maskTemplates, string path)
{
DataArray targetArray = new DataArray(sourceArray.Count);
DataArray targetArray = DataArrayPool.Get().FromCapacity(sourceArray.Count);
DataMask maskTemplate = maskTemplates.Count > 0 ? maskTemplates[0] : new DataMask();
for (int i = 0; i < sourceArray.Count; i++)
@@ -634,7 +649,7 @@ namespace UVC.Data
}
else
{
var dataObject = new DataObject();
var dataObject = DataObjectPool.Get();
dataObject.Add("value", ConvertJTokenToObject(sourceItem));
targetArray.Add(dataObject);
}
@@ -643,7 +658,7 @@ namespace UVC.Data
{
conversionErrors[itemPath] = ex;
ULog.Warning($"순차 배열 처리 오류 - 경로: {itemPath}", ex);
targetArray.Add(new DataObject());
targetArray.Add(DataObjectPool.Get());
}
}
@@ -978,9 +993,9 @@ namespace UVC.Data
catch
{
// 배열 파싱 실패시 단일 항목 배열로 처리
var dataObject = new DataObject();
var dataObject = DataObjectPool.Get();
dataObject.Add("value", sourceValue.ToString());
var array = new DataArray(1);
var array = DataArrayPool.Get().FromCapacity(1);
array.Add(dataObject);
target[propertyName] = array;
}
@@ -988,9 +1003,9 @@ namespace UVC.Data
else
{
// 다른 타입은 단일 항목 배열로 변환
var dataObject = new DataObject();
var dataObject = DataObjectPool.Get();
dataObject.Add("value", ConvertJTokenToObject(sourceValue));
var array = new DataArray(1);
var array = DataArrayPool.Get().FromCapacity(1);
array.Add(dataObject);
target[propertyName] = array;
}

515
Assets/Scripts/UVC/Data/DataObject.cs
View File

@@ -3,12 +3,9 @@
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using UnityEngine;
using UVC.Extention;
using UVC.Log;
namespace UVC.Data
{
@@ -50,13 +47,33 @@ namespace UVC.Data
/// // - password는 제외됨
/// </code>
/// </example>
public class DataObject : OrderedDictionary<string, object>, IDataObject
public class DataObject : OrderedDictionary<string, object?>, IDataObject
{
/// <summary>
/// 이 객체가 객체 풀에 있는지 여부를 나타냅니다.
/// 중복 반환을 방지하기 위해 DataObjectPool에서 내부적으로 사용됩니다.
/// </summary>
internal bool IsInPool { get; set; } = false;
/// <summary>
/// 객체의 고유 식별자를 나타내는 속성입니다. DataArray에서 데이터를 식별하는 데 사용됩니다.
/// </summary>
public string Id { get => (IdKey != null && ContainsKey(IdKey)) ? this[IdKey].ToString() : this.First().Value.ToString(); }
public string Id
{
get
{
if (IdKey != null && ContainsKey(IdKey))
{
return this[IdKey]?.ToString() ?? string.Empty;
}
if (Count > 0)
{
return this.First().Value?.ToString() ?? string.Empty;
}
return string.Empty;
}
}
/// <summary>
/// Id에 해당하는 key 문자열
@@ -72,15 +89,15 @@ namespace UVC.Data
/// <summary>
/// 직접적인 변경이 있었던 키를 저장하는 리스트입니다.
/// </summary>
protected List<string> changedProperies = new List<string>();
protected HashSet<string> changedProperies = new HashSet<string>();
/// <summary>
/// 변경된 속성의 키 목록을 읽기 전용으로 반환합니다.
/// </summary>
public ReadOnlyCollection<string> ChangedProperies => changedProperies.AsReadOnly();
public IReadOnlyCollection<string> ChangedProperies => changedProperies;
// 기존에 있던 속성 키를 추적하기 위한 집합
private HashSet<string> existingProperties = new HashSet<string>();
// 객체 생성 중에는 변경 추적을 비활성화하기 위한 플래그
private bool _isInitializing = false;
/// <summary>
/// 기본 생성자입니다. 빈 데이터 객체를 생성합니다.
@@ -93,12 +110,19 @@ namespace UVC.Data
/// <param name="other">복사할 JObject 객체</param>
public DataObject(JObject other)
{
// JObject로부터 속성을 복사
foreach (var prop in other.Properties())
_isInitializing = true;
try
{
// JToken을 object로 변환
this[prop.Name] = ConvertJTokenToObject(prop.Value);
existingProperties.Add(prop.Name);
// JObject로부터 속성을 복사
foreach (var prop in other.Properties())
{
// 인덱서를 사용하여 JToken을 객체로 변환하고 추가
this[prop.Name] = ConvertJTokenToObject(prop.Value);
}
}
finally
{
_isInitializing = false;
}
}
@@ -106,14 +130,78 @@ namespace UVC.Data
/// Dictionary로 데이터 객체를 초기화합니다.
/// </summary>
/// <param name="dictionary">초기화에 사용할 Dictionary 객체</param>
public DataObject(Dictionary<string, object> dictionary) : base()
public DataObject(Dictionary<string, object?> dictionary) : base()
{
// 생성자에서 초기 속성들을 기존 속성으로 등록
foreach (var key in dictionary.Keys)
_isInitializing = true;
try
{
Add(key, dictionary[key]);
existingProperties.Add(key);
// 생성자에서 초기 속성들을 등록
foreach (var item in dictionary)
{
this[item.Key] = item.Value;
}
}
finally
{
_isInitializing = false;
}
}
/// <summary>
/// 지정된 <see cref="JObject"/>의 속성과 값으로 현재 객체를 채웁니다.
/// </summary>
/// <remarks>이 메서드는 제공된 <see cref="JObject"/>의 모든 속성을 반복하고
/// 해당 값을 현재 객체의 해당 속성에 할당합니다. 현재 객체에 속성이 없는 경우
/// 동적으로 추가됩니다. 이 메서드는 채우기 프로세스 중 적절한 처리를 보장하기 위해 내부 초기화
/// 플래그를 임시로 설정합니다.</remarks>
/// <param name="other">복사할 속성과 값이 포함된 <see cref="JObject"/>입니다.</param>
public DataObject FromJObject(JObject other)
{
IdKey = null; // IdKey를 초기화합니다.
Name = string.Empty; // Name을 초기화합니다.
_isInitializing = true;
try
{
// JObject로부터 속성을 복사
foreach (var prop in other.Properties())
{
// 인덱서를 사용하여 JToken을 객체로 변환하고 추가
this[prop.Name] = ConvertJTokenToObject(prop.Value);
}
}
finally
{
_isInitializing = false;
}
return this;
}
/// <summary>
/// 지정된 사전의 키-값 쌍으로 현재 객체를 채웁니다.
/// </summary>
/// <remarks>이 메서드는 제공된 사전을 기반으로 객체의 속성을 업데이트합니다.
/// 사전의 키가 속성 이름과 일치하면 속성 값이 해당 값으로 설정됩니다.
/// 사전에 예상되는 속성 유형과 일치하는 유효한 키와 값이 포함되어 있는지 확인합니다.</remarks>
/// <param name="dictionary">객체의 속성을 초기화하는 키-값 쌍을 포함하는 사전입니다. 키는 속성
/// 이름을 나타내고 값은 해당 속성 값을 나타냅니다.</param>
public DataObject FromDictionary(Dictionary<string, object?> dictionary)
{
IdKey = null; // IdKey를 초기화합니다.
Name = string.Empty; // Name을 초기화합니다.
_isInitializing = true;
try
{
// 생성자에서 초기 속성들을 등록
foreach (var item in dictionary)
{
this[item.Key] = item.Value;
}
}
finally
{
_isInitializing = false;
}
return this;
}
/// <summary>
@@ -121,7 +209,7 @@ namespace UVC.Data
/// </summary>
/// <param name="token">변환할 JToken 객체</param>
/// <returns>변환된 C# 객체</returns>
private object ConvertJTokenToObject(JToken token)
private object? ConvertJTokenToObject(JToken token)
{
switch (token.Type)
{
@@ -134,10 +222,12 @@ namespace UVC.Data
case JTokenType.Boolean:
return token.ToObject<bool>();
case JTokenType.Object:
return new DataObject((JObject)token);
var dataObject = DataObjectPool.Get();
dataObject.FromJObject((JObject)token);
return dataObject;
case JTokenType.Array:
JArray array = (JArray)token;
return new DataArray(array);
return DataArrayPool.Get().FromJArray(array);
default:
return token.ToString();
}
@@ -147,33 +237,10 @@ namespace UVC.Data
/// 모든 프로퍼티를 변경된 것으로 표시합니다.
/// 전체 데이터가 갱신되었을 때 사용합니다.
/// </summary>
public void InitData()
public void MarkAllAsUpdated()
{
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);
}
changedProperies.UnionWith(this.Keys);
}
/// <summary>
@@ -183,17 +250,8 @@ namespace UVC.Data
/// <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);
}
// 인덱서를 사용하여 일관된 변경 추적 로직을 보장합니다.
this[propertyName] = value;
}
/// <summary>
@@ -202,32 +260,26 @@ namespace UVC.Data
/// </summary>
/// <param name="key">접근할 속성의 키</param>
/// <returns>속성값</returns>
public new object this[string key]
public new object? this[string key]
{
get => base[key];
set
{
// 속성 설정 전에 기존에 있는 속성인지 확인
bool isExisting = ContainsKey(key) || existingProperties.Contains(key);
// 키가 새로 추가되거나 기존 값이 변경되었는지 확인합니다.
bool hasChanged = !TryGetValue(key, out object? oldValue) || !Equals(oldValue, value);
// 기본 구현 호출
base[key] = value;
// 기존 속성이었다면 변경된 것으로 처리
if (isExisting)
if (hasChanged)
{
if (!changedProperies.Contains(key))
// 기본 딕셔너리에 값을 설정합니다.
base[key] = value;
// 객체 초기화 중이 아닐 때만 변경 사항을 추적합니다.
if (!_isInitializing)
{
changedProperies.Add(key);
}
}
else
{
// 새로 추가된 속성은 기존 속성으로 등록
existingProperties.Add(key);
}
OnPropertyChanged(key);
}
}
@@ -239,7 +291,7 @@ namespace UVC.Data
/// <returns>변환된 정수 값 또는 기본값</returns>
public int GetInt(string propertyName, int defaultValue = 0)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is int intValue)
return intValue;
@@ -256,7 +308,7 @@ namespace UVC.Data
/// <returns>변환된 문자열 값 또는 기본값</returns>
public string? GetString(string propertyName, string? defaultValue = null)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
return value.ToString();
}
@@ -271,7 +323,7 @@ namespace UVC.Data
/// <returns>변환된 불리언 값 또는 기본값</returns>
public bool GetBool(string propertyName, bool defaultValue = false)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is bool boolValue)
return boolValue;
@@ -288,7 +340,7 @@ namespace UVC.Data
/// <returns>변환된 부동 소수점 값 또는 기본값</returns>
public float GetFloat(string propertyName, float defaultValue = 0f)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is float floatValue)
return floatValue;
@@ -305,7 +357,7 @@ namespace UVC.Data
/// <returns>변환된 더블 값 또는 기본값</returns>
public double GetDouble(string propertyName, double defaultValue = 0.0)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is double doubleValue)
return doubleValue;
@@ -315,14 +367,20 @@ namespace UVC.Data
}
/// <summary>
/// 지정된 문자열을 배정밀도 부동 소수점 숫자로 변환합니다.
/// 지정된 속성의 값을 long으로 변환하여 반환합니다.
/// </summary>
/// <param name="v">변환할 숫자의 문자열 표현입니다.</param>
/// <returns>입력 문자열에서 구문 분석된 배정밀도 부동 소수점 숫자 또는 변환이 실패하면 <c>0.0</c>을 반환합니다.
///</returns>
public double GetLong(string v)
/// <param name="propertyName">속성 이름</param>
/// <param name="defaultValue">속성이 없거나 변환할 수 없는 경우 반환할 기본값</param>
/// <returns>변환된 long 값 또는 기본값</returns>
public long GetLong(string propertyName, long defaultValue = 0L)
{
return GetDouble(v, 0.0);
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is long longValue)
return longValue;
return Convert.ToInt64(value);
}
return defaultValue;
}
/// <summary>
@@ -333,7 +391,7 @@ namespace UVC.Data
/// <returns>변환된 DateTime 값 또는 기본값</returns>
public DateTime? GetDateTime(string propertyName, DateTime? defaultValue = null)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is DateTime dateTime)
return dateTime;
@@ -351,7 +409,7 @@ namespace UVC.Data
/// <returns>변환된 열거형 값 또는 기본값</returns>
public T GetEnum<T>(string propertyName, T defaultValue = default) where T : Enum
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is T enumValue)
return enumValue;
@@ -368,7 +426,7 @@ namespace UVC.Data
/// <returns>IDataObject 인터페이스를 구현한 객체 또는 기본값</returns>
public IDataObject? Get(string propertyName, IDataObject? defaultValue = null)
{
if (TryGetValue(propertyName, out object value) && value != null)
if (TryGetValue(propertyName, out object? value) && value != null)
{
if (value is IDataObject dataObject) return dataObject;
}
@@ -383,54 +441,130 @@ namespace UVC.Data
/// <returns>DataArray 객체 또는 기본값</returns>
public DataArray? GetDataArray(string propertyName, DataArray? defaultValue = null)
{
if (TryGetValue(propertyName, out object value) && value != 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 DataArrayPool.Get().FromJArray(jArray);
}
return defaultValue;
}
/// <summary>
/// 지정된 속성의 값을 DataObject로 변환하여 반환합니다.
/// <para>이 메서드는 먼저 현재 객체에서 속성을 찾습니다. 찾지 못하면 중첩된 DataObject를 재귀적으로 탐색합니다.</para>
/// <para>과도한 재귀로 인한 문제를 방지하기 위해 최대 탐색 깊이가 제한됩니다.</para>
/// </summary>
/// <param name="propertyName">속성 이름</param>
/// <param name="defaultValue">속성이 없거나 변환할 수 없는 경우 반환할 기본값</param>
/// <param name="maxDepth">재귀 탐색의 최대 깊이</param>
/// <returns>DataObject 객체 또는 기본값</returns>
public DataObject? GetDataObject(string propertyName, DataObject? defaultValue = null)
public DataObject? GetDataObject(string propertyName, DataObject? defaultValue = null, int maxDepth = 8)
{
if (TryGetValue(propertyName, out object value) && value != null)
// 내부 재귀 탐색을 시작하고, 결과를 찾지 못하면 기본값을 반환합니다.
return GetDataObjectInternal(propertyName, 0, maxDepth) ?? defaultValue;
}
/// <summary>
/// 재귀 깊이 제한을 두고 내부적으로 DataObject를 탐색하는 private 헬퍼 메서드입니다.
/// </summary>
/// <param name="propertyName">찾을 속성 이름</param>
/// <param name="currentDepth">현재 재귀 깊이</param>
/// <param name="maxDepth">최대 재귀 깊이</param>
private DataObject? GetDataObjectInternal(string propertyName, int currentDepth, int maxDepth)
{
// StackOverflow 방지를 위한 최대 재귀 깊이
if (currentDepth >= maxDepth)
{
return null; // 깊이 제한 초과 시 탐색 중단
}
// 1. 현재 객체에서 직접 속성 검색
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);
}
// propertyName으로 직접 객체를 찾지 못했거나, 찾았지만 적절한 타입이 아닌 경우,
// 현재 DataObject의 값들 중 DataObject 타입인 것들을 순회하며 내부에서 propertyName을 다시 검색합니다.
foreach (KeyValuePair<string, object> keyValue in this)
{
var dataObj = DataObjectPool.Get();
dataObj.FromJObject(jObject);
return dataObj;
}
if (value is Dictionary<string, object?> dict)
{
var dataObj = DataObjectPool.Get();
dataObj.FromDictionary(dict);
return dataObj;
}
}
// 2. 중첩된 DataObject에서 재귀적으로 검색
foreach (KeyValuePair<string, object?> keyValue in this)
{
if (keyValue.Value is DataObject nestedDataObject)
{
// 중첩된 DataObject에서 propertyName을 검색합니다.
// 여기서 defaultValue로 null을 전달하여, 이 탐색 단계에서 찾지 못하면
// 외부 호출의 defaultValue가 사용되도록 합니다.
DataObject? foundInNested = nestedDataObject.GetDataObject(propertyName, null);
// 재귀 호출 시 깊이를 1 증가
DataObject? foundInNested = nestedDataObject.GetDataObjectInternal(propertyName, currentDepth + 1, maxDepth);
if (foundInNested != null)
{
return foundInNested; // 중첩된 객체에서 찾았으면 반환
return foundInNested;
}
}
}
return defaultValue;
return null; // 이 경로에서 객체를 찾지 못함
}
/// <summary>
/// 지정된 경로를 사용하여 중첩된 DataObject를 찾습니다.
/// 경로는 점(.)으로 구분된 속성 이름과 배열 인덱스로 구성됩니다.
/// </summary>
/// <example>
/// <code>
/// var userProfile = data.FindDataObjectByPath("users.0.profile");
/// </code>
/// </example>
/// <param name="path">"data.users.0.profile"과 같은 객체 경로</param>
/// <param name="defaultValue">경로를 찾을 수 없는 경우 반환할 기본값</param>
/// <returns>찾은 DataObject 또는 기본값</returns>
public DataObject? FindDataObjectByPath(string path, DataObject? defaultValue = null)
{
var segments = path.Split('.');
object? current = this;
foreach (var segment in segments)
{
if (current == null) return defaultValue;
switch (current)
{
case DataObject currentObject:
if (!currentObject.TryGetValue(segment, out current))
{
return defaultValue;
}
break;
case DataArray currentArray:
if (int.TryParse(segment, out int index) && index >= 0 && index < currentArray.Count)
{
current = currentArray[index];
}
else
{
return defaultValue;
}
break;
default:
// Path leads to a primitive value, cannot traverse further.
return defaultValue;
}
}
return current as DataObject ?? defaultValue;
}
/// <summary>
/// 속성이 제거될 때 기존 속성 목록에서도 제거합니다.
/// </summary>
@@ -441,7 +575,7 @@ namespace UVC.Data
bool result = base.Remove(key);
if (result)
{
existingProperties.Remove(key);
// 변경 추적 목록에서도 제거합니다.
changedProperies.Remove(key);
}
return result;
@@ -453,10 +587,59 @@ namespace UVC.Data
public void RemoveAll()
{
base.Clear();
existingProperties.Clear();
changedProperies.Clear();
}
/// <summary>
/// 객체를 풀에 반환하기 전에 초기 상태로 리셋합니다.
/// 모든 속성을 제거하고, 이름과 ID 키를 기본값으로 설정합니다.
/// </summary>
public void Reset()
{
RemoveAll();
Name = string.Empty;
IdKey = null;
}
/// <summary>
/// 동일한 상태와 값을 가진 현재 데이터 객체의 새 인스턴스를 생성합니다.
/// </summary>
/// <remarks>복제된 객체는 원본 객체와 독립적이므로, 한 객체를 변경해도 다른 객체에는 영향을 미치지 않습니다.
///</remarks>
/// <returns>현재 객체의 복사본인 새 <see cref="IDataObject"/> 인스턴스를 반환합니다.</returns>
public IDataObject Clone()
{
var clone = DataObjectPool.Get();
clone.Name = Name;
clone.IdKey = IdKey;
// 모든 키-값 쌍을 순회하며 깊은 복사를 수행합니다.
foreach (var pair in this)
{
object? clonedValue;
switch (pair.Value)
{
// 값이 DataObject인 경우, 재귀적으로 Clone을 호출합니다.
case DataObject dataObjectValue:
clonedValue = dataObjectValue.Clone();
break;
// 값이 DataArray인 경우, 재귀적으로 Clone을 호출합니다.
case DataArray dataArrayValue:
clonedValue = dataArrayValue.Clone();
break;
// 그 외의 경우 (primitive 타입 등)는 그대로 복사합니다.
default:
clonedValue = pair.Value;
break;
}
// 복제된 값을 새 DataObject에 추가합니다.
clone.Add(pair.Key, clonedValue);
}
clone.changedProperies = new HashSet<string>(changedProperies);
return clone;
}
/// <summary>
/// 현재 DataObject를 JObject로 변환합니다.
/// </summary>
@@ -471,6 +654,18 @@ namespace UVC.Data
return result;
}
/// <summary>
/// 변경된 것으로 표시된 속성 목록을 지웁니다.
/// </summary>
/// <remarks>이 메서드는 변경된 속성의 내부 추적을 재설정하여
/// 기록된 모든 수정 사항을 효과적으로 지웁니다. 모든 변경 내용 추적을 삭제하고
/// 새로 시작하려면 이 메서드를 사용하세요.</remarks>
public void ClearChangedProperties()
{
// 변경 추적 목록을 초기화합니다.
changedProperies.Clear();
}
/// <summary>
/// 다른 DataObject와 현재 객체를 비교하여 다른 부분만 설정합니다.
/// 변경된 키는 자동으로 추적됩니다.
@@ -478,16 +673,28 @@ namespace UVC.Data
/// <param name="other">비교할 DataObject</param>
public void UpdateDifferent(IDataObject other)
{
if (other == null || other is not DataObject) return;
if (other == null || other is not DataObject otherDataObject) return;
// 변경 추적 목록을 초기화하여 'other' 객체의 상태를 기준으로 새로 설정합니다.
changedProperies.Clear();
foreach (var keyValue in (DataObject)other)
foreach (var keyValue in otherDataObject)
{
if (!this.ContainsKey(keyValue.Key) || this[keyValue.Key] != keyValue.Value)
if (!this.ContainsKey(keyValue.Key) || (this[keyValue.Key] == null && keyValue.Value != null)
|| (this[keyValue.Key] != null && keyValue.Value == null)
|| (this[keyValue.Key] != null && keyValue.Value != null && !this[keyValue.Key]!.Equals(keyValue.Value)))
{
this[keyValue.Key] = keyValue.Value;
changedProperies.Add(keyValue.Key);
}
}
// 현재 객체에만 있는 속성은 제거합니다.
var keysToRemove = this.Keys.Except(otherDataObject.Keys).ToList();
foreach (var key in keysToRemove)
{
this.Remove(key);
changedProperies.Remove(key);
}
}
/// <summary>
@@ -496,7 +703,7 @@ namespace UVC.Data
/// <returns>업데이트 된 항목만 가지고 있는 DataObject</returns>
public IDataObject GetUpdatedObject()
{
DataObject updated = new DataObject();
DataObject updated = DataObjectPool.Get();
foreach (var key in changedProperies)
{
if (this.ContainsKey(key))
@@ -504,9 +711,28 @@ namespace UVC.Data
updated[key] = this[key];
}
}
updated.IdKey = IdKey; // ID 키를 복사합니다.
updated.Name = Name; // 이름을 복사합니다.
//id에 해당하는 속성이 있다면, 업데이트된 객체에도 포함시킵니다.
if (IdKey != null && ContainsKey(IdKey))
{
updated[IdKey] = this[IdKey];
}
else if (Count > 0)
{
var keyValue = this.First();
updated[keyValue.Key] = keyValue.Value;
}
return updated;
}
public void ReturnToPool()
{
DataObjectPool.Return(this);
}
/// <summary>
/// 업데이트 된 속성의 수.
/// </summary>
@@ -522,68 +748,7 @@ namespace UVC.Data
{
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);
}
}
}
}

144
Assets/Scripts/UVC/Data/DataObjectPool.cs Normal file
View File

@@ -0,0 +1,144 @@
using System;
using System.Collections.Concurrent;
using UnityEngine;
namespace UVC.Data
{
/// <summary>
/// DataObject 인스턴스를 재사용하기 위한 객체 풀 클래스입니다.
/// 메모리 할당과 가비지 컬렉션을 최소화하기 위해 DataObject 인스턴스를 관리합니다.
/// </summary>
/// <remarks>
/// 객체 풀링은 자주 생성 및 삭제되는 객체의 성능을 향상시키는 패턴입니다.
/// 사용이 끝난 객체를 삭제하는 대신 풀에 반환하고, 새 객체가 필요할 때 풀에서 꺼내 재사용합니다.
/// </remarks>
/// <example>
/// <code>
/// // 객체 풀에서 DataObject 가져오기
/// DataObject obj = DataObjectPool.Get();
///
/// // 객체 사용
/// obj["name"] = "홍길동";
/// obj["age"] = 30;
///
/// // 작업 완료 후 풀에 반환
/// DataObjectPool.Return(obj);
///
/// // 풀 통계 확인
/// ULog.Debug(DataObjectPool.GetStats());
/// </code>
/// </example>
public static class DataObjectPool
{
/// <summary>
/// DataObject 인스턴스를 저장하는 스레드 안전 큐입니다.
/// </summary>
private static ConcurrentQueue<DataObject> dataObjectPool = new ConcurrentQueue<DataObject>();
/// <summary>
/// 풀의 최대 크기입니다. 이 크기를 초과하는 객체는 풀에 저장되지 않습니다.
/// </summary>
private static int maxPoolSize = 1000;
// --- 통계용 필드 ---
private static int _inUseCount = 0;
private static int _peakUsage = 0;
private static int _poolMisses = 0;
private static readonly object _statsLock = new object();
/// <summary>
/// 풀의 최대 크기를 설정합니다.
/// </summary>
/// <param name="size">설정할 최대 크기</param>
public static void SetMaxPoolSize(int size)
{
maxPoolSize = size > 0 ? size : 1000;
}
/// <summary>
/// 풀에서 DataObject 인스턴스를 가져옵니다.
/// 풀이 비어있으면 새 인스턴스를 생성하여 반환합니다.
/// </summary>
/// <returns>재사용 가능한 DataObject 인스턴스</returns>
public static DataObject Get()
{
bool fromPool = dataObjectPool.TryDequeue(out var obj);
lock (_statsLock)
{
_inUseCount++;
if (_inUseCount > _peakUsage)
{
_peakUsage = _inUseCount;
}
// 풀이 비어있어서 새 객체를 만들어야 하는 경우
if (!fromPool)
{
_poolMisses++;
// 현재 사용량이 최대 풀 크기에 도달했는지 확인
if (_inUseCount > maxPoolSize)
{
int oldSize = maxPoolSize;
maxPoolSize += 1000;
Debug.Log($"DataObjectPool size automatically increased from {oldSize} to {maxPoolSize}. Peak usage: {_peakUsage}");
}
}
}
if (_peakUsage % 100 == 0) Debug.Log($"DataObjectPool stats: {GetStats()}");
if (fromPool)
{
obj.IsInPool = false;
obj.Reset();
}
return fromPool ? obj : new DataObject();
}
/// <summary>
/// 사용이 완료된 DataObject를 풀에 반환합니다.
/// 객체는 반환 전에 초기화되어 모든 속성이 제거됩니다.
/// </summary>
/// <param name="obj">풀에 반환할 DataObject 인스턴스</param>
public static void Return(DataObject obj)
{
if (obj == null || obj.IsInPool) return;
lock (_statsLock)
{
_inUseCount--;
}
if (dataObjectPool.Count < maxPoolSize)
{
obj.Reset(); // 재사용 전 완벽한 초기화
obj.IsInPool = true;
dataObjectPool.Enqueue(obj);
}
// 풀이 가득 차면 객체는 풀에 추가되지 않고 GC 대상이 됩니다.
}
/// <summary>
/// 풀의 현재 성능 통계를 문자열로 반환합니다.
/// </summary>
/// <returns>풀 통계 (최대 사용량, 현재 사용량, 풀 비어있을 때 생성 횟수, 현재 풀 크기)</returns>
public static string GetStats()
{
return $"Peak Usage: {_peakUsage}, In Use: {_inUseCount}, Misses: {_poolMisses}, Pooled: {dataObjectPool.Count}, Max Size: {maxPoolSize}";
}
/// <summary>
/// 풀 통계를 초기화합니다.
/// </summary>
public static void ResetStats()
{
lock (_statsLock)
{
_peakUsage = 0;
_poolMisses = 0;
}
}
}
}

2
Assets/Scripts/UVC/Data/DataObjectPool.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: ccfcb80fa0900584b8569695e4fb8f21

139
Assets/Scripts/UVC/Data/DataRepository.cs
View File

@@ -69,17 +69,26 @@ namespace UVC.Data
{
if (!dataObjects.ContainsKey(key))
{
dataObject.InitData();
dataObjects.Add(key, dataObject);
var newData = dataObject.Clone();
dataObjects.Add(key, newData);
dataObject.MarkAllAsUpdated();
//UniTask.Post(() => NotifyDataUpdate(key, newData));
return dataObject;
}
else
{
IDataObject obj = dataObjects[key];
obj.UpdateDifferent(dataObject);
var newDataObject = dataObject;
if (updatedDataOnly) newDataObject = obj.GetUpdatedObject();
UniTask.Post(() => NotifyDataUpdate(key, newDataObject));
IDataObject newDataObject;
if (updatedDataOnly)
{
newDataObject = obj.GetUpdatedObject();
}
else
{
newDataObject = dataObject;
}
//UniTask.Post(() => NotifyDataUpdate(key, obj));
return newDataObject;
}
}
@@ -131,25 +140,26 @@ namespace UVC.Data
/// <remarks>
/// 같은 키에 대해 여러 핸들러를 등록할 수 있습니다.
/// 핸들러는 해당 키의 데이터가 AddData를 통해 업데이트될 때마다 호출됩니다.
/// 전달 되는 데이터 객체는 업데이트된 상태고 DataRepository에 저장된 객체이기에 pool.ReturnToPool()을 호출하면 않됩니다.
/// </remarks>
public void AddDataUpdateHandler(string key, Action<IDataObject> handler)
{
if (string.IsNullOrEmpty(key))
throw new ArgumentNullException(nameof(key), "키는 null이거나 빈 문자열일 수 없습니다.");
if (handler == null)
throw new ArgumentNullException(nameof(handler), "핸들러는 null일 수 없습니다.");
lock (syncLock)
{
if (!dataUpdateHandlers.ContainsKey(key))
{
dataUpdateHandlers[key] = handler;
}
else
{
dataUpdateHandlers[key] += handler; // 기존 핸들러에 추가
}
}
}
//public void AddDataUpdateHandler(string key, Action<IDataObject> handler)
//{
// if (string.IsNullOrEmpty(key))
// throw new ArgumentNullException(nameof(key), "키는 null이거나 빈 문자열일 수 없습니다.");
// if (handler == null)
// throw new ArgumentNullException(nameof(handler), "핸들러는 null일 수 없습니다.");
// lock (syncLock)
// {
// if (!dataUpdateHandlers.ContainsKey(key))
// {
// dataUpdateHandlers[key] = handler;
// }
// else
// {
// dataUpdateHandlers[key] += handler; // 기존 핸들러에 추가
// }
// }
//}
/// <summary>
/// 지정된 키에서 데이터 업데이트 핸들러를 제거합니다.
@@ -160,24 +170,24 @@ namespace UVC.Data
/// 지정된 키에 연결된 핸들러가 없거나, 제거하려는 핸들러가 등록되지 않은 경우 아무 작업도 수행하지 않습니다.
/// 키에 연결된 마지막 핸들러가 제거되면 해당 키는 dataUpdateHandlers 딕셔너리에서 삭제됩니다.
/// </remarks>
public void RemoveDataUpdateHandler(string key, Action<IDataObject> handler)
{
if (string.IsNullOrEmpty(key))
throw new ArgumentNullException(nameof(key), "키는 null이거나 빈 문자열일 수 없습니다.");
if (handler == null)
throw new ArgumentNullException(nameof(handler), "핸들러는 null일 수 없습니다.");
lock (syncLock)
{
if (dataUpdateHandlers.ContainsKey(key))
{
dataUpdateHandlers[key] -= handler; // 기존 핸들러에서 제거
if (dataUpdateHandlers[key] == null)
{
dataUpdateHandlers.Remove(key); // 핸들러가 없으면 제거
}
}
}
}
//public void RemoveDataUpdateHandler(string key, Action<IDataObject> handler)
//{
// if (string.IsNullOrEmpty(key))
// throw new ArgumentNullException(nameof(key), "키는 null이거나 빈 문자열일 수 없습니다.");
// if (handler == null)
// throw new ArgumentNullException(nameof(handler), "핸들러는 null일 수 없습니다.");
// lock (syncLock)
// {
// if (dataUpdateHandlers.ContainsKey(key))
// {
// dataUpdateHandlers[key] -= handler; // 기존 핸들러에서 제거
// if (dataUpdateHandlers[key] == null)
// {
// dataUpdateHandlers.Remove(key); // 핸들러가 없으면 제거
// }
// }
// }
//}
/// <summary>
/// 모든 데이터 업데이트 핸들러를 제거합니다.
@@ -187,13 +197,13 @@ namespace UVC.Data
/// 예를 들어, 씬이 변경되거나 애플리케이션이 종료될 때
/// 모든 핸들러를 정리하는 데 유용합니다.
/// </remarks>
public void ClearDataUpdateHandlers()
{
lock (syncLock)
{
dataUpdateHandlers.Clear();
}
}
//public void ClearDataUpdateHandlers()
//{
// lock (syncLock)
// {
// dataUpdateHandlers.Clear();
// }
//}
/// <summary>
/// 지정된 키의 데이터가 업데이트되었음을 알리고 등록된 핸들러들을 호출합니다.
@@ -204,20 +214,20 @@ namespace UVC.Data
/// 이 메서드는 주로 내부적으로 AddData 메서드에서 호출되어
/// 특정 키의 데이터가 변경되었을 때 등록된 핸들러들에게 알립니다.
/// </remarks>
private void NotifyDataUpdate(string key, IDataObject dataObject)
{
if (string.IsNullOrEmpty(key))
throw new ArgumentNullException(nameof(key), "키는 null이거나 빈 문자열일 수 없습니다.");
if (dataObject == null)
throw new ArgumentNullException(nameof(dataObject), "데이터 객체는 null일 수 없습니다.");
lock (syncLock)
{
if (dataUpdateHandlers.ContainsKey(key))
{
dataUpdateHandlers[key]?.Invoke(dataObject);
}
}
}
//private void NotifyDataUpdate(string key, IDataObject dataObject)
//{
// if (string.IsNullOrEmpty(key))
// throw new ArgumentNullException(nameof(key), "키는 null이거나 빈 문자열일 수 없습니다.");
// if (dataObject == null)
// throw new ArgumentNullException(nameof(dataObject), "데이터 객체는 null일 수 없습니다.");
// lock (syncLock)
// {
// if (dataUpdateHandlers.ContainsKey(key))
// {
// dataUpdateHandlers[key]?.Invoke(dataObject);
// }
// }
//}
/// <summary>
/// 저장소에 저장된 모든 데이터 객체의 키 목록을 반환합니다.
@@ -380,12 +390,13 @@ namespace UVC.Data
if (value is JObject jObject)
{
DataObject dataObject = new DataObject(jObject);
DataObject dataObject = DataObjectPool.Get();
dataObject.FromJObject(jObject);
AddData(key, dataObject, false);
}
else if (value is JArray jArray)
{
DataArray dataArray = new DataArray(jArray);
DataArray dataArray = DataArrayPool.Get().FromJArray(jArray);
AddData(key, dataArray, false);
}
}

40
Assets/Scripts/UVC/Data/HttpPipeLine.cs
View File

@@ -230,6 +230,8 @@ namespace UVC.Data
requestInProgress[key] = true;
}
IDataObject? mappedObject = null;
try
{
string result = string.Empty;
@@ -247,8 +249,7 @@ namespace UVC.Data
{
throw new OperationCanceledException("Operation cancelled", cancellationToken);
}
IDataObject? dataObject = null;
result = result.Trim();
if (!string.IsNullOrEmpty(result))
@@ -317,13 +318,13 @@ namespace UVC.Data
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(result)))
{
dataObject = info.DataMapper.MapObjectStream(stream);
mappedObject = info.DataMapper.MapObjectStream(stream);
}
}
else
{
JObject source = JObject.Parse(result);
dataObject = info.DataMapper.Map(source);
mappedObject = info.DataMapper.Map(source);
}
}
}
@@ -376,12 +377,12 @@ namespace UVC.Data
JArray? validSource = info.Validator.GetValidData(stream);
if (validSource != null)
{
dataObject = info.DataMapper.Map(validSource);
mappedObject = info.DataMapper.Map(validSource);
}
}
else
{
dataObject = info.DataMapper.MapArrayStream(stream);
mappedObject = info.DataMapper.MapArrayStream(stream);
}
}
}
@@ -393,12 +394,12 @@ namespace UVC.Data
JArray? validSource = info.Validator.GetValidData(source);
if (validSource != null)
{
dataObject = info.DataMapper.Map(validSource);
mappedObject = info.DataMapper.Map(validSource);
}
}
else
{
dataObject = info.DataMapper.Map(source);
mappedObject = info.DataMapper.Map(source);
}
}
}
@@ -416,17 +417,24 @@ namespace UVC.Data
{
throw new OperationCanceledException("Operation cancelled", cancellationToken);
}
if (dataObject != null) dataObject = DataRepository.Instance.AddData(key, dataObject, info.UpdatedDataOnly);
var repoObject = mappedObject;
if (mappedObject != null)
{
repoObject = DataRepository.Instance.AddData(key, mappedObject, info.UpdatedDataOnly);
if (repoObject == mappedObject) repoObject = mappedObject.Clone();
}
// 갱신 된 데이터가 있는 경우 핸들러 호출
if (info.UpdatedDataOnly)
{
if (dataObject != null && dataObject.UpdatedCount > 0)
if (repoObject != null && repoObject.UpdatedCount > 0)
{
if (info.SuccessHandler != null)
{
// 로컬 변수로 복사하여 클로저에서 안전하게 사용
var handlerData = dataObject;
var handlerData = repoObject;
// UI 스레드에서 성공 핸들러 호출
await UniTask.SwitchToMainThread();
info.SuccessHandler.Invoke(handlerData);
@@ -436,12 +444,12 @@ namespace UVC.Data
}
if (dataObject != null)
if (repoObject != null)
{
if (info.SuccessHandler != null)
{
// 로컬 변수로 복사하여 클로저에서 안전하게 사용
var handlerData = dataObject;
var handlerData = repoObject;
// UI 스레드에서 성공 핸들러 호출
await UniTask.SwitchToMainThread();
info.SuccessHandler.Invoke(handlerData);
@@ -482,6 +490,12 @@ namespace UVC.Data
}
finally
{
//DataMapper가 생성한 임시 객체를 풀에 반환합니다.
if (mappedObject != null)
{
mappedObject.ReturnToPool();
}
lock (requestInProgress)
{
requestInProgress[key] = false;

18
Assets/Scripts/UVC/Data/IDataObject.cs
View File

@@ -14,7 +14,7 @@
/// 모든 프로퍼티를 변경된 것으로 표시합니다.
/// 전체 데이터가 갱신되었을 때 사용합니다.
/// </summary>
public void InitData();
public void MarkAllAsUpdated();
/// <summary>
/// 다른 DataObject와 현재 객체를 비교하여 다른 부분만 설정합니다.
@@ -36,5 +36,21 @@
/// <returns>업데이트된 속성의 총 개수입니다. 업데이트된 속성이 없으면 0을 반환합니다.</returns>
public int UpdatedCount { get; }
/// <summary>
/// 동일한 상태와 값을 가진 현재 데이터 객체의 새 인스턴스를 생성합니다.
/// </summary>
/// <remarks>복제된 객체는 원본 객체와 독립적이므로, 한 객체를 변경해도 다른 객체에는 영향을 미치지 않습니다.
///</remarks>
/// <returns>현재 객체의 복사본인 새 <see cref="IDataObject"/> 인스턴스를 반환합니다.</returns>
public IDataObject Clone();
/// <summary>
/// 재사용을 위해 객체를 풀로 반환합니다.
/// </summary>
/// <remarks>객체가 더 이상 필요하지 않을 때 이 메서드를 호출하여
/// 풀에서 재사용할 수 있도록 해야 합니다. 객체를 풀로 반환하기 전에 객체가 유효한 상태인지 확인하십시오.</remarks>
public void ReturnToPool();
}
}

50
Assets/Scripts/UVC/Data/MQTTPipeLine.cs
View File

@@ -201,8 +201,7 @@ namespace UVC.Data
if (infoList.ContainsKey(topic))
{
MQTTPipeLineInfo info = infoList[topic];
IDataObject? dataObject = null;
IDataObject? mappedObject = null;
message = message.Trim();
if (!string.IsNullOrEmpty(message))
{
@@ -211,11 +210,8 @@ namespace UVC.Data
if (message.StartsWith("{"))
{
JObject source = JObject.Parse(message);
if (info.Validator != null && !info.Validator.IsValid(source))
{
return; // 유효성 검사 실패 시 핸들러 호출을 중단
}
if (info.DataMapper != null) dataObject = info.DataMapper.Map(source);
if (info.Validator != null && !info.Validator.IsValid(source)) return;
if (info.DataMapper != null) mappedObject = info.DataMapper.Map(source);
}
else if (message.StartsWith("["))
{
@@ -223,38 +219,40 @@ namespace UVC.Data
if (info.Validator != null)
{
JArray? validSource = info.Validator.GetValidData(source);
if (validSource != null && validSource.Count > 0)
{
// 유효한 데이터가 있는 경우에만 매핑
if (info.DataMapper != null) dataObject = info.DataMapper.Map(validSource);
}
else
{
return; // 유효성 검사 실패 시 핸들러 호출을 중단
}
}
else
{
if (info.DataMapper != null) dataObject = info.DataMapper.Map(source);
// 유효성 검사 실패 시 핸들러 호출을 중단
if (validSource == null || validSource.Count == 0) return;
source = validSource;
}
if (info.DataMapper != null) mappedObject = info.DataMapper.Map(source);
}
if (dataObject != null) dataObject = DataRepository.Instance.AddData(topic, dataObject, info.UpdatedDataOnly);
if (mappedObject == null) return;
// DataRepository는 내부적으로 데이터를 복사/업데이트하므로, mappedObject는 여기서 임시 객체가 됩니다.
var repoObject = DataRepository.Instance.AddData(topic, mappedObject, info.UpdatedDataOnly);
if(repoObject == mappedObject) repoObject = mappedObject.Clone();
// 핸들러 호출이 필요한지 확인
bool shouldInvoke = !info.UpdatedDataOnly || (dataObject != null && dataObject.UpdatedCount > 0);
bool shouldInvoke = !info.UpdatedDataOnly || (repoObject != null && repoObject.UpdatedCount > 0);
if (shouldInvoke)
{
var handlerData = repoObject;
// 핸들러를 메인 스레드에서 안전하게 호출
UniTask.Post(() => info.Handler?.Invoke(dataObject));
UniTask.Post(() => info.Handler?.Invoke(handlerData));
}
}
catch (Exception ex)
{
// 예외 발생 시 로깅 또는 처리
// 예외 로깅도 메인 스레드에서 처리하여 Unity API 호출에 대한 스레드 안정성 확보
UniTask.Post(() => ULog.Error($"Error processing message for topic '{topic}': {ex.Message}", ex));
//UniTask.Post(() => ULog.Error($"Error processing message for topic '{topic}': {ex.Message}", ex));
ULog.Error($"Error processing message for topic '{topic}': {ex.Message}", ex);
}
finally
{
// DataMapper가 생성한 임시 객체를 풀에 반환합니다.
if (mappedObject != null)
{
mappedObject.ReturnToPool();
}
}
}
}