Extracting string between two string

 private static string ExtractName(this string src, string findfrom, string findto)
        {
            int start = src.IndexOf(findfrom);
            int to = src.IndexOf(findto, start + findfrom.Length);
            if (start < 0 || to < 0) return "";
            string s = src.Substring(
                           start + findfrom.Length,
                           to - start - findfrom.Length);
            return s;
        }

Honda's Asimo robot gets faster and smarter in human makeover

1000 yılından beri avrupa

Abstract Ve Interface Arasındaki Farklar

www.yazgelistir.com/makale/abstract-ve-interface-arasindaki-farklar sayfasından alınmıştır

Makalemiz boyunca abstract ve interface tanımlarının arasındaki tek bir farktan yola çıkarak bir yordamı beraber yazıcağız.

Ama ilk önce çok kısa olarak abstract ve interface nedir diyelim ve neden ihtiyaç duyduğumuzu yazalım .

Nesne yönelimli programlamalar oluştururken bazı durumlarda şunu isteyebiliriz. oluşturduğumuz ara yüz ile bu tipi uygulayacak sınıfların ortak bazı metotları property leri kullanmasını isteyebiliriz.

Ve bu temel sınıf dan kalıtılan tüm sınıfların temel sınıf içerisinde belirlenmiş metotları kullanmasını isteyebiliriz.

Not : Abstract veya interface içine yazacağımız metotların metot gövdeleri bulunmamaktadır. Bunun nedeni tabi ki bu metotların özet metot bir ara yüz olmasıdır.

abstract public void Uc ()
{
}

Seklinde abstract metot tanımlarız. bu tanımlamadan metodumuzun bir erişim belirleyicisi geri dönüş tipi ve adı vardır . tanımlamamızın başında ise abstract anahtar söz dizimi kullanılmıştır. Artık c# derleyicisi bu metoda geldiği zaman bunun özet bir metot olduğunu bilir .

Simdi bir interface tanımlayalım ve arasındaki bir farka göz atalım interface imizin adına Uc diyelim ve geri dönüş tipi void olsun .

void Uc ();

Yukarıdaki şekilde Uc adında bir interface tanımladık . abstract ile interface tanımlama arasında bir fark vardır. abstract tanımlamalarda <erişim belirleyicisi > belirtiriz . ama interface tarafında belirtilen metotların <erişim belirleyicileri > tanımlanmaz interface arasına yazılan her metot , property vs .. hepsinin < erişim belirleyicileri > public olarak default atanır . Eğer biz ekstradan bildirmek istersek de hata verir .

Yordamımızı yazarken tanımlayacağımız interface ve abstract class larımızın adlarını yazalım.

Abstract olarak işaretlenmiş class larımızı adı : abstract uc () ; abstract yuz();

Interface olarak işaretlenmiş class larımızın adı : IUcabilir(); IYuzebilir();

Abstact tanımlamalarımızı yapalım .



Sekilde de görüldüğü gibi abstract class içerisinde iki adet metot tanımlanmıştır. Uc metodumuz bizden double tipinden _yukseklik Kon metodumuzda bizden string değerinde _mekan değerlerini istemektedir.

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

namespace Ornekkod
{
abstract class AbstractUc
{
abstract public void Uc(double _yukseklik);
abstract public void Kon(string _mekan);

}
}

Sekil dede görüldüğü gibi abstract class içerisindeki iki adet metot tanımladık . Dal metodumuz bizden double tipinde _derinlikgir , Cik() metodumuzda parametre almamaktadır.

Simdi bir adet balık tipi tanımlayalım .

class Balik : AbstractYuz
{
string turbilgisi;
double _derinlikgir;

public double Derinlik { get { return this._derinlikgir; } set { this._derinlikgir = value; } }

public string Tur { get { return this.turbilgisi; } set { this.turbilgisi = value; } }

public Balik(string turu)
{
Tur = turu;
}

public override void Dal(double _derinlikgir)
{
Derinlik = _derinlikgir;
Console.WriteLine("{0} Turundeki balligimiz {1} metre derinlige Daldı", this.Tur, Derinlik);
}

public override void Cik()
{
Console.WriteLine("{0} Turundeki baligimiz {1} metreden yukarı dogru cıktı", this.Tur, this.Derinlik);
}
}

Yukarıdaki şekilde balik tipimizi tanımladık ve Balik : AbstractYuz seklinde abstract class ımızı balik tipimize implement etik . implement ettiğimizi bu abstract class ımızın metotlarını da kullanarak balik tipimizi en basit hali ile oluşturduk .

Simdi örnekleyip çalıştıralım .

Balik YeniBalik = new Balik("Mürekkep Balıgı");
YeniBalik.Dal(12);
YeniBalik.Cik();

Seklinde balik nesnemizi oluşturduk . YeniBalik tipimizin içerisinde Dal ve Cik metotlarını kullanarak işlemlerimizi gerçekleştirdik.

Peki biz balik tipimize abstract class kalıtdığımız zaman abstract class imiz içerisindeki metotları balik metodumuza implement etmez isek c# bize hangi şekilde hata verecektir.

Ornekkod.Balik does not implement inherited abstract member 'Ornekkod.AdstractYuz.Dal(double)

Ornekkod.Balik does not implement inherited abstract member 'Ornekkod.AbstractYuz.Cik()' 



Yukarı dada görüldüğü gibi abstract class imiz içerisindeki metotları implent ( daha sonra overload ) etmez isek c# derleyicisi bize derleme zamanı hatası verecektir .

Önemli Not : Abstract ve interface tiplerimizi örnekleyemeyiz . sadece oluşturmak istediğimiz class ımıza rehberlik etmesini sağlayabiliriz .

Simdi uçabilen bir tip ( Kus ) tanımlayalım ve abstractUc kalıtım kullanalım ve örnekleyelim . yukarıdaki balik tipimizdeki gibi bir tanımlama yapalım kusun turunu alalım ve abstract içerisindeki metotlarımızı implement edip kullanalım .

Kus.cs

class Kus : AbstractUc
{
string _turu;
double _yukseklik;

public double Yukseklik { get { return this._yukseklik; } set { this._yukseklik = value; } }

public string Tur { get { return this._turu; } set { this._turu = value; } }

public Kus(string _turgir)
{
this._turu = _turgir;
}

public override void Uc(double _yukseklik)
{
Console.WriteLine("{0} turundeki kus {1} metre yukseklige cıktı",this.Tur,this.Yukseklik);
}

public override void Kon(string _mekan)
{
Console.WriteLine("{0} turundeki kus {1} kondu",this.Tur,_mekan);
}
}

Yukarıda kus metodumuzu tanımladık Balik.cs deki gibi herhangi bir degisiklik yapmadan sadece tur bilgisini aldık ve AbstractUc class kalıtım içerisindeki metotları kullandık .

Simdi Kus tipimizi örnekleyelim .

Kus YeniKus = new Kus("Papağan");
YeniKus.Uc(30);
YeniKus.Kon("Dama");

Yukarıdaki tanımlamalarda balik tipimizi ve kus tipimizi oluşturup örnekledik ve sonuçlarını inceledik . Abstract class larımızı tipimize bağlayıp kurallarımızı oluşturduk ve implement edip uyguladık.

Simdi hem yüzen hem ucan bir tur bulalım ve örneklemeye çalısalım . Hem uçan hem yüzen Karabatak sınıfımızı yazalım . Bakalım bu karabatak sınıfımızı yazarken bizi ne bekliyor.

namespace Ornekkod
{

class KaraBatak : AbstractYuz, abs
{

}



Karabatak tipimize şekilde görüldüğü gibi ikinci bir abstract tanımlayamıyoruz bir tipte en fazla bir adet abstract class bildirebiliriz. iki veya daha fazlası için Interface tanımlamamız ve implement etmemiz gerekir .

Simdi biz karabatak sınıfımızı interface lerimizi kullanarak oluşturalım makalemize baslarken interface lerimizi oluşturmuştuk.

Simdi direk karabatak sınıfımız üzerinde interface lerimizi tanımlayalım .

class KaraBatak : IUcabilir,IYuzebilir seklinde birden fazla interface tanımlamak için , sembolünü kullanırız simdi karabatağımızın adı nı alalım ve interface imizdeki metotlarımızı tipimize implement edelim .

#region IUcabilir Members

public void Uc(double _yukseklik)
{

Yukseklik = _yukseklik;
Console.WriteLine("{0} adındaki karabatak {1} yuksekliginde Uctu",this.Adi,this.Yukseklik);

}

public void Kon(string _mekan)
{

Mekan = _mekan;
Console.WriteLine("{0} adındaki karabatak {1} mekanına kondu",this.Adi,this.Mekan);

}

#endregion

#region IYuzebilir Members

public void Dal(double derinlik)
{

Derinlik = derinlik;
Console.WriteLine("{0} adındaki karabatak {1} metre derinlige daldı", this.Adi,this.Derinlik);

}

public void Cik()
{

Console.WriteLine("{0} adındaki karabatak {1} metre derinlikden cıktı",this.Adi,this.Derinlik);

}

#endregion

yukarıdaki gibi karabatak nesnemizde oluşturduk ve her iki kuralı da aynı nesne üzerinde tanımladık ve kullandık . simdi özet ( abstract ) ve ara yüz (interface ) hakkında biraz konusalım .

Ortak Özellikleri :

Abstract veya interface olarak tanımlanan tipler örneklenemezler .
Metot gövdeleri bulunmaz
İkiside implement edildikleri yere kendi içerisinde tanımlanan metotları property leri kullanmaya zorlar .

Farklılıkları :

Abstract tanımlarken <erişim belirmeyici > kullanırız .
Interface tanımlarken <erişim belirleyici > kullanmayız interface üzerine yazılmış her metot veya property vs. public olarak nitelendirilir.

Bir tipe bir tane abstract ama istedigimzi kadar interface ekleyebiliriz.

Bu makale boyunca elimizden geldigi kadar abstract ve interface arasındaki farkları ortaya koymaya anlatmaya calıstık .Umarım yararı olmustur.

Makale boyunca aklınıza takılan herhangi bir yer var ise mail yolu ile bana ulaşabilirsiniz en kısa zamanda cevap vermeye çalışacağım .

Sonsöz : Abstract veya interface tanımlamak aslında bir uygulama yazar iken bizim daha önce koyduğumuz kullanmak zorunda kaldığımız metotları atlamamızı engeller