Операнд += не может применяться к операндам Т и Т

    class Vector<T>
    {
        protected T[] array;
        public int Lenght { get { return array.Length; } }
 
        public Vector() { }
        public Vector(Vector<T> vector) { vector.array.CopyTo(array, 0); }
        public Vector(int size)         { array = new T[size]; }
 
        public T SumOfArray()
        {
            T sum;
            foreach (T tmp in array) sum += tmp; // здесь
            return sum;
        }
 
        public T this[int index]
        {
            get { return array[index]; }
            set
            {
                if (index < Lenght && index >= 0) array[index] = value;
                else throw new IndexOutOfRangeException();
            }
        }
    }

    class Vector<T>
    {
        protected struct Wrap<R>
        {
            public R t;
            public static R operator +(Wrap<R> x, Wrap<R> y)
            {
                return (dynamic)x.t + y.t;
            }
            public static implicit operator R(Wrap<R> x)
            {
                return x.t;
            }
 
            public static implicit operator Wrap<R>(R x)
            {
                return new Wrap<R> { t = x };
            }
        }
 
        protected Wrap<T>[] array;
        public int Lenght { get { return array.Length; } }
 
        public Vector() { }
        public Vector(Vector<T> vector) { vector.array.CopyTo(array, 0); }
        public Vector(int size) { array = new Wrap<T>[size]; }
 
        public T SumOfArray()
        {
            Wrap<T> sum = default(T);
            foreach (Wrap<T> tmp in array) sum += tmp; // здесь
            return sum;
        }
 
 
 
        public T this[int index]
        {
            get { return array[index]; }
            set
            {
                if (index < Lenght && index >= 0) array[index] = value;
                else throw new IndexOutOfRangeException();
            }
        }
    }

    /// <summary>
    /// IConvertible 
    /// вот, что нам говорит msdn:
    /// This interface provides methods to convert 
    /// the value of an instance of an implementing type 
    /// to a common language runtime type that has an equivalent value. 
    /// The common language runtime types 
    /// are Boolean, SByte, Byte, Int16, UInt16, 
    /// Int32, UInt32, Int64, UInt64, Single, 
    /// Double, Decimal, DateTime, Char, and String.
    /// из этого списка не число только string,
    /// но string это reference type,
    /// поэтому накладываем ограничение на параметр типа : struct, т.е.
    /// value-type
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class Vector<T> : IEnumerable<T> where T : struct, IConvertible 
    {
        private readonly List<T> _items;
        public T Sum()
        {
            return
                (T) ((IConvertible) _items
                                        .Select(_ => _.ToDouble(CultureInfo.InvariantCulture))
                                        .Sum(_ => _)).ToType(typeof (T), CultureInfo.InvariantCulture);
        }
 
        public int Lenght { get { return _items.Count; } }
 
         public Vector()
        {
            _items = new List<T>();
        }
 
        public void Add(T item)
        {
            _items.Add(item);
        }
 
        public T this[int index] 
        {
            get{ return _items[index]; }
            set { _items[index] = value; }
        }
 
        public Vector(IEnumerable<T> source) : this()
        {
            _items.AddRange(source);
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            return _items.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }