​

前言


在Unity的日常业务开发中，经常遇到含有滚动列表的业务功能，最常见的比如背包，结算，任务，排行榜等。这些功能大都看起来十分简单，往往一个布局再加个滚动视图就能完成整个业务的开发。但也正因为这些业务复杂度很低，往往充斥着大量的复制粘贴，更有甚者每次刷新数据都要对单元格进行销毁和重建，性能堪忧。那么本篇就来写写对于这些列表的管理方式和优化点。


需求分析


既然要对单元格进行管理，那么首先就要定义一个最基本的单元格类，该类定义了单元格的索引以及创建，销毁，选中等方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
using UnityEngine;

public abstract class BaseListItem
{
    private int m_Index;
    private bool m_IsActive;
    private GameObject m_GameObject;
    private Transform m_Transform;
    private RectTransform m_RectTransform;

    public int id
    {
        get { return m_Index + 1; }
    }

    public int index
    {
        get { return m_Index; }
        set { m_Index = value; }
    }

    public bool isActive
    {
        get { return m_IsActive; }
    }

    public GameObject gameObject
    {
        get { return m_GameObject; }
    }

    public Transform transform
    {
        get { return m_Transform; }
    }

    public RectTransform rectTransform
    {
        get { return m_RectTransform; }
    }

    public void Create(GameObject go)
    {
        if (go is null)
        {
            Debug.LogError("列表格子为空");
            return;
        }

        m_GameObject = go;
        m_Transform = go.transform;
        m_RectTransform = go.GetComponent<RectTransform>();
        m_IsActive = go.activeSelf;
        SetActive(true);
        OnCreate(go);
    }

    public void Select(bool isSelected)
    {
        OnSelect(isSelected);
    }

    public void SetActive(bool isActive)
    {
        if (m_GameObject is null || m_IsActive  == isActive)
        {
            return;
        }

        m_IsActive = isActive;
        m_GameObject.SetActive(isActive);
    }
    
    protected abstract void OnCreate(GameObject go);

    protected virtual void OnSelect(bool isSelected)
    {
    }
}

之后要实现一个可以对单元格进行管理的列表类，而为了避免频繁的创建和销毁，该列表需要实现对单元格的复用，即：只创建可视范围内的单元格，当界面滚动时，改变可视范围之外的单元格的坐标，使其重新出现在列表尾部或头部，并显示新的数据。

另外，并不是所有列表都需要滚动操作，在某些数据量不大的地方，可以采用静态列表来管理：只有单元格数量不足时才进行创建，而已经创建出来的单元格，只能随着生命周期销毁或手动强行销毁。


静态列表


功能很简单，主要就是单元格复用，单元格选中，需要注意的是，SetItemCount方法在列表发生变化会时强制重建一次，然后就把布局组件禁用，以防再次触发网格重建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

[AddComponentMenu("UI/StaticList")]
[RequireComponent(typeof(LayoutGroup))]
public class StaticList : MonoBehaviour
{
    public event Action<BaseListItem> itemUpdateEvent;
    public event Action<BaseListItem, bool> itemSelectEvent;

    public GameObject prefab;

    private List<BaseListItem> m_ListItem;
    private LayoutGroup m_LayoutGroup;
    private ContentSizeFitter m_ContentSizeFitter;
    private RectTransform m_RectTransform;
    private int m_CurrSelectIndex = -1;
    private Type m_ItemClassType;
    private bool m_IsInit;
    private int m_CurrCount;
    public void Init<T>() where T : BaseListItem, new()
    {
        if (m_IsInit)
        {
            Debug.LogError("不能重复初始化");
            return;
        }

        m_LayoutGroup = GetComponent<LayoutGroup>();
        m_ContentSizeFitter = GetComponent<ContentSizeFitter>();
        m_RectTransform =  GetComponent<RectTransform>();
        
        if (m_LayoutGroup is null)
        {
            Debug.LogError("布局组件为空");
            return;
        }

        if (prefab is null)
        {
            Debug.LogError("prefab为空");
            return;
        }

        prefab.SetActive(false);
        m_ItemClassType = typeof(T);
        m_ListItem = new();
        SetLayoutEnabled(true);
        m_IsInit = true;
    }

    public void SetItemCount(int count)
    {
        if (!m_IsInit)
        {
            Debug.LogError("未初始化，必须先调用Init方法进行初始化");
            return;
        }

        if (m_CurrCount != count)
        {
            SetLayoutEnabled(true); 
        }
        
        for (int i = 0; i < count; i++)
        {
            if (i < m_ListItem.Count)
            {
                m_ListItem[i].SetActive(true);
                itemUpdateEvent?.Invoke(m_ListItem[i]);
            }
            else
            {
                GetItem(i);
                m_ListItem[i].SetActive(true);
                itemUpdateEvent?.Invoke(m_ListItem[i]);
            }
        }

        for (int i = count; i < m_ListItem.Count; i++)
        {
            m_ListItem[i].SetActive(false);
        }

        if (m_CurrCount != count)
        {
            LayoutRebuilder.ForceRebuildLayoutImmediate(m_RectTransform);
            SetLayoutEnabled(false);
        }

        m_CurrCount = count;
    }

    public void SelectItem(int index)
    {
        if (!m_IsInit)
        {
            Debug.LogError("未初始化，必须先调用Init方法进行初始化");
            return;
        }

        if (m_ListItem == null || m_ListItem.Count < 1 || index < 0 || index >= m_ListItem.Count)
        {
            return;
        }

        if (m_CurrSelectIndex > -1 && m_CurrSelectIndex < m_ListItem.Count && m_ListItem[m_CurrSelectIndex] != null)
        {
            itemSelectEvent?.Invoke(m_ListItem[m_CurrSelectIndex], false);
        }

        if (m_ListItem[index] != null)
        {
            m_CurrSelectIndex = index;
            itemSelectEvent?.Invoke(m_ListItem[index], true);
        }
    }

    public BaseListItem GetItemByIndex(int index)
    {
        if (!m_IsInit)
        {
            Debug.LogError("未初始化，必须先调用Init方法进行初始化");
            return null;
        }

        if (m_ListItem == null || m_ListItem.Count < 1 || index < 1 || index >= m_ListItem.Count)
        {
            return null;
        }

        return m_ListItem[index];
    }

    private void GetItem(int index)
    {
        GameObject go = Instantiate(prefab, transform, false);
        go.transform.localPosition = Vector3.zero;
        go.transform.localScale = Vector3.one;
        BaseListItem item = Activator.CreateInstance(m_ItemClassType) as BaseListItem;

        if (item == null)
        {
            Debug.LogError("创建 [" + m_ItemClassType.FullName + "] 实例失败");
            return;
        }

        item.Create(go);
        item.index = index;
        m_ListItem.Add(item);
    }

    private void SetLayoutEnabled(bool enabled)
    {
        m_LayoutGroup.enabled = enabled;

        if (m_ContentSizeFitter is not null)
        {
            m_ContentSizeFitter.enabled = enabled;
        }
    }
}

使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using TMPro;
using UnityEngine;

public class Test : MonoBehaviour
{
    public StaticList staticList;

    void Start()
    {
        staticList.itemUpdateEvent += OnItemUpdate;
        staticList.Init<TestItem>();
        staticList.SetItemCount(10);
    }

    private void OnItemUpdate(BaseListItem baseListItem)
    {
        if (baseListItem is TestItem testItem)
        {
            testItem.txt.text = testItem.id.ToString();
        }
    }
}

public class TestItem : BaseListItem
{
    public TextMeshProUGUI txt;

    protected override void OnCreate(GameObject go)
    {
        txt = go.transform.Find("txt").GetComponent<TextMeshProUGUI>();
    }
}

可以看到，当单元格减少后并没有销毁单元格，只有单元格数量不足时才会创建新的单元格，符合需求。


滚动列表


滚动列表就稍微复杂些，需要计算ScrollRect的可视区域，当列表滚动时只创建可视区域能容纳的单元格数量。那么第一个问题迎面而来，如何计算可视区域？


可视区域计算


如上图所示，绿色区域是可视区域（ScrollRect的大小），红色部分是实际容纳单元格的区域，Unity的ScrollRect组件中有OnValueChanged事件，可以监听滚动坐标变化，这个滚动坐标是一个[0,1]的百分比，当滚动到尽头时它的值就达到1（注意，纵向滚动起始为1，滚动到头则为0）。而ScrollRect可滚动的距离=红色区域-绿色区域，那么这里就可以得到可视区域的起始坐标计算方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private void ScrollRectOnValueChanged(Vector2 position)
{
    if (m_ScrollRect.vertical)
    {
        float scrollSize = Mathf.Max(m_ScrollRect.content.rect.height - m_ScrollRectTransform.rect.height, 0);
        m_ScrollPosition = (1f - position.y) * scrollSize;//纵向滚动时初始为1，滚动到头为0
    }
    else
    {
        float scrollSize = Mathf.Max(m_ScrollRect.content.rect.width - m_ScrollRectTransform.rect.width, 0);
        m_ScrollPosition = position.x * scrollSize;
    }

    m_ScrollPosition = Mathf.Clamp(m_ScrollPosition, 0, scrollSize);
}

终点用起点坐标+滚动区域尺寸，这里不需要计算用到的时候算一下就可以了。有了可视范围，还需要知道可视范围能显示多少个单元格，为了兼容网格布局和横纵布局，这里直接计算可视范围的数据行数和列数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

if (m_ScrollRect.vertical)
{
    float realScrollWidth = m_ScrollRectTransform.sizeDelta.x + xSpacing;
    float realItemWidth = m_PrefabRect.sizeDelta.x + xSpacing;
    int column = Mathf.FloorToInt(realScrollWidth / realItemWidth);
    m_Column = Math.Max(1, column); //最少有一列
    m_Row = m_ItemCount / m_Column + (m_ItemCount % m_Column > 0 ? 1 : 0);
}
else
{
    float realScrollHeight = m_ScrollRectTransform.sizeDelta.y + ySpacing;
    float realItemHeight = m_PrefabRect.sizeDelta.y + ySpacing;
    int row = Mathf.FloorToInt(realScrollHeight / realItemHeight);
    m_Row = Math.Max(1, row); //最少有一行
    m_Column = m_ItemCount / m_Row + (m_ItemCount % m_Row > 0 ? 1 : 0);
}

可视范围的相关参数都有了，就需要根据这些参数找出当前显示的数据范围。到这一步问题又来了：数据的索引如何跟可视区域进行映射？


容器尺寸与索引范围


容器尺寸的计算就很简单，假设有100个格子，间距为5，每个格子高度为100，那么容器尺寸就是100100 + 99 5。把这个尺寸进行累计，存储到一个List里，就得到了每一行的末尾坐标，比如第一行的末尾就是105，第二行则为210，第三行为315………

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private void Resize()
{
    m_ItemSizeArray.Clear();//单元格的高度或宽度（纵向滚动为高，横向滚动为款）
    m_ItemOffsetArray.Clear();//每一行或列的终点坐标
    float spacing = m_ScrollRect.vertical ? ySpacing : xSpacing;//单元格间隔
    float offset = 0f;
    int rowOrColumn = m_ScrollRect.vertical ? m_Row : m_Column;
    int perCount = m_ScrollRect.vertical ? m_Column : m_Row;

    for (int i = 0; i < m_ItemCount; i++)
    {
        // 为了实现可自定义单元格尺寸的功能，使用这个事件进行尺寸获取，没有则用单元格默认尺寸
        m_ItemSizeArray.Add(renderItemSizeEvent?.Invoke(i) ?? m_PrefabRect.sizeDelta);
    }

    for (var i = 0; i < rowOrColumn; i++) // 只存储行或列的第一个元素的宽或高
    {
        int index = i * perCount;
        float itemSize = m_ScrollRect.vertical ? m_ItemSizeArray[index].y : m_ItemSizeArray[index].x;
        offset = offset + itemSize + (i == 0 ? 0 : spacing);
        m_ItemOffsetArray.Add(offset);
    }

    float offest = m_ItemOffsetArray[^1];
    float width = m_ScrollRect.horizontal ? offest : m_ScrollRect.content.sizeDelta.x;
    float height = m_ScrollRect.vertical ? offest : m_ScrollRect.content.sizeDelta.y;
    m_ScrollRect.content.sizeDelta = new Vector2(width, height);//计算容器的尺寸
}

然后使用二分法来根据可视区域计算数据的起始行列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//计算数据的起止行（或列）
private void CalculateCurrentActiveItemRange(out int startRowOrColumn, out int endRowOrColumn)
{
    float scrollRectSize = m_ScrollRect.vertical ? m_ScrollRectTransform.rect.height : m_ScrollRectTransform.rect.width;
    float startPosition = m_ScrollPosition;//当前可视区域的起始坐标
    float endPosition = m_ScrollPosition + scrollRectSize;//当前可视区域的终止坐标
    startRowOrColumn = GetItemIndexAtPosition(startPosition, 0, m_ItemOffsetArray.Count - 1);
    endRowOrColumn = GetItemIndexAtPosition(endPosition, 0, m_ItemOffsetArray.Count - 1);
}

//使用二分法查找当前的起始行（列）和终止行（列）
private int GetItemIndexAtPosition(float position, int startRowOrColumn, int endRowOrColumn)
{
    if (startRowOrColumn >= endRowOrColumn)
    {
        return startRowOrColumn;
    }

    while (startRowOrColumn < endRowOrColumn)
    {
        int middleRowOrColumn = (startRowOrColumn + endRowOrColumn) / 2;

        if (m_ItemOffsetArray[middleRowOrColumn] >= position)
        {
            endRowOrColumn = middleRowOrColumn;
        }
        else
        {
            startRowOrColumn = middleRowOrColumn + 1;
        }
    }

    return startRowOrColumn;
}

有了起止行（或列）就能计算出数据的索引。例如可视区域能展示3行4列，滚动到某一位置时，显示的数据是从第4到第7行，那么数据是从（4-1）*4  = 12 到（7 - 1）*4 + 4 = 28，其实就是一个简单的二维数组的索引计算。

1
2
3
4
5
CalculateCurrentActiveItemRange(out int startRowOrColumn, out int endRowOrColumn);
//这里startRowOrColumn和endRowOrColumn都是从0开始
int perCount = m_ScrollRect.vertical ? m_Column : m_Row;
int startIndex = startRowOrColumn * perCount;
int endIndex = Mathf.Min(m_ItemCount - 1, endRowOrColumn * perCount + perCount - 1);

剩下的工作就是遍历startIndex到endIndex，把超出可视区域的单元格进行隐藏，进入可视范围的单元格进行刷新，这里单元格我用链表来存储，原因是在滚动时需要不断的对可视范围内单元格的头和尾进行插入和删除，链表的效率更高。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
m_RemainingItemIndexes.Clear();
LinkedListNode<BaseListItem> current = m_ActiveItems.First;//使用链表来存储可视范围内的单元格

while (current != null)
{
    if (current.Value.index < startIndex || current.Value.index > endIndex)//超出可视范围进行隐藏，并从可视范围内移除。
    {
        RecycleItem(current.Value);
        current = m_ActiveItems.First;
    }
    else
    {
        m_RemainingItemIndexes.Add(current.Value.index);
        current = current.Next;
    }
}

if (m_RemainingItemIndexes.Count == 0)//
{
    for (int i = startIndex; i <= endIndex; i++)
    {
        AddItem(i, ListPositionType.Last);
    }
}
else
{
    for (int i = endIndex; i >= startIndex; i--)//如果数据在前面，向向头部插入单元格
    {
        if (i < m_RemainingItemIndexes[0])
        {
            AddItem(i, ListPositionType.First);
        }
    }

    for (int i = startIndex; i <= endIndex; i++)//如果数据在后面，向尾部插入单元格
    {
        if (i > m_RemainingItemIndexes[^1])
        {
            AddItem(i, ListPositionType.Last);
        }
    }
}

private void AddItem(int index, ListPositionType listPosition)
{
    var item = GetItem();
    item.index = index;
    item.transform.localScale = Vector3.one;
    item.transform.SetParent(m_ScrollRect.content, false);
    item.SetActive(true);
    item.rectTransform.anchorMin = new Vector2(isHorizontalReverse ? 1 : 0, isVerticalReverse ? 0 : 1);
    item.rectTransform.anchorMax = new Vector2(isHorizontalReverse ? 1 : 0, isVerticalReverse ? 0 : 1);
    item.rectTransform.pivot = new Vector2(isHorizontalReverse ? 1 : 0, isVerticalReverse ? 0 : 1);
    int row = m_ScrollRect.vertical ? index / m_Column : index % m_Row;
    int column = m_ScrollRect.vertical ? index % m_Column : index / m_Row;
    Vector2 size = m_ItemSizeArray[index];
    float itemXSpacing = column > 0 ? this.xSpacing : 0;
    float itemYSpacing = row > 0 ? this.ySpacing : 0;
    float posX = (column * size.x + itemXSpacing * column) * (isHorizontalReverse ? -1 : 1);
    float posY = (row * size.y + itemYSpacing * row) * (isVerticalReverse ? 1 : -1);
    item.rectTransform.anchoredPosition = new Vector2(posX, posY);

    if (item.rectTransform.sizeDelta != size)
    {
        item.rectTransform.sizeDelta = size;
    }

    if (listPosition == ListPositionType.First)
    {
        m_ActiveItems.AddFirst(item);
    }
    else
    {
        m_ActiveItems.AddLast(item);
    }

    renderItemEvent?.Invoke(item);
}

另外以上代码可以直接对单元格坐标进行布局，无需使用Untiy的布局组件，也避免了频繁的网格重建。到这里复用列表的基本功能就完成了，效果如下：

可视范围能展示20个单元格，滚动时最多创建了25个单元格，符合需求。用文字把代码一块一块拆解还是不太容易，直接贴完整代码，纯手撸纯原创

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

[RequireComponent(typeof(ScrollRect))]
public class ScrollList : MonoBehaviour
{
    enum ListPositionType
    {
        First,
        Last
    }

    public event Action<BaseListItem> renderItemEvent;
    public event Func<int, Vector2> renderItemSizeEvent;
    public float xSpacing;
    public float ySpacing;
    public bool isHorizontalReverse;
    public bool isVerticalReverse;
    public GameObject prefab;

    private float scrollSize
    {
        get
        {
            if (m_ScrollRect.vertical)
            {
                return Mathf.Max(m_ScrollRect.content.rect.height - m_ScrollRectTransform.rect.height, 0);
            }

            return Mathf.Max(m_ScrollRect.content.rect.width - m_ScrollRectTransform.rect.width, 0);
        }
    }

    private ScrollRect m_ScrollRect;
    private RectTransform m_ScrollRectTransform;
    private RectTransform m_PrefabRect;
    private Type m_ItemClassType;
    private int m_Row;
    private int m_Column;
    private int m_ItemCount;
    private int m_CurrStartRowOrColumn;
    private int m_CurrEndRowOrColumn;
    private float m_ScrollPosition;
    private LinkedList<BaseListItem> m_ActiveItems;
    private Queue<BaseListItem> m_RecycledItems;
    private List<Vector2> m_ItemSizeArray;
    private List<float> m_ItemOffsetArray;
    private List<int> m_RemainingItemIndexes;
    private bool m_IsInit;
    private bool m_HasAddEvent;
    private bool m_HasInitScrollPos;

    private void OnEnable()
    {
        if (!m_IsInit)
        {
            return;
        }

        if (m_ScrollRect is null)
        {
            Debug.LogError("[Scroll Rect] 组件不存在");
            return;
        }

        AddEvent();
    }

    private void OnDisable()
    {
        if (!m_IsInit)
        {
            return;
        }

        if (m_ScrollRect is null)
        {
            Debug.LogError("[Scroll Rect] 组件不存在");
            return;
        }

        RemoveEvent();
    }

    public void Init<T>() where T : BaseListItem
    {
        if (m_IsInit)
        {
            Debug.LogError("不能重复初始化");
            return;
        }

        m_ScrollRect = GetComponent<ScrollRect>();

        if (m_ScrollRect is null)
        {
            Debug.LogError("[Scroll Rect] 组件不存在");
            return;
        }

        if (m_ScrollRect.content is null || m_ScrollRect.viewport is null)
        {
            Debug.LogError("ScrollRect组件设置异常");
            return;
        }

        if (prefab is null)
        {
            Debug.LogError("prefab为空");
            return;
        }

        AddEvent();

        if (m_ScrollRect.vertical)
        {
            m_ScrollRect.content.anchorMin = new Vector2(0, isVerticalReverse ? 0 : 1);
            m_ScrollRect.content.anchorMax = new Vector2(1, isVerticalReverse ? 0 : 1);
            m_ScrollRect.content.pivot = new Vector2(0, isVerticalReverse ? 0 : 1);
        }
        else
        {
            m_ScrollRect.content.anchorMin = new Vector2(isHorizontalReverse ? 1 : 0, 0);
            m_ScrollRect.content.anchorMax = new Vector2(isHorizontalReverse ? 1 : 0, 1);
            m_ScrollRect.content.pivot = new Vector2(isHorizontalReverse ? 1 : 0, 0);
        }

        m_ScrollRectTransform = m_ScrollRect.GetComponent<RectTransform>();
        m_ScrollRect.content.offsetMax = Vector2.zero;
        m_ScrollRect.content.offsetMin = Vector2.zero;
        m_ScrollRect.content.anchoredPosition = Vector2.zero;
        m_ScrollRect.content.localRotation = Quaternion.identity;
        m_ScrollRect.content.localScale = Vector3.one;
        m_PrefabRect = prefab.GetComponent<RectTransform>();
        m_ItemClassType = typeof(T);
        m_ActiveItems = new();
        m_RecycledItems = new();
        m_ItemSizeArray = new();
        m_ItemOffsetArray = new();
        m_RemainingItemIndexes = new();
        m_IsInit = true;
    }

    public void SetItemCount(int count, bool keepPosition = true)
    {
        if (!m_IsInit)
        {
            Debug.LogError("未初始化，必须先调用Init方法进行初始化");
            return;
        }

        if (m_ItemCount == count)
        {
            RefreshActiveItems(keepPosition);
            return;
        }

        m_ItemCount = count;

        if (m_ScrollRect.vertical)
        {
            float realScrollWidth = m_ScrollRectTransform.sizeDelta.x + xSpacing;
            float realItemWidth = m_PrefabRect.sizeDelta.x + xSpacing;
            int column = Mathf.FloorToInt(realScrollWidth / realItemWidth);
            m_Column = Math.Max(1, column); //最少有一列
            m_Row = m_ItemCount / m_Column + (m_ItemCount % m_Column > 0 ? 1 : 0);
        }
        else
        {
            float realScrollHeight = m_ScrollRectTransform.sizeDelta.y + ySpacing;
            float realItemHeight = m_PrefabRect.sizeDelta.y + ySpacing;
            int row = Mathf.FloorToInt(realScrollHeight / realItemHeight);
            m_Row = Math.Max(1, row); //最少有一行
            m_Column = m_ItemCount / m_Row + (m_ItemCount % m_Row > 0 ? 1 : 0);
        }

        RecycleAllItems();
        Resize();

        if (!m_HasInitScrollPos)
        {
            ResetScrollPosition();
            m_HasInitScrollPos = true;
        }
        else if (!keepPosition)
        {
            ResetScrollPosition();
        }
        else
        {
            ResetVisibleItems();
        }
    }

    public void SetScrollPosition(float scrollPosition, bool isForce)
    {
        if (!m_IsInit)
        {
            Debug.LogError("未初始化，必须先调用Init方法进行初始化");
            return;
        }

        if (m_ItemCount < 1)
        {
            return;
        }

        scrollPosition = Mathf.Clamp(scrollPosition, 0, scrollSize);

        if (!isForce && Mathf.Approximately(m_ScrollPosition, scrollPosition))
        {
            return;
        }

        m_ScrollPosition = scrollPosition;

        if (m_ScrollRect.vertical)
        {
            m_ScrollRect.verticalNormalizedPosition = 1f - m_ScrollPosition / scrollSize;
        }
        else
        {
            m_ScrollRect.horizontalNormalizedPosition = m_ScrollPosition / scrollSize;
        }

        ResetVisibleItems();
    }

    public void RefreshActiveItems(bool keepPosition = true)
    {
        if (!m_IsInit)
        {
            Debug.LogError("未初始化，必须先调用Init方法进行初始化");
            return;
        }

        if (m_ItemCount < 1 || m_ActiveItems.Count < 1)
        {
            return;
        }

        if (!keepPosition)
        {
            ResetScrollPosition();
            return;
        }

        foreach (var activeItem in m_ActiveItems)
        {
            renderItemEvent?.Invoke(activeItem);
        }
    }

    private void ResetScrollPosition()
    {
        if (m_ScrollRect.vertical)
        {
            float scrollPositionFactor = isVerticalReverse ? 0 : 1;
            SetScrollPosition((1 - scrollPositionFactor) * scrollSize, true);
        }
        else
        {
            float scrollPositionFactor = isHorizontalReverse ? 1 : 0;
            SetScrollPosition(scrollPositionFactor * scrollSize, true);
        }
    }

    private void Resize()
    {
        if (m_ItemCount < 1)
        {
            return;
        }

        m_ItemSizeArray.Clear();
        m_ItemOffsetArray.Clear();
        float spacing = m_ScrollRect.vertical ? ySpacing : xSpacing;
        float offset = 0f;
        int rowOrColumn = m_ScrollRect.vertical ? m_Row : m_Column;
        int perCount = m_ScrollRect.vertical ? m_Column : m_Row;

        for (int i = 0; i < m_ItemCount; i++)
        {
            m_ItemSizeArray.Add(renderItemSizeEvent?.Invoke(i) ?? m_PrefabRect.sizeDelta);
        }

        for (var i = 0; i < rowOrColumn; i++) // 只存储行或列的第一个元素的宽或高
        {
            int index = i * perCount;
            float itemSize = m_ScrollRect.vertical ? m_ItemSizeArray[index].y : m_ItemSizeArray[index].x;
            offset = offset + itemSize + (i == 0 ? 0 : spacing);
            m_ItemOffsetArray.Add(offset);
        }

        float offest = m_ItemOffsetArray[^1];
        float width = m_ScrollRect.horizontal ? offest : m_ScrollRect.content.sizeDelta.x;
        float height = m_ScrollRect.vertical ? offest : m_ScrollRect.content.sizeDelta.y;
        m_ScrollRect.content.sizeDelta = new Vector2(width, height);
    }

    private void ResetVisibleItems()
    {
        if (m_ItemCount < 1)
        {
            return;
        }

        CalculateCurrentActiveItemRange(out int startRowOrColumn, out int endRowOrColumn);

        if (startRowOrColumn == m_CurrStartRowOrColumn && endRowOrColumn == m_CurrEndRowOrColumn)
        {
            return;
        }

        int perCount = m_ScrollRect.vertical ? m_Column : m_Row;
        int startIndex = startRowOrColumn * perCount;
        int endIndex = Mathf.Min(m_ItemCount - 1, endRowOrColumn * perCount + perCount - 1);
        m_RemainingItemIndexes.Clear();
        LinkedListNode<BaseListItem> current = m_ActiveItems.First;

        while (current != null)
        {
            if (current.Value.index < startIndex || current.Value.index > endIndex)
            {
                RecycleItem(current.Value);
                current = m_ActiveItems.First;
            }
            else
            {
                m_RemainingItemIndexes.Add(current.Value.index);
                current = current.Next;
            }
        }

        if (m_RemainingItemIndexes.Count == 0)
        {
            for (int i = startIndex; i <= endIndex; i++)
            {
                AddItem(i, ListPositionType.Last);
            }
        }
        else
        {
            for (int i = endIndex; i >= startIndex; i--)
            {
                if (i < m_RemainingItemIndexes[0])
                {
                    AddItem(i, ListPositionType.First);
                }
            }

            for (int i = startIndex; i <= endIndex; i++)
            {
                if (i > m_RemainingItemIndexes[^1])
                {
                    AddItem(i, ListPositionType.Last);
                }
            }
        }

        m_CurrStartRowOrColumn = startRowOrColumn;
        m_CurrEndRowOrColumn = endRowOrColumn;
    }

    private void CalculateCurrentActiveItemRange(out int startRowOrColumn, out int endRowOrColumn)
    {
        float scrollRectSize = m_ScrollRect.vertical ? m_ScrollRectTransform.rect.height : m_ScrollRectTransform.rect.width;
        float startPosition = m_ScrollPosition;
        float endPosition = m_ScrollPosition + scrollRectSize;
        startRowOrColumn = GetItemIndexAtPosition(startPosition, 0, m_ItemOffsetArray.Count - 1);
        endRowOrColumn = GetItemIndexAtPosition(endPosition, 0, m_ItemOffsetArray.Count - 1);

        bool verticalReverseCondition = m_ScrollRect.vertical && isVerticalReverse;
        bool horizontalReverseCondition = m_ScrollRect.horizontal && isHorizontalReverse;

        if (horizontalReverseCondition || verticalReverseCondition)
        {
            int tempStartRowOrColumn = (m_ScrollRect.vertical ? m_Row : m_Column) - endRowOrColumn - 1;
            int tempEndRowOrColumn = (m_ScrollRect.vertical ? m_Row : m_Column) - startRowOrColumn - 1;
            startRowOrColumn = tempStartRowOrColumn;
            endRowOrColumn = tempEndRowOrColumn;
        }
    }

    private int GetItemIndexAtPosition(float position, int startRowOrColumn, int endRowOrColumn)
    {
        if (startRowOrColumn >= endRowOrColumn)
        {
            return startRowOrColumn;
        }

        while (startRowOrColumn < endRowOrColumn)
        {
            int middleRowOrColumn = (startRowOrColumn + endRowOrColumn) / 2;

            if (m_ItemOffsetArray[middleRowOrColumn] >= position)
            {
                endRowOrColumn = middleRowOrColumn;
            }
            else
            {
                startRowOrColumn = middleRowOrColumn + 1;
            }
        }

        return startRowOrColumn;
    }

    private void AddItem(int index, ListPositionType listPosition)
    {
        if (m_ItemCount == 0)
        {
            return;
        }

        var item = GetItem();
        item.index = index;
        item.transform.localScale = Vector3.one;
        item.transform.SetParent(m_ScrollRect.content, false);
        item.SetActive(true);
        item.rectTransform.anchorMin = new Vector2(isHorizontalReverse ? 1 : 0, isVerticalReverse ? 0 : 1);
        item.rectTransform.anchorMax = new Vector2(isHorizontalReverse ? 1 : 0, isVerticalReverse ? 0 : 1);
        item.rectTransform.pivot = new Vector2(isHorizontalReverse ? 1 : 0, isVerticalReverse ? 0 : 1);
        int row = m_ScrollRect.vertical ? index / m_Column : index % m_Row;
        int column = m_ScrollRect.vertical ? index % m_Column : index / m_Row;
        Vector2 size = m_ItemSizeArray[index];
        float itemXSpacing = column > 0 ? this.xSpacing : 0;
        float itemYSpacing = row > 0 ? this.ySpacing : 0;
        float posX = (column * size.x + itemXSpacing * column) * (isHorizontalReverse ? -1 : 1);
        float posY = (row * size.y + itemYSpacing * row) * (isVerticalReverse ? 1 : -1);
        item.rectTransform.anchoredPosition = new Vector2(posX, posY);

        if (item.rectTransform.sizeDelta != size)
        {
            item.rectTransform.sizeDelta = size;
        }

        if (listPosition == ListPositionType.First)
        {
            m_ActiveItems.AddFirst(item);
        }
        else
        {
            m_ActiveItems.AddLast(item);
        }

        renderItemEvent?.Invoke(item);
    }

    private BaseListItem GetItem()
    {
        if (m_RecycledItems.Count > 0)
        {
            return m_RecycledItems.Dequeue();
        }

        var go = Instantiate(prefab);
        var item = Activator.CreateInstance(m_ItemClassType) as BaseListItem;
        item?.Create(go);
        return item;
    }

    private void RecycleAllItems()
    {
        foreach (var activeItem in m_ActiveItems)
        {
            activeItem.SetActive(false);
            activeItem.index = 0;
            m_RecycledItems.Enqueue(activeItem);
        }

        m_ActiveItems.Clear();
        m_CurrStartRowOrColumn = 0;
        m_CurrEndRowOrColumn = 0;
    }

    private void RecycleItem(BaseListItem activeItem)
    {
        m_ActiveItems.Remove(activeItem);
        m_RecycledItems.Enqueue(activeItem);
        activeItem.SetActive(false);
        activeItem.index = 0;
    }

    private void AddEvent()
    {
        if (!m_HasAddEvent)
        {
            m_ScrollRect.onValueChanged.AddListener(ScrollRectOnValueChanged);
            m_HasAddEvent = true;
        }
    }

    private void RemoveEvent()
    {
        if (m_HasAddEvent)
        {
            m_ScrollRect.onValueChanged.RemoveListener(ScrollRectOnValueChanged);
            m_HasAddEvent = false;
        }
    }

    private void ScrollRectOnValueChanged(Vector2 position)
    {
        if (m_ScrollRect.vertical)
        {
            m_ScrollPosition = (1f - position.y) * scrollSize;
        }
        else
        {
            m_ScrollPosition = position.x * scrollSize;
        }

        m_ScrollPosition = Mathf.Clamp(m_ScrollPosition, 0, scrollSize);
        ResetVisibleItems();
    }
}

结语


我见过不少所谓的无限滚动，动不动大几千行适配还做的一坨，有的甚至还只支持行列布局不支持网格布局，实在是难用的很（真想不通那么多代码写出来是干嘛的……），就想自己做一个简单易用的，于是就有了这篇东西。我做的这个复用列表代码只有500行左右，而且自动适配行列，支持单元格的横纵向翻转，没什么复杂的设置，开发业务应该可以用的很舒服了。