Csharp 키워드 --- delegate (의뢰)
32435 단어 delegate
의뢰 (Delegate) 클래스 는 정적 방법 이나 인 스 턴 스 및 이러한 인 스 턴 스 방법 을 참조 할 수 있 는 데이터 구조 입 니 다.기 존의 인터페이스 프로 그래 밍 에서 우 리 는 각종 유형의 이벤트 구동 (event driven) 의 처리 모델 을 접 한 적 이 있어 야 한다. 이런 모델 에서 우 리 는 해당 이벤트 가 촉발 하 는 함 수 를 정의 한다.예 를 들 어 Button 1 의 Click 사건 은 Button 1 을 작성 할 수 있 습 니 다.Click 이나 Btn1Clicked 등 함수 로 구동 처 리 를 합 니 다.이벤트 와 구동 함수 의 대응 관 계 는 의뢰 (Delegate) 클래스 를 통 해 연 결 됩 니 다.
사실 의뢰 (Delegate) 류 의 이러한 데이터 구 조 는 이전 C / C + + 의 함수 포인터 와 유사 합 니 다.
Delegate 클래스 의 간단 한 응용 1. Delegate 함수 데이터 구 조 를 정의 합 니 다. 2. Delegate 가 인용 할 정적 방법 이나 인용 클래스 인 스 턴 스 및 이러한 인 스 턴 스 방법 을 정의 합 니 다. 3. Delegate 데이터 변 수 는 인 스 턴 스 방법 을 가리 킵 니 다. 4. Delegate 데이터 변 수 를 통 해 인 스 턴 스 방법 을 실행 합 니 다.
A very basic example (TestClass.cs):
1: using System;
2:
3: namespace MySample
4: {
5: class TestClass
6: {
7: //1. Delegate
8: public delegate void GoDelegate();
9:
10: [STAThread]
11: static void Main(string[] args)
12: {
13: //3.Delegate
14: GoDelegate goDelegate = new GoDelegate( MyDelegateFunc);
15:
16: //4. Delegate
17: goDelegate();
18: return;
19: }
20: //2. Delegate
21: public static void MyDelegateFunc()
22: {
23: Console.WriteLine("delegate function...");
24: }
25: }
26: }
컴 파일 실행 결과:
# TestClass.exe delegate function...
Delegate 류 와 Override 를 사용 하여 다 중 비 교 를 실현 합 니 다.
1. Delegate 류 를 사용 할 때 아래 의 예 는 명확 하 게 설명 할 수 있다. 1.1 먼저 동물 기본 클래스 (MyAnimal DelegateClass) 를 정의 합 니 다. 기본 클래스 에는 속성 을 표시 하 는 (Show Animal Type) Public 방법 이 있 습 니 다. 또한 Show Animal Type 방법 에서 Delegate 가 인용 한 인 스 턴 스 방법 을 호출 합 니 다.
1.2 사자 (LionDelegateClass) 와 말 (HorseDelegateClass) 두 개의 키 종 류 를 정의 합 니 다. Delegate 는 각자 의 인 스 턴 스 방법 과 연결 되 어 있 습 니 다. 서로 다른 속성 표시 (Show Animal Type) 방법 을 실현 합 니 다.
////Delegate example (TestClass.cs): 1: AnonymousDelegatesusing System;
2:
3: namespace MySample
4: {
5: class TestClass
6: {
7: [STAThread]
8: static void Main(string[] args)
9: {
10: // （LionDelegateClass) (ShowAnimalType)
11: LionDelegateClass lionDelegate = new LionDelegateClass();
12: lionDelegate.ShowAnimalType("MySample");
13:
14: // （HorseDelegateClass) (ShowAnimalType)
15: HorseDelegateClass horseDelegate = new HorseDelegateClass();
16: horseDelegate.ShowAnimalType("MySample");
17: }
18: }
19:
20: // (MyAnimalDelegateClass)
21: public class MyAnimalDelegateClass
22: {
23: //Delegate
24: public delegate void DelegateFunction(string strFuncName);
25:
26: private DelegateFunction m_delegateFunction = null;
27:
28: //Delegate
29: public DelegateFunction delegateFunction
30: {
31: get
32: {
33: return m_delegateFunction;
34: }
35: set
36: {
37: m_delegateFunction = value;
38: }
39: }
40: // (ShowAnimalType)
41: public void ShowAnimalType(string strFuncName)
42: {
43: if (delegateFunction != null)
44: {
45: object[] args = {strFuncName};
46: // Delegate
47: delegateFunction.DynamicInvoke(args);
48: }
49: }
50: }
51:
52: // （LionDelegateClass)
53: public class LionDelegateClass:MyAnimalDelegateClass
54: {
55: public LionDelegateClass()
56: {
57: this.delegateFunction = new DelegateFunction(subFunction1);
58: }
59:
60: // （LionDelegateClass)
61: private void subFunction1(string strFuncName)
62: {
63: System.Console.WriteLine(
64: string.Format("[{0}]This is a lion....", strFuncName));
65: }
66: }
67:
68: // （HorseDelegateClass)
69: public class HorseDelegateClass:MyAnimalDelegateClass
70: {
71: public HorseDelegateClass()
72: {
73: this.delegateFunction = new DelegateFunction(subFunction2);
74: }
75:
76: // （HorseDelegateClass)
77: private void subFunction2(string strFuncName)
78: {
79: System.Console.WriteLine(
80: string.Format("[{0}]This is a horse....", strFuncName));
81: }
82: }
83: }
컴 파일 실행 결과:
# TestClass.exe
[MySample]This is a lion.... [MySample]This is a horse....
2. Override 실 장 을 사용 할 때 아래 의 예 를 참고 하 세 요. 1.1 먼저 동물 기본 클래스 (AbstractAnimal NoDelegateClass) 를 정의 합 니 다. 기본 클래스 에는 속성 을 표시 하 는 (Show Animal Type) Public 방법 이 있 습 니 다. 또한 Show Animal Type 방법 에서 추상 적 인 방법 (NoDelegate Function) 을 호출 합 니 다.
1.2 사자 (LionNoDelegateClass) 와 말 (HorseNoDelegateClass) 두 개의 키 종 류 를 정의 합 니 다. 하위 클래스 에서 실제 추상 적 인 방법 (NoDelegate Function) 서로 다른 속성 표시 (Show Animal Type) 방법 을 실현 합 니 다.
////Override example (TestClass.cs): 1: using System;
2:
3: namespace MySample
4: {
5: class TestClass
6: {
7: [STAThread]
8: static void Main(string[] args)
9: {
10: // （LionNoDelegateClass ) (ShowAnimalType)
11: LionNoDelegateClass lionNoDelegate = new LionNoDelegateClass();
12: lionNoDelegate.ShowAnimalType("MySample");
13:
14: // （HorseNoDelegateClass ) (ShowAnimalType)
15: HorseNoDelegateClass horseNoDelegate = new HorseNoDelegateClass();
16: horseNoDelegate.ShowAnimalType("MySample");
17: }
18: }
19:
20: // (AbstractAnimalNoDelegateClass)
21: public abstract class AbstractAnimalNoDelegateClass
22: {
23: public void ShowAnimalType(string strFuncName)
24: {
25: // （NoDelegateFunction）
26: NoDelegateFunction(strFuncName);
27: }
28: // （NoDelegateFunction）
29: protected abstract void NoDelegateFunction(string strFuncName);
30: }
31:
32: // （LionNoDelegateClass )
33: public class LionNoDelegateClass:AbstractAnimalNoDelegateClass
34: {
35: // （NoDelegateFunction）
36: protected override void NoDelegateFunction(string strFuncName)
37: {
38: System.Console.WriteLine(
39: string.Format("[{0}]This is a lion....", strFuncName));
40: }
41: }
42: // （HorseNoDelegateClass )
43: public class HorseNoDelegateClass:AbstractAnimalNoDelegateClass
44: {
45: // （NoDelegateFunction）
46: protected override void NoDelegateFunction(string strFuncName)
47: {
48: System.Console.WriteLine(
49: string.Format("[{0}]This is a horse....", strFuncName));
50: }
51: }
52: }
53:
컴 파일 실행 결과:
# TestClass.exe
[MySample]This is a lion.... [MySample]This is a horse....
3. Delegate 와 Override 의 실제 설치 방식 비교 Delegate 의 실제 설치 방식 에서 함수 포인터 의 구성원 변 수 를 정의 하 는 것 과 같다 는 것 을 알 수 있다. 실제 함수 의 주 소 를 이 구성원 변수 에 부여 함으로써 같은 방법 을 실현 하고 처리 방식 이 다르다. 한편, Override 방식 은 부모 클래스 에서 인 터 페 이 스 를 미리 정의 하고 실제 장 치 를 통 해 다 릅 니 다. 같은 방법, 처리 방식 이 다르다. Delegate 의 실제 포장 방식 이 비교적 유연 하고 디자인 이 완선 하지 않 은 장소 에 적합 하 며 수정 하기에 편리 하 다. Override 방식 은 포장 성 이 좋 고 상대 적 으로 안전 합 니 다.
MulticastDelegate 류 의 응용 --- --- ----------------------------------------------------------------------------------------------------------- 1: using System;
2:
3: namespace MySample
4: {
5: class TestClass
6: {
7: [STAThread]
8: static void Main(string[] args)
9: {
10: DogDelegateClass dogDelegate = new DogDelegateClass();
11: dogDelegate.ShowAnimalType("MySample");
12:
13: }
14:
15: public class MyAnimalDelegateClass
16: {
17: public delegate void DelegateFunction(string strFuncName);
18:
19: private DelegateFunction m_delegateFunction = null;
20:
21: public DelegateFunction delegateFunction
22: {
23: get
24: {
25: return m_delegateFunction;
26: }
27: set
28: {
29: m_delegateFunction = value;
30: }
31: }
32:
33: public void ShowAnimalType(string strFuncName)
34: {
35: if (delegateFunction != null)
36: {
37: object[] args = {strFuncName};
38:
39: delegateFunction.DynamicInvoke(args);
40: }
41: }
42: }
43:
44: public class DogDelegateClass:MyAnimalDelegateClass
45: {
46: public DogDelegateClass()
47: {
48: //
49: this.delegateFunction = new DelegateFunction(subFunction31);
50: this.delegateFunction += new DelegateFunction(subFunction32);
51: }
52: // 1
53: private void subFunction31(string strFuncName)
54: {
55: System.Console.WriteLine(
56: string.Format("[{0}]This is a dog....", strFuncName));
57: }
58: // 2
59: private void subFunction32(string strFuncName)
60: {
61: System.Console.WriteLine(
62: string.Format("[{0}]This is a nice dog....", strFuncName));
63: }
64: }
65: }
： # TestClass.exe [MySample]
This is a dog....[MySample]This is a nice dog....
CSDN ， ：http://blog.csdn.net/xinsir/archive/2006/08/22/1106277.aspx
1: // Copyright © Microsoft Corporation. All Rights Reserved.
2: // This code released under the terms of the
3: // Microsoft Public License (MS-PL, http://opensource.org/licenses/ms-pl.html.)
4: //
5: //Copyright (C) Microsoft Corporation. All rights reserved.
6:
7: using System;
8: using System.Collections.Generic;
9: using System.Text;
10:
11: namespace AnonymousDelegate_Sample
12: {
13:
14: // Define the delegate method.
15: delegate decimal CalculateBonus(decimal sales);
16:
17: // Define an Employee type.
18: class Employee
19: {
20: public string name;
21: public decimal sales;
22: public decimal bonus;
23: public CalculateBonus calculation_algorithm;
24: }
25:
26: class Program
27: {
28:
29: // This class will define two delegates that perform a calculation.
30: // The first will be a named method, the second an anonymous delegate.
31:
32: // This is the named method.
33: // It defines one possible implementation of the Bonus Calculation algorithm.
34:
35: static decimal CalculateStandardBonus(decimal sales)
36: {
37: return sales / 10;
38: }
39:
40: static void Main(string[] args)
41: {
42:
43: // A value used in the calculation of the bonus.
44: // Note: This local variable will become a "captured outer variable".
45: decimal multiplier = 2;
46:
47: // This delegate is defined as a named method.
48: CalculateBonus standard_bonus = new CalculateBonus(CalculateStandardBonus);
49:
50: // This delegate is anonymous - there is no named method.
51: // It defines an alternative bonus calculation algorithm.
52: CalculateBonus enhanced_bonus = delegate(decimal sales)
53: { return multiplier * sales / 10; };
54:
55: // Declare some Employee objects.
56: Employee[] staff = new Employee[5];
57:
58: // Populate the array of Employees.
59: for (int i = 0; i < 5; i++)
60: staff[i] = new Employee();
61:
62: // Assign initial values to Employees.
63: staff[0].name = "Mr Apple";
64: staff[0].sales = 100;
65: staff[0].calculation_algorithm = standard_bonus;
66:
67: staff[1].name = "Ms Banana";
68: staff[1].sales = 200;
69: staff[1].calculation_algorithm = standard_bonus;
70:
71: staff[2].name = "Mr Cherry";
72: staff[2].sales = 300;
73: staff[2].calculation_algorithm = standard_bonus;
74:
75: staff[3].name = "Mr Date";
76: staff[3].sales = 100;
77: staff[3].calculation_algorithm = enhanced_bonus;
78:
79: staff[4].name = "Ms Elderberry";
80: staff[4].sales = 250;
81: staff[4].calculation_algorithm = enhanced_bonus;
82:
83: // Calculate bonus for all Employees
84: foreach (Employee person in staff)
85: PerformBonusCalculation(person);
86:
87: // Display the details of all Employees
88: foreach (Employee person in staff)
89: DisplayPersonDetails(person);
90:
91:
92: }
93:
94: public static void PerformBonusCalculation(Employee person)
95: {
96:
97: // This method uses the delegate stored in the person object
98: // to perform the calculation.
99: // Note: This method knows about the multiplier local variable, even though
100: // that variable is outside the scope of this method.
101: // The multipler varaible is a "captured outer variable".
102: person.bonus = person.calculation_algorithm(person.sales);
103: }
104:
105: public static void DisplayPersonDetails(Employee person)
106: {
107: Console.WriteLine(person.name);
108: Console.WriteLine(person.bonus);
109: Console.WriteLine("---------------");
110: Console.ReadLine();
111: }
112: }
113: }
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
extjs 소스 분석 - 012(Funtion 확장)this : function() { var me = this, args = arguments; fcn.target = me; fcn.method = method; return (fcn.apply(scope || me...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
