2023年12月26日

cloudflight

2023-12-26 5fa6947054206e2e781eadd4effdcdf52eda28c4

 Hydro.MapView/MapViewNetWork.cs

@@ -15,17 +15,20 @@
using static Hydro.MapView.MapViewEnum;
using Hydro.CommonBase;
using TimePoint = Hydro.CommonBase.TimePoint;
using System.Runtime.InteropServices;

namespace Hydro.MapView
{
    [Serializable]
    public partial class MapViewNetWork : NetWork
    {
        bool use_old = false;
        public string Name;
        private LinkViewModelList _links=new LinkViewModelList();
        public LinkViewModelList Links { get { return _links; } set { base.Links= _links = value; } }

        public List<LinkViewModel> ViewLinks { get { return base.Links.Select(l => (LinkViewModel)l).ToList(); } }

        public List<NodeViewModel> ViewNodes { get { return base.Nodes.Select(n => (NodeViewModel)n).ToList(); } }
        private NodeViewModelList _nodes = new NodeViewModelList();
        public NodeViewModelList Nodes { get { return _nodes; }set { base.Nodes = _nodes = value; } }

        public NodeViewModel StartPoint { get; set; }

@@ -924,4 +927,349 @@


    }

    //构造一个List<LinkViewModel>类，能够实现List的所有功能
    [Serializable]
    public class LinkViewModelList:List<LinkCalcModel>
    {
        //List<LinkCalcModel> base;
        Dictionary<string, LinkViewModel> dict;//
        public LinkViewModelList() : base()
        {
            this.dict = new Dictionary<string, LinkViewModel>();
        }
        //public LinkViewModelList(List<LinkCalcModel> links)
        //{
        //    base = links;
        //    base.ForEach(link => 
        //    {
        //        if (!dict.ContainsKey(link.ID))
        //            dict.Add(link.ID,link);
        //    });
        //}
        public List<LinkViewModel> ViewLinks
        {
            get
            {
                var list = new List<LinkViewModel>();
                base.ForEach(l =>
                {
                    //if (l is LinkViewModel)
                    list.Add((LinkViewModel)l);
                });
                return list;
                //return base.Select(l => (LinkViewModel)l).ToList();
            }
        }
        /// <summary>
        /// 更新字典
        /// </summary>
        public void UpdateDict()
        {
            this.dict= new Dictionary<string, LinkViewModel>();
            base.ForEach(link =>
            {
                if (!dict.ContainsKey(link.ID))
                    dict.Add(link.ID, (LinkViewModel)link);
            });
        }
        /// <summary>
        /// 修改某个oldID至newID，同时更新字典
        /// </summary>
        /// <param name="oldID"></param>
        /// <param name="newID"></param>
        public void ChangeID(string oldID,string newID)
        {
            if (dict.ContainsKey(oldID))
            {
                dict[oldID].ID = newID;
                dict.Add(newID, dict[oldID]);
                dict.Remove(oldID);                
            }
        }
        /// <summary>
        /// 实现Add方法，同时更新字典
        /// </summary>
        public void Add(LinkViewModel linkCalcModel)
        {
            base.Add(linkCalcModel);
            if (!dict.ContainsKey(linkCalcModel.ID))
                dict.Add(linkCalcModel.ID, linkCalcModel);
        }
        /// <summary>
        /// 实现AddRange方法，同时更新字典
        /// </summary>
        /// <param name="linkCalcModels"></param>
        public void AddRange(List<LinkViewModel> linkCalcModels)
        {
            base.AddRange(linkCalcModels);
            linkCalcModels.ForEach(link =>
            {
                if (!dict.ContainsKey(link.ID))
                    dict.Add(link.ID, link);
            });
        }
       
        public bool RemoveAt(int index)
        {
            if (index < 0 || index >= base.Count) return false;
            var link = base[index];
            base.RemoveAt(index);
            if (dict.ContainsKey(link.ID))
                dict.Remove(link.ID);
            return true;
        }
        /// <summary>
        /// 统计数量
        /// </summary>
        public int Count { get { return base.Count; } }
        public LinkViewModel this[string ID]
        {
            get
            {
                if (dict.ContainsKey(ID))
                    return dict[ID];
                else 
                    return (LinkViewModel)base.Find(l => l.ID == ID);
            }
        }
        public LinkViewModel this[int index]
        {
            get
            {
                return (LinkViewModel)base[index];
            }
        }

        public void Sort()
        {
            base.Sort();
        }
        //实现Sort(Comparison<LinkViewModel> comparison)方法
        public void Sort(Comparison<LinkCalcModel> comparison)
        {
            base.Sort(comparison);
        }
        //实现Select方法
        public void Select(Action<LinkViewModel> action)
        {
            //base.ForEach(action);
            //base.ForEach(action);
            ViewLinks.ForEach(action);
        }
        //实现Find方法
        public LinkViewModel Find(Predicate<LinkViewModel> match)
        {
            //base.Find(match);
            return ViewLinks.Find(match);
        }
        //实现FindAll方法
        public List<LinkViewModel> FindAll(Predicate<LinkViewModel> match)
        {
            return ViewLinks.FindAll(match);
        }
        //实现ForEach方法
        public void ForEach(Action<LinkViewModel> action)
        {
            ViewLinks.ForEach(action);
        }
        //实现RemoveAll方法
        public int RemoveAll(Predicate<LinkCalcModel> match)
        {
            return base.RemoveAll(match);
        }
        /// <summary>
        /// 实现Remove方法，同时更新字典
        /// </summary>
        public bool Remove(LinkViewModel linkCalcModel)
        {
            if (base.Remove(linkCalcModel))
            {
                if (dict.ContainsKey(linkCalcModel.ID))
                    dict.Remove(linkCalcModel.ID);
                return true;
            }
            else
                return false;
        }




    }

    //构造一个List<NodeViewModel>类，能够实现List的所有功能
    [Serializable]

    public class NodeViewModelList : List<NodeCalcModel>
    {
        //List<NodeCalcModel> base;
        Dictionary<string, NodeCalcModel> dict;//=new Dictionary<string, NodeCalcModel>();//
        public NodeViewModelList():base()
        {
            this.dict = new Dictionary<string, NodeCalcModel>();
        }
        //public NodeViewModelList(List<NodeCalcModel> nodes)
        //{
        //    base = nodes;
        //    base.ForEach(node => 
        //    {
        //        if (!dict.ContainsKey(node.ID))
        //            dict.Add(node.ID,node);
        //    });
        //}
        /// <summary>
        /// 更新字典
        /// </summary>
        public void UpdateDict()
        {
            this.dict = new Dictionary<string, NodeCalcModel>();
            base.ForEach(node =>
            {
                if (!dict.ContainsKey(node.ID))
                    dict.Add(node.ID, node);
            });
        }
        /// <summary>
        /// 修改某个oldID至newID，同时更新字典
        /// </summary>
        /// <param name="oldID"></param>
        /// <param name="newID"></param>
        public void ChangeID(string oldID, string newID)
        {
            if (dict.ContainsKey(oldID))
            {
                dict[oldID].ID = newID;
                dict.Add(newID, dict[oldID]);
                dict.Remove(oldID);
            }
        }
        /// <summary>
        /// 实现Add方法，同时更新字典
        /// </summary>
        public void Add(NodeViewModel nodeCalcModel)
        {
            base.Add(nodeCalcModel);
            if (!dict.ContainsKey(nodeCalcModel.ID))
                dict.Add(nodeCalcModel.ID, nodeCalcModel);
        }
        /// <summary>
        /// 实现AddRange方法，同时更新字典
        /// </summary>
        /// <param name="nodeCalcModels"></param>
        public void AddRange(List<NodeViewModel> nodeCalcModels)
        {
            base.AddRange(nodeCalcModels);
            nodeCalcModels.ForEach(node =>
            {
                if (!dict.ContainsKey(node.ID))
                    dict.Add(node.ID, node);
            });
        }
        /// <summary>
        /// 实现Remove方法，同时更新字典
        /// </summary>
        public bool Remove(NodeViewModel nodeCalcModel)
        {
            if (base.Remove(nodeCalcModel))
            {
                if (dict.ContainsKey(nodeCalcModel.ID))
                    dict.Remove(nodeCalcModel.ID);
                return true;
            }
            else
                return false;
        }
        public bool RemoveAt(int index)
        {
            if (index < 0 || index >= base.Count) return false;
            var node = base[index];
            base.RemoveAt(index);
            if (dict.ContainsKey(node.ID))
                dict.Remove(node.ID);
            return true;
        }
        /// <summary>
        /// 统计数量
        /// </summary>
        public int Count { get { return base.Count; } }
        public NodeViewModel this[string ID]
        {
            get
            {
                if (dict.ContainsKey(ID))
                    return (NodeViewModel)dict[ID];
                else
                    return (NodeViewModel)base.Find(l => l.ID == ID);
            }
        }
        public NodeViewModel this[int index]
        {
            get
            {
                return (NodeViewModel)base[index];
            }
        }
        //public List<NodeCalcModel> ToList()
        //{
        //    return base;
        //}
        //实现Sort方法
        public List<NodeViewModel> ViewNodes
        {
            get
            {
                //将NodeCalcModel转换为NodeViewModel
                //return this.Select(l => (NodeViewModel)l).ToList();
                List<NodeViewModel> list = new List<NodeViewModel>();
                foreach (var item in this)
                {
                    list.Add((NodeViewModel)item);
                }
                return list;
            }

        }

        public void Sort()
        {
            base.Sort();
        }
        //实现Sort(Comparison<NodeViewModel> comparison)方法
        public void Sort(Comparison<NodeCalcModel> comparison)
        {
            base.Sort(comparison);
        }
        //实现Select方法
        public void Select(Action<NodeViewModel> action)
        {
            ViewNodes.ForEach(action);
            //base.ForEach(action);
        }
        //实现Find方法
        public NodeViewModel Find(Predicate<NodeViewModel> match)
        {
            return ViewNodes.Find(match);
        }
        //实现FindAll方法
        public List<NodeViewModel> FindAll(Predicate<NodeViewModel> match)
        {
            return ViewNodes.FindAll(match);
        }
        //实现ForEach方法
        public void ForEach(Action<NodeViewModel> action)
        {
            ViewNodes.ForEach(action);
        }
        //实现RemoveAll方法
        public int RemoveAll(Predicate<NodeCalcModel> match)
        {
            return base.RemoveAll(match);
        }




    }

}