Méthode à l'aide de la touche Func<T,TResult> en tant que paramètres

J'ai besoin d'aide sur la simplification de ma méthode

J'ai cette méthode

public double ComputeBasicAmount(double basicLimit, double eligibleAmt)
{
  return basicLimit * eligibleAmt;
}

exemple d'utilisation:

Foo foo = new Foo(100, 1000);
double basicAmt = ComputeBasicAmount(foo.BasicLimit, foo.EligibleAmt)

Le problème ici c'est que je veux le eligibleAmt dynamique parce que parfois
ce n'est pas vraiment que les eligbleAmt ce que je suis de passage à la méthode.. comme ce

Foo foo = new Foo(100, 1000);
double basicAmt = ComputeBasicAmount(foo.BasicLimit, foo.EligibleAmt/foo.RoomRate)

Ma solution c'est d'utiliser le Func délégué en tant que paramètre mais je ne sais pas comment l'utiliser correctement

je veux quelque chose de fonctionnel comme ce

public double ComputeBasicAmount<T>(double basicLimit, Func<T, double> multiplier)
{

 return basicLimt * multiplier;
}

double basicAmt = ComputeBasicAmount<Foo>(foo.BasicLimit, x => x.EligibleAmt/x.RoomRate)

quelqu'un peut m'aider. merci à l'avance...

OriginalL'auteur CSharpNoob | 2010-09-10

  1. 5

    Si le multiplicateur dépend de l'élément, puis soit vous aurez besoin de passer l'élément ainsi, ou vous aurez besoin de retourner un Func<T, double>:

    public double ComputeBasicAmount<T>(double basicLimit,
                                    Func<T, double> multiplier,
                                    T item)
{    
    return basicLimt * multiplier(item);
}
...

double basicAmt = ComputeBasicAmount<Foo>(
                        foo.BasicLimit,
                        x => x.EligibleAmt / x.RoomRate,
                        foo)

    ou

    public Func<T, double> ComputeBasicAmount<T>(double basicLimit,
                                             Func<T, double> multiplier)
{    
    return item => basicLimt * multiplier(item);
}
...
var basicAmtFunc = ComputeBasicAmount<Foo>(
                        foo.BasicLimit,
                        x => x.EligibleAmt / x.RoomRate);

var basicAmt = basicAmntFunc(foo);

    Si aucune de celles-ci est ce que vous cherchez, veuillez expliquer d'où vous voulez que le réelle valeur de T être prévue de sorte que vous pouvez travailler sur le multiplicateur.

    La première est très similaire juste d'avoir une Func<double> pour calculer le multiplicateur, bien sûr... qui à son tour est un peu comme appel que Func<double> lors du calcul de l'argumentation, pour en revenir à votre version originale, qui prend juste deux doubles.

    Je peux l'utiliser si j'ai besoin de la valeur réelle de T, mais pour ce scénario, je ne suis qu'à l'évaluation de la double valeur de la propriété de différents objets . Merci...

    OriginalL'auteur Jon Skeet

  2. 4

    Vous pouvez déclarer simplement comme un Func<double> (de cette façon vous ne faites pas de la méthode dépend de la Foo type), et de passer toute méthode prenant aucun paramètre et retournant un double argument:

    public static double ComputeBasicAmount(double basicLimit, Func<double> multiplier)
{
    return basicLimit * multiplier();
}

    Quelques exemples d'appels:

    class Foo
{
    public double One;
    public double Two;
}


Foo f = new Foo();
double result = ComputeBasicAmount(f.One, () => f.Two);

    Vous pouvez également avoir une autre méthode retournant une double

    public static double GetDoubleValue()
{
    return 4.2;
}

    ...et le passer en argument:

    double result = ComputeBasicAmount(42,GetDoubleValue);
    pouvez-vous faire une version Générique de ce, parce que ses pas l'objet FOO ce qui im va passer. merci
    oh man, je suppose que je n'ai pas à utiliser des Génériques ici parce que je n'ai pas à passer le Type... merci man...
    exactement. La méthode est déjà aussi générique que cela, étant donné que nous avons toujours voulu le faire fonctionner sur double valeurs.

    OriginalL'auteur Fredrik Mörk

  3. 0

    Vous devez utiliser un Func<double> depuis que vous utilisez seulement le double résultat

    public double ComputeBasicAmount(double basicLimit, Func<double> multiplier)
{    
    return basicLimt * multiplier();
}

    Puis l'appeler comme cela

    double basicAmt = ComputeBasicAmount<Foo>(foo.BasicLimit, x => x.EligibleAmt/x.RoomRate)

    Mais alors vous pourriez avoir un double régulière paramètre à la place.

    OriginalL'auteur Albin Sunnanbo

  4. 0

    Vous vous souhaitez déclarer votre méthode de quelque chose comme cela, alors que le multiplicateur est un délégué qui prend un objet Foo et renvoie un double:

    double ComputeBasicAmount(
   double basicLimit, Foo foo, Func<Foo, double> multiplier)

    Ensuite l'appeler comme ça, en passant lambda dans le multiplicateur:

    double basicAmt = ComputeBasicAmount(
   foo.BasicLimit, foo, x => x.EligibleAmt / x.RoomRate);
    Ce n'est pas correct qu'un Foo instance n'est en cours passé donc il n'y a rien pour le ComputeBasicAmount d'appeler le Func avec.
    Absolument droit, fixe.
    merci mais ma méthode est la même que la vôtre est la différence, le mien est Générique

    OriginalL'auteur Chris Fulstow

  5. 0

    Merci les gars, grâce À votre aide, j'ai pu rendre mon code plus lisible et fonctionnelle...

        class RNB
    {
        public RNB(double roomRate, double roomDays)
        {
            RoomRate = roomRate;
            RoomDays = roomDays;
        }

        public double RoomRate { get; set; }
        public double RoomDays { get; set; }
        public const double BasicLimit = 100;
    }

    class HMS
    {
        public double Amount { get; set; }
        public const double BasicLimit = 200;
    }

    public static double ComputeBasicAmount(double basicLimit, Func<double> multiplier)
    {
        return basicLimit * multiplier();
    }

    static void Main(string[] args)
    {
        RNB rnb = new RNB(100, 2);
        double result = ComputeBasicAmount(RNB.BasicLimit, () => rnb.RoomDays * rnb.RoomRate);
        Console.WriteLine("RNB Basic Amt: " + result.ToString());

        HMS hms = new HMS() { Amount = 1000 };
        result = ComputeBasicAmount(HMS.BasicLimit, () => hms.Amount);
        Console.WriteLine("HMS Basic Amt: " + result.ToString());

        Console.Read();
    }

    Mais j'ai un autre problème.. je Veux éliminer le passage de la BasicLimit parce que je pense qu'il est redondant ici. Est-il possible de mettre la BasicLimit à l'intérieur de la ComputeBasicAmount méthode

    Quelque chose comme ça..

     public static double ComputeBasicAmount<T>(Func<T, double> multiplier, T obj)
  {

      return obj.BasicLimit * multiplier();
  }

    Mais je dois mettre cette question dans un autre fil, car je pense que c'est un autre sujet...
    Voir vous les gars là... merci...

    OriginalL'auteur CSharpNoob