IEnumerable at IEnumerator

Bago kami lumipat sa pagkakaiba sa pagitan ng IEnumerable at IEnumerator, ipaalam sa amin muna maunawaan ang mga tuntunin Enumerator at Enumerable at kung kailan at bakit gamitin ang mga ito.

Ang hindi mabilang ay isang module na ginamit sa klase ng Array na nagbibigay sa iyo ng Enumerator. Ang klase mismo ay hindi bawat paraan. Sa katunayan, gumagamit ito ng isang paraan na tinatawag na 'GetEnumerator' na nagbibigay sa iyo ng isang Enumerator upang makuha ang item nito.

Ang isang Enumerator ay isang bagay na nagbabalik ng bawat item sa isang koleksyon sa isang partikular na pagkakasunud-sunod, nang eksakto kung hinihiling ang mga ito. Ang compiler ay bumubuo ng code na gumagamit ng isang Enumerator, kapag sumulat ka ng isang foreach loop sa C #.

Ang IEnumerator ay isang interface na ipinatupad ng isang enumerator at ang enumerable na klase ay nagpapatupad ng IEnumerable interface.

Ano ang Ienumerable?

Ang IEnumerable ay isang pangunahing interface na ginagamit upang makakuha ng isang bagay na alam kung paano magbilang (o umulit) sa mga elemento sa koleksyon.

Ito ay isang pagpapatupad ng pattern iterator na nagbibigay ng isang mekanismo upang traverse isang bagay sa koleksyon nang walang kinalaman sa kanyang panloob na istraktura. Ang IEnumerable na interface ay kumakatawan sa isang bagay na maaaring iterated sa isang koleksyon.

Gumagamit lamang ito ng isang paraan na "GetEnumerator" na nagbabalik ng halimbawa ng klase ng enumerator na nagpapatupad ng interface ng IEnumerator.

Ano ang Ienumerator?

Ang interface ng IEnumerator, isa sa iba pang mga kamay, ay nagpapahayag ng dalawang pamamaraan - I-reset () at MoveNext () - at isang ari-arian, Kasalukuyang. Ang MoveNext () ay nagbabalik ng isang Vale ng Boolean na nagpapahiwatig ng dulo ng listahan at tumutulong sa posisyon ang unang elemento sa listahan pagkatapos ng pagtawag sa paraan ng I-reset () - itakda ang enumerator sa default na posisyon nito upang muling i-ulit ang listahan mula sa simula.

Ang Kasalukuyang ari-arian ay maaari lamang tawagan sa pamamagitan ng isang halimbawa ng interface ng IEnumerator at ibabalik nito ang kasalukuyang elemento sa listahan.

Pagkakaiba sa pagitan ng IEnumerable at IEnumerator

Mga Pangunahing Kaalaman ng IEnumerable at Ienumerator

Parehong IEnumerable at IEnumerator ang mga interface na nagpapatupad ng pattern ng disenyo ng iterator ng software sa. Net Framework. Ang.Net Framework ay gumagawa ng pag-access ng mga indibidwal na elemento sa custom na koleksyon habang nagpapatupad ng mga interface ng IEnumerable at IEnumerator. Ang IEnumerable interface ay nagpapahayag lamang ng isang paraan na tinatawag na GetEnumerator na nagbabalik ng isa pang uri ng interface na tinatawag na interface ng IEnumerator para sa partikular na koleksyon. Ang IEnumerator, sa kabilang banda, ay ang batayang interface para sa lahat ng di-generic enumerators na ginagamit upang mabasa ang data sa koleksyon. Gayunpaman, ang mga enumerator ay hindi maaaring gamitin upang baguhin ang pinagbabatayan koleksyon.

Paraan

Ang IEnumerable interface ay tumutukoy lamang sa isang paraan GetEnumerator () na isang paraan ng pagkakataon na ginagamit sa maraming iba't ibang mga uri ng koleksyon. Ito ay nakakakuha ng isang IEnumerator iterator na maaaring magamit upang umulit sa lahat ng mga halaga mula sa koleksyon. Kapag sumulat ka ng isang foreach loop sa C # ang code na ito ay bumubuo ng mga tawag sa GetEnumerator na paraan upang likhain ang Enumerator na ginagamit ng loop.

Ang IEnumerator, sa kabilang banda, ay gumagamit ng dalawang paraan ng MoveNext () at I-reset () at isang Kasalukuyang Ari-arian. Ang pamamaraan ng MoveNext () ay tumatagal ng enumerator sa susunod na elemento ng koleksyon, samantalang ang hanay ng I-reset () ay nagtatakda ng enumerator sa default na posisyon nito bago ang unang elemento sa koleksyon.

Pagpapatupad

IEnumerable ay isang pangkaraniwang interface na nagbibigay ng isang abstraction para sa looping sa paglipas ng mga elemento at sa pamamagitan ng pagpapatupad ng IEnumerable interface, isang generic na klase ay mahalagang nagbibigay-daan sa pag-ulit sa pamamagitan ng IEnumerator interface. Sa paggawa nito, ang mga klase ay nagtatapos sa pagbibigay ng isang karaniwang interface upang kunin ang isang halimbawa ng isang IEnumerator bagay na sumusuporta sa lahat ng mga pangunahing hanay ng mga pamamaraan sa pag-navigate.

Ang IEnumerator ay ang base interface para sa enumerators at ang paggamit ng IEnumerable interface ay nangangailangan na ang klase ay dapat ipatupad ang IEnumerator. Dapat na ipatupad ang parehong mga interface, kung nais mong magbigay ng suporta para sa foreach. Ang abstract class na 'AbstractEnumerator' ay nagpapatupad ng IEnumerator interface.

Pag-andar ng IEnumerable at IEnumerator

Ang interface ng IEnumerable, kasama ang pagsuporta sa interface ng IEnumerator, ay nagbibigay-daan sa iyo upang umulit sa mga elemento sa stack gamit ang pahayag ng 'foreach'. Ito ang pangunahing interface na ginagamit para sa mga uri ng uri ng koleksyon. Ang pag-ulit ay nagsisimula sa tuktok na elemento sa stack at nagtatapos sa pinakalumang elemento sa stack. Sa madaling salita, ito ay kumakatawan sa isang bagay na maaaring isulat.

Kasama ang interface ng IEnumerator, pinagana nila ang mga elemento ng ArrayList na ma-ulit sa isang standardized, sequential fashion, na nagsisimula sa unang elemento at pasulong. Ang pahayag ng foreach ay gumagamit ng mga pamamaraan at mga katangian ng interface ng IEnumerator upang i-ulit ang lahat ng mga elemento sa isang koleksyon.

IEnumerable kumpara sa IEnumerator: Paghahambing Tsart

Buod ng IEnumerable verses IEnumerator

Sa maikling salita, ang parehong IEnumerable at IEnumerator ay mga interface na ginagamit upang magbilang o mag-ulit ng isang klase na may koleksyon kalikasan na nangangahulugan na pinadali nila ang umuulit na pag-access sa isang custom na koleksyon. IEnumerable ay ang pangkaraniwang interface na magagamit para sa mga uri ng koleksyon ng mga bagay at sa pamamagitan ng pagpapatupad ng IEnumerable interface, isang generic na klase ang mahalagang nagbibigay-daan sa pag-ulit sa pamamagitan ng IEnumerator interface. Gumagamit lamang ito ng isang paraan na GetEnumerator na nagbabalik ng halimbawa ng klase ng enumerator na nagpapatupad ng interface ng IEnumerator.Ang IEnumerator interface ay sinadya upang gamitin bilang accessors at hindi ito maaaring magamit upang baguhin ang pinagbabatayan koleksyon. Nagbibigay ito ng dalawang abstract na pamamaraan I-reset () at MoveNext (), at isang ari-arian Kasalukuyang upang tawagan ang isang partikular na elemento sa isang koleksyon.