Friday, October 22, 2010

Fondamentale de délégués

Les délégués est comme pointeur fonction c et c ++.
Programmeur utilise des délégués pour encapsuler mention la méthode dans les délégués object.Then délégués objet passe à la méthode de référence appropriée de code et d'appel et invoqué cette méthode qui n'est pas savoir au moment de la compilation.

Voici des exemples d'appel de la méthode simple en c#


à l'aide du système.

espace de noms withoutDelegate
{
public class Class1
{
public Process() void
{
Console.WriteLine ("processus commencer").
Console.WriteLine ("fin de processus") ;
}
}

public class test
{
static void main (string [] args)
{
Classe1 myClass = nouvelle Class1() ;
myClass.Process() ;
}
}
}

Cela fonctionne bien dans la plupart des situations.Parfois, cependant, nous ne voulons pas d'appeler une fonction directement - nous serait en mesure de transmettre à quelqu'un d'autre, donc ils peuvent appeler.Cela est particulièrement utile dans un système évènementielle, comme une interface utilisateur graphique, lorsque je veux un code à exécuter lorsque l'utilisateur clique sur un bouton, ou lorsque j'essaie de se connecter des informations, mais ne peut pas expliquer comment il est connecté

Dans les délégués, il y a deux types de délégués.
Délégués de SingleCast 1)
Délégués multicast 2)

Une chose intéressée sur les délégués est qu'il ne sait pas sur la classe de l'objet qu'il référence, comme tout autre objet do.All cette chose dépendent de paramètre de méthode et de type retour de méthode qui correspond à la signature des délégués.

Une signature de délégués des interprètes unique est :

déléguer l'identificateur de retour-type (paramètre)

ex : déléguer int calculer (int a, b int).

En plus exemple « int » est de type de retour de fonction, calculer est le nom de Deletate et l'int a et b de l'int sont le paramètre du délégué.

Quand nous voulons utiliser les délégués dans notre programme, tout d'abord nous devons définir la signature de méthode asigning et derniers invoquant les délégués.

3 Étapes :

-Declaration(Define Signature of Delegates)
-Instantiation(Asigning Method to delegate)
-Invoking(Invoking Delegate object so we dynamicall call method)


espace de noms délégué
{
/ / Déclaration
public delegate void MyDelegate() ;

classe TestDelegate
{
public MyFunc() void statique
{
Console.WriteLine ("j'ai été appelé par délégué...") ;
}

public main() void statique
{
/ / Instanciation
MyDelegate myDelegate = nouvelle MyDelegate(MyFunc) ;

/ / Appel
myDelegate() ;
}
}
}

Considérez l'exemple simple :


Espace de noms myNamespace
{
/ / et n'a aucun type de retour.
délégué public void myHandler(string message) ;

Et l'utilisation du délégué est comme l'appelant une fonction directement,
/ / Si nous devons ajouter une vérification pour voir si le délégué est null
/ / (c'est-à-dire ne pas pointer vers une fonction) avant d'appeler la fonction.
public void processus (gestionnaire de myHandler.)
{
Si (Handler! = null)
{
Handler("Process() commencer").
}

Si (Handler! = null)
{
Gestionnaire d'événements ("Process() fin").
}
}
}

/ / Tester l'application à utiliser le délégué défini
public class MonApplication
{
/ / Fonction statique: À qui est utilisée dans le délégué.Pour appeler la Process()
/ / fonction, nous avons besoin déclarer une fonction de journalisation : Logger() qui correspond à
/ / la signature du délégué.
static void Logger (chaîne s)
{
Console.WriteLine(s) ;
}

static void main (string [] args)
{
MyClass myClass = nouvelle MyClass() ;

/ / Crate une instance du délégué pointant vers la fonction de journalisation.
/ / Ce délégué sera ensuite passé à la fonction Process().
MyClass.myHandler myLogger = MyClass.myHandler(Logger) nouveau ;
myClass.Process(myLogger) ;
}
}
}

En multidiffusion Deletates, nous pouvons références plus d'une méthode aux délégués, mais ici une chose que nous devons nous rappeler que toute méthode ont même signature délégués.

Exemple : multidiffusion délégué :

Fonction de délégué public calculer (ByVal un As Integer, ByVal b As Integer) As Double

Public Class Delegateclass

Ajout de la fonction publique (ByVal un As Integer, ByVal b As Integer) As Double
Console.WriteLine(a + b)
Fonction de fin

Soustraire de la fonction publique (ByVal un As Integer, ByVal b As Integer) As Double
Console.WriteLine (a - b)
Fonction de fin
Classe de fin

Sub Main()
Dim myDlegateClass As New Delegateclass

Dim delAdd As New calculer (AddressOf myDlegateClass.Add)
Dim delSub As New calculer (AddressOf myDlegateClass.Subtract)
Dim delCalculate as calculer = DirectCast ([délégué] .Combine (delAdd, delSub), calculer)
delCalculate.Invoke (5, 3)
Console.ReadLine()
Fin Sub
}

Fonction à fractionner Numéro


CREATE FUNCTION [dbo].[GEN_NUMBER] (@ VAL VARCHAR(20))
RETOURNE VARCHAR(30)
COMME
COMMENCER

DÉCLARER @ LEN INT
DÉCLARER @ CH CHAR
DÉCLARER INT @ LEN1
DÉCLARER INT @ LEN2
DÉCLARER @ STINDEX INT
SET @LEN=LEN(@VAL)
SET @ LEN2 = 0
SET @ LEN1 = 0
SET @ STINDEX = 0
ALORS QUE (@ LEN > 0 ET @ LEN>=@LEN1)
COMMENCER
DÉFINISSEZ @ LEN1=@LEN1+1
SET @CH=SUBSTRING(@VAL,@LEN1-1,@LEN1)
SI PATINDEX('%[0-9]%',@CH) > 0
COMMENCER
SI @ LEN2<>
COMMENCER
DÉFINISSEZ @ LEN2=@LEN1
SI (@ STINDEX = 0)
DÉFINISSEZ @ STINDEX=@LEN2
FIN
FIN

FIN
SI (@ LEN2 > 0)
COMMENCER
SET @ LEN2 = CONVERT(INT,SUBSTRING(@VAL,@LEN2-1,LEN(@VAL)))
DÉFINISSEZ @ LEN2=@LEN2+1
FIN
AUTRE
SET @ LEN2 = 0
RETOUR SUBSTRING(@VAL,0, @STINDEX-1) + CONVERT (VARCHAR(20),@LEN2)

FIN

Espace de noms en c#

Un espace de noms est un domaine dans lequel type nom doit être unique. Types sont généralement organisées dans les espaces de noms hiérarchique — tant pour éviter les conflits de noms et faire des noms de type plus facile à trouver. Par exemple, le type RSA, qui gère le cryptage de la clé publique, est défini dans l'espace de noms suivant :

System.Security.Cryptography

Un espace de noms fait partie intégrante du nom d'un type.Le code suivant appelle la méthode Create RSA :

Rsa System.Security.Cryptography.RSA = System.Security.Cryptography.RSA.Create () ;

Le mot-clé de l'espace de noms définit un type au sein d'un espace de noms.Par exemple :

espace de noms Outer.Middle.Inner
{
classe Classe1 {}
classe Classe2 {}
}

Les points en l'espace de noms indiquent une hiérarchie des espaces de noms imbriqués.Ce qui suit est sémantiquement identique à l'exemple précédent :


espace de noms des
{
espace de noms moyen
{
espace de noms intérieure
{
classe Classe1 {}
classe Classe2 {}
}
}
}

Using directive importe un espace de noms.Il s'agit d'un moyen pratique pour faire référence aux types sans leurs noms qualifiés complets.Par exemple :
à l'aide de Outer.Middle.Inner.
classe test / / test est dans l'espace de noms global
{
static void main)
{
Classe1 c ;/ / Nom qualifié complet est inutile
}
}

Une utilisation directive peut être imbriqué dans un espace de noms lui-même afin de limiter le champ d'application de la directive

Tous les noms présents dans les espaces de noms externe sont implicitement importées dans les espaces de noms interne.Dans cet exemple, les noms de moyen et Classe1 sont implicitement importées dans intérieure :

espace de noms des
{
espace de noms moyen
{
classe Classe1 {}

espace de noms intérieure
{
classe Classe2 : Class1 {}
}
}
}

Si vous voulez faire référence à un type dans une branche différente de votre hiérarchie de l'espace de noms, vous pouvez utiliser un nom partiellement qualifié.Dans l'exemple suivant, nous basons SalesReport sur Common.ReportBase :

espace de noms MyTradingCompany
{
espace de noms communs
{
classe ReportBase {}
}
espace de noms ManagementReporting
{
la classe SalesReport : Common.ReportBase {}
}
}

Si le même nom de type apparaît dans une iAnywhere.Data.UltraLite intérieure et extérieure, le nom interne gagne.Pour faire référence au type externe, vous devez utiliser le nom qualifié complet.

À l'occasion, un nom de type qualifié complet peut entrer en conflit avec un nom interne.Vous pouvez forcer c# à utiliser le nom de type qualifié complet en préfixant il avec global:: comme suit :

Global:: System.Text.StringBuilder sb.