如何让foreach 的var自动识别自己写的类型 (Unity萌新的备忘录）

public class Pack<Key, Value>
{
    
    private Key[] pack;
    private Value[] packValue;
  
    /// <summary>
    /// foreach遍历，不用继承IEnumerable<T>.只需要写一个带有IEnumerator<T>的返回类型 GetEnumeraotr()方法。因为PackCollection继承了IEnumerator<T>所以这里填的PackCllection返回类型。也可以直接填IEnumerator<T>
    /// </summary>
    /// <returns></returns>
    public PackCollection GetEnumerator()
    {
        return new PackCollection(this);
    }
    /// <summary>
    /// foreach遍历的结构体，需要继承IEnumerator<T>。因为我是遍历泛型的。
    /// </summary>
    public struct PackCollection : IEnumerator<PackItem<Key,Value>>
    {
        private Key[] keys;
        private Value[] values;
        private int index;
        public PackCollection(Pack<Key,Value> pack)
        {
            this.keys = pack.pack;
            this.values = pack.packValue;
            index = -1;
        }

        public PackItem<Key, Value> Current
        {
            get
            {
                if (index<0)
                {
                    return null;
                }
                else
                {
                    return new PackItem<Key, Value>(keys[index],values[index]);
                }
            }
        }

        object IEnumerator.Current
        {
            get
            {
                if (index < 0)
                {
                    return null;
                }
                else
                {
                    return new PackItem<Key, Value>(keys[index], values[index]);
                }
            }
        }

        public void Dispose()
        {                }

        public bool MoveNext()
        {
            ++index;
            if (index<keys.Length)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public void Reset()
        {
            index = -1;
        }
    
    }
  

}
[System.Serializable]
public class PackItem<Key, Value>
{
    public PackItem(Key key, Value value)
    {
        this._key = key;
        this._value = value;
    }
    private Key _key;
    public Key key
    {
        get { return _key; }
    }
    public Value value
    {
        get { return _value; }
    }
    private Value _value;
}

       不继承IEnumerable<T>的好处就是你写的GetEnumerator方法，只需要让返回类型继承IEnumerator<T>就可以，可以让foreach 遍历时的 var自动识别你的对象的类型。

这样就可以直接用Item点里面的方法，而不用删除var重新定类型。

      继承了IEnumerable<T>的就要实现接口，实现后返回两个GetEnumerator的方法（一个是带泛型返回类型的，一个是不带的），你是不能修改返回类型，你填写后的是不会被foreach的var识别到类型，还要自己确定类型。（大概是我不知道如何让foreach调用带类型的GetEnumerator）