1.集合想要支持foreach方式遍历,需要返回一个迭代器(IEnumerator),foreach会自动调用迭代器的状态迁移(MoveNext()、Curent、Reset())

#region Assembly mscorlib.dll, v4.0.0.0
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion using System;
using System.Runtime.InteropServices; namespace System.Collections
{
// Summary:
// Supports a simple iteration over a nongeneric collection.
[ComVisible(true)]
[Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
public interface IEnumerator
{
object Current { get; } bool MoveNext(); void Reset();
}
}

2.IEnumerable接口定制了foreach的需求

#region Assembly mscorlib.dll, v4.0.0.0
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion using System.Runtime.InteropServices; namespace System.Collections
{
// Summary:
// Exposes the enumerator, which supports a simple iteration over a non-generic
// collection.
[ComVisible(true)]
[Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
public interface IEnumerable
{
[DispId(-)]
IEnumerator GetEnumerator();
}
}

3.类似于List的列表定义如下:

    /// <summary>
/// 列表
/// </summary>
class MyList : ArrayList, IEnumerable<object>
{ // 迭代器返回  
public IEnumerator<object> GetEnumerator()
{
return new MyListEnumerator(this);
} /// <summary>
/// 1.由于IEnumerable<T>继承自IEnumerable,因此必须实现其方法
/// 2.由于已经存在同名方法,因此需要显示实现
/// </summary>
/// <returns></returns>
IEnumerator IEnumerable.GetEnumerator()
{
//return GetEnumerator(); // IEnumerator是IEnumerator<T>的基类  
return null;
}
} /// <summary>
/// 为列表定制的迭代器
/// </summary>
class MyListEnumerator : IEnumerator<object>
{
private int current = -;
private MyList _mylist; public MyListEnumerator(MyList mylist)
{
_mylist = mylist;
current = _mylist == null || _mylist.Count == ? - : ;
} public bool MoveNext()
{
current++;
return _mylist != null && _mylist.Count > current;
} object IEnumerator<object>.Current
{
get
{
if (_mylist != null && _mylist.Count > current) return _mylist[current];
return null;
}
}
// 1.由于IEnumerable<out T>继承自IEnumerable,因此必须实现其方法
// 2.由于已经存在同名方法,因此需要显示实现
object IEnumerator.Current
{
get
{
//if (_mylist != null && _mylist.Count > current)return _mylist[current];
return null;
}
} public void Reset()
{
current = _mylist == null || _mylist.Count == ? - : ;
} // IEnumerator<T>继承了IDisposable,为了遍历完后清理状态,所以需要实现该方法  
// 该方法在foreach循环完毕后自动调用  
public void Dispose() { }
}

4.IEnumerator作为迭代器,源于底层编程语言指针的启发;

引用类型不同于值类型的一个重要特点就是用到的时候才会进行真正的处理

.Net中yield关键字对此有很好的支持,以下举例说明:

       static void Main(string[] args)
{
var list = GetStrings();
foreach (var item in list)
{
Console.WriteLine(item);
} list = GetStrings();
foreach (var item in list)
{
Console.WriteLine(item);
} Console.ReadLine();
}
运行结果:aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZcAAADOCAIAAAB98tjRAAAgAElEQVR4nO2d2XMbx5bm8Sf1THRMdEzEzMPERPTtietrW4steZcXWZstL5Lt64hZniZ6XnsmYtaevqOdlLVZlixZEgmuIEWCBEkAxL7v+14FFKCYhwIKhcrMU1kFyjbB84vvgZU4eTIrUfh0sggVLbObkVlHdNYRtW7F5rbjc9vxX9YCd2c37szY78zYbz+z3362fvvZ+p0Z+52ZjTszG3etG/fmNu/Pbd6f23qwsDXvCD/3ptd8Gbs/sxnIOYK57VB+J5x3RoquWGk3XvLEy95E2Zus+BQlKt5ExZuo+JJVX6rmT9cDmWYw1wrnxUixEy1JsXI3Vu7GKr14pRev9GIslbWKDhQp9yLl7lClbqTUDSsqUhQaKKhWoa9AQeorL/kH8snK9eUl5JGVlXZVcmckd0Zy0dVxpiHtpDvbilI62hpReyupVmcMtR1jSXQkxE1uOdRKinISyomoTnZkHdKd7bS0nZZ2ZGWknYzkzHRHlfzvf7L87bWkK9cbkfOnP1iO/I+dF67cC/fL0e44yu8HqSasPX3ngz9YjsrLq9bc9aOWPz2w5l64ci+cirKQLAvO1IIrtejKLLozS+7M0m52yZOzefI2b97myds8uWVPbtmTs3lyNm/e5s2v+Aqr/sLzQGEtUFwPFu3B4kawuBEqOkLFrXBpO1LeiZZdsbI7Xt1NVD2JqidZ86ZqvlTdl274UnVvXzVvqu5L133phj/T9GdbgZwYzLfDRUl2nEipO2pJIwqXe+ESqaFPhYojCo4qUOwGlJ8L3UCh6y90/fmuP9/1F/ry5YfyylIbU07yZCVPtrM7kFtWpi+XItiMSNNJdraSHUdfdCPYTLQ3TCje3oiLhOT2tt2wRHtcXB9TMVMadLcP1bbLJ0I58c5GsrM5kCMpOZKSI6Wo60h1HenuVrq7le5up3taZRS9GFH2xc5eC/6gTozIE99WlKFoS630iBwDWVZ8+RVfYdVXXPWXVgPl58HK82BlLVhZC1W1CtfWI7X1cM0erm1E6huR+ma07ojWHLH6VrS2HavtJOrOeN2VaLiTjd1UYzfZ8KSb3nTLlxmRN9PyjrSI/pzoz7UD+U6oKA2sp8dSkKZAX32H8heHftS3p0EB5VVqqDytblJpNye5c5I7K7kHBZRSQzkzkjMztCRZVD8adaXhx2kz2dlIDGXvq70eBxVrr6n0nFNRjcTnEXE1Ij6PiKtRcTXaNq+IuDKuBD61BtK0i6uyBicycqbKCsTba/GOovW4tB6X1hMqJSV7sitrY0S9jVRvI9XbpOjFZnqP5TCqzK+hLT7p5FFNG1qE1IvN1IsNQnZFyaHWB7IM7SlSt0cbG9HGRrS5EWttxlubsaZKLVmOeGsz3nLEW454ayshbCeE7URrJ9FyJlrOZMuZbLnTwm5a3E2LnozoybS9GdGbbftG5c2KvuygPdeR5c9L/oJcHPUChZ6fqnzPB0lTPXU9Ku3mpKGU/V1WcmdHtnVORem+hj6V7mynVZsXxZsSfRGu1LEnOvZ4xx7vrKu0FuusxTrPR6QxCHE1Kq6oFRFXIqIN1LJGYZaE5ZCwGBKWQsJSWFgKi+YVEhbHVNCsBhmWRk+kf479RWgvR9o2WVFZHVu0syIr1lmJdVZjndWYtBqXVuPS83j3ebz7PCGrp2hNoySlZX0vZDet1P7RYM7k6a8pSvTWVOuvK8tGtLERa27GWo644IgLjoS4lRi5h7JN3IPYTvaLjp1UZyfVdqbbznTblW670sMtlewRnmzHk+l4smSl0/FkO6MtXW9fPVkeDu1S1HXneu5sV5Er23WN3gfZUe6SpCT5psl2WtpOSVsqyTuOzdHqaVBAtTcS7fVB3aQtiwaFgGJJKyrZBh+q5aEo7rCoKCQuBsUFUPNBcT4ozhmTMBcQ5gLCXFCW0e4qBQTrWGpZ/SOa5VA/OCBLfS7MecqrNB8SF0LthXB7MdxZDHcWI53FSGcp0lmKSEsRaSkqLUel5Wh3OdpdjvaWYyOyKYqrflY1ruydVs0p8XLFbyvPgTyqCZMnblMU69li2rdgRNGhLI644EgIWwlxK9neSnW2UtL24LM9+LR3t9OqT35a2hkUKXLNolQx7uyIdrNK1dP1ZLu7OUXDIsit3PbOSbvZbl+5rvKzm5BLJc1t2p1MdycznKR8FltprTc5hiYlbSo/JKXNpLSRlOxJyZ6Q7AlpPdFRJO9E5LppVVZUVntF/kc+0raF28vh9nK4vaTS4kALoaHmh9J6kHUowRoQZv2QZlR6JsvH1FO6Wk+9A/lajBg+eVtPxlLziYdTjSeexkiLtyknGZxF6ym5An7hmV+c8YszAXE20J4NtmeDbWuwbQ12rMGONdSZC3XmQtJcSJoLS/N0decj3QW6egvR3uKeasm0Yi9RkK2MCsozOmHy3BdkRXoLkd48oHBflmHxlepsDyxMNi9nputMq2wi23VmuzsqObMjL7kIuXMDZXuubM+d7Q0NSCXXaJ6htL9Lkn1qVOnudrq7Ld+gJYqpvgYOtZGQNdzuDXd5sk/FO89jnX4ZFWuvxlSVVKS9QlRSSxGtSc2H2vPB9nywPTeQNTDU7FDijH+oZ37xqVo+8YlPfOIT+vJyyCP8wtBjHbUI6XZhp9ptPTKv5iN382cjeiRrV1brsaLRE+kvhVd44hWfeOW1bT/xtZ/420/VCrSfBdrPAp1nwc5MUJoJSTMhaTYkzYa6fYW7s+GudUS9oSI9a6Q3t0eCPr2/nRa4ZSgtefryYiprOzuqGUWh3kyoZ3HEhS2WkfW9o+fM6sslaxgs21NPI9KbKMak0namb1Lbg18kDZXqbsm/Y0p1Hamuup4aKtEvrAbllbQel9bikrq2UsqrlWhH2fEpVqUpqRY1JZVSOgXE2YA469dqxtfXs6GEp96hZA/6RaXHFLUee1uPPa1HVNEc4efd1kPDaj50Nx+4mw/czYfupvHuI6keuE2o8cDV+IlPD9Ryy2o+JLUrq/WzLE/rZ4/wyCM88gqPvaKsX7ztEfnaT3ydJ/7OU7/0NCA9C0jPAt1nwb5mhup/hGZCvZmgrGH77G8r4mO/V7KaEjMheBaa5X1G6OlAls3+jXzBERe2EkK6KuXqUq7ezde7+UY33+j11ezlmy/yzZ6OGi9B9V6+3svpqJut6SijqNrNVLvpUaWq3VRVGqoipSpSclQJRWUpUZbiapX6ihGKqlUcKmJAnUixEy4YUMic8iqZTkKmMqa2oiC3VL3oZ0EskRQuSmHqapdkdSOlbnSo3oiI7yq+VMVNq/K7l2q2PEsRpcmyHqnbI3V7pGGPNlKVzj9evXXs5MXjn148fuqbt05/+/bp794+8+d3zv75nbPfv3P2+3fPfv/uORQKhfodyTL8dli4lqmIb3z8lcVisVgsVqvVQkBtNMqeJEEQBOmz6i+u+kur/tJqoJQuC0c/+kJutxKwGgGMWqH6JXIs6qBAGM8MEQTZ96z4Ciu+woqvuOIrpEutIx+et6jcRGMrZKMuZDDcHR6a7G7oEEGQCUT+35E2X8HmK6RKrSMnzlONwLQ7UF0Mrq3IjuhiCIIwkf1rxV/o12InzsvthnZq/Js4/tJMcU9NZnQxBEFG6N8UU+6LffgFNQxwB41zUY2MWmGRh8AQwEz43RZBkAlE/dQK9e8oNXC6GMs7NGUU1Vw0ffldjP8QQZAJxB5p2CMNe7Ruj9az1faxT76W2/lrHOWQVQFpLMzCV4JxllfoYghy0NmUH2URFxxxIVeTjn96UW7ntwO1i1lGSzNWX04XgwNMHCIIMoGoH8KTq0tvnfpWbjfqYpqKTN1OxgMJNS5GVmHkxGB0zh9BkP2O+nk7+Ub37dPfye267mAltn7qQyX/+C4GdzR0iCDIBCI/3IZ0MTXUogawLcDFYIOzjJZg1Hh0MQRBRthRPfuU6mKs0ol0Lk1RRoaRvcj5aPyLzIwuhiDICINnN3e2k51cXXrr1DfKS2pLAjZ6MLBtwSXe+AnRxRBk8tlOduRb+46EKP+OUrekMmQNhlwJbmftMYHh0MUQZPJxxIXNuLARb23Emplq+83B98U0jGkHcHeeGo1s150SWhiCHAjs0cZ6pL4eqa+H65mKePSjL+V21k2r8UdEc0EQZC9ZC1XXgtW1YOV5oJwuCcD/Bmc1Ahi1Qk2pxULTBYZjDRAE2c+sBkqr/tKKv2jzFZKl5uEPPrMwbmZRG3Xh3y0CowAbSUOHCIJMIDZvflmWJ5csNg+9f45qBKbdgepicG1FdkQXQxCEybI3v+TJLe3mltzZZKH5+ntn5XYTOzUey+AvzRT31AyKLoYgyAgDF8tqXEyDrjuwrE0Tz+8y/LWYUbdFEGSisHnzNk9+2ZNf3u3vKKlhgPvwWIamjGKVcuok/C7Gf4ggyASy6i/KfzrE5s2nSs3DJz6X243WOICLWYmdIGfVxjM0uhiCHHSeB8qyNE+sNmoHui7GmQ2u13Qnhi6GIAcOe7i2Hq6th2tr4SrwV3VNuBhQtQEJNS5GVmGsUXgKNwRBJpCNWHMj1rTHmvZYI1NtHzt5QW7XdQeqm5D5x3cxuKOhQwRBJhBHQpC1mRBytZFnWigAJRUcQw1jvaRupFZe6GIIglDYSnUU5etmni+mW6OxDlkuph6RzIwuhiDICDtpaSejekrimT8rL6ktCdjowcC2BZvj+AnRxRBk8nFmun1lu/lm752z3+uWVIaswZArwe2sPSYwHLoYgkw+rmxPUaHZe+fs99SwMe0A7s5To5HtulNCC0OQA4E7+0JRofni3YGLsW5ajT8imguCIHuJO/dCUaH54t1zQxej3lknGwGMWqGm1GKh6QLDsQYIguxnqC5mpd3Mojbqwr9bBEYBNpKGDhEEmUAUC3MNXIxqBKbdgepicG1FdkQXQxCEyW7uxS7fjhK2Hs4dHH9pprinJjm6GIIgI7Dui2kA3EFtXiwjo1ZY5CEwBDATfrdFEGQCcedfKHrZLsbyMnVfagzsYvyHCIJMICwXM1fjUF+yEjtBnhKMc2h0MQQ56OzmXygqjrqYOozHDuBCjDMbXK/pTgxdDEEOHHvlYtQqibM0ow6khGmqMNYoPIUbgiATCOBi/AYB+MX4LgZ3NHSIIMgE4sm/UFRk3N0HSirNq2QkcEi1GKuqBKPGo4shCDKCp9C3sF2Gi7FKJ41zsTZxJlxMPSKZGV0MQZARPPmeouLoMy00RZb6B353gG0LNsfxE6KLIcjks5vtKio2e++c+bNuSWXIGgy5EtzO2mMCw6GLIcjk485IslwZqdCgPLFaZkw7gLvz1Ghku+6U0MIQ5EDgTInOlCArX5eOf3pRbmfdtBp/RDQXBEH2kq1YYytW34rVt6L1XLWt/nuU1DvrZCOAUSvUlFosNF1gONYAQZD9jD1UsodK68HSerCUKQuHP/jMwriZRW3UhX+3CIwCbCQNHSIIMoGsejOr3vSKJ72ym04VG6++c4pqBKbdgepicG1FdkQXQxCEybIzvrwTW9qJLu5Ek/nqH499LLcb2qnx7+D4SzPFPTXJ0cUQBBlhYTs87wjNO4Lzm8F4tvx3R09QwwB3UJsXy8ioFRZ5CAwBzITfbREEmUDmNgNzm4G5Db/V7o9nyn84/D41jNN9YBdjeZm6LzUGdjET80QQZHKYdwTlQqxfix3pu5i5Gof6kpXYCfKUYJxDo4shyEFnaSeyuN1XMl/9d298KLcbtQPA3Vi+xsoDx6CLIQgywqo7uepOrriTK+5kulh/5fhJud2cHWi2hJylGXUgJUxThZETg+GZNoIg+xh7IDdQPlNuvv7eGbld1x1YZZeu/Rl1MbijoUMEQSaQrUh5oEq+Kh45cZ6MAUoqC63+ooaRhywfVOdBF0MQRAdXou5KNGQV6p03B/8DSYFVOmn8hVWgmXAx9Yhk9YcuhiDICJ5Uy5NuedKCJyMUm9Kxwf8GtxBFlvoHfneAbQsu8cZPiC6GIJPPwMJEb1YsNaW3Tn1Drap0aygWhlwJbmftMYHh0MUQZPLxpJredMuTEWQXO37qG2rYmHYAd+ep0ch23SmhhSHIgWA3Wd9NNXZTLU+mVWwMd5Ssm1bjj4jmgiDIXuKKV93xmjtZ3002io3Om598LbdbCViNAEatUFNqsdB0geFYAwRB9jPOaNkZLbviFXeiVqi1j370pYVxM4vaqAv/bhEYBdhIGjpEEGQCcUaKzkjJGS27YpVCTTx84nOqEZh2B6qLwbUV2RFdDEEQJs5I0RkpOqNFZ6SUrwqvv3dWbje3U9PdxPGXZop7agZFF0MQZARXpOiKFJ2RgjNSyFdbr759ihrG4w6AwVErLFYe8iW4FjPhtgiCTA7uWNEVLboiRWe4kK80//TWSWqYrvvAxqEpo3hMkN/FDM0TQZBJwxOruGMld7TojBTyleYrYzyxWv2D5lUL6ERkMDwBajzPIYIgE4g3WfXGy7uxkjtayFea6ufuq8Ng39FYDxmg20K+xIpBF0MQZIRAuu5PVn2JsideKlRbrxw36WJkuUQtnSy00ow6kCaJOq3u6KzCDUGQCSSUbQYydX+q5ktUirWWcl9M1x2oBkG2j+9icEdDhwiCTCCRvBDKNoOZeiBVLdWF196h/I4SKKl0I4FDVgZ1HnQxBEF0iBbEcL4VyjaCmXq5IR4afF9MgVU6UVvIMs2Ei6lHJKs/dDEEQUaIl9qxohDJC5Fcs9JsHznxufKS2o+AjR4MbFtAi+6WkychuhiCTD6Jcide6sSLYqwoVFvSGx9/SdZTFu7vSZAYciW4nbXHBIZDF0OQySdVkZIVKVHuxEvtmiAdO3mBGjamHcDdeWo0sl13SmhhCHIgSFelVEWSvawudI+rnliNaHipVj5OfkOZdatjzhhz6A5q9B88npg9X59fjV9//Xnaf3cFRLraTVeldFVKVaW62H3r1Le/6vD7DRNvj3WUMZOb+7yxaljdC5cnMwwwExOD/pouxtkROF/dxRnnkuBMTp2VobHGWU+j52sS2cJkNcTuW4wnViMyPO+BuffMRCT5A09y1s/wEDyZdQ/hhJxrayJgT9aH59O4J6egiTT0sR/HI/bKxV6KT8GkKx1FDRF3lHsA57tI/WeKBTU/TzA5H6MfaXgIODkwGZ7z5VsbaLbUduB8qXOG4w315YyxEO8CTxc40tAKwznHXIG9J11pK6qL0rHBE6sBqJcCEMmKB14yEWYanhkCUHuZmIPRLpZRR+BPbh38C6971SqRRpOzDuFsPMFwC+tMDeXkXx/dCZBwvtH862bi+rQwrhzyfSdTwfmpaX8NUmUxVRZSZTFVFuuCJD+xGgZYHaPxnKmMjmgUc/lNX1hkR9bVwDk6EM+6/nTjLaqrGZ4G55nqTkB3WXRbqMsIr62J9eGfAE93MoAVQ31J9+zgOZA/G1pzYKrU9pdFuiyky0KqLKTLQl2QDqu+9bpXGH1jTIeZxkR+Qxe60VSsi4/1GYMnw3Nlk/G6Vyr1Vd2xNB8b9RmRIxr6RFFH5/nYm1gfdS9gAtS+rDBNThLqhI2uv9JIzoQ1eWANgfyss6C+KeOSKrVSpWaq2EwVm/VW59D75yy0BSWnpZk3MD84nueUgLdTeTM074ehebLOF5iP6VfJYDKeJ78VRBPJmZ8aD79ZZDA8kOZtoo5L/gBPT3d0VoyJ9aFOkrX+wOTht5gf+DKgnprmLHi6WMA3jsxPnafxk+NG9q9ksZksNuqt9uvvnbEQ75aVuDg0pwQEm4gnYXVRfla/ATz5WVPimc/4AZpIzSmQ6OaHr5sx4+HTgYPhoTUjkhNgZaMmsdDWEOhrdH0so5cHsCxAQtbMTWNo/TXXm4VYeeqsyLOG3yD46nopyC6WKjZTxUa91X7tXZMuRr10gHhWciqsLuoRNT9Q58PTrjsTntlSp0EOysoJj2LlvnT2MD8QDAMk16wAeSKsn8m+ujM3tNrUU9ZMj3/BOWdo4VhMckn5D4EVg2cItHCuMKtxz0jLO8pSf0f52rtnyYnCJ0YGaADidfvCXajdWTmBjsohPB/Od4K8MuAM1FPQzU8esnoZvapY+U0Ew6dmVWGhrRt8akC8bi8TYTxTIl8ytCD8L1m4LY+8pIEVJt8deM78Swefy7ikSy1ZqVKrLnRee++cMip1CSyq0yMP9ySehNVFdzjOjjxT4nwb9uQNhseiXoXjDAonsRLAwfDQ1CRwdzh4/NUwtD6a95e6OMA1wP9eG73e+F+FT0c3iTpynIt8L1F+R5kqC3VBevW9zzRja86ZekEDlzgcTw5BoonUHZRnPrppgUWAsbKvYP5G3QUx1JGVjZUHPoSTA4e6b5YSD68hMAGemfOvNnUawFWn6WjovRh/kvyvslaMcwjynTK37HtJqiykSkMX++N759UDv9yx9wN79Yky1GjuE8IzK55s/C6mO3NDpqbxMnhoOCdgNGOuNs/czL2kG2PCHeAu5HnpDgE42jjzHJdESUiUhGRJSJTEuiD93Tvn4YvgQEG+PSz4g6mj6ELOhyeeehbU0eGzBvqyWqhrAnRXd6SeL6s7NQkrP2v94VGAIeD5GB3LwnExcCbkOV/qOgOLxsrGc/3onvhYxItCvCjEimKsKFZb0r89vvffej2Y8H9gXu4bzPfJ4T80ndbEBPZwCCD45Z2IuVS6Rmk6WN0OLDLV1PgHMjTJvSFSECIFIZIXIgWx2pL+9dHPgIH3ZDYv/ZQQBDlQuJINV7LhTDaciWa+1v6bQ/2/HkItZamNAEatUPOPAAtNFxiONUAQZD/zf+bS/3su9b/mUv/TmtqO1//61dMWvQ2zIWswWl7CQ5PdDR0iCDKBfHktcP6q/7Mr/s+u+GfdpX/2ymmqEZh2B6qLwbUV2RFdDEEQJmcu+U5d8n76F+/Jv3ifOkt/9cf+X9U1tFPj38Txl2aKe2oyo4shCDLCmcu+M5d8p/6f7+Q/eZ+6in/1x9PUMMAdNM5FNTJqhUUeAkMAM+F3WwRBJpDPrgTOXfGfueQ7dcn31FX6538ay8VY3qEpo6jmounL72L8hwiCTCBfXA2evxr4/Erg3OXArLv816+ekdv5axzlkFUBaSzMwleCcZZX6GIIctD5+kboy+uhL66Hvrgesnoq/+L14Tct1GGw76h9StdodLPBMehiCIKMcGEq/PVU+Kup8Fc3wnOeivr7YuowXRfTVGTqdjIeSKhxMbIKIycGo3P+CILsdy5ORy5ORy5MRb6eCs97Kn9ziPJkHtggqIdK/vFdDO5o6BBBkAnkm5uRi9ORr6fCGhdTQy1qANsCXAw2OMtoCUaNRxdDEGSEi9ORC9PhC9PKjlLrYqzSiXQuTVFGhpG9yPlo/IvMjC6GIMgI396MfHMzfGE6fGEqPOcdcTG1JQEbPRjYtuASb/yE6GIIMvl8fyv65x8i3/0Q+e6HyIKv+i8Pn9MtqQxZgyFXgttZe0xgOHQxBJl8/tOPif94L/4f7sX//Z34sr/2r47Sny82ph3A3XlqNLJdd0poYQhyIPgvjzN//yjz948y//nn9PNw498c7z+xmnXTavwR0VwQBNlL/pu18F+thX+YLfzDbH4z1vzbd7+S260ErEYAo1aoKbVYaLrAcKwBgiD7mb/Yyv9kK//f5fI/LpWcSeGVD762MG5mURt14d8tAqMAG0lDhwiCTCBTG7Xr9tr19er19aonIx766CLVCEy7A9XF4NqK7IguhiAIk9tb9VuO2i1H7QdHzZcTj35yUW43sVPjsQz+0kxxT82g6GIIgoxwb7t6b6t6Z6tyx1Hx58Q3PrlADdN1B5a1aeL5XYa/FjPqtgiCTBT3HMW7m8U7m4U7GwV/tvXGx19RwwD34bEMTRnFKuXUSfhdjP8QQZAJ5M569vZ69tZa5tZaxp9pHP3oC7ndaI0DuJiV2AlyVm08Q6OLIchB5+ZKYnolMW2LT9vi3lTtyIn+t16N2oGui3Fmg+s13YmhiyHIgWNqKXpjKXxjMXxjMexJVg59MHwyjzrMhIsBVRuQUONiZBXGGoWncEMQZAK5thC6thC6vhC6vhDyJCqH3jf8fDF1PJl/fBeDOxo6RBBkArk2P3CxxZAnOXQxNUBJBcdQw1gvqRuplRe6GIIgFK4vhm4shaeWItNLUW+yeviE9n+Ds0onddEE12isQ5aLqUckM6OLIQgywtRybNoWv2lL3lxJ+dKNox9+obyktiRgowcD2xZsjuMnRBdDkMnnh9X0reeZ2+u5O/Z8INt88+OvdEsqQ9ZgyJXgdtYeExgOXQxBJp+79tzdzcI9R+m+oxzMicdOcn133yhwd54ajWzXnRJaGIIcCO47yve3qz/t1B44G+FC+61T38jtrJtW44+I5oIgyF7yk7P+wNV46G7+7G6Fi9Jbp7+V260ErEYAo1aoKbVYaLrAcKwBgiD7mYeupmxhP+8K4aL09ulvLYybWdRGXfh3i8AowEbS0CGCIBPIQ3dTUbjQeevUt1QjMO0OVBeDayuyI7oYgiBMHroaD5z1B876Tzv1UL59/FMzzxfj38Hxl2aKe2qSo4shCDLCT9vV+9uV+1vlHx2lYE7g/B2lpjhSF1BU46BWWOQhMAQwE363RRBkArm3Wby7kb+zkbu9nvNnmqafL0b+TMazvEzdlxoDuxj/IYIgE8jttcwPz9M3V1PTtqQ3VTv64fAvuZmocagvWYmdIE8Jxjk0uhiCHHSmbfGp5diNxei1hbAnUTn8wWdyuwk7gAsxzmxwvaY7MXQxBDlwXF8IX50PXbEGrlgDu/Hy6++dlduN2gG1SuIszagDKWGaKow1Ck/hhiDIBHLFGrg86788678043XHSq+9e0Zu13UH6+gOkbN0shh3MbijoUMEQSaQy7P+SzP+SzO+S8+8rljxtXdPkzFASaV5lYwEDqkWY1WVYNR4dDEEQUaQa7FLs/7LMz53rES6GKt00lFpeqcAAAYMSURBVDgXaxNnwsXUI5KZ0cUQBBnh2kL42nzo6lzwijXgjpWU+2IWoshS/8DvDrBtweY4fkJ0MQSZfKZtianl+I2l2I3FqCdRPfT+Od2SypA1GHIluJ21xwSGQxdDkMnn9nr21lr21vPMD6tpX6p+5MR5atiYdgB356nRyHbdKaGFIciB4J6jdG+zeHejeHej4M803/joS7mdddNq/BHRXBAE2UseOBsPnPWfdmo/7VSD+eGzXq0ErEYAo1aoKbVYaLrAcKwBgiD7mUce4dGu8PNu62d3K1zoyM+0sNJuZlEbdeHfLQKjABtJQ4cIgkwgj73iY6/42CM+8ojhooTPF0MQZJ/RdzFv38XeZj+xGrYezh0cf2mmuKcmOboYgiAjPPKIyqYyXOgoz93XALiD2rxYRkatsMhDYAhgJvxuiyDIBPLQ1Xzoasj3+NXPetXA6T6wi7G8TN2XGgO7mIl5IggyOfy4VfnRUb7nKN3bLAWyAvA7Sp4ah/qSldgJ8pRgnEOjiyHIQef2eu72evb2WvbWWhb4vpiuHQDuxvI1Vh44Bl0MQZARbq4kp22JqeXE1HLcm6wp3903ZweaLSFnaUYdSAnTVGHkxGB4po0gyD7mxmL0+kLk2nz46lxoN1459P45uV3XHVhll679GXUxuKOhQwRBJpCrgwdaXJ71u2OlQ6pnWigAJZWFVn9Rw8hDlg+q86CLIQiig2Jh8vPFXidcjFU6afyFVaCZcDH1iGT1hy6GIMgIV+dDV+dCV+aCV6yB3Vj5ED5fDEGQ/cWNpeh1+dbYQtiTqODzxRAE2WfcXEndXElOrySnbQlvqobPF0MQZJ9xez3X/8rYOvR9MaDRKGguCILsJT9ulX909BXICcdOfi23WwlYjQBGrVBTarHQdIHhWAMEQfYzD12NBwOFCu3jn35jYdzMojbqwr9bBEYBNpKGDhEEmUAeeQRF4aL09unvqEZg2h2oLgbXVmRHdDEEQZg89ojKI8YiJent09/J7eZ2arqbOP7STHFPzaDoYgiCjPDYIypGFilJb5/5jhrG4w6AwVErLFYe8iW4FjPhtgiCTA7kjpIapus+sHFoyigeE+R3MUPzRBBk0niguruvftaroRpHaaG6mJXYCfKUYPxD8x8iCDKByN+xuOco33OUgzlRedYrvx1oCiiWi/Fng2PQxRAEGeHWWlaRP9N885Ph98XUYbouRpZL1NLJQivNqANpkqjT6o7OKtwQBJlApmyJKVtiypacsiW9qcYbH38lt+u6A9UgyPbxXQzuaOgQQZAJ5NpC+NpC5NpC5Ppi1JOsHf3oCzIGKKl0I4FDVgZ1HnQxBEF0uGINXJkLXp0LXZ0Pe5LVIx9qXYxVOlFbyDLNhIupRySrP3QxBEFGuGINXLEGr8yFrs6FNC6m9iNgowcD2xbQorvl5EmILoYgk8+VudDV+f6mUt5RkvWUhft7EiSGXAluZ+0xgeHQxRBk8rm+FLu+FL+xHL+xnPCm6m989BU1bEw7gLvz1Ghku+6U0MIQ5EBwcyV1czV9czX9w/OM+psWCIIg+4M7G4U7G4W7G8W7G8VAVjh28uJvPSMEQRAj3N+u3t+u3d+p3d+phfLt46e++a1nhCAIYoSH7paicIH5v8ERBEF+pzz2th952o884iOPGC4yn8yDIAjyO+UXX+cXX+exr/PY14mUuuhiCILsM4Yu5u2on/WKIAiyP3js7W8n+zvKwfPFEARB9gf9W/uu1kNXK1To4O8oEQTZZ/y4Xftxu/rjdvX+djWYE4+dvPBbzwhBEMQId+x5Req/DY4gCLI/mF5J9mVLelP1Ix+e/61nhCAIYoRrC1FFnkT18AefWRn81jNFEAShcdkavNJXaDdeOfT+OXQxBEH2E5dn/ZdnA5dnA5dng+54+dB76GIIguwrLs8GL2MthiDI/uXqfOTaQuTaQvTaYtSTrB4+8flvPSMEQRAjTC0np2zJaVty2pbypupHib8egiAI8rvm1lru1lru1lr+1nren2m++TH9idUIgiC/U+5ulu9ulu86yvcc5UAOn/WKIMg+4/8DhvRRfg97TuIAAAAASUVORK5CYII=" alt="" /> /// <summary>
/// 1.yield return将单次运算结果放入IEnumerable集合中
/// 2.yield break中断当前迭代器的作用域
/// </summary>
/// <param name="length"></param>
/// <returns></returns>
public static IEnumerable<string> GetStrings(int length = )
{
for (int i = ; i < length; i++)
{
if (i < )
{
yield return string.Format("第{0}次调用", i);
}
else
{
yield break;
}
}
Console.WriteLine("yield break之后在迭代作用域内的代码不会再被执行");
}

补充:上面GetStrings传统上很多人习惯如下写法,但是这样做的时间开销是n*m,其中n为待运算列表长度,m为第一次遍历长度,这就是为什么上面强调用到的时候才会进行真正的处理

 public static List<string> GetStrings(int length = )
{
var result = new List<string>();
for (int i = ; i < length; i++)
{
if (i < )
{
result.Add(string.Format("第{0}次调用", i));
}
}
return result;
}

最新文章

  1. 总结的JS数据类型判定(非常全面)
  2. mysql 几个命令
  3. SUID ,SGID ,Sticky
  4. Android5.0之NavigationView的使用
  5. Angular Textarea 高度自动变化
  6. RabbitMQ中文入门教程
  7. shell 脚本阅读之二——ltp工具下的runltp
  8. 循序渐进之Spring AOP(4) - Introduction
  9. Npm vs Yarn 之备忘大全
  10. 【iOS】Core Bluetooth
  11. 初识JAVA——流程控制之if语句
  12. jmeter分布式压测(多台电脑一起压测)
  13. mysql数据库数据的 备份以及还原
  14. .Net开发工程师工具箱
  15. 关于宽带接两台路由,并且第二台需要关闭DHCP的设置
  16. 【Canal源码分析】数据传输协议
  17. 基数估算HyperLogLog
  18. 5 -- Hibernate的基本用法 --2 Hibernate入门
  19. 使用SSH命令从一台Linux远程登陆到另一台Linux
  20. vue移动端项目vw适配运行项目时出现&quot;advanced&quot;报错解决办法。

热门文章

  1. LwIP学习笔记——STM32 ENC28J60移植与入门
  2. 《得知opencv》注意事项——矩阵和图像处理——cvOr,cvOrS,cvrReduce,cvRepeat,cvScale,cvSet and cvSetZero
  3. csdn 博客,你很努力,有人帮你-2015年03一个月17日本
  4. linux_后台启动多个java -jar 程序,及关闭
  5. 自动引用计数(ARC)
  6. MVC应用程序使用Web Services(asmx)
  7. C# ---- 串口数据YSI实例
  8. CSS3 选择器读解
  9. 小议 js 下字符串比较大小
  10. vim打开出现的文档^M什么