Functors quand devrais-je les utiliser?

Je pense que vous êtes confus termes de langues différentes. Vous semblez être à l'aide de "Foncteur" dans le C++ ou Java sens, par exemple,voir la page de wikipedia. En C++, c'est un objet d'une classe qui surcharge la fonction d'appel de l'opérateur, de sorte qu'il peut être utilisé comme une fonction, mais avec l'état.

C'est logiquement la même chose en tant que délégué à une méthode d'instance en C# (ou tout .NET de la langue).

Il y a trois façons d'écrire une telle chose. Tout d'abord, vous pouvez écrire une méthode ordinaire, puis attribuez le nom de la méthode à un délégué variable.

void MyMethod() { Console.WriteLine("Hi!"); }

void Foo()
{
    Action a = MyMethod;
    a();
}

Seconde, vous pouvez utiliser la méthode anonyme syntaxe, introduit en C# 2.0:

void Foo()
{
    Action a = delegate { Console.WriteLine("Hi!"); }
    a();
}

Troisièmement, vous pouvez utiliser lambda syntaxe, introduit en C# 3.0:

void Foo()
{
    Action a = () => Console.WriteLine("Hi!");
    a();
}

L'avantage de la dernière deux est que le corps de la méthode peut lire et écrire des variables locales dans le contenant de la méthode.

L'avantage de la lambda la syntaxe sur la anon-méthodes qu'il est plus succinct et il n'type d'inférence sur les paramètres.

Mise à jour: L'avantage de anon-méthodes (delegate mot-clé) sur les lambdas, c'est que vous pouvez omettre les paramètres tout à fait si vous n'en avez pas besoin:

//correct way using lambda
button.Click += (sender, eventArgs) => MessageBox.Show("Clicked!");

//compile error - wrong number of arguments
button.Click += () => MessageBox.Show("Clicked!");

//anon method, omitting arguments, works fine
button.Click += delegate { MessageBox.Show("Clicked!"); };

Je ne connais qu'un exemple de situation où c'est la peine de savoir, qui est lors de l'initialisation d'un événement de sorte que vous n'avez pas à vérifier null avant de le tirer:

event EventHandler Birthday = delegate { };

Évite beaucoup de bêtises ailleurs.

Enfin, vous mentionnez qu'il existe quatre types de foncteur. En fait, il y a une infinité de peut-être délégué types, bien que certains auteurs peuvent avoir leurs favoris et il y aura évidemment quelques modèles communs. Un Action ou Command prend aucun paramètre et renvoie voidet d'un prédicat prend une instance d'un type et retourne true ou false.

En C# 3.0, vous pouvez concocter un délégué avec jusqu'à quatre paramètres de tous les types que vous aimez:

Func<string, int, double> f;  //takes a string and an in, returns a double

Re: Mise À Jour En Question

Vous demander (je pense) si il y a beaucoup de cas d'utilisation pour les lambdas. Il y a plus que ce qui peut éventuellement être répertoriés!

Vous le plus souvent les voir au milieu de la plus grande des expressions qui fonctionnent sur des séquences (listes calculées à la volée). Supposons que j'ai une liste de gens, et je veux une liste de personnes exactement quarante ans:

var exactlyForty = people.Where(person => person.Age == 40);

La Where méthode est une méthode d'extension sur le IEnumerable<T> interface, où T dans ce cas est une sorte de Person classe.

C'est connu dans .NET comme "Linq to Objects", mais connu par ailleurs comme pure programmation fonctionnelle sur des séquences ou des cours d'eau ou "paresseux" listes (toutes des noms différents pour la même chose).

Intéressant avec la terminologie; mon spontanée à l'interprétation du terme "Foncteur" était qu'elle se réfère à des méthodes anonymes. Donc, ça va être mon prendre sur elle.

Ce sont certains de mes utilisations courantes:

Comparaisons (généralement de tri d'une liste):

List<int> ints = new List<int>();
ints.AddRange(new int[] { 9, 5, 7, 4, 3, 5, 3 });
ints.Sort(new Comparison<int>(delegate(int x, int y)
    {
        return x.CompareTo(y);
    }));
//yes I am aware the ints.Sort() would yield the same result, but hey, it's just
//a conceptual code sample ;o)

//and the shorter .NET 3.5 version:
ints.Sort((x, y) =>
{
    return x.CompareTo(y);
});

Je vais utiliser cette approche pour les comparaisons, plutôt que de l'avoir dans son propre méthode à l'aide d'un délégué pour cette méthode, dans le cas où ce type particulier qui se passe dans un seul endroit. Si il est probable que je veux utiliser la même comparaison ailleurs, il arrive à vivre dans son propre, réutilisable méthode.

Un autre de mes assez commune utilise est dans les tests unitaires, lorsque le test s'appuie sur certains cas d'être posée. J'ai trouvé que pour être essentielle lorsque l'unité de flux de test dans le Workflow Foundation:

WorkflowRuntime runtime = WorkflowHost.Runtime;  
WorkflowInstance instance = runtime.CreateWorkflow(typeof(CreateFile)); 
EventHandler<WorkflowEventArgs> WorkflowIdledHandler = delegate(object sender, WorkflowEventArgs e)
{
    //get the ICreateFileService instance from the runtime  
    ISomeWorkflowService service = WorkflowHost.Runtime.GetService<ISomeWorkflowService>();

    //set the desired file content  
    service.DoSomeWork(instance.InstanceId, inputData);
};  
//attach event handler
runtime.WorkflowIdled += WorkflowIdledHandler;  

instance.Start();  
//perform the test, and then detach the event handler
runtime.WorkflowIdled -= WorkflowIdledHandler; 

Dans ce cas, il est plus simple d'avoir le gestionnaire d'événement déclaré que les méthodes anonymes car il utilise le instance variable qui est définie dans l'unité de test de la portée de la méthode. Avais-je intstead opté pour implelment le gestionnaire d'événements comme sa propre méthode que j'ai aussi besoin de trouver un moyen pour ramasser instanceprobablement par l'introduction d'un niveau de classe membre qui ne semble pas comme un design parfait dans une unité de la classe de test.

Il y a plus de cas où je retrouve cela dans mon code, mais ils ont généralement une ou deux choses en commun:

• Je n'ai aucun intérêt dans le référencement de ce morceau de code à partir de n'importe où ailleurs que dans ce lieu particulier.
• La méthode a besoin d'accéder à des données qui seraient hors du champ d'application d'une méthode régulière

La vraie réponse est qu'un foncteur est un type d'objet mathématique, et est "réifiée" par des langues différentes de différentes manières. Par exemple, supposons que vous avez un "conteneur" de l'objet qui stocke un tas d'autres objets du même type. (Par exemple, un ensemble ou un tableau) Ensuite, si votre langue a une méthode qui vous permettent de "carte" sur le récipient, de sorte que vous pouvez appeler une méthode sur chaque objet dans le conteneur, puis le conteneur serait un foncteur.

En d'autres termes, un foncteur est un conteneur avec une méthode qui vous permet de passer d'une méthode à ses contenus choses.

Chaque langue a sa propre façon de faire cela, et ils ont parfois l'amalgame entre l'utilisation. Par exemple, C++ utilise des pointeurs de fonction pour représenter le "passage" d'une méthode, et appelle le pointeur de fonction d'un "foncteur." Les délégués sont juste une poignée de méthodes que vous pouvez passer. Vous êtes à l'aide de la terminologie de "mal", tout comme le C++ n'.

Haskell obtient droit. Vous déclarez un type implémente le foncteur de l'interface, et puis, vous obtenez la méthode de cartographie.

Fonctions (tels que les lambdas) sont les foncteurs trop, mais il peut être difficile de penser à une fonction comme un "conteneur". En bref, une fonction est un "conteneur" autour d'une valeur de retour, construit d'une manière telle que la valeur de retour (peut-être) repose sur les arguments de la fonction.