C# List.Trouver la méthode - comment puis-je passer une valeur dans le prédicat?

Je ne peux pas travailler sur la façon de faire un "rechercher" sur une Liste que j'ai basé sur l'utilisation d'une valeur que je vais passer au moment de l'exécution. Si vous voyez ci-dessous mon code, je veux être en mesure de trouver la CustomClass dans la Liste pour laquelle il est Chemin paramètre est égal à X, où X sera défini au moment de l'exécution.

Toutes les idées comment faire une telle trouver sur une Liste? Ou n'est-ce pas possible sans l'écriture d'un itérateur et de faire le rechercher manuellement? Dans quel cas peut-être, il est l'un des principaux ed collection je devrais regarder en utilisant à la place?

   private List<CustomClass> files;

   public void someMethod()
  {
       Uri u= new Uri(www.test.com);
       CustomClass cc = this.files.find( matchesUri(u) );  //WON'T LET ME DO THIS
  }

   private static bool matchesUri(List<CustomClass> cc, Uri _u)
    {
        return cc.Path == _u;           }


public class CustomClass
{
    private Uri path;

    public Uri Path
    {
        get { return this.path; }
        set { this.path = value; }
    }
}

PS. Je dois avouer que je n'ai pas tout à fait suivi le prédicat de choses dans le doco à http://msdn.microsoft.com/en-us/library/x0b5b5bc.aspx

OriginalL'auteur Greg | 2009-10-07

c#collections find list predicate

12

Utiliser une lambda:
```
 Uri u = new Uri("www.test.com");
 CustomClass cc = this.files.Find(cc => cc.Path == u);
```
ou si vous souhaitez encore une méthode nommée:
```
static bool matchesUri(CustomClass cc, Uri _u)
{
    return cc.Path == _u;
}

 Uri u = new Uri("www.test.com");
 CustomClass cc = this.files.Find(cc => matchesUri(cc, u));
```
merci les gars d'ailleurs si j'ai pu (si j'avais plus de place sur C#), travaillé par simplement en regardant la syntaxe de la méthode dans le doco? (ie. Paramètres, match, Type: System..::.Prédicat< (< T>)>), Le Prédicat< (< T>)>) le délégué qui définit les conditions de l'élément à rechercher...
Type de paramètre limite le type de délégué, vous pouvez passer à la méthode, et donc la signature de la méthode ou lambda vous avez à utiliser pour créer ce délégué. Il n'est pas, en soi, l'utilisation de lambdas plus que tout autre type de délégué. Documentation pour les lambdas est ici: msdn.microsoft.com/en-us/library/bb397687.aspx
Délégué est semblable à un pointeur de fonction. En regardant la signature (delegate bool Predicate<T>(T obj)) vous pouvez voir qu'un prédicat est une fonction (méthode) qui prend un seul paramètre de type T, et renvoie un bool.

OriginalL'auteur Pavel Minaev
1

Vous pouvez écrire
```
CustomClass cc = this.files.Find( p=> p.Path == u );
```
La méthode Find() retourne null si aucun élément n'a été trouvée, qui correspond au prédicat.

OriginalL'auteur Jehof

Par souci d'exhaustivité seulement, ici est ce que vous feriez si vous ne souhaitez pas utiliser une lambda:

//Predicate must be a method with a single parameter,
//so we must pass the other parameter in constructor

public class UriMatcher
{
    private readonly Uri _u;
    public UriMatcher(Uri u)
    {
        _u = u;
    }

    //Match is Predicate<CustomClass>
    public bool Match(CustomClass cc)
    {
        return cc.Path == _u;
    }
}

Et ensuite l'utiliser comme:

public void someMethod()
{
    Uri u = new Uri("www.test.com");
    UriMatcher matcher = new UriMatcher(u);
    CustomClass cc = this.files.Find(matcher.Match);
}

Remarque que vous êtes de passage à un référence à une méthode, pas le résultat de la méthode -- Match vs Match().

Vérifier ce fil: Prédicat Délégués en C#.

OriginalL'auteur Groo

public void someMethod()
{
    Uri u= new Uri("www.test.com");
    CustomClass cc = this.files.find( p => { return p.Path == u; } );
}

Pourquoi déclaration lambda?
PEBCAK. Pet cerveau. Faites votre choix.

OriginalL'auteur Matthew Scharley

0

Essayez d'utiliser de méthode anonyme pour la recherche et l'utilisation locale de la variable que vous souhaitez à l'intérieur de lui. Si ce n'est pas satisfaisante, appelez votre normalement défini méthode du délégué.

OriginalL'auteur Daniel Mošmondor

.NET 2.0 réponse à l'aide d'un délégué anonyme (notez que cela ne fonctionne que pour le C#, VB.NET n'ont pas de délégués anonymes).

public void someMethod()
{
  Uri u= new Uri("www.test.com");
  CustomClass cc = this.files.find(delegate(CustomClass oTemp) { return oTemp.Path == u;});
}

OriginalL'auteur stevehipwell

0

De Pavel post marqué comme réponse, je pense que la ligne:
```
CustomClass cc = this.files.Find(cc => cc.Path == u);
```
devraient plutôt être comme:
```
CustomClass cc = this.files.Find(cc2 => cc2.Path == u);
```
C'est parce que l'expression à gauche de => est une définition de la variable (le type est déduit à partir de l'expression) - Le compilateur donne une redéfinition d'erreur sinon.

Cette expression peut aussi s'écrire avec une définition explicite comme:
```
CustomClass cc = this.files.Find((CustomClass  cc2) => cc2.Path == u);
```
OriginalL'auteur pasx
0

Voici une solution que j'ai utilisé. J'avais besoin de passer plusieurs arguments et ne voulait pas l'utiliser tout ce qui pourrait m'empêcher de modification de la méthode en cours d'exécution, alors je suis venu avec cette.

Évidemment, si vous voulais vous pouvez le changer à une méthode générique (bon terme?) en utilisant des arguments de type. Cela aussi permet de contourner le problème de la lambdas dans une méthode. Pas sûr que cela s'applique à des méthodes anonymes ou pas, mais c'est déjà séparé, donc pas de gros problème.

Je ne sais pas si la réflexion aurait une performance ou pas.
```
private Predicate<ItemData> FindItemData(string search, string fieldName)
{
    var field = typeof(ItemData).GetField(fieldName);
    return delegate(ItemData item) { return (string)field.GetValue(item) == search; };
}

//in another method...
itemlist.Find(FindItemData(e.Row[2].ToString(), "ItemName"));
```
Je vais dire que je n'ai pas vérifié qu'il laissez-moi faire des modifications, mais sinon il fonctionne très bien.

OriginalL'auteur Arlen Beiler

Vous devez vous connecter pour publier un commentaire.