Is there any way to format a string by name rather than position in C#?
In python, I can do something like this example (shamelessly stolen from here):
>>> print '%(language)s has %(#)03d quote types.' % \
{'language': "Python", "#": 2}
Python has 002 quote types.
Is there any way to do this in C#? Say for instance:
String.Format("{some_variable}: {some_other_variable}", ...);
Being able to do this using a variable name would be nice, but a dictionary is acceptable too.
There is no built-in method for handling this.
Here's one method
string myString = "{foo} is {bar} and {yadi} is {yada}".Inject(o);
Here's another
Status.Text = "{UserName} last logged in at {LastLoginDate}".FormatWith(user);
A third improved method partially based on the two above, from Phil Haack
Update: This is now built-in as of C# 6 (released in 2015).
String Interpolation
$"{some_variable}: {some_other_variable}"
I have an implementation I just posted to my blog here: http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx
It addresses some issues that these other implementations have with brace escaping. The post has details. It does the DataBinder.Eval thing too, but is still very fast.
Interpolated strings were added into C# 6.0 and Visual Basic 14
Both were introduced through new Roslyn compiler in Visual Studio 2015.
C# 6.0:
return "\{someVariable} and also \{someOtherVariable}" OR
return $"{someVariable} and also {someOtherVariable}"
source: what's new in C#6.0
VB 14:
return $"{someVariable} and also {someOtherVariable}"
source: what's new in VB 14
Noteworthy features (in Visual Studio 2015 IDE):
syntax coloring is supported - variables contained in strings are highlighted
refactoring is supported - when renaming, variables contained in strings get renamed, too
actually not only variable names, but expressions are supported - e.g. not only {index} works, but also {(index + 1).ToString().Trim()}
Enjoy! (& click "Send a Smile" in the VS)
You can also use anonymous types like this:
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;
}
Of course it would require more code if you also want to parse formatting, but you can format a string using this function like:
Format("test {first} and {another}", new { first = "something", another = "something else" })
There doesn't appear to be a way to do this out of the box. Though, it looks feasible to implement your own IFormatProvider that links to an IDictionary for values.
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);
Outputs:
Python has 2 quote types
The caveat is that you can't mix FormatProviders, so the fancy text formatting can't be used at the same time.
The framework itself does not provide a way to do this, but you can take a look at this post by Scott Hanselman. Example usage:
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);
This code by James Newton-King is similar and works with sub-properties and indexes,
string foo = "Top result for {Name} was {Results[0].Name}".FormatWith(student));
James's code relies on System.Web.UI.DataBinder to parse the string and requires referencing System.Web, which some people don't like to do in non-web applications.
EDIT: Oh and they work nicely with anonymous types, if you don't have an object with properties ready for it:
string name = ...;
DateTime date = ...;
string foo = "{Name} - {Birthday}".FormatWith(new { Name = name, Birthday = date });
See https://stackoverflow.com/questions/271398?page=2#358259
With the linked-to extension you can write this:
var str = "{foo} {bar} {baz}".Format(foo=>"foo", bar=>2, baz=>new object());
and you'll get "foo 2 System.Object".
I think the closest you'll get is an indexed format:
String.Format("{0} has {1} quote types.", "C#", "1");
There's also String.Replace(), if you're willing to do it in multiple steps and take it on faith that you won't find your 'variables' anywhere else in the string:
string MyString = "{language} has {n} quote types.";
MyString = MyString.Replace("{language}", "C#").Replace("{n}", "1");
Expanding this to use a List:
List<KeyValuePair<string, string>> replacements = GetFormatDictionary();
foreach (KeyValuePair<string, string> item in replacements)
{
MyString = MyString.Replace(item.Key, item.Value);
}
You could do that with a Dictionary<string, string> too by iterating it's .Keys collections, but by using a List<KeyValuePair<string, string>> we can take advantage of the List's .ForEach() method and condense it back to a one-liner:
replacements.ForEach(delegate(KeyValuePair<string,string>) item) { MyString = MyString.Replace(item.Key, item.Value);});
A lambda would be even simpler, but I'm still on .Net 2.0. Also note that the .Replace() performance isn't stellar when used iteratively, since strings in .Net are immutable. Also, this requires the MyString variable be defined in such a way that it's accessible to the delegate, so it's not perfect yet.
My open source library, Regextra, supports named formatting (amongst other things). It currently targets .NET 4.0+ and is available on NuGet. I also have an introductory blog post about it: Regextra: helping you reduce your (problems){2}.
The named formatting bit supports:
Basic formatting
Nested properties formatting
Dictionary formatting
Escaping of delimiters
Standard/Custom/IFormatProvider string formatting
Example:
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);
Result:
We just shipped your order of 'Widget', placed on 2/28/2014. Your {credit} card will be billed $1,500.00.
Check out the project's GitHub link (above) and wiki for other examples.
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);
}
Example:
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 }
});
Output:
你好,wayjet,今天是2011-05-04, 这是你第18次登录，积分{ 100.40 }
Check this one:
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());
});
}
Sample:
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));
Performance is pretty ok compared to other solutions.
I doubt this will be possible. The first thing that comes to mind is how are you going to get access to local variable names?
There might be some clever way using LINQ and Lambda expressions to do this however.
Here's one I made a while back. It extends String with a Format method taking a single argument. The nice thing is that it'll use the standard string.Format if you provide a simple argument like an int, but if you use something like anonymous type it'll work too.
Example usage:
"The {Name} family has {Children} children".Format(new { Children = 4, Name = "Smith" })
Would result in "The Smith family has 4 children."
It doesn't do crazy binding stuff like arrays and indexers. But it is super simple and high performance.
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;
}
}
}
here is a simple method for any object:
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;
}
And here how to use it:
DateTime date = DateTime.Now;
string dateString = StringWithFormat("{Month}/{Day}/{Year}", date);
output : 2/27/2012
I implemented this is a simple class that duplicates the functionality of String.Format (except for when using classes). You can either use a dictionary or a type to define fields.
https://github.com/SergueiFedorov/NamedFormatString
C# 6.0 is adding this functionality right into the language spec, so NamedFormatString is for backwards compatibility.
I solved this in a slightly different way to the existing solutions.
It does the core of the named item replacement (not the reflection bit that some have done). It is extremely fast and simple...
This is my solution:
/// <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 + ":");
}
}
It is used in the following way:
[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!"));
}
Hope someone finds this useful!
Even though the accepted answer gives some good examples, the .Inject as well as some of the Haack examples do not handle escaping. Many also rely heavily on Regex (slower), or DataBinder.Eval which is not available on .NET Core, and in some other environments.
With that in mind, I've written a simple state machine based parser that streams through characters, writing to a StringBuilder output, character by character. It is implemented as String extension method(s) and can take both a Dictionary<string, object> or object with parameters as input (using reflection).
It handles unlimited levels of {{{escaping}}} and throws FormatException when input contains unbalanced braces and/or other errors.
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;
}
}
Ultimately, all the logic boils down into 10 main states - For when the state machine is outside a bracket and likewise inside a bracket, the next character is either an open brace, an escaped open brace, a closed brace, an escaped closed brace, or an ordinary character. Each of these conditions is handled individually as the loop progresses, adding characters to either an output StringBuffer or a key StringBuffer. When a parameter is closed, the value of the key StringBuffer is used to look up the parameter's value in the dictionary, which then gets pushed into the output StringBuffer. At the end, the value of the output StringBuffer is returned.
string language = "Python";
int numquotes = 2;
string output = language + " has "+ numquotes + " language types.";
Edit:
What I should have said was, "No, I don't believe what you want to do is supported by C#. This is as close as you are going to get."
Related
Help me guys to complete the code using Regex. I'm new to learn c#.
Create a C# program to complete the following task using Regular Expressions
i. Create a string variable 'Myinput' and read the value from user
ii. Check whether the given values are matching with the following
Cappuccino
Tea
Milk
Espresso
iii. If any other values except the above, the program need to throw an error
message
using System;
using System.Linq;
using System.Text.RegularExpressions;
namespace RegularExpression
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Enter the user choice input");
string Myinput = Console.ReadLine();
string[] arrayy = new string[4] { "Cappucino", "Tea", "Milk", "Espresso" };
MyChoice obj = new MyChoice();
bool ans = obj.MyChoiceContains(Myinput, arrayy);
Console.WriteLine(ans);
Console.ReadKey();
/// i. Create a string variable 'Myinput' and read the value from user.
/// ii. Check whether the given values are matching with the following
/// 1.Cappuccino 2. Tea 3. Milk 4. Espresso.
/// iii. If any other values except the above, the program need to throw the error
///message.
/// Display valid or invalid message here.
}
}
public class MyChoice
{
public bool MyChoiceContains(string Userchoice, string[] myChoiceValues)
{
Userchoice = #"^[A-Za-z]$";
Regex rg = new Regex(Userchoice);
bool ans = true;
foreach (string s in myChoiceValues)
{
ans = Regex.IsMatch(Userchoice, s);
}
return ans;
}
}
}
/// <summary>
/// Create Class with Class name 'MyChoice'.
/// </summary>
/// <summary>
/// Create a method with the name 'MyChoiceContains'.
/// <param name="Userchoice"></param><type>string</type>
/// <param name="myChoiceValues"></param><type>string[]</type>
/// <returns>bool</returns>return "true" if valid else return "false".
/// Note: Please dont use Console.WriteLine() and Console.ReadLine() in this method.
/// </summary>
In the comments you have stated that the user will input a regular expression, and that you want to check if the regular expression matches on any of the elements in the array. You can either do this manually:
foreach (string s in myChoiceValues)
{
if (rg.IsMatch(s))
return true;
}
return false;
I've moved the return false; outside so that you don't return false; when the first item doesn't match.
Alternatively, you can do this using the LINQ extension methods. You'll need to ensure you have using System.Linq; at the top of your file.
return myChoiceValues.Any(v => rg.IsMatch(v));
// or simply: return myChoiceValues.Any(rg.IsMatch);
You might also need to rewrite your hardcoded test expression (^[A-Za-z]$) as this currently requires a single character between the start and end of the string (i.e. the matched string should be a single character). Perhaps you meant:
^[A-Za-z]+$
The + means it will match 1 or more characters matching from the [A-Za-z] set.
string pattern = #"(Cappuccino | Tea | Milk | Espresso)";
string input = "text";
Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
if (m.Success)
{
// matched
}
else
{
// not matched
}
Ressource
I want to allow user so they can read more than one tag in a string. So far, user could only add one tag
if (rtb.Text.Contains("[b]"))
{
Regex regex = new Regex(#"\[b\](.*)\[/b\]");
var v = regex.Match(rtb.Text);
string s = v.Groups[1].ToString();
rtb.SelectionStart = rtb.Text.IndexOf("[b]");
rtb.SelectionLength = s.Length + 7;
rtb.SelectionFont = new Font(rtb.Font.FontFamily, rtb.Font.Size, FontStyle.Bold);
rtb.SelectedText = s;
}
else if (rtb.Text.Contains("[i]"))
{
Regex regex = new Regex(#"\[i\](.*)\[/i\]");
var v = regex.Match(rtb.Text);
string s = v.Groups[1].ToString();
rtb.SelectionStart = rtb.Text.IndexOf("[b]");
rtb.SelectionLength = s.Length + 7;
rtb.SelectionFont = new Font(rtb.Font.FontFamily, rtb.Font.Size, FontStyle.Italic);
rtb.SelectedText = s;
}
richTextBox1.Select(richTextBox1.TextLength, 0);
richTextBox1.SelectedRtf = rtb.Rtf;
If i have this string:
"Hello [b]World[/b] Meet the [b]Programmer[/b]"
the output would be like this:
"Hello World Meet the Programmer"
And if i have this string:
"Hello [b]World[/b] Meet the [i]Programmer[/i]"
the output would be like this:
"Hello World Meet the [i]Programmer[/i]"
How to read multiple tags from a string? like, in a string if i have 2 [b][/b] tags, 5 [i][/i] tags or even mixed tags ([b][i][/i][/b])?
Two problems:
1. Greedy matching semantics of Regex
\[b\](.*)\[/b\] looks for the longest possible match within your string, i.e. it is greedy. In your example, you expect it to match [b]World[/b], when in fact it matches [b]World[/b] Meet the [b]Programmer[/b] (consequently making "Meet the" bold as well). This can easily be resolved using non-greedy syntax: \[b\](.*?)\[/b\] (note the extra ?)
Details: How to Match with Regex "shortest match" in .NET
2. You are only looking for one occurrence of tags!
Obviously, your code will only highlight a single [b]/[i] tag. Don't use else if if you want [i] to be handled if your string contains [b]. Use loops and Regex.Matches if you want to handle all occurrences of your regular expression instead of just the first one.
Without Regex but still must be adapted slightly.
The test:
[Test]
public void Text()
{
string str = "[b]Hello[/b] This is sample text [b] Goodbye [/b]";
var bold = AllIndexesOf(str, "b").ToArray();
// Assume the IEnumerable is even else it should of thrown an error
for (int i = 0; i < bold.Count(); i += 2)
{
Console.WriteLine($"Pair: {bold[i]} | {bold[i+1]}");
}
// str.AllIndexesOf
}
Here is the method.
/// <summary>
/// Courtesy of : http://stackoverflow.com/a/24016130/5282506
/// Adapted by me.
///
/// Pass in the unique symbol and itll find the first and last index pairs
/// Can adapt to find all unique pairs at once.
/// </summary>
/// <param name="str">The string.</param>
/// <param name="searchstring">The searchstring letter (b, i, etc)</param>
/// <returns></returns>
public static IEnumerable<int> AllIndexesOf(string str, string searchstring)
{
//assumes the string is formatted correctly. Only one tag of the same type inside each tag.
int minIndex = str.IndexOf("["+searchstring+"]");
while (minIndex != -1)
{
Console.WriteLine("First: {0}", minIndex);
yield return minIndex;
var maxIndexEnd = str.IndexOf("[/"+ searchstring +"]", minIndex + searchstring.Length +3);//added three for the [/ and ] characters.
Console.WriteLine("End: {0}", maxIndexEnd);
if (maxIndexEnd == -1)
{
//Malformed string, no end element for a found start element
//Do something...
throw new FormatException("Malformed string");
}
yield return maxIndexEnd;
minIndex = str.IndexOf("[" + searchstring+"]", maxIndexEnd + searchstring.Length+2);//added two for the [ and ] characters
}
}
If you wish to make it an extension method for string change signature to this:
public static IEnumerable<int> AllIndexesOf(this string str, string searchstring)
Heres the console result for bold indexes:
Pair: 0 | 8
Pair: 33 | 45
I have not fully tested this method for all edge cases.
First, all my cities were returned as UPPERCASE, so I switched them to lowercase. How can I get the first letter as uppercase now? Thanks for any help!
List<string> cities = new List<string>();
foreach (DataRow row in dt.Rows)
{
cities.Add(row[0].ToString().ToLower());
**ADDED THIS BUT NOTHING HAPPENED**
CultureInfo.CurrentCulture.TextInfo.ToTitleCase(row[0] as string);
}
return cities;
Use the TextInfo.ToTitleCase method:
System.Globalization.TextInfo.ToTitleCase();
A bit from the MSDN example, modified to work with OP's code:
// Defines the string with mixed casing.
string myString = row[0] as String;
// Creates a TextInfo based on the "en-US" culture.
TextInfo myTI = new CultureInfo("en-US", false).TextInfo;
// Retrieve a titlecase'd version of the string.
string myCity = myTI.ToTitleCase(myString);
All in one line:
string myCity = new CultureInfo("en-US", false).TextInfo.ToTitleCase(row[0] as String);
I know I'm resurrecting a ghost here, but I had the same problem, and wanted to share what I think is the best solution. There are a few ways you can do it, either splitting the string and replacing the first letter, or transforming it into a char-array for better performance. The best performance, though, comes with using a regular expression.
You can use a bit of Regex voodoo to find the first letter of each word. The pattern you are looking for is \b\w (\b means the beginning of a word, and \w is an alpha character). Use a MatchEvaluator delegate (or an equivalent lambda expression) to modify the string (the first character, that your pattern found).
Here's an extension method over string that will upper-case-ify the first letter of each word in a string:
static string UpperCaseFirst(this string input)
{
return Regex.Replace(input, #"\b\w", (Match match)=> match.ToString().ToUpper())
}
Regex may seem a bit long, but works
List<string> cities = new List<string>();
foreach (DataRow row in dt.Rows)
{
string city = row[0].ToString();
cities.Add(String.Concat(Regex.Replace(city, "([a-zA-Z])([a-zA-Z]+)", "$1").ToUpper(System.Globalization.CultureInfo.InvariantCulture), Regex.Replace(city, "([a-zA-Z])([a-zA-Z]+)", "$2").ToLower(System.Globalization.CultureInfo.InvariantCulture)));
}
return cities;
new CultureInfo("en-US",false).TextInfo.ToTitleCase(myString);
here is an extension method that you can use. It supports the current culture, or allows you to pass in the culture.
to use:
cities.Add(row[0].ToString().ToTitleCase()
public static class StringExtension
{
/// <summary>
/// Use the current thread's culture info for conversion
/// </summary>
public static string ToTitleCase(this string str)
{
var cultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
return cultureInfo.TextInfo.ToTitleCase(str.ToLower());
}
/// <summary>
/// Overload which uses the culture info with the specified name
/// </summary>
public static string ToTitleCase(this string str, string cultureInfoName)
{
var cultureInfo = new CultureInfo(cultureInfoName);
return cultureInfo.TextInfo.ToTitleCase(str.ToLower());
}
/// <summary>
/// Overload which uses the specified culture info
/// </summary>
public static string ToTitleCase(this string str, CultureInfo cultureInfo)
{
return cultureInfo.TextInfo.ToTitleCase(str.ToLower());
}
}
With linq:
String newString = new String(str.Select((ch, index) => (index == 0) ? ch : Char.ToLower(ch)).ToArray()); *
gently stolen from this post : How to lowercase a string except for first character with C#
You could use this method (or create an extension method out of it):
static string UpperCaseFirst(this string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}
Here's quick little method:
public string UpperCaseFirstLetter(string YourLowerCaseWord)
{
if (string.IsNullOrEmpty(YourLowerCaseWord))
return string.Empty;
return char.ToUpper(YourLowerCaseWord[0]) + YourLowerCaseWord.Substring(1);
}
public static string UppercaseFirst(string value)
{
// Check for empty string.
if (string.IsNullOrEmpty(value))
{
return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(value[0]) + value.Substring(1);
}
cities.Select(UppercaseFirst).ToList();
I need a better way to do this:
Regex.Replace(Regex.Replace(Regex.Replace(Regex.Replace(Regex.Replace(textMessage.Trim(), "{birthday}", person.Birthday, RegexOptions.None), "{phone}", person.MobilePhone, RegexOptions.None), "{email}", person.Email, RegexOptions.None), "{lastname}", person.LastName, RegexOptions.None), "{firstname}", person.FirstName, RegexOptions.None)
textMessage.Trim()
.Replace("{birthday}",person.Birthday)
.Replace("{phone}",person.Phone)
...
IDictionary<string, string> replacements = new Dictionary<string, string>();
replacements.Add("{birthday}", person.Birthday);
replacements.Add("{phone}", person.MobilePhone);
...
foreach (string s in replacements.Keys) {
Regex.Replace(textMessage, s, replacements[s], RegexOptions.None);
}
I prefer to match on say, {word} and then use the Replace overload that takes a MatchEvaluator.
Then it's easy to have a dictionary (or switch or whatever) provide the replacement input (for the given "word").
There are additional advantages such as better run-time characteristics (O(n) vs O(k*n)), scales nicely/allows separation of replacement data, and isn't affected if one of the replacements contains {} stuff.
Happy coding.
I dug this out of an old project. It looks like this even "understands" formatting. YMMV.
/// <summary>
/// Like string.Format but takes "{named}" identifiers with a Dictionary
/// of replacement values.
/// </summary>
/// <param name="format"></param>
/// <param name="replaces"></param>
/// <returns></returns>
public static string Format(string format, IDictionary<string,object> replaces) {
if (format == null) throw new ArgumentNullException("format");
if (replaces == null) throw new ArgumentNullException("replaces");
return Regex.Replace(format, #"{(?<key>\w+)(?:[:](?<keyFormat>[^}]+))?}", (match) => {
Object value;
var key = match.Groups["key"].Value;
var keyFormat = match.Groups["keyFormat"].Value;
if (replaces.TryGetValue(key, out value)) {
if (string.IsNullOrEmpty(keyFormat)) {
return "" + value;
} else {
// format if applicable
return string.Format("{0:" + keyFormat + "}", value);
}
} else {
// don't replace not-found
return match.Value;
}
});
}
Of course, in a more trivial manner (extracted from above, YMMV x2):
var person = GetPerson(); // I love closures
var res = Regex.Replace(input, #"{(?<key>\w+)}", (match) => {
switch (match.Groups["key"].Value) {
case "birthday": return person.Birthday;
// ....
default: return "";
}
});
I have a delimited text file: one of the columns is DocDate
The ddate column looks like this
20070222
20070221
(there is 100's of dates in this text file like this)
so it's (delimited with |)
|DDate|
|20070222|
|20070221|
I need to translate this to
|DDate|
|02/22/2007|
|02/21/2007|
i have a current replace statement that i have this text file being formated in. If someone could show me how to actually to place that inside of the statement that would be awesome.
using (StreamReader stream = new StreamReader(File.Open(#"C:\nPrep\" + textBox1.Text + "\\CI\\ncr.txt", FileMode.Open)))
{
string fileText = stream.ReadToEnd();
fileText = fileText.Replace(#"BegAtt|EndAtt", "BegAtt#|EndAtt#");
fileText = fileText.Replace(#"Cc|*RFP", "CC|RFP");
fileText = fileText.Replace(#"<swme> ", string.Empty);
fileText = fileText.Replace(#" </swme>",";");
using (StreamWriter writer = new StreamWriter(File.Open(#"C:\" + textBox1.Text + "\\nc" + "\\Data\\ncr.txt", FileMode.Create)))
{
writer.Write(fileText);
}
}
}
Example:
Before date conversion:
216442|216443|||20080823|EM
After Date:
216442|216443|||08/23/2005|EM
You can run the date strings through a method like this:
private static string ReformatDate(string input)
{
return DateTime.ParseExact(input, "|yyyyMMdd|", CultureInfo.InvariantCulture)
.ToString("MM/dd/yyyy", CultureInfo.InvariantCulture);
}
Example:
Console.WriteLine(ReformatDate("|20070222|")); // prints 02/22/2007
Update
Complete sample including file parsing:
private const int DATE_COLUMN = 4;
static void Main(string[] args)
{
string inputFile = #"c:\temp\input.txt";
string outputFile = #"c:\temp\output.txt";
using (StreamReader reader = File.OpenText(inputFile))
using(Stream outputStream = File.OpenWrite(outputFile))
using (StreamWriter writer = new StreamWriter(outputStream))
{
do
{
string line = reader.ReadLine();
if (line == null)
{
break;
}
writer.WriteLine(TransformLine(line));
} while (true);
}
File.Delete(inputFile);
File.Move(outputFile, inputFile);
}
private static char[] separator = "|".ToCharArray();
private static string TransformLine(string line)
{
string[] columns = line.Split(separator);
columns[DATE_COLUMN] = ReformatDate(columns[4]);
return string.Join("|", columns);
}
private static string ReformatDate(string input)
{
return DateTime.ParseExact(input, "yyyyMMdd", CultureInfo.InvariantCulture)
.ToString("MM/dd/yyyy", CultureInfo.InvariantCulture);
}
Now it will have replaced the original file with one that has the transformed lines.
I think this does what you want:
using System;
using System.Linq;
using System.Text.RegularExpressions;
using System.IO;
class Program
{
static void Main(string[] args)
{
string inputFilename = "input.txt";
string outputFilename = "output.txt";
string[] dateColumnNames = { "DDate" };
using (StreamReader stream = new StreamReader(File.Open(inputFilename, FileMode.Open)))
using (StreamWriter writer = new StreamWriter(File.Open(outputFilename, FileMode.Create)))
{
int[] dateColumns = new int[0];
while (true)
{
string line = stream.ReadLine();
if (line == null)
break;
// Split into columns.
string[] columns = line.Split('|');
// Find date columns.
int[] newDateColumns =
columns.Select((name, index) => new { Name = name, Index = index })
.Where(x => dateColumnNames.Contains(x.Name))
.Select(x => x.Index)
.ToArray();
if (newDateColumns.Length > 0)
dateColumns = newDateColumns;
// Replace dates.
foreach (int i in dateColumns)
{
if (columns.Length > i)
{
Regex regex = new Regex(#"(\d{4})(\d{2})(\d{2})");
columns[i] = regex.Replace(columns[i], "$2/$3/$1");
line = string.Join("|", columns);
}
}
// Make other replacements.
line = line.Replace(#"BegAtt|EndAtt", "BegAtt#|EndAtt#");
line = line.Replace(#"Cc|*RFP", "CC|RFP");
line = line.Replace(#"<swme> ", string.Empty);
line = line.Replace(#" </swme>", ";");
// Output line.
writer.WriteLine(line);
}
}
}
}
Example input:
a|b|c|d|DDate|e
216442|20011223|||20080823|EM
216443|20011223|||20080824|EM
a|DDate|c|d|e|f
216442|20011223|||20080823|EM
<swme> Just a test </swme>
Output:
a|b|c|d|DDate|e
216442|20011223|||08/23/2008|EM
216443|20011223|||08/24/2008|EM
a|DDate|c|d|e|f
216442|12/23/2001|||20080823|EM
Just a test;
Notice that the DDate column changes. You can also specify multiple date columns if you wish. Just change the array dateColumnNames.
Honestly I wouldn't really try anything clever here, the problem is pretty straight forward.
The easiest way to do the conversion is to convert the original to a C# DateTime, and then format it again with the new style. You can use DateTime.Parse method with the format string fitting your old style, and follow it with a ToString call with a different format string.
DateTime.Parse
DateTime.ToString
DateTimeFormatInfo class -has the custom format strings
As for the general solution, I think I'd map the columns to a class with some simple properties. If memory is not an issue, then create a list of these objects from file data, format the dates, and write the objects back. I find it easier to do it this way because it's more transparent and easier to debug than complex regex statements and the like, and because it's a little more maintenance friendly.
The class would have properties mapping to columns (think of what an ORM does for a database). You can add different format options for it, and override the ToString method in creative ways, add different validation/formatting/logic rules etc.
The problem goes sort of like this then:
create a "get next token" function
grab the required number of tokens that makes up a row
pass the tokens to the class constructor, add class to list
do that until there is nothing left in the file
start a new file, or overwrite the old one
for each item in the list, call the ToString method and append the result to the file
Then if your formatting rules change, or the file format or whatever, you have a straightforward maintenance path.
Edit: For a looser schema you can use a Dictionary object in a couple of clever ways, something like this:
Get the series of tokens representing the first row. This is your mapping for column name/type and its number. You can store them in a simple array - meaning that for every line of text that you read you can look up the name - let's say ColumnArray[TokenNumber] will give you the name of the column.
For every line of text, create a Dictionary, and fill it with a series of values of the form {ColumnArray[TokenNumber], Token}. This represents your row. Add this dictionary to the list of all rows.
For every item in the list, reformat item["DDate"] to the desired value
Then write the list back to the file. First output the tokenized ColumnArray - these are your headers. Then For every row dictionary you can run a loop like this:
foreach(Dictionary<string, string> row in rowList){
foreach(string columnName in ColumnArray){
WriteToken(row[columnNmae]);
}
}
Update
I made something that's fairly generic for this purpose. Slow day today I guess :)
public class ListFormatter {
// stores transformation delegates keyed by column name (multiple keys for each column is allowed)
public List<KeyValuePair<String, Func<String, String>>> Transforms = new List<KeyValuePair<String, Func<String, String>>>();
// method for tokenizing and writing back - encapsulate file format to some extent
public Func<String, String[]> GetTokensFromLine { get; set; }
public Func<IEnumerable<String>, String> GetLineFromTokens { get; set; }
public String ReservedColumnNameAnyColumn = String.Empty;
public String ReservedColumnNameWholeLine = "WholeLine";
public ListFormatter() {
// by default let's set up for '|' delimited tokens, client can overwrite however
GetTokensFromLine = s => { return s.Split('|'); };
GetLineFromTokens = l => {
var b = new StringBuilder();
for (int i = 0; i < l.Count(); i++) {
b.Append((i > 0) ? " | " + l.ElementAt(i) : l.ElementAt(i));
}
return b.ToString();
};
}
public void FormatList(StreamReader inStream, StreamWriter outStream) {
// get the column names
var columns = GetTokensFromLine(inStream.ReadLine());
// TODO - validate that every column has a name
// write he column header to the output
outStream.WriteLine(GetLineFromTokens(columns));
// iterate through the stream
while (true) {
// get a line of text, run any transforms registered to work on the whole line
var line = RunTransforms(inStream.ReadLine(), GetRowTransforms());
if (line == null) break;
// get the row of tokens TODO - validate for number of tokens
var tokens = GetTokensFromLine(line);
// run transforms on the columns
for (var i = 0; i < tokens.Count(); i++ ) {
tokens[i] = RunTransforms(tokens[i], GetColumnTransforms(columns[i]));
}
// write the new line to the output
outStream.WriteLine(GetLineFromTokens(tokens));
}
}
/// <summary>
/// Gets the transforms associated with a single column value
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
public IEnumerable<Func<String, String>> GetColumnTransforms(string name) {
return from kv in Transforms where kv.Key == ReservedColumnNameAnyColumn || kv.Key == name select kv.Value;
}
/// <summary>
/// Gets the transforms associated with the whole row
/// </summary>
/// <returns></returns>
public IEnumerable<Func<String, String>> GetRowTransforms() {
return from kv in Transforms where kv.Key == ReservedColumnNameWholeLine select kv.Value;
}
/// <summary>
/// Runs the transforms on a string
/// </summary>
/// <param name="item">The item.</param>
/// <param name="transformList">The transform list.</param>
/// <returns></returns>
public string RunTransforms(string item, IEnumerable<Func<String, String>> transformList) {
if (item != null) {
foreach (var func in transformList) {
item = func(item);
}
}
return item;
}
}
// usage example
public void FormatList() {
var formatter = new ListFormatter();
// add some rules
// formats every line of text
formatter.Transforms.Add(new KeyValuePair<string, Func<string, string>>(formatter.ReservedColumnNameWholeLine, s => s.Trim()));
// format every column entry
formatter.Transforms.Add(new KeyValuePair<string, Func<string, string>>(formatter.ReservedColumnNameAnyColumn, s => s.Trim()));
// format that date
formatter.Transforms.Add(new KeyValuePair<string, Func<string, string>>("DDate", s => DateTime.ParseExact(s, "oldformat", CultureInfo.InvariantCulture).ToString("newformat")));
// format
using (var reader = File.OpenText("infile"))
using(var outputStream = new StreamWriter(File.OpenWrite("outfile"))) {
formatter.FormatList(reader, outputStream);
}
}
Allows you to add arbitrary number of rules for a specific column, all columns, and whole line of text. Uses your delimiter characters by default, but can be overridden however. The actual formatter class works on streams, so any buffer and file management stuff is left up to the client.
The idea is to encapsulate the core functionality into something simple and reusable. So, for example, to add you other text replacements you simply add another rule that works on the whole line of text, or every column value separately, whichever fits the situation. The actual rules are separate from the formatting process and can be tested individually. Here is how you could configure your other replacements:
formatter.Transforms.Add(new KeyValuePair<string, Func<string, string>>(formatter.ReservedColumnNameWholeLine, s => {
// Make other replacements.
s = s.Replace(#"BegAtt|EndAtt", "BegAtt#|EndAtt#");
s = s.Replace(#"Cc|*RFP", "CC|RFP");
s = s.Replace(#"<swme> ", string.Empty);
s = s.Replace(#" </swme>", ";");
return s;
}));