Is the list sorted? The you can use that fact to realize which item must be first. Nevertheless you can do with one for-loop, if you prefer:

private static void MyFunction(string item1, string item2)
{
    List<string> input = new() {"A", "B", "C", "D", "E"};

    int index1 = input.IndexOf(item1);
    int index2 = input.IndexOf(item2);
    int beginIndex = Math.Min(index1, index2);
    int count = Math.Abs(index1 - index2) + 1;

    foreach (string item in input.GetRange(beginIndex, count))
    {
        Console.Write(item);
    }
}

You iterate three times over the list: Two times in IndexOf, and then once again in your loop. You can make your code more efficient with this code, which iterates only once over the list.

privat void MyFunction(MyClass listItem, MyClass anotherListItem)
{
    bool betweenTwoItems = false;
    foreach(var item in myList)
    {
        if(item == listItem || item == anotherListItem)
        {
            betweenTwoItems = !betweenTwoItems;
            if(!betweenTwoItems)
            {
               break;
            }
        }

        if(betweenTwoItems )
        {
            // do stuff
        }
    }
}

We set a bool variable if we are between the two items. In the beginning, it is false. The we iterate over the list and check whether the current item is one of the two method parameters. If this is the case, we invert the value of the bool. If after the inversion of the bool the value is false, we can leave the list. After that, we check whether the bool is true. If so, we can do stuff.

Online demo: https://dotnetfiddle.net/xYcr7V

If you are looking for performance (IndexOf twice can be a bit slow) and generalization (when myList is not necessary List<T> but IEnumerable<T> only) you can put it as

bool proceed = false;
MyClass lastItem = default; 

foreach (var item in myList) {
  if (!proceed) {
    if (proceed = item == listItem) 
      lastItem = anotherListItem; 
    else if (proceed = item == anotherListItem) 
      lastItem = listItem; 
  }

  if (proceed) {
    //TODO: do staff here

    if (item == lastItem)
      break; 
  } 
}

Your existing solution can be improved:

int listItemIdx = myList.IndexOf(listItem);
int anotherListItemIdx = myList.IndexOf(anotherListItem);
int startIdx = Math.Min(listItemIdx, anotherListItemIdx);
int endIdx = Math.Max(listItemIdx, anotherListItemIdx);

for(int i = startIdx ; i <= endIdx ; i++)
{
    // do stuff
}

Thus, the code duplication disappears and only a minor refactoring is required.

To create a range-loop version, you can create a subset using GetRange(), something like:

int listItemIdx = myList.IndexOf(listItem);
int anotherListItemIdx = myList.IndexOf(anotherListItem);
int startIdx = Math.Min(listItemIdx, anotherListItemIdx);
int endIdx = Math.Max(listItemIdx, anotherListItemIdx);
var subset = myList.GetRange(startIdx, endIdx - startIdx);

foreach(var item in subset)
{
    // do stuff
}

Thus, filtering the list and processing the list can now be separated.

More generic version of the same idea. So this can be created as extension method for IEnumerable<,>

public static IEnumerable<T> RangeOf<T>(this IEnumerable<T> elements, T el1, T el2, 
  IEqualityComparer<T> comparer = null)
{
  comparer ??= EqualityComparer<T>.Default;
  var hasStarted = false;
  var end = default;
        
  foreach (T el in elements)
  {
    if (!hasStarted) 
    {
      hasStarted = comparer.Equals(el, el1) || comparer.Equals(el, el2);
      end = comparer.Equals(el, el1) ? el2 : el1;
    }
            
    if (hasStarted)
      yield return el;
            
    if (comparer.Equals(el, end))
      yield break;
  }
}

and version with the while loop supporting ranges from el to el. For example for [5, 0, 1, 2, 0, 6] the range [0, 0] will be [0, 1, 2, 0]:

public static IEnumerable<T> RangeOf<T>(this IEnumerable<T> elements, T el1, T el2,
  IEqualityComparer<T> comparer = null)
{   
  comparer ??= EqualityComparer<T>.Default;
  var hasStarted = false;
  var end = default;
        
  var it = elements.GetEnumerator();
  while (!hasStarted && it.MoveNext())
  {
    T el = it.Current;
    hasStarted = comparer.Equals(el , el1) || comparer.Equals(el , el2);
    end = comparer.Equals(it.Current, el1) ? el2 : el1;
  }
        
  if (hasStarted)
    yield return it.Current;
        
  while (it.MoveNext())
  {
    yield return it.Current;

    if (comparer.Equals(it.Current, end))
      yield break;
  }
}

both can be used like this

foreach (var el in list.RangeOf(listItem, anotherListItem))
  // Do with el whatever you want to do