Форматирование именованных строк в C #


156

Есть ли способ отформатировать строку по имени, а не по позиции в C #?

В python я могу сделать что-то вроде этого примера (бесстыдно украденного отсюда ):

>>> print '%(language)s has %(#)03d quote types.' % \
      {'language': "Python", "#": 2}
Python has 002 quote types.

Есть ли способ сделать это в C #? Скажем, например:

String.Format("{some_variable}: {some_other_variable}", ...);

Было бы неплохо сделать это, используя имя переменной, но допустим и словарь.


Я тоже скучаю по Руби.
JesperE

Я думаю, что ваш пример слишком упрощен и заставляет людей давать вам бесполезные ответы. Возможно, использование переменной более одного раза в строке будет более показательным.
Клин

На самом деле, конкретная путаница заключается в использовании String.Format. Это поддается ответам, таким как мои, которые не являются полезными, потому что они не ориентированы на переменные, но точны в том, что касается String.Format.
Джон Руди

1
Вызов String.Format, очевидно, является надуманным примером. Если, конечно, вы не знали, что вызов String.Format с эллипсами невозможен. Проблема заключалась в том, что я не сказал, что хотел, чтобы форматирование происходило по именованным параметрам, а не по положению, что было ошибкой.
Джейсон Бейкер

К вашему сведению: отправлено в пользовательский голос MS Connect, чтобы сделать это стандартной функцией фреймворка. Для всех, кто заинтересован, просим сообщить об этом: visualstudio.uservoice.com/forums/121579-visual-studio/…
JohnLBevan

Ответы:


130

Для этого нет встроенного метода.

Вот один из методов

string myString = "{foo} is {bar} and {yadi} is {yada}".Inject(o);

Вот еще один

Status.Text = "{UserName} last logged in at {LastLoginDate}".FormatWith(user);

Третий улучшенный метод, частично основанный на двух выше , от Фила Хаака


11
Я был очень счастлив, используя FormatWith (), но хотел указать на проблему, с которой я недавно столкнулся. Реализация опирается на DataBinder из System.Web.UI, который не поддерживается в SQL CLR. Inject (o) не использует связыватель данных, что делает его полезным для замены нескольких токенов в моем объекте SQL CLR.
EBarr

1
Может быть, вы можете обновить первое предложение вашего ответа. Строковая интерполяция присутствует в C # и VB в течение нескольких месяцев (наконец ...). Ваш ответ вверху, поэтому он может быть полезен для читателей, если вы можете связать их с некоторыми обновленными ресурсами .NET.
Miroxlav

1
@miroxlav это не совсем то же самое. Вы не можете передавать интерполированные строки: stackoverflow.com/q/31987232/213725
DixonD

@DixonD - вы определенно правы, но это не было их целью. В связанных с вами вопросах и ответах OP пытается сослаться на имя переменной еще до ее появления. Не очень хорошая идея, но если кто-то настаивает на этом, он может создать специализированный парсер. Но я бы не стал связываться с общей концепцией интерполяции строк.
Miroxlav

44

У меня есть реализация, которую я только что разместил в своем блоге здесь: http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx

Это решает некоторые проблемы, которые эти другие реализации имеют с выходом скобки. У поста есть подробности. Это тоже делает DataBinder.Eval, но все еще очень быстро.


3
Код доступен для скачивания в этой статье 404-х годов. Мне бы тоже очень хотелось это увидеть.
Квентин Старен

2
@qes: обновленная ссылка была размещена в комментариях: code.haacked.com/util/NamedStringFormatSolution.zip
Der Hochstapler

3
@OliverSalzburg: Я уже давно использую SmartFormat для всех своих потребностей в форматировании, обожаю. github.com/scottrippey/SmartFormat
quentin-starin

@qes: Не могли бы вы написать и ответить об этом и показать, как это работает? Выглядит интересно
Der Hochstapler

@qes: Вы обязательно должны добавить SmartFormat в качестве ответа, так как он очень хороший и активно поддерживается (2015).
Разван Флавиус Панда

42

Интерполированные строки были добавлены в C # 6.0 и Visual Basic 14

Оба были представлены через новый компилятор Roslyn в Visual Studio 2015 .

Интересные функции (в Visual Studio 2015 IDE):

  • поддерживается синтаксическая раскраска - переменные, содержащиеся в строках, подсвечиваются
  • поддерживается рефакторинг - при переименовании переменные, содержащиеся в строках, тоже переименовываются
  • на самом деле поддерживаются не только имена переменных, но и выражения - например, не только {index}работает, но и{(index + 1).ToString().Trim()}

Наслаждайтесь! (и нажмите «Отправить улыбку» в VS)


2
Вопрос помечен .net 3.5, поэтому ваша информация верна, но это не альтернатива
Дуглас Гандини

1
@miroxlav - Ты прав насчет фреймворковой версии. Интерполяция строк зависит только от нового компилятора Roslyn, который использовался в VS 2015.
Дуглас Гандини

2
Это также не будет работать, если ваша строка формата не помещена в сам код. то есть он не будет работать, если ваша строка формата поступает из внешнего источника, такого как файл конфигурации или база данных.
Крейг Бретт

40

Вы также можете использовать анонимные типы, как это:

    public string Format(string input, object p)
    {
        foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(p))
            input = input.Replace("{" + prop.Name + "}", (prop.GetValue(p) ?? "(null)").ToString());

        return input;
    }

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

Format("test {first} and {another}", new { first = "something", another = "something else" })

1
Идеально подходит для тех из нас, кто еще на 2.0. Да, я знаю .... Это решение простое и легкое для понимания. И ЭТО РАБОТАЕТ !!!
Брэд Брюс

14

Кажется, нет способа сделать это из коробки. Тем не менее, выглядит возможным реализовать свою собственную IFormatProviderссылку IDictionaryна значения.

var Stuff = new Dictionary<string, object> {
   { "language", "Python" },
   { "#", 2 }
};
var Formatter = new DictionaryFormatProvider();

// Interpret {0:x} where {0}=IDictionary and "x" is hash key
Console.WriteLine string.Format(Formatter, "{0:language} has {0:#} quote types", Stuff);

Выходы:

Python имеет 2 типа цитат

Предостережение заключается в том, что вы не можете смешивать FormatProvidersтекст, поэтому нельзя использовать причудливое форматирование текста одновременно.


1
+1 для описания, IMHO, лучшего концептуального метода, который имеет хорошую реализацию на mo.notono.us/2008/07/c-stringinject-format-strings-by-key.html - другие посты включают это, но они также предложить методы на основе рефлексии, которые, ИМХО, довольно злые
Адам Ральф

9

Сам фреймворк не предоставляет способа сделать это, но вы можете взглянуть на этот пост Скотта Хансельмана. Пример использования:

Person p = new Person();  
string foo = p.ToString("{Money:C} {LastName}, {ScottName} {BirthDate}");  
Assert.AreEqual("$3.43 Hanselman, {ScottName} 1/22/1974 12:00:00 AM", foo); 

Этот код Джеймса Ньютона-Кинга похож и работает с подсвойствами и индексами,

string foo = "Top result for {Name} was {Results[0].Name}".FormatWith(student));

Код Джеймса опирается на System.Web.UI.DataBinder для анализа строки и требует ссылки на System.Web, что некоторым людям не нравится делать в не-веб-приложениях.

РЕДАКТИРОВАТЬ: Да, и они прекрасно работают с анонимными типами, если у вас нет объекта со свойствами, готовыми к нему:

string name = ...;
DateTime date = ...;
string foo = "{Name} - {Birthday}".FormatWith(new { Name = name, Birthday = date });


4

Я думаю, что ближе всего вы получите индексированный формат:

String.Format("{0} has {1} quote types.", "C#", "1");

Есть также String.Replace (), если вы хотите сделать это в несколько шагов и поверить, что вы не найдете свои «переменные» где-либо еще в строке:

string MyString = "{language} has {n} quote types.";
MyString = MyString.Replace("{language}", "C#").Replace("{n}", "1");

Расширяя это, чтобы использовать список:

List<KeyValuePair<string, string>> replacements = GetFormatDictionary();  
foreach (KeyValuePair<string, string> item in replacements)
{
    MyString = MyString.Replace(item.Key, item.Value);
}

Вы также можете сделать это с помощью Dictionary <string, string>, перебирая его коллекции .Keys, но используя List <KeyValuePair <string, string >>, мы можем воспользоваться преимуществом метода List .ForEach () и сжать его обратно до однострочник:

replacements.ForEach(delegate(KeyValuePair<string,string>) item) { MyString = MyString.Replace(item.Key, item.Value);});

Лямбда была бы еще проще, но я все еще на .Net 2.0. Также обратите внимание, что производительность .Replace () не является звездной при многократном использовании, поскольку строки в .Net являются неизменяемыми. Кроме того, для этого требуется, чтобы MyStringпеременная была определена таким образом, чтобы она была доступна делегату, поэтому она еще не идеальна.


Ну, это не самое красивое решение, но это то, что я собираюсь сделать сейчас. Единственное, что я сделал по-другому - это использовал StringBuilder вместо строки, чтобы я не продолжал создавать новые строки.
Джейсон Бейкер

3

Моя библиотека с открытым исходным кодом, Regextra , поддерживает именованное форматирование (среди прочего). В настоящее время он нацелен на .NET 4.0+ и доступен на NuGet . У меня также есть вступительное сообщение в блоге об этом: Regextra: помогает вам уменьшить ваши (проблемы) {2} .

Именованный бит форматирования поддерживает:

  • Основное форматирование
  • Форматирование вложенных свойств
  • Форматирование словаря
  • Экранирование разделителей
  • Стандартное / Пользовательское / IFormatProvider форматирование строки

Пример:

var order = new
{
    Description = "Widget",
    OrderDate = DateTime.Now,
    Details = new
    {
        UnitPrice = 1500
    }
};

string template = "We just shipped your order of '{Description}', placed on {OrderDate:d}. Your {{credit}} card will be billed {Details.UnitPrice:C}.";

string result = Template.Format(template, order);
// or use the extension: template.FormatTemplate(order);

Результат:

Мы только что отправили ваш заказ «Виджет», размещенный 28.02.2014. С вашей кредитной карты будет списана сумма в размере 1500 долларов США.

Проверьте ссылку проекта GitHub (выше) и вики для других примеров.


Вау, это выглядит потрясающе, особенно если иметь дело с некоторыми из более сложных примеров форматов, с которыми можно столкнуться.
Николас Петерсен

2

Проверьте это:

public static string StringFormat(string format, object source)
{
    var matches = Regex.Matches(format, @"\{(.+?)\}");
    List<string> keys = (from Match matche in matches select matche.Groups[1].Value).ToList();

    return keys.Aggregate(
        format,
        (current, key) =>
        {
            int colonIndex = key.IndexOf(':');
            return current.Replace(
                "{" + key + "}",
                colonIndex > 0
                    ? DataBinder.Eval(source, key.Substring(0, colonIndex), "{0:" + key.Substring(colonIndex + 1) + "}")
                    : DataBinder.Eval(source, key).ToString());
        });
}

Образец:

string format = "{foo} is a {bar} is a {baz} is a {qux:#.#} is a really big {fizzle}";
var o = new { foo = 123, bar = true, baz = "this is a test", qux = 123.45, fizzle = DateTime.Now };
Console.WriteLine(StringFormat(format, o));

Производительность довольно хорошая по сравнению с другими решениями.


1

Я сомневаюсь, что это будет возможно. Первое, что приходит на ум, это как получить доступ к именам локальных переменных?

Однако для этого можно использовать какой-нибудь умный способ использования выражений LINQ и Lambda.


@leppie: +1, если вы можете дать мне LINQ + Lambda для этого; D (хорошо, +1 за соответствующий ответ)
user7116

Я бы тоже хотел это увидеть! Может быть, я приму этот вызов!
Леппи

Я подумал, что это было бы невозможно сделать с именами переменных, но поместил это там на случай, если я ошибся. :) Нет никакого способа сделать это с помощью словаря?
Джейсон Бейкер

Я попробовал и кое-что получил, но посчитал это слишком уродливым и сложным в использовании. Это выглядело бы так: string s = format (f => f ("{hello} {world}", hello, world));
Леппи

1

Вот один, который я сделал некоторое время назад. Он расширяет String с помощью метода Format, принимающего один аргумент. Приятно то, что он будет использовать стандартную строку. Формат, если вы предоставите простой аргумент, такой как int, но если вы используете что-то вроде анонимного типа, это тоже будет работать.

Пример использования:

"The {Name} family has {Children} children".Format(new { Children = 4, Name = "Smith" })

Результатом будет «Семья Смитов имеет 4 детей».

Это не делает сумасшедшие привязки, такие как массивы и индексаторы. Но это супер просто и высокая производительность.

    public static class AdvancedFormatString
{

    /// <summary>
    /// An advanced version of string.Format.  If you pass a primitive object (string, int, etc), it acts like the regular string.Format.  If you pass an anonmymous type, you can name the paramters by property name.
    /// </summary>
    /// <param name="formatString"></param>
    /// <param name="arg"></param>
    /// <returns></returns>
    /// <example>
    /// "The {Name} family has {Children} children".Format(new { Children = 4, Name = "Smith" })
    /// 
    /// results in 
    /// "This Smith family has 4 children
    /// </example>
    public static string Format(this string formatString, object arg, IFormatProvider format = null)
    {
        if (arg == null)
            return formatString;

        var type = arg.GetType();
        if (Type.GetTypeCode(type) != TypeCode.Object || type.IsPrimitive)
            return string.Format(format, formatString, arg);

        var properties = TypeDescriptor.GetProperties(arg);
        return formatString.Format((property) =>
            {
                var value = properties[property].GetValue(arg);
                return Convert.ToString(value, format);
            });
    }


    public static string Format(this string formatString, Func<string, string> formatFragmentHandler)
    {
        if (string.IsNullOrEmpty(formatString))
            return formatString;
        Fragment[] fragments = GetParsedFragments(formatString);
        if (fragments == null || fragments.Length == 0)
            return formatString;

        return string.Join(string.Empty, fragments.Select(fragment =>
            {
                if (fragment.Type == FragmentType.Literal)
                    return fragment.Value;
                else
                    return formatFragmentHandler(fragment.Value);
            }).ToArray());
    }


    private static Fragment[] GetParsedFragments(string formatString)
    {
        Fragment[] fragments;
        if ( parsedStrings.TryGetValue(formatString, out fragments) )
        {
            return fragments;
        }
        lock (parsedStringsLock)
        {
            if ( !parsedStrings.TryGetValue(formatString, out fragments) )
            {
                fragments = Parse(formatString);
                parsedStrings.Add(formatString, fragments);
            }
        }
        return fragments;
    }

    private static Object parsedStringsLock = new Object();
    private static Dictionary<string,Fragment[]> parsedStrings = new Dictionary<string,Fragment[]>(StringComparer.Ordinal);

    const char OpeningDelimiter = '{';
    const char ClosingDelimiter = '}';

    /// <summary>
    /// Parses the given format string into a list of fragments.
    /// </summary>
    /// <param name="format"></param>
    /// <returns></returns>
    static Fragment[] Parse(string format)
    {
        int lastCharIndex = format.Length - 1;
        int currFragEndIndex;
        Fragment currFrag = ParseFragment(format, 0, out currFragEndIndex);

        if (currFragEndIndex == lastCharIndex)
        {
            return new Fragment[] { currFrag };
        }

        List<Fragment> fragments = new List<Fragment>();
        while (true)
        {
            fragments.Add(currFrag);
            if (currFragEndIndex == lastCharIndex)
            {
                break;
            }
            currFrag = ParseFragment(format, currFragEndIndex + 1, out currFragEndIndex);
        }
        return fragments.ToArray();

    }

    /// <summary>
    /// Finds the next delimiter from the starting index.
    /// </summary>
    static Fragment ParseFragment(string format, int startIndex, out int fragmentEndIndex)
    {
        bool foundEscapedDelimiter = false;
        FragmentType type = FragmentType.Literal;

        int numChars = format.Length;
        for (int i = startIndex; i < numChars; i++)
        {
            char currChar = format[i];
            bool isOpenBrace = currChar == OpeningDelimiter;
            bool isCloseBrace = isOpenBrace ? false : currChar == ClosingDelimiter;

            if (!isOpenBrace && !isCloseBrace)
            {
                continue;
            }
            else if (i < (numChars - 1) && format[i + 1] == currChar)
            {//{{ or }}
                i++;
                foundEscapedDelimiter = true;
            }
            else if (isOpenBrace)
            {
                if (i == startIndex)
                {
                    type = FragmentType.FormatItem;
                }
                else
                {

                    if (type == FragmentType.FormatItem)
                        throw new FormatException("Two consequtive unescaped { format item openers were found.  Either close the first or escape any literals with another {.");

                    //curr character is the opening of a new format item.  so we close this literal out
                    string literal = format.Substring(startIndex, i - startIndex);
                    if (foundEscapedDelimiter)
                        literal = ReplaceEscapes(literal);

                    fragmentEndIndex = i - 1;
                    return new Fragment(FragmentType.Literal, literal);
                }
            }
            else
            {//close bracket
                if (i == startIndex || type == FragmentType.Literal)
                    throw new FormatException("A } closing brace existed without an opening { brace.");

                string formatItem = format.Substring(startIndex + 1, i - startIndex - 1);
                if (foundEscapedDelimiter)
                    formatItem = ReplaceEscapes(formatItem);//a format item with a { or } in its name is crazy but it could be done
                fragmentEndIndex = i;
                return new Fragment(FragmentType.FormatItem, formatItem);
            }
        }

        if (type == FragmentType.FormatItem)
            throw new FormatException("A format item was opened with { but was never closed.");

        fragmentEndIndex = numChars - 1;
        string literalValue = format.Substring(startIndex);
        if (foundEscapedDelimiter)
            literalValue = ReplaceEscapes(literalValue);

        return new Fragment(FragmentType.Literal, literalValue);

    }

    /// <summary>
    /// Replaces escaped brackets, turning '{{' and '}}' into '{' and '}', respectively.
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    static string ReplaceEscapes(string value)
    {
        return value.Replace("{{", "{").Replace("}}", "}");
    }

    private enum FragmentType
    {
        Literal,
        FormatItem
    }

    private class Fragment
    {

        public Fragment(FragmentType type, string value)
        {
            Type = type;
            Value = value;
        }

        public FragmentType Type
        {
            get;
            private set;
        }

        /// <summary>
        /// The literal value, or the name of the fragment, depending on fragment type.
        /// </summary>
        public string Value
        {
            get;
            private set;
        }


    }

}

1
private static Regex s_NamedFormatRegex = new Regex(@"\{(?!\{)(?<key>[\w]+)(:(?<fmt>(\{\{|\}\}|[^\{\}])*)?)?\}", RegexOptions.Compiled);

public static StringBuilder AppendNamedFormat(this StringBuilder builder,IFormatProvider provider, string format, IDictionary<string, object> args)
{
    if (builder == null) throw new ArgumentNullException("builder");
    var str = s_NamedFormatRegex.Replace(format, (mt) => {
        string key = mt.Groups["key"].Value;
        string fmt = mt.Groups["fmt"].Value;
        object value = null;
        if (args.TryGetValue(key,out value)) {
            return string.Format(provider, "{0:" + fmt + "}", value);
        } else {
            return mt.Value;
        }
    });
    builder.Append(str);
    return builder;
}

public static StringBuilder AppendNamedFormat(this StringBuilder builder, string format, IDictionary<string, object> args)
{
    if (builder == null) throw new ArgumentNullException("builder");
    return builder.AppendNamedFormat(null, format, args);
}

Пример:

var builder = new StringBuilder();
builder.AppendNamedFormat(
@"你好,{Name},今天是{Date:yyyy/MM/dd}, 这是你第{LoginTimes}次登录,积分{Score:{{ 0.00 }}}",
new Dictionary<string, object>() { 
    { "Name", "wayjet" },
    { "LoginTimes",18 },
    { "Score", 100.4 },
    { "Date",DateTime.Now }
});

Вывод: 你好, wayjet, 今天 是 2011-05-04, 这 是 你 第 18 次 登录 , 积分 {100.40}


1

Вот простой метод для любого объекта:

    using System.Text.RegularExpressions;
    using System.ComponentModel;

    public static string StringWithFormat(string format, object args)
    {
        Regex r = new Regex(@"\{([A-Za-z0-9_]+)\}");

        MatchCollection m = r.Matches(format);

        var properties = TypeDescriptor.GetProperties(args);

        foreach (Match item in m)
        {
            try
            {
                string propertyName = item.Groups[1].Value;
                format = format.Replace(item.Value, properties[propertyName].GetValue(args).ToString());
            }
            catch
            {
                throw new FormatException("The format string is not valid");
            }
        }

        return format;
    }

А вот как это использовать:

 DateTime date = DateTime.Now;
 string dateString = StringWithFormat("{Month}/{Day}/{Year}", date);

выходной: 27.02.2012


0

Я реализовал это простой класс, который дублирует функциональность String.Format (за исключением случаев использования классов). Вы можете использовать словарь или тип для определения полей.

https://github.com/SergueiFedorov/NamedFormatString

C # 6.0 добавляет эту функциональность прямо в спецификацию языка, поэтому NamedFormatStringдля обратной совместимости.


0

Я решил это немного иначе, чем существующие решения. Это делает ядро ​​замены названного элемента (а не бит отражения, который сделали некоторые). Это очень быстро и просто ... Это мое решение:

/// <summary>
/// Formats a string with named format items given a template dictionary of the items values to use.
/// </summary>
public class StringTemplateFormatter
{
    private readonly IFormatProvider _formatProvider;

    /// <summary>
    /// Constructs the formatter with the specified <see cref="IFormatProvider"/>.
    /// This is defaulted to <see cref="CultureInfo.CurrentCulture">CultureInfo.CurrentCulture</see> if none is provided.
    /// </summary>
    /// <param name="formatProvider"></param>
    public StringTemplateFormatter(IFormatProvider formatProvider = null)
    {
        _formatProvider = formatProvider ?? CultureInfo.CurrentCulture;
    }

    /// <summary>
    /// Formats a string with named format items given a template dictionary of the items values to use.
    /// </summary>
    /// <param name="text">The text template</param>
    /// <param name="templateValues">The named values to use as replacements in the formatted string.</param>
    /// <returns>The resultant text string with the template values replaced.</returns>
    public string FormatTemplate(string text, Dictionary<string, object> templateValues)
    {
        var formattableString = text;
        var values = new List<object>();
        foreach (KeyValuePair<string, object> value in templateValues)
        {
            var index = values.Count;
            formattableString = ReplaceFormattableItem(formattableString, value.Key, index);
            values.Add(value.Value);
        }
        return String.Format(_formatProvider, formattableString, values.ToArray());
    }

    /// <summary>
    /// Convert named string template item to numbered string template item that can be accepted by <see cref="string.Format(string,object[])">String.Format</see>
    /// </summary>
    /// <param name="formattableString">The string containing the named format item</param>
    /// <param name="itemName">The name of the format item</param>
    /// <param name="index">The index to use for the item value</param>
    /// <returns>The formattable string with the named item substituted with the numbered format item.</returns>
    private static string ReplaceFormattableItem(string formattableString, string itemName, int index)
    {
        return formattableString
            .Replace("{" + itemName + "}", "{" + index + "}")
            .Replace("{" + itemName + ",", "{" + index + ",")
            .Replace("{" + itemName + ":", "{" + index + ":");
    }
}

Он используется следующим образом:

    [Test]
    public void FormatTemplate_GivenANamedGuid_FormattedWithB_ShouldFormatCorrectly()
    {
        // Arrange
        var template = "My guid {MyGuid:B} is awesome!";
        var templateValues = new Dictionary<string, object> { { "MyGuid", new Guid("{A4D2A7F1-421C-4A1D-9CB2-9C2E70B05E19}") } };
        var sut = new StringTemplateFormatter();
        // Act
        var result = sut.FormatTemplate(template, templateValues);
        //Assert
        Assert.That(result, Is.EqualTo("My guid {a4d2a7f1-421c-4a1d-9cb2-9c2e70b05e19} is awesome!"));
    }

Надеюсь, кто-то найдет это полезным!


0

Несмотря на то, что принятый ответ дает несколько хороших примеров, .Inject, а также некоторые примеры Haack не обрабатывают экранирование. Многие также сильно зависят от Regex (более медленный) или DataBinder.Eval, который недоступен в .NET Core и в некоторых других средах.

Имея это в виду, я написал простой парсер на основе конечного автомата, который выполняет потоковую обработку символов, запись в StringBuilderвывод, символ за символом. Он реализован как Stringметод (ы) расширения и может принимать в качестве входных данных как a, так Dictionary<string, object>и objectпараметры (используя отражение).

Он обрабатывает неограниченные уровни {{{escaping}}}и броски, FormatExceptionкогда ввод содержит несбалансированные фигурные скобки и / или другие ошибки.

public static class StringExtension {
    /// <summary>
    /// Extension method that replaces keys in a string with the values of matching object properties.
    /// </summary>
    /// <param name="formatString">The format string, containing keys like {foo} and {foo:SomeFormat}.</param>
    /// <param name="injectionObject">The object whose properties should be injected in the string</param>
    /// <returns>A version of the formatString string with keys replaced by (formatted) key values.</returns>
    public static string FormatWith(this string formatString, object injectionObject) {
        return formatString.FormatWith(GetPropertiesDictionary(injectionObject));
    }

    /// <summary>
    /// Extension method that replaces keys in a string with the values of matching dictionary entries.
    /// </summary>
    /// <param name="formatString">The format string, containing keys like {foo} and {foo:SomeFormat}.</param>
    /// <param name="dictionary">An <see cref="IDictionary"/> with keys and values to inject into the string</param>
    /// <returns>A version of the formatString string with dictionary keys replaced by (formatted) key values.</returns>
    public static string FormatWith(this string formatString, IDictionary<string, object> dictionary) {
        char openBraceChar = '{';
        char closeBraceChar = '}';

        return FormatWith(formatString, dictionary, openBraceChar, closeBraceChar);
    }
        /// <summary>
        /// Extension method that replaces keys in a string with the values of matching dictionary entries.
        /// </summary>
        /// <param name="formatString">The format string, containing keys like {foo} and {foo:SomeFormat}.</param>
        /// <param name="dictionary">An <see cref="IDictionary"/> with keys and values to inject into the string</param>
        /// <returns>A version of the formatString string with dictionary keys replaced by (formatted) key values.</returns>
    public static string FormatWith(this string formatString, IDictionary<string, object> dictionary, char openBraceChar, char closeBraceChar) {
        string result = formatString;
        if (dictionary == null || formatString == null)
            return result;

        // start the state machine!

        // ballpark output string as two times the length of the input string for performance (avoids reallocating the buffer as often).
        StringBuilder outputString = new StringBuilder(formatString.Length * 2);
        StringBuilder currentKey = new StringBuilder();

        bool insideBraces = false;

        int index = 0;
        while (index < formatString.Length) {
            if (!insideBraces) {
                // currently not inside a pair of braces in the format string
                if (formatString[index] == openBraceChar) {
                    // check if the brace is escaped
                    if (index < formatString.Length - 1 && formatString[index + 1] == openBraceChar) {
                        // add a brace to the output string
                        outputString.Append(openBraceChar);
                        // skip over braces
                        index += 2;
                        continue;
                    }
                    else {
                        // not an escaped brace, set state to inside brace
                        insideBraces = true;
                        index++;
                        continue;
                    }
                }
                else if (formatString[index] == closeBraceChar) {
                    // handle case where closing brace is encountered outside braces
                    if (index < formatString.Length - 1 && formatString[index + 1] == closeBraceChar) {
                        // this is an escaped closing brace, this is okay
                        // add a closing brace to the output string
                        outputString.Append(closeBraceChar);
                        // skip over braces
                        index += 2;
                        continue;
                    }
                    else {
                        // this is an unescaped closing brace outside of braces.
                        // throw a format exception
                        throw new FormatException($"Unmatched closing brace at position {index}");
                    }
                }
                else {
                    // the character has no special meaning, add it to the output string
                    outputString.Append(formatString[index]);
                    // move onto next character
                    index++;
                    continue;
                }
            }
            else {
                // currently inside a pair of braces in the format string
                // found an opening brace
                if (formatString[index] == openBraceChar) {
                    // check if the brace is escaped
                    if (index < formatString.Length - 1 && formatString[index + 1] == openBraceChar) {
                        // there are escaped braces within the key
                        // this is illegal, throw a format exception
                        throw new FormatException($"Illegal escaped opening braces within a parameter - index: {index}");
                    }
                    else {
                        // not an escaped brace, we have an unexpected opening brace within a pair of braces
                        throw new FormatException($"Unexpected opening brace inside a parameter - index: {index}");
                    }
                }
                else if (formatString[index] == closeBraceChar) {
                    // handle case where closing brace is encountered inside braces
                    // don't attempt to check for escaped braces here - always assume the first brace closes the braces
                    // since we cannot have escaped braces within parameters.

                    // set the state to be outside of any braces
                    insideBraces = false;

                    // jump over brace
                    index++;

                    // at this stage, a key is stored in current key that represents the text between the two braces
                    // do a lookup on this key
                    string key = currentKey.ToString();
                    // clear the stringbuilder for the key
                    currentKey.Clear();

                    object outObject;

                    if (!dictionary.TryGetValue(key, out outObject)) {
                        // the key was not found as a possible replacement, throw exception
                        throw new FormatException($"The parameter \"{key}\" was not present in the lookup dictionary");
                    }

                    // we now have the replacement value, add the value to the output string
                    outputString.Append(outObject);

                    // jump to next state
                    continue;
                } // if }
                else {
                    // character has no special meaning, add it to the current key
                    currentKey.Append(formatString[index]);
                    // move onto next character
                    index++;
                    continue;
                } // else
            } // if inside brace
        } // while

        // after the loop, if all braces were balanced, we should be outside all braces
        // if we're not, the input string was misformatted.
        if (insideBraces) {
            throw new FormatException("The format string ended before the parameter was closed.");
        }

        return outputString.ToString();
    }

    /// <summary>
    /// Creates a Dictionary from an objects properties, with the Key being the property's
    /// name and the Value being the properties value (of type object)
    /// </summary>
    /// <param name="properties">An object who's properties will be used</param>
    /// <returns>A <see cref="Dictionary"/> of property values </returns>
    private static Dictionary<string, object> GetPropertiesDictionary(object properties) {
        Dictionary<string, object> values = null;
        if (properties != null) {
            values = new Dictionary<string, object>();
            PropertyDescriptorCollection props = TypeDescriptor.GetProperties(properties);
            foreach (PropertyDescriptor prop in props) {
                values.Add(prop.Name, prop.GetValue(properties));
            }
        }
        return values;
    }
}

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


-6
string language = "Python";
int numquotes = 2;
string output = language + " has "+ numquotes + " language types.";

Изменить: то, что я должен был сказать, было: «Нет, я не верю, что то, что вы хотите сделать, поддерживается C #. Это настолько близко, насколько вы собираетесь получить».


1
Мне любопытно, что голосуют против. Кто-нибудь хочет сказать мне, почему?
Кевин

1
Таким образом, string.format будет выполнять эту операцию на 4/10 тысячных секунд быстрее. Если эта функция будет вызвана на тонну, вы можете заметить эту разницу. Но это, по крайней мере, отвечает на его вопрос, а не просто говорит ему сделать это так, как он уже сказал, что не хочет делать это.
Кевин

4
Я не проголосовал за вас, но я бы не стал реализовывать это, главным образом потому, что я считаю, что делать много строк - ужасно. Но это мое личное мнение.
Джейсон Бейкер

Странно, что за это проголосовало так много. Подумайте над расширением своего ответа: если конкатенация не вызывается часто, вы можете считать ее "someString" + someVariable + "someOtherString"более читабельной. Эта статья с вами согласна.
Стивен Джеурис
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.