Showing posts with label c#. Show all posts
Showing posts with label c#. Show all posts

Friday, October 5, 2012

Kalıtım Örneği (c#)


Bu örneğimizde temel bir Ev sınıfı oluşturacağız. Oluşturduğumuz temel ev sınıfında tüm evler için kullanılabilinir özellikler olan kat numarası, oda sayısı, alanı, semti gibi özellikler olacak. Temel Ev sınıfından bir KiralıkEv sınıfı türeteceğiz ve bu sınıfımızda sadece kiralik evler için geçerli olan depozito ve kira özelliklerini ekleyeceğiz. Ardından Main metodunun bulunduğu sınıfta nesne örneklerimizi oluşturacağız.


Temel Ev Sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace evsinifi
{
    public class Ev
    {
        private int odasayisi;

        public int Odasayisi
        {
            get { return odasayisi; }
            set { odasayisi = value; }
        }
        private int katno;

        public int Katno
        {
            get { return katno; }
            set { katno = value; }
        }
        private int alan;

        public int Alan
        {
            get { return alan; }
            set { alan = value; }
        }
        private string semt;

        public string Semt
        {
            get { return semt; }
            set { semt = value; }
        }

   

        public string EvGoruntule()
        {
            return string.Format(" Odasayisi: {0} Katno: {1} Alan: {2} Semt: {3}", odasayisi, katno, alan, semt);
        }
    }
}

Ev sınıfından türetilen KiralıkEv sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/*kalitimda türetilen classların namespaceleri aynı olması tek bir referans üzerinden erişmemiz için kolaylık sağlar.*/

namespace kiraliksinifi
{
    public class kiralikev:Ev
    {
        public kiralikev()
        {
        }

        public kiralikev(int odasayisi, int katno, int alan, string semt, double kira) : base(/*boş yerine dolu olabilirdi*/)
        {
           /*yukarıdaki boş base constructori dolu olsaydı tekrardan base ile ataması yapmamıza gerek kalmayacaktı. */
           base.Odasayisi = odasayisi;
           base.Katno = katno;
           base.Alan = alan;
           base.Semt = semt;
           this.kira = kira;
           
        }

        public double kira;
        public double depozito;

        public string EvGoruntule()
        {
            return string.Format(" Odasayisi: {0}, Katno: {1}, Alan: {2}, Semt: {3}, kira: {4}", Odasayisi, Katno, Alan, Semt, kira);
        }
    }
}

Main metodunun bulunduğu ana sınıf:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using evsinifi;
using kiraliksinifi;


namespace Kalitim
{
    class Program
    {
        static void Main(string[] args)
        {
            kiralikev ev1 = new kiralikev();
            ev1.Alan = 120;
            ev1.Katno = 3;
            ev1.Odasayisi = 4;
            ev1.Semt = "bebek";
            ev1.kira = 550;

            Ev ev2 = new Ev();
            ev2.Alan = 120;
            ev2.Katno = 3;
            ev2.Odasayisi = 4;
            ev2.Semt = "Etiler";

            kiralikev ev3 = new kiralikev(3,7,120,"besiktas",430);

            Console.WriteLine(ev1.EvGoruntule());
            Console.WriteLine(ev2.EvGoruntule());
            Console.WriteLine(ev3.EvGoruntule());

           
            Console.ReadLine();
        }
    }
}

Kalıtım (c#)

Temel bir Memeli sınıfı tasarlayacağız. Her memeli hayvan da  bulunan özellikler boy, ağırlık gibi fiziksel özellikler
olabilir. Daha sonra Kedi sınıfını tasarlayacağız. Ancak Kedi sınıfı Memeli sınıfından türeteceğiz. Yani Memeli sınıfının
tüm özelliklerini Kedi sınıfına aktaracağız. Memeli sınıfında boy ve ağırlık bilgilerini gösteren OzelliklerGoster()
isimli bir metot olacak. Kedi sınıfında da hayvanın kedi olduğunu gösteren string türünden bir özellik olacak.
Ayrıca Kedi sınıfında kedinin türünü yazdıracak bir de metot olmalıdır.

Türetme işlemi aşağıdaki gibi yapılır.

class Kedi: Memeli
{


}

burada kedi sınıfından türemiş sınıf(derived class) Memeli ise temel sınıf (base class) olarak adlandırılır. Şimdi bu sınıfların nasıl yazıldığına bakalım.

using system;

class Memeli
{
  puplic double Boy;
  puplic double Agirlik;

  puplic void OzellikGoster()
  {
    console.WriteLine("Boy = " + Boy);
    console.WriteLİne("Ağırlık = " Agirlik);
  }

}


class Kedi:Memeli
{
  puplic string Tur;

  puplic void TurGoster();
  {
   console.writeline("Turu: " + Tur);
  }
}

Class MainMetodu
{
  Private void Main(String [] Args)
  {
   Kedi kedi1 = new Kedi();

   kedi1.Boy= 15;
   kedi1.Agırlık = 4;
   kedi1.Tur = "Van";
 
   kedi1.OzellikGoster();
   kedi1.TurGoster();

   Kedi kedi2 = new Kedi();
   kedi2.Boy= 19;
   kedi2.Agırlık = 8;
   kedi2.Tur = "kara";
 
   kedi2.OzellikGoster();
   kedi2.TurGoster();

   Console.ReadLine();
  }
}

Bu programın ekran çıktısı;

Boy = 15
Agırlık = 4
Turu = Van

Boy =  19
Agırlık = 8
Turu = Kara

şeklinde olacaktır.


Gördüğünüz üzere Kedi sınıfı üzerinden Memeli sınıfına ait bütün özelliklere ve metotlara erişebiliyoruz.
Bunu sağlayan,

class Kedi : Memeli
{
}
satırıdır.

Ancak yazdığımız programda;

Memeli memeli = new Memeli();
memeli.TurGoster();

şeklinde Türeyen sınıftaki metoda erişmemiz mümkün değildir.

Programı derlemeye çalıştığımızda hata mesajı alırız; çünkü memeli nesnesi üzerinden TurGoster() metoduna ulaşamayız.
Yani temel sınıf olarak Memeli sınıfının kendisinden türeyen Kedi sınıfındaki üye elemanlardan haberi yoktur.
Ancak tersi doğru değildir.



Wednesday, October 3, 2012

Singleton Tasarım Örneği (C#)


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Evler
{
    public class Ev
    {
        /*static elemanlar içerisinde static elemanlar çağrılabileceği için static tanımladık. */
       static Ev instance;


       /* dışardan bir müdahale olmaması için private tanımlanan ev türünden instance değerine belirleyici yazmalıyız.*/
        public static Ev Instance
        {
            get
            {
                /* ev sınıfının nesne örneğini geri döndürmek için; */
                return Ev.instance;
            }
        }

        /* yeni sınıf oluşturulmaması için dışardan ulaşılmamak üzere private tanımlanmalı. */
        private Ev()
        {
         

        }

        public void deneme(double alan2)
        {
            this.Alan=alan2;
        }

      /* static constructorlar parametre almazlar ve private olarak tanımlanırlar. */
      /* ev sınıfından nesne kurulmadan çalıştırılması gerektiği için static tanımladık. diğer türlü sınıfı kurmadan
       constructor çağırmamız mümkün olmayacak ve new anahtar sözcüğünü bir kereyle sınırlandırma şansımız 
       olmayacaktı. */
        static Ev()
        {
            /* instance static olarak tanımlandığı için buradaki static metot tarafından çağrılabiliyor. */
            /* instance değişkeni ile Ev sınıfı kurulduğu anda bellekte bir kereye mahsus olmak üzere new anahtar 
             sözcüğü ile Ev sınıfı için yer oluşturuluyor. daha sonra ev sınıfından üretilen nesneler aynı özellikleri 
             taşıyacaktır. */
            instance = new Ev();
        }

        private static int katno;
        private int odasayisi;
        private double alan;
        private string semt;

        public int Katno
        {
            get
            {
                return katno;
            }

            set
            {
                katno = value;
            }
        }

        public int Odasayisi
        {
            get
            {
                return odasayisi;
            }

            set
            {
                odasayisi = value;
            }
        }

        public double Alan
        {
            get
            {
                return alan;
            }

            set
            {
                alan = value;
            }
        }

        public string Semt
        {
            get
            {
                return semt;
            }

            set
            {
                semt = value;
            }
        }

        public String EvBilgileriniGetir()
        {
            return string.Format(" katno: {0} \n odasayisi: {1} \n alan: {2} \n semt: {3}", katno, odasayisi, alan, semt);
        }

    }


ana program;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Evler;

namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        {
            /* ev ilk kurulduğu anda instance sözcüğü new anahtar sözcüğünü işaret edicek bellekte bir kereliğine
             sınıf için yer açılacak. ardından kurulan her nesne örneği aynı referansı temsil edecektir. */
            Ev ev1 = Ev.Instance;

            ev1.Katno = 3;
            ev1.Odasayisi = 2;
            ev1.Semt = "besiktas";

            Ev ev2 = Ev.Instance();
            ev2.deneme(2);
            ev2.Katno = 11;

            /* ev1 veya ev2 yazmamız bir şeyi değiştirmicektir üzerinde çalıştığımız nesne aynıdır. */
            Console.WriteLine(ev1.EvBilgileriniGetir());

            Console.ReadLine();
        }
    }
}

}

Singleton (Tek) Nesneler (C#)


Singleton (Tek) Nesneler

singleton deseni bir programın yaşam süresince belirli olan bir nesneden sadece bir örneğin(instance) olmasını garantiler.
Aynı zamanda bu desen, yaratılan tek nesneye ilgili sınıfın dışından global düzeyde mutlaka erişilmesini hedefler.

Yeni bir nesne oluşturmak için new anahtar sözcüğünün temsil ettiği yapıcı metoduna dışarıdan erişimin olması gerekir.
Yani yapıcı metodun puplic olarak bildirilmiş olması gerekir. Ancak singleton desenine göre belirli bir anda sadece bir
nesne olabileceği için new anahtar sözcüğünün kullanımının yasaklanması gerekir yani yapıcı metotodun protected ya da private
olarak bildirilmesi gerekir.

Eğer bir metodun varsayılan yapıcı metodu puplic olarak bildirilmemiş ise ilgili sınıf türünden herhangi bir nesnenin sınıfın
dışında tanımlanması mümkün değildir.

Bizim istediğimiz yalnızca bir sınıfın yaratılması olduğuna göre bunu ancak statik üye elemanlar ile yapabiliriz.

1. yöntem:

Puplic class Ev
{

   /*static elemanlar içerisinde static elemanlar çağrılabileceği için static tanımladık. */
   private static Ev ornek;
 
   /* dışardan bir müdahale olmaması için private tanımlanan ev türünden instance değerine belirleyici yazmalıyız.*/
   Puplic Static Ev Ornek
   {
     get
     {
      /* ev sınıfının nesne örneğini geri döndürmek için; */   
       return Ev.ornek;
     }
   }

  /* yeni sınıf oluşturulmaması için dışardan ulaşılmamak üzere private tanımlanmalı. */
  Private Ev()
  {

  }


   /* static constructorlar parametre almazlar ve private olarak tanımlanırlar. */
   /* ev sınıfından nesne kurulmadan çalıştırılması gerektiği için static tanımladık. diğer türlü sınıfı kurmadan constructorı
    * çağırmamız mümkün olmucak ve new anahtar sözcüğünü bir kereyle sınırlandırma şansımız olmucaktı. */
   Static Ev()
  {

       /* instance static olarak tanımlandığı için buradaki static metot tarafından çağrılabiliyor. */
       /* instance değişkeni ile Ev sınıfı kurulduğu anda bellekte bir kereye mahsus olmak üzere new anahtar sözcüğü ile
        * Ev sınıfı için yer oluşturuluyor. daha sonra ev sınıfından üretilen nesneler aynı özellikleri taşıyacaktır. */
     ornek= New Ev();
  }


2.yöntem:

Puplic class Ev
{
  private static Ev ornek;

  Private Ev()
  {
  }

 /* nesne üzerinden erişilmesine gerek kalmadan direkt sınıf ile erişilmesi için statik olmak zorunda */
 
  Puplic static Ev Ornek()
  {
   
      if ( nesne == null)
          nesne = new Ev();
   
     return nesne;
    }

 }
    Gördüğümüz üzere nesne ile ilk olarak sınıf belleğe yüklediğinde değilde o nesneyi ilk defa kullanmak istediğimizde
   yaratılıyor. ilgili nesneyi her istediğimizde yeni bir nesnenin yaratılmaması içinde
   if(nesne == null)
   şeklinde bir koşul yazdığımıza dikkat edin.
 
   sınıf yaratmak için Ev evim = Ev.Ornek();

Monday, September 24, 2012

Constructors ve statik metot örneği (c#)


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Evler
{
    public class Ev
    {

        /*constructor*/
        /* başta kendiliğinden kuruluyor */
        public Ev()
        {

        }

        /* nesnenin tüm özellikleri sınıf kurulurken atanıyor*/
        public Ev(int katno, int odasayisi, double alan, string semt)
        {
            this.katno = katno;
            this.odasayisi = odasayisi;
            this.alan = alan;
            this.semt = semt;
        }

        /* sadece semti belli olan nesnelerin kurulumunde tercih edilir */
        public Ev(String semt)
        {
            this.semt = semt;
        }

        /* Static ile oluşturulan constructor, sınıf program içersinde ilk kurulduğu anda bir kereye mahsus oluşturulur. */
        /* Static ile constructor oluşturma kurulan sınıf içersinde dosya yazdırılacağı zaman ilk başta dosyanın oluşturulması gibi
         * adımlarda işimizi kolaylaştırır. */
       
        static Ev()
        {
            Console.WriteLine("ilk ev oluşturuldu");
        }

        /*fields */
        private int katno;
        private int odasayisi;
        private double alan;
        private string semt;

        /* Protected erişim belirleyicisi*/
        public int Katno
        {
            get
            {
                return katno;
            }

            set
            {
                katno = value;
            }
        }

        public int Odasayisi
        {
            get
            {
                return odasayisi;
            }

            set
            {
                odasayisi = value;
            }
        }

        public double Alan
        {
            get
            {
                return alan;
            }

            set
            {
                alan = value;
            }
        }

        public string Semt
        {
            get
            {
                return semt;
            }

            set
            {
                semt = value;
            }
        }


        public String EvBilgileriniGetir()
        {
            return string.Format(" katno: {0} \n odasayisi: {1} \n alan: {2} \n semt: {3}", katno, odasayisi, alan, semt);
        }

        /*Const */
        const double katsayi = 3.44;

        /*Static */
        /*Nesne üzerinden erişilmesine gerek olmayan koşullarda kullanılır, direkt sınıf üzerinden erişilir. */
        public static double KatsayiGonder(double alan)
        {
            return alan * katsayi;
        }
    }
}

Statik Üye Elemanlar (c#)


Statik Üye Elemanlar

c# dilindeki tüm metotlara sınıflar üzerinden erişiriz. Çoğu durumda da erişim için bu sınıflardan nesneler oluştururuz.
Ancak bazı durumlarda metotları kullanmak için nesne oluşturmamız gereksiz olabilir. Bu durumda statik metotlar tanımlanır.
Statik metotlar olabiliceği gibi statik üye değişkenler ve statik yapıcı metotlarda olabilir. Bir üye elemanının statik
olduğunu bidirmek için bildirimden önce static anahtar sözcüğü eklenir.

Statik elemanlar bir sınıfın global düzeydeki elemanlarıdır. Yani statik üyeleri kullanmak için herhangi bir nesne
 tanımlamıza gerek yoktur. Şimdi sırasıyla üye elemanları inceleyelim.



STATİK METOTLAR



Metotlar konusunda Math sınıfının çeşitli metotlarını görmüştük Bu metotları herhangi bir nesne oluşturmadan kullanabildik.
Örneğin bir sayının karekökünü almak için
Math.sqrt(sayi);
ifadesini kullanmamız yeterliydi. Karekök alma işlemi genel bir işlem olduğu için bu tür işleri yapmak için nesne tanımlamamız
çok saçma olurdu. Neyse ki c# dilini tasarlayanlar bunu düşünmüşler. Statik Metotlara sınıf adı ile ulaşılır. Örneğin
aşağıdaki Topla() metodu statik olarak tanımlanmış ve Main() metodu içersinden çağrılmıştır.

class cebir
{
    public static int Topla(params int[] dizi)
    {
        int toplam = 0;
        for (i = 0; i < dizi.Length; i++)
            toplam += dizi[i];
        return toplam;
    }
}

class Anasinif
{
    static void main()
    {
        int i;
        i = cebir.Topla(5, 6, 8);
        Console.Write(i);
    }
}


gördüğümüz gibi Cebir sınıfından herhangi bir nesne tanımlanmadan Topla() metoduna ulaştık.


Peki statik bir metoda nesne üzerinden erişmemiz mümkün mü? Hayır, mümkün değil. Örneğin aşağıdaki c nesnesi üzerinden
Topla() metoduna erişmeye çalışmak hatalıdır.
Cebir c= new cabir();
c.Topla(5,6,8);

Sınıflarımızı tanımlarken nesneler ile doğrudan iş yapmayan metotları statik olarak bildirmemiz gerekir.


Şu ana kadar yaptığımız tüm örneklerde main metodunun statik olarak tanımlamıştık. bunun nedeni main metodunun çalışması
için herhangi bir sınıf nesnesine ihtiyaç duymadan çalışmasını sağlamaktır.

Static anahtar sözcüğünü kullanırken erişim belirleyiciden önce veya sonra koymamız fark yaratmaz.





Bir statik metot içersinden sınıfn diğer statik metotları çağrılabilir. Ancak normal bir üye metot çağrılamaz.
Çünkü normal metotlar nesneler üzerinden işlem yaparlar. dolayısıyla nesnelerin adresleri gizlice metoda this referansı ile
gönderilir. Ancak statik metotlar sınıfın global metotlar olduğu için this referansları yoktur.

aşağıdaki bildirim geçerlidir.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication12
{
    class Program
    {
         static void   Main()
        {
            metot2();
            Console.ReadLine();
        }
        public static void metot1()
        {
         
            Console.WriteLine("metot1");
        }

        public static void metot2()
        {
            metot1();
            Console.WriteLine("metot2");
        }

     
    }
}
// ekrana metot1 metot2 yazar.

eğer metot içerisinden cağırılan metot static değil iste nesne üzerinden çağırılmalıdır.
aşağıdaki örnek gibi;



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication12
{
    class Program
    {
         static void  Main()
        {
            metot2();
            Console.ReadLine();
        }
        public void metot1()
        {
         
            Console.WriteLine("metot1");
        }

        public static void metot2()
        {
            Program c = new Program();
            c.metot1();

            Console.WriteLine("metot2");
        }

     
    }
}
// ekrana metot1 metot2 yazar.





Statik olan bir metot statik olmayan bir metot içersinden çağırabilinir. yani çağırılan metodun statik olması gerekir
aşağıdaki örnekte görebilirsiniz.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace statikler
{
    class Program
    {
         static void   Main()
        {
            Program c = new Program();

             c.metot2();
             Console.ReadLine();
        }
        public static void metot1()
        {
         
            Console.WriteLine("metot1");
        }

        public  void metot2()
        {
            metot1();
            Console.WriteLine("metot2");
        }

     
    }



kısaca statik olarak tanımlanan bir metot herhangi bir metot içersinden nesne oluşturulmadan cağırılabilinir.




STATİK YAPICI METOTLAR



Normal metotlar gibi yapıcı metotlarda statik olabilir. Statik yapıcı metotlar bir sınıfın statik değişkenleri ile ilgili
işlemler yapmada kullanılır. Bir nesne ilk defa yaratıldığında statik üye değişkenini değiştirmek için genellikle statik
yapıcı metotlar tanımlanır. Statik olan bir metot ile statik olmayan bir değişkeni değiştirmek nasıl mümkün değil ise
statik olan yapıcılarda statik olmayan değişkenleri değiştiremez.

Statik metotların bildirilmesi normal metotların bildirim ile aynıdır. Sadece bildirimin başına static sözcüğü eklenir.

aşağıdaki örneği ve çıktısını inceleyelim.

using system
{
 class oyuncu
  {
     puplic oyuncu()
     {
        console.writeline("Statik olmayan yapıcı");
     }
 
     static oyuncu()
     {
        console.writeline("Statik yapıcı");
     }
}

 class Anasınıf
  {
    puplic static void main()
     {
         oyuncu x = new oyuncu();
         oyuncu o = new oyuncu();
         console.readline();
     }
}

Bu programın çıktısı;

Statik yapıcı
Statik olmayan yapıcı
Statik olmayan yapıcı

şeklindedir.

Görüldüğü gibi o nesnesi oluşturulduğunda hem statik yapıcı metot hem de statik olmayan metot çağrılmıştır(önce statik yapıcı
metot çağrılmış). Ancak x nesnesi oluşturulduğunda sadece statik olmayan metot çağrılmıştır.

Statik yapıcı metotlar herhangi bir parametre almazlar. Yani parametreli statik yapıcı metot tanımlanamaz.
Statik yapıcı metotların erişim belirleyicileride yoktur.

Bir nesneyi hangi yapıcı metot ile oluşturursak oluşturalım satatik yapıcı metot mutlaka ilk nesne tanımlandığında çalışır.


Statik yapıcı metotlar genellikle statik değişkenler ile ilgili işlemler yapılır. Ama bu zorunlu değildir. Örneğin aşağıdaki
kaynak kodda her oyuncu nesnesi oluşturulduğunda statik Toplam değişkeni 1 artırılıyor ve her oyuncu değişkeni işlevini
bitirdiğinde yıkıcı işlev yardımıyla Toplam değişkeni 1 azaltılıyor.




using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
    class Oyuncu
    {
        public static int Toplam;

        public Oyuncu()
        {
            Oyuncu.Toplam++;
        }
        static Oyuncu()
        {
            Toplam = 0;
        }

        ~Oyuncu()
        {
            Console.WriteLine("Bir oyuncu gitti...");
            Toplam--;
        }
    }
    class Anasinif
    {
 
        static void Main()
        {

            Oyuncu o = new Oyuncu();
            Console.WriteLine("toplam oyuncu = " + Oyuncu.Toplam);
            Oyuncu x = new Oyuncu();
            Console.WriteLine("toplam oyuncu = " + Oyuncu.Toplam);
 
        }      
    }
}


bu programın ekran görüntüsü aşağıdaki gibidir.

toplam oyuncu = 1
toplam oyuncu = 2
Bir oyuncu gitti...
Bir oyuncu gitti...











Yapıcı Metotlar(Constructors) (c#)


Yapıcı Metotlar(Constructors)

Şu ana kadar gördüğümüz örneklerde bir sınıf nesnesinin üye elemanlarından olan özelliklere değerler verirken ya kendimiz
EnBoyBelirle() gibi metotlar tanımladık ya da '.' operatörü ile eğer eleman puplic ise direkt ulaştık. Ancak bu şekilde ilk
değer vermeler genellikle kullanılmaz, nesne yönelimli programlama tekniğinin getirdiği birtakım avantajlardan yararlanılır.

referans tipi oluşturulduğunda elemenlara  varsayılan değer atanıyordu. İşte bu işlemi yapan aslında otomatik çalışan bir
yapıcı metottur. Burdan da anlaşılacağı gibi biz tanımlamasakta her sınıfın bir yapıcı metotodu vardır. Bunlara
default constructor denilmektedir.

yapıcı metotların geri dönüş değerinin olmaması geri dönüş tipinin void olduğu anlamına gelir.


Şimdi örnek bir sınıf üzerinden yapıcı metotların nasıl bildirildiğine bakalım. Yapıcı metotların diğer metotlardan
2 farkı vardır. birincisi, yapıcı metotların geri dönüş değeri yoktur. yani geri dönüş değeri kavramı yoktur bu yüzden
metotun tipi tanımlanmaz. ikincisi yapıcı metotların ismi sınıf ismi ile aynı
olmak zorundadır.




Şimdi Ev adlı bir sınıf için bir yapıcı metot oluşturalım. Ev sınıfı içerisinde katno, odasayisi, alan, semt bilgisini tutan
bir veri yapısı olacaktır.

class Ev
{
   puplic int odasayisi;
   puplic int katno;
   puplic int alan;
   puplic string semt;


   Puplic Ev(int odasi, int kati, int alani, string semti)
   {
       odasayisi = odasi;
       katno = kati
       alan = alani;
       semt = semti;
   }
}

Friday, September 21, 2012

Erişim Belirleyici yardımıyla dosyaya yazma (C#)

Erişim Belirleyici yardımıyla dosyaya yazma


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace evler
{
    public class Ev
    {
        private int odasayisi;
        private int katno;
        private double alan;
        private string semt;
     
     
        public int Odasayisi
       {
           get
           {
               return odasayisi;
           }

           set
           {
               if (value < 0)
               {
                   FileInfo fi = new FileInfo("c:/Netgame/loglar.txt");
                   FileStream fs;
                      if (fi.Exists == true)
                       {
                          fs = new FileStream("c:/Netgame/loglar.txt", FileMode.Append);
                       }

                      else
                          fs = new FileStream("c:/Netgame/loglar.txt", FileMode.Create);

                      StreamWriter yazici = new StreamWriter(fs);
                      yazici.Write("hatalı deger girildi("+DateTime.Now+")");
                      yazici.Flush();
                      yazici.Close();
                      fs.Close();

               }
               value = Math.Abs(value);
               odasayisi = value;
           }
       }


         public int Katno
        {
            get
            {
                return katno;
            }

            set
            {
                this.katno = value;
            }
        }

         public double Alan
         {
             get
             {
                 return this.alan;
             }

             set
             {
                this.alan = value;
             }
         }

         public string Semt
         {
             get
             {
                 return semt;
             }

             set
             {
                 semt = value;
             }
        }

         public string EvGoster()
        {
            return string.Format(" Odasayisi: {0} \n Katno: {1} \n Alan: {2} \n Semt: {3}", odasayisi, katno, alan, semt);
        }
   }
}



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using evler;

namespace dosyalama
{
    class Program
    {
        static void Main(string[] args)
        {
            Ev ev1 = new Ev();

            ev1.Odasayisi = -5;
            ev1.Katno = 2;
            ev1.Alan = 120;
            ev1.Semt = "Besiktas";
         
            Console.WriteLine(ev1.EvGoster());
            Console.ReadLine();
        }
    }
}

Erişim belirleyicisi örneği (C#)


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace evler
{
    public class EV
    {
        private int katno;
        private int odasayisi;
        private string semt;


        public string Evgoster()
        {
           return string.Format("kat: {0} \noda: {1}\nsemt: {2}", katno,odasayisi,semt);
        }

        public int Katno
        {
            get { return katno; }
            set { katno = value; }
        }

        public int Odasayisi
        {    
            get
            {
                return this.odasayisi;
            }
            set
            {
                if (value < 0)
                {
                    value = Math.Abs(value);
                   
                }
                this.odasayisi = value;
            }
        }
        public string Semt
        {
            get { return semt; }
            set { semt = value; }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using evler;

namespace siniflar
{
    class Program
    {
        static void Main(string[] args)
        {
            EV ev1 = new EV();

            ev1.Katno = 3;
            Console.WriteLine("oda sayisi: ");
            ev1.Odasayisi = Convert.ToInt32(Console.ReadLine());
            ev1.Semt = "besiktas";


            Console.WriteLine(ev1.Evgoster());

            Console.ReadLine();
        }
    }

}

Protected Erişim Belirleyicisi (C#)


Protected Erişim Belirleyicisi

Sınıflar konusunda belirleyicilerini incelerken, protected erişim belirleyicisini türetmeyi anlatırken inceleyeceğimizi
söylemiştik. Kalıtım yolu ile sadece puplic ve protected elemanlar aktarılır. Temel sınıfta bulunan private üye elemanlara
türeyen sınıf içersinde ulaşamayız. Örneğin aşağıdaki kullanım geçersizdir.

using System;

class Memeli

{
  private double Boy;
  private double Agirlik;

  puplic void OzellikGoster()
  {
    console.WriteLine("Boy = " + Boy);
    console.writeline("Ağırlık = " + agirlik);
  }
}

class Kedi : Memeli
{
  puplic string Turu;
 
  puplic void BoyGoster()
  {
    Console.writeline("Boy = " + Boy);
  }
}

Burada Kedi sınıfı Memeli sınıfnda türemiş olmasına rağmen Kedi sınıfında bulunan BoyGoster() metodu içerisinden Memeli
sınıfındaki Boy özelliğinin private olarak bildirilmesidir. private özelliklerinde kalıtım yolu ile aktarılması için her
değişken için get ve set blokları tanımlanabilir. Bu durumda Memeli sınıfının private elemanlarına erişebiliriz.

Diğer sınıfların kullanımına kapalı ancak türetme ile türemiş sınıfa geçebilen özellikler protected anahtar sözcüğü ile
oluşturulur. Eğer türeme söz konusu değilse protected olarak bildirilen elemenlarla private olarak bildirilen elemanlar
arasında fark kalmaz. protected eleman içeren bir sınıf türetildiğinde bu elemanlar türemiş sınıflar içinde rahatlıkla
kullanılabilir. protected elemanlar diğer sınıflar için private olarak kalmaya devam eder. Buna göre asağıdaki sınıf
bildirimleri geçerlidir.

Get ve Set anahtar sözcükleri (C#)


Set ve get Anahtar sözükleri

get ve set anahtar sözlükleri ile bir özellik tanımlanır. Ancak bu özelliklere erişmek için belirli kod bolkarını çalıştırma
şansımız mevcuttur. Metotlar ve özellikler arasındaki tek fark özellikleri çağırırken, fonksiyon çağırmak için kullandığımız
parantezleri kullanmamızdır.

private olarak tanımlanan En ve Boy elemananlarının Dortgen sınıfı için bir arayüz oluşturmayacağı için ikisinde önüne
member(üye) sözcüğünü temsil eden "m" harfini koyacağız. Böylece orjinal isimler get ve set erişimlerini kullancağımız
özelliklerde kalacaktır.

Dortgen sınıfının yeni arayüzü aşağıdaki gibidir.

class Dortgen
{
    private int mEn;
    Private int mBoy;

    puplic int En
    {
       get
       {
         return mEn;
       }
   
       set
       {
          if (value <0)
              mEn= 0;
          else
          mEn=value;
       }
    }

    puplic int Boy
    {
       get
       {
         return mBoy;
       }
   
       set
       {
          if (value <0)
              mBoy= 0;
          else
          mBoy=value;
       }
    }
}


Value anahtar sözcüğü ise özelliklere atanacak nesnenin değerini ifade eder. Örneğin,

Dortgen d= new Dortgen();

d.En = 50;

ifadesinde value anahtar sözcüğü 50 değerini temsil etmektedir. Veri elemanı hangi türden ise value değeri de o türden olur.

This anahtar sözcüğü (C#)


This Anahtar Sözcüğü

Nesneler üzerinden metotlar çağrılırken aslında biz farkına varmadan metotlara gizlice ilgili nesnelerin referansları geçirilir.
Örneğin, this anahtar sözcüğünün anlamını daha iyi kavrayabilmek için soyutlama yapalım;

Dorgen d1= new Dortgen();

d1.EnBoyBelirle();

yerine aşağıdaki gibi bir kullanımda olabilirdi:

Dortgen d1 = new Dortgen();


d1.EnBoyBelirle(d1 'in referansı);

Eğer this anahtar sözcüğü olmasaydı ikinci şekildeki gibi bir kullanıma mecbur kalacaktık. İkinci şekildeki gibi bir kullanımın
kullanışsız olduğunu söyleyebiliriz. Bu yüzden C# dilini tasarlayanlar d1 nesnesinin referansını gizlice EnBoyBelirle()
metoduna aktarmada kullanılacak bir sistem geliştirmişlerdir. İşte this anahtar sözcüğü bu referansı temsil etmektedir.
this anahtar sözcüğü çok fazla kullanılmasa da bazı durumlarda faydalı olabilir; örneğin,
EnBoyBelirle() metodunun aşağıdaki gibi olduğunu düşünelim:

puplic void EnBoyBelirle(int En, int Boy)
{
     if(En < 0 || Boy < 0)
     {
           En= 0;
           Boy = 0;
     }
     else
     {
           En = En;
           Boy = Boy;
     }
}



EnBoyBelirle() metodunun parametreleri olan En ve Boy değişkenleri Dortgen sınıfının üye elemanları ile aynı isime sahiptir.
Metot gövdesinde kullandığımız En ve Boy değişkenleri EnBoyBelirle() metodunun parametleridir. Çünkü bir üst faaliyet
alanında olan Dortgen sınıfının En ve Boy değişkenleri EnBoyBelirle() metodunun parametleri tarafından görünmez hale gelmiştir.

Böyle bir durumda this anahtar sözcüğünü kullanarak mantıksal hatayı önlemiş oluruz.

puplic void EnBoyBelirle(int En, int Boy)
{
     if(En < 0 || Boy < 0)
     {
           this.En= 0;
           this.Boy = 0;
     }
     else
     {
           this.En = En;
           this.Boy = Boy;
     }
}


derleyecek olursak;

using System;


namespace ThisSoz
{
    class dortgen
    {
        public int En;
        public int Boy;

        public int Alan()
        {
            int Alan = En * Boy;
            return Alan;
        }
         public void EnBoyBelirle(int En, int Boy)
        {
            if (En < 0 || Boy < 0)
            {
                this.En = 0;
                this.Boy = 0;
            }
            else
            {
                this.En = En;
                this.Boy = Boy;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            dortgen d1 = new dortgen();
            d1.EnBoyBelirle(2,-5);
            Console.WriteLine("En: " +d1.En +"  "+ "Boy: " +d1.Boy);
            Console.ReadLine();
        }
    }
}
ekran çıktısı olarak En: 0 Boy: 0 sonucunu alacağız.



this anahtar sözcüğü ile EnBoyBelirle() metodunun En ve Boy parametleri, o an üzerinde çalışılan Dortgen nesnesinin En ve Boy özelliklirine atanıyor. this anahtar sözcüğünün kullanımına olanak tanımamak okunabilirlik açısından önemlidir.


Sınıf oluşturma (c#)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace siniflar
{


    class Program
    {
        static void Main(string[] args)
        {
            EV ev1 = new EV();

            ev1.kat = 3;
            ev1.oda = 2;
            ev1.semt = "besiktas";

            Console.WriteLine(ev1.Evgoster());

            Console.ReadLine();
        }
    }


    public class EV
    {
        public int kat;
        public int oda;
        public string semt;

        public string Evgoster()
        {

            return string.Format(" kat numarasi: {0} \n oda sayisi: {1} \n semt: {2}", kat, oda, semt);
        }
    }
}



Nesne Tabanlı Programlama (C#)


NESNE TABANLI PROGRAMLAMA

Nesne yönelim tekniği, gerçek hayatı programlar için simule edecej yöntemler topluluğudur. Her nesnenin kendine has özellikleri
vardır. Nesneler tamamen birbirlerinden soyutlanarak farklılaştırılır. Tabi her nesnenin birbirine mesaj göndermesi de son
derece doğaldır. Bu gerçek yaşamda da böyledir. Nesne yönelimli programlama tekniğinde gerçek bir sistem parçalara ayrılır
ve parçalar arasında ilişkiler kurulur. Nesne tabanlı programlamada önemli olan her parçayı etkili bir şekilde tasarlamaktır.



NESNE KAVRAMI

Nesneler gerçek hayatta görebildiğimiz ya da varlığını bildiğimiz eşyalardır. Nesne yönelimli programlama tekniğinde sınıflar
nesnelerin biçimlerini belirler. Oluşturduğumuz nesneler dınıf türlerinden nesneler olarak da adlandırılabilir. Her bir nesne
kendi içinde tutarlı bir yapıya sahiptir. Yani veriler arasında sıkı bir bağ vardır.

C#'ta nesne yönelimli programlama yapısını sınıflar sağlar. Sınıfları kullanarak nesneler tanımlarız. Hatırlayacağınız gibi
bir nesne aşağıdaki gibi oluşturuluyordu.

using System;

class Sınıf
{
   puplic int a;

   puplic int A()
   {
     return a;
   }
}

class MainMetodu
{
   static void Main()
   {
     Sınıf x = new Sınıf();
   }
}


Yukarıdaki programda Sınıf bir nesnenin şeklini belirlemektedir. Kısacası bir tür bilgisi saklamaktadır. new anahtar sözcüğünü
kullanarak bu türdeb x isimli bir nesne tanımlıyoruz. Bu x nesnenin bir tane veri taşıyan yapısı, bir tanede iş yapan metodu
mevcuttur.

Sınıflar bir tür  bilgisi olduğuna göre bu türü paketleyip istediğimiz programda kullanabilmemiz gerekir.



Sınıf Kütüphanesi Oluşturma

Her zaman olduğu gibi boş olduğu gibi boş bir metin dosyası açıp aşağıdaki sınıf yazalım ve RastgeleSayi.cs adıyla kaydedelim.
Bu sınıf yapısında rastgele bir değer bulunan bir özelliğe sahiptir. Ayrıca rastgele sayıyı daha sonra değiştirebilmek için
bir de Değiştir() isimli bir metot sağlanmıştır. Bu örnekte rastgele sayılar üretmek için System isim alanında bulunan
Random sınıfı kullanılmıştır.

using System;

namespace Csharp
{
  puplic class Rastgelesayi1
  {
    pravite Random rnd = new Random();
    pravite int mSayi;

    Puplic int sayi
    {
      get
       {
         return mSayi;
       }
    }
    puplic RastgeleSayi()
    {
      mSayi = rnd.Next(0,100);
    }

    puplic void Değistir()
    {
     mSayi = rnd.Next(0,100);
    }
  }
}


Yukaridaki kaynak kodda Main() metodunun olmadığına dikkat edin. Burada tanımladığınız sınıf kendi başına çalışabilen bir yapı
değildir. Ancak bir program içinde bu sınıf türünden nesneler tanımlayabiliriz.

yazdığımız sınıfın solution kısmına sağ tıklayarak build ettiğimizde daha önce belirtilen yolda sınıfın .dll dosyası derlenir.
bu dosya da yazdığımız sınıfı içeren binary düzeyde bilgiler bulunur. Dosyayı açtığımızda kodlarımızı açık bir şekilde
göremeyiz. Sınıfın  .dll dosyası elimizde olduğu sürece programlarmızda sınıfı dilediğimiz gibi kullanabiliriz.

Sınıf Kütüphanesi kullanma

Oluşturduğumuz bu sınıfı programlarımızda kullabilmek için derleyiciye .dll dosyasının yolunu bildirmek gerekir.

ana sınıfımızın bulunduğu programımızda solutionun referansına add referans dediktikten sonra .dll dosyamızı seçtikten sonra
programızın refaranslarının çağrıldığı kısma using .dll ismini eklediğimiz oluşturduğumuz sınıfı kullanabiliriz.
namespaceini eklicez bitti.


Metotlar (C#)


Metotlar tekrar tekrar aynı kodların yazılmasını önlemek için kullanılır.Bir fonsiyonun çalışması için başka bir fonksiyon tarafından çağrılması gerekir.
Metot içinde tanımladığımız kod parçacığını ana metot içinde çağırdığımız takdirde o metotun sahip olduğu deyimleride çalıştırmış oluruz. böylece
sürekli aynı kod parçacıklarını kullanmamız gereken durumlarda bize kolaylık sağlar.
metotlar ;  tür metot_adı (parametreler) { deyimler.. } şeklinde tanımlanır.
kullandığımız main fonksiyonuda buna örnektir.


private tanımlanan metotlara sadece bulundugu sınıf içersinden erişebilinirken
puplic tanımlanan metotlara ise tüm sınıflardan  erişebilinir.

bir metot Private static int metot(int x, int y) şeklinde tanımlanır. konsolda main metodu static olduğu için diğer metotlarda static tanımlanır.

örnek 1: kullanıcıdan alınan sayıları toplama, çarpma ve bolme metotlarına gönderen ve işlem yaptıran program.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace metotolar
{
    class Program
    {
        private static int toplama(int sayi1, int sayi2)
        {
            int toplam = sayi1 + sayi2;
            return toplam;
        }

        private static int carpma(int sayi1, int sayi2)
        {
            int carpim = sayi1 * sayi2;
            return carpim;
        }

        private static float bolme(float sayi1, int sayi2)
        {
            float bolum = sayi1 / sayi2;
            return bolum;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("1.sayiyi giriniz: ");
            int sayi1= Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("2.sayiyi giriniz: ");
            int sayi2= Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("toplama: "+ toplama(sayi1, sayi2));
            Console.WriteLine("carpma: "+ carpma(sayi1, sayi2));
            Console.WriteLine("bolme: "+ bolme(sayi1, sayi2));
            Console.ReadLine();
            }
        }
    }


örnek 2: rastgele sayılardan oluşan 10 elemanlı bir dizinin elemanlarını metot yardımıyla isteğe göre büyükten küçüğe veya küçükten büyüğe sıralayan program.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace diziler
{
    enum siralamatipi
    {
        artan=0, azalan=1
    }
    class Program
    {
        private static int[] sirala(int[] siralanmis)
        {
            int ara;
            Console.WriteLine("siralama tipini seciniz: ");
            siralamatipi tip = (siralamatipi)Convert.ToInt32(Console.ReadLine());
            for (int i = 0; i < siralanmis.Length; i++)
            {
                for (int j = i + 1; j < siralanmis.Length; j++)
                {
                    if (tip == siralamatipi.artan)
                    {
                        if (siralanmis[i] > siralanmis[j])
                        {
                            ara = siralanmis[i];
                            siralanmis[i] = siralanmis[j];
                            siralanmis[j] = ara;
                        }
                    }

                    else if (tip == siralamatipi.azalan)
                    {
                        if (siralanmis[i] < siralanmis[j])
                        {
                            ara = siralanmis[i];
                            siralanmis[i] = siralanmis[j];
                            siralanmis[j] = ara;
                        }
                    }

                }
            }
            return siralanmis;
        }

        static void Main(string[] args)
        {

            int[] dizi = new int[10];
            Random rnd = new Random();

            for (int i = 0; i < 10; i++)
            {
                dizi[i] = rnd.Next(100);
            }

            sirala(dizi);

            foreach (int item in dizi)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
        }
    }
}



örnek: main fonksiyonuyla kullanıcıdan alınan sayının metotlar yardımıyla asal ve mukemmel sayı olup olmadığını
kontrol eden program;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace sayilar
{
  class Program
    {
      private static void asalsayi(int a)
      {
          bool durum = true;
          int kalan;

          for (int i = 2; i < a; i++)
          {
              kalan = a % i;

              if (kalan == 0)

                  durum = false;
              break;
         }

          if (durum == true)
              Console.WriteLine("sayi asal");
          else
              Console.WriteLine("sayi asal degil");
      }

      private static void mukkemmel(int a)
      {
          int [] dizi = new int [a];
          int s=0;
          int toplam = 0;
          for (int i = 2; i < a; i++)
          {
              if (a % i == 0)
              {

                  dizi[s++] = i;
              }
          }
             
              for (int j = 0; j <= s; j++)
              {

                  toplam = dizi[j] + toplam;
              }

              toplam = toplam + 1;
         

              if(toplam== a)
              Console.WriteLine(a + " mukemmel sayi");

              else
              Console.WriteLine(a+ " mukemmel degil.");
         
     
      }
        public static void Main(string [] Args)
            {
                int sayi;

                Console.WriteLine("sayiyi giriniz: ");
                sayi = Convert.ToInt32(Console.ReadLine());
                asalsayi(sayi);
                mukkemmel(sayi);

                Console.ReadLine();
        }
    }
}









Diziler (C#)


Diziler belirle sayıda veriyi içinde barından değişken listesidir.
dizi içersindeki verilerin indexi(sıra konumu) 0 dan başlar. yani ilk sıradaki dizinin indexi 0 dır. int türünden deneme adında 10 eleman içeren bir dizi
tanımlamamız gerekirse, int [] deneme = new int[10] şeklinde tanımlamalıyız.

Dizi kullanımda 2 önemli özellik vardır bunlar;
 1. Dizi elemanları bellekte ardışıl  olarak bulunurlar
 2. Dizi elemanları aynı türden nesnelerdir.

dizi tanımlanması aşağıda ki gibi olur.

int [] sayilar = new int[10];

boyutu 10 olan int türünden bir dizi tanımlamış olduk.
dizi elemanlarına dizi[index]= değer; şeklinde değer verebiliriz.

Dizi elemanlarına index operatörüyle [] ulaşılabilir.

int sayilar[0]= 10;
int sayilar[1]= 20;  sayilar adlı dizinin 0. indexte bulunan elemanı 10, 1.indexte bulunan elamanı 20dir.



örnek 1: klavyeden 5tane değer girilen 5 değeri diziye atan ve bu dizideki değerlerin ortalamasını alan program.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace diziler
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] dizi = new int[5];
            int ortalama = 0, toplam=0;
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("{0}. elemani giriniz: ", i+1);
                dizi[i]= Convert.ToInt32(Console.ReadLine());
                toplam = dizi[i] + toplam;
            }

            ortalama = toplam / 5;
            Console.WriteLine(ortalama);
            Console.ReadLine();
        }
    }
}

örnek 2: 10elamanlı bir sayı dizisinin en küçük elemanını bulan program.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace diziler
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] dizi = new int[10];
           
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("{0}. elemanı giriniz: ", i+1);
                dizi[i] = Convert.ToInt32(Console.ReadLine());
                Console.Clear();              
            }

            int min = dizi[0];
           

            for (int j = 1; j < 10; j++)
            {
                if (dizi[j] < min)
                {
                    min = dizi[j];
                }
            }
            Console.WriteLine("en kucuk elemani: {0}",min);
            Console.ReadLine();
        }
    }
}


örnek 3: 10 elemanlı bir sayı dizisine 1-10arası puan girilen ve hangi puandan kaç adet bulunduğunu gösteren program.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace puantut
{
    class Program
    {
        static void Main(string[] args)
        {
            int i;
            int[] dizi = new int[10];
            int[] Puansayisinitut = new int[11];

            for (i = 0; i <= 10; i++)
            {
                Puansayisinitut[i] = 0;
            }
                for (i = 0; i < 10; i++)
                {
                    Console.WriteLine(i + 1 + ". puanı giriniz(0-10 arasi hesaplanacak); ");
                    dizi[i] = Convert.ToInt32(Console.ReadLine());

                    Puansayisinitut[dizi[i]]++;
                    Console.Clear();
                }

                for (i = 0; i <= 10; i++)
                {
                    Console.WriteLine(i + "'den" + Puansayisinitut[i] + "adet var");
                   
                }
                Console.ReadLine();
            }
        }
    }


Örnek 4; 10 elamanlı bir sayı dizisinin elamanlarını büyükten küçüğe sıralayan program.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace diziler
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] dizi = new int[10];
           
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("{0}. elemanı giriniz: ", i+1);
                dizi[i] = Convert.ToInt32(Console.ReadLine());
                Console.Clear();
               
            }

            int ara;
            for (int s = 0; s < 10; s++)
            {
                for (int k = s+1; k < 10; k++)
                {
                    if (dizi[s] < dizi[k])
                    {
                        ara = dizi[s];
                        dizi[s] = dizi[k];
                        dizi[k] = ara;
                    }
                }
            }
                int[] siralanmis = dizi;

                foreach (int item in siralanmis)
                {
                    Console.Write(item + "--");
                }

                Console.ReadLine();
            }
        }
    }

Monday, July 30, 2012

10'luk tabana çevirme programı

1.örnek:  2'lik tabanda yazılan sayıyı 10'luk tabana çeviren program;


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace onluktabanacevir
{
    class Program
    {
        static void Main(string[] args)
        {
            int uzunluk, i, sonuc = 0;
            string sayi;
            int ara, a, taban = 2;

            Console.Write("10luk Tabana cevrilecekse sayi:");
            sayi = Console.ReadLine();

            uzunluk = sayi.Length - 1;
            int son = Convert.ToInt32(sayi[uzunluk].ToString());
            for (i =uzunluk-1; i >=0 ; i--)
            {
                int ussu = 1; /* iç içe for da değişkene yeni değer atıcaksak birinci for'içinde tanımlamamız gerekir,
                                   aksi halde değişkenin aldığı değer sıfırlanmadan döngü devam eder. */
                ara = Convert.ToInt32(sayi[i].ToString());
                for (a = uzunluk - 1; a>= i;  a--)
                {
                    ussu = (taban * ara * ussu);
                }

                sonuc = sonuc + ussu;
            }

            Console.WriteLine(sonuc + son);

            Console.ReadLine();

        }

    }
}

2'lik tabana çevirme programı (C#)


1.örnek: 10luk tabanda yazılan sayıyı 2lik tabana çeviren program;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ikiliktabanacevir
{
    class Program
    {
        static void Main(string[] args)
        {
            int sayi, bolum, kalan;

            string sonuc="" , kalann;

            Console.Write("2lik tabana cevrilcek sayi: ");
            sayi= Convert.ToInt32(Console.ReadLine());

            while(sayi>=2){

                bolum = sayi / 2;  /* bolum degiskenine değer atamasını bir döngü içersinde yaptığımız için sadece
                                           döngü içesinde  kullanabiliriz aksi halde alan dışında kullanıldı uyarısı alırız. */
                kalan = sayi % 2;
                kalann= kalan.ToString();
                sonuc = kalan + sonuc;

                sayi = bolum;
            }
           
            Console.Write( sayi + sonuc); /* bolum degiskenini disarda kullanamacigimiz icin son bolum degerini 
                                                          sayi degerine atadığımızdan sonucun basına sayi(bolum) degerini 
                                                          yazdırdık. */

            Console.ReadLine();

        }

    }
}

Saturday, July 21, 2012

Fibonacci serisini bulan program (C#)


Fibonacci sayıları son iyi sayının toplamanın bir sonraki sayıyı verdiği sayılardır. 0 1 den başlayan seri 0+1=1
0 1 1 ( 1+1 =2 ) 0 1 1 2 ( 1+2= 3 ) 0 1 1 2 3 şeklinde sıralanır.

Örnek: Fibonacci serisini bulan program;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace fibonacci
{
    class Program
    {
        static void Main(string[] args)
        {

            int i, adet;
            int a=0, b=1,c;
            Console.Write("kac adet sayi goruntulensin?");
            adet = Convert.ToInt32(Console.ReadLine());

            Console.Write(a + " " + b + " ");

            for (i = 3; i <= adet; i++)
            {
                c = a + b;

                Console.Write(c+" ");

                a = b;
                b = c;
            }

                Console.ReadLine();
        }
    }
}

Döngüler ile Örnekler (C#)


1.Örnek:  tersinin 4 ile çarpımı kendisine eşit olan 4 basamaklı sayıyı bulan program;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ornek
{
    class Program
    {
        static void Main(string[] args)
        {
            int sayi, i, sonuc;
            string ara;

            for (sayi = 1000; sayi <= 9999; sayi++)
            {
                ara = sayi.ToString();
                string ters = "";

                for (i = 3; i >= 0; i--)
                {
                    ters = ters + ara[i].ToString();
                }

                sonuc = Convert.ToInt32(ters);

                if ((sonuc * 4) == sayi)
                {
                    Console.WriteLine(sayi);
                    break;
                }
            }

            Console.ReadLine();
        }
    }
}

2.Örnek: satır sayısı kadar yıldız yazdıran program;

A. İç içe for kullanarak;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int i, k, adet;

            Console.Write("kac satir yildiz olsun?: ");
            adet=Convert.ToInt32(Console.ReadLine());

            for (i = 1; i <= adet; i++)
            {
                for (k = 1; k <= i; k++)
                {
                    Console.Write("*");
                }

                Console.WriteLine();
            }

            Console.ReadLine();
        }
    }
}

B. Tek for kullanarak;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ornek
{
    class Program
    {
        static void Main(string[] args)
        {
            int i ,a;
            string sonuc="";

            Console.Write("kac satir olsun?: ");
            a = Convert.ToInt32(Console.ReadLine());

            for (i = 1; i <= a; i++ )
            {

                sonuc = sonuc + "*";
                Console.WriteLine(sonuc);
                
            }
            
                Console.ReadLine();
        }
    }
}