Halimbawa 1:
Dumaan tayo sa isang C# program na nagpapakita ng paggamit ng XOR operator (^) upang matukoy ang kalusugan ng pagkain batay sa kung ito ay vegetarian o naglalaman ng karne. Ang unang linya na 'gamit ang System;' ay isang deklarasyon ng namespace na nagbibigay-daan sa programa na ma-access ang mga klase at function na tinukoy sa 'System' namespace na naglalaman ng mga pangunahing uri at pangunahing functionality ng C#. Tinutukoy ng code ang isang pampublikong klase na pinangalanang 'Dummy'.
Tinukoy ng pampublikong keyword na ang klase ay maaaring makuha mula sa ibang bahagi ng programa. Sa loob ng klase ng 'Dummy', mayroong isang static na pamamaraan na pinangalanang 'Main'. Ang 'Main' na paraan ay tumatagal ng isang hanay ng mga string (string[] args) bilang isang parameter na nagbibigay-daan sa pagpasa ng mga argumento ng command-line sa programa.
Sa loob ng 'Main' na pamamaraan, tatlong Boolean variable ang idineklara at sinisimulan: 'isVeg' ay nakatakda sa true na nagpapahiwatig kung ang pagkain ay vegetarian, 'isMeat' ay nakatakda sa false na nagpapahiwatig kung ang pagkain ay naglalaman ng karne, 'IsFit' ay ipinahayag at itinalaga kasama ang resulta ng operasyon ng XOR (isVeg ^ isMeat) na tumutukoy sa kalusugan ng pagkain batay sa pagiging vegetarian nito at nilalaman ng karne.
Ang linya ng Console.WriteLine ay naglalabas ng resulta ng pagsusuri sa kalusugan gamit ang string interpolation. Ang halaga ng 'isFit' ay ipinapakita sa loob ng string na nagpapahiwatig kung ang pagkain ay itinuturing na malusog o hindi.
gamit ang System ;
pampublikong klase Dummy {
pampubliko static walang bisa Pangunahing ( string [ ] args )
{
bool isVeg = totoo ;
bool isMeat = mali ;
bool isFit = isVeg ^ ay Karne ;
Console. WriteLine ( $ 'Masustansya ba ang pagkain? : {isFit}' ) ;
}
}
Upang buod, ipinapakita ng code na ito ang konsepto ng Boolean logic sa C# at kung paano magagamit ang XOR operator upang matukoy ang lohikal na XOR ng dalawang Boolean variable at suriin ang kalusugan ng pagkain batay sa kung ito ay vegetarian o sumasaklaw sa karne.
Halimbawa 2:
Ipakita natin ang paggamit ng XOR operator sa C# sa pamamagitan ng isa pang halimbawa ng code. Magsasagawa kami ng bitwise XOR operation sa dalawang integer variable (n1 at n2). Ang code ay nagsisimula sa 'gamit ang System;' statement na nag-i-import ng 'System' namespace upang payagan ang paggamit ng mga klase na tinukoy sa 'System' namespace gaya ng 'Console' na klase.
Tinutukoy ng code ang isang klase na pinangalanang 'Check' gamit ang syntax na 'public class check'. Ang klase na ito ay naglalaman ng isang solong pamamaraan na 'Mai'. Kinukuha ng main() function ang 'args' string array bilang isang parameter na maaaring magamit upang ipasa ang mga value ng command-line sa code program.
Sa loob ng Main() na pamamaraan, dalawang integer na variable, 'n1' at 'n2', ay idineklara at sinisimulan na may mga halagang 17 at 8, ayon sa pagkakabanggit. Ang halaga ng 'n1' ay may binary na representasyon ng 10001 na nangangahulugang ito ay katumbas ng decimal 17, at ang halaga ng 'n2' ay may binary na representasyon ng 1000 na nangangahulugan na ito ay katumbas ng decimal 8.
Ang “int Res = n1 ^ n2;” kinakalkula ng linya ang resulta ng operasyon ng XOR sa pagitan ng 'n1' at 'n2' gamit ang XOR operator (^). Ang kinalabasan ay pinananatili sa 'Res' na mutable. Ang operasyon ng XOR ay inilapat sa binary na representasyon ng 'n1' at 'n2'. Inihahambing nito ang bawat katumbas na bit ng binary na representasyon at itinatakda ang resultang bit sa 1 kung magkaiba ang mga bit at 0 kung magkapareho ang mga bit.
Sa pagsasagawa ng XOR operation, makuha namin ang binary na resulta ng 11001 na katumbas ng decimal 25. Ang Console.WriteLine($”Result: {Res}”); line print ang resulta ng XOR operation sa console. Ginagamit ang paraan ng Console.WriteLine para ipakita ang string na 'Resulta:' na sinusundan ng value ng variable na 'Res'. Ang {$”Result: {Res}”} syntax ay tinatawag na string interpolation na nagbibigay-daan sa amin na i-embed ang value ng variable na “Res” nang direkta sa string.
gamit ang System ;pampublikong klase Check {
pampubliko static walang bisa Pangunahing ( string [ ] args )
{
int n1 = 17 ; // 10001
int n2 = 8 ; // 1000
int Res = n1 ^ n2 ;
Console. WriteLine ( $ 'Resulta: {Res}' ) ;
}
}
Ang output console screen na ipinapakita sa sumusunod na larawan ay nagpapakita ng '25' na resulta na ibinubunga ng paggamit ng XOR operation sa pagitan ng 17 at 8:
Halimbawa 3:
Lumipat tayo sa huling halimbawa ng artikulong ito na tumutukoy sa paggamit ng XOR operator sa C#. Ang sumusunod na naka-attach na snippet ng code ay nagsisimula sa 'gamit ang System;' statement na nag-i-import ng 'System' namespace.
Susunod, ang isang pampublikong klase na pinangalanang 'Pagsubok' ay idineklara. Ang klase na ito ay na-cast-off bilang panimulang punto dito at sumasaklaw din sa pangunahing() na pamamaraan. Sa loob ng 'Main()' method, ginagawa namin ang XOR operation sa mga value ng character. Dalawang 'char' na variable, 'L1' at 'L2', ang idineklara at itinalaga kasama ang 'M' at 'R' na mga halaga, ayon sa pagkakabanggit.
Ang mga variable na ito ay kumakatawan sa mga character. Ang isa pang variable na 'char' na pinangalanang 'Res' ay idineklara at itinalaga kasama ang resulta ng operasyon ng XOR sa pagitan ng 'L1' at 'L2'. Ang XOR operation ay isinasagawa sa pamamagitan ng XOR operator “^”.
Dahil ang operator ng XOR ay gumagana sa mga halaga ng integer, ang (char) cast ay ginagamit upang i-convert ang nagresultang halaga ng integer pabalik sa isang character. Ang Console.WriteLine na pahayag ay na-cast-off upang i-print ang resulta. Ginagamit nito ang string interpolation (`$`) para isama ang value ng “Res” sa output.
Kapag ang programa ay naisakatuparan, ang pangunahing() na pamamaraan ay tinatawag at ang sumusunod na output ay ipinapakita sa console. Sa kasong ito, ang operasyon ng XOR sa pagitan ng 'M' at 'R' na mga character ay nagreresulta sa '?' o “.” karakter. Ang resultang character ay naka-print bilang bahagi ng output.
gamit ang System ;Pagsusulit sa pampublikong klase {
pampubliko static walang bisa Pangunahing ( string [ ] args )
{
char L1 = 'M' ;
char L2 = 'R' ;
char Res = ( char ) ( L1 ^ L2 ) ;
Console. WriteLine ( $ 'Resulta: {Res}' ) ;
}
}
Iyan ay isang detalyadong paliwanag ng dating ibinigay na code. Ipinapakita nito na ang operator ng XOR ay ginagamit upang magsagawa ng operasyong Bitwise XOR sa mga halaga ng character at i-print ang resulta tulad ng ipinapakita sa sumusunod na nakalakip na larawan:
Konklusyon
Ang operator ng C# XOR ay nagbibigay ng isang nababaluktot na tool upang isagawa ang Bitwise at lohikal na mga operasyon. Binibigyang-daan ka nitong magtrabaho kasama ang mga binary bit at ipahayag ang mga natatanging kundisyon sa Boolean logic. Gamit ang mga halimbawa ng code, tinalakay namin kung paano mailalapat ang operator ng XOR sa mga halaga ng Boolean, mga halaga ng integer, at mga halaga ng character upang makuha ang nais na output. Gamit ang XOR operator nang maayos, mapapahusay mo ang iyong mga kasanayan bilang isang C# programmer.