c# open a pdf file : Delete pages from pdf document software application project winforms windows asp.net UWP theword17-part1317

Sk    Modifier symbol
Sm    Mathematical symbol
So    Other symbol
Z     Separator
Zl    Line separator
Zp    Paragraph separator
Zs    Space separator
Extended properties such as "Greek" or "InMusicalSymbols" are not supported by PCRE.
Specifying caseless matching does not affect these escape sequences. For example, \p{Lu} always
matches only upper case letters.
The \X escape matches any number of Unicode characters that form an extended Unicode sequence. \X is
equivalent to
That is, it matches a character without the "mark" property, followed by zero or more characters with the
"mark" property, and treats the sequence as an atomic group (see below).
Characters with the "mark"
property are typically accents that affect the preceding character.
Matching characters by Unicode property is not fast, because PCRE has to search a structure that
contains data for over fifteen thousand characters. That is why the traditional escape sequences such
as \d and \w do not use Unicode properties in PCRE.
Simple assertions
The fourth use of backslash is for certain simple assertions. An assertion specifies a condition that has to
be met at a particular point in a match, without consuming any characters from the subject string. The use
of subpatterns for more complicated assertions is described below.
The backslashed assertions are:
\b     matches at a word boundary
\B     matches when not at a word boundary
\A     matches at start of subject
\Z     matches at end of subject or before newline at end
\z     matches at end of subject
\G     matches at first matching position in subject
These assertions may not appear in character classes (but note that \b has a different meaning, namely
the backspace character, inside a character class).
A word boundary is a position in the subject string where the current character and the previous
character do not both match \w or \W (i.e. one matches \w and the other matches \W), or the start or end
of the string if the first or last character matches \w, respectively.
The \A, \Z, and \z assertions differ from the traditional circumflex and dollar (described in the next
Delete pages from pdf document - remove PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provides Users with Mature Document Manipulating Function for Deleting PDF Pages
delete page on pdf; delete pages out of a pdf
Delete pages from pdf document - VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Visual Basic Sample Codes to Delete PDF Document Page in .NET
delete pages on pdf online; acrobat extract pages from pdf
section) in that they only ever match at the very start and end of the subject string, whatever options are
set. Thus, they are independent of multiline mode. These three assertions are not affected by the
PCRE_NOTBOL or PCRE_NOTEOL options, which affect only the behaviour of the circumflex and dollar
metacharacters. However, if the startoffset argument of pcre_exec() is non-zero, indicating that matching
is to start at a point other than the beginning of the subject, \A can never match. The difference
between \Z and \z is that \Z matches before a newline that is the last character of the string as well as at
the end of the string, whereas \z matches only at the end.
The \G assertion is true only when the current matching position is at the start point of the match, as
specified by the startoffset argument of pcre_exec(). It differs from \A when the value of startoffset is non-
zero. By calling pcre_exec() multiple times with appropriate arguments, you can mimic Perl's /g option,
and it is in this kind of implementation where \G can be useful.
Note, however, that PCRE's interpretation of \G, as the start of the current match, is subtly different from
Perl's, which defines it as the end of the previous match. In Perl, these can be different when the
previously matched string was empty. Because PCRE does just one match at a time, it cannot reproduce
this behaviour.
If all the alternatives of a pattern begin with \G, the expression is anchored to the starting match position,
and the "anchored" flag is set in the compiled regular expression.
Outside a character class, in the default matching mode, the circumflex character is an assertion that is
true only if the current matching point is at the start of the subject string. If the startoffset argument of
pcre_exec() is non-zero, circumflex can never match if the PCRE_MULTILINE option is unset. Inside a
character class, circumflex has an entirely different meaning (see below).
Circumflex need not be the first character of the pattern if a number of alternatives are involved, but it
should be the first thing in each alternative in which it appears if the pattern is ever to match that branch.
If all possible alternatives start with a circumflex, that is, if the pattern is constrained to match only at the
start of the subject, it is said to be an "anchored" pattern. (There are also other constructs that can cause
a pattern to be anchored.)
A dollar character is an assertion that is true only if the current matching point is at the end of the subject
string, or immediately before a newline character that is the last character in the string (by default). Dollar
need not be the last character of the pattern if a number of alternatives are involved, but it should be the
last item in any branch in which it appears. Dollar has no special meaning in a character class.
The meaning of dollar can be changed so that it matches only at the very end of the string, by setting the
PCRE_DOLLAR_ENDONLY option at compile time. This does not affect the \Z assertion.
The meanings of the circumflex and dollar characters are changed if the PCRE_MULTILINE option is set.
When this is the case, they match immediately after and immediately before an internal newline character,
respectively, in addition to matching at the start and end of the subject string. For example, the pattern /
^abc$/ matches the subject string "def\nabc" (where \n represents a newline character) in multiline mode,
but not otherwise. Consequently, patterns that are anchored in single line mode because all branches
start with ^ are not anchored in multiline mode, and a match for circumflex is possible when the startoffset
argument of pcre_exec() is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE
C# PDF Page Insert Library: insert pages into PDF file in C#.net
how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C# .NET, how to reorganize PDF document pages and how
delete page pdf file reader; acrobat export pages from pdf
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Page Process. File: Merge, Append PDF Files. File: Split PDF Document. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing
delete pages from a pdf reader; delete page in pdf document
is set.
Note that the sequences \A, \Z, and \z can be used to match the start and end of the subject in both
modes, and if all branches of a pattern start with \A it is always anchored, whether PCRE_MULTILINE is set
or not.
Outside a character class, a dot in the pattern matches any one character in the subject, including a non-
printing character, but not (by default) newline. In UTF-8 mode, a dot matches any UTF-8 character, which
might be more than one byte long, except (by default) newline. If the PCRE_DOTALL option is set, dots
match newlines as well. The handling of dot is entirely independent of the handling of circumflex and
dollar, the only relationship being that they both involve newline characters. Dot has no special meaning
in a character class.
Outside a character class, the escape sequence \C matches any one byte, both in and out of UTF-8 mode.
Unlike a dot, it can match a newline. The feature is provided in Perl in order to match individual bytes in
UTF-8 mode. Because it breaks up UTF-8 characters into individual bytes, what remains in the string may
be a malformed UTF-8 string. For this reason, the \C escape sequence is best avoided.
PCRE does not allow \C to appear in lookbehind assertions (described below),
because in UTF-8 mode
this would make it impossible to calculate the length of the lookbehind.
An opening square bracket introduces a character class, terminated by a closing square bracket. A
closing square bracket on its own is not special. If a closing square bracket is required as a member of
the class, it should be the first data character in the class (after an initial circumflex, if present) or escaped
with a backslash.
A character class matches a single character in the subject. In UTF-8 mode, the character may occupy
more than one byte. A matched character must be in the set of characters defined by the class, unless the
first character in the class definition is a circumflex, in which case the subject character must not be in the
set defined by the class. If a circumflex is actually required as a member of the class, ensure it is not the
first character, or escape it with a backslash.
For example, the character class [aeiou] matches any lower case vowel, while [^aeiou] matches any
character that is not a lower case vowel. Note that a circumflex is just a convenient notation for specifying
the characters that are in the class by enumerating those that are not. A class that starts with a circumflex
is not an assertion: it still consumes a character from the subject string, and therefore it fails if the current
pointer is at the end of the string.
In UTF-8 mode, characters with values greater than 255 can be included in a class as a literal string of
bytes, or by using the \x{ escaping mechanism.
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Able to add and insert one or multiple pages to existing adobe PDF document in VB.NET. Add and Insert Multiple PDF Pages to PDF Document Using VB.
delete pages from pdf online; delete pages from a pdf
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Create the new document with 3 pages. String outputFilePath = Program.RootPath + "\\" Output.pdf"; newDoc.Save(outputFilePath);
delete pdf page acrobat; delete page from pdf document
When caseless matching is set, any letters in a class represent both their upper case and lower case
versions, so for example, a caseless [aeiou] matches "A" as well as "a", and a caseless [^aeiou] does not
match "A", whereas a caseful version would. When running in UTF-8 mode, PCRE supports the concept of
case for characters with values greater than 128 only when it is compiled with Unicode property support.
The newline character is never treated in any special way in character classes, whatever the setting of the
PCRE_DOTALL or PCRE_MULTILINE options is. A class such as [^a] will always match a newline.
The minus (hyphen) character can be used to specify a range of characters in a character class. For
example, [d-m] matches any letter between d and m, inclusive. If a minus character is required in a class, it
must be escaped with a backslash or appear in a position where it cannot be interpreted as indicating a
range, typically as the first or last character in the class.
It is not possible to have the literal character "]" as the end character of a range. A pattern such as [W-]
46] is interpreted as a class of two characters ("W" and "-") followed by a literal string "46]", so it would
match "W46]" or "-46]". However, if the "]" is escaped with a backslash it is interpreted as the end of
range, so [W-\]46] is interpreted as a class containing a range followed by two other characters. The octal
or hexadecimal representation of "]" can also be used to end a range.
Ranges operate in the collating sequence of character values. They can also be used for characters
specified numerically, for example [\000-\037]. In UTF-8 mode, ranges can include characters whose
values are greater than 255, for example [\x{100}-\x{2ff}].
If a range that includes letters is used when caseless matching is set, it matches the letters in either case.
For example, [W-c] is equivalent to [][\\^_`wxyzabc], matched caselessly, and in non-UTF-8 mode, if
character tables for the "fr_FR" locale are in use, [\xc8-\xcb] matches accented E characters in both cases.
In UTF-8 mode, PCRE supports the concept of case for characters with values greater than 128 only when
it is compiled with Unicode property support.
The character types \d, \D, \p, \P, \s, \S, \w, and \W may also appear in a character class, and add the
characters that they match to the class. For example, [\dABCDEF] matches any hexadecimal digit. A
circumflex can conveniently be used with the upper case character types to specify a more restricted set
of characters than the matching lower case type. For example, the class [^\W_] matches any letter or digit,
but not underscore.
The only metacharacters that are recognized in character classes are backslash, hyphen (only where it can
be interpreted as specifying a range), circumflex (only at the start), opening square bracket (only when it
can be interpreted as introducing a POSIX class name - see the next section), and the terminating closing
square bracket. However, escaping other non-alphanumeric characters does no harm.
Perl supports the POSIX notation for character classes. This uses names enclosed by [: and :] within the
enclosing square brackets. PCRE also supports this notation. For example,
matches "0", "1", any alphabetic character, or "%". The supported class names are
alnum    letters and digits
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
' Create the new document with 3 pages. Dim outputFilePath As String = Program.RootPath + "\\" Output.pdf" newDoc.Save(outputFilePath).
delete blank pages in pdf; delete pages from a pdf document
C# Word - Delete Word Document Page in C#.NET
Delete Consecutive Pages from Word in C#. How to delete a range of pages from a Word document. How to delete several defined pages from a Word document.
delete page pdf file; cut pages from pdf preview
alpha    letters
ascii    character codes 0 - 127
blank    space or tab only
cntrl    control characters
digit    decimal digits (same as \d)
graph    printing characters, excluding space
lower    lower case letters
print    printing characters, including space
punct    printing characters, excluding letters and digits
space    white space (not quite the same as \s)
upper    upper case letters
word     "word" characters (same as \w)
xdigit   hexadecimal digits
The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13), and space (32). Notice that this list
includes the VT character (code 11). This makes "space" different to \s, which does not include VT (for Perl
The name "word" is a Perl extension, and "blank" is a GNU extension from Perl 5.8. Another Perl extension
is negation, which is indicated by a ^ character after the colon. For example,
matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the POSIX syntax [.ch.] and [=ch=]
where "ch" is a "collating element", but these are not supported, and an error is given if they are
In UTF-8 mode, characters with values greater than 128 do not match any of the POSIX character classes.
Vertical bar characters are used to separate alternative patterns. For example, the pattern
matches either "gilbert" or "sullivan". Any number of alternatives may appear, and an empty alternative is
permitted (matching the empty string). The matching process tries each alternative in turn, from left to
right, and the first one that succeeds is used. If the alternatives are within a subpattern (defined below),
"succeeds" means matching the rest of the main pattern as well as the alternative in the subpattern.
be changed from within the pattern by a sequence of Perl option letters enclosed between "(?" and ")".
The option letters are
C# PDF metadata Library: add, remove, update PDF metadata in C#.
C#.NET PDF SDK - Edit PDF Document Metadata in C#.NET. Allow C# Developers to Read, Add, Edit, Update and Delete PDF Metadata in .NET Project.
copy pages from pdf to word; delete page from pdf online
C# PowerPoint - Delete PowerPoint Document Page in C#.NET
C#. How to delete a range of pages from a PowerPoint document. C#. How to delete several defined pages from a PowerPoint document.
delete pages of pdf online; delete pages in pdf
For example, (?im) sets caseless, multiline matching. It is also possible to unset these options by
preceding the letter with a hyphen, and a combined setting and unsetting such as (?im-sx), which sets
permitted. If a letter appears both before and after the hyphen, the option is unset.
When an option change occurs at top level (that is, not inside subpattern parentheses), the change
applies to the remainder of the pattern that follows. If the change is placed right at the start of a pattern,
PCRE extracts it into the global options (and it will therefore show up in data extracted by the 
pcre_fullinfo() function).
An option change within a subpattern affects only that part of the current pattern that follows it, so
matches abc and aBc and no other strings (assuming PCRE_CASELESS is not used). By this means, options
can be made to have different settings in different parts of the pattern. Any changes made in one
alternative do carry on into subsequent branches within the same subpattern. For example,
matches "ab", "aB", "c", and "C", even though when matching "C" the first branch is abandoned before the
option setting. This is because the effects of option settings happen at compile time. There would be
some very weird behaviour otherwise.
The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed in the same way as the
Perl-compatible options by using the characters U and X respectively. The (?X) flag setting is special in
that it must always occur earlier in the pattern than any of the additional features it turns on, even when it
is at top level. It is best to put it at the start.
Subpatterns are delimited by parentheses (round brackets), which can be nested. Turning part of a
pattern into a subpattern does two things:
1. It localizes a set of alternatives. For example, the pattern
matches one of the words "cat", "cataract", or "caterpillar". Without the parentheses, it would match
"cataract", "erpillar" or the empty string.
2. It sets up the subpattern as a capturing subpattern. This means that, when the whole pattern matches,
that portion of the subject string that matched the subpattern is passed back to the caller via the ovector
argument of pcre_exec(). Opening parentheses are counted from left to right (starting from 1) to obtain
numbers for the capturing subpatterns.
For example, if the string "the red king" is matched against the pattern
the ((red|white) (king|queen))
the captured substrings are "red king", "red", and "king", and are numbered 1, 2, and 3, respectively.
The fact that plain parentheses fulfil two functions is not always helpful. There are often times when a
grouping subpattern is required without a capturing requirement. If an opening parenthesis is followed
by a question mark and a colon, the subpattern does not do any capturing, and is not counted when
computing the number of any subsequent capturing subpatterns. For example, if the string "the white
queen" is matched against the pattern
the ((?:red|white) (king|queen))
the captured substrings are "white queen" and "queen", and are numbered 1 and 2. The maximum
number of capturing subpatterns is 65535, and the maximum depth of nesting of all subpatterns, both
capturing and non-capturing, is 200.
As a convenient shorthand, if any option settings are required at the start of a non-capturing subpattern,
the option letters may appear between the "?" and the ":". Thus the two patterns
match exactly the same set of strings. Because alternative branches are tried from left to right, and
options are not reset until the end of the subpattern is reached, an option setting in one branch does
affect subsequent branches, so the above patterns match "SUNDAY" as well as "Saturday".
Identifying capturing parentheses by number is simple, but it can be very hard to keep track of the
numbers in complicated regular expressions. Furthermore, if an expression is modified, the numbers may
change. To help with this difficulty, PCRE supports the naming of subpatterns, something that Perl does
not provide. The Python syntax (?P<name>...) is used. Names consist of alphanumeric characters and
underscores, and must be unique within a pattern.
Named capturing parentheses are still allocated numbers as well as names. The PCRE API provides
function calls for extracting the name-to-number translation table from a compiled pattern. There is also
a convenience function for extracting a captured substring by name. For further details see the pcreapi
Repetition is specified by quantifiers, which can follow any of the following items:
a literal data character
the . metacharacter
the \C escape sequence
the \X escape sequence (in UTF-8 mode with Unicode properties)
an escape such as \d that matches a single character
a character class
a back reference (see next section)
a parenthesized subpattern (unless it is an assertion)
The general repetition quantifier specifies a minimum and maximum number of permitted matches, by
giving the two numbers in curly brackets (braces), separated by a comma. The numbers must be less than
65536, and the first must be less than or equal to the second. For example:
matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special character. If the second number
is omitted, but the comma is present, there is no upper limit; if the second number and the comma are
both omitted, the quantifier specifies an exact number of required matches. Thus
matches at least 3 successive vowels, but may match many more, while
matches exactly 8 digits. An opening curly bracket that appears in a position where a quantifier is not
allowed, or one that does not match the syntax of a quantifier, is taken as a literal character. For example,
{,6} is not a quantifier, but a literal string of four characters.
In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to individual bytes. Thus, for example, \x
{100}{2} matches two UTF-8 characters, each of which is represented by a two-byte sequence. Similarly,
when Unicode property support is available, \X{3} matches three Unicode extended sequences, each of
which may be several bytes long (and they may be of different lengths).
The quantifier {0} is permitted, causing the expression to behave as if the previous item and the quantifier
were not present.
For convenience (and historical compatibility) the three most common quantifiers have single-character
*    is equivalent to {0,}
+    is equivalent to {1,}
?    is equivalent to {0,1}
It is possible to construct infinite loops by following a subpattern that can match no characters with a
quantifier that has no upper limit, for example:
Earlier versions of Perl and PCRE used to give an error at compile time for such patterns. However,
because there are cases where this can be useful, such patterns are now accepted, but if any repetition of
the subpattern does in fact match no characters, the loop is forcibly broken.
By default, the quantifiers are "greedy", that is, they match as much as possible (up to the maximum
number of permitted times), without causing the rest of the pattern to fail. The classic example of where
this gives problems is in trying to match comments in C programs. These appear between /* and */ and
within the comment, individual * and / characters may appear. An attempt to match C comments by
applying the pattern
to the string
/* first comment */  not comment  /* second comment */
fails, because it matches the entire string owing to the greediness of the .* item.
However, if a quantifier is followed by a question mark, it ceases to be greedy, and instead matches the
minimum number of times possible, so the pattern
does the right thing with the C comments. The meaning of the various quantifiers is not otherwise
changed, just the preferred number of matches. Do not confuse this use of question mark with its use as
a quantifier in its own right. Because it has two uses, it can sometimes appear doubled, as in
which matches one digit by preference, but can match two if that is the only way the rest of the pattern
If the PCRE_UNGREEDY option is set (an option which is not available in Perl), the quantifiers are not
greedy by default, but individual ones can be made greedy by following them with a question mark. In
other words, it inverts the default behaviour.
When a parenthesized subpattern is quantified with a minimum repeat count that is greater than 1 or with
a limited maximum, more memory is required for the compiled pattern, in proportion to the size of the
minimum or maximum.
If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent to Perl's /s) is set, thus allowing
the . to match newlines, the pattern is implicitly anchored, because whatever follows will be tried against
every character position in the subject string, so there is no point in retrying the overall match at any
position after the first. PCRE normally treats such a pattern as though it were preceded by \A.
In cases where it is known that the subject string contains no newlines, it is worth setting PCRE_DOTALL in
order to obtain this optimization, or alternatively using ^ to indicate anchoring explicitly.
However, there is one situation where the optimization cannot be used. When .* is inside capturing
parentheses that are the subject of a backreference elsewhere in the pattern, a match at the start may fail,
and a later one succeed. Consider, for example:
If the subject is "xyz123abc123" the match point is the fourth character. For this reason, such a pattern is
not implicitly anchored.
When a capturing subpattern is repeated, the value captured is the substring that matched the final
iteration. For example, after
has matched "tweedledum tweedledee" the value of the captured substring is "tweedledee". However, if
there are nested capturing subpatterns, the corresponding captured values may have been set in
previous iterations. For example, after
matches "aba" the value of the second captured substring is "b".
With both maximizing and minimizing repetition, failure of what follows normally causes the repeated item
to be re-evaluated to see if a different number of repeats allows the rest of the pattern to match.
Sometimes it is useful to prevent this, either to change the nature of the match, or to cause it fail earlier
than it otherwise might, when the author of the pattern knows there is no point in carrying on.
Consider, for example, the pattern \d+foo when applied to the subject line
After matching all 6 digits and then failing to match "foo", the normal action of the matcher is to try again
with only 5 digits matching the \d+ item, and then with 4, and so on, before ultimately failing. "Atomic
grouping" (a term taken from Jeffrey Friedl's book) provides the means for specifying that once a
subpattern has matched, it is not to be re-evaluated in this way.
If we use atomic grouping for the previous example, the matcher would give up immediately on failing to
match "foo" the first time. The notation is a kind of special parenthesis, starting with (?> as in this
This kind of parenthesis "locks up" the part of the pattern it contains once it has matched, and a failure
further into the pattern is prevented from backtracking into it. Backtracking past it to previous items,
however, works as normal.
An alternative description is that a subpattern of this type matches the string of characters that an
identical standalone pattern would match, if anchored at the current point in the subject string.
Atomic grouping subpatterns are not capturing subpatterns. Simple cases such as the above example can
be thought of as a maximizing repeat that must swallow everything it can. So, while both \d+ and \d+?
are prepared to adjust the number of digits they match in order to make the rest of the pattern match, (?
>\d+) can only match an entire sequence of digits.
Atomic groups in general can of course contain arbitrarily complicated subpatterns, and can be nested.
However, when the subpattern for an atomic group is just a single repeated item, as in the example
above, a simpler notation, called a "possessive quantifier" can be used. This consists of an additional +
character following a quantifier. Using this notation, the previous example can be rewritten as
Possessive quantifiers are always greedy; the setting of the PCRE_UNGREEDY option is ignored. They are
a convenient notation for the simpler forms of atomic group. However, there is no difference in the
meaning or processing of a possessive quantifier and the equivalent atomic group.
The possessive quantifier syntax is an extension to the Perl syntax. It originates in Sun's Java package.
When a pattern contains an unlimited repeat inside a subpattern that can itself be repeated an unlimited
number of times, the use of an atomic group is the only way to avoid some failing matches taking a very
long time indeed. The pattern
matches an unlimited number of substrings that either consist of non-digits, or digits enclosed in <>,
followed by either ! or ?. When it matches, it runs quickly. However, if it is applied to
Documents you may be interested
Documents you may be interested