Arbeiten mit .NET: C-Sharp/ Materialien/ Ein Beispielprogramm

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Wir kennen das alle: Da hat man schon eine neue Programmiersprache entdeckt, und dann soll man auch noch diese ganzen Definitionen, Beschreibungen, Erklärungen und Erklärungen für Erklärungen lesen. Dabei fiebert man doch eigentlich dem ersten Praxistest entgegen: Was kann diese Sprache? Ist das wirklich so leicht? Wie macht man dies oder jenes? Was passiert eigentlich, wenn ... ?

Als ultimative Antwort auf all diese Fragen gibt's hier eine fix und fertige "Spielwiese", in der wir uns schon mal nach Herzenslust austoben können. Falsch machen kann man dabei gar nichts. Im schlimmsten Fall muss eben der ganze Quelltext noch einmal von dieser Seite kopiert werden. Also: Nur keine Hemmungen! - Kopiere einfach den gesamten Quelltext in deine Entwicklungsumgebung und teste C#! Schneller kannst du nicht lernen.

Glasbutton Tipp.svg

Tipp: Verändere das Programm; teste, was wie funktioniert; probiere aus, was Fehler verursacht.
Und erweitere, ändere, bearbeite die Spielwiese C# ganz so, wie du Lust und Laune hast.

Alle wichtigen Zeilen wurden mit Kommentaren versehen. Dort findest du auch ein paar Stichworte, worum es in diesen Zeilen geht. Und wenn du Fragen hast, schaust du in das Buch und suchst dir die interessanten Artikel heraus.

Und wer weiß? Vielleicht stellst du schon morgen eine Spielwiese C# Version 2 hier ein, um den Leuten zu zeigen, was noch alles geht?


Quelltext: Spielwiese C#[Bearbeiten]


Crystal Clear app terminal.png C#-Code:  

using System;
 
namespace Spielwiese
{
   class Program
   {
     // Haupteinstieg für die Anwendung.
     // Stichworte: 
     // Klassen, Methoden, statische Methoden, Parameter
     static void Main(string[] args)
     {
       // Stichworte:
       // Schleifen, Kopfgesteuerte Schleifen, Foreach 
       foreach(string arg in args)
       {
         // Textausgabe auf dem Bildschirm
         Console.WriteLine("Übergebener Parameter: {0}", arg);
       }

       // Wir probieren den Aufruf einer Methode aus.
       Console.WriteLine("");
       Console.WriteLine("Wir testen den Aufruf einer Methode:");
       TesteKlasse();

       // Wir probieren Vererbung aus.
       Console.WriteLine("");
       Console.WriteLine("Wir testen die Vererbung:");
       TesteVererbung();

       // Wir warten, 
       // bis der Benutzer [ENTER] drückt.
       Console.WriteLine("");
       Console.WriteLine("Test beendet. Warte auf [Enter].");
       Console.ReadLine();
     }

     // Eine statische Methode.
     // Stichworte:
     // Klassen, Methoden, statische Methoden, Parameter, Zugriffsmodifizierer
     static public int Addiere(int zahl1, int zahl2)
     {
       // Wir berechnen das Ergebnis 
       // und geben es zurück.
       return zahl1 + zahl2;
     }

     // Eine statische Methode.
     // Stichworte:
     // Klassen, Methoden, statische Methoden, Parameter, Zugriffsmodifizierer
     static public void TesteKlasse()
     {
       // Wir holen uns ein Objekt der Klasse NeueSpielwiese.
       // Stichworte:
       // Klassen, Objekte, Vererbung
       NochNeuereSpielwiese neuesteSpielwiese = new NochNeuereSpielwiese();

       // Stichworte:
       // Polymorphie, Überladen
       float ergebnis = neuesteSpielwiese.Subtrahiere(1.2f, 2.3f);
       Console.WriteLine("Das Ergebnis der Subtraktion der überladenen Methode mit zwei Parametern lautet: {0}", ergebnis);

       // Stichworte:
       // Polymorphie, Überladen
       ergebnis = neuesteSpielwiese.Subtrahiere(1.2f, 2.3f, 3.4f);
       Console.WriteLine("Das Ergebnis der Subtraktion der überladenen Methode mit drei Parametern lautet: {0}", ergebnis);
     }

     static void TesteVererbung()
     {
       // Wir holen uns ein Objekt.
       // Stichworte:
       // Klassen, Objekte, Vererbung
       NochNeuereSpielwiese neuesteSpielwiese = new NochNeuereSpielwiese();
       Console.WriteLine("Der Name der Subklasse lautet: {0}", neuesteSpielwiese.Name);
     }

     // Eine private Klassenvariable.
     // Stichworte:
     // Klassen, Variablen, Klassenvariablen, 
     // Zugriffsmodifizierer, Modifizierer
     private static string m_Name = "Spielwiese";

     // Eine statische Eigenschaft.
     // Stichworte:
     // Klassen, Eigenschaften,
     // Zugriffsmodifizierer, Modifizierer
     static private string Name
     {
       // Was soll geschehen,
       // wenn jemand den Namen wissen will?
       // Stichworte:
       // Klassen, Eigenschaften
       get { return m_Name; }
       // Was soll geschehen, 
       // wenn jemand den Namen schreiben will?
       // Stichworte:
       // Klassen, Eigenschaften
       set { m_Name = value; }
     }
   }
   // Eine andere Klasse.
   // Stichworte:
   // Klassen, Zugriffsmodifizierer, Modifizierer
   abstract class NeueSpielwiese
   {
     // Eine geschützte Klassenvariable.
     // Stichworte:
     // Klassen, Variablen, Klassenvariablen,
     // Zugriffsmodifizierer, Modifizierer
     protected string m_Name = "Spielwiese 2";

     // Eine Eigenschaft.
     // Stichworte:
     // Klassen, Eigenschaften,
     // Zugriffsmodifizierer, Modifizierer
     public string Name
     {
       // Was soll geschehen,
       // wenn jemand den Namen wissen will?
       // Stichworte:
       // Klassen, Eigenschaften
       get { return m_Name; }
       // Was soll geschehen, 
       // wenn jemand den Namen schreiben will?
       // Stichworte:
       // Klassen, Eigenschaften
       set { m_Name = value; }
     }

     // Der Konstruktor
     // Stichworte:
     // Klassen, Konstruktoren, Zugriffsmodifizierer
     protected NeueSpielwiese()
     {
     }

     // Eine abstrakte Methode.
     // Stichworte:
     // Klassen, Methoden, Polymorphie, Überladen,
     // Zugriffsmodifizierer, Modifizierer
     abstract public string UeberschriebeneMethode();
   }
   // Noch eine andere Klasse
   // Stichworte:
   // Klassen, Vererbung,
   // Zugriffsmodifizierer, Modifizierer
   class NochNeuereSpielwiese : NeueSpielwiese
   {
     // Der Konstruktor
     // Stichworte:
     // Klassen, Konstruktoren, Zugriffsmodifizierer
     public NochNeuereSpielwiese()
     {
       m_Name = "Spielwiese 3";
     }

     // Eine überschriebene Methode.
     // Stichworte:
     // Klassen, Methoden, Polymorphie, Überladen,
     // Zugriffsmodifizierer, Modifizierer
     public override string UeberschriebeneMethode()
     {
       return "Ich bin eine überschriebene Methode.";
     }

     // Eine überladene Methode.
     // Stichworte:
     // Klassen, Methoden, Polymorphie, Überladen,
     // Zugriffsmodifizierer, Modifizierer
     public float Subtrahiere(float zahl1, float zahl2)
     {
       float ergebnis = zahl1 - zahl2;

       return ergebnis;
     }

     // Eine überladene Methode.
     // Stichworte:
     // Klassen, Methoden, Polymorphie, Überladen,
     // Zugriffsmodifizierer, Modifizierer
     public float Subtrahiere(float zahl1, float zahl2, float zahl3)
     {
       float ergebnis = zahl1 - zahl2 - zahl3;

       return ergebnis;
     }
   }
}

Wie bringe ich die Spielwiese zum Laufen?[Bearbeiten]

Ganz einfach:

  1. Kopiere den gesamten Quelltext von oben, also von using ... bis zur letzten }.
    (Die optische Trennung dient nur der besseren Übersicht. Kopiere bitte den gesamten(!) Text des Beispiels.)
  2. Füge ihn in deine Entwicklungsumgebung ein.
  3. Starte den Compiler.