c# pdf viewer itextsharp : Move pages in pdf SDK control project winforms web page .net UWP Windows%20Powershell%20in%20Action%202nd%20Edition69-part1526

660
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
release of PowerShell. When these features are largely subsumed by the newer debug-
ger, there are still scenarios like debugging remote scripts where they’re useful.
In our work with the debugger, we started by looking at how the debugger is inte-
grated into the 
ISE
and uses the same command-key bindings as the Visual Studio 
debugger. You saw how to set breakpoints, look at variables, and step through code.
Finally we ended the chapter by covering the command-line debugger. It offers a 
superset of the graphical debugger features, including the ability to have conditional 
breakpoints  and  breakpoints  on  variables  where  they’re  read  or  set.  We  also 
explained some of the limitations in the debugger as shipped in v2.
This chapter concludes the first part of book. In part 1 of Windows PowerShell in 
Action, our focus was on exploring the features of the PowerShell language and run-
time largely in isolation. In the second part of the book, we look at applying this 
knowledge in various technology domains to solve broader problems. The technology 
areas that are covered are files, paths, and text (chapter 16), .
NET
(chapter 17), 
COM 
(chapter 18), 
WMI
and 
WSM
an (chapter 19), and event handling (chapter 20). The 
last chapter in the book is devoted to security, covering topics that are extremely 
important for PowerShell users who need to be able to write secure scripts. 
Move pages in pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to reverse pages in pdf; how to rearrange pages in pdf document
Move pages in pdf - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
reorder pages in pdf; how to rearrange pages in pdf using reader
2
P A
R
T
Using PowerShell
I
n the second part of the book, we look at applying your PowerShell knowledge in 
various technology domains to solve broader problems. The technology areas that are 
covered are files, paths, and text (chapter 16); .
NET
(chapter 17); 
COM
(chapter 18); 
WMI
and 
WSM
an (chapter 19); and event handling in chapter 20. The last chapter 
(chapter 21) in the book is devoted to security, covering topics that are extremely 
important for PowerShell users who need to be able to write secure scripts. 
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Using this C#.NET Tiff image management library, you can easily change and move the position of any two or more Tiff file pages or make a totally new order for
move pages within pdf; how to reverse page order in pdf
C# Word - Sort Word Pages Order in C#.NET
page reorganizing library control, developers can swap or adjust the order of all or several Word document pages, or just C# DLLs: Move Word Page Position.
how to move pages in pdf converter professional; move pages in a pdf
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the C# DLLs: Move PowerPoint Page Position.
change page order pdf reader; change page order in pdf file
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
RasterEdge XDoc.PDF allows you to easily move PDF document pages position, including sorting pages and swapping two pages. Copying and Pasting Pages.
how to move pages in pdf reader; how to reorder pages in pdf
663
C
H
A
P T E R   1 6
Working with files, text, 
and XML
16.1  PowerShell and paths  664
16.2  File processing  672
16.3  Processing unstructured text  681
16.4  XML structured text 
processing  693
16.5  Summary  717
Where is human nature so weak as in the bookstore?
—Henry Ward Beecher
Outside of a dog, a book is man’s best friend. Inside of a dog, 
it’s too dark to read.
—Groucho Marx
In this chapter, we’re going to cover PowerShell’s features for processing text and files. 
We’ll look at how PowerShell deals with file paths and concepts behind the provider 
model. We’ll revisit regular expressions and take another look at the language features 
and cmdlets that are provided for dealing with text. This chapter also covers the fea-
tures that PowerShell offers for dealing with a special kind of text—
XML
—as strings 
and in files. In the process, you’ll see how to use the .
NET
classes to accomplish tasks 
when the native PowerShell language features may not be sufficient.
C# PDF insert text Library: insert text into PDF content in C#.net
int pageIndex = 0; // Move cursor to (400F, 100F). String outputFilePath = Program.RootPath + "\\" output.pdf"; doc.Save(outputFilePath);
how to reorder pages in pdf preview; how to move pages in pdf files
VB.NET PDF insert text library: insert text into PDF content in vb
Dim pageIndex As Integer = 0 ' Move cursor to (400F, 100F). Dim outputFilePath As String = Program.RootPath + "\\" output.pdf" doc.Save(outputFilePath).
change pdf page order preview; how to rearrange pdf pages in preview
664
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
16.1
P
OWER
S
HELL
AND
PATHS
In this section we’ll explore the basic concepts underlying PowerShell’s path processing. 
PowerShell does a lot of work to promote a consistent user experience when navigating 
through hierarchical namespaces. This consistency allows you to use the same com-
mands to work with the file system, the Registry, and other stores. The core mechanism 
that PowerShell uses to accomplish this is the PowerShell provider model. A PowerShell 
provider is a software component, loaded through modules or snapins, that’s used to 
produce a file system–like experience for other data stores, such as the Registry.
16.1.1
Providers and the core cmdlets
A PowerShell provider is an installable component usually packaged as part of a Pow-
erShell module  or  snap-in.  So  far,  there’s  no  way  to  write a  provider  in  Power-
Shell—they have to be written in a compiled language like 
C
#. That said, the basic 
architecture of the provider module aligns with what are called the core cmdlets. These 
cmdlets provide the common (or core) activities and are grouped by noun: 
Item
ChildItem
Content
and
ItemProperty
. The 
Item
cmdlets work with an item in 
the store. For example, using 
Get-Item
on a file will return information about that 
file. The 
ChildItem
cmdlets provide a way to work with items that are children of a 
particular item. Using 
Get-ChildItem
on a directory in the file system will return 
the files in that directory. If the target is a file, then 
Get-Content
will return the con-
tent of the file. Finally, the 
ItemProperty
cmdlets allow properties on an item to be 
manipulated. Once you learn these patterns, you can apply them to any store sur-
faced as a provider.
This may seem like an overly complex arrangement, but it allows the core cmdlets 
to work with a wide variety of types of stores, including the Registry and Active 
Directory. It’s even  possible  to  write a  provider  for  an 
XML
document  (though 
PowerShell doesn’t include one at this time). Many of these stores are more complex 
than the file system and may allow structures like data elements with both content 
and children. (This isn’t possible in the Windows file system, but it does happen in 
the Registry.) By learning these core patterns, PowerShell users will have a mental 
model that will allow them to use new providers as they’re encountered.
You can get a list of the providers installed in your session by using the 
Get-
PSProvider
cmdlet:
PS (1) > Get-PSProvider
Name                 Capabilities             Drives 
----                 ------------             ------
WSMan                Credentials              {WSMan}
Alias                ShouldProcess            {Alias} 
Environment          ShouldProcess            {Env} 
FileSystem           Filter, ShouldProcess    {C, D, L, M...} 
Function             ShouldProcess            {Function} 
Registry             ShouldProcess, Transa... {HKLM, HKCU} 
Variable             ShouldProcess            {Variable} 
Certificate          ShouldProcess            {cert}
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Get image information, such as its location, zonal information, metadata, and so on. Able to edit, add, delete, move, and output PDF document image.
how to rearrange pdf pages reader; reordering pages in pdf
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Rapidly and multiple PDF document (pages) creation and edit methods file formats; merge, append, and split PDF files; insert, delete, move, rotate, copy
how to rearrange pages in a pdf reader; reordering pages in pdf document
P
OWER
S
HELL
AND
PATHS
665
You’ve worked with most of these providers already. In section 16.1.6 you’ll work 
with a Registry provider, and in chapter 21 (section 21.4.3) you’ll use the certificate 
provider when you learn script signing.
Providers are the heart of the namespace mechanism, but you don’t usually work 
directly with them. Instead, you work through named drives that allow you access to 
the provider’s capabilities.
16.1.2
Working with PSDrives
PowerShell providers are typically accessed through named drives. This means that 
each provider must have at least one drive associated with it for it to be usable. The 
drives that a provider exports needn’t correspond to things like system disk drives 
(though the file system provider usually has one drive name exported for each physi-
cal drive on the computer). Their names can also be longer than the single character 
permitted in drive letters. You saw an example of both of these things when you used 
the 
WSM
an: drive to manage PowerShell remoting in section 13.1.2.
To keep people from mixing up the PowerShell drives with the system drives, 
Microsoft calls them PSDrives. Similarly, a path that contains a 
PSD
rive is called a 
PSPath, and a path that contains a physical drive is called a provider-specific path. A 
PSP
ath must be translated to the provider-specific path form before it can be pro-
cessed by the system, as you’ll see in the next example.
Another useful feature supported by many providers is the ability to create your 
own drive names. That means you can, for example, create a 
PSD
rive as a shortcut to 
a common resource. For example, it might be convenient to have a docs: drive that 
points to your document directory. You can create this drive using the 
New-PSDrive 
cmdlet:
PS (1) > New-PSDrive -Name docs -PSProvider filesystem ` 
>>  -Root (Resolve-Path ~/*documents) 
>>
Name       Provider      Root                             Current
Location 
----       --------      ----                             --------
docs       FileSystem    C:\Documents and Settings\brucep
Notice the path used as the argument to the 
–Root
parameter. The string “~/documents” 
is passed to the 
Resolve-Path
command. In this string, ~ means the home drive for this 
provide. The call to 
Resolve-Path
converts the 
PSP
ath to an absolute provider path.
Once the drive has been created, you can 
cd
into it
PS (2) > cd docs:
and then use 
Get-Location
(to see where you are):
PS (3) > Get-Location
Path 
----
docs:\
666
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
You are, at least according to PowerShell, in the docs: drive. Create a file here:
PS (4) > "Hello there!" > junk.txt
Next, try to use 
cmd.exe
to display it (we’ll get to why you’re doing this in a second):
PS (5) > cmd /c type junk.txt
Hello there!
This code displays the context of the file with no problems. Next, display it using 
Get-Content
with the fully qualified path, including the docs: drive:
PS (6) > Get-Content docs:/junk.txt 
Hello there!
This code also works as expected. But when you try to use the full path with 
cmd.exe
PS (7) > cmd /c type docs:/junk.txt 
The syntax of the command is incorrect.
it fails. This is because non-PowerShell applications don’t understand the PowerShell 
drive fiction and can’t process 
PSP
aths. But when you “
cd
’ed” to the location first, you 
were able to use 
cmd.exe
to display the file. This worked because when you’re “in” 
that drive, the system automatically sets the current directory properly on the child 
process object to the provider-specific path before starting the process. This is why 
using relative paths from 
cmd.exe
worked. But if you pass in 
PSP
ath as an argument, 
it fails. To mitigate this issue, use the 
Resolve-Path
cmdlet to get the provider-
specific path. This cmdlet takes the 
PSP
ath and translates it into the provider’s native 
path representation. Use this cmdlet to pass the translated path to 
cmd.exe
:
PS (7) > cmd /c type (Resolve-Path docs:/junk.txt).ProviderPath 
Hello there!
This time, it works. You need to be somewhat careful when dealing with this concept 
and think about how things should work with non-PowerShell applications. If you 
wanted to open a file with Notepad in the doc: directory, you’d have to do the same 
thing you did for 
cmd.exe
and resolve the path first:
notepad (Resolve-Path docs:/junk.txt).ProviderPath
If you frequently use Notepad in 
PSP
aths, then you can create a function in your profile:
function notepad 
{
$args | foreach { notepad.exe (Resolve-Path $_).ProviderPath } 
}
You could even create a function to launch an arbitrary executable:
function Start-Program 
{
$cmd, $files = $args
$cmd = @(Get-Command -type Application $cmd)[0].Definition
$files | foreach { & $cmd  (Resolve-Path $_).ProviderPath } 
}
P
OWER
S
HELL
AND
PATHS
667
This function uses PowerShell’s multiple-assignment feature to split the list of argu-
ments into two parts: the command name and the list of files. It then uses 
Get-
Command
to limit the type of command to run to external applications and resolves 
the names of the argument files.
Each provider has a home directory
Another feature supported by the PowerShell path mechanism is a shortcut notation 
that allows you to easily access the default, or home, directory for that provider. Start 
the path with the tilde (~) character, and the remaining path components will be 
resolved relative to the provider’s home directory. In the file system, this directory will 
be the user’s home directory, giving you easy access to the subdirectories off your 
home directory. For example, to 
cd
to the desktop folder, you just have to use this:
cd ~/desktop
This code makes accessing these directories very convenient.
Remember, though, the 
~
always refers to the home directory for the current 
drive’s associated provider. Consequently, if your current location is somewhere in 
the Registry provider, using 
cd ~/desktop
won’t work because the 
~
will resolve to 
the home directory of the Registry provider, not the file system provider.
While we’re on the topic of paths, let’s look at some additional features Power-
Shell provides for working with paths.
16.1.3
Working with paths that contain wildcards
Another great feature of the PowerShell provider infrastructure is universal support 
for wildcards (see chapter 4 for details on wildcard patterns). You can use wildcards 
any place you can navigate to, even in places such as the alias: drive. For example, say 
you want to find all the aliases that begin with 
gc
. You can do this with wildcards in 
the Alias provider:
PS (1) > dir alias:gc*
CommandType     Name                  Definition 
-----------     ----                  ----------
Alias           gc                    Get-Content 
Alias           gci                   Get-ChildItem 
Alias           gcm                   Get-Command
As you can see, there are three of them.
We might all agree that this is a great feature, but there’s a downside. Suppose you 
want to access a path that contains one of the wildcard metacharacters: ?, *, [, and ]. 
In the Windows file system, * and ? aren’t a problem because you can’t use these 
characters in a file or directory name. But you can use [ and ]. Working with files 
whose names contain [ or ] can be quite a challenge because of the way wildcards and 
quoting (see chapter 3) work. Square brackets are used a lot in filenames in browser
668
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
caches to avoid collisions by numbering the files. Let’s run some experiments on 
some of the files in the Internet Explorer 
(IE)
cache.
16.1.4
Suppressing wildcard processing in paths
In one of the directories used to cache temporary Internet files, say you want to find 
all of the files that begin with “thumb*”. It’s easy enough:
PS (2) > dir thumb*
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Doc
uments and Settings\brucepay\Local Settings\Temporary I
nternet Files\Content.IE5\MYNBM9OJ
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          9/7/2006  10:34 PM       4201 ThumbnailServe
r[1].jpg 
-a---          9/7/2006  10:35 PM       3223 ThumbnailServe
r[2].jpg 
-a---          7/8/2006   7:58 PM       2066 thumb[1].jpg 
-a---         9/11/2006   2:48 PM      12476 thumb[2].txt 
-a---         9/11/2006   2:48 PM      11933 thumb[3].txt
You  get  five  files.  Now  you  want  to  limit  the set  of  files  to  things  that  match 
“thumb[”. Try this directly using a wildcard pattern:
PS (3) > dir thumb[*
Get-ChildItem : Cannot retrieve the dynamic parameters for 
the cmdlet. The specified wildcard pattern is not valid: 
thumb[* 
At line:1 char:3 
+ ls  <<<< thumb[*
Dealing with hidden files
By default, the Get-ChildItem cmdlet (and its alias dir) won’t show hidden files. 
To see the  hidden  files, use the -Force  parameter. For example, to  find the
Application Data directory in your home directory, you might try
PS (1) > dir ~/app*
but nothing is returned. That’s because this directory is hidden. To see the directory, 
use -Force as in:
PS (2) > dir ~/app* -Force
Directory:Microsoft.PowerShell.Core\FileSystem::C:\Docum
ents and Settings\brucepay 
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d-rh-        12/14/2006   9:13 PM             Application Data
Now the directory is visible. You’ll need to use -Force to get into the directory 
containing the temporary Internet files.
P
OWER
S
HELL
AND
PATHS
669
Of course, it fails because the [ is being treated as part of a wildcard pattern. Clearly 
you need to suppress treating [ as a wildcard by quoting it. The obvious first step, as 
you’ll recall from chapter 4, is to try a single backtick:
PS (4) > dir thumb`[*
Get-ChildItem : Cannot retrieve the dynamic parameters for 
the cmdlet. The specified wildcard pattern is not valid: 
thumb\[* 
At line:1 char:3 
+ ls  <<<< thumb`[*
This code fails because the single backtick is discarded in the parsing process. In fact, 
it takes four backticks to cause the square bracket to be treated as a regular character:
PS (5) > dir thumb````[*
Directory: Microsoft.PowerShell.Core\FileSystem::C:\
Documents and Settings\brucepay\Local Settings\Temporary
Internet Files\Content.IE5\MYNBM9OJ
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          7/8/2006   7:58 PM       2066 thumb[1].jpg 
-a---         9/11/2006   2:48 PM      12476 thumb[2].txt 
-a---         9/11/2006   2:48 PM      11933 thumb[3].txt
The reason is that one set of backticks is removed by the interpreter and a second set 
is removed by the provider itself. (This second round of backtick removal is so you 
can use escaping to represent filenames that contain literal quotes.) Putting single 
quotes around the pattern keeps the interpreter from performing quote processing in 
the string, simplifying this to needing only two backticks:
PS (8) > ls 'thumb``[*'
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Doc
uments and Settings\brucepay\Local Settings\Temporary I
nternet Files\Content.IE5\MYNBM9OJ
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          7/8/2006   7:58 PM       2066 thumb[1].jpg 
-a---         9/11/2006   2:48 PM      12476 thumb[2].txt 
-a---         9/11/2006   2:48 PM      11933 thumb[3].txt
In this particular example, much of the complication arises because you want some of 
the metacharacters to be treated as literal characters, whereas the rest still do pattern 
matching. Trial and error is usually the only way to get this right.
NOTE
As we’ve said before, this stuff is hard. It’s hard to understand 
and it’s hard to get right. Unfortunately, no one has come up with a 
better mechanism yet. This problem occurs in any language that sup-
ports pattern matching. Patience, practice, and experimentation are the 
only ways to figure it out.
Documents you may be interested
Documents you may be interested