With an ordinary for loop, you manage the index yourself, and if you are iterating through an array, you have to use the index to look up items.

var a = new string[] {"This","Is","An","Array"};
for (var i = a.GetLowerBound(0); i <= a.GetUpperBound(0); i = i + 1)
{
    var s = a[i];
    Console.WriteLine(s);
}

With a foreach loop, the framework uses a special interface (IEnumerable) to do the iteration and lookup for you:

var a = new string[] {"This","Is","An","Array"};
foreach (var s in a)
{
    Console.WriteLine(s);
}

Most arrays, lists, dictionaries, and other types of collections implement IEnumerable, so you can use this technique to go through most lists. If IEnumerable isn't available, you can't use foreach.

The foreach construct requires less typing, and iterations can run in parallel (using Parallel.ForEach), so it has some advantages. The main disadvantage is that there is no guarantee what order the elements will be processed, plus you no longer have access to a variable that has the index in it. This could be an issue in certain cases, e.g. copying data between two arrays, where order might be important.

Also, while using the enumerator, deleting and adding items is highly discouraged if not outright impossible due to confusion it can introduce.

foreach is not a very good choice when you are utilizing parallel arrays (hint, parallel arrays are not actually used all that often, or ever, in "real" code).

The reason is, as you discovered, that you have no idea what a given item's index is (foreach does not guarantee linear traversal, though it often is in practice). Here are three ways of solving the problem:

Assume Linear Traversal

You can setup a counter outside of the loop and increment it with every iteration. Assuming that foreach starts at index 0 and increments by 1, you will still have your index:

int iterationIndex = 0;
foreach (item in collection)
{
     iterationIndex++;
}

Of course, if the assumption is wrong (in practice, traversal is usually linear, and always is on arrays and lists) then your code will break.

Search the array

You know which item you are looking for; you can use an array/list method to get its index:

int index = collection.IndexOf(item);
var parallelItem = parallelCollection[index];

This breaks down if collection has multiple instances of item (effectively a duplicate key).

Use a class (Correct answer!)

All of this is moot if you discard parallel arrays and use objects. Say I have a pizza class:

public class Pizza
{
    public double Size {get; set}
    public double Price {get; set;}
}

Now the data association is handled by the framework and I can write:

Pizza requestedPizza;
foreach (Pizza pizza in allPizzas)
{
     if (pizza.Price == enteredPrice)
     {
         requestedPizza = pizza;
         break;
     }
}
Console.WriteLine($"Found pizza size {requestedPizza.Size} that matches price {requestedPizza.Price}");

For future use, that whole foreach is totally unnecessary, LINQ will write it for us:

Pizza requestedPizza = allPizzas.FirstOrDefault(p => p.Price == requestedPrice);