We Keep Coding

Get first paragraph found from string containing exact matching word [duplicate]

In C#, I want to use a regular expression to match any of these words:
string keywords = "(shoes|shirt|pants)";
I want to find the whole words in the content string. I thought this regex would do that:
if (Regex.Match(content, keywords + "\\s+",
RegexOptions.Singleline | RegexOptions.IgnoreCase).Success)
{
//matched
}
but it returns true for words like participants, even though I only want the whole word pants.
How do I match only those literal words?

You should add the word delimiter to your regex:
\b(shoes|shirt|pants)\b
In code:
Regex.Match(content, #"\b(shoes|shirt|pants)\b");

Try
Regex.Match(content, #"\b" + keywords + #"\b", RegexOptions.Singleline | RegexOptions.IgnoreCase)
\b matches on word boundaries. See here for more details.

You need a zero-width assertion on either side that the characters before or after the word are not part of the word:
(?=(\W|^))(shoes|shirt|pants)(?!(\W|$))
As others suggested, I think \b will work instead of (?=(\W|^)) and (?!(\W|$)) even when the word is at the beginning or end of the input string, but I'm not sure.

put a word boundary on it using the \b metasequence.

.net regex match line

Why does ^.*$ does not match a line in:
This is some sample text
this is another line
this is the third line
how can I create a regular expression that will match an entire line so that when finding the next match it will return me the next line.
In other words I will like to have a regex so that the first match = This is some sample text , next match = this is another line etc...

^ and $ match on the entire input sequence. You need to use the Multiline Regex option to match individual lines within the text.
Regex rgMatchLines = new Regex ( #"^.*$", RegexOptions.Multiline);
See here for an explanation of the regex options. Here's what it says about the Multiline option:
Multiline mode. Changes the meaning of ^ and $ so they match at the
beginning and end, respectively, of any line, and not just the
beginning and end of the entire string.

use regex options
Regex regex = new Regex("^.*$", RegexOptions.Multiline);

You have to enable RegexOptions.Multiline to make ^ and $ matches the start and end of line. Otherwise, ^ and $ will match the start and end of the whole input string.

Regex to match full lines of text excluding crlf

How would a regex pattern to match each line of a given text be?
I'm trying ^(.+)$ but it includes crlf...

Just use RegexOptions.Multiline.
Multiline mode. Changes the meaning of
^ and $ so they match at the beginning
and end, respectively, of any line,
and not just the beginning and end of
the entire string.
Example:
var lineMatches = Regex.Matches("Multi\r\nlines", "^(.+)$", RegexOptions.Multiline);

I'm not sure what you mean by "match each line of a given text" means, but you can use a character class to exclude the CR and LF characters:
[^\r\n]+

The wording of your question seems a little unclear, but it sounds like you want RegexOptions.Multiline (in the System.Text.RegularExpressions namespace). It's an option you have to set on your RegEx object. That should make ^ and $ match the beginning and end of a line rather than the entire string.
For example:
Regex re = new Regex("^(.+)$", RegexOptions.Compiled | RegexOptions.Multiline);

Have you tried:
^(.+)\r?\n$
That way the match group includes everything except the CRLF, and requires that a new line be present (Unix default), but accepts the carriage return in front (Windows default).

I assume you're using the Multiline option? In that case you'll want to match the newline explicitly with "\n". (substitute "\r\n" as appropriate.)

Why is my C# Regular Expression not matcing between lines?

I have the following Regex in C#:
Regex h1Separator = new Regex(#"<h1>(?'name'[\w\d\s]+?)(<br\s?/?>)?</h1>", RegexOptions.Singleline);
Trying to match a string that looks like this:
<h1>test content<br>
</h1>
right now it matches strings that look like the following:
<h1>test content<br></h1>
<h1>test content</h1>
What am I doing wrong? Should I be matching for a newline character? If so, what is it in C#? I can't find one.

You don't check for whitespace between the end of the br tag and the start of the next tag, so it expects to see the hr tag immediately after. Add a \s* in between to allow that.

You have it defined as a single line regex, see the RegexOptions.Singleline flag :) use RegexOptions.Multiline

The newline character in C# is: \n. However, I am not skilled in regex and couldn't tell you what would happen if there was a newline in a regex expression.

you can either add a dot . to your string before the ending </h1> and keep the RegexOptions.Singleline option, or change it to RegexOptions.Multiline and add a $ to the regex before the </h1>. details here

Use the Multiline flag. (Edit to address my mispeaking about the .Net platform).
Singleline mode treats the entire string you are passing in as one entry. Therefore ^ and $ represent the entire string and not the beginning and ending of a line within the string. Example <h1>(?'name'[\w\d\s]+?)(<br\s?/?>)?</h1> will match this:
<h1>test content<br></h1>
Multiline mode changes the meaning of ^ and $ to the beginning and ending of each line within the string (i.e. they will look at every line break).
Regex h1Separator = new Regex(#"<h1>(?'name'[\w\d\s]+?)$(<br\s?/?>)?</h1>", RegexOptions.Multiline);
will match the desired pattern:
<h1>test content<br>
</h1>
In short, you need to tell the regex parser you expect to work with multiple lines. It helps to have a regex designer that speaks your dialect of regex. There are many.

Regex that matches a newline (\n) in C#

OK, this one is driving me nuts....
I have a string that is formed thus:
var newContent = string.Format("({0})\n{1}", stripped_content, reply)
newContent will display like:
(old text)
new text
I need a regular expression that strips away the text between parentheses with the parenthesis included AND the newline character.
The best I can come up with is:
const string regex = #"^(\(.*\)\s)?(?<capture>.*)";
var match= Regex.Match(original_content, regex);
var stripped_content = match.Groups["capture"].Value;
This works, but I want specifically to match the newline (\n), not any whitespace (\s)
Replacing \s with \n \\n or \\\n does NOT work.
Please help me hold on to my sanity!
EDIT: an example:
public string Reply(string old,string neww)
{
const string regex = #"^(\(.*\)\s)?(?<capture>.*)";
var match= Regex.Match(old, regex);
var stripped_content = match.Groups["capture"].Value;
var result= string.Format("({0})\n{1}", stripped_content, neww);
return result;
}
Reply("(messageOne)\nmessageTwo","messageThree") returns :
(messageTwo)
messageThree

If you specify RegexOptions.Multiline then you can use ^ and $ to match the start and end of a line, respectively.
If you don't wish to use this option, remember that a new line may be any one of the following: \n, \r, \r\n, so instead of looking only for \n, you should perhaps use something like: [\n\r]+, or more exactly: (\n|\r|\r\n).

Actually it works but with opposite option i.e.
RegexOptions.Singleline

You are probably going to have a \r before your \n. Try replacing the \s with (\r\n).

Think I may be a bit late to the party, but still hope this helps.
I needed to get multiple tokens between two hash signs.
Example i/p:
## token1 ##
## token2 ##
## token3_a
token3_b
token3_c ##
This seemed to work in my case:
var matches = Regex.Matches (mytext, "##(.*?)##", RegexOptions.Singleline);
Of course, you may want to replace the double hash signs at both ends with your own chars.
HTH.

Counter-intuitive as it is, you can use both Multiline and Singleline option.
Regex.Match(input, #"(.+)^(.*)", RegexOptions.Multiline | RegexOptions.Singleline)
First capturing group will contain first line (including \r and \n) and second group will have second line.
Why:
First of all RegexOptions enum is flag so it can be combined with bitwise operators, then
Multiline:
^ and $ match the beginning and end of each line (instead of the beginning and end of the input string).
Singleline:
The period (.) matches every character (instead of every character except \n)
see docs