C# Génériques ne permettent pas à Déléguer les Contraintes de Type

Est-il possible de définir une classe en C#, tels que

class GenericCollection<T> : SomeBaseCollection<T> where T : Delegate

Je ne pouvais pas pour la vie de m'accomplir cette dernière nuit .NET 3.5. J'ai essayé d'utiliser

delegate, Delegate, Action<T> and Func<T, T>

Il me semble que cela devrait être permis, d'une certaine façon. Je suis en train de mettre en place mes propres EventQueue.

J'ai juste le faire [primitive rapprochement que vous avez l'esprit].

internal delegate void DWork();

class EventQueue {
    private Queue<DWork> eventq;
}

Mais je perds la possibilité de réutiliser la même définition pour les différents types de fonctions.

Pensées?

InformationsquelleAutor Nicholas Mancuso | 2008-10-10

c#constraints delegates events generics

65

Un certain nombre de classes sont disponibles comme générique contraintes - Enum est un autre.

Pour les délégués, le plus proche que vous pouvez obtenir est: "classe", peut-être à l'aide de la réflexion afin de vérifier (par exemple, dans le constructeur statique) que le T est un délégué:
```
static GenericCollection()
{
    if (!typeof(T).IsSubclassOf(typeof(Delegate)))
    {
        throw new InvalidOperationException(typeof(T).Name + " is not a delegate type");
    }
}
```
- +1 pour: 1) en utilisant le constructeur statique et 2), y compris un message détaillé en raison bizarre de débogage conditions environnantes type d'initialisation.
- Ne pas lancer une exception dans un initialiseur statique violer CA1065: Do not raise exceptions in unexpected locations ... j'étais toujours dans l'hypothèse que vous devez utiliser un code personnalisé de règles d'analyse pour trouver des invalides usages de votre classe qui ne sont normalement pas disponibles au moment de l'exécution.
- Débutant en C# 7.3 (sorti en Mai 2018), il est permis de contraindre comme ça, where T : Delegate, (et quelqu'un a publié une nouvelle réponse à ce sujet ci-dessous).
InformationsquelleAutor Marc Gravell
13

Edit: Certains ont proposé des solutions de rechange sont proposées dans ces articles:

http://jacobcarpenters.blogspot.com/2006/06/c-30-and-delegate-conversion.html

http://jacobcarpenters.blogspot.com/2006_11_01_archive.html

De la C# 2.0 on peut lire (20.7, Contraintes):

Une classe de type de contrainte doivent satisfaire aux règles suivantes:
- Le type doit être un type de classe.
- Le type ne doit pas être scellé.
- Le type ne doivent pas être l'un des types suivants: Système d'.Tableau, Système.Délégué Système.Enum, ou d'un Système.ValueType.
- Le type ne doit pas être l'objet. Parce que tous les types de dériver de l'objet, telle contrainte serait sans effet si elle était autorisée.
- Au plus une contrainte pour un paramètre de type peut être un type de classe.
Et bien sûr VS2008 crache une erreur:
```
error CS0702: Constraint cannot be special class 'System.Delegate'
```
Pour l'info et enquête sur cette question, lire ici.

InformationsquelleAutor Jorge Ferreira

Si vous êtes prêt à prendre un moment de la compilation de dépendance sur un IL Weaver vous pouvez faire cela avec Fody.

À l'aide de cet addin pour Fody https://github.com/Fody/ExtraConstraints

Votre code peut ressembler à ceci

public class Sample
{
    public void MethodWithDelegateConstraint<[DelegateConstraint] T> ()
    {        
    }
    public void MethodWithEnumConstraint<[EnumConstraint] T>()
    {
    }
}

Et être compilé à ce

public class Sample
{
    public void MethodWithDelegateConstraint<T>() where T: Delegate
    {
    }

    public void MethodWithEnumConstraint<T>() where T: struct, Enum
    {
    }
}

Lien brisé. Avez-vous un actuel?
mise à jour

InformationsquelleAutor Simon

9

Oui c'est possible en C# 7.3, les Contraintes de la famille a augmenté pour inclure Enum, Delegate et unmanaged types.
Vous pouvez écrire ce code sans problème:
```
void M<D, E, T>(D d, E e, T* t) where D : Delegate where E : Enum where T : unmanaged
    {

    }
```
Liens utiles:

L'avenir de C#, à partir de Microsoft Build 2018

Les nouveautés de C# 7.3?
- Oui, il est possible en C# 7.3 (depuis Mai 2018), et vous pouvez voir notes de version ici.
InformationsquelleAutor mshwf

Délégué prend déjà en charge de chaînage. N'est-ce pas répondre à vos besoins?

public class EventQueueTests
{
public void Test1()
{
Action myAction = () => Console.WriteLine("foo");
myAction += () => Console.WriteLine("bar");
myAction();
//foo
//bar
}
public void Test2()
{
Action<int> myAction = x => Console.WriteLine("foo {0}", x);
myAction += x => Console.WriteLine("bar {0}", x);
myAction(3);
//foo 3
//bar 3
}
public void Test3()
{
Func<int, int> myFunc = x => { Console.WriteLine("foo {0}", x); return x + 2; };
myFunc += x => { Console.WriteLine("bar {0}", x); return x + 1; };
int y = myFunc(3);
Console.WriteLine(y);
//foo 3
//bar 3
//4
}
public void Test4()
{
Func<int, int> myFunc = x => { Console.WriteLine("foo {0}", x); return x + 2; };
Func<int, int> myNextFunc = x => { x = myFunc(x);  Console.WriteLine("bar {0}", x); return x + 1; };
int y = myNextFunc(3);
Console.WriteLine(y);
//foo 3
//bar 5
//6
}
}

ce n'est pas vraiment la fonctionnalité, je suis à la recherche d'... j'ai essayé de faire un type de contrainte sur ma classe générique...

InformationsquelleAutor Amy B

3

Je suis tombé sur une situation où j'avais besoin de traiter avec un Delegate à l'intérieur, mais je voulais une contrainte générique. Plus précisément, je voulais ajouter un gestionnaire d'événement à l'aide de la réflexion, mais je voulais utiliser un argument générique pour le délégué. Le code ci-dessous ne fonctionne PAS, depuis le "Gestionnaire" est un type de variable, et le compilateur ne jette pas Handler à Delegate:
```
public void AddHandler<Handler>(Control c, string eventName, Handler d) {
c.GetType().GetEvent(eventName).AddEventHandler(c, (Delegate) d);
}
```
Cependant, vous pouvez passer une fonction qui fait la conversion pour vous. convert prend un Handler argument et renvoie un Delegate:
```
public void AddHandler<Handler>(Control c, string eventName, 
Func<Delegate, Handler> convert, Handler d) {
c.GetType().GetEvent(eventName).AddEventHandler(c, convert(d));
}
```
Maintenant que le compilateur est heureux. L'appel de la méthode est facile. Par exemple, en joignant à la KeyPress événement sur un contrôle Windows Forms:
```
AddHandler<KeyEventHandler>(someControl, 
"KeyPress", 
(h) => (KeyEventHandler) h,
SomeControl_KeyPress);
```
où SomeControl_KeyPress est la cible de l'événement. La clé est le convertisseur de lambda - il n'a pas de travail, mais il convainc le compilateur vous lui avez donné un valide délégué.

(Commencer 280Z28) @Justin: Pourquoi ne pas l'utiliser?
```
public void AddHandler<Handler>(Control c, string eventName, Handler d) { 
c.GetType().GetEvent(eventName).AddEventHandler(c, d as Delegate); 
} 
```
(Fin 280Z28)
- J'ai édité votre réponse à mettre mon commentaire à la fin, car il a un bloc de code.
- Bonne prise. Qui fonctionne très bien.
InformationsquelleAutor Justin Bailey
2

Comme mentionné ci-dessus, vous ne pouvez pas avoir les Délégués et les Enum comme une contrainte générique. System.Object et System.ValueType aussi ne peut pas être utilisé comme une contrainte générique.

Le travail autour de peut être, si vous construisez un appel approprié en vous IL. Cela fonctionnera très bien.

Ici est un bon exemple de Jon Skeet.

http://code.google.com/p/unconstrained-melody/

J'ai pris mes références de Jon Skeet du livre C# en Profondeur, 3e édition.

InformationsquelleAutor maxspan
1

Selon MSDN

Erreur du compilateur CS0702

Contrainte ne peut pas être classe spéciale " identifier Les types suivants ne peuvent pas être utilisés comme des contraintes:
- Système.Objet
- Système.Tableau
- Système.Délégué
- Système.Enum
- Système.ValueType.
- Cette réponse n'aide pas à résoudre le problème!
InformationsquelleAutor Rahul Nikate

Vous devez vous connecter pour publier un commentaire.