IT-Academy Logo
Sign Up Login Help
Home - Programmieren - .Net - C# - Grundlagen C#



Grundlagen C#

Grundlagen der C# Programmierung von CBA.


Autor: x y (kuertu)
Datum: 06-11-2006, 23:28:35
Referenzen: Visual C#.Net
Schwierigkeit: Fortgeschrittene
Ansichten: 18722x
Rating: 7 (2x bewertet)

Hinweis:

Für den hier dargestellte Inhalt ist nicht der Betreiber der Plattform, sondern der jeweilige Autor verantwortlich.
Falls Sie Missbrauch vermuten, bitten wir Sie, uns unter missbrauch@it-academy.cc zu kontaktieren.

[Druckansicht] [Als E-Mail senden] [Kommentar verfassen]



Struktogram (Nassi-Schneidermann)



Programmablaufplan (PAP oder Flussdiagramm)


Datentypen
Verzweigungen (Bedingung und Auswahl) if- Schleife if(Bedingung) { //Anweisungen, wenn Bedingung wahr } else { //Anweisungen, wenn Bedingung falsch } switch- case- Schleife switch(variable) { case 1: //Anweisungen… break; case 2: //Anweisungen… break; case 3: //Anweisungen… break; default: //Standard-Anweisungen break; } Iterationen (Schleifen) for-, while-, do- Schleife for (Initialisierung;Bedingung;Aktualisierung) { //Anweisungen } while (Bedingung) { //Anweisungen }; do { //Anweisungen }; Unterprogramme Prozeduren class Programm { static void Main(string[] args) { int PersNr = 122; string Name = “Huber”; string Vorname = “Hans”; Datenausgabe(); } Static void Datenauisgabe() { System.Console.WriteLine(„PersNr =“ + PersNr); System.Console.WriteLine(„name =“ + Vorname); System.Console.WriteLine(„Vorname =“ + Vorname); } } Mit globalen Variablen: class Programm { static int PersNr; static string Name; static string Vorname; static void Main(string[] args) { PersNr = 122; Name = “Huber”; Vorname = “Hans”; Datenausgabe(); } Static void Datenausgabe() { System.Console.WriteLine(„PersNr =“ + PersNr); System.Console.WriteLine(„name =“ + Vorname); System.Console.WriteLine(„Vorname =“ + Vorname); } } Parameterübergabe per Wert (call by value): class Programm { static void Main(string[] args) { int PersNr = 122; string Name = “Huber”; string Vorname = “Hans”; Datenausgabe(PersNr, Name, Vorname); } Static void Datenausgabe(int PersNr, string Name, string Vorname) { System.Console.WriteLine(„PersNr =“ + PNr); System.Console.WriteLine(„name =“ + Vorname); System.Console.WriteLine(„Vorname =“ + Vorname); } } Parameterübergabe per Referenz (call by reference): class Programm { static void Main(string[] args) { int PersNr = 122; string Name = “Huber”; string Vorname = “Hans”; Datenausgabe(ref PersNr, ref Name, ref Vorname); } static void Datenausgabe(ref int PersNr, ref string Name, ref string Vorname) { System.Console.WriteLine(„PersNr =“ + PNr); System.Console.WriteLine(„name =“ + Vorname); System.Console.WriteLine(„Vorname =“ + Vorname); } } Funktionen (Prozeduren mit Rückgabewerten) Rückgabewert: Prozeduren können auch einen Rückgabewert eines bestimmten Datentyps haben. Man spricht dann von Funktionen. Mit solchen Funktionen können Sie wie mit Variablen des entsprechenden Typs arbeiten, z.B. den Funktionsnamen in Ausdrücken verwenden und ihn anderen Variablen zuweisen. Es ist allerdings nicht zwingend erforderlich den Rückgabewert einer Funktion zu verarbeiten. class Programm { static void Main(string[] args) { int a = addition(); System.Console.WriteLine(a); } static int addition() { int i; i = 3+4; return i; } } //Das Programm gibt „7“ aus, da dies der Rückgabewert der Funktion ist Enumeratoren

Mittels Enumenatoren kann man neue, eigene Datentypen definieren. Den Variablen dieses neuen Datentyps können die im Enumerator definierten sprechenden Bezeichnungen, anstelle der Werte, zugewiesen werden. Durch die Verwendung von Enumerator-Datentypen erhalten wir übersichtlicheren, fehlerfreieren und vor allem lesbareren Programmcode. Class MeinProgramm { //Neuen Enumerator Datentyp definieren enum eTage{Samstag, Sonntag, Montag, Dienstag, Mittwoch, Donnerstag, Freitag}; //Samstag wird automatisch der Wert „0“ zugewiesen, Sonntag „1“… //ausser man schreibt z.B. „Samstag = 1,…“ //dann wird wieder normal ab dem gegebenen Wert heraufgezählt static void Main(string[] args) { //Neuen Enumerator Datentyp verwenden (Variablen erstellen) eTage d1 = eTage.Montag; //Der Name der Variable ist “d1” int i = 5; if(d1 == eTage.Montag) { … } } } Ausgabe: System.Console.WriteLine(Convert.ToInt32(d1)); //gibt 3 aus System.Console.WriteLine(d1.ToString()); //gibt „Dienstag“ aus Compilerfehler Class Class1{ enum eMaschineZustand : byte {aus=0,standby=1,reduziert=2,vollbetrieb=3, Alarm=4} static void Main(string[] args) { eMaschinenZustand m1, m2; //OK m1=eMaschinenZustand.Alarm; //OK m1=Alarm; //Compilerfehler m1=4; //Compilerfehler m1= (eMaschinenZustand)4; //OK m1= (eMaschinenZustand)77; //falsch da 77 nicht definiert, aber kein Compilerfehler! byte btemp; //OK btemp = m1; //Compilerfehler btemp = eMaschinenZustand.Alarm; //Compilerfehler int itemp1 = m1; //Compilerfehler int itemp2 = (int)m1; //OK } } Arrays (Datenfelder) int[] iFeld = new int[5000]; //ein Array mit 5000 Integer Variablen wurde erstellt //das geht auch mit anderen Datentypen (long, double, byte,…) Beispiele: static void Main(string[] args) { int i = 0; Console.WriteLine("Wieviele Zahlen möchten Sie eingeben"); i = Convert.ToInt32(Console.ReadLine()); byte[] zahlen = new byte[i]; //Einlesen der Werte der Variablen des Arrays: for(int x=0;xSortieren int feld[] = new int[3]; feld[0] = 5 feld[1] = 2 feld[2] = 4 for(iIndex = 0; iIndex < nAnz; iIndex++) { for(iIndex2=iIndex+1; iIndex2 < nAnz; iIndex2++) { if(Feld[iIndex]>Feld[iIndex2]) { int temp = Feld[iIndex]; Feld[iIndex] = Feld[iIndex2]; Feld[iIndex2]= temp; } } } Ein Array an ein Unterprogramm übergeben: … static void Main(string[] args) { … int[] Feld = new int[5]; zahlenausgeben(Feld); …. } static void Zahlenausgeben(int[] Zahlen) //ist das Original! { … } … //Tipp: „Arrayname“.GetUpperBound(0);  sucht Obergrenze des Arrays Strukturen Mittels Strukturen kann man neue, eigene Datentypen definieren. Strukturen können thematisch zusammengehörige Daten gleicher oder unterschiedlicher Datentypen organisieren (zusammenfassen). Die so in einer Struktur zusammengefassten Daten tragen einen Namen (Strukturbezeichnung) welchen man als neuen Datentyp verwenden kann um Variablen zu erzeugen. Class Class1 { struct struPerson { public int PNr; public string Name; public string Vorname; public DateTime Geburtsdatum; } static void Main(string[] args) { struPerson p1; //Eine Variable „p1“ des neuen Datentyps „struPerson“ erstellen p1.PNr = 100; p1.Name = „Huber“; p1.Vorname = „Hans“; p1.geburtsdatum = Convert.ToDateTime(„07.04.1972“); Personendatenausgeben(p1); } static void Personendatenausgeben(struPerson p) //keine Referenz, nur Kopie! { … } } Enumeratoren in Strukturen Beispiel Schachbret using System; namespace Schachbrett { /// /// Zusammenfassung für Class1. /// class Class1 { enum eSchachfiguren: byte { Keine=0, Koenig=1, Dame, Laeufer, Springer, Turm, bauer } enum eFarbe: byte { Undefiniert=0, Schwarz=1, Weiss=2 } struct struSchachfeld { public eSchachfiguren figur; public eFarbe farbe; public bool isbedroht; } [STAThread] static void Main(string[] args) { //Deklaration struSchachfeld[,] Schachbrett = new struSchachfeld[8,8]; //Initialisierung (nicht inbedingt nötig, da Inhalt auf 0 gesetzt wird -- Korrekt) for(int iSpalte = Schachbrett.GetLowerBound(0); iSpalte < Schachbrett.GetUpperBound(0); iSpalte++) { for(int iZeile = Schachbrett.GetLowerBound(1); iZeile < Schachbrett.GetUpperBound(1); iZeile++) { Schachbrett[iZeile,iSpalte].farbe = eFarbe.Undefiniert; Schachbrett[iZeile,iSpalte].figur = eSchachfiguren.Keine; Schachbrett[iZeile,iSpalte].isbedroht = false; } } } } } Zeichenliterale Ein Zeichenliteral ist ein einzelnes, von einfachen Anführungszeichen umschlossenes Zeichen, beispielsweise ’x’. Es werden folgende Escapesequenzen unterstützt:
Escapesequenz Beschreibung
\‘ Einfaches Anführungszeichen
\“ Doppeltes Anführungszeichen
\\ Umgekehrter Schrägstrich (Backslash)
\0 Null-Zeichen
\a Alarm (kurze Tonausgabe)
\b Rückschritt (backspace)
\f Formularvorschub (Formfeed)
\n Neue Zeile
\r Wagenrücklaufzeichen (Return)
\t Tabulator
\v Vertikaler Tabulator
\xdddd Zeichen (dddd steht für den Hex-Code des Zeichens)
\udddd Unicode-Zeichen dddd (Hex-Code)
Konstanten C# ermöglicht die Definition von Werten als Konstanten. Soll ein Wert als Konstante definiert werden, muss der Wert etwas sein, dass als Konstante geschrieben werden kann. Diese Anforderung schränkt die Konstantentypen auf die integrierten Typen ein, die als literale Werte geschrieben werden können. Das Platzieren von const vor einer Variablen bedeutet, dass deren Wert nicht geändert werden kann. Hier ein Konstantenbeispiel: using System; enum MyEnum { Jet } class LotsOLiterals { // const-Elemente können nicht geändert werden // const impliziert static public const int value1 = 33; public const string value2 = "Hello"; public const MyEnum value3 = MyEnum.Jet; } class Test { public static void Main() { Console.WriteLine("{0} {1} {2}", LotsOLiterals.value1, LotsOLiterals.value2, LotsOLiterals.value3); } } Modulo-Operator Der Modulo- Operator (%) ermittelt den Rest einer Division. Hier ein Beispiel der Anwendung des Modulo- Operators: using System; namespace Modulo_Demonstration { class Modulo_Demonstration { /// /// Der Haupteinsprungspunkt der Anwendung. /// /// 0 ... Erfolg [STAThread] public static void Main() { int dividend; int divisor; int resultDivision; int resultModulo; do { Console.Write("Eingabe des Dividenden (positive Zahl > 0): "); dividend = Convert.ToInt32(Console.ReadLine()); } while (dividend <= 0); do { Console.Write ("Eingabe des Divisors (Zahl ungleich 0): "); divisor = Convert.ToInt32(Console.ReadLine()); } while (divisor == 0); resultDivision = dividend/divisor; Console.WriteLine("\nDivision: "+resultDivision+" = "+dividend+" / "+divisor); resultModulo = dividend%divisor; Console.WriteLine("Modulo: "+resultModulo+" = "+dividend+" % "+divisor); Console.ReadLine(); } } } Console.Write()/WriteLine()/ReadLine() Beispiel mit Text: Code: using System; namespace ConsoleApplication2 { /// /// Zusammenfassung für Class1. /// class Class1 { /// /// Der Haupteinstiegspunkt für die Anwendung. /// [STAThread] static void Main(string[] args) { string text; string text2; Console.Write("Bitte geben Sie einen Text ein: "); //Ausgabe OHNE anschliessenden Zeilenumbruch text = Console.ReadLine(); //Aufnahme einer Eingabe MIT anschliessendem Zeilenumbruch Console.Write("Sie haben folgenden Text eingegeben: "+text); //Ausgabe OHNE anschliessenden Zeilenumbruch Console.WriteLine("Bitte geben Sie noch einen Text ein: "); //Ausgabe MIT anschliessendem Zeilenumbruch text2 = Console.ReadLine(); //Aufnahme einer Eingabe MIT anschliessendem Zeilenumbruch Console.WriteLine("Sie haben folgenden Text eingegeben: "+text2); //Ausgabe MIT anschliessendem Zeilenumbruch Console.ReadLine(); //Wartet auf Eingabe um Fenster bis Druck einer Taste anzuzeigen } } } Konsole:
Beispiel mit Zahlen: Code: using System; namespace ConsoleApplication2 { /// /// Zusammenfassung für Class1. /// class Class1 { /// /// Der Haupteinstiegspunkt für die Anwendung. /// [STAThread] static void Main(string[] args) { int zahl; int zahl2; Console.Write("Bitte geben Sie eine Zahl ein: "); //Ausgabe OHNE anschliessenden Zeilenumbruch zahl = Convert.ToInt32(Console.ReadLine()); //Aufnahme einer Eingabe MIT anschliessendem Zeilenumbruch Console.Write("Sie haben folgende Zahl eingegeben: "+zahl); //Ausgabe OHNE anschliessenden Zeilenumbruch Console.WriteLine("Bitte geben Sie noch eine Zahl ein: "); //Ausgabe MIT anschliessendem Zeilenumbruch zahl2 = Convert.ToInt32(Console.ReadLine()); //Aufnahme einer Eingabe MIT anschliessendem Zeilenumbruch Console.WriteLine("Sie haben folgende Zahl eingegeben: "+zahl2); //Ausgabe MIT anschliessendem Zeilenumbruch Console.ReadLine(); //Wartet auf Eingabe um Fenster bis Druck einer Taste anzuzeigen } } } Konsole


cshark
Rookie
Beitrag vom:
24-09-2008, 10:03:50

Druckansicht

In der Druckansicht fehlen ab 'Konstanten' die Zeilenumbrüche.

-----------------------------------------------------


paedubucher
Professonial
Beitrag vom:
07-11-2006, 21:30:55

Kommentare

Nicht dass ich die Kommentare im Code schlecht finden würde, sie reichen ja eigentlich aus.

Grössere Kommentare habe ich aber lieber ausserhalb des Codes, da verliert man den Blick aufs "wesentliche" nicht. Sonst sieht der Code manchmal etwas aufgebläht aus... Ist eine Vorliebe von mir, mit den Kommentaren ausserhalb des Codes.

-----------------------------------------------------


kuertu
Senior Member
Beitrag vom:
07-11-2006, 19:30:11

Danke für den Kommentar

Das Dokument habe ich dem Betreiber zuerst als pdf, dann nach Anfrage als doc Datei zur Verfügung gestellt. Die Grafiken sind dort in guter Qualität vorhanden. Also verlieren die Grafiken ihre Qualität beim hochladen...

Zu den Kommentaren, diese habe ich absichtlich in den Code eingebaut um die Funktion des Codes verständlich zu zeigen. Weiterläufige Kommentare sind oberhalb des Codes als Text ausgeschrieben.

mfg kuertu

-----------------------------------------------------


paedubucher
Professonial
Beitrag vom:
07-11-2006, 18:36:10

Grafiken

Die Grafiken oben am Artikel sehen recht übel aus. Auf manchen kann man gar nichts erkennen. Wurden die beim Hochladen noch etwas zusammengedrückt?

Weiter unten befinden sich jedoch ein paar brauchbare Beispiele. Mit einigen Erläuterungen (ausserhalb der Kommentare) wären diese jedoch noch um einiges besser...

-----------------------------------------------------


[back to top]



Userdaten
User nicht eingeloggt

Gesamtranking
Werbung
Datenbankstand
Autoren:04511
Artikel:00815
Glossar:04116
News:13565
Userbeiträge:16552
Queueeinträge:06248
News Umfrage
Ihre Anforderungen an ein Online-Zeiterfassungs-Produkt?
Mobile Nutzung möglich (Ipone, Android)
Externe API Schnittstelle/Plugins dritter
Zeiterfassung meiner Mitarbeiter
Exportieren in CSV/XLS
Siehe Kommentar



[Results] | [Archiv] Votes: 1158
Comments: 0