Что делает __ utma средний?

Это связано с аналитикой Google ... используется для их отслеживания. Хотя я подозреваю, что ответ Брайана отвечает на то, что вы действительно спрашивали ...

Я понимаю, что мое мнение, вероятно, не является популярным, но я думаю, мне трудно запрыгнуть на универсал Linq-y. Это здорово. Это сжато. Я понимаю это и не возражаю против использования там, где это уместно. Может быть, это только я, но мне кажется, что люди перестали думать о создании служебных функций для выполнения того, что они хотят, и вместо этого предпочитают засорять свой код (иногда) чрезмерно длинными строками кода Linq ради создания плотного однострочного кода.

Я не говорю, что какой-либо из ответов Linq, которые здесь предоставили, плохие, но я думаю, я чувствую, что есть вероятность того, что эти отдельные строки кода могут начать становиться длиннее и менее понятными по мере необходимости. справляться с различными ситуациями. Что делать, если ваш массив равен нулю? Что, если вам нужна строка с разделителями, а не просто конкатенация? Что делать, если некоторые из целых чисел в вашем массиве являются двузначными, и вы хотите дополнить каждое значение ведущими нулями, чтобы строка для каждого элемента имела ту же длину, что и остальные?

Возьмем один из предоставленных ответов в качестве примера :

        result = arr.Aggregate(string.Empty, (s, i) => s + i.ToString());

Если мне нужно беспокоиться о том, что массив является нулевым, теперь он становится таким:

        result = (arr == null) ? null : arr.Aggregate(string.Empty, (s, i) => s + i.ToString());

Если мне нужна строка с разделителями-запятыми, теперь она становится такой:

        result = (arr == null) ? null : arr.Skip(1).Aggregate(arr[0].ToString(), (s, i) => s + "," + i.ToString());

Это все еще неплохо, но я думаю с первого взгляда не очевидно, что делает эта строка кода.

Конечно, ничто не мешает вам вставить эту строку кода в вашу собственную служебную функцию, чтобы у вас не было этого долгого беспорядка, смешанного с вашим приложением логика, особенно если вы делаете это в нескольких местах:

    public static string ToStringLinqy<T>(this T[] array, string delimiter)
    {
        // edit: let's replace this with a "better" version using a StringBuilder
        //return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(array[0].ToString(), (s, i) => s + "," + i.ToString());
        return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(new StringBuilder(array[0].ToString()), (s, i) => s.Append(delimiter).Append(i), s => s.ToString());
    }

Но если вы ' вы все равно собираетесь поместить его в служебную функцию, действительно ли вам нужно, чтобы он был сжат до однострочника? В таком случае почему бы не добавить несколько дополнительных строк для ясности и не воспользоваться StringBuilder, чтобы не выполнять повторяющиеся операции конкатенации:

    public static string ToStringNonLinqy<T>(this T[] array, string delimiter)
    {
        if (array != null)
        {
            // edit: replaced my previous implementation to use StringBuilder
            if (array.Length > 0)
            {
                StringBuilder builder = new StringBuilder();

                builder.Append(array[0]);
                for (int i = 1; i < array.Length; i++)
                {
                    builder.Append(delimiter);
                    builder.Append(array[i]);
                }

                return builder.ToString()
            }
            else
            {
                return string.Empty;
            }
        }
        else
        {
            return null;
        }
    }

И если вас действительно так беспокоит производительность, вы можете даже превратить его в гибридная функция, которая решает, делать ли string.Join или использовать StringBuilder в зависимости от того, сколько элементов находится в массиве (это микрооптимизация, которую, на мой взгляд, не стоит делать и, возможно, более вредно, чем полезно, но я используя его в качестве примера для этой проблемы):

    public static string ToString<T>(this T[] array, string delimiter)
    {
        if (array != null)
        {
            // determine if the length of the array is greater than the performance threshold for using a stringbuilder
            // 10 is just an arbitrary threshold value I've chosen
            if (array.Length < 10)
            {
                // assumption is that for arrays of less than 10 elements
                // this code would be more efficient than a StringBuilder.
                // Note: this is a crazy/pointless micro-optimization.  Don't do this.
                string[] values = new string[array.Length];

                for (int i = 0; i < values.Length; i++)
                    values[i] = array[i].ToString();

                return string.Join(delimiter, values);
            }
            else
            {
                // for arrays of length 10 or longer, use a StringBuilder
                StringBuilder sb = new StringBuilder();

                sb.Append(array[0]);
                for (int i = 1; i < array.Length; i++)
                {
                    sb.Append(delimiter);
                    sb.Append(array[i]);
                }

                return sb.ToString();
            }
        }
        else
        {
            return null;
        }
    }

В этом примере влияние на производительность, вероятно, не заслуживает внимания, но дело в том, что если вы находитесь в ситуации, когда вам действительно нужно заботиться о производительности ваших операций, какими бы они ни были, то, скорее всего, будет проще и удобнее обрабатывать это в служебной функции, чем использовать сложное выражение Linq.

Эта служебная функция все еще выглядит неуклюже. Теперь давайте откажемся от гибридных вещей и сделаем следующее:

    // convert an enumeration of one type into an enumeration of another type
    public static IEnumerable<TOut> Convert<TIn, TOut>(this IEnumerable<TIn> input, Func<TIn, TOut> conversion)
    {
        foreach (TIn value in input)
        {
            yield return conversion(value);
        }
    }

    // concatenate the strings in an enumeration separated by the specified delimiter
    public static string Delimit<T>(this IEnumerable<T> input, string delimiter)
    {
        IEnumerator<T> enumerator = input.GetEnumerator();

        if (enumerator.MoveNext())
        {
            StringBuilder builder = new StringBuilder();

            // start off with the first element
            builder.Append(enumerator.Current);

            // append the remaining elements separated by the delimiter
            while (enumerator.MoveNext())
            {
                builder.Append(delimiter);
                builder.Append(enumerator.Current);
            }

            return builder.ToString();
        }
        else
        {
            return string.Empty;
        }
    }

    // concatenate all elements
    public static string ToString<T>(this IEnumerable<T> input)
    {
        return ToString(input, string.Empty);
    }

    // concatenate all elements separated by a delimiter
    public static string ToString<T>(this IEnumerable<T> input, string delimiter)
    {
        return input.Delimit(delimiter);
    }

    // concatenate all elements, each one left-padded to a minimum length
    public static string ToString<T>(this IEnumerable<T> input, int minLength, char paddingChar)
    {
        return input.Convert(i => i.ToString().PadLeft(minLength, paddingChar)).Delimit(string.Empty);
    }

Теперь у нас есть отдельные и довольно компактные служебные функции, каждая из которых, возможно, полезна сама по себе.

В конечном счете, я хочу сказать, что вы не должны использовать Linq, Скорее всего, не забывайте о преимуществах создания собственных служебных функций, даже если они небольшие и, возможно, содержат только одну строку, которая возвращает результат из строки кода Linq. По крайней мере, выпароль @ сервер: port? parameterList # anchorName

Пример:

http://stackoverflow.com:80/page?param1=value1¶m2=value2

• #anchorName перейдет к определенной части страницы HTML
• Часть parameterList также называется запросом
• Часть протокола также называется схемой
• Имя пользователя : пароль часть может быть опущена
• Порт по умолчанию будет иметь значение 80, если протокол является HTTP, а порт не указан
• Если вы не • Укажите протокол в веб-браузере, по умолчанию он будет использовать HTTP.
• Часто бывает необходимо, чтобы одна страница выполняла несколько действий. Это достигается за счет принятия различных параметров. Эти параметры обычно передают информацию на сервер, который изменяет способ отображения следующей страницы или выполнение другого действия на сервере
• Иногда параметры URL заменяются красивыми путями URL. Это достигается с помощью новых веб-фреймворков, таких как ASP .NET MVC, Django, Ruby on Rails и т. Д.

Есть гораздо более подробное описание из того, что я дал в RFC 3986: Uniform Resource Identifier (URI) : Общий синтаксис .