C# kódok » elmélet

TragetSite

nameless — Sat, 25 Jul 2009 07:41:02 +0000

TragetSite tulajdonságok:

using System;
 
namespace Program
{
    class Radio
    {
        public void TurnOn(bool on)
        {
            if (on)
                Console.WriteLine("Jamming...");
            else
                Console.WriteLine("Quite time...");
        }
    }
 
    class Car
    {
        //max sebesség konstansa
        public const int MaxSpeed = 100;
 
        //Belső állapot adatok
        private int currSpeed;
        private string petName;
 
        //az autó még mindig működőképes?
        private bool CarIsDead;
 
        //Az autónak van egy rádiója
        private Radio theMusicBox = new Radio();
 
        //Konstruktorok
        public Car() { }
        public Car(string name, int currSp)
        {
            currSpeed = currSp;
            petName = name;
        }
 
        //Rádió be?
        public void CrankTunes(bool state)
        {
            theMusicBox.TurnOn(state);
        }
 
        //Kivételt jelez, hogyha a felhasználó a MaxSpeed értéke fölé gyorsítja za autót.
        public void Accelerate(int delta)
        {
            if (CarIsDead)
                Console.WriteLine("{0} is out of order...", petName);
            else
            {
                currSpeed += delta;
                if (currSpeed > MaxSpeed)
                {
                    CarIsDead = true;
                    currSpeed = 0;
 
                    //Kivétel kiváltása a throw segítségével
                    throw new Exception(string.Format("{0} has overheated!",petName));
                }
                else
                    Console.WriteLine("=> CurrSpeed = {0}", currSpeed);
            }
        }
 
    }
 
    class MainClass
    {
        public static void Main()
        {
            Console.WriteLine("*****Simple Exception Example*****");
            Console.WriteLine("=> Creating a car and steppong on it!");
            var myCar = new Car("David", 20); //zippy a neve és jelenleg 20-szal megyünk
            myCar.CrankTunes(true); //rádió bekapcsolva
 
            try
            {
                for (int i = 0; i < 10; i++)
                    myCar.Accelerate(10); //10-zel nő a sebesség addig, amíg elnem éri a 100-at, utána felrobban
            }
            catch (Exception ex)
            {
                Console.WriteLine("*** Error! ***");
 
               //***************************************
                 Console.WriteLine("Method: {0}", ex.TargetSite);
                Console.WriteLine("Class defining member: {0}",ex.TargetSite.DeclaringType);
                Console.WriteLine("Member type: {0}", ex.TargetSite.MemberType);
               //****************************************        
 
                Console.WriteLine("Message: {0}", ex.Message);
                Console.WriteLine("Source: {0}", ex.Source);
            }
 
            //A hibát kezeltük, a program FOLYTATÓDIK
            Console.WriteLine("\n***** Out of Exception logic *****");
            Console.ReadKey();
        }
    }
 
}

Felüldefiniálások

nameless — Thu, 23 Jul 2009 20:40:16 +0000

ToString() Equals() GetHashCode() felüldefiniálása:

using System;
 
namespace Program
{
    class Person
    {
        public string fName;
        public string lName;
        public sbyte personAge;
 
        public Person(string firstName, string lastName, byte age)
        {
            fName = firstName;
            lName = lastName;
            personAge = (sbyte)age;
        }
        public Person() { }
 
        //fölülírjuk a ToStringet
        public override string ToString()
        {
            string myState;
            myState = String.Format("[First Name: {0}; Last Name: {1}; Age: {2}]", fName, lName, personAge);
            return myState;
        }
 
        //felüldefiniáljuk az Equalst
        public override bool Equals(object obj)
        {
            if (obj is Person && obj != null)
            {
                Person temp;
                temp = (Person)obj;
                if (temp.fName == this.fName && temp.lName == this.lName && temp.personAge == this.personAge)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return false;
        }
        //visszaadja a ToString() érték alapján kiszámított hashértéket.
        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
    }
 
    class EntryPoint
    {
        public static void Main()
        {
            //Az Equals() és a GetHashCode() teszteléséhez
            //ezeknek egyezniük kell.
            var p1 = new Person("Homer", "Simpson", 50);
            var p2 = new Person("Homer", "Simpson", 50);
 
            //Az objektum szöveges verziójának beolvasása
            Console.WriteLine("p1.ToString() {0}",p1.ToString());
            Console.WriteLine("p2.ToString() {0}", p2.ToString());
 
            //a felülbírált Equals() tesztelése
            Console.WriteLine("p1 = p2?: {0}", p1.Equals(p2));
 
            //a hashérték tesztelése.
            Console.WriteLine("Same hash codes?: {0}", p1.GetHashCode() == p2.GetHashCode());
            Console.WriteLine();
 
            //A p2 korának módosítása, és ismételt tesztelése.
            p2.personAge = 45;
            Console.WriteLine("p1.ToString() {0}", p1.ToString());
            Console.WriteLine("p2.ToString() {0}", p2.ToString());
            Console.WriteLine("p1 = p2?: {0}", p1.Equals(p2));
            Console.WriteLine("Same hash codes?: {0}", p1.GetHashCode() == p2.GetHashCode());
            Console.WriteLine();
 
 
            Console.ReadKey();
        }
    }
}

Részleges típusok

nameless — Thu, 16 Jul 2009 20:01:09 +0000

Részleges típusok (partial, parciális osztályok):

A partial lehetővé teszi, hogy több .cs fájlban is meghatározzuk a típust.

partial class Employee
{
   //Konstruktorok.
   ...
   //Tulajdonságok.
 
}

A privát adatmezők és típusmetódusok a kezdeti employee.cs lesznek meghatározva:

using System;
 
partial class Employee
{
    //Mezőadatok
    private string empName;
    private int empID;
    private float currPay;
    private int empAge;
    private string empSSN;
    private static string companyName;
 
    public void GiveBonus(float amount)
    {
        currPay += amount;
    }
 
    public void DisplyaStats()
    {
        Console.WriteLine("Name: {0}",empName);
        Console.WriteLine("ID: {0}",empID);
        Console.WriteLine("Age: {0}",empAge);
        Console.WriteLine("SSN: {0}", empSSN);
        Console.WriteLine("Pay: {0}", currPay);
    }
}

Az egyetlen követelmény a részleges típusok meghatározásakor az, hogy a típus neve ugyan az legyen, és ugyanazon a .NET névteren

belül határozódjon meg.

Objektum Orientált Programozás (kód elmélet)

nameless — Thu, 16 Jul 2009 07:31:47 +0000

Objektum Orientált Programozás (kód elmélet):

using System;
 
namespace Program
{
    sealed class Radio
    {
        public void Power(bool turnOn)
        {
            Console.WriteLine("Radio on: {0}", turnOn);
        }
    }
 
    class Car
    {
        // az autónak van egy rádiója
        private Radio myRadio = new Radio();
 
        public void TurnOnRadio(bool onOff)
        {
            //Hívás továbbítása a belső objektumnak
            myRadio.Power(onOff);
        }
    }
 
    class MainClass
    {
        public static void Main()
        {
            //A hívás belső továbbítása a Radio osztáklynak
            Car viper = new Car();
            viper.TurnOnRadio(true);
 
            Console.ReadKey();
        }
    }
}

A Rádiót külön osztályba soroljuk, mert semmi köze sincs az autóhoz, csak annyi, hogy benne van…

Most írunk egy olyan programot, ami lemodellezi egy dolgos dolgozó munkáját:
Először hozzunk létre egy új alkalmazást EmployeeApp néven, és szúrjunk be egy új osztályt a Project -> Add class menüelemmel.
Módosítsuk az Employee osztályt a következő mezőkkel, metódusokkal és konstruktorokkal:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace EmployeeApp
{
    class Employee
    {
        //mezőadatok
        private string empName;
        private int empID;
        private float currPay;
 
 
        //lekérdező get metódus
        public string GetName()
        {
            return empName;
        }
 
        //Módosító set metódus
        public void SetName(string name)
        {
            empName = name;
        }
 
        //Konstruktorok
        public Employee() { }
        public Employee(string name, int id, float pay)
        {
            empName = name;
            empID = id;
            currPay = pay;
        }
 
        public void GiveBonus(float amount)
        {
            currPay += amount;
        }
        public void DisplayStats()
        {
            Console.WriteLine("Name: {0}",empName);
            Console.WriteLine("ID: {0}", empID);
            Console.WriteLine("Pay: {0}", currPay);
        }
 
    }
}

Main() rész:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace EmployeeApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee("Marvin", 436, 3000);
            emp.GiveBonus(1000);
            emp.DisplayStats();
 
            //munka az objektum nevével a get/set módosítók segítségével
            emp.SetName("Marv");
            Console.WriteLine("Employee is named: {0}", emp.GetName());
 
            Console.ReadKey();
        }
    }
}

A projekt letöltése

Egységbe zárás propertykkel: (property, tulajdonságok, set, get)

Main rész:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace EmployeeApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee("Marvin", 436, 3000);
            emp.GiveBonus(1000);
            emp.DisplayStats();
 
            //a Name tulajdonságok beolvasása és beállítása
            emp.Name = "Marv";
            Console.WriteLine("Employee is named: {0}", emp.Name);
 
            Console.ReadKey();
        }
    }
}

A hozzáadott osztály:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace EmployeeApp
{
    class Employee
    {
        //mezőadatok
        private string empName;
        private int empID;
        private float currPay;
 
 
        //tulajdonságok
        public string Name
        {
            get { return empName; }
            set { empName = value; }
        }
 
        public float pay
        {
            get { return currPay; }
            set { currPay = value; }
        }
 
        //Konstruktorok
        public Employee() { }
        public Employee(string name, int id, float pay)
        {
            empName = name;
            empID = id;
            currPay = pay;
        }
 
        public void GiveBonus(float amount)
        {
            currPay += amount;
        }
        public void DisplayStats()
        {
            Console.WriteLine("Name: {0}",empName);
            Console.WriteLine("ID: {0}", empID);
            Console.WriteLine("Pay: {0}", currPay);
        }
 
    }
}

Statikus tulajdonságok, statikus probertyk:

using System;
 
namespace Program
{
    class MainClass
    {
        public static void Main()
        {
            WebSite.WebName = "www.csharpkodok.atw.hu";
            Console.WriteLine(WebSite.WebName);
 
            Console.ReadKey();
        }
    }
 
    class WebSite
    {
        //statikus tulajdonsághoz a mezőnek is statikusnak kell lennie...
        private static string WebsiteName;
        public static string WebName
        {
            get { return WebsiteName; }
            set { WebsiteName = value; }
        }
    }
}

Interfész (elmélet)

nameless — Wed, 15 Jul 2009 20:42:03 +0000

Interfész, interface (elmélet):

Vannak az emberek és az állatok, na meg a szamarak. Fingani mindegyik tud, magyarul egy ilyen felületet mindegyik megvalósít:

public interface IFarter
{
  bool DoFart();
 
  event EventHandler ShitFlowingInMyLeg;
}
 
public class ShitFlowingOnMyLegEventArgs : EventArgs
{
  public ShitFlowingOnMyLegEventArgs(bool leftLeg, double ammountInKilogramms)
  {
    this.LeftLeg = leftLEg;
    this.AmmountInKilogramms = ammountInKilogramms;
  }
 
  public bool LeftLeg { get; private set; }
 
  public double AmmountInKilogramms { get; private set; }
}

A DoFart metódussal meg lehet kérni a delikvenst, hogy ugyan, fingjon már egyet. Ha tud, akkor megereszt egy komolyabb lepkét, és visszatér ‘true’-val, ha nem, akkor csak elvörösödik a feje, bef0s1k, erről egy eseménykezelőn keresztül tájékoztatja a külvilágot, és a visszatérési érték ‘false’.

A felület csak azt írja le, hogy ez a viselkedés hogy fog látszani, és hogyan kezelhető a külvilág számára. Absztrakt fogalom, nem tudjuk, hogy a fingásra képes élőlények hogyan finganak, de azt tudjuk, hogyan kell kezelni a helyzetet. Comprende?

Nézzük tovább:

public abstract Animal : IFarter
{
  abstract bool DoFart();
 
  event EventHandler ShitFlowingOnMyLeg;
}

Az állat absztrakt osztályfogalom, mert ebből fog származni minden konkrét állatfaj, de itt már jelezhetjük a felület megvalósíátást (és megvalósíthatjuk absztrakt módon), mert akinek bele van, az fingani is fog. Ebből az osztályból lehet származtatni a szamarat, és a legnagyobb állatot az embert. Mindegyik ismerni fogja az IFarter felületet. De akkor mire jó a felület, miért nem elég csak az absztrakt ős?
Mit tud egy fingópárna? Na? Bingó: fingani, mint a gép! (Maximum nem fo…kakilja le a lába szárát, de az eseményt nem kötelező meghívni):

public sealed class FartPillow : IFarter
{
  public bool DoFart()
  {
    // Itt implementalja a belso f1ng0mechanizmust
  }
 
  event EventHandler ShitFlowingInMyLeg;
  // ezzel meg nem foglalkozik, bar az uj modellek csodakra lehetnek kepesek
}

Anélkül, hogy az állatoknak és egy teljesen más alapokon nyugvó fingó párnak közös őstől kellett volna származtatni, tudunk belőlük kezelni egy egységes, nagy és összetartó fingó közösséget, akinek minden tagja eregeti a buborékot, de nagyon durván. Ezeket be tudjuk állítani egy sorba:

List faterList = new List();

Bele tudjuk dobni egy gödörbe:

Stack farterStack = new Stack();

Mind a gödör, mind a sor megvalósítja az IEnumaerable felületet, amin keresztül tudjuk iterálni a benne lévő elemeket, és a benne lévő elemek megvalósítják az IFarter feleületet, szóval tudnak fingani, ezért:

foreach (IFarter farter in faterList) // IEnumerable-t hasznal a foreach!
{
  farter.DoFart();
}
 
foreach (IFarter farter in faterStack)
{
  farter.DoFart();
}

Hála a interfészeknek van egységes felület, amin a hasonló viselkedéssel, de teljesen más megvalósítással rendelkező objektumokat képesek vagyunk azonos módon (mindenféle cast-elések nélkül) kezelni.

Durván ennyi.

írta: Chikk