La différence entre les 2 numéros

Vous pouvez le faire comme ceci

public decimal FindDifference(decimal nr1, decimal nr2)
{
  return Math.Abs(nr1 - nr2);
}

Juste en ajoutant cette, que personne n'a écrit ici:

Alors que vous pouvez certainement l'utiliser

Math.Abs(number1 - number2);

qui est la solution la plus simple (et accepté de répondre), je me demande personne n'a écrit sur ce que l'Abs ne fait. Voici une solution qui fonctionne dans Java, C, C# et tous les autres langage avec une syntaxe de type C:

int result = number1 - number2;
if (result < 0) {
    result *= -1;
}

C'est aussi simple que cela. Vous pouvez aussi l'écrire comme ceci:

int result = number1 > number2 ? number1 - number2 : number2 - number1;

Le dernier pourrait être encore plus rapide une fois qu'il est compilé; les deux ont un si et une soustraction, mais le premier a une multiplication dans certains cas, le dernier n'a pas. Pourquoi seulement dans certains cas? Certains Processeurs ont un "swap signe" de l'opération et le compilateur reconnaît que *= -1 ne sert qu'à des swaps de le signe, donc au lieu d'une multiplication, il sera question d'un échange signer le fonctionnement pour les Processeurs qui l'offrir, et cette opération est aussi rapide qu'un PROCESSEUR opération peut obtenir (généralement un seul cycle d'horloge).

Le premier exemple de code est en train de faire ce que l'Abs est en train de faire dans la plupart des implémentations de faire usage de "swap signe" où la prise en charge, le dernier sera plus rapide que sur les Processeurs qui n'ont pas de "swap signe" et de multiplications sont plus chers que les ajouts (sur les Processeurs modernes, ils sont souvent tout aussi rapide).

C'est comment je le fais dans des projets d'entreprise:

namespace Extensions
{
    public class Functions
    {
        public static T Difference<T>(object x1, object x2) where T : IConvertible
        {
            decimal d1 = decimal.Parse(x1.ToString());
            decimal d2 = decimal.Parse(x2.ToString());

            return (T)Convert.ChangeType(Math.Abs(d1-d2), typeof(T));
        }
    }
}

et de tests:

namespace MixedTests
{
    [TestClass]
    public class ExtensionsTests
    {
        [TestMethod]
        public void Difference_int_Test()
        {
            int res2 = Functions.Difference<int>(5, 7);
            int res3 = Functions.Difference<int>(-3, 0);
            int res6 = Functions.Difference<int>(-3, -9);
            int res8 = Functions.Difference<int>(3, -5);

            Assert.AreEqual(19, res2 + res3 + res6 + res8);
        }

        [TestMethod]
        public void Difference_float_Test()
        {
            float res2_1 = Functions.Difference<float>(5.1, 7.2);
            float res3_1 = Functions.Difference<float>(-3.1, 0);
            double res5_9 = Functions.Difference<double>(-3.1, -9);
            decimal res8_3 = Functions.Difference<decimal>(3.1, -5.2);

            Assert.AreEqual((float)2.1, res2_1);
            Assert.AreEqual((float)3.1, res3_1);
            Assert.AreEqual(5.9, res5_9);
            Assert.AreEqual((decimal)8.3, res8_3);

        }
    }
}