Den här artikeln beskriver syntaxen för C# -språket . Den beskrivna syntaxen är helt kompatibel med syntaxen för C#-språket i .Net Framework och Mono .
Identifieraren är namnet på enheten i koden . Det finns en standard för namngivning av identifierare som ska användas i kod. ID kan:
En identifierare kan inte:
Nyckelord är fördefinierade reserverade identifierare som har en speciell syntaktisk betydelse. Språket har två typer av nyckelord - reserverade i valfri del av koden och kontextuella. Ord av den första typen, som false eller byte , kan bara användas som nyckelord. Ord av den andra typen, som ordet där , har en speciell betydelse endast i ett visst sammanhang och kan användas som identifierare utanför det. [MSDN 1] Om du fortfarande behöver använda nyckelordet som en identifierare måste du deklarera det med ett @-prefix, till exempel @byte . [MSDN 1]
| Nyckelord C# | |||
|---|---|---|---|
| abstrakt | som | bas | bool |
| ha sönder | byte | fall | fånga |
| röding | kontrollerade | klass | konst |
| Fortsätta | decimal- | standard | delegera |
| do | dubbel | annan | uppräkning |
| händelse | explicit | extern | falsk |
| till sist | fast | flyta | för |
| för varje | gå till | om | implicit |
| i [MSDN 2] | in (universell modifierare) [MSDN 3] | int | gränssnitt |
| inre | är | låsa | lång |
| namnutrymme | ny | null | objekt |
| operatör | ut [MSDN 4] | ut (generisk modifierare) [MSDN 5] | åsidosätta |
| params | privat | skyddad | offentlig |
| skrivskyddad | ref | lämna tillbaka | sbyte |
| sluten | kort | storlek av | stackalloc |
| statisk | sträng | struktur | växla |
| detta | kasta | Sann | Prova |
| sorts | uint | lång | okontrollerad |
| osäker | kort | använder sig av | virtuell |
| tomhet | flyktig | medan | |
| Kontextsökord C# | |||
|---|---|---|---|
| Lägg till | dynamisk | från | skaffa sig |
| global | grupp | in i | Ansluta sig |
| låta | sortera efter | partiell (typ) [MSDN 6] | partiell (metod) [MSDN 7] |
| ta bort | Välj | uppsättning | värde |
| var | var (universell begränsning
typ) [MSDN 8] |
där (frågeklausul) [MSDN 9] | avkastning |
Exempel:
sträng @ut ; //För att ge en identifierare ett namn som är identiskt med ett nyckelord, måste du använda @ -prefixet strängidentifierare ; //C# stöder Unicode och gör att identifierare kan namnges med vilken Unicode-teckensträng som helst var { get ; set ;}; //Du behöver inte använda prefixet @ här. var - kontext nyckelord public void function () { var s = "" ; //För att kompilatorn automatiskt ska bestämma typen av en variabel, används nyckelordet var }| Heltal | |
|---|---|
| Hexadecimal | 0xF5, 0x[0..9, A..F, a..f]+ |
| Decimaler | 245, [0..9]+ |
| Flyttal | |
| enda precision | 23,5F, 23,5f; 1.72E3F, 1.72E3f, 1.72e3F, 1.72e3f |
| Dubbel precision | 23,5, 23,5D, 23,5d; 1.72E3, 1.72E3D, ... |
| Datum | |
| datumet | Stöds inte |
| Symboler | |
| symbol | 'a', 'Z', '\u0231' |
| Strängar | |
| linje | "Hej världen" "C:\\Windows\\" , @"C:\Windows\" |
| Escape-tecken [1] | |
| Unicode teckenkod | \u följt av teckenkod |
| tabbtecken _ | \t |
| Plats | \b |
| vagnretur | \r |
| sidbrytning | \f |
| snedstreck | \\ |
| enda citat | \' |
| dubbelt citat | \" |
| linjeöversättning | \n |
En variabel är en identifierare som innehåller något värde. En variabel definieras av en typ och ett namn, och kan även initieras när den deklareras. Du kan bara deklarera variabler inuti funktioner.
Meddelande int variabel _ //Deklaration av en oinitierad heltalstypvariabel med namnet variabel Initiering int variabel _ //Deklaration av en oinitierad variabelvariabel = 1 ; //Variabelinitiering Deklaration och initiering int variabel = 1 ; //Samtidig deklaration och initialisering av en variabelDu kan deklarera flera variabler av samma typ samtidigt:
int a , b ; int a = 2 , b = 3 ; Implicit typ Introducerad i C# 3.0Om kompilatorn kan bestämma variabelns typ vid initiering kan den utelämnas genom att ersätta den med nyckelordet var :
var chars = new char [] { 'A' , 'O' }; //konverterad av kompilatorn till char[] chars = nytt char[] {'A', 'O'}; var nummer = ny lista < int >(); //konverterad av kompilatorn till List<int>-tal = new List<int>();se även
En konstant är en identifierare som innehåller ett värde som inte får ändras under programkörning. Konstanter är implicit statiska .
constEn lokal variabel eller egenskap med ett givet värde kan deklareras med nyckelordet const , varefter dess värde inte kan ändras.
klass Foo { const dubbel PI = 3,1415 ; Foo () { const int countOfPlanets = 9 ; } } readonlyEn egenskap som deklareras med nyckelordet skrivskyddad , som en konstant, kan inte ändras efter initiering. Men till skillnad från ett fält med nyckelordet const kan det initieras i en konstruktor.
klass Foo { skrivskyddad int a = 3 ; skrivskyddad sträng b ; skrivskyddad StringBuilder- byggare ; Foo () { b = "Sträng" ; builder = new StringBuilder (); } }Operatörer {...}används för att markera början och slutet av kodblock, samt för att indikera omfattning. En identifierare som deklareras inuti lockiga klammerparenteser är endast synlig inom dem och i kapslade omfång. Följande exempel visar hur ett kodblock och omfång fungerar:
void doSomething () { int a ; { int b ; a = 0 _ } a = 1 _ b = 1 ; //Kompilatorn kommer att kasta ett fel här, eftersom variabeln b deklareras i ett scope som inte är tillgängligt för denna kod. }Ansökningar skrivna i C# består av klasser och deras medlemmar. Klasser och andra typer deklareras i namnutrymmen, såväl som andra klasser.
namnområde FooNamespace { class Foo { class IncludedClass { } } }Namnutrymmet är en del av typnamnet. Används för att gruppera typer eller för att skilja mellan typer med samma namn men olika funktioner.
System . I.O. _ DirectoryInfo //Class DirectoryInfo i IO-namnområdet, som är kapslat i SystemnamnområdetNamnutrymmet deklareras så här:
namnområdesapplikation { //Medlemmar är män } Nyckelord usingNär du använder en klass är det inte nödvändigt att kvalificera dess namnområde om det är specificerat i .cs-filen med användningsdirektivet. Detta placeras vanligtvis överst i källfilen, men kan placeras någon annanstans, till exempel inom en klass.
använder System ; använder System.Collections ;Direktivet usingtillåter dig också att skapa namnutrymme eller skriva alias, till exempel om dess namn är för långt:
använder Net = System . netto ; använder DirInfo = System . I.O. _ DirectoryInfo ;Alla program, oavsett om det är konsol eller grafiskt, måste ha en ingångspunkt. I en C#-applikation är denna punkt metoden Main, som bara kan ha en instans och måste vara statisk. Denna metod kanske inte returnerar ett värde (sökord void):
static void Main ( sträng [] args ) { }...eller returnera ett heltal som är programavslutskoden: om programmet avslutades utan fel är denna kod 0.
static int Main ( sträng [ ] args ) { return 0 ; }| Operatörskategori | Operatörer |
|---|---|
| Aritmetisk | + - * / % |
| Boolean (boolesk och bitvis) | & | ^ ! ~ && || |
| Strängsammansättning | + |
| öka, minska | ++ -- |
| Flytta | << >> |
| Jämförelse | == != < > <= >= |
| Uppdrag | = += -= *= /= %= &= |= ^= <<= >>= |
| Tillgång till medlemmar | . |
| Indexering | [ ] |
| Kasta | ( ) |
| Villkorlig | ? : |
| Skapa ett objekt | new |
| Typ information | as is sizeof typeof |
| Överflödeskontroll | checked unchecked |
| Arbeta med pekare | * -> [] & |
Vissa operatörer kan vara överbelastade. För att överbelasta en operator måste du definiera en statisk funktion vars namn består av ett nyckelord operatoroch själva operatorn. För unära operatorer måste funktionen ha en parameter, för binära operatorer och jämförelseoperatorer två. I båda fallen måste en av parametrarna vara av samma typ som klassen eller strukturen som deklarerade den.
public static Foo operator +( Foo foo , Bar bar ) { return new Foo ( foo . Value + bar . Value ); }Lista över överbelastade operatörer:
| Operatörer | |
|---|---|
| Unära operatörer | + - ! ~ ++ -- true false |
| Binära operatorer | + - * / % & | ^ << >> |
| Jämförelseoperatörer
kan endast överbelastas i par |
== != < > <= >= |
se även
Cast-operatorn kan inte överbelastas, men du kan definiera explicit konvertering (typ casting) operatorer - explicit och implicit konvertering - implicit. De skiljer sig åt genom att implicita konverteringsoperatörer inte får göra undantag och måste se till att informationen bevaras. [MSDN 10] . För en explicit omvandling måste du använda operatorn ( ), för en implicit gör du inte det.
Implicit konverteringsoperatör
Explicit konverteringsoperatör
Operatören asär en gjuten operatör. Om en typkonvertering är möjlig kommer operatören att returnera ett objekt av den angivna typen, annars returnerar den null.
Stream stream = Fil . Öppna ( @"C:\Temp\data.dat" ); FileStream fstream = streama som FileStream ; // Kommer att returnera ett objekt. String str = ström som String ; //Kommer att misslyckas och returnera null.Om värdet på den vänstra variabeln är null, kommer värdet på den högra variabeln att returneras, annars kommer värdet på den vänstra variabeln att returneras.
Följande kod
returnera ifNotNullValue ?? annarsVärde ;likvärdig
returnera ifNotNullValue == null ? annarsValue : ifNotNullValue ;| C# | |
|---|---|
| versioner |
|
| PÅ |
|
| Relaterad | |