如何为含嵌套List的复杂Order类实现OrdersList实例迭代切换

看起来你之前已经搞定了继承自List<Order>的Orders类的实例切换，现在要给包含List<OrdersList>的Order类做同样的导航——核心思路其实和之前一致：维护当前索引并处理边界，只是因为结构不同，不能直接继承列表类了。下面给你两种可行的方案：

方案一：直接在Order类中嵌入导航逻辑 #

这种方式和你原来的Orders类思路最像，直接把导航相关的字段、属性和方法加到Order里，专门针对ordersList处理：

public class Order {
    public string nome { get; set; }
    public string cognome { get; set; }
    // 初始化列表避免空引用异常
    public List<OrdersList> ordersList { get; set; } = new List<OrdersList>();

    // 维护当前选中的OrdersList索引
    private int _currentOrdersListIndex = 0;

    // 处理索引边界的属性
    public int CurrentOrdersListIndex {
        get {
            // 列表为空时返回-1，避免后续访问出错
            if (ordersList.Count == 0) return -1;
            
            // 和你原来的逻辑一致，修正越界的索引
            if (_currentOrdersListIndex >= ordersList.Count) {
                _currentOrdersListIndex = 0;
            } else if (_currentOrdersListIndex < 0) {
                _currentOrdersListIndex = 0;
            }
            return _currentOrdersListIndex;
        }
        set {
            _currentOrdersListIndex = value;
        }
    }

    // 切换到下一个OrdersList
    public void MoveNextOrdersList() {
        if (ordersList.Count == 0) return;
        _currentOrdersListIndex++;
        // 调用属性自动修正索引
        _ = CurrentOrdersListIndex;
    }

    // 切换到上一个OrdersList
    public void MovePreviousOrdersList() {
        if (ordersList.Count == 0) return;
        _currentOrdersListIndex--;
        // 调用属性自动修正索引
        _ = CurrentOrdersListIndex;
    }

    // 获取当前选中的OrdersList
    public OrdersList CurrentOrdersList {
        get {
            if (ordersList.Count == 0) return null;
            return ordersList[CurrentOrdersListIndex];
        }
    }
}

public class OrdersList {
    public string id_ordine { get; set; }
    public double prezzo { get; set; }
}

使用示例： #

// 创建并填充Order实例
var johnsOrder = new Order {
    nome = "john",
    cognome = "doe",
    ordersList = new List<OrdersList> {
        new OrdersList { id_ordine = "1", prezzo = 10 },
        new OrdersList { id_ordine = "2", prezzo = 12 },
        new OrdersList { id_ordine = "3", prezzo = 22 }
    }
};

// 获取当前条目
Console.WriteLine(johnsOrder.CurrentOrdersList.id_ordine); // 输出1

// 切换到下一个
johnsOrder.MoveNextOrdersList();
Console.WriteLine(johnsOrder.CurrentOrdersList.id_ordine); // 输出2

// 切换到上一个
johnsOrder.MovePreviousOrdersList();
Console.WriteLine(johnsOrder.CurrentOrdersList.id_ordine); // 输出1

// 越界测试：连续切换到最后一个之后再切下一个
johnsOrder.MoveNextOrdersList();
johnsOrder.MoveNextOrdersList();
johnsOrder.MoveNextOrdersList();
Console.WriteLine(johnsOrder.CurrentOrdersList.id_ordine); // 输出1（回到第一个）

方案二：通用列表导航器（可复用） #

如果以后其他类里的列表也需要类似的导航功能，可以把导航逻辑封装成一个通用类，这样代码更复用：

// 通用导航器，支持任何List<T>
public class ListNavigator<T> {
    private readonly List<T> _targetList;
    private int _currentIndex = 0;

    public ListNavigator(List<T> targetList) {
        // 确保传入的列表不为空，避免空引用
        _targetList = targetList ?? new List<T>();
    }

    public int CurrentIndex {
        get {
            if (_targetList.Count == 0) return -1;
            
            if (_currentIndex >= _targetList.Count) {
                _currentIndex = 0;
            } else if (_currentIndex < 0) {
                _currentIndex = 0;
            }
            return _currentIndex;
        }
        set {
            _currentIndex = value;
        }
    }

    public void MoveNext() {
        if (_targetList.Count == 0) return;
        _currentIndex++;
        _ = CurrentIndex;
    }

    public void MovePrevious() {
        if (_targetList.Count == 0) return;
        _currentIndex--;
        _ = CurrentIndex;
    }

    public T Current {
        get {
            return _targetList.Count == 0 ? default(T) : _targetList[CurrentIndex];
        }
    }
}

// 修改Order类使用通用导航器
public class Order {
    public string nome { get; set; }
    public string cognome { get; set; }

    private List<OrdersList> _ordersList = new List<OrdersList>();
    public List<OrdersList> ordersList {
        get => _ordersList;
        set {
            // 每次更新列表时，同步更新导航器
            _ordersList = value ?? new List<OrdersList>();
            OrdersListNavigator = new ListNavigator<OrdersList>(_ordersList);
        }
    }

    // 公开导航器实例供外部调用
    public ListNavigator<OrdersList> OrdersListNavigator { get; private set; }

    public Order() {
        OrdersListNavigator = new ListNavigator<OrdersList>(_ordersList);
    }
}

public class OrdersList {
    public string id_ordine { get; set; }
    public double prezzo { get; set; }
}

使用示例： #

var johnsOrder = new Order {
    nome = "john",
    cognome = "doe",
    ordersList = new List<OrdersList> {
        new OrdersList { id_ordine = "1", prezzo = 10 },
        new OrdersList { id_ordine = "2", prezzo = 12 },
        new OrdersList { id_ordine = "3", prezzo = 22 }
    }
};

// 通过导航器操作
Console.WriteLine(johnsOrder.OrdersListNavigator.Current.id_ordine); // 1

johnsOrder.OrdersListNavigator.MoveNext();
Console.WriteLine(johnsOrder.OrdersListNavigator.Current.id_ordine); // 2

johnsOrder.OrdersListNavigator.MovePrevious();
Console.WriteLine(johnsOrder.OrdersListNavigator.Current.id_ordine); // 1

两种方案对比 #

• 方案一：简单直接，和你原来的代码风格完全一致，适合只在Order类中使用导航的场景。
• 方案二：通用性强，一次封装多次复用，适合项目中多个列表需要导航功能的场景。

内容的提问来源于stack exchange，提问作者andymo