Delege nedir? [kapalı]

Bir delegenin asıl rolü nedir?

Bu soruya röportajlarımda birçok kez soru soruldu, ancak görüşmecilerin cevabımdan memnun olduklarını düşünmüyorum.

Biri bana en iyi tanımı, tek bir cümleyle, pratik bir örnekle söyleyebilir mi?

Bir delegeyi "bir işleve işaretçi" olarak düşünmeyi seviyorum. Bu C günlerine kadar gidiyor, ama fikir hala geçerli.

Fikir, bir kod parçasını çağırabilmeniz gerektiğidir, ancak çağıracağınız kod parçası çalışma zamanına kadar bilinmemektedir. Yani bu amaçla bir "delege" kullanıyorsunuz. Delegeler, olay işleyicileri ve örneğin farklı olaylara dayalı farklı şeyler yaptığınız işler için kullanışlıdır.

İşte size bakabileceğiniz C # için bir referans:

Örneğin, C # 'da diyelim ki yapmak istediğimiz bir hesaplama yaptık ve çalışma zamanına kadar bilmediğimiz farklı bir hesaplama yöntemi kullanmak istedik. Dolayısıyla, bunun gibi birkaç hesaplama yöntemimiz olabilir:

public static double CalcTotalMethod1(double amt)
{
    return amt * .014;
}

public static double CalcTotalMethod2(double amt)
{
    return amt * .056 + 42.43;
}

Bunun gibi bir temsilci imzası beyan edebiliriz:

public delegate double calcTotalDelegate(double amt);

Ve sonra delegeyi böyle bir parametre olarak alan bir yöntem beyan edebiliriz:

public static double CalcMyTotal(double amt, calcTotalDelegate calcTotal)
{
    return calcTotal(amt);
}

Ve CalcMyTotalkullanmak istediğimiz delege yönteminden geçen yöntemi çağırabiliriz .

double tot1 = CalcMyTotal(100.34, CalcTotalMethod1);
double tot2 = CalcMyTotal(100.34, CalcTotalMethod2);
Console.WriteLine(tot1);
Console.WriteLine(tot2);

bir temsilci basitçe bir işlev işaretleyicisidir.
sadece temsilcinizi çalıştırmak istediğiniz yöntemi atayın. daha sonra kodda Invoke ile bu yöntemi çağırabilirsiniz.

göstermek için bazı kodlar (sözdizimi kapalı olabilmesi için bunu bellekten yazdı)

delegate void delMyDelegate(object o);

private void MethodToExecute1(object o)
{
    // do something with object
}

private void MethodToExecute2(object o)
{
    // do something else with object
}

private void DoSomethingToList(delMyDelegate methodToRun)
{
    foreach(object o in myList)
        methodToRun.Invoke(o);
}

public void ApplyMethodsToList()
{
    DoSomethingToList(MethodToExecute1);
    DoSomethingToList(MethodToExecute2);
}

Buradan alındı

S Delege nedir?
A Bir nesne bir istek aldığında, nesne ya isteğin kendisini işleyebilir ya da işi yapmak için isteği ikinci bir nesneye iletebilir. Nesne isteği iletmeye karar verirse, nesnenin isteği ikinci nesneye işleme sorumluluğunu ilettiğini söylersiniz.

Ya da, kolay bir sahte örnek olarak: bir şey object1'e bir istek gönderir. object1 daha sonra isteği ve kendisini delege olan object2'ye iletir. object2 isteği işler ve bazı işler yapar. (not: yukarıdaki bağlantı iyi örnekler verir)

Temsilciyi, Komut kalıbının basitleştirilmiş bir uygulaması olarak düşünün.

Temsilci, bir yönteme başvurabilen bir nesnedir. Böylece, bir temsilci oluşturduğumuzda, bir yönteme başvuru yapabilen bir nesne yaratırız. Ayrıca, yöntem bu referans ile çağrılabilir. Böylece, bir delege, başvurduğu yöntemi çağırabilir. Temsilcinin temel avantajı, bir yönteme çağrı belirlememize izin vermesidir, ancak gerçekte çağrılan yöntem derleme zamanında değil, çalışma zamanında belirlenir.

Basit Delege

Declaration of delegate:
delegate-modifier delegate return-type delegate-name(parameters)
Implementation of delegate:
Delegate-name delegate-object=new Delegate-name(method of class)

http://knowpacific.wordpress.com/2012/01/26/delegate/

Burada delegeleri, çok noktaya yayın delegelerini ve bunların kullanımını açıklayacağım. Delege, bir nesnede yöntem (ler) başvurusunu tutan bir türdür. Ayrıca, bir tür güvenli işlev işaretçisi olarak da adlandırılır. Bir temsilci, yöntem imzasını tanımlayan bir türdür diyebiliriz.

Bir temsilci başlatırken, örneğini uyumlu bir imzayla herhangi bir yöntemle ilişkilendirebilirsiniz. Temsilci örneği aracılığıyla yöntemi çağırabilirsiniz (veya çağırabilirsiniz). Delegeler, yöntemleri diğer yöntemlere argüman olarak iletmek için kullanılır. Olay işleyicileri, temsilciler aracılığıyla çağrılan yöntemlerden başka bir şey değildir. Temsilcileri kullanmanın avantajları, yöntemin çağrıyı çağırın Kapsüllendirilmesi Temsilcinin etkili kullanımı, uygulamanın performansını eşzamansız olarak çağırmak için kullanılır. Delegelerin bazı özellikleri var

Delegates are like C++ function pointers but are type safe.
Delegates allow methods to be passed as parameters.
Delegates can be used to define callback methods.
Delegates can be chained together; for example, multiple methods can be called on a single event.
Methods do not have to match the delegate signature exactly.

genel temsilci type_of_delegate delegate_name () // Beyan

You can use delegates without parameters or with parameter list
If you are referring to the method with some data type then the delegate which you are declaring should be in the same format. This is why it is referred to as type safe function pointer. Here I am giving an example with String.

Aşağıdaki örnekte bir temsilci işlemi gösterilmektedir:

    namespace MyDelegate
    {
        class Program
        {
            private delegate void Show(string s);


            // Create a method for a delegate.
            public static void MyDelegateMethod(string me

ssage)
        {
            System.Console.WriteLine(message);
        }

        static void Main(string[] args)
        {
            Show p = MyDelegateMethod;
            p("My Delegate");
            p.Invoke("My Delegate");
            System.Console.ReadLine();
        }
    }
}

Çok Noktaya Yayın Temsilcisi nedir?

Birden fazla yöntemin referansını tutan bir temsilci. Çok noktaya yayın delegeleri yalnızca geçersiz döndüren yöntemler içermelidir, aksi takdirde çalışma zamanı istisnası vardır.

 delegate void MyMulticastDelegate(int i, string s);
 Class Class2
 {
  static void MyFirstDelegateMethod(int i, string s)
  {
    Console.WriteLine("My First Method");
  }

  static void MySecondDelegateMethod(int i, string s)
  {
    Console.WriteLine("My Second Method");
  }

  static void Main(string[] args)
  {
    MyMulticastDelegate Method= new MyMulticastDelegate(MyFirstDelegateMethod);
    Method+= new MyMulticastDelegate (MySecondDelegateMethod);
    Method(1,"Hi");             // Calling 2 Methodscalled
    Method-= new MyMulticastDelegate (MyFirstDelegateMethod);
    Method(2,"Hi");             //Only 2nd Method calling
  }
}

Burada Temsilci + = operatörü kullanılarak eklenir ve - = operatörü kullanılarak kaldırılır.

Delege türleri, .NET Framework'teki Delegate sınıfından türetilir. Delege türleri mühürlenir - türetilemezler. Örneklendirilen temsilci bir nesne olduğundan, parametre olarak iletilebilir veya bir özelliğe atanabilir. Bu, bir yöntemin bir delegeyi parametre olarak kabul etmesine ve daha sonra bir süre için delege çağırmasına izin verir. Bu, eşzamansız geri arama olarak bilinir.

Temsilci deseninin büyük bir açıklaması ve pratik uygulaması Google Koleksiyonlar Yönlendirme Sınıflarında (ayrıca Dekoratör kalıbı) bulunabilir.

Olay iletişiminde, gönderen olayı hangi nesnenin işleyeceğini bilmez. Temsilci, yöntemin başvurusunu tutan türdür. Temsilcinin imzası vardır ve Temsilcisi tür güvenli işlev işaretçisine benzemesi için imzasıyla eşleşen yönteme başvurur.

button1.Click + = yeni System.EventHandler (button1_Click) System.EventHandler burada bir temsilci olarak bildirilir. Net Olaylarında Delege kavramı üzerinde çalışır (Düğme Tıklaması gibi)

Temsilci çalışma zamanında hangi kodu çağıracağınızı bilmediğinizde kullanılır. Dolayısıyla, o zaman Temsilci, Olayları işlemek için kullanılır

http://msdn.microsoft.com/en-us/library/ms173171(v=vs.80).aspx

Bir temsilci nesnesi şey o nesnenin içinde meydana geldiğinde başka amacı danışır o bir nesnedir. Örneğin, arabanıza bir şey olursa tamirciniz sizin temsilcinizdir. tamircinize gidip ondan arabayı tamir etmesini istersiniz (bazıları arabayı kendileri tamir etmeyi tercih etse de, bu durumda arabaları için kendi delegeleri).

Temsilci, bir işlevin işaretçisini temsil eden bir nesnedir. Ancak, sıradan bir işlev işaretçisi değildir:

1) Nesneye Yönelik mi

2) Tür güvenli midir, yani yalnızca bir yönteme işaret edebilir ve işaret ettiği ham bellek adresini okuyamazsınız

3) kuvvetle yazılmıştır. Yalnızca imzalarıyla eşleşen yöntemlere işaret edebilir.

4) Aynı anda birden fazla yönteme işaret edebilir.

Delegeler çoğunlukla etkinliklerle kullanılır.

İhtiyaç:

Programı çalıştırdığınız sırada bir parça kod yürütmek istemezsiniz. Programı çalıştırdıktan sonra, bir olay meydana geldiğinde bu kod parçasını yürütmek istersiniz.

Misal :

1. Konsol uygulaması - kod yalnızca programı çalıştırdığınızda çalıştırılabilir. (Ana yöntem içinde yazılmıştır)
2. Windows uygulaması (kullanıcı arabirimi programlama) - program çalıştırıldıktan sonra düğmeye tıklandığında kod yürütülebilir.

Dedikleri bu, derleme sırasında hangi yöntemin çağrıldığını bilmiyorsunuz. sadece düğmeyi tıkladığınızda olan çalışma zamanında biliyorsunuz.

Delegeler olmadan kullanıcı arabirimi programlaması yapılamaz. Çünkü kullanıcı düğmeyi tıklatıp, metin kutusuna yazarak, açılır liste öğesini seçerek ve benzeri olayları gerçekleştirdiğinde kod yürütüyorsunuz.

Temsilci, görevin devredildiği bir şeydir. Delegasyonun temel amacı kodu ayırmak ve daha fazla esneklik ve yeniden kullanıma izin vermektir.

Programlamada ve özellikle nesne yönelimli programlamada, bu, bir yöntem bir iş yapmak için çağrıldığında, çalışmayı referans aldığı başka bir nesnenin yöntemine aktardığı anlamına gelir. Referans, nesne önceden tanımlanmış bir yöntem kümesine uyduğu sürece, istediğimiz her nesneye işaret edebilir. Biz buna "bir arayüze programlama" diyoruz (somut bir sınıf uygulamasına programlamaya karşı). Bir arayüz temel olarak genel bir şablondur ve uygulaması yoktur; sadece bir tarif, bir dizi yöntem, önkoşul ve sonşartlar (kurallar) anlamına gelir.

Basit örnek:

SomeInterface
{
   public void doSomething();
}


SomeImplementation implements SomeInterface
{
   public void doSomething()
   {
      System.err.println("Was it good for you?");
   }

}


SomeCaller
{
   public void doIt(SomeInterface someInterface)
   {
      someInterface.doSomething();
   }
}

Gördüğünüz gibi, SomeCaller'deki kodu değiştirmeden istediğim herhangi bir uygulamayı her zaman kullanabileceğimi görüyorsunuz çünkü geçen tip doIt()somut değil, bir arayüz olduğundan soyut. Java dünyasında, bu genellikle bir hizmete (belirli bir arabirim aracılığıyla kendini hizmet olarak tanıtan bir nesne) çağrı yaptığınız hizmet paradigmasında ifade edilir ve hizmet daha sonra işini yapmasına yardımcı olmak için delegelere seslenir. Hizmetin yöntemleri, kaba taneli görevler (makePayment (), createNewUser (), vb.) Olarak adlandırılırken, delege yoluyla nitritli çalışma varsa delegelerin türleri somut uygulamalar yerine arayüzler olarak dahili olarak çok şey yapar.

SomeService
{
    SomeInterface someImplementation = ... // assign here
    SomeOtherInterface someOtherImplementation = ... // okay, let's add a second

    public void doSomeWork()
    {
         someImplementation.doSomething();
         someOtherImplementation.doSomethingElse();
    }
}

(Not: Bir uygulamanın nasıl atandığı bu iş parçacığının kapsamı dışındadır. Arama denetiminin ve bağımlılık enjeksiyonunun ters çevrilmesi.)

Gerçekten bir "işlev işaretçisi" olmasa da, bir temsilci PHP gibi dinamik bir dil gibi görünebilir:

$func = 'foo';
$func();

function foo() {
    print 'foo';
}

veya JavaScript'te aşağıdakine benzer bir şey yapabilirsiniz:

var func = function(){ alert('foo!'); }
func();