List分组迭代器

说明：

针对长度较大的List对象，可以分组批量进行处理，如：长度为1000的List对象,可分为10组,每组100条,对数据进行业务逻辑处理...

Source

/******************************************************************************
 * 名称：List分组迭代器
 * 说明：针对长度较大的List对象，可以分组批量进行处理
 * 如：长度为1000的List<int>对象,可分为10组,每组100条,对数据进行业务逻辑处理
 * 作者：Sybs
 * 时间：2018-10-15
 * **************************************************************************/
namespace System.Collections.Generic
{
    /// <summary>
    /// List分组迭代器
    /// </summary>
    public class ListGroupIterator<T>
    {
        private int _groupsize = 1;

        /// <summary>
        /// 分组大小(缺省值为1)
        /// </summary>
        public int GroupSize
        {
            get => _groupsize;
            set => _groupsize = value < 1 ? 1 : value;
        }

        /// <summary>
        /// List数据源
        /// </summary>
        public List<T> Source { get; set; }

        public ListGroupIterator() { }
        public ListGroupIterator(int groupSize) : this(groupSize, null) { }
        public ListGroupIterator(List<T> list) : this(1, list) { }
        public ListGroupIterator(int groupSize, List<T> list)
        {
            this.GroupSize = groupSize;
            this.Source = list;
        }

        /// <summary>
        /// ListGroupIterator迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator<List<T>> GetEnumerator()
        {
            if (Source?.Count > 0)
            {
                var ps = Convert.ToInt32(Math.Ceiling(Source.Count * 1.0d / GroupSize));
                var model = Source.Count % GroupSize;
                for (int i = 0; i < ps; i++)
                {
                    var len = ps - i == 1 && model > 0 ? model : GroupSize;
                    yield return Source.GetRange(GroupSize * i, len);
                }
            }
        }

        /// <summary>
        /// 将List<T>实例赋值给ListGroupIterator对象
        /// </summary>
        /// <param name="list"></param>
        public static implicit operator ListGroupIterator<T>(List<T> list)
        {
            return new ListGroupIterator<T> { Source = list };
        }
    }
}

调用

using System;
using System.Collections.Generic;
namespace Demo
{
    class Program
    {
        static void Main()
        {
            ListGroupIterator<int> lg1 = new List<int>() { 1, 2, 3, 4, 5 };
            ListGroupIterator<int> lg2 = new ListGroupIterator<int>(new List<int> { 1, 2, 3, 4, 5 });
            ListGroupIterator<int> lg3 = new ListGroupIterator<int>(3, new List<int>() { 1, 2, 3, 4, 5 });
            
            lg3.Source.AddRange(new List<int>() { 6, 7, 8, 9 });
            lg3.GroupSize = 2;
            foreach (var item in lg3) { Console.WriteLine(string.Join(",", item)); }
            Console.ReadLine();
        }
    }
}

C#--深入理解类型

今日无事，回顾了一下C#基础知识，颇有收获，就自己的理解，写了这篇文章，如有不对，欢迎指正。

C#中的类型可以分为两类：值类型与引用类型，如下图所示。

值类型通常被分配到线程的堆栈上，而引用类型则被分配到托管堆上。例如下面例子：

valuetype和reftype在内存中的位置如下所示：

从上面可以看出，值类型与引用类型的区别在于实际数据的存储位置：

值类型的变量和实际数据都存储在堆栈中；而引用类型只有变量存储在堆栈中，变量储存着实际数据的地址，实际数据储存在与地址相对应的托管堆中。

但是，上边所说的情况并不是绝对的，也就是说值类型的实例不一定分配到线程堆上。

1、应用类型中嵌套定义值类型

以上代码内存分配情况如下：

如果类的字段类型是值类型，他将作为引用类型实例的一部分，被分配到托管堆中。但那些作为局部变量（例子中的c变量）的值类型，则依然会被分配到托管堆中。

2.值类型中嵌套定义引用类型

内存分配如下：

值类型实例总会被分配到它声明的地方，声明的是局部变量时，将分配到栈上，而声明为引用类型成员时，则被分配到托管堆上；而引用类型实例总是被分配到托管堆上。

值类型与引用类型除了在内存上分布方面的区别，还有以下几个方面的区别：

1、值类型继承自ValueType,ValueType又继承自System.Object；而引用类型则直接继承自System.Object；

2、值类型不收GC（垃圾回收器）控制，作用域结束时操作系统自行释放，从而减少了托管堆的压力；

3、若值类型是密封的（sealed），你将不能把值类型作为其他任何类型的基类；而引用类型则一般具有继承性，这里指的是类和接口；

4、值类型不能为null，他会默认初始化为数值0；而引用类型默认情况下会初始化为null值，表示不指向托管堆中的任何地址。对值为null的引用类型的任何操作，都会引发NullReferenceExcption异常；

5、由于值类型包含其实际数据，因此在默认情况下，值类型之间的参数传递不会影响变量自身；而引用类型变量保存的是数据的引用地址，他们作为参数被传递时，参数会发生改变，从影响引用类型变量的值。

两大类型的转换--装箱和拆箱

隐式转换：由低级别类型向高级别类型转换的过程；

显式转换：也叫强制类型转换；

通过is和as运算符进行安全的类型转换；

通过.NET类库中的Convert类来进行类型转换；

装箱拆箱的概念：

装箱：将值类型转换为引用类型的过程；

拆箱：将引用类型转换成值类型的过程；

装箱过程中，系统会在托管堆中生成一份托管堆中值类型对象的副本；而拆箱则是从托管堆中将引用类型所指向的已装箱数据复制回值类型对象的过程。

下面介绍装箱与拆箱过程：

1、装箱过程

具体分为以下三个步骤：

（1）内存分配：在托管堆中分配好内存空间以存放复制的实际数据；

（2）完成实际数据的复制：将值类型的实际数据复制到新分配的内存中；

（3）地址返回：将托管堆中的对象地址返回给引用类型变量；

拆箱过程：

（1）检查实例：首先检查要进行拆箱操作的引用类型变量是否为null，如果为null则抛出NullReferenceException异常；如果不为null则继续检查变量是否和拆箱后的类型是同一类型，若结果为否，会导致InvalidCastException异常。

（2）地址返回：返回已装箱变量的实际数据部分的地址；

（3）数据复制：将托管堆中的实际数据复制到栈中；

总结：

由上面图解可以知道，如果程序中有过多的拆箱装箱操作，由于两个过程都需要进行数据复制，该操作会大量额外运行时间，并且在装箱拆箱过程中必须会产生多余的变量，进一步加重了GC的负担，导致程序的性能降低。

参数传递问题剖析：

1、值类型参数的按值传递：

参数分为两类：形参与实参。形参指的是被调用方法中的参数，也就是说方法定义中的参数为形参；实参指的是调用方法时，传递给对应参数的值。

对值类型的按值传递，传递的是该值类型实例的一个副本，也就是说形参接受到的是实参的一个副本，被调用方法操作的是实参的一个副本而已；

2、引用类型的按值传递

当传递的参数是引用类型时，传递和操作的目标是指向对象的地址，而传递的实际内容是对地址的复制。由于地址指向的是实参的值，当方法对地址进行操作时，实际上操作了地址所指向的值，所以调用方法后原来实参的值就会被修改。

3、string引用类型参数按值传递的特殊情况

虽然string类型为引用类型，然而在按值传递时，传递的实参却不会因为方法中形参的改变而被修改。

string具有不变形，一个string被赋值，则不能再通过代码去修改它的值。上边代码看似oldStr被赋予了新值“New string”，但实际上内存会重新分配一块内存空间来存放“New string”字符串，然后把分配的内存首地址赋给oldStr变量。

4、值类型和引用类型参数的按引用传递

不管是值类型还是引用类型，你都可以使用ref或out关键字来实现参数的按引用传递。并且在按引用传递时，方法的定义和调用都必须显示的调用ref或out关键字，否则会发生编译错误。

在按引用传递时，不参数是值类型还是引用类型，其本质都是一样的，都是通过ref或out关键字来告诉编译器，方法传递的是参数地址而不是参数本身。

说明：