使用泛型List时如何操作运算符"++"？

你的T有可能不是数值类型，他没法加你只能
if(items[i] is int ) items[i]=items[i]+1;

<t> 类型不能运算，liST<int> 这个强制 list 所有值必须为INT ，所以不会错

有个变通的方法，用Expression.Increment表达式，构造一个Lambda，然后动态编译

写个例子：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;namespace ConsoleApplication1
{
    class Program
    {
        static T Inc<T>(T value)
        {
            var x = Expression.Parameter(typeof(T), "x");
            var body = Expression.Increment(x);
            var lambda = Expression.Lambda(body, x);
            return (lambda.Compile() as Func<T, T>)(value);
        }        static void Main(string[] args)
        {
            Console.WriteLine(Inc(2));
            Console.WriteLine(Inc(1.2f));
        }
    }
}3
2.2
请按任意键继续. . .

泛型，程序不知道你传进来的一定是int类型，万一你传个bool型或者string咋办呢？

我觉得LZ可能是学过C或者C++的，想实现类似C++的运算符重载。c++的运算符重载实在是太好用了，在类中定义运算符重载，就可以在泛型模板上直接使用。最经典的就是复数运算了。
可以百度一下 “c# 运算符重载”，c#也完全可以实现泛型List重载++操作符，只需要给List<T> 中的T重载++运算符即可！ public static T operator ++(Complex c1, Complex c2) ...{ return c1 + new T ...{ Real = c2.Real, Imaginary = c2.Imaginary }; }随手百度了一下语法哈

public static T operator ++(T T1, T T2) { T3=new T（）;
T3.X=T1.X+T2.X;
T3.Y=T1.Y-T2.Y;
......
return T3 }

感谢楼上各位，特别是caozhy版主，你的写法很新潮。微软.NET团队将语法变得越来越精练，但是可读性变的困难了，真不知道他们是怎么想的，符合高能语言的本意吗？
楼上的其他各位，请不要根据经验想当然的写代码，有空也检测一下你的代码再发
下面是修改后代码，成功编译：
public class class1<T>
    {
        private static List<T> items = new List<T>();        public static List<T> MyItems
        {
            get
            {
                return items;
            }
        }        public static void MySub()
        {
            for (int i = 0; i < items.Count; i++)
            {
                //items[i]++;   //这里提示错误：运算符"++"无法应用于"T"类型的操作数
                //将集合中各个项目值加1
                items[i]=Inc(items[i]);                //Console.WriteLine(items[i]);
            }
        }
        //使用Lambda表达式将类型参数的值加1。使用的好处是可以动态编译
        private static T Inc(T value)
        {
            var x = Expression.Parameter(typeof(T), "x");
            //var body = Expression.Increment(x);    //.NEE 3.5不提供 Increment （增量）方法
            var body = Expression.Add(x, Expression.Constant(1));    //将类型参数的值加1            //下面两段代码作用相同。只是将两行写成一行了。
            //var lambda = Expression.Lambda(body, x);
            //return (lambda.Compile() as Func<T, T>)(value);            //下面两行作用相同
            //return (Expression.Lambda<Func<T, T>>(body, x).Compile())(value);
            return (Expression.Lambda(body, x).Compile() as Func<T, T>)(value);
        }
    }

感谢楼上各位，特别是caozhy版主，你的写法很新潮。微软.NET团队将语法变得越来越精练，但是可读性变的困难了，真不知道他们是怎么想的，符合高能语言的本意吗？
楼上的其他各位，请不要根据经验想当然的写代码，发代码的时候自己先检测一下
下面是修改后代码，成功编译：
public class class1<T>
    {
        private static Collection<T> items = new Collection<T>();        public static Collection<T> MyItems
        {
            get
            {
                return items;
            }
        }        public static void MySub()
        {
            for (int i = 0; i < items.Count; i++)
            {
                //items[i]++;   //这里提示错误：运算符"++"无法应用于"T"类型的操作数                //将集合中各个项目值加1
                items[i]=Inc(items[i]);                //Console.WriteLine(items[i]);
            }
        }        //使用Lambda表达式将类型参数的值加1。使用的好处是可以动态编译
        private static T Inc(T value)
        {
            var x = Expression.Parameter(typeof(T), "x");
            //var body = Expression.Increment(x);    //.NET 3.5不提供 Increment （增量）方法
            var body = Expression.Add(x, Expression.Constant(1));    //将类型参数的值加1            //下面两段代码作用相同。只是将两行写成一行了。
            //var lambda = Expression.Lambda(body, x);
            //return (lambda.Compile() as Func<T, T>)(value);            //下面两行作用相同
            //return (Expression.Lambda<Func<T, T>>(body, x).Compile())(value);
            return (Expression.Lambda(body, x).Compile() as Func<T, T>)(value);
        }
    }

调试易

使用泛型List时如何操作运算符"++"？

解决方案 »