Öncelikle yazımı okuyan herkese merhabalar demek istiyorum. Bu yazımda sizlere piyasayı bir bilgisayar mühendisliği bölümünde okuyan bir öğrencinin gözünden anlatmaya çalışacağım.

Mesleğimiz itibari ile bir çok alanda çalışma imkanımız bulunmasına rağmen, piyasada bilindiği üzere bir çok işsiz yada az maaşla çalışan bilgisayar mühendisi var. Bu durumda benim gibi bir çok mühendis adayını korkutuyor. Ha gerçi bir çok kişide bunu bilmesine rağmen okul hayatında gezmeyi, eğlenmeyi çok daha ön planda tutuyor kendini geliştirmekten (kendimi bu kategoride görmüyorum neyse ki :) ).

Belki de korkmamızın sebeplerinden birisi okulda verilen eğitimden ziyade ( oraya birazdan geleceğiz ), bir bilgisayar mühendisi, yazılım mühendisi, Web & Mobil uygulama geliştirici aklınıza hangi dallar geliyorsa artık, tam olarak ne iş yaptıklarını bilmememizden de kaynaklanıyor olabilir. Okullarda ders veren bir çok hoca akademik kariyerleri yüksek fakat piyasa bilgileri sıfıra yakın olan insanlar. Bu yüzden piyasa konusunda onlardan pekte bir şey öğrenemiyoruz. Bu eksikliğimizi 1 günlük eğitim seminerlerine profesyonelleri çağırarak gidermeye çalışıyoruz oda yeterli olmuyor. Buna yakından şahit olan bir öğrenciyim :) ve havada uçuşan bir sürü abidik gubidik sertifika eğitimleri ve bunları alacağım diye uğraşan bir sürü insan. Bu sorunun çözümü bence okulların akademik kariyerleri yüksek, bilgili hocaların arasına bir kaç tanede piyasayı iyi bilen, piyasada çalışan hatta, profesyonelleri de eğitim kadrolarına dahil etmeleri.

Şimdi gelelim eğitime, ilk soru okulda verilen eğitim bilgisayar mühendisi olmak için yeterli mi?

Sorunun cevabı çok açık ve net tabi ki de hayır. Diyebilirsiniz senin okulunun belkide eğitim kalitesi düşüktür diye. Ben Lefke Avrupa Üniversitesinde okuyorum. Hocalarımızın bir çoğuda gerçekten çok bilgili ve kariyerli insanlar. Bu arada Akdeniz Üniversitesinde de okudum bu yüzden bu sorunun cevabını rahatlıkla verebiliyorum. Okul sadece işin temelini vermeye çalışır doğrumu derseniz değil tabi ki de ama böyle. Gerisi öğrencinin kendisine bırakılır öğrenciye de işin tembellik tarafı daha cazip gelir. Ki bu yüzden de piyasada bir çok işsiz, iş arayan yeni mezun bilgisayar mühendisleri ile dolu. Ha birde en büyük sorunlardan birisi bence, bir çok okulun microsoft sevdası. Tabi ki microsoft, microsoft programlama dilleri bir bilgisayar mühendisi için önemli ama bir çok öğrenci arkadaşım bu güne kadar bir Linux işletim sistemi kullanmadı belkide görmedi bile. Open source bir çok güçlü programlama dili var ama okul microsoft diye dayattığı için öğrenci mesaisini microsoft üzerinde harcamak zorunda kalıyor. Bende biraz geç olsa da bunun farkına vardım ve web programlama alışkanlığımı değiştirmeye başladım ve PHP öğrenmeye çalışıyorum. Ve şiddetle diğer arkadaşlarıma da öneriyorum bir open source programlama dilini öğrenmeye başlasınlar. Mesela bir çok arkadaşım mobil programlama hakkında zerre bir şey bilmiyorlar. Okullar müfredatlarını gelişen teknolojiye göre yenilemek durumundalar ama Türkiye’de ne yazık ki bunu yapan üniversite sayısı bir elin beş parmağını geçmez.

Neyse naçizane bir önerim de olacak arkadaşlarıma çalışmak istediğiniz sektörün iş ilanlarını yakından takip edin ve orada istenilen özelliklerin hepsini olmasa da bir kısmını okul bitmeden edinmeye çalışın ki okul bittiği zaman kara kara düşünmeyesiniz ne iş yapacağım nasıl bulacağım diye ;) .

Lafı fazla uzatmadan son olarak bende bir bilgisayar mühendisi adayı olarak ve son sınıf öğrencisi olarak biraz da olsa panik havasındayım ama inanıyorum ki bir çok arkadaşım da bende bir gün çok iyi mevkilerde olacağız.

Kolay Gelsin
Kaynak : blog.fettahkurtulus.com

Uygulama geliştirirken OOP prensiplerine yaklaştıkça nesneler arasındaki ilişkilerin önemi de gitgide artıyor.  Ben de tasarım desenlerine verdiğim kısa arada çok karıştırılan iki kavramdan bahsetmek istiyorum. Nesneler arasındaki iki ilişki türü : Aggregation, Association

Aggregation : Bu tür ilişki de nesnelerin yaşam döngüleri birbirlerinden ayrıdır. Bir nesne diğerinden bağımsız olarak da yaşamını sürdürebilir. Yani aralarında bir sahiplik ilişkisi (has-a ) vardır. Örneğin Dizüstü Bilgisayarınız ile onun çantası arasında böyle bir ilişki vardır. Çantayı ayrı olarak ya da laptop’u ayrı olarak düşünebiliriz. Yaşam döngüleri ortak değildir. UML diagramında gösterimi ve koda dökülmüş bir örneği aşağıdaki gibidir.

public class Canta
{

}
public class Laptop {
private Canta _canta;
public Laptop(Canta canta)
{
_canta = canta;
}
}

Composition : Bu tür ilişki de nesnelerin yaşam döngüleri birbirleriyle bağlantılıdır. Bir nesne diğerinden bağımsız olarak kullanılamaz. Aralarındaki ilişki parçası olma(is-a-part-of ) ilişkisidir. Az önceki örneğimizden gidersek dizüstü bilgisayarımız ile ekranı arasında bu tarz bir ilişki vardır. UML diagramında gösterimi ve koda dökülmüş bir örneği aşağıdaki gibidir.

public class Ekran
{

}
public class Laptop
{

Ekran _ekran = new Ekran();
}

Şu aralar daha önceden üzerinden geçtiğim tasarım desenleri ile uğraşıyorum tekrar. Ama bu sefer biraz daha pratik şekilde ilerlemeye çalışıyorum. İlerdikçe de burada hem bana ilerde hatırlamam için not olması hem de ihtiyacı olanların faydalanması için paylaşmaya çalışıyorum.

Son yazımda Strateji tasarım deseninden bahsetmiştim. Bu kez ise Observer tasarım deseninden bahsetmeye çalışacağım. Örneğin bir alışveriş sitesinin kampanyalarından haberdar olmak için maillist’ine kayıt olduğunuzu düşünün, daha sonra bir başkasının da aynı listeye abone olduğunu düşünelim. Bir kampanya olduğunda siteden abone olan herkese bu kampanya gönderilir.  Daha sonradan artık kampanya bilgilerini almak istemezseniz listeden çıkarsınız ve artık yeni kampanya bilgileri diğer abonelere gönderilir.

Observer tasarım deseni de uygulamalarımızdaki bu tarz işlemlerimizi yapmamızı kolaylaştıran bir desendir. Örneğin bir nesnenin durumu değiştiğinde uyarılacak nesneler listesine eklenmiş nesnelerimiz otomatik olarak uyarılır.

Bu desen ile ilgili örneğimi bir önceki strateji deseni örneğim üzerinden yapacağım. Böyle olması biraz daha karışık olmasına sebep oldu ama ezbere kaçmayı önlememi sağladı. Ayrıca iki deseni bir örnek de birleştirmiş oldum. Öncelikle eklememiz gereken yeni arayüz ve sınıfları vereceğim, daha sonra değişiklik yapmamız gereken kısımlardan bahsedeceğim.

İlk olarak biri yayıncı(subject) biri de dinleyici (subscriber,observer) olmak üzere iki interface tanımlayacağım. Daha sonra kullanacağım bütün dinleyici ve yayıncı sınıfları bu sınıflardan türeteceğim.

public interface IYayinci
{
void dinleyiciKaydet(IDinleyici dinleyici);
void dinleyiciCikar(IDinleyici dinleyici);
void dinleyicileriUyar();
}
public interface IDinleyici
{
void guncelle(ArrayList args);
}

Burada IYayinci arayüzümüzde üç adet metodumuz var bunlar uyarılacak nesneleri eklememizi, çıkarmamızı ve nesnenin durumu değiştiğinde listemizdeki nesnelerin uyarılmasını sağlıyor. IDinleyici arayüzündeki metodumuz ise durum değişikliği olduğunda yapılması gereken işlemleri içeren metoddur.

İkinci olarak yayıncı sınıfımızı oluşturuyoruz. Bu sınıfımızda arayüzden aldığı metodları implemente ediyoruz. Ayrıca ben bir adet renkDegisti metodu ekledim ki bu metodu da renk değişimi olduğunda kullanacağız.

public class RenkYayinci : IYayinci
{
ArrayList _dinleyiciler;
ArrayList _args;
public RenkYayinci()
{
_dinleyiciler = new ArrayList();
_args = new ArrayList();
}
public void dinleyiciKaydet(IDinleyici dinleyici)
{
_dinleyiciler.Add(dinleyici);
}
public void dinleyiciCikar(IDinleyici dinleyici)
{
int i = _dinleyiciler.IndexOf(dinleyici);
if (i >= 0)
{
_dinleyiciler.RemoveAt(i);
}
}
public void dinleyicileriUyar()
{
for (int i = 0; i < _dinleyiciler.Count; i++)
{
IDinleyici dinleyici = (IDinleyici)_dinleyiciler[i];
dinleyici.guncelle(_args);
}
}
public void renkDegisti(string renk)
{
_args.Clear();
_args.Add(renk);
dinleyicileriUyar();
}
}

Burada renkDegisti metoduna renk değişkenini almama rağmen bunu arraylist’e atma sebebim IDinleyici arayüzünün sadece renk için özelleşmesini engellemek ve daha sonra da kullanmak istememdir. Daha sonra dinleyicileriUyar() metodunu çağırıyoruz ve bütün ekli nesneleri haberdar ediyoruz.

Artık eski sınıflarımızda değişiklik yapmaya başlayabiliriz. Öncelikle Daire ve Kare Sınıflarımızı aşağıdaki şekle getiriyoruz.

public class Kare : Sekil, IDinleyici
{
private RenkYayinci _renkYayinci;
public Kare(Dictionary<string, int> degerler, RenkYayinci renkYayinci)
{
_cevre = new KareCevre();
_degerler = degerler;
this._renkYayinci = renkYayinci;
this._renkYayinci.dinleyiciKaydet(this);
}
public void guncelle(ArrayList args)
{
Console.WriteLine(“\nKare kenar renkler değişti ” + args[0].ToString());
}
}

public class Daire : Sekil, IDinleyici
{
private RenkYayinci _renkYayinci;
public Daire(Dictionary<string, int> degerler, RenkYayinci renkYayinci)
{
_cevre = new DaireCevre();
_degerler = degerler;
this._renkYayinci = renkYayinci;
this._renkYayinci.dinleyiciKaydet(this);
}
public void guncelle(ArrayList args)
{
Console.WriteLine(“\nDaire çember içi renkler değişti” + args[0].ToString());
}
}

Sınıf tanımlamalarımızda koyu ile işaretli yerleri değiştiriyoruz. Burada öncelikle constructor metodumuzda parametre olarak aldığımız yayıncıya nesnemizi ekliyoruz. Daha sonra dinleyici arayüzünden alınan guncelle metodunu implemente ediyoruz.

Artık desenimizi deneyebiliriz. Önceki yazımızda bulunan örnekteki main metodunu aşağıdaki şekilde değiştiriyoruz.

static void Main(string[] args)
{
Dictionary<string, int> dd = new Dictionary<string, int>();
dd.Add(“BirKenar”, 4);
RenkYayinci renkYayinci = new RenkYayinci();
Sekil sk = new Kare(dd, renkYayinci);
renkYayinci.renkDegisti(“mavi”);
Console.WriteLine(sk.cevreHesapla(dd).ToString());
Console.ReadLine();
}

Programımızı derleyip çalıştırdığımızda karşımızda

Kare kenar renkler değişti mavi

16

çıktısını görebiliriz.

Strateji tasarım deseni geliştirdiğimiz uygulama içinde algoritmaları sınıflandırmamızı ve çalışma anında kullanacağımız algoritmayı seçmemizi sağlar. Bu algoritmalar kendi içinde kapsüllenerek (encapsulate) programın geri kalanından soyutlanır ve uygulamamızın loosely coupled bir yapıda olmasına yardım eder. Örneğin bir maliyet hesabında LIFO mu yoksa FIFO mu kullanacağımızı çalışma anında belirlemek istiyorsak strateji tasarım desenini kullanarak bunu nesne yönelimli programlama ilkeleri doğrultusunda yapabiliriz.

Algoritmaların seçim işlemini if else blogları ile yapabilirdik. Ancak küçük bir değişiklikte uygulamamızın içine müdahale etmek zorunda kalırdık. Ayrıca yeni algoritmalar ekledikçe bu if else bloglarımız gittikçe uzayacaktı. Ya da işlemi kalıtım yolu ile de gerçekleştirebilirdik. Bir metodu üst bir sınıfta tanımlayıp, alt sınıflarda bu metodu override edebilirdik. Ancak bu durumda da bir değişiklik durumunda bütün alt sınıflarda kodu tekrar düzenlememiz gerekecekti. Ya da eklediğimiz her yeni sınıf için yeniden metodu override etmemiz gerekecekti. Bu durumda kodların yeniden kullanılabilirliği konusunda başarısız olacaktık.

Bu deseni nasıl uygulayabileceğimizi bir örnekle daha iyi gösterebiliriz. Ben nesne yönelimli programlama ile ilgili örnekler verirken daha anlaşılır ve daha uygulanabilir olması nedeniyle mümkün olduğunca şekiller üzerinden gitmeyi tercih ediyorum. Yine vereceğim bu örnekte Strateji tasarım desenini kullanarak Şekil sınıfından türeyen daire ve kare sınıflarının çevrelerini hesaplayan basit bir uygulama yazacağım.

Öncelikle çevre hesaplama algoritmalarını bir araya toplamam gerekiyor. Kapsülleme işlemini gerçekleştirmek ve çevre hesaplama algoritmalarını belli bir formatta tutmak için öncelikle bir interface yazıyorum.

public interface ICevre
{
int hesapla(Dictionary<string, int> degerler);
}

Bundan sonra çevre hesaplama algoritmalarımı tutacak bütün sınıfları bu interface’den türeteceğim. Bu interface’imiz bir adet hesapla metodu içeriyor. Interface’imizden sonra ise çevre hesaplayacak sınıflarımızı oluşturacağız.

public class DaireCevre : ICevre
{
private int cevresi = 0;
public int hesapla(Dictionary<string, int> degerler)
{
cevresi = 2*degerler["Pi"]*degerler["r"];
return cevresi;
}
}

DaireCevre sınıfımız ICevre interface’inden aldığı hesapla metodunu implemente ediyor. Aynı şekilde KareCevre sınıfını da yazıyoruz. Bu sınıf da kendine özgü algoritmasıyla çevre hesaplamasını yapıyor.

public class KareCevre : ICevre
{
private int cevresi = 0;
public int hesapla(Dictionary<string, int> degerler)
{
cevresi = degerler["BirKenar"]*4;
return cevresi;
}
}

Artık çevre ile ilgili hesaplamalarımızı yaptığımıza göre kullanacağımız sınıfları yazmaya geçebiliriz. İlk olarak şekillerimi türeteceğim bir Sekil sınıfı yazıyorum.

public class Sekil
{
public ICevre _cevre;
public Dictionary<string, int> _degerler;

public int cevreHesapla(Dictionary<string, int> degerler)
{
return _cevre.hesapla(degerler);
}
}

Bu sınıfımızda bütün algoritma sınıflarımızı kapsayabilmesi için bir adet ICevre interface’i nesnesi oluşturuyoruz. Böylece loosely coupled özelliğini de sağlamış oluyoruz. Yeni ekleyeceğimiz, çıkaracağımız ya da değiştireceğimiz algoritmalar uygulamanın geri kalanını etkilemiyor. Ayrıca parametreler için bir adet Dictionary nesnesi tanımladım. Burada gördüğümüz cevreHesapla metodu bizim dışarıdan erişeceğimiz ve hesaplama işlemlerini yaptıracağımız metod. Kendi içinde hangi şeklinde çevresi hesaplanacak ise ona ait metodu çağırıyor.

Artık kullanacağımız sınıfları yazabiliriz.

public class Kare : Sekil
{
public Kare(Dictionary<string, int> degerler)
{
_cevre = new KareCevre();
_degerler = degerler;
}
}

public class Daire : Sekil
{
public Daire(Dictionary<string, int> degerler)
{
_cevre = new DaireCevre();
_degerler = degerler;
}
}

Bu sınıflarımız da constructor metod çağrıldığında ICevre türünden olan nesnemize ilgili cevre sınıfı nesnesi(DaireCevre, KAreCevre) oluşturularak atanıyor. Böylece doğru hesapla fonksiyonunun çağrılması sağlanıyor.

Son olarak uygulamamızı deneyeceğimiz kısmı yazabiliriz.

static void Main(string[] args)
{
Dictionary<string,int> dd = new Dictionary<string,int>();
dd.Add(“BirKenar”,4);
Sekil sk = new Kare(dd);
Console.WriteLine(sk.cevreHesapla(dd).ToString());
Console.ReadLine();
}

Böyle bir denemede ekrana 16 yazacaktır.

www.mehmetkordaci.com

Elimizde iki tablolu bir yapı olduğunu düşünelim, İşçiler ve Yöneticiler. Üç adet yöneticimiz ve bu yöneticilere bağlı 60000 çalışanımız olsun. Yöneticilere ait olan işçi sayılarına baktığımızda :

Select COUNT(*),yoneticiID
From tblIsci
Group By yoneticiID
Order By yoneticiID

Yonetici ID

İşçi Sayısı

1

40000

2

19999

3

1

İlk olarak 1 adet işçinin bağlı olduğu ID si 3 olan yöneti ve işçi bilgilerini sorgulayalım.

Sıra

SQL Sorgusu

Sonuç

1

SELECT isciID,
	   isciAdi,
           (SELECT yoneticiAdi 
	    FROM tblYonetici 
	    WHERE tblYonetici.yoneticiID = 
     tblIsci.yoneticiID)
     FROM tblIsci
     WHERE tblIsci.yoneticiID = 3

Etkilenen Satır Sayısı : 1

Sorgu Maaliyeti : 0.0006

2

SELECT isciID,
	   isciAdi,
	   yoneticiAdi 
  FROM tblIsci
	   INNER JOIN tblYonetici ON (tblYonetici.yoneticiID =
	   tblIsci.yoneticiID)
WHERE tblIsci.yoneticiID = 3

Etkilenen Satır Sayısı : 1

Sorgu Maaliyeti : 0.0006

Yukarıdaki 1 ve 2 numaralı testleri incelediğimizde etkilenen satır sayısı ve sorgu maaliyetleri aynı oldu. Şimdi birde etkilenen satır sayısı arttığında sorgu maaliyetinde bir değişme olacak mı ? bunu gözlemleyelim.

Sıra

SQL Sorgusu

Sonuç

3

SELECT isciID,
	   isciAdi,
           (SELECT yoneticiAdi 
	    FROM tblYonetici 
	    WHERE tblYonetici.yoneticiID = 
     tblIsci.yoneticiID)
     FROM tblIsci
     WHERE tblIsci.yoneticiID = 1

Etkilenen Satır Sayısı : 40000

Sorgu Maaliyeti : 4.326

4

SELECT isciID,
	   isciAdi,
	   yoneticiAdi 
  FROM tblIsci
	   INNER JOIN tblYonetici ON (tblYonetici.yoneticiID =
	   tblIsci.yoneticiID)
WHERE tblIsci.yoneticiID = 1

Etkilenen Satır Sayısı : 40000

Sorgu Maaliyeti : 0.305

3 ve 4 numaralı testlerimize baktığımızda etkilenen satır sayıları eşit ve 40000, ama bu sefer sorgu maaliyetleri Join işleminde düşük çıktı.

Sonuç olarak kullanacağımız sorgularda eğer farklı tablolardan veriler ile çalışıyor ve etiklenecek olan satır sayısının büyük olacağını kestirebiliyorsak Join işlemlerini Sub Query işlemlerine tercih etmeliyiz.

Sql 2008 ‘ i Kurdunuz ve Reporting services ayarları yapmaya çalışıyorsunuz ve bu hatayı alıyorsunuz. Configuration Manager: “Invalid namespace”.
Devamını okuyun »

Bu desen Factory Method desenine çok benzer. Amaç yine aynıdır. Sistemden nesnelerin oluşma işini soyutlar. Abstract Factory benzer özellikleri olan nesne fabrikalarını gruplar. İçinde birden fazla fabrika vardır.
Örneğimizde birden fazla türde database’de kaydetme ve sorgulama işlemlerini gruplamak için soyut fabrikayı kullanıyoruz :
Kısaca kodlarına da bakalım :
Devamını okuyun »

Bu tasarım deseni nesne oluşturma işini sistemden ayırır ve aldığı parametreye göre nesneleri oluşturarak kullanıcıya geri döner.
Bir örnek verecek olursak düşünün ki gezmeye giderken farklı yöntemleriniz olsun. Ben şimdilik iki tane kullanacağım : Araba ve Bisiklet. Bu iki sınıf “Yöntem” arayüzümüzden türemişler. Bir adet de YöntemFabrika’mız var.

Yöntem.cs

interface Yöntem
{
void Gez();
}

Araba.cs

class Araba : Yöntem
{
public void Gez()
{
MessageBox.Show(“arabayla geziyorum”);
}


}

Bisiklet.cs

class Bisiklet : Yöntem
{
public void Gez()
{
MessageBox.Show(“bisikletle geziyorum”);
}


}

YöntemFabrikası.cs

class YöntemFabrikası
{
public Yöntem yöntemYarat(string opt)
{
if (opt == “arabayla”)
return new Araba();
else if(opt==”bisikletle”)
return new Bisiklet();

return new Araba();//if’lere girmezse


}


}

ve kullanacağımız yer

string parametre = //istenilen yerden dinamik olarak çekilebilir
Yöntem y = new YöntemFabrikası().yöntemYarat(parametre );
y.Gez();

Türkçe’ye Tek Nesne olarak çevrilen bu tasarım desenindeki ana amaç bir nesnenin yalnızca bir kez oluşturulabilmesidir. Buna neden ihtiyaç duyarız sorusuna gelince mesela bir bağlantıyı dinleyen nesneniz olsun. Bunu ikince kez yaratmak kimi zaman sorunlara yol açabilir. Sonuçta bunlar sonsuz threadlerdir. Onun yerine bu nesne bir kez yaratılsın ve ihtiyaç duyulduğu zaman daha önce oluşan nesne oraya gitsin ve işlerini halletsin isteriz.

Basit bir örnek verelim :
class RandomSayıVerici
{
private RandomSayıVerici() { }
private static Random r = new Random();

public static Random nesneAl()
{ return r; }
public static int sayiVer(int min, int max)
{
return r.Next(min, max);
}
public static int sayiVer(int max)
{
return r.Next(max);
}
public static int sayiVer()
{
return r.Next();
}
}

Şimdi biz bu örnekte bir adet RandomSayiVerici oluşturduk. Özellikle Random sınıfını kullandım çünkü özellikle yani başlan bir çok kişi bu sınıfın sürekli aynı sayı ürettiğini düşünüyor. Ama kaçırdıkları şey sınıfı sürekli baştan yaratmaları. Ve bunun bir döngü içinde olduğu düşünülürse mikro saniyeler seviyesinde sayı değişimi çok da fazla olmayacaktır. İstenilen yerde :

TextBox1.Text += RandomSayıVerici.sayiVer(0, 53).ToString() ;
şeklinde kullanılması yeterli.
İyi çalışmalar..

MDI formlarda child formun iki kere açılmasını önlemek için singleton tasarım desenini kullanacağız. MDI form olarak tanımlanmış formumuz Form1 olsun. Bunun içinde açacağımız child form ise Form2 olsun. Form1de herhangi bir şekilde Form2 çağrıldığında sadece bir tane instance oluşturarak bir tane açılmasını istiyorum. Bunun için Form2nin classına şu kodu yazalım.

 

static Form2 myform;

public static Form2 Myform()

{

 

    if (myform == null)

    {

        myform = new Form2();

    }

    return myform;

 

}

 

if (myform == null) yazmamız burada çok önemli. Form2nin sadece bir tane nesnesi oluşturulsun istiyoruz ve bu nesne daha önce oluşturulmamışsa yani null ise oluştur diyoruz. Bu şekilde buraya singleton desenini uyguladık. Daha sonra Form1 den bir buton eventından veya buna benzer herkangi bir şeyden Form2 yi çağırırken şu kodu yazıyoruz.

Form2 yeni = Form2.Myform();

yeni.MdiParent = this;

yeni.Show();

yeni.Activate();

 

Form2nin nesnesini oluştururken new Form2() diye değil de Form2.Myform() diye oluşturduk buna dikkat edelim. En son olarak da Form2nin kapanış eventına bi kod cümlesi daha eklememiz gerekiyor.

private void Form2_FormClosing(object sender, FormClosingEventArgs e)

{

     myform = null;

}

 

Bunu yazmazsak nesnesini oluşturup açtığımız Form2yi kapatıp tekrar açmak istediğimizde bir hatayla karşılaşırız. Bunu engellemek için bu cümleciği yazıyoruz. Nedeni form nesnemizi bir kere oluşturabilmek üzere oluşturduk ve bunun için “nesne null ise yarat” dedik. Bu yüzden nesneyi null yapmadan tekrardan oluşturamayız. Dolayısıyla form kapatılırken nesneye null değerini atıyoruz ki istediğimizde Form2yi tekrardan yaratabilelim.

© 2010 bilyaz.com , Programlama Makaleleri, Yazılım Makaleleri , Örnek Kodlar , Eğitim Videoları , C#,ASP.NET,SQL,PHP Suffusion WordPress theme by Sayontan Sinha