概要

unity比较常见的优化之一是将scrollview的滑动改成无限滚动的形式，以减少性能跟内存的开销，下面不多说，直接附上实现的代码。

技术细节

public class ScrollViewManager : MonoBehaviour
{
    
    
    public ScrollRect scrollRect;
    public RectTransform content;
    public GameObject itemPrefab;

    public int itemsPerRow = 1;
    public float verticalSpacing = 10f;
    public float horizontalSpacing = 10f;
    public float topPadding = 10f;
    public float bottomPadding = 10f;
    public float leftPadding = 10f;

    private List<RectTransform> pooledItems = new List<RectTransform>();
    private int totalItems;
    private float itemHeight = 0;
    private float itemWidth = 0;
    private System.Func<int, GameObject, GameObject> dataProvider;

    private int firstVisibleIndex;
    private int maxVisibleItemCount;

    private void Start()
    {
    
    
        scrollRect.onValueChanged.AddListener(OnScrollValueChanged);
    }

    public void InitializeList(int count, System.Func<int, GameObject, GameObject> provider)
    {
    
    
        if (itemWidth == 0)
        {
    
               
            RectTransform itemRect = itemPrefab.GetComponent<RectTransform>();
            itemHeight = itemRect.rect.height;
            itemWidth = itemRect.rect.width;
        }

        dataProvider = provider;
        totalItems = count;

        float totalHeight = CalculateContentHeight();
        content.sizeDelta = new Vector2(content.sizeDelta.x, totalHeight);

        int visibleItemCount = CalculateVisibleItemCount() + itemsPerRow;

        if (pooledItems.Count < visibleItemCount)
        {
    
    
            int itemsToCreate = visibleItemCount - pooledItems.Count;
            for (int i = 0; i < itemsToCreate; i++)
            {
    
    
                GameObject item = Instantiate(itemPrefab, content);
                pooledItems.Add(item.GetComponent<RectTransform>());
            }
        }
        else if (pooledItems.Count > visibleItemCount)
        {
    
    
            int itemsToRemove = pooledItems.Count - visibleItemCount;
            for (int i = 0; i < itemsToRemove; i++)
            {
    
    
                Destroy(pooledItems[pooledItems.Count - 1].gameObject);
                pooledItems.RemoveAt(pooledItems.Count - 1);
            }
        }

        maxVisibleItemCount = visibleItemCount;

        // 更新所有池化项目的位置和内容
        for (int i = 0; i < pooledItems.Count; i++)
        {
    
              
            pooledItems[i].gameObject.SetActive(i < totalItems);
            UpdateItemPosition(pooledItems[i], i);
            UpdateItemContent(pooledItems[i].gameObject, i);
        }

        scrollRect.verticalNormalizedPosition = 1;
        firstVisibleIndex = 0;
    }

    private float CalculateContentHeight()
    {
    
    
        int totalRows = Mathf.CeilToInt((float)totalItems / itemsPerRow);
        float contentHeight = topPadding + bottomPadding + (totalRows * itemHeight) + ((totalRows - 1) * verticalSpacing);
        float height = scrollRect.viewport != null ? scrollRect.viewport.rect.height : scrollRect.GetComponent<RectTransform>().rect.height;
        return Mathf.Max(contentHeight, height);
    }

    private int CalculateVisibleItemCount()
    {
    
    
        float height = scrollRect.viewport != null ? scrollRect.viewport.rect.height : scrollRect.GetComponent<RectTransform>().rect.height;
        return Mathf.CeilToInt(height / (itemHeight + verticalSpacing)) * itemsPerRow;
    }

    private void OnScrollValueChanged(Vector2 value)
    {
    
    
        UpdateVisibleItems();
    }

    private void UpdateVisibleItems()
    {
    
    
        if (totalItems == 0) return;

        float viewportTop = Mathf.Max(0, content.anchoredPosition.y);
        int newFirstVisibleIndex = Mathf.FloorToInt(viewportTop / (itemHeight + verticalSpacing)) * itemsPerRow;
        newFirstVisibleIndex = Mathf.Clamp(newFirstVisibleIndex, 0, Mathf.Max(0, totalItems - pooledItems.Count));

        if (newFirstVisibleIndex != firstVisibleIndex)
        {
    
    
            firstVisibleIndex = newFirstVisibleIndex;

            for (int i = 0; i < pooledItems.Count; i++)
            {
    
    
                int dataIndex = firstVisibleIndex + i;
                if (dataIndex < totalItems)
                {
    
    
                    pooledItems[i].gameObject.SetActive(true);
                    UpdateItemPosition(pooledItems[i], dataIndex);
                    UpdateItemContent(pooledItems[i].gameObject, dataIndex);                    
                }
                else
                {
    
    
                    pooledItems[i].gameObject.SetActive(false);
                }
            }
        }
    }

    private void UpdateItemPosition(RectTransform item, int index)
    {
    
    
        int row = index / itemsPerRow;
        int col = index % itemsPerRow;
        float xPos = leftPadding + col * (itemWidth + horizontalSpacing) + itemWidth / 2; // 修改：加入左边距
        float yPos = -(topPadding + row * (itemHeight + verticalSpacing) + itemHeight / 2);
        item.anchoredPosition = new Vector2(xPos, yPos);
    }


    private void UpdateItemContent(GameObject item, int index)
    {
    
    
        dataProvider(index, item);
    }
}

InitializeList 方法实现一个返回 GameObject 的函数

ScrollViewManager scrollView = GetComponent<ScrollViewManager>();
scrollView.InitializeList(1000, (index, gameObject) => 
{
    
    
    Text text = gameObject.GetComponentInChildren<Text>();
    if (text != null)
    {
    
    
        text.text = $"Item {
      
      index}";
    }
    // 在这里可以对 gameObject 进行其他自定义操作
    return gameObject;
});

这个代码考虑到多条数据切换时复用同一个ScrollView，做了简单数据限制的判定，但并不完善，感兴趣的能完善一下

小结

希望这个这个代码能启发到您，新人创作不易