using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
namespace LB_VisionProcesses
|
{
|
[Serializable]
|
public class ProcessCollections<T> : ICollection<ProcessCollectionItem<T>>
|
{
|
private readonly object _lock = new object(); // 线程安全锁
|
private List<ProcessCollectionItem<T>> _items = new List<ProcessCollectionItem<T>>();
|
|
// 通过名称查找
|
public ProcessCollectionItem<T> Get(string name)
|
{
|
lock (_lock)
|
{
|
var item = _items.FirstOrDefault(item => item.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
|
if (item == null)
|
{
|
//// 如果不存在，创建新项并分配索引
|
//_items.Add(item);
|
return default;
|
}
|
return item;
|
}
|
}
|
|
// 通过索引查找
|
public ProcessCollectionItem<T> Get(int index)
|
{
|
lock (_lock)
|
{
|
var item = _items.FirstOrDefault(item => item.Index == index);
|
if (item == null)
|
{
|
// 如果不存在，创建新项并分配索引
|
_items.Add(item);
|
return default;
|
}
|
return item;
|
}
|
}
|
|
public Dictionary<string, object> GetAllByName()
|
{
|
try
|
{
|
Dictionary<string, object> dic = new Dictionary<string, object>();
|
|
for (int i = 0; i <= _items.Count - 1; i++)
|
dic.TryAdd(_items[i].Name, _items[i].Value);
|
|
return dic;
|
}
|
catch { return new Dictionary<string, object>(); }
|
}
|
|
public List<object> GetAllByIndex()
|
{
|
try
|
{
|
List<object> list = new List<object>();
|
|
for (int i = 0; i <= _items.Count - 1; i++)
|
list.Add(_items[i].Value);
|
|
return list;
|
}
|
catch { return new List<object>(); }
|
}
|
|
// ICollection<NamedItem<T>> 实现
|
public int Count => _items.Count;
|
|
public bool IsReadOnly => false;
|
|
void ICollection<ProcessCollectionItem<T>>.Add(ProcessCollectionItem<T> item)
|
{
|
lock (_lock)
|
{
|
var existingItem = Get(item.Name);
|
|
if (existingItem != null)
|
{
|
// 如果已存在，更新现有项的值
|
existingItem = item;
|
}
|
else
|
{
|
// 如果不存在，创建新项并分配索引
|
_items.Add(item);
|
}
|
|
// 更新后自动排序
|
SortItems();
|
}
|
|
}
|
// 添加项时为新项分配一个索引
|
public void Add(string name, T value)
|
{
|
lock (_lock)
|
{
|
var existingItem = Get(name);
|
|
if (existingItem != null)
|
{
|
// 如果已存在，更新现有项的值
|
existingItem.Value = value;
|
}
|
else
|
{
|
// 如果不存在，创建新项并分配索引
|
var newItem = new ProcessCollectionItem<T>(name, _items.Count > 0 ? _items.Max(i => i.Index) + 1 : 0, value);
|
_items.Add(newItem);
|
}
|
|
// 更新后自动排序
|
SortItems();
|
}
|
}
|
// 按 Index 排序集合
|
private void SortItems()
|
{
|
lock (_lock)
|
{
|
_items = _items.OrderBy(item => item.Index).ToList();
|
}
|
}
|
|
// 通过索引器实现基于序号的访问
|
public T this[int index]
|
{
|
get
|
{
|
if (index < 0 || index >= _items.Count)
|
{
|
return default;
|
}
|
return _items[index].Value;
|
}
|
set
|
{
|
lock (_lock)
|
{
|
if (index < 0 || index >= _items.Count)
|
{
|
return;
|
}
|
_items[index].Value = value;
|
}
|
}
|
}
|
|
public T this[string name]
|
{
|
get
|
{
|
var existingItem = Get(name);
|
if (existingItem != null)
|
{
|
// 如果已存在，更新现有项的值
|
return existingItem.Value;
|
}
|
return default;
|
}
|
set
|
{
|
lock (_lock)
|
{
|
var item = _items.FirstOrDefault(i => i.Name == name);
|
if (item != null)
|
{
|
item.Value = value;
|
}
|
}
|
}
|
}
|
|
public void Clear()
|
{
|
lock (_lock)
|
{
|
_items.Clear();
|
_items.TrimExcess(); // 将容量缩减到实际元素数量
|
}
|
}
|
|
public bool Contains(ProcessCollectionItem<T> item)
|
{
|
return _items.Contains(item);
|
}
|
|
public bool Contains(string name)
|
{
|
var item = _items.FirstOrDefault(i => i.Name == name);
|
if (item != null)
|
return true;
|
|
return false;
|
}
|
|
public bool ContainsKey(string name)
|
{
|
var item = _items.FirstOrDefault(i => i.Name == name);
|
if (item != null)
|
return true;
|
|
return false;
|
}
|
|
public bool GetKey(int index, out string name)
|
{
|
if (index < 0 || index >= _items.Count)
|
{
|
name = null;
|
return false;
|
}
|
name = _items[index].Name;
|
return true;
|
}
|
|
public void CopyTo(ProcessCollectionItem<T>[] array, int arrayIndex)
|
{
|
lock (_lock)
|
{
|
_items.CopyTo(array, arrayIndex);
|
}
|
}
|
|
public bool Remove(ProcessCollectionItem<T> item)
|
{
|
lock (_lock)
|
{
|
var removed = _items.Remove(item);
|
if (removed)
|
{
|
// 移除元素后，调整后续元素的索引
|
UpdateIndexes();
|
}
|
return removed;
|
}
|
}
|
|
public IEnumerator<ProcessCollectionItem<T>> GetEnumerator()
|
{
|
lock (_lock)
|
{
|
return _items.GetEnumerator();
|
}
|
}
|
|
IEnumerator IEnumerable.GetEnumerator()
|
{
|
lock (_lock)
|
{
|
return _items.GetEnumerator();
|
}
|
}
|
|
// 通过名称删除
|
public bool Remove(string name)
|
{
|
lock (_lock)
|
{
|
var namedItem = Get(name);
|
if (namedItem != null)
|
{
|
return Remove(namedItem);
|
}
|
return false;
|
}
|
}
|
|
// 通过索引删除
|
public bool Remove(int index)
|
{
|
lock (_lock)
|
{
|
var namedItem = Get(index);
|
if (namedItem != null)
|
{
|
return Remove(namedItem);
|
}
|
return false;
|
}
|
}
|
|
// 删除项后，调整其他项的索引
|
private void UpdateIndexes()
|
{
|
lock (_lock)
|
{
|
for (int i = 0; i < _items.Count; i++)
|
{
|
_items[i].Index = i;
|
}
|
}
|
}
|
}
|
|
public class ProcessCollectionItem<T>
|
{
|
public string Name { get; set; }
|
public int Index { get; set; }
|
public T Value { get; set; } // 存储的对象
|
|
public ProcessCollectionItem(string name, int index, T value)
|
{
|
Name = name;
|
Index = index;
|
Value = value;
|
}
|
|
public override string ToString()
|
{
|
return $"{Name} (Index: {Index}, Value: {Value})";
|
}
|
}
|
}
|
