Dela via

Allmän struktur för ett C#-program

Tips/Råd

Är du nybörjare på att utveckla programvara? Börja med självstudierna Komma igång först. De vägleder dig genom att skriva dina första C#-program innan du lär dig mer om programstrukturen.

Har du erfarenhet av ett annat språk? Du kanske vill skumma igenom avsnittet Kom igång för C#-specifik syntax och sedan komma tillbaka hit.

Du skapar C#-program från dessa grundläggande byggstenar: namnrymder organiserar dina typer, typer (klasser, strukturer, gränssnitt, uppräkningar och delegater) definierar beteende och data, och instruktioner och uttryck utför arbete under körning. Hur du strukturerar startpunkten beror på vilket programformat du väljer.

Välja programformat

När du skapar ett C#-program gör du två oberoende val om hur du strukturerar det:

  • Filbaserad eller projektbaserad?
    • En filbaserad app körs från en enda .cs fil utan projektfil.
    • En projektbaserad app använder en .csproj fil och kan sträcka sig över flera källfiler.
  • Toppnivåinstruktioner eller Main -metod?
    • Med instruktioner på den översta nivån kan du skriva körbar kod direkt överst i en fil.
    • En Main metod omsluter startpunkten i en explicit statisk metod.

Både projektbaserade appar och filbaserade appar stöder antingen startpunktsformat.

Filbaserade appar jämfört med projektbaserade appar

Från och med C# 14 och .NET 10 kan du med filbaserade appar köra ett program som finns i en enda *.cs fil utan en projektfil. Lagra följande kod i en fil med namnet hello-world.cs och kör den med dotnet run hello-world.cs eller dotnet hello-world.cs:

#!/usr/bin/env dotnet
Console.WriteLine("Hello, World!");

Anmärkning

Linjen på #! möjliggör att Unix-skal kan köra filen direkt. I alla Unix-system anger du behörigheten kör (+x) och kör filen från kommandoraden.

Filbaserade appar stöder all C#-syntax och kan använda förprocessordirektiv för att konfigurera byggsystemet. Använd filbaserade appar för små kommandoradsverktyg, prototyper och experiment. En filbaserad app består av en enda fil i en katalog:

my-app/
└── hello-world.cs

Projektbaserade appar använder en .csproj fil och .NET CLI-kommandonadotnet new, dotnet buildoch dotnet run arbetsflödet. Välj projektbaserade appar när programmet omfattar flera filer eller behöver detaljerad byggkonfiguration. En projektbaserad app innehåller en projektfil tillsammans med en eller flera källfiler:

my-app/
├── my-app.csproj
├── Program.cs
├── Models/
│   └── Person.cs
└── Services/
    └── GreetingService.cs

Om din filbaserade app växer kan du enkelt konvertera den till en projektbaserad app. Kör dotnet project convert för att generera en projektfil från din befintliga källfil.

Om du vet att din app behöver flera källfiler från början börjar du med en projektbaserad app. Du undviker konverteringssteget och kan ordna koden i separata filer direkt.

Toppnivåinstruktioner jämfört med Main metod

Med hjälp av toppnivåinstruktioner kan du skriva körbar kod direkt i en fil utan att omsluta den i en klass och Main metod. Det här formatet är standard när du skapar en ny konsolapp med dotnet new console. I följande exempel visas ett modernt C#-program som använder toppnivåinstruktioner:

Console.WriteLine("Hello, World!");

namespace YourNamespace
{
    class YourClass
    {
    }

    struct YourStruct
    {
    }

    interface IYourInterface
    {
    }

    delegate int YourDelegate();

    enum YourEnum
    {
    }
}

Endast en fil i ett projekt kan ha toppnivåinstruktioner och startpunkten är den första raden med programtext i filen. När du skapar större program inkluderar du fler programelement.

Du kan också definiera en explicit statisk Main metod som programmets startpunkt:

// A skeleton of a C# program using an explicit Main method
namespace YourNamespace;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

Båda startpunktsformaten fungerar med filbaserade och projektbaserade appar. Båda formaten stöder samma funktioner.

Skapa och köra C#-program

C# är ett kompilerat språk. För projektbaserade appar använder du dotnet build kommandot för att kompilera källfiler till ett binärt paket. Använd dotnet run för att skapa och köra i ett steg. dotnet CLI, som ingår i .NET SDK, innehåller många verktyg för att skapa, skapa och hantera C#-projekt.

För filbaserade appar dotnet run hello-world.cs kompilerar och kör den enskilda filen direkt – ingen projektfil krävs.

Uttryck och satser

Om du har följt självstudierna Komma Igång har du redan skrivit uttryck och instruktioner. Varje kodrad som du skrev var den ena eller den andra (eller båda). Nu ska vi definiera dessa termer.

Uttryck och instruktioner är de grundläggande byggstenarna i ett C#-program. Ett uttryck genererar ett värde. En instruktion utför en åtgärd och slutar vanligtvis i ett semikolon.

Följande är uttryck:

  • 42 (literalvärde)
  • x + y (aritmetisk operation)
  • Math.Max(a, b) (metodanrop som genererar ett värde)
  • condition ? trueValue : falseValue (villkorsuttryck)
  • new Person("John") (skapa objekt)

En instruktion utför en åtgärd. Instruktioner styr programflödet, deklarerar variabler eller anropar åtgärder. Följande är påståenden:

  • int x; (deklarationsutdrag)
  • int x = 42; (deklarationsuttryck med initiering)
  • Console.WriteLine("Hello"); (metodanropsinstrukering)
  • if (condition) { /* code */ } (villkorssats)
  • return result; (retursats)

Ofta består satser av uttryck och uttryck kan nästlas inom andra uttryck. Till exempel, följande deklarationsuttryck tilldelar resultatet av ett tilläggsuttryck till f. Det additionsuttrycket lägger till resultatet av två metodanropsuttryck:

var maxResult = Math.Max(a, b) + Math.Max(c, d);

För detaljerad information om uttalanden, se Uttalanden. Information om medlemmar med uttryckskropp finns i Medlemmar med uttryckskroppar.

Relaterat innehåll

  • Last updated on