1.1. fejezet, Alapok

Beküldte pzoli - 2013, június 11 - 5:26du

Alap típusok

C# típus .NET típus Méret (byte) Leírás
byte System.Byte 1 előjel nélküli 8 bites egész szám (0..255)
char System.Char 2 egy Unicode karakter
bool System.Boolean 1 Logikai típus, értéke igaz(1 vagy true) vagy hamis(0
vagy false)
sbyte System.SByte 1 Előjeles, 8 bites egész szám (-128..127)
short System.Int16 2 Előjeles, 16 bites egész szám (-32768..32767)
ushort System.Uint16 2 Előjel nélküli, 16 bites egész szám (0..65535)
int System.Int32 4 Előjeles, 32 bites egész szám (–2147483648..
2147483647).
uint System.Uint32 4 Előjel nélküli, 32 bites egész szám (0..4294967295)
float System.Single 4 Egyszeres pontosságú lebegőpontos szám
double System.Double 8 Kétszeres pontosságú lebegőpontos szám
decimal System.Decimal 16 Fix pontosságú 28+1 jegyű szám
long System.Int64 8 Előjeles, 64 bites egész szám
ulong System.Uint64 8 Előjel nélküli, 64 bites egész szám
string System.String N/A Unicode karakterlánc
object System.Object N/A Általános ősosztály

Operátorok

precedencia példa leírás
1 (a+b)*c, a.x, a.getX(), b++, b--, new MyClass(), typeof(a), sizeof(i), byte y = unchecked((byte)x); byte y = checked((byte)x); Zárójel, mező hozzáférés ("." operátor), metódushívás, postfix inkrementáló és dekrementáló operátorok, a new operátor, typeof, sizeof, checked és unchecked típuskonverziók
2 (x = -5), !b, ++b, --b, int c = (int) b Pozitív és negatív operátorok, logikai és bináris tagadás, prefix inkrementáló és dekrementáló operátorok, explicit típuskonverzió
3 a*b, a/b, a%b Szorzás, maradékos és maradék nélküli osztás
4 a+b, a-b Összeadás, kivonás
5 x<<1, y>>2 Bit-eltoló operátorok
6 a<=b, a>=b Kisebb (vagy egyenlő), nagyobb (vagy egyenlő), as, is
7 a==b, a!=b Egyenlő és nem egyenlő operátorok
8 a&&b Logikai ÉS
9 a^b Logikai XOR
10 a||b Logikai VAGY
11 a&b Feltételes ÉS (mindkét oldal kiértékelődik!)
12 a|b Feltételes VAGY (mindkét oldal kiértékelődik!)
13 a==b?true:false Feltételes operátor
14 a=b, a+=b, a-=b, a*=b, a/=b, a^=b Értékadó operátor és a rövid formájú, matematikával kombinált változatuk

Üres érték

MyClass mc = null;
int? x = null; //nullable típus deklarálása
int y = (int)x; //explicit konverzió szükséges

Dinamikus típus (DLR)

dynamic x = 8;
x = "nyolc";

Ne használjuk Object helyett!

Konstansok

const int x = int.Parse(Console.ReadLine());
const int x = 8;

Felsorolt típus (enum)

enum Animal { Cat, Dog, Mouse, Wolf };
Animal animal = Animal.Dog;

Tömbök

Egyszerű tömbök:

char[] charArray = new char[] { 'a', 'b', 'c', 'd' };
readonly char[] separator = {' '};
 
int[] array = new int[10];
Random r = new Random();
for (int i = 0; i < array.Length; ++i)
{
    array[i] = r.Next(0, 100);
}
foreach (int item in array)
{
    Console.WriteLine(item);
}
Console.ReadKey();

Több dimenziós tömbök:

int[,] matrix = new int[,]
{
{12, 23, 2},
{13, 67, 52},
{45, 55, 1}
};

Struktúrák

Egyszerű srtuktúrák:

struct Test
{
    int x;
    int y;
}

Struktúra konstruktorral:

struct Test
{
    int x;
    int y;
    public Test(int x, int y)
    {
        this.y = y;
        this.x = x;
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        Test t1 = new Test(10, 11);
        Test t2 = new Test();
        Test t3 = t2;
        t3.x = 10;
        Console.ReadKey();
    }
}

Összetett struktúrák, get/set és ToString függvényekkel:

namespace Homework4CSBasics
{
    struct Point
    {
        int x;
        public int X
        {
            get { return x; }
            set { x = value; }
        }
        int y;
        public int Y
        {
            get { return y; }
            set { y = value; }
        }
        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
        public override string ToString()
        {
            return "[x = " + x.ToString() + "; y = " + y.ToString() +"]";
        }
    }
    struct Line
    {
        Point a;
        public Point A
        {
            get { return a; }
            set { a = value; }
        }
        Point b;
        public Point B
        {
            get { return b; }
            set { b = value; }
        }
        public override string ToString()
        {
            return "P1 = " + a.ToString() + "; P2 = " + b.ToString();
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Line line = new Line();
            line.A = new Point(10, 10);
            line.B = new Point(20, 20);
            Console.WriteLine(line);
        }
     }
}

A t2 értékként és nem referenciaként került t3-ba. Tehát a t2.x értéke változatlan t3.x módosítása után.

Változók átadása, értékek és referenciák

Érték szerinti átadás:

  • Beépített numerikus
  • Felsorolt (enum)
  • Logikai
  • Karakter
  • Struktúra (struct)

Referencia szerinti átadás:

  • Osztály (class)
  • Interfész (interface)
  • Delegált (delegate)
  • String
  • Minden Object leszármazott

Az érték szerinti átadás megváltoztatható referenciakénti átadásra a metódus paraméter elé írt ref kulcsszóval:

static public void TransformerMethod(ref int item)
{
  item *= item;
}

Globális változók nincsenek.

Konzol alkalmazása

Olvasás/írás konzolról/konzolra

Console.WriteLine(message);
Console.ReadKey();

Vezérlési szerkezetek

If-then-else

if (value == 0)
{
    Console.WriteLine("x értéke 0");
} else if (x % 2 == 1) // Ha x%2 maradéka 1
{
    Console.WriteLine("x páratlan szám");
}
else // Máskülönben
{
    Console.WriteLine("x páratlan szám");
}

switch-case

Console.WriteLine(animal);
switch (animal)
{
    case Animal.cat: Console.WriteLine("miau"); break;
    case Animal.mouse: Console.WriteLine("cin-cin"); goto default;
    case Animal.dog:
    case Animal.wolf:
        Console.WriteLine("grrrr");
        Console.WriteLine("aoouuuu"); break;
    default: Console.WriteLine("csend"); break;
}

For ciklus

for (int i = 0; i < 10; ++i)
{
    Console.WriteLine(i);
}
 
for (;;)
{
  Console.WriteLine("Végtelen ciklus");
}

While

int i = 0;
while (i < 10)
{
  Console.WriteLine("i értéke: {0}", i);
  ++i;
}

do-while

int i = 0;
do
{
    Console.WriteLine("i értéke: {0}", i);
    i++;
} while (i < 10);
 
bool getnext = true;
do
{
    Console.WriteLine("i={0}",i);
    Console.WriteLine("Következő szám? i/n");
    if (Console.ReadKey(true).KeyChar == 'n')
        getnext = false;
    else
        i++;
} while (getnext);

foreach

string str = "abcdefghijklmnopqrstuvwxyz";
foreach (char ch in str)
{
    Console.Write(ch);
}

Az IEnumerable és IEnumerator interfészeket megvalósító osztályokat is használhatjuk a foreach iterációnál

yield

static public IEnumerable EnumerableMethod(int max)
{
    for (int i = 0; i < max; ++i)
    {
        yield return i;
    }
}
 
static void Main(string[] args)
{
    int number = int.Parse(args[0]);
    foreach (int idx in EnumerableMethod(number))
    {
        Console.Write(idx);
    }
    Console.ReadKey();
}

Legelső metódushívásnál a ciklus megtesz egy lépést, utána a metódus állapotát megtartva kilép a ciklusból, a következő hívásnál nem újraindul, hanem onnan folytatja, ahol legutóbb kilépett, és IEnumerable interfészt megvalósító objektumot képez le.

Kivételek kezelése

int[] array = new int[2];
try
{
    array[2] = 10;
}
catch (System.IndexOutOfRangeException e)
{
    Console.WriteLine(e.Message);
    throw (new System.IndexOutOfRangeException("Tovább", e));
} finally
{
    Console.WriteLine("Tömb hossza: {0}", array.Length);
}

Osztály deklaráció

using System;
 
namespace Homework4CSBasics
{
    class MyClass
    {
        private int x = 1;
        public int value { get; private set; }
 
        public void add(int value)
        {
            x += value;            
        }
 
        public int getX()
        {
            return x;
        }
 
        public int getY()
        {
            int z = 2 * x;
            return z;
        }
 
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Console.Out.WriteLine("This is a hello world app.");
            MyClass my = new MyClass();
            Console.Out.WriteLine("my.x value: " + my.getX());
            my.add(4);
            Console.Out.WriteLine("my.x new value: " + my.getX());
            Console.Out.WriteLine("calculated double value: {0}", my.getY());
            Console.ReadKey();
        }
    }
}

Absztrakt osztály, virtuális metódus, interfészek

namespace Homework4CSBasics
{
    interface IDog
    {
        void ugat();
    }
 
    interface IAllat
    {
        void eszik();
    }
 
    abstract class AbstractAllat : IAllat
    {
        public abstract void eszik();
    }
 
    class Dog : IDog, IAllat
    {
        public void eszik()
        {
            Console.WriteLine("Habzsi-dőzsi...");
        }
 
        public virtual void ugat()
        {
            Console.WriteLine("Vau - Vau");
        }
    }
 
    class BigDog : Dog
    {
        public override void ugat()
        {
            Console.WriteLine("VAU-VAU");
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Dog d = new Dog();
            IAllat ia = d as IAllat;
            if (d is IDog)
            {
                Console.WriteLine("Az objektum az IDog implementációja");
            }
            d.ugat();
            ia.eszik();
        }
    }
}

Névütközések feloldása:

class Test : IOne, ITwo
{
  void IOne.Method()
  {
    Console.WriteLine("IOne Method!");
  }
    void ITwo.Method()
  {
    Console.WriteLine("ITwo Method!");
  }
}
 
Test t = new Test();
((IOne)t).Method();
ITwo it = t;
it.Method();

Operátorok kiterjesztése

namespace Homework4CSBasics
{
    class MyInt
    {
        public MyInt(int value)
        {
            this.Value = value;
        }
 
        public int Value { get; private set; }
 
        //binary (right-hand-side, left-hand-side)
        static public MyInt operator +(MyInt lhs, MyInt rhs)
        {
            return new MyInt(lhs.Value + rhs.Value);
        }
 
        //unary
        static public MyInt operator ++(MyInt rhs)
        {
            MyInt result = new MyInt(rhs.Value); //slow down
            return ++result;
        }
 
        //relational
        static public bool operator <(MyInt lhs, MyInt rhs)
        {
            return lhs.Value < rhs.Value;
        }
 
        static public bool operator <(MyInt lhs, MyInt rhs)
        {
            return lhs.Value < rhs.Value;
        }
 
        public override string ToString()
        {
            return Value.ToString();
        }
 
        //Convert
        static public implicit operator MyInt(int rhs)
        {
            return new MyInt(rhs);
        }
 
        static public explicit operator MyInt(string rhs)
        {
            return new MyInt(int.Parse(rhs));
        }
/*
        public override bool Equals(object rhs)
        {
            if (!(rhs is MyInt))
            {
                return false;
            }
            return this == (MyInt)rhs;
        }
 
        public override int GetHashCode(object rhs)
        {
            return this.Value << 2;
        }
*/
        static public bool operator ==(MyInt lhs, MyInt rhs)
        {
            return lhs.Value == rhs.Value;
        }
 
        static public bool operator !=(MyInt lhs, MyInt rhs)
        {
            return !(lhs.Value == rhs.Value);
        }
 
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            MyInt x = new MyInt(10);
            MyInt y = new MyInt(20);
            MyInt z = new MyInt(10);
            MyInt result = x + y;
            Console.WriteLine("MyInt (" + x + " + " + y + ") result = " + result);
            Console.WriteLine("MyInt ( x.Equals(z) = " + x.Equals(z).ToString() + "; x == z : " + (x==z).ToString() + ")");
        }
    }
}

Attribútumok

angol nyelvű útmutató