Inne sposoby radzenia sobie z" inicjalizacją pętli " w C#

Osobiście podoba mi się opcja Marka Byera, ale zawsze możesz napisać własną metodę generyczną:

public static void IterateWithSpecialFirst<T>(this IEnumerable<T> source,
    Action<T> firstAction,
    Action<T> subsequentActions)
{
    using (IEnumerator<T> iterator = source.GetEnumerator())
    {
        if (iterator.MoveNext())
        {
            firstAction(iterator.Current);
        }
        while (iterator.MoveNext())
        {
            subsequentActions(iterator.Current);
        }
    }
}

public static void IterateWithSpecialLast<T>(this IEnumerable<T> source,
    Action<T> allButLastAction,
    Action<T> lastAction)
{
    using (IEnumerator<T> iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
            return;
        }            
        T previous = iterator.Current;
        while (iterator.MoveNext())
        {
            allButLastAction(previous);
            previous = iterator.Current;
        }
        lastAction(previous);
    }
}

EDIT: ponieważ twój komentarz dotyczył wydajności tego, powtórzę mój komentarz w tej odpowiedzi: chociaż ten ogólny problem jest dość powszechny, to Nie jest powszechne, aby to było takie wąskie gardło wydajności, że warto mikro-optymalizacji w pobliżu. W rzeczy samej, nie pamiętam, żebym kiedykolwiek spotkał się z sytuacją, w której maszyny zapętlające stały się wąskim gardłem. Jestem pewien, że to się zdarza, ale to nie jest "powszechne". Jeśli kiedykolwiek natknę się na ten kod, to w specjalnym przypadku zastosuję ten konkretny kod, a najlepsze rozwiązanie będzie zależało od dokładnie tego, co kod musi zrobić.

Ogólnie jednak cenię czytelność i możliwość wielokrotnego użytku znacznie bardziej niż mikro-optymalizację.

Jesteś już gotów zrezygnować z foreach. Więc to powinno być odpowiednie:

        using (var enumerator = array.GetEnumerator()) {
            if (enumerator.MoveNext()) {
                for (;;) {
                    append(enumerator.Current);
                    if (!enumerator.MoveNext()) break;
                    append(delimiter);
                }
            }
        }

Na pewno można stworzyć goto rozwiązanie w C# (uwaga: nie dodałem null):

string Join(string[] array, string delimiter) {
  var sb = new StringBuilder();
  var enumerator = array.GetEnumerator();
  if (enumerator.MoveNext()) {
    goto start;
    loop:
      sb.Append(delimiter);
      start: sb.Append(enumerator.Current);
      if (enumerator.MoveNext()) goto loop;
  }
  return sb.ToString();
}

Dla Twojego konkretnego przykładu, wygląda to dla mnie dość prosto (i jest to jedno z rozwiązań, które opisałeś):

string Join(string[] array, string delimiter) {
  var sb = new StringBuilder();
  foreach (string element in array) {
    sb.Append(element);
    sb.Append(delimiter);
  }
  if (sb.Length >= delimiter.Length) sb.Length -= delimiter.Length;
  return sb.ToString();
}

Jeśli chcesz uzyskać funkcjonalność, możesz spróbować użyć takiego podejścia do składania:

string Join(string[] array, string delimiter) {
  return array.Aggregate((left, right) => left + delimiter + right);
}

Chociaż czyta się bardzo ładnie, nie używa StringBuilder, więc może warto trochę nadużywać Aggregate, aby go użyć:

string Join(string[] array, string delimiter) {
  var sb = new StringBuilder();
  array.Aggregate((left, right) => {
    sb.Append(left).Append(delimiter).Append(right);
    return "";
  });
  return sb.ToString();
}

Lub możesz użyć tego (zapożyczenie pomysłu z innych odpowiedzi tutaj):

string Join(string[] array, string delimiter) {
  return array.
    Skip(1).
    Aggregate(new StringBuilder(array.FirstOrDefault()),
      (acc, s) => acc.Append(delimiter).Append(s)).
    ToString();
}

Czasami używam LINQ .First() i .Skip(1) do tego... Może to dać stosunkowo czyste (i bardzo czytelne) rozwiązanie.

Używając Twojego przykładu,

append(array.First());
foreach(var x in array.Skip(1))
{
  append(delimiter);
  append (x);
}

[zakłada się, że w tablicy znajduje się co najmniej jeden element, co jest łatwym testem do dodania, jeśli trzeba tego uniknąć.]

Użycie F # byłoby kolejną propozycją : -)

Istnieją sposoby na obejście podwojonego kodu, ale w większości przypadków zduplikowany kod jest znacznie mniej brzydki/niebezpieczny niż możliwe rozwiązania. Rozwiązanie" goto", które cytujesz, nie wydaje mi się ulepszeniem - nie wydaje mi się, że naprawdę zyskujesz coś znaczącego (zwartość, czytelność lub wydajność), używając go, podczas gdy zwiększasz ryzyko, że programista dostanie coś złego w pewnym momencie życia kodu.

Ogólnie mam tendencję do podejście:

• specjalny przypadek pierwszego (lub ostatniego) działania
• pętla dla pozostałych akcji.

Eliminuje to nieefektywność wprowadzoną przez sprawdzanie, czy pętla znajduje się w pierwszej iteracji za każdym razem i jest naprawdę łatwa do zrozumienia. W przypadku nietrywialnych przypadków użycie metody delegata lub helpera do zastosowania akcji może zminimalizować powielanie kodu.

Lub inne podejście, które używam czasami, gdy wydajność nie jest ważna:

• pętla i test jeśli łańcuch znaków jest pusty, aby określić, czy wymagany jest ogranicznik.

Można to zapisać tak, aby było bardziej zwarte i czytelne niż podejście goto i nie wymaga żadnych dodatkowych zmiennych/pamięci / testów do wykrycia iteraitonu "specjalnego przypadku".

Ale myślę, że podejście Marka Byersa jest dobrym, czystym rozwiązaniem dla Twojego konkretnego przykładu.

Preferuję first metodę zmienną. Prawdopodobnie nie jest to najczystszy, ale najbardziej skuteczny sposób. Alternatywnie możesz użyć Length rzeczy, do której dodajesz i porównać ją do zera. Działa dobrze z StringBuilder.

Dlaczego nie przenieść pierwszego elementu poza pętlę ?

StringBuilder sb = new StrindBuilder()
sb.append(array.first)
foreach (var elem in array.skip(1)) {
  sb.append(",")
  sb.append(elem)
}

Jeśli chcesz przejść trasę funkcjonalną, możesz zdefiniować String.Join like LINQ construct, który jest wielokrotnego użytku w różnych typach.

Osobiście prawie zawsze starałbym się o przejrzystość kodu przy zapisywaniu kilku egzekucji kodu opcode.

EG:

namespace Play
{
    public static class LinqExtensions {
        public static U JoinElements<T, U>(this IEnumerable<T> list, Func<T, U> initializer, Func<U, T, U> joiner)
        {
            U joined = default(U);
            bool first = true;
            foreach (var item in list)
            {
                if (first)
                {
                    joined = initializer(item);
                    first = false;
                }
                else
                {
                    joined = joiner(joined, item);
                }
            }
            return joined;
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            List<int> nums = new List<int>() { 1, 2, 3 };
            var sum = nums.JoinElements(a => a, (a, b) => a + b);
            Console.WriteLine(sum); // outputs 6

            List<string> words = new List<string>() { "a", "b", "c" };
            var buffer = words.JoinElements(
                a => new StringBuilder(a), 
                (a, b) => a.Append(",").Append(b)
                );

            Console.WriteLine(buffer); // outputs "a,b,c"

            Console.ReadKey();
        }

    }
}