pdf viewer in asp net c# : Add image field to pdf form control software system azure windows web page console PowerGREP31-part3052

306 
«
\b\w+[^s]\b
».  When  applied  to  ´
John's
µ,  the  former will  match  „
John
µ  and  the  latter  „
John'
µ 
(including the apostrophe). I will leave it up to you to figure out why. (Hint: «
\b
» matches between the 
apostrophe and the ´
s
µ). The latter will also not match single-letter words like ´aµ or ´Iµ. The correct regex 
without  using lookbehind  is  «
\b\w*[^s\W]\b
» (star  instead  of  plus,  and  \W  in  the  character  class). 
Personally, I find the lookbehind easier to understand. The last regex, which works correctly, has a double 
negation (the \W in the negated character class). Double negations tend to be confusing to humans. Not to 
regex engines, though. 
The bad news is that most regex flavors do not allow you to use just any regex inside a lookbehind, because 
they cannot apply a regular expression backwards. Therefore, the regular expression engine needs to be able 
to figure out how many steps to step back before checking the lookbehind. 
Therefore, many regex flavors, including those used by Perl and Python, only allow fixed-length strings. You 
can use any regex of which the length of the match can be predetermined. This means you can use literal text 
and character classes. You cannot use repetition or optional items. You can use alternation, but only if all 
options in the alternation have the same length. 
PCRE is not fully Perl-compatible when it comes to lookbehind. While Perl requires alternatives inside 
lookbehind to have the same length, PCRE allows alternatives of variable length. Each alternative still has to 
be fixed-length. 
Java takes things a step further by allowing finite repetition. You still cannot use the star or plus, but you can 
use the question mark and the curly braces with the max parameter specified. Java recognizes the fact that 
finite repetition can be rewritten as an alternation of strings with different, but fixed lengths. Unfortunately, 
the JDK 1.4 and 1.5 have some bugs when you use alternation inside lookbehind. These were fixed in JDK 
1.6. 
The only regex engines that allow you to use a full regular expression inside lookbehind, including infinite 
repetition, are the JGsoft engine and the .NET framework RegEx classes. 
Finally, flavors like JavaScript, Ruby and Tcl do not support lookbehind at all, even though they do support 
lookahead. 
Lookaround Is Atomic 
The fact that lookaround is zero-width automatically makes it atomic. As soon as the lookaround condition is 
satisfied, the regex engine forgets about everything inside the lookaround. It will not backtrack inside the 
lookaround to try different permutations. 
The  only  situation  in  which  this makes  any  difference  is  when  you  use  capturing  groups  inside  the 
lookaround.  Since  the  regex  engine  does  not  backtrack  into  the lookaround,  it  will  not  try  different 
permutations of the capturing groups. 
For this reason, the regex «
(?=(\d+))\w+\1
» will never match ´
123x12
µ. First the lookaround captures 
123
µ into «
\1
». «
\w+
» then matches the whole string and backtracks until it matches only „
1
µ. Finally, «
\w+
» 
fails since «
\1
» cannot be matched at any position. Now, the regex engine has nothing to backtrack to, and 
the overall regex fails. The backtracking steps created by «
\d+
» have been discarded. It never gets to the point 
where the lookahead captures only ´
12
µ. 
Add image field to pdf form - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
add image to pdf preview; how to add an image to a pdf
Add image field to pdf form - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
how to add an image to a pdf file in acrobat; add png to pdf preview
307 
Obviously, the regex engine does try further positions in the string. If we change the subject string, the regex 
«
(?=(\d+))\w+\1
» will match „
56x56
µ in ´
456x56
µ. 
If you don’t use capturing groups inside lookaround, then all this doesn’t matter. Either the lookaround 
condition can be satisfied or it cannot be. In how many ways it can be satisfied is irrelevant. 
VB.NET PDF Form Data Read library: extract form data from PDF in
a full-featured PDF software, it should have functions for processing text, image as well DLLs: Read and Extract Field Data in VB.NET. Add necessary references:
adding images to a pdf document; add picture to pdf in preview
C# PDF Form Data Read Library: extract form data from PDF in C#.
PDF software, it should have functions for processing text, image as well as C#.NET Project DLLs: Read and Extract Field Data in C#. Add necessary references:
adding images to pdf files; add image to pdf file acrobat
308 
19. Testing The Same Part of a String for More Than One 
Requirement 
Lookaround, which I introduced in detail in the previous topic, is a very powerful concept. Unfortunately, it 
is often  underused by people new to regular  expressions, because  lookaround is a  bit confusing. The 
confusing part is that the lookaround is zero-width. So if you have a regex in which a lookahead is followed 
by another piece of regex, or a lookbehind is preceded by another piece of regex, then the regex will traverse 
part of the string twice. 
To make this clear, I would like to give you another, a bit more practical example. Let’s say we want to find a 
word that is six letters long and contains the three consecutive letters ´
cat
µ. Actually, we can match this 
without  lookaround.  We  just  specify  all  the  options  and  lump  them  together  using  alternation: 
«
cat\w{3}|\wcat\w{2}|\w{2}cat\w|\w{3}cat
». Easy enough. But this method gets unwieldy if you 
want to find any word between 6 and 12 letters long containing either ´catµ, ´dogµ or ´mouseµ. 
Lookaround to The Rescue 
In this example, we basically have two requirements for a successful match. First, we want a word that is 6 
letters long. Second, the word we found must contain the word ´catµ. 
Matching a 6-letter word is easy with «
\b\w{6}\b
». Matching a word containing ´catµ is equally easy: 
«
\b\w*cat\w*\b
». 
Combining the two, we get: «
(?=\b\w{6}\b)\b\w*cat\w*\b
» . Easy! Here’s how this works. At each 
character position in the string where the regex is attempted, the engine will first attempt the regex inside the 
positive lookahead. This sub-regex, and therefore the lookahead, matches only when the current character 
position in the string is at the start of a 6-letter word in the string. If not, the lookahead will fail, and the 
engine will continue trying the regex from the start at the next character position in the string. 
The lookahead is zero-width. So when the regex inside the lookahead has found the 6-letter word, the current 
position in the string is still at the beginning of the 6-letter word. At this position will the regex engine 
attempt the remainder of the regex. Because we already know that a 6-letter word can be matched at the 
current position, we know that «
\b
» matches and that the first «
\w*
» will match 6 times. The engine will then 
backtrack, reducing the number of characters matched by «
\w*
», until «
cat
» can be matched. If «
cat
» cannot 
be matched, the engine has no other choice but to restart at the beginning of the regex, at the next character 
position in the string. This is at the second letter in the 6-letter word we just found, where the lookahead will 
fail, causing the engine to advance character by character until the next 6-letter word. 
If «
cat
» can be successfully matched, the second «
\w*
» will consume the remaining letters, if any, in the 6-
letter word. After that, the last «
\b
» in the regex is guaranteed to match where the second «
\b
» inside the 
lookahead matched. Our double-requirement-regex has matched successfully. 
VB.NET PDF Field Edit library: insert, delete, update pdf form
By using RaterEdge .NET PDF package, you can add form fields to existing pdf files, delete or remove form field in PDF page and update PDF field in VB.NET
add photo to pdf online; acrobat add image to pdf
C# PDF Field Edit Library: insert, delete, update pdf form field
By using RaterEdge .NET PDF package, you can add form fields to existing pdf files, delete or remove form field in PDF page and update PDF field in C#
add a picture to a pdf document; adding a jpeg to a pdf
309 
Optimizing Our Solution 
While the above regex works just fine, it is not the most optimal solution. This is not a problem if you are just 
doing a search in a text editor. But optimizing things is a good idea if this regex will be used repeatedly 
and/or on large chunks of data in an application you are developing. 
You can discover these optimizations by yourself if you carefully examine the regex and follow how the regex 
engine applies it, as I did above. I said the third and last «
\b
» are guaranteed to match. Since it is zero-width, 
and therefore does not change the result  returned by the regex engine, we can remove them, leaving: 
«
(?=\b\w{6}\b)\w*cat\w*
». Though the last «
\w*
» is also guaranteed to match, we cannot remove it 
because it adds characters to the regex match. Remember that the lookahead discards its match, so it does not 
contribute to the match returned by the regex engine. If we omitted the «
\w*
», the resulting match would be 
the start of a 6-letter word containing ´catµ, up to and including ´catµ, instead of the entire word. 
But we can optimize the first «
\w*
». As it stands, it will match 6 letters and then backtrack. But we know that 
in a successful match, there can never be more than 3 letters before ´catµ. So we can optimize this to 
«
\w{0,3}
». Note that making the asterisk lazy would not have optimized this sufficiently. The lazy asterisk 
would find a successful match sooner, but if a 6-letter word does not contain ´catµ, it would still cause the 
regex engine to try matching ´catµ at the last two letters, at the last single letter, and even at one character 
beyond the 6-letter word. 
So we have «
(?=\b\w{6}\b)\w{0,3}cat\w*
». One last, minor, optimization involves the first «
\b
». Since 
it  is  zero-width  itself,  there’s  no  need  to  put  it  inside  the  lookahead.  So  the  final  regex  is: 
«
\b(?=\w{6}\b)\w{0,3}cat\w*
» . 
You could replace the final «
\w*
» with «
\w{0,3}
» too. But it wouldn’t make any difference. The lookahead 
has already checked that we’re at a 6-letter word, and «
\w{0,3}cat
» has already matched 3 to 6 letters of 
that word. Whether we end the regex with «
\w*
» or «
\w{0,3}
» doesn’t matter, because either way, we’ll be 
matching all the remaining word characters. Because the resulting match and the speed at which it is found 
are the same, we may just as well use the version that is easier to type. 
A More Complex Problem 
So, what would you use to find any word between 6 and 12 letters long containing either ´catµ, ´dogµ or 
´mouseµ?  Again  we  have  two  requirements,  which  we  can  easily  combine  using  a  lookahead:  «
\b(?=\w{6,12}\b)\w{0,9}(cat|dog|mouse)\w*
» . Very easy, once you get the hang of it. This regex 
will also put ´catµ, ´dogµ or ´mouseµ into the first backreference. 
VB.NET PDF Form Data fill-in library: auto fill-in PDF form data
PDF Page. Image: Copy, Paste, Cut Image in Page. Fill-in Field Data. Field: Insert, Delete, Update Field. Images. Redact Pages. Annotation & Drawing. Add Sticky Note
add image field to pdf form; adding images to pdf
C# PDF Form Data fill-in Library: auto fill-in PDF form data in C#
Following C# sample code can help you have a quick evaluation of it. C#.NET Demo Code: Auto Fill-in Field Data to PDF in C#.NET. Add necessary references:
add image to pdf acrobat; adding an image to a pdf
310 
20. Continuing at The End of The Previous Match 
The anchor «
\G
» matches at the position where the previous match ended. During the first match attempt, 
«
\G
» matches at the start of the string in the way «
\A
» does. 
Applying «
\G\w
» to the string ´
test string
µ matches „
t
µ. Applying it again matches „
e
µ. The 3rd attempt 
yields „
s
µ and the 4th attempt matches the second „
t
µ in the string. The fifth attempt fails. During the fifth 
attempt, the only place in the string where «
\G
» matches is after the second 
t
. But that position is not 
followed by a word character, so the match fails. 
End of The Previous Match vs. Start of The Match Attempt 
With some regex flavors or tools, «
\G
» matches at the start of the match attempt, rather than at the end of the 
previous match result. This is the case with EditPad Pro, where «
\G
» matches at the position of the text 
cursor, rather than the end of the previous match. When a match is found, EditPad Pro will select the match, 
and move the text cursor to the end of the match. The result is that «
\G
» matches at the end of the previous 
match result only when you do not move the text cursor between two searches. All in all, this makes a lot of 
sense in the context of a text editor. 
\G Magic with Perl 
In Perl, the position where the last match ended is a ´magicalµ value that is remembered separately for each 
string variable. The position is not associated with any regular expression. This means that you can use «
\G
» 
to make a regex continue in a subject string where another regex left off. 
If a match attempt fails, the stored position for «
\G
» is reset to the start of the string. To avoid this, specify 
the continuation modifier 
/c
All this is very useful to make several regular expressions work together. E.g. you could parse an HTML file 
in the following fashion: 
while ($string =~ m/</g) { 
if ($string =~ m/\GB>/c) { 
# Bold
} elsif ($string =~ m/\GI>/c) { 
# Italics
} else { 
# ...etc...
}
The regex in the while loop searches for the tag’s opening bracket, and the regexes inside the loop check 
which tag we found. This way you can parse the tags in the file in the order they appear in the file, without 
having to write a single big regex that matches all tags you are interested in. 
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Scan image to PDF, tiff and various image formats. Get image information, such as its location, zonal information Able to edit, add, delete, move, and output PDF
acrobat insert image into pdf; add picture to pdf online
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
multiple types of image from PDF file in VB.NET, like XObject Image, XObject Form, Inline Image DLLs for PDF Image Extraction in VB.NET. Add necessary references
how to add a photo to a pdf document; add photo to pdf
311 
\G in Other Programming Languages 
This flexibility is not available with most other programming languages. E.g. in Java, the position for «
\G
» is 
remembered by the Matcher object. The Matcher is strictly associated with a single regular expression and a 
single subject string. What you can do though is to add a line of code to make the match attempt of the 
second Matcher start where the match of the first Matcher ended. «
\G
» will then match at this position. 
The «
\G
» token is supported by the JGsoft engine, .NET, Java, Perl and PCRE. 
312 
21. If-Then-Else Conditionals in Regular Expressions 
A special construct «
(?ifthen|else)
» allows you to create conditional regular expressions. If the if part 
evaluates to true, then the regex engine will attempt to match the then part. Otherwise, the else part is 
attempted instead. The syntax consists of a pair of round brackets. The opening bracket must be followed by 
a question mark, immediately followed by the if part, immediately followed by the then part. This part can be 
followed by a vertical bar and the else part. You may omit the else part, and the vertical bar with it. 
For the if part, you can use the lookahead and lookbehind constructs. Using positive lookahead, the syntax 
becomes «
(?(?=regex)then|else)
». Because the lookahead has its own parentheses, the if and then parts 
are clearly separated. 
Remember that the lookaround constructs do not consume any characters. If you use a lookahead as the if 
part, then the regex engine will attempt to match the then or else part (depending on the outcome of the 
lookahead) at the same position where the if was attempted. 
Alternatively, you can check in the if part whether a capturing group has taken part in the match thus far. 
Place the number of the capturing group inside round brackets, and use that as the if part. Note that although 
the syntax for a conditional check on a backreference is the same as a number inside a capturing group, no 
capturing group is created. The number and the brackets are part of the if-then-else syntax started with «
(?
». 
For the then and else, you can use any regular expression. If you want to use alternation, you will have to group 
the 
then 
or 
else 
together 
using 
parentheses, 
like 
in 
«
(?(?=condition)(then1|then2|then3)|(else1|else2|else3))
». Otherwise, there is no need to 
use parentheses around the then and else parts. 
Looking Inside the Regex Engine 
The regex «
(a)?b(?(1)c|d)
» matches „
bd
µ and „
abc
µ. It does not match ´
bc
µ, but does match „
bd
µ in 
´
abd
µ. Let’s see how this regular expression works on each of these four subject strings. 
When applied to ´
bd
µ, «
a
» fails to match. Since the capturing group containing «
a
» is optional, the engine 
continues with «
b
» at the start of the subject string. Since the whole group was optional, the group did not 
take part in the match. Any subsequent backreference to it like «
\1
» will fail. Note that «
(a)?
» is very 
different from «
(a?)
». In the former regex, the capturing group does not take part in the match if «
a
» fails, 
and backreferences to the group will fail. In the latter group, the capturing group always takes part in the 
match, capturing either „
a
µ or nothing. Backreferences to a capturing group that took part in the match and 
captured nothing always succeed. Conditionals evaluating such groups execute the ´thenµ part. In short: if 
you want to use a reference to a group in a conditional, use «
(a)?
» instead of «
(a?)
». 
Continuing with our regex, «
b
» matches „
b
µ. The regex engine now evaluates the conditional. The first 
capturing group did not take part in the match at all, so the ´elseµ part or «
d
» is attempted. «
d
» matches „
d
µ 
and an overall match is found. 
Moving on to our second subject string ´
abc
µ, «
a
» matches „
a
µ, which is captured by the capturing group. 
Subsequently, «
b
» matches „
b
µ. The regex engine again evaluates the conditional. The capturing group took 
part in the match, so the ´thenµ part or «
c
» is attempted. «
c
» matches „
c
µ and an overall match is found. 
313 
Our third subject ´
bc
µ does not start with ´
a
µ, so the capturing group does not take part in the match 
attempt, like we saw with the first subject string. «
b
» still matches „
b
µ, and the engine moves on to the 
conditional. The first capturing group did not take part in the match at all, so the ´elseµ part or «
d
» is 
attempted. «
d
» does not match ´
c
µ and the match attempt at the start of the string fails. The engine does try 
again starting at the second character in the string, but fails since «
b
» does not match ´
c
µ. 
The fourth subject ´
abd
µ is the most interesting one. Like in the second string, the capturing group grabs the 
a
µ and the «
b
» matches. The capturing group took part in the match, so the ´thenµ part or «
c
» is attempted. 
«
c
» fails to match ´
d
µ, and the match attempt fails. Note that the ´elseµ part is not attempted at this point. 
The capturing group took part in the match, so only the ´thenµ part is used. However, the regex engine isn’t 
done yet. It will restart the regular expression from the beginning, moving ahead one character in the subject 
string. 
Starting at the second character in the string, «
a
» fails to match ´
b
µ. The capturing group does not take part 
in the second match attempt which started at the second character in the string. The regex engine moves 
beyond the optional group, and attempts «
b
», which matches. The regex engine now arrives at the conditional 
in the regex, and at the third character in the subject string. The first capturing group did not take part in the 
current match attempt, so the ´elseµ part or «
d
» is attempted. «
d
» matches „
d
µ and an overall match „
bd
µ is 
found. 
If you want to avoid this last match result, you need to use anchors. «
^(a)?b(?(1)c|d)$
» does not find any 
matches in the last subject string. The caret will fail to match at the second and third characters in the string. 
Regex Flavors 
Conditionals are supported by the JGsoft engine, Perl, PCRE and the .NET framework. All these flavors, 
except Perl, also support named capturing groups. They allow you to use the name of a capturing group 
instead of its number as the if test, e.g.: «
(?<test>a)?b(?(test)c|d)
». 
Python  supports  conditionals  using  a  numbered or named  capturing  group. Python  does  not  support 
conditionals using lookaround, even though Python does support lookaround outside conditionals. Instead of 
 conditional  like  «
(?(?=regex)then|else)
»,  you  can  alternate  two  opposite  lookarounds: 
«
(?=regex)then|(?!regex)else)
». 
Example: Extract Email Headers 
The regex «
^((From|To)|Subject):  ((?(2)\w+@\w+\.[a-z]+|.+))
»  extracts the  From,  To, and 
Subject headers from an email message. The name of the header is captured into the first backreference. If 
the header is the From or To header, it is captured into the second backreference as well. 
The second part of the pattern is the if-then-else conditional «
(?(2)\w+@\w+\.[a-z]+|.+))
». The if part 
checks whether the second capturing group took part in the match thus far. It will have taken part if the 
header is the From or To header. In that case, the then part of the conditional «
\w+@\w+\.[a-z]+
» tries to 
match an email address. To keep the example simple, we use an overly simple regex to match the email 
address, and we don’t try to match the display name that is usually also part of the From or To header. 
314 
If the second capturing group did not participate in the match this far, the else part «
.+
» is attempted instead. 
This simply matches the remainder of the line, allowing for any test subject. 
Finally, we place an extra pair of round brackets around the conditional. This captures the contents of the 
email header matched by the conditional into the third backreference. The conditional itself does not capture 
anything. When implementing this regular expression, the first capturing group will store the name of the 
header (´Fromµ, ´Toµ, or ´Subjectµ), and the third capturing group will store the value of the header. 
You  could try  to match  even more  headers by  putting  another conditional  into  the ´elseµ  part. E.g. 
«
^((From|To)|(Date)|Subject): 
((?(2)\w+@\w+\.[a-z]+|(?(3)mm/dd/yyyy|.+))
»  would 
match a ´Fromµ, ´Toµ, ´Dateµ or ´Subjectµ, and use the regex «
mm/dd/yyyy
» to check whether the date is 
valid. Obviously, the date validation regex is just a dummy to keep the example simple. The header is 
captured in the first group, and its validated contents in the fourth group. 
As you can see, regular expressions using conditionals quickly become unwieldy. I recommend that you only 
use them if one regular expression is all your tool allows you to use. When programming, you’re far better of 
using the regex «
^(From|To|Date|Subject): (.+)
» to capture one header with its unvalidated contents. 
In your source code, check the name of the header returned in the first capturing group, and then use a 
second regular expression to validate the contents of the header returned in the second capturing group of 
the first regex. Though you’ll have to write a few lines of extra code, this code will be much easier to 
understand and maintain. If you precompile all the regular expressions, using multiple regular expressions will 
be just as fast, if not faster, than the one big regex stuffed with conditionals. 
315 
22. XML Schema Character Classes 
XML Schema Regular Expressions support the usual six shorthand character classes, plus four more. These 
four aren’t supported by any other regular expression flavor. «
\i
» matches any character that may be the first 
character of an XML name, i.e. «
[_:A-Za-z]
». «
\c
» matches any character that may occur after the first 
character in an XML name, i.e. «
[-._:A-Za-z0-9]
». «
\I
» and «
\C
» are the respective negated shorthands. 
Note that the «
\c
» shorthand syntax conflicts with the control character syntax used in many other regex 
flavors. 
You can use these four shorthands both inside and outside character classes using the bracket notation. 
They’re very useful for validating XML references and values in your XML schemas. The regular expression 
«
\i\c*
» matches an XML name like „
xml:schema
µ. In other regular expression flavors, you’d have to spell 
this out as «
[_:A-Za-z][-._:A-Za-z0-9]*
». The latter regex also works with XML’s regular expression 
flavor. It just takes more time to type in. 
The regex «
<\i\c*\s*>
» matches an opening XML tag without any attributes. «
</\i\c*\s*>
» matches any 
closing tag. «
<\i\c*(\s+\i\c*\s*=\s*("[^"]*"|'[^']*'))*\s*>
» matches an opening tag with any 
number 
of 
attributes. 
Putting 
it 
all 
together, 
«
<(\i\c*(\s+\i\c*\s*=\s*("[^"]*"|'[^']*'))*|/\i\c*)\s*>
» matches either an opening tag with 
attributes or a closing tag. 
Character Class Subtraction 
While the regex flavor it defines is quite limited, the XML Schema adds a new regular expression feature not 
previously seen in any (popular) regular expression flavor: character class subtraction. Currently, this feature is 
only supported by the JGsoft and .NET regex engines (in addition to those implementing the XML Schema 
standard). 
Character class subtraction makes it easy to match any single character present in one list (the character class), 
but not present in another list (the subtracted class). The syntax for this is 
[class-[subtract]]
. If the 
character after  a hyphen is  an  opening bracket, XML  regular expressions interpret the  hyphen as the 
subtraction operator rather than the range operator. E.g. «
[a-z-[aeiuo]]
» matches a single letter that is not 
a vowel (i.e. a single consonant). Without the character class subtraction feature, the only way to do this 
would be to list all consonants: «
[b-df-hj-np-tv-z]
». 
This feature is more than just a notational convenience, though. You can use the full character class syntax 
within the subtracted character class. E.g. to match all Unicode letters except ASCII letters (i.e. all non-
English letters), you could easily use «
[\p{L}-[\p{IsBasicLatin}]]
». 
Nested Character Class Subtraction 
Since you can use the full character class syntax within the subtracted character class, you can subtract a class 
from the class being subtracted. E.g. «
[0-9-[0-6-[0-3]]]
» first subtracts 
0-3
from 
0-6
, yielding «
[0-9-
[4-6]]
», or «
[0-37-9]
», which matches any character in the string ´
0123789
µ. 
The class subtraction must always be the last element in the character class. 
[0-9-[4-6]a-f]
is not a valid 
regular expression. It should be rewritten as «
[0-9a-f-[4-6]]
». The subtraction works on the whole class. 
Documents you may be interested
Documents you may be interested