Addition of 2 integers I've implemented an algorithm found in a book. It adds 2 positive integers of equal size. How can it be improved? It is assumed that inputted data is always positive integers with an equal number of digits.

EDIT
As there are lots of comments regarding the question, I would like to rephrase it. This program tries (yes it tries, could be wrong) to simulate how humans do manual additions of 2 positive integers. This is similar to the technique students learn in (I hope..) primary schools. It is based on the book "Invitation to Computer Science". One obvious improvement to this program is adding validations. What else can be done to improve it? 

class Program
{ 
    static void Main(string[] args)
    {
        Add2Numbers(97,47);
        Console.ReadLine();            
    }



    static void Add2Numbers(int a, int b)
    {
        int carry = 0,sum=0;
        List&lt;int&gt; lstA = new List&lt;int&gt;();
        List&lt;int&gt; lstB = new List&lt;int&gt;();
        List&lt;int&gt; lstSum = new List&lt;int&gt;();

        foreach (var item in GetDigit(a))
        {
            lstA.Add(item);
        }

        foreach (var item in GetDigit(b))
        {
            lstB.Add(item);
        }

        for (int j = 0; j &lt; lstB.Count;j++ )
        {
            sum = lstA[j] + lstB[j] + carry;
            if (sum &gt; 9)
            {
                sum = sum - 10;
                carry = 1;
            }
            else
                carry = 0;
            lstSum.Add(sum);
        }

        if (carry &gt; 0)
            lstSum.Add(carry);

        lstSum.Reverse();
        foreach (var item in lstSum)
        {
            Console.Write(item);
        }
    }

    static IEnumerable&lt;int&gt; GetDigit(int number)
    {
        while (number &gt; 0)
        {
            yield return number % 10;
            number = number / 10;
        }
    }



}
I generally prefer foreach to for, but in the case where you are using the index variable to iterate through two lists at once, for is a pretty good option. I still try to use .Zip() instead, as the other answer demonstrated, but sometimes that can get hairy. Here are some smaller improvements that don't involve changes to the overall structure.


It's always a good idea to use descriptive names


I would rename LstA to DigitsOfA (same for B, and Sum)
I would rename GetDigit to GetDigits

It's usually1 a good idea to delay declaration of a variable until it's used


A related concept is reducing variable scope; not using a global variable if a local variable will do. This doesn't have any technical impact, but it does have a readability impact: If I see you using a variable but have to scroll up to see how that variable was declared, the flow of my reading has been interrupted. We could call this "spatial scope".
Here, this would mean declaring sum and carry just before the for loop, instead of at the top of the function.
You could even declare sum inside the loop. It does seem inefficient to instantiate a new variable every iteration of the loop, but (1) the impact will probably be low, even negligible, (2) you can generally trust the compiler to do something smart (3) if making my program a tiny bit easier to read also makes it a tiny bit slower, that's a trade I'll gladly make every time.

I usually prefer var over explicit types when declaring a variable


This is the subject of a fair amount of debate, but here's my reasoning. It's easier for me to read 
var prices = new Dictionary&lt;Fruit, decimal&gt;();
var lemon = new Lemon();
var price = 17.50;
prices.Add(lemon, price);
 than 
Dictionary&lt;Fruit, decimal&gt; prices = new Dictionary&lt;Fruit, decimal&gt;();
Lemon lemon = new Lemon();
decimal price = 17.50;
prices.Add(lemon, price);
 In the former, the information I immediately want to know (what are the variables' names? how are they used?) all flows nicely down the left edge.

It's nearly always easier (to write and to read) to use LINQ's .ToList() than to call List.Add() in a loop.


This means you can initialize your lists quite easily as var digitsOfA = GetDigits(a).ToList();

Implicit braces do make your code shorter and prettier, but they are also the source of a very common bug. You write 
if (awake)
    GetCoffee();
 then I come along and update your code to 
if (awake)
    GetCoffee();
    GetBreakfast();
All of a sudden I'm eating breakfast while I'm still asleep. And if you're thinking I'd have to be a real bonehead to make that mistake, you're right! But it's a mistake I've made before, it's a mistake that will be made again... And it's a mistake that would be impossible if the original code were
if (awake)
{
    GetCoffee();
}
 So consider very carefully how likely it is that others might modify your code in the future, or that you might modify it before you have your coffee... I recommend the braces every time.
You can dodge the whole brace issue, however, by modular arithmetic instead of if: 
carry = sum / 10;
sum = sum % 10;

I quite like the GetDigits function as it stands! That's an excellent use of yield return, in my opinion.


1This advice does not apply to Javascript, thanks to variable hoisting