使用C#实现Luhn算法

Question

我正在使用以下代码在C#语言中实现Luhn算法来进行信用卡检查，但是无法获得输出以生成校验和，它显示有效性。请帮忙。提前感谢您。

public class Program
{
    private static void Main(string[]creditcard)
    {
        int sum = 0, d;
        string num ="7992739871";
        int a = 0;

        for (int i = num.Length - 2; i >= 0; i--)
        {
            d = Convert.ToInt32(num.Substring(i, 1));
            if (a % 2 == 0)
                d = d * 2;
            if (d > 9)
                d -= 9;
            sum += d;
            a++;
        }

        if ((10 - (sum % 10) == Convert.ToInt32(num.Substring(num.Length - 1))))
            Console.WriteLine("valid");

        Console.WriteLine("sum of digits of the number" + sum);
    }
}    

- user3181351

---

有什么问题？你是否遇到了错误？如果是的话，请将错误信息和堆栈跟踪一起发布。 - JNYRanger

我想在这个过程中生成校验和，但我无法获得。 - user3181351

我认为这段代码有 bug。对于 sum ≡ 0 mod 10，它的运行结果不正确（检查总是失败）。 - Gebb

Answer 1

这里提供一些扩展方法，用于计算Luhn校验位、验证带有校验位的数字以及给数字添加校验位。在.NET 4.5中进行了测试。

有针对字符串、整数、长整数和列表的扩展方法。

我从rosettacode.org获取了一些灵感。

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

public static class CheckDigitExtension
{
    static readonly int[] Results = { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 };

    #region extension methods for IList<int>

    /// <summary>
    /// For a list of digits, compute the ending checkdigit 
    /// </summary>
    /// <param name="digits">The list of digits for which to compute the check digit</param>
    /// <returns>the check digit</returns>
    public static int CheckDigit(this IList<int> digits)
    {
        var i = 0;
        var lengthMod = digits.Count%2;
        return (digits.Sum(d => i++ % 2 == lengthMod ? d : Results[d]) * 9) % 10;
    }

    /// <summary>
    /// Return a list of digits including the checkdigit
    /// </summary>
    /// <param name="digits">The original list of digits</param>
    /// <returns>the new list of digits including checkdigit</returns>
    public static IList<int> AppendCheckDigit(this IList<int> digits)
    {
        var result = digits;
        result.Add(digits.CheckDigit());
        return result;
    }

    /// <summary>
    /// Returns true when a list of digits has a valid checkdigit
    /// </summary>
    /// <param name="digits">The list of digits to check</param>
    /// <returns>true/false depending on valid checkdigit</returns>
    public static bool HasValidCheckDigit(this IList<int> digits)
    {
        return digits.Last() == CheckDigit(digits.Take(digits.Count - 1).ToList());
    }

    #endregion extension methods for IList<int>

    #region extension methods for strings

    /// <summary>
    /// Internal conversion function to convert string into a list of ints
    /// </summary>
    /// <param name="digits">the original string</param>
    /// <returns>the list of ints</returns>
    private static IList<int> ToDigitList(this string digits)
    {
        return digits.Select(d => d - 48).ToList();
    }

    /// <summary>
    /// For a string of digits, compute the ending checkdigit 
    /// </summary>
    /// <param name="digits">The string of digits for which to compute the check digit</param>
    /// <returns>the check digit</returns>
    public static string CheckDigit(this string digits)
    {
        return digits.ToDigitList().CheckDigit().ToString(CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Return a string of digits including the checkdigit
    /// </summary>
    /// <param name="digits">The original string of digits</param>
    /// <returns>the new string of digits including checkdigit</returns>
    public static string AppendCheckDigit(this string digits)
    {
        return digits + digits.CheckDigit(); 
    }

    /// <summary>
    /// Returns true when a string of digits has a valid checkdigit
    /// </summary>
    /// <param name="digits">The string of digits to check</param>
    /// <returns>true/false depending on valid checkdigit</returns>
    public static bool HasValidCheckDigit(this string digits)
    {
        return digits.ToDigitList().HasValidCheckDigit();
    }

    #endregion extension methods for strings

    #region extension methods for integers

    /// <summary>
    /// Internal conversion function to convert int into a list of ints, one for each digit
    /// </summary>
    /// <param name="digits">the original int</param>
    /// <returns>the list of ints</returns>
    private static IList<int> ToDigitList(this int digits)
    {
        return digits.ToString(CultureInfo.InvariantCulture).Select(d => d - 48).ToList();
    }

    /// <summary>
    /// For an integer, compute the ending checkdigit 
    /// </summary>
    /// <param name="digits">The integer for which to compute the check digit</param>
    /// <returns>the check digit</returns>
    public static int CheckDigit(this int digits)
    {
        return digits.ToDigitList().CheckDigit();
    }

    /// <summary>
    /// Return an integer including the checkdigit
    /// </summary>
    /// <param name="digits">The original integer</param>
    /// <returns>the new integer including checkdigit</returns>
    public static int AppendCheckDigit(this int digits)
    {
        return digits * 10 + digits.CheckDigit();
    }

    /// <summary>
    /// Returns true when an integer has a valid checkdigit
    /// </summary>
    /// <param name="digits">The integer to check</param>
    /// <returns>true/false depending on valid checkdigit</returns>
    public static bool HasValidCheckDigit(this int digits)
    {
        return digits.ToDigitList().HasValidCheckDigit();
    }

    #endregion extension methods for integers

    #region extension methods for int64s

    /// <summary>
    /// Internal conversion function to convert int into a list of ints, one for each digit
    /// </summary>
    /// <param name="digits">the original int</param>
    /// <returns>the list of ints</returns>
    private static IList<int> ToDigitList(this Int64 digits)
    {
        return digits.ToString(CultureInfo.InvariantCulture).Select(d => d - 48).ToList();
    }

    /// <summary>
    /// For an integer, compute the ending checkdigit 
    /// </summary>
    /// <param name="digits">The integer for which to compute the check digit</param>
    /// <returns>the check digit</returns>
    public static int CheckDigit(this Int64 digits)
    {
        return digits.ToDigitList().CheckDigit();
    }

    /// <summary>
    /// Return an integer including the checkdigit
    /// </summary>
    /// <param name="digits">The original integer</param>
    /// <returns>the new integer including checkdigit</returns>
    public static Int64 AppendCheckDigit(this Int64 digits)
    {
        return digits * 10 + digits.CheckDigit();
    }

    /// <summary>
    /// Returns true when an integer has a valid checkdigit
    /// </summary>
    /// <param name="digits">The integer to check</param>
    /// <returns>true/false depending on valid checkdigit</returns>
    public static bool HasValidCheckDigit(this Int64 digits)
    {
        return digits.ToDigitList().HasValidCheckDigit();
    }

    #endregion extension methods for int64s
}

这里有一些XUnit测试用例，展示了扩展方法是如何工作的。

public class CheckDigitExtensionShould
{
    [Fact]
    public void ComputeCheckDigits()
    {
        Assert.Equal(0, (new List<int> { 0 }).CheckDigit());
        Assert.Equal(8, (new List<int> { 1 }).CheckDigit());
        Assert.Equal(6, (new List<int> { 2 }).CheckDigit());

        Assert.Equal(0, (new List<int> { 3, 6, 1, 5, 5 }).CheckDigit());
        Assert.Equal(0, 36155.CheckDigit());
        Assert.Equal(8, (new List<int> { 3, 6, 1, 5, 6 }).CheckDigit());
        Assert.Equal(8, 36156.CheckDigit());
        Assert.Equal(6, 36157.CheckDigit());
        Assert.Equal("6", "36157".CheckDigit());
        Assert.Equal("3", "7992739871".CheckDigit());
    }

    [Fact]
    public void ValidateCheckDigits()
    {
        Assert.True((new List<int> { 3, 6, 1, 5, 6, 8 }).HasValidCheckDigit());
        Assert.True(361568.HasValidCheckDigit());
        Assert.True("361568".HasValidCheckDigit());
        Assert.True("79927398713".HasValidCheckDigit());
    }

    [Fact]
    public void AppendCheckDigits()
    {
        Console.WriteLine("36156".CheckDigit());
        Console.WriteLine("36156".AppendCheckDigit());
        Assert.Equal("361568", "36156".AppendCheckDigit());
        Assert.Equal("79927398713", "7992739871".AppendCheckDigit());
    }
}

- dajo

---

我会将其放在一个独立的类中，而不是扩展内置类型，因为我认为这样会污染内置类型。 - Fred

很好的解释。完整的答案，我相信。 - Asiri Dissanayaka

Answer 2

紧凑型 Luhn 校验：

public static bool Luhn(string digits)
{
    return digits.All(char.IsDigit) && digits.Reverse()
        .Select(c => c - 48)
        .Select((thisNum, i) => i % 2 == 0
            ? thisNum
            :((thisNum *= 2) > 9 ? thisNum - 9 : thisNum)
        ).Sum() % 10 == 0;
}

示例代码: https://dotnetfiddle.net/CCwE48

- garryp

---

为什么要使用“-48”？ - M84

将字符转换为其数值。0的字符代码是48，1的字符代码为49等。减去48就得到了数值。 - garryp

Answer 3

这里是一个正确快速的实现：

bool PassesLuhnCheck(string value)
{
    long sum = 0;

    for (int i = 0; i < value.Length; i++)
    {
        var digit = value[value.Length - 1 - i] - '0';
        sum += (i % 2 != 0) ? GetDouble(digit) : digit;
    }

    return sum % 10 == 0;

    int GetDouble(long i)
    {
        switch (i)
        {
            case 0: return 0;
            case 1: return 2;
            case 2: return 4;
            case 3: return 6;
            case 4: return 8;
            case 5: return 1;
            case 6: return 3;
            case 7: return 5;
            case 8: return 7;
            case 9: return 9;
            default: return 0;
        }
    }
}

- Philippe

Answer 4

我尝试了这段代码，可能会对其他人有帮助：

    public string GenerateLuhnNumber(string baseNumber)
    {
        if (!double.TryParse(baseNumber, out double baseNumberInt))
            throw new InvalidWorkflowException($"Field contains non-numeric character(s) : {baseNumber}");

        var step2 = string.Empty;
        for (var index = baseNumber.Length - 1; index >= 0; index -= 2)
        {
            var doubleTheValue = (int.Parse(baseNumber[index].ToString())) * 2;

            if (doubleTheValue > 9)
                doubleTheValue = Math.Abs(doubleTheValue).ToString().Sum(c => Convert.ToInt32(c.ToString()));

            step2 = step2.Insert(0, (index != 0 ? baseNumber[index - 1].ToString() : "") + doubleTheValue);
        }
        var step3 = Math.Abs(Convert.ToDouble(step2)).ToString(CultureInfo.InvariantCulture).Sum(c => Convert.ToDouble(c.ToString())).ToString(CultureInfo.InvariantCulture);

        var lastDigitStep3 = Convert.ToInt32(step3[step3.Length - 1].ToString());
        string checkDigit = "0";

        if (lastDigitStep3 != 0)
            checkDigit = (10 - lastDigitStep3).ToString();

        return baseNumber + checkDigit;
    }

- Saurin Vala

---

我注意到如果字符串长度为18，使用此方法生成第19位数字会抛出异常。 - israel

Answer 5

你可以非常简单地完成它（参考），

    public static bool Mod10Check(string creditCardNumber)
    {              
        // check whether input string is null or empty
        if (string.IsNullOrEmpty(creditCardNumber))
        {
            return false;
        }

        int sumOfDigits = creditCardNumber.Where((e) => e >= '0' && e <= '9')
                        .Reverse()
                        .Select((e, i) => ((int)e - 48) * (i % 2 == 0 ? 1 : 2))
                        .Sum((e) => e / 10 + e % 10);


        return sumOfDigits % 10 == 0;
    }

- Dhanuka777

---

这将针对无效的信用卡号返回true。尝试使用“adfafda”作为信用卡号。 - SergioL

Answer 6

Philippe 给出了一个很好的答案，但这里有一个更简单的版本，仍然是 O(n)。我在 xUnit 中使用了一个数据集进行了测试，它比一些得到赞同的答案快了几倍。

    public static bool CheckLuhnParity(string digits)
    {
        bool isValid = false;

        if (!string.IsNullOrEmpty(digits))
        {
            long sum = 0;
            int parity = digits.Length % 2;
            for (int i = 0; i < digits.Length; i++)
            {
                int digit = digits[^(i + 1)] - '0';
                sum += (i % 2 == parity) ? Luhn(digit) : digit;
            }
            isValid = (sum % 10) == 0;
        }

        return isValid;

        int Luhn(int digit) => (digit *= 2) > 9 ? digit - 9 : digit;
    }

这个方法和被接受的答案一样有缺陷，因为它没有完全实现Luhn算法。它假设实际的校验位不需要验证，这意味着无效的数字可能会被接受。以下是更好的方法：

    public static bool CheckLuhnDigit(string digits)
    {
        bool isValid = false;

        if (!string.IsNullOrEmpty(digits) && digits.Length > 2)
        {
            long sum = 0;
            for (int i = 0; i < digits.Length - 1; i++)
            {
                int digit = digits[^(i + 2)] - '0';
                sum += (i % 2 == 0) ? Luhn(digit) : digit;
            }
            int checkDigit = digits[^1] - '0';
            isValid = (10 - (sum % 10)) % 10 == checkDigit;
        }

        return isValid;

        int Luhn(int digit) => (digit *= 2) > 9 ? digit - 9 : digit;
    }

有人想尝试O(log n)吗？

- danzuep

Answer 7

我相信这个可以做到：

static void Main(string[] args)
    {
        string number = "1762483";
        int digit = 0;
        int sum = 0;

        for (int i = 0; i <= number.Length - 1; i++)
        {

            if (i % 2 == 1)
            {
                digit = int.Parse(number.Substring(i, 1));
                sum += DoubleDigitValue(digit);

                Console.WriteLine(digit);
            }
            else
            {
                digit = int.Parse(number.Substring(i, 1));
                sum += digit;
            }

        }
        Console.WriteLine(sum);
        if (sum % 10 == 0)
        {
            Console.WriteLine("valid");
        }
        else
        {
            Console.WriteLine("Invalid");
        }
    }
    static int DoubleDigitValue(int digit)
    {
        int sum;
        int doubledDigit = digit * 2; 
        if (doubledDigit >= 10)
        {
            sum = 1 + doubledDigit % 10;
        } else
        {
            sum = doubledDigit; 
        }
        return sum; 
    }

- user9070436

Answer 8

这是获取校验和的简短版本

private int getCheckSum(string number)
        {
            var sum = number.Reverse() //Reverse
                        .Select((d, i) => i % 2 == 0 ? Convert.ToInt32(d.ToString()) * 2 : Convert.ToInt32(d.ToString())) //double every 2nd digit including starting
                            .Select(x => x.ToString().Select(c => Convert.ToInt32(c.ToString())).Sum()) //sum double digit number 18 = 1 + 8 = 9
                              .Sum(); //Sum all
            return (10 - (sum % 10)) % 10; 
        }

验证校验和时，请传递没有校验和的数字，并将结果与原始数字的最后一位进行比较。

- Bhavesh

Answer 9

我刚刚将C语言代码翻译成了C#。C语言的代码可以在这里找到：(https://uk.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D1%83%D0%BD%D0%B0)。我已经在几个设备上测试过了。

byte[] data = new byte[19];

//fill the data[] 
...

//use it
if (checkByLuhn(data))
{
  //check complete
}
...
private bool checkByLuhn(byte[] pPurposed)
{
    int nSum = 0;
    int nDigits = pPurposed.Length;
    int nParity = (nDigits - 1) % 2;
    char[] cDigit = new char[] { '0','\0' };

    for (int i = nDigits; i > 0; i--)
    {
        cDigit[0] = (char)pPurposed[i - 1];
        int nDigit = (int)Char.GetNumericValue(cDigit[0]);

        if (nParity == i % 2)
        {
            nDigit = nDigit * 2;
        }
        nSum += nDigit / 10;
        nSum += nDigit % 10;
    }
    return 0 == nSum % 10;
}

- Ivan Parfenov

---

你可以通过解释你的操作和它为什么起作用来改进这个内容。 - jaabh

我刚刚将C语言代码转换成了C#语言。 C语言的代码可以在这里找到：(https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D1%83%D0%BD%D0%B0) 我已经在几个设备上进行了检查。 - Ivan Parfenov

Answer 10

这些是我验证和计算最后一位数字的方法。要验证一个数字，只需检查第一个方法的结果是否为0；

private int LuhnChecksum(string input)
    {
        var length = input.Length; 
        var even = length % 2; 
        var sum = 0;

        for (var i = length - 1; i >= 0; i--)  
        {
            var d = int.Parse(input[i].ToString());
            if (i % 2 == even)
                d *= 2;
            if (d > 9)
                d -= 9;
            sum += d;
        }
        return sum % 10;
    }

    private int LuhnCalculateLastDigit(string input) 
    {
        var checksum = LuhnChecksum(input + "0");
        return checksum == 0 ? 0 : 10 - checksum;
    }

- CodingCretin