1)Τι είναι η C#;

Η C# είναι μία ολοκληρωμένη αντικειμενοστραφής γλώσσα προγραμματισμού σχεδιασμένη για τη δημιουργία λογισμικού σε .Net Framework.

• Τα πάντα στη C# είναι αντικείμενα

• Παρέχει άμεση πρόσβαση σε τεράστιες βιβλιοθήκες κλάσεων του .Net Framework
  & ασφάλεια των τύπων της.

2)Απλό παράδειγμα C# προγράμματος:

Θα δούμε παρακάτω τη σύνταξη και τη δομή ενός απλού προγράμματος (Console Application) στη C# που εμφανίζει το μήνυμα ‘’Hello World’’ και θα αναλύσουμε γραμμή γραμμή τα μέρη του:

1.    using System;      

2.    namespace MyNamespace 
3.    
4.    {
5.       class Helloworld   
6.       {
7.        static void Main() 
a.        {
i.          Console.WriteLine("Hello World");
ii.          Console.ReadKey();

b.        }
8.       }
9.      }

3)Χώροι ονομάτων (Namespaces):

Σε ένα C# πρόγραμμα χρησιμοποιούμαι Namespaces για την οργάνωση του κώδικα μας.
Στο παραπάνω πρόγραμμα χρησιμοποιήσαμε τον χώρο ονομάτων System (γραμμή 1 του παραδείγματος) μέσο της λέξης κλειδιού using ,το οποίο περιλαμβάνει έτοιμες κλάσεις και μεθόδους του .ΝΕΤ με έτοιμο επαναχρησιμοποιήσιμο κώδικα!

Ένα Namespace μπορεί να περιέχει τους εξής τύπους :

• Namespaces
• Classes
• Delegates
• Enums
• Structs
• Interfaces

Για τη δημιουργία ενός δικού μας Namespace χρησιμοποιούμε τη δεσμευμένη λέξη-κλειδί namespace (γραμμή 2), έτσι η κλάση Helloworld (γραμμή 4) εμπεριέχεται στο MyNamespace που δημιουργήσαμε.

Στη συνέχεια του κώδικα μπορούμε να δούμε πως μπορούμε να εμφανίσουμε στη γραμμή εντολών το μήνυμα "Hello World". Η μέθοδος Main() (γραμμή 6) περιέχει την εντολή Console.WriteLine("Hello World"); ,η οποία εμφανίζει το τελικό μήνυμα.

ΠΑΡΑΤΗΡΉΣΕΙΣ:

• Η κλάση Console ανήκει στο χώρο ονομάτων System
  και η WriteLine() είναι μέθοδος της Console.
  Εάν δεν χρησιμοποιούσαμε την εντολή using System; Η εντολή θα συντασσόταν System.Console.WriteLine("Hello Word");
  
  

• Χρησιμοποιούμε την τελεία ανάμεσα από Namespaces, κλάσεις και μεθόδους για να δείξουμε τι εμπεριέχεται σε τι. Πχ.

namespace N1     // N1
{
    class C1      // N1.C1
    {
        Method() C2   // N1.C1.C2()
        {
        }
    }
    namespace N2  // N1.N2
    {
        class C2   // N1.N2.C2
        {
        }
    }
}

• Την εντολή Console.ReadKey(); την χρησιμοποιούμε απλά για να κρατήσουμε το
  παράθυρο της γραμμής εντολών ανοικτό και να δούμε το μήνυμα που εμφανίζουμε,
  το πρόγραμμα απλά περιμένει ο χρήστης να πατήσει κάποιο κουμπί και στη
  συνέχεια τερματίζει.

4)Ψευδώνυμα (Aliases):

Μπορούμε να χρησιμοποιούμε ψευδώνυμα (Aliases) για να κάνουμε τον κώδικα μας ακόμα πιο σύντομο και να αποφύγουμε να γράφουμε μακροσκελείς εντολές. Πχ.

using  Alias = System.Console ;
            
namespace MyNamespace
{
    public class Helloworld
    {
       static void Main()
        {   
            Alias.WriteLine("Hello World");
            Console.ReadKey();
        }
     }
 }
 

5)Σχόλια:

Μπορούμε να χρησιμοποιούμε σχόλια στον κώδικά μας κυρίως για να εξηγούμε κάποια σημεία του, όπως τη λειτουργία μιας κλάσης/μεθόδου που δημιουργήσαμε ,έτσι ώστε να γίνεται ο κώδικας εύκολος στην ανάγνωση τόσο για μας ,αν θελήσουμε κάποια στιγμή να τον ανατρέξουμε να δούμε τη λειτουργία του, αλλά και για κάποιο τρίτο πρόσωπο που θα χρειαστεί να τον δει.

Τα σχόλια συντάσσονται χρησιμοποιώντας αυτόν τον συμβολισμό ( // ) ,εάν επρόκειτο για μία γραμμή σχολίου:
//Αυτό είναι ένα σχόλιο

ή αν το σχόλιο απαιτεί παραπάνω γραμμή με αυτόν τον τρόπο:
/* Αυτό είναι
ένα σχόλιο */

Με τον τρόπο αυτό ο compiler προσπερνάει οτιδήποτε βρίσκεται μετά τα εισαγωγικά και δεν επηρεάζει το τελικό αποτέλεσμα του προγράμματος.

Παραδείγματα σχολίων:

Console.WriteLine("Hello World"); //Output a greeting

Console.WriteLine("Hello World"); /*Output
a greeting*/

Π Ρ Ο Σ Ο Χ Η
Εάν χρησιμοποιούσαμε τα διπλά εισαγωγικά μπροστά από την Console.WriteLine κάπως έτσι: // Console.WriteLine("Hellow Word"); Output a greeting ,τότε ο compiler θα προσπερνούσε αυτήν την εντολή σαν σχόλιο και το αποτέλεσμα της δεν θα εμφανιζόταν ποτέ στην οθόνη.

5)Δήλωση μεταβλητών, Ανάθεση-Σύγκριση τιμών &
Εμφάνιση αποτελεσμάτων στην οθόνη:

Σε ένα C# πρόγραμμα μπορούμε να δηλώσουμε μεταβλητές σε οποιοδήποτε σημείο του προγράμματος , πριν τις χρησιμοποιήσουμε για κάποια πράξη.

• Για να δηλώσουμε μία μεταβλητή ορίζουμε πρώτα τον τύπο της και ύστερα το όνομα της.
  πχ. int x; string y1; long z_2;

• Για να κάνουμε ανάθεση τιμής σε μεταβλητές χρησιμοποιούμε το ίσον ( = )
  πχ. x = 5; Ή η ίδια εντολή ως int x = 5; άν την δηλώναμε ταυτόχρονα μαζί με την
  ανάθεση της τιμής. char y = 'h'; Κτλ.

• Για σύγκριση μεταβλητών ισχύουν :
  >= μεγαλύτερο ή ίσο
  <= μικρότερο ή ίσο
  == ίσο
  != διάφορο

• Για να εμφανίσουμε το περιεχόμενο μεταβλητών στην οθόνη η C# χρησιμοποιεί τη μέθοδο WriteLine() με δύο τρόπους σύνταξης.

Παρακάτω θα δούμε σε ένα απλό πρόγραμμα που εμφανίζει το άθροισα δύο ακεραίων τον τρόπο δήλωσης μεταβλητών, την ανάθεση τιμών σε αυτές και τέλος πώς να εμφανίζουμε μεταβλητές με τη χρήση της WriteLine() :

using System;

namespace MyNamespace
{
    class Sum_x1_x2
    {
        static void Main()
        {   
            // 1ος τρόπος δήλωσης στην αρχή του προγράμματος
            int x1 = 5; 
            int x2 = 3;
            int y = x1 + x2;
            
            // 1ος τρόπος σύνταξης της WriteLine
            Console.WriteLine(" Το αποτέλεσμα είναι : {0} ", y) ;
            
            /* To output είναι: Το αποτέλεσμα είναι : 8
               Στη θέση του συμβόλου {0} η WriteLine 
               τοποθετεί την τιμή που έχει το y.Το μηδέν 
               μέσα στα άγκιστρα δείχνει τη θέση 
               της μεταβλητής μετά το κόμμα μέσα στη Writeline.
               Αν θέλαμε να εμφανίσουμε παραπάνω μεταβλητές
               θα κάναμε το εξής:
               Console.WriteLine("{0} + {1} = {2}",x1,x2,y);
               Το output εδώ θα ήταν : 5 + 3 = 8
               Στη θέση του {0} πάει η τιμή της x1, στο {1} η x2 
               και στο {2} η y.
            */

            string z = "!!!"; /*2ος τρόπος δήλωσης κατά τη ροή του 
                                προγράμματος */

           // 2ος τρόπος σύνταξης της WriteLine
            Console.WriteLine("To αποτέλεσμα είναι : {0}" +z ,y);
            
            /* Γιατί +z ??? 
               Στη WriteLIne οτιδήποτε είναι μέσα σε εισαγωγικά
               αποτελεί string. Η μεταβλητή z είναι επίσης ένα
               string. Βλέπουμε λοιπόν ότι μπορούμε να προσθέσουμε
               δύο strings μαζί και το αποτέλεσμα θα έιναι 
               το ένα string να "κολλήσει" πίσω από το άλλο. 
               Το output εδώ θα δώσει : To αποτέλεσμα είναι : 8!!! 
             */

             Console.ReadKey();

        }
    }
}

ΠΑΡΑΤΗΡΗΣΕΙΣ:

• Η C# είναι Case sensitive ,
  Για να δηλώσουμε την Main() χρησιμοποιήσαμε κεφαλαίο M! Θα ήταν λάθος να λέγαμε static void main(). ο compiler εξ ορισμού καταλαβαίνει ότι το βασικό πρόγραμμα βρίσκεται στην μέθοδο Main() και όχι στην main().
  Εννοείται πως int y ≠ int Y !

• Keywords,
  Στη C# υπάρχουν δεσμευμένες λέξεις-κλειδιά.
  Δεν μπορούμε να δηλώσουμε πχ μια μεταβλητή με όνομα Console/int/void/class,
  όπως επίσης δεν μπορούμε να βάζουμε αριθμό μπροστά από μεταβλητή!

• Σταθερές ( Constans ),
  Η δήλωση των σταθερών στο C# πρόγραμμα όπως πχ. Η τιμή του π=3.14. γίνεται με αυτόν τον τρόπο : const double p = 3.14;

• Στη WriteLine() υπάρχουν 2 τρόποι εμφάνισης μεταβλητών.
  1ος τρόπος ως συνεχόμενο string
  2ος τρόπος με int μεταβλητές :
  πχ.
  int x = 1;
  int y = 2;
  int sum = x + y;

//1ος τρόπος
Console.WriteLine(x + "+" + y + "=" + sum);
// outuput 1+2=3

//2ος τρόπος
Console.WriteLine("{0}+{1}={2}",x,y,sum);
//output 1+2=3

Integers (ακέραιοι)

Floating point Number (μεταβλητές κινητής υποδιαστολής)

Οι μεταβλητές περιέχουν μια τιμή, η οποία μπορεί να μεταβληθεί κατά την διάρκεια εκτέλεσης του προγράμματος.

Για να χρησιμοποιηθεί όμως μια μεταβλητή πρέπει πρώτα να δηλωθεί, να της δοθεί δηλαδή ένα όνομα και να επιλεγεί ο τύπος δεδομένων που θα αποθηκεύει. Η δήλωση γίνεται γράφοντας έναν τύπο δεδομένων ακολουθούμενο από ένα όνομα.

1. Παράδειγμα (Byte):

static void Main() {

byte MyNumber = 254;

Console.WriteLine(MyNumber); //Εμφανίζει 254

MyNumber++;
// Συν 1 -> 255

Console.WriteLine(MyNumber); //Εμφανίζει 255

MyNumber++;
// Συν 1 -> 0 (όριο 255)

Console.WriteLine(MyNumber); //Εμφανίζει 0

MyNumber++;
// Συν 1 -> 1

Console.WriteLine(MyNumber); //Εμφανίζει 1

}

2. Παράδειγμα (int/float)

Με Int

static void Main()

//Σε περίπτωση που Δηλώσουμε 2 ακεραίους INT

{

//Δηλώνουμε 2 ακεραίους

INT int A = 10; int B = 3;

//διαιρούμε 10/3

int apotelesma = A/B;

// Μας εμφανίζει 3 και Οχι 3,333...

Console.WriteLine(apotelesma);

}

Με Float

static void Main()

//Σε περίπτωση που Δηλώσουμε 2 ακεραίους Single

{

//Δηλώνουμε 2 ακεραίους Single ή double ή float

Single A = 10; Single B = 3;

//διαιρούμε 10/3

Single apotelesma = A/B;

// Μας 3,333...

Console.WriteLine(apotelesma);

}

3. Παράδειγμα (Float)

static void Main()

{

float apostasi;

float xronos;

float taxitita;

apostasi = 0.1f;

// 100m είναι 0.1 km

// για 9.87 δευτερόλεπτα είναι 9.87/60*60 h

xronos = 9.87f / 3600;

taxitita = apostasi / xronos;

Console.WriteLine("Η μέση ταχύτητα είναι {0} km/h", taxitita);

}

4. Παράδειγμα (Int/Long):

static void Main()

{

int x = 10000;

int y = 20000;

//Σε αυτό οι μεταβλητές "int" μετατρέπονται σε "long"

//Δεν χρειάζεται conversion από το ‘int’ σε ‘long’,γίνεται αυτόματα.

int total;

total = x * y;

Console.WriteLine("Το αποτέλεσμα είναι:" + total);

}

Strings & chars (Συμβολοσειρές και χαρακτήρες)

Συμβολοσειρά (string) είναι μια σειρά αλφαριθμητικών χαρακτήρων (γενικά  εκτυπώσιμων συμβόλων ASCII). Όταν λέμε σειρά εννοούμε διαδοχικές θέσεις  μνήμης που μπορούν να αντιμετωπισθούν σαν ένα σύνολο διατεταγμένων  στοιχειωδών δεδομένων.

Η συμβολοσειρά είναι ένας ειδικός τύπος πίνακα με δεδομένα του τύπου char και με τερματισμό μέσω του μηδενικού χαρακτήρα.

Παράδειγμα:

static void Main()

{

//το Α = StudentGuru

string A = "StudentGuru";

//B = με το πρώτο χαρακτήρα της μεταβλητής Α άρα = "S"

char B = A[0]; Console.WriteLine(B);

// εκτυπώνει στην κονσόλα.

Console.WriteLine(A);

// εκτυπώνει στην κονσόλα.

//Τώρα το B = με το τρίτο χαρακτήρα της μεταβλητής Α άρα ="u"

B=A[2];

Console.WriteLine(B);

// εκτυπώνει στην κονσόλα.

}

Bool τιμές

Ο τύπος bool έχει δύο σταθερές τιμές:

• την true 
• και την false

Σημείωση: true = αληθές και false = εσφαλμένο, ψευδές.

Παράδειγμα:

static void Main()

{

bool CheckNumber;

Console.WriteLine("Typose studentguru");

string num = Console.ReadLine();

//εάν η μεταβλητή = studentguru

if (num =="studentguru")

{

CheckNumber = true;

//τότε το checkNumber = true

}

else

{

CheckNumber = false;

//διαφορετικά checkNumber = false

}

Console.WriteLine(CheckNumber);

}

Nullable Types

Ο όρος Null είναι μια ενδιαφέρουσα ιδέα στον κόσμο του προγραμματισμού και δεν είναι συνώνυμο με το «μηδέν» ή «κενό», αλλά «απροσδιόριστη».

Κάθε προγραμματιστή συχνά κατά τη διάρκεια της ανάπτυξης των εφαρμογών τους  έχουν να κάνουν με τη λεγόμενη “τύπους τιμή δεδομένων” (τύποι αξία) ως  int, double, bool, char κτλ. Αυτοί οι τύποι δεδομένων είναι οι βασικοί,  είναι λίγο περίεργη σε ορισμένες περιπτώσεις, δεν μπορεί να οριστούν μηδενικές.

Ευτυχώς, η C #  παρέχει ένα πολύ χρήσιμο εργαλείο:. Nullable Types  δεδομένων. Αυτοί οι τύποι δεδομένων μπορούν να χρησιμοποιηθούν σε οποιοδήποτε σημείο του κώδικα όπου υπάρχει ανάγκη να έχουμε μια μεταβλητή που μπορεί να έχει αξίες.

1. Παράδειγμα σύνταξη:

1. char? letter = 'a';
   
   2. int? i = null;
   
   3. int? i = 10;
   
   4. double? d1 = 3.14;
   
   5. bool? flag = null;
   
    6. int?[] arr = new int?[10];
   
    Το "var" δεν είναι συμβατό με αυτό Nullable Type: var? i = null; //Λάθος Η σωστή σύνταξη για το "var" είναι: var i = 4;

2. Παράδειγμα Nullable types

static void Main(string[] args)

{

int? num = null; //Nullable Types Σύνταξη

//Έλεγχος εάν η μεταβλητή num έχει τιμή

if (num.HasValue == true)

//αν ναι τύπωσε μας την τιμή

System.Console.WriteLine(num.Value);

Else

//αν όχι τύπωσε NULL

System.Console.WriteLine("NULL");

}

3. Άμεση Μετατροπή

int? n = null;

//int m1 = n; // Λάθος

int m2 = (int)n;

int m3 = n.Value;

4. Έμμεση μετατροπή

int? n1 = null;

int? n2;

n2 = 10; //Έμμεση μερατροπή

5. “??” Τελεστές Nullable

int? c = null;

// d = c, και το c είναι null, το d = -1.

int d = c ?? -1;

int? e = null;

int? f = null;

// g = e ή και f, εκτός εάν το e και το f = null, που για κάθε περίπτωση g = -1.

int g = e ?? f ?? -1;

bool? b = null;

if (b)

// Λάθος CS0266

{

}

Var Types

Η μεταβλητή δεν είναι άλλο από μια ονομασμένη θέση μνήμης που μπορεί να περιέχει δεδομένα οποιουδήποτε είδους.  Με τον τύπο Var δεν χρειάζεται να σκεφτούμε πολύ σκληρά το πώς θα δηλώσουμε την μεταβλητή μας. Η var είναι εύχρηστη, διότι δεν χρειάζεται να αποφασίσετε αν θα χρησιμοποιήσετε System.String ή System.Int32. Ο compiler καθορίζει τον τύπο για μάς.

1. Παράδειγμα Var Types

Παράδειγμα: 

static void Main()

{

var leksi = “studentGuru”;

var Arithmos = 21;

var MegArithmo = 219283746253;

var dekadiko = 2,19283746253;

}

Παρόμοια κατάσταση, αν έχετε μια απλή κλάση με το όνομα Person:

public class Person

{

public string Name { get; set; }

public int Age { get; set; }

}

static void Main()

{

var person = new Person();

person.Age = 21;

person.Name = “StudentGuru”;

}

Οι τελεστές (Operators) είναι σύμβολα ή λέξεις που αναπαριστούν συγκεκριμένες διεργασίες, οι οποίες εκτελούνται πάνω σε ένα ή περισσότερα δεδομένα. Τα δεδομένα καλούνται τελεστές (operands) και μπορούν να είναι μεταβλητές, σταθερές ή ακόμη και κλήσεις συναρτήσεων.

Οι τελεστές χρησιμοποιούνται για το σχηματισμό εκφράσεων. Μία έκφραση (=Μεταβλητή), εν γένει, αποτελείται από έναν ή περισσότερους τελεστές. Κάθε έκφραση έχει μία τιμή, η οποία υπολογίζεται με ορισμένους κανόνες.

Σύμβολα συνηθισμένων τελεστών

C# Operators (Τελεστές) 

Τα ποιο συνηθισμένα σύμβολα τελεστών

Προτεραιότητα και προσεταιριστικότητα τελεστών στη C#

Παράδειγμα τελεστές υπό όρους(Operators Conditional)

Το σύμβολο ‘?’ ακολουθεί τη συνθήκη, και το σύμβολο ‘:’ εμφανίζεται ανάμεσα από τις δύο εκφράσεις. Όλες τις εκφράσεις που πραγματοποιούνται μεταξύ του ‘?’ αλλά και του ‘:’ αντιμετωπίζονται ως μία έκφραση. 

Στο συγκεκριμένο παράδειγμα ο τελεστής (Conditional) επιστρέφει μια τιμή : αληθής (True) ή ψευδείς (False):

static void Main(string[] args)

{

bool Βool_ = true;

string apotelesma = Βool_ ? "Αληθές" : "Ψευδείς";

Console.WriteLine("{0}", apotelesma);

Console.WriteLine(Βool_ ? "Eίναι Αληθές" : "Eίναι Ψευδείς");

Console.Read();

}

static void Main(string[] args)

{

bool Βool_ = false;

string apotelesma = Βool_ ? "Αληθές" : "Ψευδείς";

Console.WriteLine("{0}", apotelesma);

Console.WriteLine(Βool_ ? "Eίναι Αληθές" : "Eίναι Ψευδείς ");

Console.Read();

}

Παράδειγμα τελεστές Σχεσιακή (Operators Relational)

Προκειμένου να αξιολογηθεί η σύγκριση μεταξύ των δύο εκφράσεων μπορούμε να χρησιμοποιήσουμε τη σχεσιακή (Operators Relational). Το αποτέλεσμα από μια σχεσιακή λειτουργία είναι Boolean τιμή δηλαδή δεν μπορεί παρά να είναι αληθείς ή ψευδείς.

Παράδειγμα:

static void Main(string[] args)

{

Console.WriteLine("Πόσο χρονών είσαι;");

int Age = Convert.ToInt32(Console.ReadLine());

if (Age >= 18)

{

Console.WriteLine("Τότε είσαι ενήλικας");

}

else if (Age < 18)

{

Console.WriteLine("Τότε είσαι ανήλικας");

}

}

Παράδειγμα τελεστές Αλφαριθμητικά και ανάθεσης (Arithmetic, Assignment)

Οι αριθμητικοί τελεστές είναι αυτοί που χρησιμοποιούνται για να κάνουν βασικές αριθμητικές πράξεις και στη C# και είναι 5: 

• πρόσθεση: + 
• αφαίρεση: – 
• πολλαπλασιασμός: * 
• διαίρεση: /  
• υπόλοιπο διαίρεσης: %

Οι τελεστές εκχώρησης είναι ο “=” και οι συνδυασμοί τελεστών εκχώρησης και αριθμητικών τελεστών.  

Για παράδειγμα:

•  x+=y ισοδυναμεί με x=x+y 
•  x-=y ισοδυναμεί με x=x-y 
•   x*=y ισοδυναμεί με x=x*y 
•  x/=y ισοδυναμεί με x=x/y
•  x%=y ισοδυναμεί με x=x%y

static void Main(string[] args)

{

int x, y;

x = 6;

y = 5;

x += y;

Console.WriteLine(x);

}
 

static void Main(string[] args)

{

int x, y;

x = 6;

y = 5;

x *= y;

Console.WriteLine(x);

}

static void Main(string[] args)

{

int x, y;

x = 5;

y = 50;

x %= y;

Ψonsole.WriteLine(x);

}

Μοναδιαίοι τελεστές είναι οι τελεστές προσαύξησης ή μείωσης που αυξάνουν ή μειώνουν την τιμή μιας μεταβλητής κατά 1.

•  x++; (αυξάνει την τιμή του x κατά 1) 
•  x- -; (μειώνει την τιμή του x κατά 1)

x* = 10;  εκτελεί την πράξη του πολλαπλασιασμού μεταξύ των x και 10 και εκχωρεί το αποτέλεσμα στο x. Αντιστοιχεί στην πρόταση x = x * 10;

x* = y + 1; Αντιστοιχεί στην πρόταση x = x * (y + 1); κι ΟΧΙ στην πρόταση x = x * y + 1;

Τελεστές ανάθεσης δημιουργούν κι οι τελεστές διαχείρισης δυαδικών ψηφίων (bitwise operators). Οι τελεστές αυτοί είναι: >>=  << =   &=   ^=   |= . Οι τελεστές ανάθεσης μαζί με τους τελεστές αύξησης/μείωσης γίνονται αιτία δημιουργίας παρενεργειών (side effects), για το λόγο αυτό αναφέρονται και ως παρενεργοί τελεστές (side effect operators).

Οι παρενέργειες αυτές έχουν ως αποτέλεσμα την απροσδιόριστη συμπεριφορά του συστήματος ως προς τον τρόπο υπολογισμού της τιμής της μεταβλητής i σε εκφράσεις όπως: i = n[i++];  ή  i = ++i + 1;

Πιο συγκεκριμένα όπως είδατε και παραπάνω οι τελεστές σύγκρισης είναι οι εξής:

•  == ισότητας (επιστρέφει true αν οι μεταβλητές είναι ίσες) 
•  != ανισότητας (επιστρέφει true αν οι μεταβλητές δεν είναι ίσες) 
• < μικρότερο (επιστρέφει true αν η μεταβλητή στα αριστερά είναι μικρότερη) 
• > μεγαλύτερο (επιστρέφει true αν η μεταβλητή στα αριστερά είναι μεγαλύτερη) 
• <= μικρότερο ή ίσο (επιστρέφει true αν η μεταβλητή στα αριστερά είναι μικρότερη ή ίση με την μεταβλητή στα δεξιά
•  >= μεγαλύτερο ή ίσο (επιστρέφει true αν η μεταβλητή στα αριστερά είναι μεγαλύτερη ή ίση με την μεταβλητή στα δεξιά) 

Οι λογικοί τελεστές χρησιμοποιούνται για να συνδυαστούν εκφράσεις που παράγουν λογικές τιμές. Χρησιμοποιούνται για τους λογικούς συνδυασμούς and, or, x or, και το λογικό not και είναι οι παρακάτω:

• &, &&: χρησιμοποιούνται για να εκφράσουν το λογικό and και επιστρέφουν true αν και οι δύο λογικές εκφράσεις είναι true.  
•  |, ||: χρησιμοποιούνται για να εκφράσουν το λογικό or και επιστρέφουν true αν τουλάχιστον μία από τις δύο λογικές εκφράσεις είναι true.
• ^ : χρησιμοποιείται για να εκφράσει το λογικό xor και επιστρέφει true μόνο αν οι δύο λογικές εκφράσεις είναι η μία true και η άλλη false.
• ! : χρησιμοποιείται για να εκφράσει το λογικό not και επιστρέφει true μόνο αν η λογική έκφραση είναι false.

Μέχρι στιγμής τα προγράμματα που έχουμε δει έχουν το εξής χαρακτηριστικό: οι εντολές τους εκτελούνται μια-μια, με την σειρά. Σε αυτό το tutorial θα δούμε πως μπορούμε να κάνουμε τα προγράμματα μας να εκτελούν διαφορετικές εντολές, αναλόγως με το αν ικανοποιούνται διάφορες συνθήκες που θέτουμε. Πιο συγκεκριμένα θα δούμε τις παρακάτω δομές ελέγχου:

• if statement
• switch statement

Καθώς και πως χρησιμοποιούμε τις εντολές break και goto.

Για να δοκιμάσουμε τα παρακάτω αρκεί να δημιουργήσουμε ένα νέο C# Console Application στο Visual Studio.

if statement

Η εντολή if μας επιτρέπει να εκτελέσουμε μια εντολή ή ένα μπλοκ εντολών αναλόγως με το αν ικανοποιείται μια συνθήκη. Η σύνταξη της είναι η παρακάτω:

if (condition)
            statement;

Ως συνθήκη μπορούμε να ορίσουμε μια οποιαδήποτε λογική έκφραση, για παράδειγμα:

• true
• false
• x> = y
• x == 0 && y < 10
• κ.ο.κ.

Εάν ικανοποιείται η συνθήκη τότε εκτελείται η εντολή που αντιστοιχεί στο if. Σε αντίθετη περίπτωση η εκτέλεση συνεχίζεται με τις εντολές που ακολουθούν το if. Για παράδειγμα ο κώδικας που ακολουθεί μας δίνει την παρακάτω έξοδο:

int x = 10;

if (x >= 10)
    Console.WriteLine("x is greater/equal 10");
        
// continues here

Εάν θέλουμε μέσα στο if να εκτελέσουμε παραπάνω από μια εντολές αρκεί να χρησιμοποιήσουμε μπλοκ κώδικα. Δηλαδή πολλές εντολές που βρίσκονται ανάμεσα σε { και } και συμπεριφέρονται ως ενιαίο κομμάτι. Παράδειγμα:

int x = 42;
 
if (x >= 10) {
    Console.WriteLine("x is greater than 10");
    Console.WriteLine("or equal to 10");
}

if-else statement

Η λειτουργία της είναι παρόμοια με την if μόνο που ορίζουμε και ποιες εντολές θα εκτελεστούν εάν δεν ισχύει η συνθήκη. Η σύνταξη είναι η εξής:

if (condition)
    statement_1;
else
    statement_2;

Ας δούμε ένα παράδειγμα και την έξοδο που δίνει:

int x = 42;
 
if (x == 0 || x < 0)
    Console.WriteLine("your number is negative or zero");
else
    Console.WriteLine("your number is positive");

if (condition_1)
    statement_1;
else if (condition_2)
    statement_2;
else if (condition_3)
    ...
else if (condition_n)
    statement_n;
else
    statement_else;

int x = 4;
 
if (x < 0)
    Console.WriteLine("x < 0");
else if (x >= 0 && x <= 10)
    Console.WriteLine("x in [0,10]");
else if (x > 10 && x <= 20)
    Console.WriteLine("x in (10,20]");
else
    Console.WriteLine("x > 20");

switch (variable)
{
    case value_1:
        statement_1a;
        statement_1b;
        break;
    case value_2:
        statement_2a;
        statement_2b;
        break;
    case value_3:
        ...
        ...
    case value_n:
        statement_na;
        statement_nb;
        break;
    default:
        statement_default;
        break;
}

int x = 2;
 
switch (x)
{
    case 0:
        Console.WriteLine("x equals 0 ");
        break;
    case 1:
    case 2:
        Console.WriteLine("x equals 1");
        Console.WriteLine("or x equals 2");
        break;
    case 3:
        Console.WriteLine("x equals 3");
        break;
    default:
        Console.WriteLine("x is negative or greater than 3");
        break;
}

label_name:
    statement;
    ....
 
 
    statement;
 
    goto label_name;

using System;
 
class Program
{
    static void Main(string[] args)
    {
        string input;
 
    mylabel1:
 
        Console.Write("type something :");
        input = Console.ReadLine();
 
        if(input == "exit")
            goto mylabel2;
        else
            goto mylabel1;
 
    mylabel2:
 
        Console.WriteLine("bye");
    }
}

Εισαγωγή

Ο OOP(Object-Oriented Programming ή Αντικειμενοστρεφής προγραμματισμός) είναι ένας τρόπος ανάπτυξης κώδικα. Πριν τον OOP χρησιμοποιούνταν ο συναρτησιακός προγραμματισμός μέχρι που ο αντικειμενοστρεφής έλυσε πολλά από τα προβλήματα του πρώτου. Στον συναρτησιακό, η ανάπτυξη του προγράμματος γραφόταν σε μερικές ενότητες (modules) κώδικα ή μπορεί και σε μία μόνο (ανάλογα με το πρόγραμμα) και αυτές οι ενότητες εξαρτιόνταν από άλλες. Αν άλλαζες μια γραμμή του κώδικα θα έπρεπε να ξαναγράψεις όλη την ενότητα ξανά και ίσως και όλο το πρόγραμμα. Στον αντικειμενοστρεφή προγραμματισμό, οι developers γράφουν ανεξάρτητα κομμάτια προγράμματος, τις λεγόμενες κλάσεις και κάθε κλάση αναπαριστά μια λειτουργία ενός κομματιού του συστήματος. Έτσι σε ενδεχόμενο πρόβλημα, το μόνο που χρειάζεται να γίνει είναι να αλλάξει αυτό το κομμάτι χωρίς να επηρεάζει τα άλλα τμήματα.

Κλάσεις και αντικείμενα

Μπορεί να μην σας είναι εύκολο να καταλάβετε την ιστορία με τις κλάσεις και τα αντικείμενα αλλά θα κάνω το καλύτερο για να τα εξηγήσω. Πραγματικά, οι κλάσεις και τα αντικείμενα είναι στενά συνδεδεμένα μεταξύ τους και μερικοί αρχάριοι δεν νοιάζονται για να το καταλάβουν καθαρά, οπότε και περνάνε δύσκολα όταν μελετάν την c#!

Η έννοια του αντικειμενοστρεφούς προγραμματισμού παίρνει το μεγαλύτερο μέρος της λειτουργικότητας της από έννοιες της πραγματικής ζωής. Θα παρουσιάσω την έννοια των κλάσεων και των αντικειμένων του κόσμου πρώτα και μετά θα καταλάβετε τις κλάσεις και τα αντικείμενα των υπολογιστών προτού γράψω τίποτα περί αυτών.

Οι κλάσεις και τα αντικείμενα στον κόσμο

Τα πάντα στον κόσμο μας θεωρούνται αντικείμενα. Για παράδειγμα, οι άνθρωποι είναι αντικείμενα, τα ζώα επίσης, τα ορυκτά είναι αντικείμενα, τα πάντα είναι αντικείμενα. Εύκολο, σωστά; Τι γίνεται όμως με τις κλάσεις; Στον κόσμο μας πρέπει να διαφοροποιούμε τα αντικείμενα με τα οποία εμείς ζούμε. Έτσι πρέπει να καταλάβουμε πως υπάρχουν κατατάξεις (classifications, έτσι πήραν το όνομα και την έννοια της κλάσης) για όλα αυτά τα αντικείμενα. Για παράδειγμα, εγώ είμαι αντικείμενο, ο Νίκος επίσης, η Μαρία είναι άλλο αντικείμενο γι αυτό και είμαστε όλοι από την κλάση (η τύπος) άνθρωπος. Έχω έναν σκύλο που ονομάζεται Ricky έτσι είναι αντικείμενο. Ο σκύλος του φίλου μου ονομάζεται Doby, επίσης αντικείμενο και τα δυο από την κλάση Σκύλος. Ένα τρίτο παράδειγμα. Έχω έναν υπολογιστή Pentium III. Αυτό είναι το αντικείμενο. Ο φίλος μου έχει επίσης ένα Pentium IV οπότε και ένα άλλο αντικείμενο από την κλάση Υπολογιστής. Τώρα νομίζω πιάσατε την έννοια της κλάσης και του αντικειμένου αλλά αφήστε με να σας το ξεκαθαρίσω λίγο παραπάνω. Στον κόσμο μας έχουμε μια κατάταξη για τα αντικείμενα και κάθε αντικείμενο πρέπει να είναι από κάποια κατάταξη. Έτσι, μια κλάση είναι ένας τρόπος για να περιγράψουμε μερικές ιδιότητες και λειτουργίες ή συμπεριφορές για μια ομάδα από αντικείμενα. Με άλλα λόγια, η κλάση θεωρείται ως πρότυπο για μερικά αντικείμενα. Έτσι μπορεί να φτιάξω μια κλάση που ονομάζεται «άτομο» έτσι ώστε να είναι ένα πρότυπο που να περιλαμβάνει τις ιδιότητες και τις λειτουργίες ενός ατόμου (πχ σαν ιδιότητες ηλικία, φύλλο κλπ).

Κλάσεις και αντικείμενα του υπολογιστή

Οι κλάσεις στον υπολογιστή είναι παρόμοιες με αυτές του κόσμου, με μερικές τροποποιήσεις ούτως ώστε να μπορούν να κωδικοποιηθούν σε πρόγραμμα υπολογιστή.

Κλάσεις και αντικείμενα στην C#

Μια κλάση στην c# θεωρείται ως το πρωταρχικό στοιχείο για οικοδόμηση της γλώσσας. Αυτό που εννοώ είναι ότι κάθε φορά που δουλεύετε με την C# θα δημιουργείτε κλάσεις για να σχηματίζουν το πρόγραμμα. Χρησιμοποιούμε κλάσεις ως ένα πρότυπο για να βάλουμε μέσα τις ιδιότητες και τις λειτουργίες σε ένα δομικό στοιχείο (building block) για μερικά γκρουπ αντικειμένων και μετά τις χρησιμοποιούμε ως πρότυπα για να φτιάξουμε τα αντικείμενα που χρειαζόμαστε. Αλλά αρκετά με την θεωρία. Πάμε να δούμε τα πράγματα στον κώδικα.

Έστω λοιπόν πως θέλουμε να φτιάξουμε το πρότυπο για έναν άνθρωπο. Στο πρόγραμμα μας θέλουμε να μπορούμε να κρατάμε το όνομα του και την ηλικία του. Έχουμε λοιπόν:

class person { 
 public int Age;
        public string ΗairColor;
    }

Για την δήλωση λοιπόν της κλάσης person γράφουμε την λέξη class, το όνομα της κλάσης και τις αγγύλες {}. Μέσα στις αγκύλες υπάρχει όλη η υλοποίηση της κλάσης. Πέραν της γνωστής δήλωσης της μεταβλητής name (string name;) παρατηρούμε και το keyword public. Μην ανησυχείτε τώρα για αυτό, θα δούμε αργότερα τον σκοπό του.

Έως τώρα λοιπόν έχουμε φτιάξει το πρότυπο. Δεν υπάρχουν ακόμα αντικείμενα. Πάμε να δούμε πως τους δίνουμε υπόσταση (Instantiate) ή δημιουργούμε μέσα από ένα παράδειγμα.

static void Main(string[] args)
        {
            Person Michael = new Person(); //δημιουργία αντικειμένου τύπου Person με το όνομα Michael
            Person Mary = new Person(); //αντίστοιχα
 
            // Ορισμός τιμών για τις ιδιότητες του Michael
            Michael.Age = 20;
            Michael.HairColor = "Brown";
 
            // Ορισμός τιμών για τις ιδιότητες της Mary
            Mary.Age = 25;
            Mary.HairColor = "Black";
 
            // εκτύπωση της ηλικίας τους
            Console.WriteLine("Michael’s age = {0}, and Mary’s age= {1}", Michael.Age, Mary.Age);
            Console.ReadLine();
        }

Έτσι αρχίζουμε την Main μέθοδο μας φτιάχνοντας 2 αντικείμενα του τύπου Person. Στην συνέχεια αρχικοποιούμε (δίνουμε αρχικές τιμές στις μεταβλητές) για τα αντικείμενα Michael και Mary. Στο τέλος εκτυπώνουμε μερικές τιμές στην κονσόλα.

Όταν δημιουργούμε το αντικείμενο Michael, ο compiler της c# δεσμεύει χώρο για τις 2 μεταβλητές της κλάσης person, για να μπορούμε να κρατήσουμε τις τιμές εκεί. Το ίδιο συμβαίνει και για το αντικείμενο Mary. Έτσι, κάθε αντικείμενο περιέχει διαφορετικά δεδομένα.

Εισαγωγή

Ο OOP(Object-Oriented Programming ή Αντικειμενοστρεφής προγραμματισμός) είναι ένας τρόπος ανάπτυξης κώδικα. Πριν τον OOP χρησιμοποιούνταν ο συναρτησιακός προγραμματισμός μέχρι που ο αντικειμενοστρεφής έλυσε πολλά από τα προβλήματα του πρώτου. Στον συναρτησιακό, η ανάπτυξη του προγράμματος γραφόταν σε μερικές ενότητες (modules) κώδικα ή μπορεί και σε μία μόνο (ανάλογα με το πρόγραμμα) και αυτές οι ενότητες εξαρτιόνταν από άλλες. Αν άλλαζες μια γραμμή του κώδικα θα έπρεπε να ξαναγράψεις όλη την ενότητα ξανά και ίσως και όλο το πρόγραμμα. Στον αντικειμενοστρεφή προγραμματισμό, οι developers γράφουν ανεξάρτητα κομμάτια προγράμματος, τις λεγόμενες κλάσεις και κάθε κλάση αναπαριστά μια λειτουργία ενός κομματιού του συστήματος. Έτσι σε ενδεχόμενο πρόβλημα, το μόνο που χρειάζεται να γίνει είναι να αλλάξει αυτό το κομμάτι χωρίς να επηρεάζει τα άλλα τμήματα.

Κλάσεις και αντικείμενα

Μπορεί να μην σας είναι εύκολο να καταλάβετε την ιστορία με τις κλάσεις και τα αντικείμενα αλλά θα κάνω το καλύτερο για να τα εξηγήσω. Πραγματικά, οι κλάσεις και τα αντικείμενα είναι στενά συνδεδεμένα μεταξύ τους και μερικοί αρχάριοι δεν νοιάζονται για να το καταλάβουν καθαρά, οπότε και περνάνε δύσκολα όταν μελετάν την c#!

Η έννοια του αντικειμενοστρεφούς προγραμματισμού παίρνει το μεγαλύτερο μέρος της λειτουργικότητας της από έννοιες της πραγματικής ζωής. Θα παρουσιάσω την έννοια των κλάσεων και των αντικειμένων του κόσμου πρώτα και μετά θα καταλάβετε τις κλάσεις και τα αντικείμενα των υπολογιστών προτού γράψω τίποτα περί αυτών.

Οι κλάσεις και τα αντικείμενα στον κόσμο

Τα πάντα στον κόσμο μας θεωρούνται αντικείμενα. Για παράδειγμα, οι άνθρωποι είναι αντικείμενα, τα ζώα επίσης, τα ορυκτά είναι αντικείμενα, τα πάντα είναι αντικείμενα. Εύκολο, σωστά; Τι γίνεται όμως με τις κλάσεις; Στον κόσμο μας πρέπει να διαφοροποιούμε τα αντικείμενα με τα οποία εμείς ζούμε. Έτσι πρέπει να καταλάβουμε πως υπάρχουν κατατάξεις (classifications, έτσι πήραν το όνομα και την έννοια της κλάσης) για όλα αυτά τα αντικείμενα. Για παράδειγμα, εγώ είμαι αντικείμενο, ο Νίκος επίσης, η Μαρία είναι άλλο αντικείμενο γι αυτό και είμαστε όλοι από την κλάση (η τύπος) άνθρωπος. Έχω έναν σκύλο που ονομάζεται Ricky έτσι είναι αντικείμενο. Ο σκύλος του φίλου μου ονομάζεται Doby, επίσης αντικείμενο και τα δυο από την κλάση Σκύλος. Ένα τρίτο παράδειγμα. Έχω έναν υπολογιστή Pentium III. Αυτό είναι το αντικείμενο. Ο φίλος μου έχει επίσης ένα Pentium IV οπότε και ένα άλλο αντικείμενο από την κλάση Υπολογιστής. Τώρα νομίζω πιάσατε την έννοια της κλάσης και του αντικειμένου αλλά αφήστε με να σας το ξεκαθαρίσω λίγο παραπάνω. Στον κόσμο μας έχουμε μια κατάταξη για τα αντικείμενα και κάθε αντικείμενο πρέπει να είναι από κάποια κατάταξη. Έτσι, μια κλάση είναι ένας τρόπος για να περιγράψουμε μερικές ιδιότητες και λειτουργίες ή συμπεριφορές για μια ομάδα από αντικείμενα. Με άλλα λόγια, η κλάση θεωρείται ως πρότυπο για μερικά αντικείμενα. Έτσι μπορεί να φτιάξω μια κλάση που ονομάζεται «άτομο» έτσι ώστε να είναι ένα πρότυπο που να περιλαμβάνει τις ιδιότητες και τις λειτουργίες ενός ατόμου (πχ σαν ιδιότητες ηλικία, φύλλο κλπ).

Κλάσεις και αντικείμενα του υπολογιστή

Οι κλάσεις στον υπολογιστή είναι παρόμοιες με αυτές του κόσμου, με μερικές τροποποιήσεις ούτως ώστε να μπορούν να κωδικοποιηθούν σε πρόγραμμα υπολογιστή.

Κλάσεις και αντικείμενα στην C#

Μια κλάση στην c# θεωρείται ως το πρωταρχικό στοιχείο για οικοδόμηση της γλώσσας. Αυτό που εννοώ είναι ότι κάθε φορά που δουλεύετε με την C# θα δημιουργείτε κλάσεις για να σχηματίζουν το πρόγραμμα. Χρησιμοποιούμε κλάσεις ως ένα πρότυπο για να βάλουμε μέσα τις ιδιότητες και τις λειτουργίες σε ένα δομικό στοιχείο (building block) για μερικά γκρουπ αντικειμένων και μετά τις χρησιμοποιούμε ως πρότυπα για να φτιάξουμε τα αντικείμενα που χρειαζόμαστε. Αλλά αρκετά με την θεωρία. Πάμε να δούμε τα πράγματα στον κώδικα.

Έστω λοιπόν πως θέλουμε να φτιάξουμε το πρότυπο για έναν άνθρωπο. Στο πρόγραμμα μας θέλουμε να μπορούμε να κρατάμε το όνομα του και την ηλικία του. Έχουμε λοιπόν:

class person
    {
        public string Νame;
        public string ΗairColor;
    }

Για την δήλωση λοιπόν της κλάσης person γράφουμε την λέξη class, το όνομα της κλάσης και τις αγγύλες {}. Μέσα στις αγκύλες υπάρχει όλη η υλοποίηση της κλάσης. Πέραν της γνωστής δήλωσης της μεταβλητής name (string name;) παρατηρούμε και το keyword public. Μην ανησυχείτε τώρα για αυτό, θα δούμε αργότερα τον σκοπό του.

Έως τώρα λοιπόν έχουμε φτιάξει το πρότυπο. Δεν υπάρχουν ακόμα αντικείμενα. Πάμε να δούμε πως τους δίνουμε υπόσταση (Instantiate) ή δημιουργούμε μέσα από ένα παράδειγμα.

static void Main(string[] args)
        {
            Person Michael = new Person(); //δημιουργία αντικειμένου τύπου Person με το όνομα Michael
            Person Mary = new Person(); //αντίστοιχα
 
            // Ορισμός τιμών για τις ιδιότητες του Michael
            Michael.Age = 20;
            Michael.HairColor = "Brown";
 
            // Ορισμός τιμών για τις ιδιότητες της Mary
            Mary.Age = 25;
            Mary.HairColor = "Black";
 
            // εκτύπωση της ηλικίας τους
            Console.WriteLine("Michael’s age = {0}, and Mary’s age= {1}", Michael.Age, Mary.Age);
            Console.ReadLine();
        }

Έτσι αρχίζουμε την Main μέθοδο μας φτιάχνοντας 2 αντικείμενα του τύπου Person. Στην συνέχεια αρχικοποιούμε (δίνουμε αρχικές τιμές στις μεταβλητές) για τα αντικείμενα Michael και Mary. Στο τέλος εκτυπώνουμε μερικές τιμές στην κονσόλα.

Όταν δημιουργούμε το αντικείμενο Michael, ο compiler της c# δεσμεύει χώρο για τις 2 μεταβλητές της κλάσης person, για να μπορούμε να κρατήσουμε τις τιμές εκεί. Το ίδιο συμβαίνει και για το αντικείμενο Mary. Έτσι, κάθε αντικείμενο περιέχει διαφορετικά δεδομένα.

Properties

Όπως παρατηρήσατε στο προηγούμενο παράδειγμα χρησιμοποιήσαμε τις μεταβλητές με άμεσο τρόπο και τους βάλαμε ότι τιμή θέλαμε, σωστά? Οπότε κάποιο άτομο θα μπορούσε να βάλει στην ηλικία την τιμή 120. Για αυτό το πρόβλημα υπάρχει λύση μέσω των properties.

Οι ιδιότητες προσφέρουν έναν τρόπο να αποκτήσουμε πρόσβαση στις μεταβλητές μιας κλάσης με ασφαλή τρόπο. Ας δούμε το ίδιο παράδειγμα χρησιμοποιώντας properties.

class Person
    {
        private int age;
        private string hairColor;
        public int Age
        {
            get
            {
                return age;
            }
            set
            {
                if (value <= 65 && value >= 18)
                {
                    age = value;
                }
                else
                    age = 18;
            }
        }
        public string HairColor
        {
            get
            {
                return hairColor;
            }
            set
            {
                hairColor = value;
            }
        }
    }

Έκανα μερικές αλλαγές αλλά απλά δείτε τις 2 νέες ιδιότητες που πρόσθεσα εδώ. Μια ιδιότητα αποτελείται από 2 μέρη (accessors). Τον get accessor ο οποίος είναι υπεύθυνος για την ανάκτηση της τιμής της μεταβλητής και τον set accessor ο οποίος είναι υπεύθυνος για την τροποποίηση της τιμής της μεταβλητής. Ο κώδικας του get accessor είναι πολύ απλός και απλά χρησιμοποιούμε το keyword return με το όνομα της μεταβλητής για την επιστροφή της τιμής της. Έτσι ο κώδικας:

         get
            {
                return hairColor;
            }

Επιστρέφει την τιμή της μεταβλητής hairColor.

Ας δούμε πως δουλεύει ο κώδικας με τις properties και μετά ας αναλύσουμε τον set accessor.

static void Main(string[] args)
        {
            Person Michael = new Person();
            Person Mary = new Person();
 
            Michael.Age = 20;
            Michael.HairColor = "Brown";
            Mary.Age = 25;
            Mary.HairColor = "Black";
 
            Console.WriteLine("Michael’s age = {0}, and Mary’s age= {1}", Michael.Age,
            Mary.Age);
            Console.ReadLine();
        }

Δημιούργησα λοιπόν τα ίδια αντικείμενα όπως και πριν. Η μόνη διαφορά είναι πως τώρα χρησιμοποιώ properties για την ανάθεση/τροποποίηση της τιμής αντί για απευθείας πρόσβαση. Κοιτάξτε σε αυτήν την γραμμή κώδικα:

Michael.Age = 20;

Όταν ορίζουμε μια τιμή σε μια property όπως εδώ, η c# χρησιμοποιεί τον set accessor. Το καλό με τον set accessor είναι πως μπορεί να ελέγξει την τιμή πριν την ορίσει στην μεταβλητή και ίσως και να την αλλάξει σε μερικές περιπτώσεις. Όταν ορίζεις μια τιμή σε μια property η c# τοποθετεί αυτήν την τιμή σε μια δεσμευμένη μεταβλητή με το keyword value. Ας ξαναδούμε τον set accessor:

        set
            {
                if (value <= 65 && value >= 18)
                {
                    age = value;
                }
                else
                    age = 18;
            }

Άρα για το παράδειγμα μας η μεταβλητή value έχει την τιμή 20. Αν είχαμε γράψει

Michael.Age = 15;

Η value θα είχε τιμή 15 και άρα στην μεταβλητή age θα έμπαινε η τιμή 18.

This Keyword

Πολλές φορές θέλουμε να αποκτήσουμε πρόσβαση στο ίδιο το αντικείμενο της κλάσης. Αυτό μπορεί να είναι είτε για να δούμε τις ιδιότητες, μεταβλητές και μεθόδους που περιέχει η κλάση μας είτε για να περάσουμε το ίδιο αντικείμενο που δουλεύουμε σαν παράμετρο σε μια μέθοδο. Το keyword this μας επιτρέπει να το επιτύχουμε αυτό.

Άρα στην ουσία
Το keyword this αναφέρεται στο τρέχων στιγμιότυπο της κλάσης. Τα στοιχεία που έχουν δηλωθεί ως static δεν μπορούν να αναφερθούν με το this. To this μπορούμε να το χρησιμοποιήσουμε και για να ξεχωρίσουμε παραμέτρους όπου κρύβουν γενικότερες μεταβλητές. Πχ

private string name;
private string alias;
public Employee(string name, string alias) 
{
   this.name = name;
   this.alias = alias;
}

Variable Scope & Access modifiers

class person { 
    string fullScopeString;//ορατό σε όλη την κλάση. 
    void testMethod() { 
        string str;//ορατό μόνο στην μέθοδο test method 
    } 
    void exampleMethod2() { 
        fullScopeString = "test";//μπορώ εδώ να δω το string fullScopeString 
        //str="test2";//ΛΑΘΟΣ - η str είναι ορατή μόνο στην μέθοδο testMethod     } 
    void example3() 
    { 
        int i; 
        for (int i = 0; i < 10; i++) 
        { string s;//ορατό μόνο στην for 
            s = i + "s"; Debug.Write(s);
        } 
    } 
}

class person
    {
        private string testStr; //προσβάσιμη μόνο μέσα στην κλάση person 
        private void testMethod()// -- // -- 
        {

        }
        public string str2;//Προσβάσιμο σε όσα μέρη χρησιμοποιούν την κλάση 
        public string getHello()
        {
            return "hello!";
        }

        protected string str3;//προσβάσιμο στην κλάση και σε αυτές που την κληρονομούν. 
    }
    class test
    {
        //contructor 
        public test()
        {
            person p = new person(); p.str2 = "Hello World";//το str2 είναι προσβάσιμο 
            string s = p.getHello();//σωστό. Η get hello είναι public και άρα προσβάσιμη

            // p.testStr="smthng";//ΛΑΘΟΣ - το testStr δεν είναι προσβάσιμο  
        }
    }

Η struct είναι μια δομή όπου μπορεί να περιέχει constructors, σταθερές, μεταβλητές, μεθόδους, ιδιότητες, indexers, events και εμφωλευμένους τύπους. Μια τυπική δήλωση struct μπορεί να έχει την παρακάτω μορφή

public struct myStruct
    {
        
    }

Παρατηρήσεις

Ο τύπος struct είναι κατάλληλος για να αντιπροσωπεύει ελεφρά αντικείμενα όπως Point, Rectangle και Color. Αν και είναι δυνατόν το αντικείμενο πχ Point να παρασταθεί με μια κλάση, η Struct είναι αποτελεσματικότερη σε μερικές περιπτώσεις. Για παράδειγμα, αν δηλώσεις έναν πίνακα με 1000 Point αντικείμενα, θα δεσμεύσεις επιπλέον μνήμη για να κάνεις αναφορά (reference) σε κάθε αντικείμενο. Σε αυτήν την περίπτωση, η struct είναι λιγότερο ακριβή.

Είναι λάθος να δηλώνει κανείς έναν constructor χωρίς ορίσματα για μια struct. Αυτός ο default constructor χρησιμοποιείται πάντοτε για να αρχικοποιήσει τις μεταβλητές με τις default τιμές τους.

Είναι λάθος να αρχικοποιήσει κανείς μια μεταβλητή μέσα στην struct.

Όταν κάποιος δημιουργεί ένα αντικείμενο struct χρησιμοποιώντας το new, δημιουργείται και ο κατάληλος constructor καλείται. Σε αντίθεση με τις κλάσεις, οι structs μπορούν να αρχικοποιηθούν και να αποκτήσουν υπόσταση χωρίς το new. Αν δεν χρησιμοποιήσετε το new, τα πεδία θα παραμείνουν ανεκχώρητα (χωρίς τιμή) και το αντικείμενο δεν θα μπορεί να χρησιμοποιηθεί μέχρι όλα τα πεδία να αρχικοποιηθούν.

Παράδειγμα 1

Στο παρακάτω παράδειγμα δείχνεται πως αρχικοποιείται μια struct με τον default και παραμετροποιημένο contructor

// Δήλωση και αρχικοποίηση
public struct Point 
{
   public int x, y;

   public Point(int p1, int p2) 
   {
      x = p1;
      y = p2;    
   }
}

class MainClass 
{
   public static void Main()  
   {
      // Initialize:   
      Point myPoint = new Point();
      Point yourPoint = new Point(10,10);

      // Προβολή αποτελεσμάτων:
      Console.Write("My Point:   ");
      Console.WriteLine("x = {0}, y = {1}", myPoint.x, myPoint.y);
      Console.Write("Your Point: ");
      Console.WriteLine("x = {0}, y = {1}", yourPoint.x, yourPoint.y);
   }
}

Έξοδος:
My Point: x = 0, y = 0 Your Point: x = 10, y = 10

Παράδειγμα 2

Αυτό το παράδειγμα δείχνει μια μοναδική λειτουργία για τις struct. Την δημιουργία αντικειμένου struct χωρίς το new. Αν αντικαταστήσετε το struct με class δεν θα γίνει compile.

public struct Point 
{
   public int x, y;

   public Point(int x, int y) 
   {
      this.x = x;
      this.y = y; 
   }
}

class MainClass 
{
   public static void Main() 
   {
      // Declare an object:
      Point myPoint;

      // Initialize:
      myPoint.x = 10;
      myPoint.y = 20;

      // Display results:
      Console.WriteLine("My Point:");
      Console.WriteLine("x = {0}, y = {1}", myPoint.x, myPoint.y);
   }
}

Τύποι Enums

Ένας τύπος enum (συχνά και enumaration - απαρίθμηση) παρέχει έναν αποτελεσματικό τρόπο για να ορίσουμε ένα σετ από ονοματισμένες σταθερές που μπορούν να ορίσουν τιμή σε μια μεταβλητή. Για παράδειγμα, υποθέστε πως πρέπει να ορίσετε σταθερές οι οποίες θα αντιπροσωπεύουν κάθε μέρα της βδομάδας. Υπάρχουν μόνο 7 τιμές με το αντίστοιχο νόημα όπου κάθε σταθερά θα πρέπει να αποθηκεύσει. Για να ορίσετε αυτές τις τιμές, μπορείτε να χρησιμοποιήσετε enum ως ακολούθως:

enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

Ως εξ ορισμού, κάθε στοιχείο αντιπροσωπεύεται με τον τύπο int. Μπορείτε να ορίσετε έναν άλλον απαριθμητό τύπο χρησιμοποιώντας άνω και κάτω τελεία. Πχ

enum Months : byte { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec
    };

Τα παρακάτω είναι πλεονεκτήματα των enums έναντι των αριθμητικών τύπων:

• Διευκρινέζετε σαφώς στον κώδικα ποιες τιμές είναι αποδεκτές για μια μεταβλητή
• Στο visual Studio, η InteliSense απαριθμεί τις ορισμένες τιμές

Όταν δεν ορίζει κανείς τιμές για τα στοιχεία της λίστας στο enum, οι τιμές αυξάνουν αυτόματα κατά ένα. Στο προηγούμενο παράδειγμα, το στοιχείο Days.Sunday έχει τιμή 0, Days.Monday τιμή 1 κλπ.

Στο επόμενο παράδειγμα η μεταβλητή meetingDay είναι τύπου Days, οπότε μπορεί να πάρει τιμές που έχουν οριστεί μόνο στο enum Days. Και αν θέλουμε να αλλάξει αυτή η τιμή, μπορούμε να την αλλάξουμε όπως φαίνεται στο παράδειγμα:

Days meetingDay = Days.Monday;
//...
meetingDay = Days.Friday;

Μπορούμε να ορίσουμε τιμές για τα στοιχεία στο enum και να αφήσουμε τις άλλες να υπολογιστούν ή να μπουν αυτόματα

enum MachineState
{
    PowerOff = 0,
    Running = 5,
    Sleeping = 10,
    Hibernating = Sleeping + 5
}

Επίσης μπορούμε να ορίσουμε μια τιμή σε σταθερά με αυτές που ακολουθούν να παίρνουν πάντα την προηγούμενη τιμή +1

enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

Arrays & Collections

Περιγραφή

Σε αυτά τα tutorials θα δούμε πίνακες και διάφορα collections που μπορούμε να χρησιμοποιήσουμε στην C#, όπως

• Arrays
• ArrayList
• Dictionary
• List
• Queue
• Stack

Array – Πίνακας

 Τι είναι:

 Ο πίνακας είναι μια στατική δομή δεδομένων που μας επιτρέπει να αποθηκεύσουμε μέσα του δεδομένα του ίδιου τύπου. Οι πίνακες εμφανίζονται με δύο συνηθέστερες μορφές. Πίνακας μονοδιάστατος και δισδιάστατος.

Μονοδιάστατος πίνακας:

Η δήλωση ενός μονοδιάστατου πίνακα γίνετε με δύο τρόπους ως εξής:

int[] intArray = new int[20];

int[] intArray = new int[] {1,2,3,4,5};

 Στο πρώτο παράδειγμα δηλώνουμε έναν κενό πίνακα ακεραίων 20 θέσεων, ενώ με το δεύτερο παράδειγμα δηλώνουμε έναν πίνακα ακεραίων με τους αριθμούς 1,2,3,4,5 τα οποία εκχωρούνται στις θέσεις 0,1,2,3,4 αντίστοιχα μιας και η αρίθμηση των θέσεων του πίνακα ξεκινάει από το μηδέν. Επίσης στο δεύτερο παράδειγμα δεν έχουμε δηλώσει το μέγεθος γιατί το μέγεθος σε αυτή την περίπτωση υπολογίζεται κατευθείαν από τον αριθμό των παραμέτρων που έχουμε δώσει.

Δισδιάστατος πίνακας:

Για να δηλώσουμε έναν δισδιάστατο πίνακα κάνουμε τα εξής:

int[,] twodim = new int[3,4];

Έτσι δημιουργήσαμε έναν κενό πίνακα με 3 γραμμές και 4 στήλες.

Ή μπορούμε να τον αρχικοποιήσουμε με συγκεκριμένες τιμές.

int[,] twodim = new int[,]
{

  {1,2,3,4}  //Πρώτη γραμμή

  {5,6,7,8}  //Δεύτερη γραμμή

  {9,10,11,12} //Τρίτη γραμμή

};

 Σε γραφική απεικόνιση ο πίνακάς μας θα έχει την εξής μορφή.

Indexing

 Η αρίθμηση των θέσεων του πίνακα όπως αναφέραμε και πριν ξεκινάει από το μηδέν. Έτσι για να χρησιμοποιήσουμε ένα στοιχείο που βρίσκεται στην δεύτερη θέση του πίνακα αναφερόμαστε σε αυτό ως Πίνακας[1] κλπ.

int[,] twodim = new int[,]
{

  {1,2,3,4}  //Πρώτη γραμμή

  {5,6,7,8}  //Δεύτερη γραμμή

  {9,10,11,12} //Τρίτη γραμμή

};

Με τον ίδιο τρόπο χρησιμοποιούμε την αρίθμηση για να γεμίσουμε έναν πίνακα.

int[] array = new int[5];

array[0] = 1;

array[1] = 2;

array[2] = 3;

Ο πίνακας είναι μία στατική δομή δεδομένων και έχει σταθερό μέγεθος. Αν ο πίνακας που έχετε στην διάθεσή σας έχει 5 θέσεις και εσείς προσπαθήσετε να εισάγετε ή να διαβάσετε δεδομένα με την εντολή Πίνακας[5] το πρόγραμμα θα σας ειδοποιήσει όταν το "τρέξετε" ότι αντιμετώπισε exception καθώς η αρίθμηση ξεκινάει από το μηδέν οπότε η εντολή Πίνακας[5] δείχνει στην έκτη θέση του πίνακα η οποία δεν υπάρχει.

Επιπλέον δυνατότητες:

Ο πίνακας περιέχει τις ιδιότητες Length και LongLength οι οποίες μας δείχνουν το μέγεθος του πίνακα με 32 bit και 64 bit αντίστοιχα και την ιδιότητα Rank που μας λέει πόσες διαστάσεις έχει ο πίνακας.

int[] array = new int[]{1,2,3,4,5};

int number = array[1];

int anotherNumber = array[4];

Console.WriteLine(array.Length);

Console.WriteLine(array.Rank);

/*

5

1

*/

ArrayList

ArrayList myCollection = new ArrayList();

ArrayList myCollection = new ArrayList(5);

string[] nameArray = new string[] { "Κώστας", "Μαρία", "Γιάννης" };

ArrayList nameCollection = new ArrayList(nameArray);

string[] nameArray = new string[] { "Kwstas", "Maria", "Giannhs" };
ArrayList nameCollection = new ArrayList(nameArray);
Console.WriteLine(nameCollection[0]);
Console.WriteLine(nameCollection[1]);
Console.WriteLine(nameCollection[2]);

/* Output
Kwstas
 
Maria
 
Giannhs
*/

ArrayList myCollection = ArrayList.Repeat("Item",5);

ArrayList Items= ArrayList.Repeat("Item",3);

ArrayList extraItems = ArrayList.Repeat("Extra",2);

Items.AddRange(extraItems);

ArrayList Items= ArrayList.Repeat("Item",3);

ArrayList extraItems = ArrayList.Repeat("Extra",2);

Items.InsertRange(1,extraItems);

ArrayList items= ArrayList.Repeat("Item",5);

// Ξεκινώντας από την πρώτη θέση αφαίρεσε 3 στοιχεία

items.RemoveRange(0,3);

string[] array = new string[] { "One", "Two", "Find Me"};

ArrayList myCollection = new ArrayList(array);

int location1 = myCollection.IndexOf("Find Me", 0);

Console.WriteLine(location1);

/* Output
 
2

*/           

string[] array = new string[] { "One", "Two", "Three" };

ArrayList myCollection = new ArrayList(array);

// Sort items

myCollection.Sort();

Console.WriteLine(myCollection[0]);

Console.WriteLine(myCollection[1]);

Console.WriteLine(myCollection[2]);

/* Output

One

Three

Two

*/

ArrayList myCollection = new ArrayList();

myCollection.Add("One");

myCollection.Add("Two");

myCollection.Add("Three");

myCollection.Add("Four");

myCollection.Add("Five");

int capacity = myCollection.Capacity;

Console.WriteLine("Initial capacity is {0} items", capacity);

myCollection.TrimToSize();

capacity = myCollection.Capacity;

Console.WriteLine("New capacity is {0} items", capacity);

/* Output

Initial capacity is 8 items

New capacity is 5 items

*/

List<string> list = new List<string>();

List<string> list = new List<string>(10);

List<string> list = new List<string>();

list.Add("Kwstas");

list.Add("Dimitris");

string name1 = list[0];

string name2 = list[1];

Console.WriteLine(name1);

Console.WriteLine(name2);

/*
 
Kwstas
 
Dimitris
 
*/

List<string> list = new List<string>();

list.Add("Kwstas");

list.Add("Dimitris");

list[1] = "John";

string name1 = list[0];

string name2 = list[1];

Console.WriteLine(name1);

Console.WriteLine(name2);

/*
 
Kwstas

John

*/

Queue q = new Queue();

Queue<string> q = new Queue<string>();

Queue q = new Queue(10);

Queue q = new Queue(10, 1.5F);

ArrayList al = new Arraylist();

al.Add(“string 1”);

al.Add(“string 2”);

Queue q = new Queue(al);

Queue q = new Queue();

//Eisagwgi

q.Enqueue("Kwstas");

q.Enqueue("Giannhs");

//Eksagwgi

string name1 = q.Dequeue().ToString(); // name1 = Kwstas

string name2 = q.Dequeue().ToString(); // name2 = Giannhs

Console.WriteLine(name1);

Console.WriteLine(name2);

/*
 
Κwstas
 
Giannhs
 
*/

Queue q = new Queue();

q.Enqueue("Kwstas");

q.Enqueue("Giannhs");

int num = q.Count;

Console.WriteLine(num);

string name  = q.Peek().ToString();

Console.WriteLine(name);

int num2 = q.Count;

Console.WriteLine(num2);

q.Clear();

int num3 = q.Count;

Console.WriteLine(num3);

Console.WriteLine(q.Contains("Kwstas"));

Console.WriteLine(q.Contains("Maria"));

/* Output

2

Kwstas

2

0

False

False

*/

Stack st = new Stack();

Stack<string> q = new Stack<string>();

Stack st = new Stack(10);

ArrayList al = new Arraylist();

al.Add(“string 1”);

al.Add(“string 2”);

Stack st = new Stack(al);

Stack st = new Stack(al);

//Eisagwgi

st.Push(“Kwstas”);

st.Push (“Giannhs”); 

//Eksagwgi

string name1 = st.Pop(); // name1 = Kwstas

string name2 = st.Pop(); // name2 = Giannhs

Stack st = new Stack();

st.Push("Kwstas");

st.Push ("Giannhs");

Console.WriteLine(st.Count);

Console.WriteLine(st.Peek().ToString());

Console.WriteLine(st.Count);

Console.WriteLine(st.Contains("Kwstas"));

Console.WriteLine(st.Contains("Maria"));

st.Clear();

Console.WriteLine(st.Count);

/* Output

2

Giannhs

2

True

False

0

*/

Dictionary<int, string> dict = new Dictionary<int, string>();

Dictionary<int, string> dict = new Dictionary<int, string>(20);

Dictionary<int, string> dict = new Dictionary<int, string>();

dict.Add(1, "Kwstas");// 1 = key, “Kwstas” = value

dict.Add(2, "Maria");

string x = dict[1];

string y = dict[2];

Console.WriteLine(x);

Console.WriteLine(y);

/* Output

Kwstas

Maria

*/

Dictionary<int, string> dict = new Dictionary<int, string>();

dict.Add(1, "Kwstas");// 1 = key, “Kwstas” = value

dict.Add(2, "Maria");

List<int> list1 = new List<int>(dict.Keys);

List<string> list2 = new List<string>(dict.Values);

Console.WriteLine(list1[0]);

Console.WriteLine(list2[1]);

Console.WriteLine(dict.Count);

bool a = dict.ContainsKey(1);

bool b = dict.ContainsValue("Giannhs");

Console.WriteLine(a);

Console.WriteLine(b);

/* Output

1

Maria

2

True

False

*/

Περιγραφή

Σε αυτά τα tutorials θα δούμε τις δομές επανάληψης for, while, do-while και foreach όπως αυτά συντάσσονται και χρησιμοποιούνται στην C#.

For

Η for είναι η πιο συνηθισμένη δομή επανάληψης. Χρησιμοποιείτε μόνο όταν ξέρουμε τον αριθμό των επαναλήψεων που θα γίνουν μιας και μέρος της σύνταξής της είναι ο αριθμός των επαναλήψεων. Η for συντάσσεται ως εξής:

for  ( αρχικοποίηση; συνθήκη; επανάληψη )

{

      εντολές

}

Στο κομμάτι της αρχικοποίησης ορίζουμε μία μεταβλητή συνήθως ακέραια που δηλώνει από που θα αρχίσει η for να μετράει επαναλήψεις.Στο επόμενο κομμάτι έχουμε την συνθήκη της επανάληψης. Αυτό το κομμάτι είναι Boolean δηλαδή επιστρέφει πάντα true ή false.  Όσο η συνθήκη είναι true οι επαναλήψεις συνεχίζονται, σταματάνε όταν επιστραφεί η τιμή false. Το τελευταίο κομμάτι είναι αυτό της επανάληψης εκεί ορίζουμε μία εντολή που γίνετε κάθε φορά που τελειώνει μία επανάληψη.  Παράδειγμα:

int i;

string numbers = "";

for (i = 1; i <= 5; i++)

{
     numbers += i.ToString();
}

Console.WriteLine(numbers);

/* Output
 
12345
 
*/

Στο παράδειγμα αρχικοποιούμε το i = 1, ορίζουμε την συνθήκη i <= 5 που σημαίνει ότι οι επαναλήψεις θα συνεχίσουν μέχρι το i να γίνει 5 και τέλος ορίσαμε το i++ ώστε σε κάθε επανάληψη να αυξάνεται κατά 1. Πέρα από την απλή αυτή χρήση με την for μπορούμε   επίσης να διαβάσουμε και να εισάγουμε δεδομένα σε πίνακες . Παράδειγμα:

int[] array = new int[5];
int i;
int j;
string numbers="";
for (i = 0; i <= array.Length - 1; i++)
{
    array[i] = i;
    Console.WriteLine(array[i]);
}

for (j = 0; j <= array.Length-1; j++)
{
    numbers += array[j];
}

Console.WriteLine(numbers);

/* Output
 
0
 
1

2

3

4

01234

*/

Εμφωλευμένα for:

Υπάρχει η δυνατότητα να έχουμε μία δομή for μέσα σε μία άλλη δομή for. Αυτό συνήθως το κάνουμε να προσπελάσουμε πίνακες με παραπάνω από μία διάσταση. Παράδειγμα: 

int[,] table = new int[13, 13];

// Outer loop

for (int row = 0; row <= 12; row++)
{
    // Inner loop
    for (int col = 0; col <= 12; col++)
    {
        table[row, col] = row * col;
    }
}

Break - Continue:

Στις δομές επανάληψης μπορούμε να χρησιμοποιήσουμε τις δεσμευμένες λέξεις break και continue όπως εξηγούνται σε προηγούμενο tutorial. Παράδειγμα:

string[] items = new string[] { "A", "B", "C", "D", "E", "F", "G", "H" };
int pos;

for (pos = 0; pos <= items.Length; pos++)
{

   if (items[pos] == "C")
   {
      break;
   }
}
Console.WriteLine("C is at position {0}", pos); 

/* Output

C is at position 2

*/

Σε αυτό το παράδειγμα ψάχνουμε την τιμή C μέσα στον πίνακα. Όταν βρούμε την τιμή αυτή δεν έχει νόημα να συνεχίσει η for. Έτσι βάζουμε το break για να σταματήσει και να συνεχίσει η ροή του προγράμματος.

Στο επόμενο παράδειγμα θα δούμε την χρήση του keyword continue.

for (int i = 0; i <= 100; i++)
{
   if ((i % 2) == 0) continue;
   Console.WriteLine(i);
}

/* Output

Perittoi arithmoi apo to 0 mexri to 100

*/

Καθώς γίνονται οι επαναλήψεις με το if ελέγχουμε αν ο αριθμός είναι περιττός ή άρτιος. Αν είναι άρτιος εκτελείτε το continue και προχωράει η επανάληψη χωρίς να εκτελεστεί το Console.WriteLine(i); από την στιγμή που θέλουμε μόνο τους περιττούς αριθμούς.

Foreach

Είναι συχνά απαραίτητο να κάνουμε επαναλήψεις με βάση τα περιεχόμενα μιάς συλλογής ή ενός πίνακα και όχι με βάση των αριθμό των θέσεων. Αυτό ακριβώς κάνει η foreach. Η σύνταξης της είναι:

foreach ( τύπος μεταβλητή in συλλογή/πίνακας )

{

       εντολές

}

Όταν ξεκινάει η επανάληψη η μεταβλητή παίρνει την τιμή που υπάρχει στην πρώτη θέση του πίνακα. Σε κάθε επανάληψη συνεχίζει να παίρνει τις υπόλοιπες τιμές με την σειρά. Ο τύπος της μεταβλητής είναι πολύ σημαντικός στην foreach καθώς αν δεν ταιριάζει με τον τύπο των στοιχείων του πίνακα θα εμφανιστεί exception. Για παράδειγμα αν τα στοιχεία του πίνακα είναι τύπου int πρέπει και ο τύπος στην foreach να είναι int.

int[] values = new int[] { 1, 3, 5, 7, 9, 10, 15, 6, 4, 2 };
int maxValue = int.MinValue;
foreach (int i in values)
{
    if (i > maxValue)
    {
        maxValue = i;
    }
}

Στην foreach μπορούμε να χρησιμοποιήσουμε κανονικά τα keyword break και continue.

Παράδειγμα με break:

string[] items = new string[] { "A", "B", "C", "D", "E", "F", "G", "H" };
int pos = 0;
foreach (string s in items)
{
    pos++;
    if (s == "C")
    {
        Console.WriteLine("C found at position {0}", pos);
        break;
    }
}

/* Output
 
C found at position 3

*/

Παράδειγμα με continue:

int[] values = new int[] { 1, 3, 5, 7, 9, 10, 8, 6, 4, 2 };
//int maxValue = int.MinValue;
foreach (int i in values)
{
    if ((i % 2) == 0)
    {
        continue;
    }
    Console.WriteLine(i);
}

/* Output

1

3

5

7

9

*/

int current = 1;
string output = String.Empty;
// Loop while the value being checked is 1000 or less
while (current <= 1000)
{
    output += current.ToString() + " ";
    current *= 3;
}
Console.WriteLine(output);

/* Output
 
1 3 9 27 81 243 729
 
*/

int current = 1001;
string output = String.Empty;
// Loop while the value being checked is 1000 or less
while (current <= 1000)
{
    output += current.ToString() + " ";
    current *= 3;
}
Console.WriteLine(output);

/* Output
---
*/

int value = 1;
int factorial = 10;
do
{
    value *= factorial;
    factorial--;
} while (factorial > 1);
Console.WriteLine(value);

/* Output

3628800

*/