Массивы

    Итак, мас­сив - на­бор объ­ек­тов од­но­го ти­па, име­ющий чет­кую пос­ле­до­ва­тель­ность этих объ­ек­тов и стро­го за­дан­ный раз­мер, т.е. ко­ли­чес­т­во объ­ек­тов в на­бо­ре. Мас­сив мо­жет быть лю­бо­го ти­па, раз­мер мас­си­ва дол­жен быть боль­ше 0 и мень­ше чем мак­си­маль­ное зна­че­ние int (на 32 раз­ряд­ных ма­ши­нах - 2^32=4294967296).

    Декларация мас­си­ва по­доб­на дек­ла­ра­ции пе­ре­мен­ной­, с од­ним толь­ко из­ме­не­ни­ем - пос­ле ти­па дек­ла­ри­ру­емо­го мас­си­ва до­бав­ля­ют­ся квад­рат­ные скоб­ки - [].

    Пример:

    

    В строч­ке вы­ше по­ка­за­на дек­ла­ра­ция од­но­мер­но­го мас­си­ва ти­па int. Мас­сив мо­жет быть мно­го­мер­ным. При­чем в .NET мно­го­мер­ность мо­жет быть раз­ной.

    Вариант 1 - мно­го­мер­ный мас­сив ста­ро­го об­раз­ца, так на­зы­ва­емый мас­сив-мас­си­вов:

    

    Система прос­тая - каж­дая скоб­ка соз­да­ет свой мас­сив. Т.е. мож­но пред­с­та­вить это в та­ком ви­де: (int[])[] ar­ray­Na­me - мас­сив ти­па int[], ко­то­рый то­же яв­ля­ет­ся мас­си­вом. По­доб­ных вло­же­ний мо­жет быть нес­коль­ко.

    Вариант 2 - мно­го­мер­ный мас­сив .NET:

    

    

    Внутри скоб­ки ста­вит­ся нуж­ное ко­ли­чес­т­во за­пя­тых, каж­дая за­пя­тая соз­да­ет плюс од­но из­ме­ре­ние мас­си­ва. Т.е. в при­ве­ден­ной вы­ше строч­ке дек­ла­ри­ру­ет­ся таб­ли­ца (дву­мер­ный мас­сив) для це­ло­чис­лен­ных дан­ных.

    У каж­до­го ва­ри­ан­та есть свои плю­сы и свои ми­ну­сы. Ес­ли ко­рот­ко - вто­рой ва­ри­ант удоб­нее и чуть быс­т­рее ра­бо­та­ет, за­то пер­вый ва­ри­ант поз­во­ля­ет раз­де­лять мас­сив на сос­тав­ля­ющие при не­об­хо­ди­мос­ти. При­ме­ры ис­поль­зо­ва­ния мас­си­вов бу­дут по­том.

    

    Свойства

    Свойства - спе­ци­аль­ная фи­ча для воз­мож­нос­ти про­вер­ки дан­ных, вво­ди­мых в пе­ре­мен­ную и за­да­ния ка­ких-ли­бо дей­ст­вий при из­ме­не­нии зна­че­ния. Сво­его ро­да пос­ред­ник меж­ду пе­ре­мен­ной и про­чим ко­дом, а по сов­мес­ти­тель­с­т­ву - ох­ран­ник и сек­ре­тарь этой пе­ре­мен­ной :). Свой­ст­ва су­щес­т­ву­ют толь­ко внут­ри клас­са, вмес­те с пе­ре­мен­ны­ми уров­ня клас­са.

    Задаются очень прос­то:

    

    Сначала, как обыч­но, мо­ди­фи­ка­тор дос­ту­па. Клю­че­вое сло­во pro­perty ука­зы­ва­ет, что дек­ла­ри­ру­ет­ся свой­ст­во. Да­лее ука­зы­ва­ет­ся тип дан­ных, в при­ме­ре - оди­нар­ное дроб­ное. За­тем имя свой­ст­ва и от­к­ры­ва­ет­ся фи­гур­ная скоб­ка, на­чи­на­ющая блок опи­са­ния. Лю­бое свой­ст­во дол­ж­но иметь блок get - по­лу­чить. Ес­ли свой­ст­во толь­ко-для-чте­ния, оно не име­ет бло­ка set - ус­та­но­вить. В каж­дом бло­ке про­пи­сы­ва­ет­ся, что на­до сде­лать. Пом­ни­те, что свой­ст­во не хра­нит дан­ные, т.к. не яв­ля­ет­ся пе­ре­мен­ной - оно лишь пос­ред­ник, по­это­му в бло­ке get ука­за­но - вер­нуть зна­че­ние пе­ре­мен­ной _si­ze, в ко­то­рой зна­че­ние хра­нит­ся ре­аль­но. В бло­ке set на­пи­са­но, что де­лать при ус­та­нов­ке но­во­го зна­че­ния - сна­ча­ла про­ве­рить на пра­виль­ность... ну, нап­ри­мер, что­бы вво­ди­ли от 0 до 1, ког­да нуж­но и т.п. Пос­ле про­вер­ки - ус­та­но­вить зна­че­ние; клю­че­вое сло­во va­lue, в дан­ном слу­чае, ука­зы­ва­ет на вхо­дя­щее зна­че­ние. Ну и под за­на­вес - вы­пол­нить со­бы­тие "раз­мер из­ме­нил­ся". За­вер­ша­ет дек­ла­ра­цию зак­ры­ва­юща­яся фи­гур­ная скоб­ка.

    Свойства поз­во­ля­ют соз­да­вать все пе­ре­мен­ные как pri­va­te, а нуж­ные для от­к­ры­то­го дос­ту­па вы­во­дить че­рез свой­ст­ва, имея та­ким об­ра­зом га­ран­тию, что лю­бое внеш­нее из­ме­не­ние зна­че­ния бу­дет про­ве­ре­но на пра­виль­ность.

    

    Делегаты

    Делегаты - ес­ли прос­то, то это ука­за­те­ли на фун­к­ции. Ес­ли вам на­до пе­ре­дать фун­к­цию как ар­гу­мент, то у вас два пу­ти - ли­бо че­рез стро­ко­вое наз­ва­ние фун­к­ции ис­кать ее в биб­ли­оте­ке (assembly) и вы­зы­вать как внеш­нюю фун­к­цию, ли­бо ис­поль­зо­вать де­ле­гат. Де­ле­гат поз­во­ля­ет оп­ре­де­лить под­пись фун­к­ции - т.е. воз­в­ра­ща­емый тип, ти­пы и ко­ли­чес­т­во ар­гу­мен­тов.

    Делегат - это объ­ект уров­ня клас­са, соб­с­т­вен­но это и есть класс, толь­ко очень осо­бый. Од­на­ко дек­ла­ра­ция его очень по­хо­жа на дек­ла­ра­цию аб­с­т­рак­т­ной фун­к­ции:

    

    Не за­бы­вай­те, что де­ле­гат - это класс, и для то­го, что­бы его мож­но бы­ло ис­поль­зо­вать, не­об­хо­ди­мо соз­дать объ­ект де­ле­га­та, ко­то­рый при­пи­сы­ва­ет­ся к кон­к­рет­ной фун­к­ции и даль­ше пе­ре­да­ет­ся, ес­ли ну­жен. У де­ле­га­та есть ме­тод In­vo­ke, ко­то­рый соб­с­т­вен­но и за­пус­ка­ет фун­к­цию, на ко­то­рую де­ле­гат ука­зы­ва­ет.

    Пример ис­поль­зо­ва­ния де­ле­га­та внут­ри фун­к­ции:

    

    В при­ме­ре пред­по­ла­га­ет­ся, что d1 и d2 - пе­ре­мен­ные ти­па do­ub­le, a фун­к­ция MyFun­c­ti­on име­ет под­пись: do­ub­le MyFun­c­ti­on(do­ub­le d1, do­ub­le d2).

    

    Assembly

    Кратко: As­sembly = сбор­ка, файл, яв­ля­ющий­ся кон­тей­не­ром для na­mes­pa­ce/клас­сов/кон­с­тант/де­ле­га­тов/интер­фей­сов и ре­сур­сов (кар­ти­нок/тек­с­та/ико­нок и пр.). As­sembly мо­жет быть за­пус­к­ным (exe) или не за­пус­к­ным (dll). От­ли­чие толь­ко в том, что в за­пус­к­ном фай­ле про­пи­сан ме­тод Win­Ma­in (или ma­in для кон­соль­ных при­ло­же­ний­). Нес­мот­ря на рас­ши­ре­ния фай­ла, ни­че­го об­ще­го (кро­ме поль­зо­ва­тель­с­ко­го при­ме­не­ния) со ста­ры­ми (до .NET) фай­ла­ми не име­ет. Ос­нов­ные два от­ли­чия от win32 стан­дар­тов - as­sembly име­ет соб­с­т­вен­ное опи­са­ние внут­ри се­бя. Опи­са­ние вклю­ча­ет: вер­сию, ав­то­ра, па­ра­мет­ры бе­зо­пас­нос­ти не­об­хо­ди­мые для вы­пол­не­ния и мно­гое дру­гое, в час­т­нос­ти - опи­са­ние под­пи­сей всех фун­к­ций­, пе­ре­мен­ных и т.д. Т.е. не на­до знать за­ра­нее как вы­зы­вать ту или иную фун­к­цию из биб­ли­оте­ки - это мож­но уз­нать на ле­ту. Вто­рое от­ли­чие - as­sembly хра­нит код не в ви­де ас­сем­б­ле­ра, а в MSIL - Mic­ro­soft In­ter­me­di­ate Lan­gu­age - сво­е­об­раз­ный ме­та-язык, ко­то­рый ком­пи­ли­ру­ет­ся на ле­ту и по зап­ро­су (just-in-ti­me com­pi­ling and de­bug­ging) в со­от­вет­с­т­вии с тре­бо­ва­ни­ями сис­те­мы на ко­то­рой ком­пи­ли­ру­ет­ся (раз­ряд­ность про­цес­со­ра и т.д.). Плю­сы та­ко­го под­хо­да - кросс-плат­фор­мен­ность и кросс-сис­тем­ность, а так­же бе­зо­пас­ность вы­пол­не­ния. Ми­ну­сы - код всег­да от­к­рыт и дос­ту­пен лю­бо­му для проч­те­ния, а так­же ухо­дит вре­мя и ре­сур­сы на ком­пи­ля­цию. Впро­чем, кни­ги и му­зы­ку то­же мо­жет лю­бой про­чи­тать/услы­шать... и по­че­му-то ав­то­ров это не нап­ря­га­ет, а пла­ги­ато­ров не так уж мно­го...

    Assembly мо­жет быть од­но­мо­дуль­ным и мно­го­мо­дуль­ным. Мо­дуль - часть as­sembly, как пра­ви­ло, до сбор­ки пред­с­тав­ля­ющая со­бой от­дель­ный файл. Т.е. нес­коль­ко биб­ли­отек клас­сов мож­но объ­еди­нить в од­ну as­sembly, и до­ба­вить еще кар­тин­ки до ку­чи. Каж­дая кар­тин­ка и каж­дая биб­ли­оте­ка бу­дут от­дель­ным мо­ду­лем внут­ри еди­ной as­sembly. Плю­сов в та­ком под­хо­де ма­ло­ва­то, по­это­му ред­ко ис­поль­зу­ет­ся. MS Vi­su­al Stu­dio да­же не име­ет воз­мож­нос­ти соз­да­вать муль­ти­мо­дуль­ные as­sembly в ин­тер­фей­сном ре­жи­ме.

    Лично я от­но­шусь к as­sembly по ста­ро­му - как к exe и dll win32 стан­дар­та. Един­с­т­вен­ное, о чем при­хо­дит­ся пом­нить - as­sembly дол­ж­ны иметь иден­ти­фи­ка­то­ры, ес­ли ими со­би­ра­етесь поль­зо­вать­ся не вы один. Т.е. вер­сия, ав­тор и раз­ре­ше­ния бе­зо­пас­нос­ти дол­ж­ны быть про­пи­са­ны. Да и под­пи­сать as­sembly клю­чом strong na­me то­же нуж­но. Ключ strong na­me - уни­каль­ный иден­ти­фи­ка­тор as­sembly, ко­то­рый ис­поль­зу­ет­ся для рас­поз­на­ва­ния раз­ных as­sembly с од­ним име­нем на од­ной ма­ши­не. Для под­пи­сы­ва­ния есть кон­соль­ная ути­ли­та sn.exe, а в VS2005 есть и ин­тер­фей­сные оп­ции в свой­ст­вах про­ек­та для этой це­ли.

    Если кто-то хо­чет ра­зоб­рать­ся под­роб­нее - есть неп­ло­хая статья (ку­сок кни­ги) на co­dep­ro­j­ect: лежит здесь - http://www.codeproject.com/books/1893115593_6.asp.

    

    

    Рассмотрев син­так­сис дек­ла­ра­ций­, пе­ре­хо­дим к ос­нов­ным кон­с­т­рук­там или ко­ман­дам язы­ка. Как из­вес­т­но, код внут­ри фун­к­ции вы­пол­ня­ет­ся пос­т­роч­но, ес­ли не ис­поль­зу­ют­ся ка­кие-ли­бо ко­ман­ды. Дру­ги­ми сло­ва­ми - ко­ман­ды язы­ка приз­ва­ны обес­пе­чить не­ли­ней­ность вы­пол­не­ния ко­да. Са­мая из­вес­т­ная из не-ли­ней­ных ко­манд - go­to - есть в язы­ке C#, од­на­ко я нас­то­ятель­но не ре­ко­мен­дую ей поль­зо­вать­ся. Ос­таль­ных ко­манд впол­не дос­та­точ­но, что­бы обес­пе­чить лю­бую не­ли­ней­ность, а при­вы­кать к go­to - это как пра­ви­ло оз­на­ча­ет при­выч­ку к пло­хой струк­ту­ри­за­ции ко­да.

    Но сна­ча­ла, что­бы бы­ло про­ще по­ни­мать ко­ман­ды, рас­смот­рим не­ко­то­рые опе­ра­то­ры язы­ка.

    

    Операторы

    Операторы срав­не­ния:

    ‹ - стро­го мень­ше. Оп­ре­де­лен для лю­бых чис­ло­вых ти­пов (int, do­ub­le, short, byte, de­ci­mal, flo­at, bo­ol)

    › - стро­го боль­ше. Ана­ло­гич­но пре­ды­ду­ще­му.

    ‹= - мень­ше или рав­но. Ана­ло­гич­но пре­ды­ду­ще­му.

    ›= - боль­ше или рав­но. Ана­ло­гич­но пре­ды­ду­ще­му.)

    == - рав­но (экви­ва­лен­т­но). Оп­ре­де­лен для боль­шин­с­т­ва ти­пов и клас­сов. Для мно­гих клас­сов оз­на­ча­ет имен­но иден­тич­ность объ­ек­тов клас­са, а не ра­вен­с­т­во их внут­рен­них зна­че­ний.

    != - не рав­но. Ана­ло­гич­но пре­ды­ду­ще­му.

    Обратите вни­ма­ние: про­вер­ка на ра­вен­с­т­во обоз­на­ча­ет­ся дву­мя зна­ка­ми рав­но! Од­ним зна­ком обоз­на­ча­ет­ся опе­ра­тор прис­во­ения зна­че­ния.

    

    Логические опе­ра­то­ры:

    || - ло­ги­чес­кое ИЛИ.

    && - логическое И.

    ! - ло­ги­чес­кое НЕ.

    

    Арифметические опе­ра­то­ры:

    помимо стан­дар­т­ных +, -, *, / есть их мо­ди­фи­ка­ции со зна­ком рав­но: +=, -=, *=, /=. Оз­на­ча­ют "вы­пол­нить опе­ра­тор и при­рав­нять", т.е.

    

    означает при­ба­вить 10 к зна­че­нию пе­ре­мен­ной i, и за­пи­сать ре­зуль­тат в нее же. Это ана­ло­гич­но за­пи­си:

    

    есть еще два опе­ра­то­ра:

    ++ - при­ба­вить еди­ни­цу к пе­ре­мен­ной и за­пи­сать ре­зуль­тат в нее. Ин­к­ре­мен­т­ный опе­ра­тор.

    -- - от­нять еди­ни­цу от зна­че­ния пе­ре­мен­ной и за­пи­сать ре­зуль­тат в нее. Дек­ре­мен­т­ный опе­ра­тор.

    

    

    Основные кон­с­т­рук­ты мож­но раз­де­лить на цик­ло­вые - поз­во­ля­ющие за­пус­кать ку­сок ко­да в цик­ле, и ус­лов­ные - поз­во­ля­ющие вы­пол­нять нуж­ный ку­сок ко­да, вы­би­ра­емый по ус­ло­вию. Я опи­шу ос­нов­ные кон­с­т­рук­ты, ес­ли ка­кой за­бу­ду, а вам он ин­те­ре­сен - пи­ши­те.

    

    Циклы

    Самый рас­п­рос­т­ра­нен­ный цикл - for. Смыс­ло­вое пред­наз­на­че­ние - вы­пол­нять пос­ле­до­ва­тель­ность дей­ст­вий за­дан­ное ко­ли­чес­т­во раз. За­да­ет­ся сле­ду­ющим об­ра­зом:

    

    После клю­че­во­го сло­ва for сле­ду­ет круг­лая скоб­ка, внут­ри кто­рой обя­за­тель­но при­сут­с­т­ву­ют три вы­ра­же­ния, раз­де­лен­ные точ­кой с за­пя­той. Пер­вое вы­ра­же­ние, в на­шем слу­чае "i=0" - опе­ра­ция, ко­то­рую на­до вы­пол­нить пе­ред на­ча­лом цик­ла. За­час­тую в этом мес­те пи­шут дек­ла­ра­цию пе­ре­мен­ной­, ко­то­рая су­щес­т­ву­ет толь­ко для цик­ла, тог­да вы­ра­же­ние выг­ля­дит, нап­ри­мер так: "int i = 0". С тем же ус­пе­хом по­ле мо­жет быть пус­тым. Вто­рое вы­ра­же­ние ус­та­нав­ли­ва­ет ус­ло­вие, при ко­то­ром цикл дол­жен про­дол­жать­ся... его мож­но рас­смат­ри­вать как "Про­дол­жать цикл по­ка вы­ра­же­ние 2 ис­тин­но". Мо­жет быть пус­тым, но тог­да вам са­мим при­дет­ся внут­ри цик­ла про­ве­рять ус­ло­вие вы­хо­да и са­мим же вы­хо­дить из цик­ла. Третье вы­ра­же­ние за­да­ет опе­ра­цию, ко­то­рую на­до вы­пол­нить по за­вер­ше­нии каж­до­го кру­га цик­ла. То­же мо­жет быть пус­тым.

    Итак в строч­ке при­ме­ра по­ка­зан цикл, об­ну­ля­ющий пе­ре­мен­ную i вна­ча­ле, ис­пол­ня­ющий­ся по­ка пе­ре­мен­ная i мень­ше 10, пос­ле каж­до­го кру­га уве­ли­чи­ва­ющий i на 1, что да­ет 10 вы­пол­не­ний цик­ла, при нор­маль­ных ус­ло­ви­ях.

    Для до­пол­ни­тель­но­го уп­рав­ле­ния вы­пол­не­ни­ем цик­ла пре­дус­мот­ре­ны еще два клю­че­вых сло­ва: con­ti­nue - за­вер­ша­ет те­ку­щий круг вы­пол­не­ния, bre­ak - за­вер­ша­ет цикл.

    

    

    Цикл whi­le (быв­ший do...whi­le). Смыс­ло­вое пред­наз­на­че­ние - вы­пол­нять пос­ле­до­ва­тель­ность дей­ст­вий­, по­ка что-то не слу­чит­ся/изме­нит­ся.

    задается так:

    

    После клю­че­во­го сло­ва whi­le сле­ду­ет круг­лая скоб­ка, в ко­то­рой за­да­ет­ся ло­ги­чес­кое вы­ра­же­ние, про­ве­ря­емое на ис­тин­ность каж­дый круг цик­ла. Цикл вы­пол­ня­ет­ся по­ка вы­ра­же­ние ис­тин­но, или до клю­че­во­го сло­ва bre­ak, внут­ри цик­ла. Сло­во con­ti­nue при­ме­ни­мо к это­му цик­лу так же, как и к пре­ды­ду­ще­му.

    

    Цикл fo­re­ach. Смыс­ло­вое пред­наз­на­че­ние - вы­пол­нить ку­сок ко­да для каж­до­го чле­на мас­си­ва/спис­ка/кол­лек­ции. В .NET по­яви­лись клас­сы обес­пе­чи­ва­ющие не­ну­ме­ро­ван­ные, ди­на­ми­чес­кие мас­си­вы. В ос­нов­ном для них и был сде­лан этот опе­ра­тор.

    задается так:

    

    После клю­че­во­го сло­ва fo­re­ach сле­ду­ет круг­лая скоб­ка в ко­то­рой за­да­ет­ся класс оди­ноч­но­го объ­ек­та, над ко­то­рым вы­пол­ня­ет­ся опе­ра­ция в ос­нов­ном бло­ке, имя объ­ек­та (пе­ре­мен­ной­) для об­ра­ще­ния в ос­нов­ном бло­ке, за­тем клю­че­вое сло­во in и имя пе­ре­мен­ной­, ука­зы­ва­ющее на мас­сив/спи­сок/кол­лек­цию объ­ек­тов то­го клас­са, ко­то­рый ука­за­ли в на­ча­ле ус­ло­вия. Ос­нов­ной код, как обыч­но, пи­шет­ся в фи­гур­ных скоб­ках.

    Ну, нап­ри­мер, час­то встре­ча­ет­ся - цикл по всем фай­лам ка­ко­го-ли­бо ти­па в ка­та­ло­ге:

    

    

    Условия

    Условие if...else. Смыс­ло­вое пред­наз­на­че­ние - вы­пол­нить блок ко­да, толь­ко ес­ли ус­ло­вие ис­тин­но... с ва­ри­ан­том - ес­ли лож­но - вы­пол­нить дру­гой ку­сок ко­да.

    задается так:

    

    После клю­че­во­го сло­ва if сле­ду­ет ло­ги­чес­кое ус­ло­вие в круг­лых скоб­ках, при ис­тин­нос­ти ко­то­ро­го вы­пол­ня­ет­ся код, рас­по­ло­жен­ный в фи­гур­ных скоб­ках. Ес­ли ус­ло­вие лож­но - вы­пол­ня­ет­ся сле­ду­ющий блок. Сле­ду­ющий блок дол­жен на­чи­нать­ся с клю­че­во­го сло­ва el­se, за ко­то­рым мо­жет сле­до­вать сло­во if и еще од­но ус­ло­вие. Та­кая це­поч­ка мо­жет быть длин­ной­, но на­до пом­нить, что пос­ле вы­пол­не­ния хо­тя бы од­но­го бло­ка це­поч­ка пре­ры­ва­ет­ся.

    Пример:

    

    В этом при­мер бу­дет вы­пол­не­на толь­ко фун­к­ция Do­So­met­hing2(). В пер­вом ус­ло­вии мы про­ве­ря­ем оба фла­га на ис­тин­ность, ес­ли хо­тя бы один не ра­вен ис­тин­но, пе­ре­хо­дим на вто­рой блок. Вто­рой блок то­же с ус­ло­ви­ем - про­ве­ря­ем пер­вый флаг на ис­тин­ность - мы точ­но зна­ем, что хо­тя бы один флаг ло­жен, ес­ли пер­вый ис­тин­нен - вто­рой ло­жен. Тре­тий блок - ес­ли пер­вый не ис­тин­нен, то ли­бо вто­рой ис­тин­нен, ли­бо оба лож­ны, но воз­мож­но нам это уже не важ­но...

    

    Пример 2:

    

    В этом, край­не нег­ра­мот­ном при­ме­ре, то­же бу­дет вы­пол­не­на толь­ко фун­к­ция Do­So­met­hing2(). А гра­мот­но та­кую си­ту­ацию рас­пи­сы­вать че­рез опе­ра­тор switch;

    

    Условие swit­ch...ca­se. Смыс­ло­вое пред­наз­на­че­ние - вы­пол­нять кус­ки ко­да по зна­че­нию пе­ре­мен­ной. Сво­е­об­раз­ная раз­вил­ка (или пе­рек­лю­ча­тель). С до­пол­ни­тель­ным воз­мож­нос­тя­ми.

    задется так:

    

    После клю­че­во­го сло­ва switch сле­ду­ет имя пе­ре­мен­ной­, по чьему зна­че­нию нуж­но раз­вет­вить код. В фи­гур­ных скоб­ках за­да­ют­ся ва­ри­ан­ты зна­че­ний­, ко­то­рые дол­ж­ны об­ра­ба­ты­вать­ся. Ва­ри­ант зна­че­ния за­да­ет­ся как клю­че­вое сло­во ca­se, зна­че­ние пе­ре­мен­ной­, дво­ето­чие. Ес­ли фун­к­ци­ональ­ный блок за­кан­чи­ва­ет­ся сло­вом bre­ak - прог­рам­ма вы­хо­дит из бло­ка switch пос­ле не­го, ес­ли не за­кан­чи­ва­ет­ся - прог­рам­ма пе­ре­хо­дит на вы­пол­не­ние сле­ду­юще­го по по­ряд­ку бло­ка ca­se. клю­че­вое сло­во de­fa­ult на мес­те ca­se оз­на­ча­ет "все ва­ри­ан­ты".

    Пример:

    

    В этом при­ме­ре бу­дут вы­пол­не­ны фун­к­ции Do­So­met­hing1() и Do­So­met­hing3().

    Переменная мо­жет быть не чис­ло­вой­:

    

    В этом при­ме­ре бу­дет вы­пол­не­на толь­ко фун­к­ция Do­Ex­c­la­ma­ti­on(), а ес­ли пе­ре­мен­ная с бу­дет рав­на не воп­ро­си­тель­но­му зна­ку и не вос­к­ли­ца­тель­но­му - ни­че­го сде­ла­но не бу­дет.

    

    По по­во­ду на­хож­де­ния ос­нов­но­го ко­да внут­ри фи­гур­ных ско­бок - ес­ли код сос­то­ит из од­ной строч­ки, мож­но пи­сать его без фи­гур­ных ско­бок:

    

    

Гла­ва 5. Ини­ци­али­за­ция пе­ре­мен­ных. Кол­лек­ции. Ти­пы дан­ных.

    int i = 0;

    double d = 0.2;

    string s = "test string"

    DateTime dt = new Da­te­Ti­me();

    MyClass mc = new MyClass();

    int[] in­tAr­ray = new int[20];

    public par­ti­al class Form1 : Form

    {

    public Da­te­Ti­me dt = new Da­te­Ti­me();

    ArrayList al = new Ar­ray­List();

    int i = 2;

    double d = 4.5;

    string s = "test";

    MyClass mc = new MyClass();

    al.Add(i);

    al.Add(d);

    al.Add(s);

    al.Add(mc);

    string s2 = (string)al[2];

    if (var is int) { do so­met­hing }

    for (int i = 0; i ‹ al.Length; i ++) {

    if (al[i] is int) { /*сде­лать что-то с це­лым чис­лом */ (int)al[i]}

    else if (al[i] is do­ub­le} { /*сде­лать что-то с дроб­ным чис­лом*/ (do­ub­le)al[i]}

    else if (al[i] is string} { /*сде­лать что-то со стро­кой­*/ (string)al[i]}

    else { Mes­sa­ge­Box.Show(al[i].ToS­t­ring()); } // по­ка­зать со­об­ще­ние со стро­ко­вым пред­с­тав­ле­ни­ем объ­ек­та

    }

    double d = 4.2;

    string s1 = d.ToS­t­ring();

    string s2 = Con­vert.ToS­t­ring(4.2);

    CheckBox cb = new Chec­k­Box();

    object obj = cb;

    ((CheckBox)obj).Checked = true;

    string s = al[2] as string;