Action kullanarak multi thread sql update

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading;

namespace caThreadSqlUpdate
{
    class Program
    {
        private static SqlConnection cnn = new SqlConnection("Data Source=10.130.214.200,8585;Initial Catalog=ERecete;User Id=kullanici;Password=sifre;");
        static void Main(string[] args)
        {
            if (cnn.State != ConnectionState.Open)
            {
                cnn.Open();
            }

            SqlCommand cmd = cnn.CreateCommand();
            cmd.CommandText = "select ereceteIlacListe_id,barkod FROM dbo.EReceteIlacListesi";
            SqlDataAdapter da = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();
            da.Fill(ds);

            Dictionary<IAsyncResult, Action<int, string>> li = new Dictionary<IAsyncResult, Action>();
            int i = 0;
            foreach (DataRow row in ds.Tables[0].Rows)
            {
                i++;
                Action<int, string> act = f_BarkodGuncelle;
                IAsyncResult ai = act.BeginInvoke((int)row[0], (string)row[1], delegate { Console.WriteLine("Bitti: " + row[0] + " ve " + row[1]); }, null);
                li.Add(ai, act);
                if (i == 5)
                {
                    break;
                }
            }
            while (true)
            {
                foreach (var key in li.Keys)
                {
                    if (key.IsCompleted && li[key] == null)
                    {
                        Console.WriteLine("End invoke çağırdım");
                        li[key].EndInvoke(key);
                        li[key] = null;
                    }
                }
                Thread.Sleep(1000);
            }

        }

        static public void f_BarkodGuncelle(int _iIlacId, string _sBarkod)
        {
            SqlCommand cmd = cnn.CreateCommand();
            cmd.CommandText = String.Format("UPDATE dbo.yedekEReceteIlaclari SET barkod={0} WHERE refEreceteIlacListe_id={1} ", _sBarkod, _iIlacId);
            cmd.ExecuteNonQuery();
        }
    }
}

AsyncTask on Android

Süper bir açıklama
Güzel bir örnek
Gayem aklımdan çıkarsa notlarımda kalsın. AsyncTask bizim için Thread ve Handler tiplerini barındıran bir sınıf. Örneğin arka planda WebServisine bağlanmak ve veri çekip gelen veriyi ekranda bir bileşene bağlamak istiyorsunuz. İşte web servisine bir thread ile bağlanırsınız(böylece ekran donmamış olur -5sn donanı android kapıyomuş-) Handler ile de UI threadinde bileşene verileri aktarabiliyorsunuz.

AsyncTask
Thread [ doInBackground() metodunu kullanıyoruz ]
Handler [ onPostExecute() metodunu kullanıyoruz ]

AsyncTask sınıfının jenerik tipleri kullandığınıda ekleyelim:
AsyncTask <TypeOfVarArgParams , ProgressValue , ResultValue>

1. doInBackground metoduna parametre geçirmek için
TypeOfVarArgParams'ı kullanıyoruz.
2. ProgressValueis parametresi ile işlem bilgisini geçiriyoruz.
3. ResultValue ise Thread'in metodundan, Handler'ın onPostExecute metoduna dönen değeri gösteriyor.

 private class DownloadWebPageTask extends AsyncTask<String, Void, String> {
  @Override
  protected String doInBackground(String... urls) {
   String response = "";
   for (String url : urls) {
    DefaultHttpClient client = new DefaultHttpClient();
    HttpGet httpGet = new HttpGet(url);
    try {
     HttpResponse execute = client.execute(httpGet);
     InputStream content = execute.getEntity().getContent();

     BufferedReader buffer = new BufferedReader(
       new InputStreamReader(content));
     String s = "";
     while ((s = buffer.readLine()) != null) {
      response += s;
     }

    } catch (Exception e) {
     e.printStackTrace();
    }
   }
   return response;
  }

  @Override
  protected void onPostExecute(String result) {
   textView.setText(result);
  }
 }

 public void readWebpage(View view) {
  DownloadWebPageTask task = new DownloadWebPageTask();
  task.execute(new String[] { "http://www.vogella.de" });

 }

Handler kullanarak Thread içinden UI bileşenine mesaj işlemek

Ref: http://www.helloandroid.com/tutorials/using-threads-and-progressdialog

    public class ProgressDialogExample extends Activity implements Runnable {
     
            private String pi_string;
            private TextView tv;
            private ProgressDialog pd;
     
            @Override
            public void onCreate(Bundle icicle) {
                    super.onCreate(icicle);
                    setContentView(R.layout.main);
     
                    tv = (TextView) this.findViewById(R.id.main);
                    tv.setText("Press any key to start calculation");
            }
     
            @Override
            public boolean onKeyDown(int keyCode, KeyEvent event) {
     
                    pd = ProgressDialog.show(this, "Working..", "Calculating Pi", true,
                                    false);
     
                    Thread thread = new Thread(this);
                    thread.start();
     
                    return super.onKeyDown(keyCode, event);
            }
     
            public void run() {
                    pi_string = Pi.computePi(800).toString();
                    handler.sendEmptyMessage(0);
            }
     
            private Handler handler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                            pd.dismiss();
                            tv.setText(pi_string);
     
                    }
            };     
    }

Çeşitli Thread yöntemleri

private void btnUpdate_Click(object sender, EventArgs e)
{
    if (pc != null)
    {
        Commander cmd = new Commander(pc);

        new Thread(new ThreadStart(delegate()
                                        {
                                            int i = pc.ToplamOkunacakByte;
                                            MessageBox.Show(i.ToString());
                                        })).Start();

// pc formun SerialPort okuma işini yapan objeyi barındıran sınıfının örneği
        new Thread(new ThreadStart(() =>
                                        {
                                            int i = pc.ToplamOkunacakByte;
                                            MessageBox.Show(i.ToString());
                                        })).Start();

// pb form üzerindeki ProgresBar dır (private System.Windows.Forms.ProgressBar pb;)
        pb.Maximum = 100;
        pb.Value = 0;

// Thread e parametre olarak pb yi veriyor, 
// delegesinde ise p olarak kullanıyoruz.
        new Thread(new ParameterizedThreadStart((p) =>
                                                    {
                                                        for (int i = 0; i < 100; i++)
                                                        {
                                                            Thread.Sleep(10);
                                                            ((ProgressBar)p).Value++;
                                                        }
                                                    })).Start(pb);
    }
}

C# ile Thread lenmiş İstemci-Sunucu

Ref: http://www.switchonthecode.com/tutorials/csharp-tutorial-simple-threaded-tcp-server

Sunucu

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace newServer
{
    public partial class FrmServer : Form
    {
        public FrmServer()
        {
            InitializeComponent();
            CheckForIllegalCrossThreadCalls = false;
        }

        private TcpListener tcpListener;
        private Thread mainThread;
        private void Form1_Load(object sender, EventArgs e)
        {
            tcpListener = new TcpListener(IPAddress.Any, 3000);
            mainThread = new Thread(ListenMainThread);
            mainThread.Start(tcpListener);
        }

        public void ListenMainThread(object listener)
        {
            tcpListener.Start();
            while (true)
            {
                TcpClient client = tcpListener.AcceptTcpClient();
                lbLog.Items.Add("Bağlantı geldi");
                Thread clientThread = new Thread(HandleClientComm);
                clientThread.Start(client);
            }
        }

        public void HandleClientComm(object client)
        {
            TcpClient tcpClient = (TcpClient) client;
            NetworkStream clientStream = tcpClient.GetStream();

            byte[] message = new byte[4096];
            int bytesRead;

            while (true)
            {
                bytesRead = 0;

                try
                {
                    //blocks until a client sends a message
                    bytesRead = clientStream.Read(message, 0, 4096);
                }
                catch
                {
                    //a socket error has occured
                    break;
                }

                if (bytesRead == 0)
                {
                    //the client has disconnected from the server
                    break;
                }

                //message has successfully been received
                ASCIIEncoding encoder = new ASCIIEncoding();
                string okunan = encoder.GetString(message, 0, bytesRead);
                lbLog.Items.Add("Okundu: " + okunan);
            }

            tcpClient.Close();
        }
    }
}

İstemci

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace NewClient
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            TcpClient client = new TcpClient();
            client.Connect("127.0.0.1", 3000);
            NetworkStream nsClient = client.GetStream();
            for (int i = 0; i < 10; i++)
            {
                string sMesaj = "Merhaba " + i;
                byte[] barrMesaj = Encoding.ASCII.GetBytes(sMesaj);
                int iLen = barrMesaj.Length;
                nsClient.Write(barrMesaj,0,iLen);
                Thread.Sleep(1000);
            }
        }
    }
}

C# Event

Delegate ile ilgili makalemi okuyarak buradan okumaya devam ederseniz dünya daha güzel bir yer olabilir ;)

Event meselesini futboldan örnekle anlatmaya çalışayım.
Örneğin bir FutbolOyuncusu sınıfını düşün. Sahaya bu sınıftan 22 tane nesne yaratarak süreceksin. Her oyuncunun özellikleri, yeteneği, hızı, gücü farklı olacak.
- Golcü nesnesi(mesela Mario Gomez :) pozisyona girecek ve şut atmayı düşünecek ve keyfi bir hızla topu tepecek.
- Şut atıldığında bizim bir olayı tetiklememiz gerekiyor ki, diğer oyuncular buna göre pozisyon alsınlar.
- Ancak bu olay ayrıca Gomez'in o anda kaç km hızla topa vurduğu, açısını, zamanlamasını OnShoot olayına geçirmesini gerektirebilir.
- Olayın parametrelerine göre(hız, zaman, açı vs.) göre kaleci şutu görebilecek, topa uzanabilecek, tutacak ya da tokatlayacak.
- Olayın peşine, diğer nesneler(kaleci, rakip savunma, hücumcu oyuncular vs.) bir cevap üretebilmek için bu olayı takip ediyor olabilirler(bu olaya abone olabilirler).
- Ya da Mario atamaz diye hiç bir eylem içinde bulunmayabilir diğerleri.

* İşte OnShoot bizim EVENT'imiz(olayımız) anlaştık mı?
* OnShoot olayı anında bazı parametrelerimiz açığa çıkıyor (hız, açı, zamanlama vs.) bunlarda olay argumanları(Event Arguments).

Kod yazalım ve içindeki yorumlarımıza bakarak ilerleyelim:

using System;
using System.Data;
using System.Runtime;

namespace CSharp_Orneklerim.Delegate_Event
{
    public class Event_01
    {
        public static void Calis()
        {
            Topcu kaleciMuslera = new Topcu() { Adi = "Muslera" };
            Topcu cenkGonen = new Topcu() { Adi = "Cenk Gönen" };

            // Olaylara abone olacak nesnelerin fonksiyonlarını ekleyelim
            cenkGonen.OnShoot += (sutuVuranOyuncu, sutunOzelligi) =>
            {
                // Muslera hiçbir topu tutamasın ve top ağlarla buluşsun.
                if (!kaleciMuslera.Yakalamayi_Dene(sutunOzelligi))
                {
                    // TopunDurumu türünden dönecek sonucu 
                    // hakem gol olarak ilan edecek
                    Console.WriteLine("Muslera > - Ah Vah ah vah...");
                    return new TopunDurumu()
                           {
                               x1 = -2,
                               x2 = -2,
                               y1 = -2,
                               y2 = -2,
                               Hizi = 0
                           };
                }
                else
                {
                    // kaleci topu tekmeyle sahanın ortasına uzaklaştırsın
                    return new TopunDurumu()
                    {
                        x1 = 0,
                        y1 = 12,
                        x2 = 20,
                        y2 = 15,
                        Hizi = 20
                    };
                }
            };

            // herkes pozisyonunu aldı ve golcümüz ceza sahasına giriyor
            cenkGonen.Ceza_Sahasina_Topla_Gir();
        }
    }

    public partial class Topcu
    {
        /*
         * Çeşitli özellikleri olabilir
         * tackle : topu ayağından almak
         * speed : hız
         * size : boyut
         */
        public string Adi;

        /// <summary>
        /// Tüm oyuncular ceza sahasına girebilir(savunma, hücum vs.)
        /// Ancak davranışları elbette farklıdır. 
        /// Örneğin rakip hücumcu girerse kaleyi görüp şut çekerken,
        /// kendi ceza sahasına giren savunmacı uzaklaştırmak isteyecektir.
        /// Bu yüzden bu metodu virtual yapalım ki, Topcu sınıfını miras alacak başka sınıflar
        /// kendi isteklerine göre ezebilsinler.
        /// </summary>
        public virtual void Ceza_Sahasina_Topla_Gir()
        {
            /** 
             * Oyuncu topu ceza sahasına sürsün ve kaleyi görsün.
             * Şut çekecek ve bizim olayımız tetiklenecek
             * this oyuncumuz şutu çekti
             */
            Shoot shoot = new Shoot()
                          {
                              Aci = 60, // Topa 60 dereceyle 
                              Hiz = 50, // 50 km hızda 
                              Zaman = DateTime.Now, // şimdi vursun
                          };

            TopunDurumu durumu = veShoooot(shoot);
            // Şut atıldığında bir olayı(event) tetiklemek istiyoruz. 
            // Böylece bu olayı dinleyen tüm abonelere şut ile ilgili bilgi verebilelim
            // Görünüşe göre veShoooot metodu bu işi yapacak.
            // veShoooot metodu Shoot türünden bir değişken alsın ve topun durumunu dönsün
            // Bu metodu birazdan tanımlayacağız 
            // Ancak önce oluşturacağımız metodun dönen tipi ve parametrelerine bakalım
            //
            // 1 Parametre geçireceğiz bu metoda Shoot tipinde bir değişken
            // ve topun son durumu dönecek: {koordinatı, yönü, hızı} 
            //
            // Demekki Shoot ve TopunDurumu diye iki sınıfımızı yazmalıyız
        }
    }

    // 1. Shoot sınıfı
    public partial class Shoot
    {
        public int Aci, Hiz;
        public DateTime Zaman;
    }

    // 2. Topun durumu
    public class TopunDurumu
    {
        // iki nokta bir vektör tanımlar. konumu ve Yönünü bulduk.
        public int x1, y1, x2, y2, Hizi;
    }

    // 3. OnShoot olayı için method handler
    // OnShoot olayı(eventi) için bir delegate tipinde metot tutucu tipine ihtiyacımız var
    public delegate TopunDurumu Del_Donussuz_Shoot_Parametreli(Topcu _topcu, Shoot _shoot);

    // 4. Topcu sinifina OnShoot olayi tanımlama vakti geldi
    // OnShoot eventini Topcu sınıfına eklemeliyiz ki, tetikleyebilelim
    public partial class Topcu
    {
        // event tanımlamaları sınıf içinde yapılır ve ancak sınıftan tetiklenebilirler
        // event değikenlerine doğrudan bir atama(eventDegiskeni = null) yapılamaz
        // ancak += ya da -= ile atama yapılabilir
        public event Del_Donussuz_Shoot_Parametreli OnShoot;
        
        // Geldik OnShoot olayımızı tetikleme işini yapacak metodumuza.
        // Metodumuz event tetikleyecek. Event ancak sınıfın içinden tetiklenebilir, nesneden değil!
        // bu yüzden public erişim belirleyicisini kullanamayız.
        // Topcu sınıfından türetilen tiplerin de bu metodu çağırması gerekecek 
        protected virtual TopunDurumu veShoooot(Shoot shoot)
        {
            // OnShoot bizim tetikleyeceğimiz olayımız olacak(event)
            // OnShoot olayının tanımlandığı yerde varsayılan bir değer yok! Null kontrolü yapalım ! 
            if (OnShoot == null)
            {
                throw new NoNullAllowedException("OnShoot olayına hiç metot eklenmiş olmaz, olamaz!");
            } 
            return OnShoot(this, shoot);
        }

        /// <summary>
        /// Shoot parametresi ve kalecinin özellikleri arasında bir fonksiyonun sonucuna göre
        /// gol ise true, değilse false dönebilir. Ama burada kaleci Muslera ise kesin gol diyelim
        /// </summary>
        /// <param name="_shoot"></param>
        /// <returns></returns>
        public bool Yakalamayi_Dene(Shoot _shoot)
        {
            if (this.Adi == "Muslera")
            {
                return false; // tutamadı, gol
            }
            return true;
        }
    }

    /**
     * ----- YAPIYI ANLAYALIM:
     * Farkettiyseniz olayı tetiklendiğinde, bu olaya abonelere
     *   olayı kimin yaptığı,
     *   nasıl bir parametreyle gerçekleştiğini dönüyor
     *   Sonuçtada abonelerin topa müdahele edeceği düşünüldüğü için TopunDurumu
     *   tipinde bir sonuç değerini bekliyoruz.
     * 
     *           TopunDurumu OnShoot(Topcu sender, Shoot e) 
     *       
     * 
     * ----- GENEL DELEGATE TİPİ TANIMLAMAYA ÇALIŞALIM:
     * Bu OLAY TANIMINI genelleyerek şu metodu olay tutucu metodun imzası olarak elde edebiliriz:
     * 
     *             void On_BirŞey_Oldu(object sender, OlayParams e)
     *             
     *        
     * ----- GENEL OLAY PARAMETRE TİPİ TANIMLAMAYA ÇALIŞALIM
     * Bu metot tutucuyu şöyle yazabiliriz:
     * 
     *        delegate void OnDelegate(object sender, EventArgs e)
     *       
     * Bu tanımala gereği bizim EventArgs diye "genel olay parametreleri" tutan bir üst sınıfa ihtiyacımız var
     * Bu sınıftan kendi parametrelerimizi taşıyan sınıflar yaratarak aynı delegate tipini kullanabiliriz
     *  
     * ----- EVENTHANDLER TİPİ İŞİMİZİ GÖRECEK SANKİ
     * Yukarıdaki delegate tip tanımına uyan genel bir tip var adı: EventHandler tipi. 
     * Hem her olaya uygun olan EventArgs tipinde parametresi de var
     * 
     *      public delegate void EventHandler(object sender, System.EventArgs e)
     *      
     * Şeklinde tanımlı ve yukarıdaki imzaya uygun(void dönen ve iki parametre alan[object, EventArgs] metotlar için)
     * EventHandler tipini kullanabiliriz artık.
     */

    // ----- GENEL OLAY PARAMETRE TİPİ olan EventArgs'dan türesin olay parametre tipimiz
    public partial class Shoot : EventArgs { }

    /** 
     * Artık olay tanımımızı değiştirebiliriz
     */

    public partial class Topcu
    {
        // Başlangıç için boş bir isimsiz metodu değer olarak atadık ki 
        // eventi tetikleyeceğimiz yerde if(OnShoot2 != null){ OnShoot2(..) } null kontrolüne gerek kalmasın
        public event EventHandler OnShoot2 = delegate(object sender, EventArgs args) { };
    }
    /**
     * OnShoot2 metoduna parametre olacak gelen args değerleri Shoot türünden olabilir.
     * Ancak içeride bilinçli(explicit) cast(tür dönüşümü) etmeliyiz
     * 
     * kaleciMuslera.OnShoot2 += (sutuVuranOyuncu, sutunOzelligi) => Console.WriteLine(((Shoot)sutunOzelligi).Hiz);
     * 
     * gibi. 
     * Yada generic tip olan EventHandler<T> ile EventArgs türünden değil, kendi parametre türümüz olan Shoot türünden
     * bir method handler yaratmasını söylemeliyiz. 
     * 
     * Aşağıdaki gibi:
     */

    public partial class Topcu
    {
        // Generic tipli EventHandler'ı kullanarak bizim arguman tipimizden değerleri geçiriyor olağız.
        // eventi tetikleyeceğimiz yerde if(OnShoot3 != null){ OnShoot3(..) } null kontrolüne gerek kalmasın
        public event EventHandler<Shoot> OnShoot3 = delegate(object sender, Shoot args) { };
    }

    /**
     * Eğer Topcu sinifindan türeyen bir SolBek tipimiz olsa ve onun da OnShoot olayını tetiklemesi gerekse
     */

    public partial class SolBek : Topcu
    {
        public override void Ceza_Sahasina_Topla_Gir()
        {
            base.Ceza_Sahasina_Topla_Gir();
        }

        /// <summary>
        /// Sol beklerin şutu azıcık farklı olsun. 
        /// Mesela sol ayağına gelirse normal golcüden 2 kaplan daha güçlü vursun ;)
        /// </summary>
        public void SolAyaklaShoot()
        {
            // Topu düzeltsin,
            // Sol ayağına alsın, 
            // hede höde yapsın ve vursun. OnShoot olayı ata sınıftan tetikleneceği için
            // base.veShoooot metodunu çağırsın
            base.veShoooot(new Shoot()
                           {
                               Hiz = 100,
                               Aci = 70, //azicik yamuk vursun
                               Zaman = DateTime.Now
                           });

            // sonra ellerini başının arasına alsın,
            // Geri koşsun vs. vs....
        }
    }
}

Şimdi biz neden event diye bir
Çalışan hali

using System;
using System.Threading;

namespace caEvent1
{
public delegate void OnDemlendi();

class CayMakinasi
{
public CayMakinasi()
{
Console.WriteLine("Çay koyuldu...");
}

public event OnDemlendi eventDemlendi;

public void Demle()
{
Console.WriteLine();
Console.Write("Çay demleniyor ");
for (int i = 3; i > 0; i--)
{
Console.Write(".");
Thread.Sleep(1000);   
}
Console.WriteLine();
Demlendi();
}

private void Demlendi()
{
if (eventDemlendi!=null)
{
Console.WriteLine("  ---       DEMLİK İÇİNDE İŞLEMLER YAPILIYOR       --- ");
Console.WriteLine("  --- Demlikte işlem yapılıyor. Bitince haber verilecek");
Console.WriteLine("  --- ");
Console.Write("  --- Demleniyor");
for (int i = 3; i > 0; i--)
{
Thread.Sleep(3000);
Console.Write(".");
}
Console.WriteLine("  --- ");
Console.WriteLine("  --- Demlikten Haber VAR: <Çay demlendi>");
Console.WriteLine();
Console.WriteLine();
eventDemlendi();
}
}
}

class Program
{
static void Main(string[] args)
{
Console.WriteLine("Çay yapmaya başlıyoruz...");
Console.WriteLine();

CayMakinasi cm = new CayMakinasi();
cm.eventDemlendi += new OnDemlendi(cm_OnDemlendi);

cm.Demle();

Console.WriteLine();
Console.WriteLine("Tavşan kanı bunlaaarrr...");
}

static void cm_OnDemlendi()
{
Console.WriteLine("**************************************************************");
Console.WriteLine("* Çayın olduğunda, makine metot işaretçisini tetikler.");
Console.WriteLine("* ");
Console.WriteLine("* O işaretçiyede kendi metodumuzu iliştiririzki ");
Console.WriteLine("* tam o sıra bizde işlemler yapabilelim.");
Console.WriteLine("* ");
Console.WriteLine("* Buna en güzel örnek, düğmeye tıklandığında işlem yapmamız");
Console.WriteLine("*  ya da GridView'a her satır eklendiğinde (RowDataBound) ");
Console.WriteLine("* satıra müdahale etme isteğimiz verilebilir.");
Console.WriteLine("**************************************************************");

}
}
}

Çalışan hali

using System;
using System.Threading;

namespace caEvent1
{
public delegate void OnDemlendi();

class CayMakinasi
{
public CayMakinasi()
{
Console.WriteLine("Çay koyuldu...");
}

public event OnDemlendi eventDemlendi;

public void Demle()
{
Console.WriteLine();
Console.Write("Çay demleniyor ");
for (int i = 3; i > 0; i--)
{
Console.Write(".");
Thread.Sleep(1000);   
}
Console.WriteLine();
Demlendi();
}

private void Demlendi()
{
if (eventDemlendi!=null)
{
Console.WriteLine();
Console.WriteLine("  *** Demlikten Haber VAR: <Çay demlendi>");
Console.WriteLine();
Console.WriteLine();
eventDemlendi();
}
}
}

class Program
{
static void Main(string[] args)
{
Console.WriteLine("Kahvehanede müşteri seslenir.");
Console.WriteLine("  - Garsooon 3 çaaay...!");
Thread.Sleep(1000);
Console.WriteLine("Garon cevap verir.");
Console.WriteLine("  - Taze yapıyorum Ali abicim...");

Thread.Sleep(1500);            
Console.WriteLine("Çay Makinesinin fişi takılır(nesne yaratılır),");
CayMakinasi cm = new CayMakinasi();

Thread.Sleep(4000);
Console.WriteLine("Çay olunca makine ötecek. Bizde bu sinyali duyar duymaz çay almaya gideceğiz.");
cm.eventDemlendi += new OnDemlendi(cm_OnDemlendi);

Thread.Sleep(2000);
Console.WriteLine("Çay Makinesinin ÇAY YAP düğmesine basılır(nesnenin metodu tetiklenir)");
cm.Demle();

Console.WriteLine("Tavşan kanı bunlaaarrr...");
}

static void cm_OnDemlendi()
{
Console.WriteLine("Garson makinenin başına gelir ve 3 çay koyar.");
Thread.Sleep(2500);
}
}
}

Peki birde metin okuyan ve "okuma tamamlandığında" olayında çalışan fonksiyon örneğiyle bir kod görelim:

using System;
using System.Speech.Synthesis;
using System.Threading;

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            SpeechSynthesizer synthesizer = new SpeechSynthesizer();
            synthesizer.Volume = 100;  // 0...100
            synthesizer.Rate = -2;     // -10...10

            // Synchronous
            synthesizer.Speak("Merhaba Cem");
            synthesizer.SpeakCompleted += (a, b) =>
                                          {
                                              Console.WriteLine("Konuşma tamamlandı");
                                          };

            // Asynchronous
            var p = synthesizer.SpeakAsync("Asynchronous talk with Speak Async");
            while (!p.IsCompleted)
            {
                Console.WriteLine("Async function is still continuing");
                Thread.Sleep(100);
            }
            Console.WriteLine("End of Main Thread");
        }
    }
}

Form harici bir sınıftan formun kontrollerine erişmek

using System;
using System.Threading;
using System.Windows.Forms;
/**
 * Invoke metodu ne iş yapar? 
 *    Invoke işlemi bir thread içinde işlem yaparken başka threaddeki bir control üzerinde işlem yapmamızı sağlar. 
 *    Invoke metodunu kullanmadan bu control'e erişmeye kalkarsak 
 *    "Cross-thread operation not valid" 
 *    gibi bir mesaj alırız. 
 *    
 * Eğer runtime da ekledigimiz controller varsa ve thread içerisinde onlara erişmemiz gerekiyorsa 
 * invoke ve delegate kullanarak bunu yapabiliriz. 
 **/ 
namespace waForm
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private delegate void DelFormCalisirkenBizimMetodaErismemizeYardimciOlacakMetotReferansi();
        
        private void button1_Click(object sender, EventArgs e)
        {
            FormHariciSinif mt = new FormHariciSinif();

            DelFormCalisirkenBizimMetodaErismemizeYardimciOlacakMetotReferansi yardimciOlacakMetotReferansi
                = new DelFormCalisirkenBizimMetodaErismemizeYardimciOlacakMetotReferansi(mt.f_CalistirmakIstedigimizMetot);

            /** 
             * Formun çalışmasından farklı olarak (Bunun main thread, ilk iş parçacığımız olduğunu unutmayalım)
             * Calismasini istediğimiz 
             * "FormHariciSinif" 
             *    sınıftan türetilen bir objenin 
             *    
             * "f_CalistirmakIstedigimizMetot" 
             *    metodu bulunuyor.(Bununda ikinci iş parçacığı olacağını unutmayalım)
             *    
             * Ama metodumuz formun dışında bir sınıfın objesine ait olacağı ve her işlemin sonunda Form daki btn isimli button 
             * kontrolüne erişeceği için thread ler arası(iş parçacıkları arası) bir iletişime ihtiyacımız var.
             **/

            // Metodun sonunda, f_InvocationBitti metodu çalışsın
            yardimciOlacakMetotReferansi.BeginInvoke(f_InvocationBitti, null);  
        }

        private void f_InvocationBitti(IAsyncResult _ar)
        {
            if (_ar.IsCompleted)
            {
                MessageBox.Show("bitti");
            }
        }
    }

    public class FormHariciSinif
    {
        public void f_CalistirmakIstedigimizMetot()
        {
            Form frm = Form.ActiveForm as Form1;
            Button btn = (Button) frm.Controls.Find("btn", true)[0];
            for (int i = 0; i < 10; i++)
            {
                if (btn.InvokeRequired)  // btn nesnesine başvuru farklı iş parçacığından mı? yani invoke gerekli mi?
                { // Gerekiyorsa, yeniden bir metodun referansına Invoke ile gideriz.
                    btn.Invoke(new MethodInvoker(delegate
                                                     {
                                                         btn.Text = i.ToString();
                                                     }));
                }

                Thread.Sleep(250); // Çalıştığını görelim diye.
            }

            /** for döngüsünden çıkınca da çalışsın diye buraya konulabilirdi ama 
             *  biz, BeginInvoke(fBitinceCalisacakFonk,null) diye yazdık.             
             
            if (btn.InvokeRequired)
            {
                btn.Invoke(new MethodInvoker(delegate
                                                 {
                                                     MessageBox.Show("bitti");
                                                 }));
            }
             * */
        }
    }
}

Java da Thread

Threadi tanımak için bu makaleyi okuyabilirsiniz.
Öncelikle java Thread sınıfı ve Runnable interfacesini bize hizmet etsinler diye verir. Thread sınıfının Runnable arayüzünün implemente edilmiş sınıfların objesini kabul eden bir yapıcı metodu vardır. Java da bir kalıtım yapacak olursak ancak bir sınıftan extend edebiliriz(Single Inheritance).


SINGLE INHERITANCE:
Bu da java da single inheritance olarak geçmektedir. Peki biz bir sınıf yaratalım ve ata sınıfı A olsun. Ama aynı zamanda sınıfımızda Thread işlemleri de yapabilmek için Thread sınıfından türetelim. Bunu aşağıdaki gibi yapmak gerekiyor.

  class A {
    // falanda filan
  }

  class B extends A, Thread{ // Hata verecektir. Single Inheritance a göre.
    // falanda filan
  }

Ama burada hata oluşur çünkü Hem A sınıfından hem Thread sınıfından sınıfımızı extend edemeyiz.


Single Inheritance yüzünden bizde Runnable arayüzünü kullanırız. Böylece Thread işlemlerine kendi sınıfımızı sokabiliriz.

  class B extends A implements Runnable{
    // Falanda filan
  }

Yazdığınız herhangi bir java programının başlangıç yordamı public sınıfın main metodudur. Bu metod işlerken standart program için bir Thread oluşur ve program sonlandığında Thread’ da sonlanır. Ancak bununla birlikte bir sınıf içindeki diğer yordamlarında hem programın bir parçasıymışçasına hem de programdan bağımsız işlemci gücü kullanarak çalışması Thread sayesinde yapılabilir. Bu iş parçacıkları ana iş parçacığı içinden yönetilebilir. Ref:JAVA İçinde Thread Kullanımı

Thread Önceliklerini Belirlemek

Bunun sonucunda çıktımız aşağıdaki gibi olacaktır. Artık first thread ilk çalışıyor dikkat ederseniz.

Arkaplan ve Önplan threadleri (Foreground, Background Threads)


thObj.setDaemon(true); // Background Thread olsun

ile threadimiz background thread olarak çalışır. Uygulama bitirilmek istendiği zaman background threadler kapanmayı geciktirmez.Ama foreground threadler bitirilmeden uygulama kapatılamaz.
Kodumuz aşağıdaki gibi olacak:


Sonuç foreground thread olduğu için ikinci thread bitinceye kadar bekleyecek şekilde yani aşağıdaki gibi olacaktır.

10 sn bekleme bittikten sonra;

Threadi Durdurmak

Bir threadi durdurmak için önceden stop() fonksiyonu kullanılırken şimdilerde abilerin tavsiyesi ile bir şart değişkeni kullanılarak işleyiş durdurulmalıdır.

public class Thredim extends Thread{
  public void run(){
    while(!timeToStop){
      // birşeyler yap
    }
  }

  void StopToRunning(){
    timeStop= true;
  }

}

Delegate ile Thread yaklaşımı.

Sözün Özü
Çünkü bu konuda çok örnek var. Ben sadece iki çok az daha farklı metot ile anlaşılırlığı birazcık daha arttırmak istedim. Ama esas vurgum en alttaki nota olacak. "this.InvokeRequired" herhangi bir delegate (beginInvoke) ile çağırıldığında TRUE olarak set ediliyor. Yani listbox1.InvokeRequired ya da button1.InvokeRequired doğrudan Main Thread den başka bir threade geçilmek isteniyor mu (BeginInvoke call edilmiş mi?) diye bakar. this.InvokeRequired, listbox1.InvokeRequired ya da button1.InvokeRequired ile de geçişi yakalayabilirsiniz.

Olayımız Nedir?
Butonumuz kırmızı ve gri olacak Timer1 nesnemizle her 3 saniyede. Bu arada thread bir for içinde dönecek 1000000... gibi bir sayıya ulaşıncaya kadar listBox1 içine item ekleyeceğiz.
Sonuç aşağıdaki gibi olacak:

Bunu aşağıdaki kodla yapabiliyoruz:


Aşağıdaki kodla da yapabiliyoruz:


NOT:

InvokeRequired required compares the thread ID of the calling
thread to the thread ID of the creating thread.
If these threads are different,it returns true.

namespace wfDelegate
{
    public partial class Form1 : Form
    {
        private delegate void DelYeni();
        private DelYeni delYeniBeginInvoke;

        private delegate void DelSayListeyeEkle();
        private DelSayListeyeEkle delSayEkle;


        public Form1()
        {
            delYeniBeginInvoke = new DelYeni(YeniDelegate);
            delSayEkle = new DelSayListeyeEkle(SayListeyeEkle);
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            delSayEkle.BeginInvoke(null, null);
        }

        void SayListeyeEkle()
        {
            for (int i = 0; i < 1000000000000; i++)
            {
                ListeyeEkle(i);
            }
        }

        private bool b;
        private void ListeyeEkle(object item)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new MethodInvoker(
                    delegate
                        {
                            b = this.InvokeRequired;
                            delYeniBeginInvoke.BeginInvoke(null, null);
                            listBox1.Items.Add(item);
                        }));
            }
        }


        void YeniDelegate()
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new MethodInvoker(
                                delegate
                                {
                                    button1.Width = 250;
                                }));
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (button1.BackColor == Color.Red)
                button1.BackColor = Color.DimGray;
            else
                button1.BackColor = Color.Red;
        }
    }
}