Comment simplifier ce code ?

Version imprimable

Bonjour,

Les 2 méthodes ci-dessous font la même chose, mais j'ai du en créer 2 car j'ai 2 appels de fonctions different : Func<int, double> et Func<int, DateTime, double>.

Existe-t-il une manière de réécrire cela de manière à ne garder plus qu'une seule procédure ?

Merci beaucoup.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        public static double SumItem(Func<int, double> method, int startPeriodIncluded, int endPeriodIncluded)
        {
            double sumItem = 0;
            for (int j = startPeriodIncluded; j < endPeriodIncluded + 1; j++)
            {
                sumItem += method(j);
            }
            return sumItem;
        }
 
        public static double SumItem(Func<int, DateTime, double> method, int startPeriodIncluded, int endPeriodIncluded, DateTime refinancingDate)
        {
            double sumItem = 0;
            for (int j = startPeriodIncluded; j < endPeriodIncluded + 1; j++)
            {
                sumItem += method(j, refinancingDate);
            }
            return sumItem;
        }

16/03/2020, 10h49
popo

Tout dépend de ce que font les méthodes passées en paramètre.
Mais, il est bizarre de voir une méthode statique attendre un pointeur de méthode.

Bonjour,

Vous trouverez ci-dessous les méthodes passées en paramètres. Ce sont de simples calculs de dates. Oui, j'apprends sur le tas et j'ai bien conscience que mon code doit contenir beaucoup de choses peu orthodoxes...

Bien à vous,

Code:

1
2
3
4
5
6
7
8
9
public virtual DateTime PeriodDate(int p)
        {
            return DateTimeUtils.PeriodDate(this, p);
        }
 
public virtual DateTime PeriodDate(int p, DateTime refinancingDate)
        {
           return DateTimeUtils.PeriodDate(this, p, refinancingDate);
        }

Elles appellent :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
static public DateTime PeriodDate(FinancialInstrument financialInstrument, int p)
        {
            DateTime issueDate = DateOnly(financialInstrument.IssueDate);
            int fiFrequency = financialInstrument.FiFrequency; 
            return issueDate.AddMonths(p * fiFrequency);
        }
 
static public DateTime PeriodDate(FinancialInstrument financialInstrument, int p, DateTime refinancingDate)
        {
            int totalNbOfPeriods = financialInstrument.TotalNbOfPeriods;
            DateTime nDate = PeriodDate(financialInstrument, totalNbOfPeriods);
            DateTime pDate = PeriodDate(financialInstrument, p);
            DateTime refiDate = DateOnly(refinancingDate);
 
            if (refiDate <= nDate)
            {
                if (pDate < refiDate & pDate < nDate)
                {
                    return pDate;
                }
                else
                {
                    return refiDate;
                }
            }
            else
            {
                return pDate;
            }
        }

En ne faisant qu'une seule méthode static PeriodDate prenant un Nullable<DateTime> tu devrais pouvoir n'avoir qu'une seul méthode virtuelle PeriodDate avec un Nullable<DateTime> et donc un seule méthode SumItem avec un Nullable<DateTime>.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
static public DateTime PeriodDate(FinancialInstrument financialInstrument, int p, Nullable<DateTime> refinancingDate)
{
     if (refinancingDate.HasValue) 
    {
 
            int totalNbOfPeriods = financialInstrument.TotalNbOfPeriods;
            DateTime nDate = PeriodDate(financialInstrument, totalNbOfPeriods);
            DateTime pDate = PeriodDate(financialInstrument, p);
            DateTime refiDate = DateOnly(refinancingDate.Value);
 
            if (refiDate <= nDate)
            {
                if (pDate < refiDate & pDate < nDate)
                {
                    return pDate;
                }
                else
                {
                    return refiDate;
                }
            }
            else
            {
                return pDate;
            }
      }
      else
     {
            DateTime issueDate = DateOnly(financialInstrument.IssueDate);
            int fiFrequency = financialInstrument.FiFrequency; 
            return issueDate.AddMonths(p * fiFrequency);
     }
 }

Code:

1
2
3
4
public virtual DateTime PeriodDate(int p, Nullable<DateTime> refinancingDate)
{
     return DateTimeUtils.PeriodDate(this, p, refinancingDate);
}

Code:

1
2
3
4
5
6
7
8
9
10
 
        public static double SumItem(Func<int, Nullable<DateTime>, double> method, int startPeriodIncluded, int endPeriodIncluded, Nullable<DateTime> refinancingDate)
        {
            double sumItem = 0;
            for (int j = startPeriodIncluded; j < endPeriodIncluded + 1; j++)
            {
                sumItem += method(j, refinancingDate);
            }
            return sumItem;
        }

17/03/2020, 19h01
Noxen

Je ne sais pas exactement ce à quoi correspond ton code, mais je me demande si tu ne réécrits pas des choses qui existent déjà sur les dates.
17/03/2020, 19h12
Rayanea

@popo : merci je vais tester ça. Je pensais que le Delegate pouvait m'apporter une solution, mais de ce que j'en comprends, ça fonctionne comme un Func<>, donc a priori non

@Noxen : c'est possible, ça ne m'étonnerait pas. Comme dit, j'apprends sur le tas... Pourrais-tu expliciter que je comprenne l'erreur potentielle ?
17/03/2020, 21h26
Noxen

Avec DateTime et TimeStamp tu as des méthodes pour faire des calculs sur les dates et les durées : ajouter ou retirer des jours, des mois, des heures, calculer la durée entre deux dates, etc... Mais comme je l'ai dit je ne sais pas si c'est tout ce dont tu as besoin.
18/03/2020, 22h39
Rayanea

En fait j'ai copié collé les mauvaises fonctions... Les PeriodDate ne sont pas appelées dans le cadre de cette fonction, mais d'autres fonctions suivant le même principe et retournant des doubles.

Est-ce que l'utilisation de Delegate peut me permettre de résoudre mon problème de "redondance de code" ?
19/03/2020, 11h07
Noxen

Les delegates permettent d'éviter la duplication lorsque tu as un algorithme de haut niveau pour lequel on veut pouvoir substituer l'une des composante ; c'est ce que tu as avec toutes les méthodes d'extension Linq ou bien la méthode List<T>.ForEach(Action<T>). Mais en principe tous les delegates concernés respecteront la même signature, donc il ne sera pas possible d'avoir différents nombre de paramètres.

Par contre une méthode pourrait admettre des paramètres dont l'un aurait disposerait d'une valeur "idem potente" (par exemple le 0 pour des nombres). Mais en général on fait des méthodes spécialisés pour des questions de lisibilité. Et puis tout dépend de ce que tu appelles une redondance, si tu as besoin de différents nombre de paramètres cela peut correspondre à différents contextes et ce n'est pas forcément de la redondance.
19/03/2020, 11h52
Rayanea

Qu'est ce qu'il faut entendre "algorithme de haut niveau" et "valeur "idem potente" "?

Ce que j'appelle redondance c'est par exemple dans ma fonction SumItem le fait que la boucle est strictement la même. Si je devais changer la logique de la boucle, je devrais la changer dans les 2 fonctions.

Ici ce n'est qu'un exemple, mais mon code comporte beaucoup de redondances de ce type que j'essaie de réduire au fur et à mesure. J'imaginais que l'emploi de Delegate pouvait m'aider. Le Nullable<T> me semble une bonne solution, mais je n'ai pas encore eu le temps de tester.
28/03/2020, 08h26
Sehnsucht

Le DateTime est fixé dès le début et n'intervient pas dans la méthode, du point de vue de la méthode qu'il existe ou pas revient au même. Autant donc le fixer en amont à l'aide d'une closure et le problème est réglé.

Code:

SumItem(n => methodWithDate(n, refinancingDate), startPeriodIncluded, endPeriod

On peut bien sûr, stocker la lambda dans une variable locale en amont au besoin.
29/03/2020, 12h00
Rayanea

@Sehnsucht : désolé mais je n'ai pas compris... peux-tu s'il te plait expliciter ?
@popo : j'ai essayé de changer avec un Nullable<DateTime>, mais le problème est que je ne vois pas l'intérêt. Finalement cela ne simplifie pas vraiment le code, cela met tout dans une seule fonction, mais on doit quand même avoir un if... else... qui reprendra les mêmes algorithmes que précédemment.
29/03/2020, 12h06
Sehnsucht

Je vois pas vraiment quoi expliquer de plus que ce que j'ai déjà dit, surtout que je donne le code qui répond à la question initiale ; comment n'avoir qu'une surcharge et pouvoir l'utiliser avec le délégué qui a le DateTime quand même.
29/03/2020, 13h02
Rayanea

Je ne comprends pas ce que l'utilisation de la closure telle que décrite va différer d'un

Code:

Func<int, DateTime, double> method

Elle ne diffère pas, elle permet de l'utiliser directement avec la surcharge de SumItem qui attend un Func<int, double>, et donc de n'avoir plus besoin que d'une surcharge (ou en avoir 2 avec la seconde déléguant à la première) ; comme dit dans mon message précédent

Citation:

Envoyé par Sehnsucht

je donne le code qui répond à la question initiale ; comment n'avoir qu'une surcharge et pouvoir l'utiliser avec le délégué qui a le DateTime quand même.
Code:

1 2 3 4 5 6 7 8 9 //utilisation directe DateTime refinancingDate = … Func<int, DateTime, double> methodWithDate = (i, dt) => … Func<int, double> methodWithDateFixed = i => methodWithDate(i, refinancingDate); SumItem(methodWithDateFixed, …); //Surcharge qui délègue public static double SumItem(Func<int, DateTime, double> method, int startPeriodIncluded, int endPeriodIncluded, DateTime refinancingDate) => SumItem(i => method(i, refinancingDate), startPeriodIncluded, endPeriodIncluded);