c# pdf viewer free : How to reorder pages in a pdf document application Library tool html asp.net winforms online Windows%20Powershell%20in%20Action%202nd%20Edition37-part1491

340
CHAPTER 9
U
SING
AND
AUTHORING
MODULES
>>> function:Get-Count,function:setIncrement 
VERBOSE: Performing operation "Remove Item" on Target 
"Item: count".
VERBOSE: Performing operation "Remove Item" on Target 
"Item: increment".
VERBOSE: Performing operation "Remove Item" on Target 
"Item: Reset-Count".
VERBOSE: Performing operation "Remove Item" on Target 
"Item: Get-Count".
VERBOSE: Performing operation "Remove Item" on Target 
"Item: setIncrement".
PS (14) >
This is necessary because there’s no implicit grouping of all the members created by a 
script.
At this point, it’s clear that, although it’s possible to build libraries using dot-sourcing, 
there are a number of problems with this approach. Private implementation details 
leak into the public namespace, and the members of a dot-sourced script lose any sort 
of grouping that allows you to manage them as a whole. Let’s turn this script into a 
module and see how that fixes the problem.
9.4.2
Turning a script into a module
Now let’s turn the counter script into a module. Do this simply by changing the 
extension on the module from .ps1 to .psm1 (where the m stands for module):
PS (1) > copy .\counter.ps1 .\counter.psm1 -Force -Verbose 
VERBOSE: Performing operation "Copy File" on Target "Item: 
C:\wpia_v2\text\chapter09\code\counter.ps1 Destination: 
C:\wpia_v2\text\chapter09\code\counter.psm1".
PS (2) >
Finding function definitions
It’s not true that there’s no way to find out which functions came from a particular file. 
Another change in PowerShell v2 was to attach the path to the file where a function was 
defined  to  the  scriptblock  of  the  function.  For  the  counter  example  we’ve  been 
discussing, the path might look like
PS (23) > ${function:Get-Count}.File 
C:\wpia_v2\text\chapter09\code\counter.ps1 
PS (24) >
This File  property  makes  it  easier  to  figure  out  where  things  came  from  in  your 
environment when you have to debug it. For example, all the functions that were defined 
in your profile will have the path to your profile in it, functions that were defined in the 
system profile will have the system profile path, and so on. (We discussed the set of 
profiles that PowerShell uses in chapter 2.) This only fixes part of the problem—managing 
functions—and doesn’t deal with variables and aliases.
How to reorder pages in a pdf document - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
rearrange pages in pdf file; reorder pages pdf
How to reorder pages in a pdf document - 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
change page order in pdf reader; how to move pages in a pdf document
W
RITING
SCRIPT
MODULES
341
(You’re using the 
-Force
parameter here to make the example work all the time.) Try 
loading the renamed file. Figure 9.7 shows what you’ll probably see when you do this. 
The module wasn’t run. The default action is to open the file in the editor associ-
ated with the extension. This is because module files aren’t commands and can’t just 
be run. Instead, you need to use the 
Import-Module
command to load this module:
PS {3) > Import-Module .\counter.psm1 
PS {4) >
Now that you’ve loaded a module, you can try the 
Get-Module
command and see 
something useful:
PS {5) > Get-Module
ModuleType Name                      ExportedCommands 
---------- ----                      ----------------
Script     counter                   {setIncrement, Get-Coun...
Again let’s use the 
Format-List
(alias: 
fl
) cmdlet to see the object in more detail:
PS {6) > Get-Module | fl
Name              : counter 
Path              : C:\wpia_v2\text\chapter09\code\counter.psm1 
Description       : 
ModuleType        : Script 
Version           : 0.0 
NestedModules     : {}
ExportedFunctions : {Get-Count, Reset-Count, setIncrement} 
ExportedCmdlets   : {}
ExportedVariables : {}
ExportedAliases   : {}
Figure 9.7 What happens when you 
try to directly run a module file. The 
module file is opened up in the editor 
associated with the .psm1 extension. 
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
pdf reorder pages online; how to reorder pages in a pdf document
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB.NET amount of robust PPT slides/pages editing methods & profession imaging controls, PDF document, image to
reorder pages pdf file; reorder pages of pdf
342
CHAPTER 9
U
SING
AND
AUTHORING
MODULES
An important thing to notice is that the 
Path
property stores the full path to where 
the module was loaded from. The module type is 
script
and the version is 0.0—the 
default for a script module. (When we look at manifests in chapter 10, you’ll see how 
to change this.) The most important thing to notice are the export lists. You see that 
all the functions defined in the script module are being exported but no variables are. 
To verify this, use 
Get-Command
to look for all the functions defined by the script:
PS {7) > Get-Command -Module counter
CommandType     Name                    Definition 
-----------     ----                    ----------
Function        Get-Count               ... 
Function        Reset-Count             ... 
Function        setIncrement            param($x)...
You can immediately see one of the benefits of using modules: you can work with sets 
of related elements as a unit. (More on this in a bit.) Now that you’ve loaded the 
functions, you have to run them to make sure they work:
PS {8) > Get-Count 
PS {9) > Get-Count 
PS {10) > Get-Count 
3
As before, you see that 
Get-Count
returns the next element in the sequence. Now 
let’s check on the variables used by 
Get-Count
. These were a big problem when you 
dotted the script:
PS (14) > $count
PS (16) > $increment
Neither of them exist. Try assigning a value to 
$count
and see whether it makes a 
difference:
PS (17) > $count = 100
PS (18) > Get-Count 
4
As desired, it has no effect on 
Get-Count
. Try 
Reset-Count
and verify that it works:
PS (19) > Reset-Count
PS (20) > Get-Count 
1
And it does. Now let’s look at another issue you had to deal with when using script 
libraries: how to remove  the imported  elements. With  modules,  you  can simply 
remove the module:
PS (21) > Remove-Module counter
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize or re-arrange PDF document files using C#.NET code.
reorder pages in pdf reader; reorder pages in pdf online
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
with the functions to merge PDF files using C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split PDF document in both
how to rearrange pages in a pdf document; move pages in pdf online
W
RITING
SCRIPT
MODULES
343
This will remove the module from the session and remove all imported members, so 
if you try to run 
Get-Count
now, you get an error:
PS (22) > Get-Count
The term 'Get-Count' is not recognized as the name of a cmdlet, 
function, script file, or operable program. Check the spelling o 
f the name, or if a path was included, verify that the path is c 
orrect and try again.
At line:1 char:10 
+ Get-Count <<<<
+ CategoryInfo          : ObjectNotFound: (Get-Count:String
) [], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
In the next section, we’ll look at ways to get more fine-grained control over the things 
that modules export.
9.4.3
Controlling member visibility with Export-ModuleMember
Let’s recap what you saw in the last example. You converted a script to a module sim-
ply by changing the file extension. When you imported the module, all the functions 
you’d defined were visible by default but nothing else was. This is the default behavior 
in a module when you don’t do anything to control member visibility. Because script 
libraries written for v1 typically depended on this behavior, simply renaming them 
with a .psm1 extension may be all that’s needed to turn them into modules.
Although this approach is simple, it’s not very flexible. For complex scenarios, you 
need to be able to control exactly what gets exported. You do this with the 
Export-
ModuleMember
cmdlet. This cmdlet lets you declare exactly which commands and 
variables are exported from the module. We’ll start by reviewing how it works with 
functions.
Controlling which functions are exported
First we’ll look at how you can hide the functions you want to be private in a module. 
Let’s take a look at another variation of the 
counter
module: 
PS (1) > Get-Content .\counter1.psm1 
$script:count = 0 
$script:increment = 1
function Get-Count 
{
return $script:count += $increment 
}
function Reset-Count 
{
$script:count=0
setIncrement 1 
}
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image to
pdf rearrange pages online; how to move pages around in pdf file
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
pdf reorder pages; change page order pdf reader
344
CHAPTER 9
U
SING
AND
AUTHORING
MODULES
function setIncrement ($x) 
{
$script:increment = $x 
}
Export-ModuleMember *-Count
The only difference between this version and the previous one is the last line, which 
uses the 
Export-ModuleMember
cmdlet. This line says “Export all functions match-
ing the pattern *-Count.” Now import the module:
PS (2) > Import-Module .\counter1.psm1
You verify that the count and reset commands are there:
PS (3) > Get-Command *-Count
CommandType     Name                     Definition 
-----------     ----                     ----------
Function        Get-Count                ... 
Function        Reset-Count              ...
But the 
setIncrement
command isn’t, because it wasn’t explicitly exported:
PS (4) > Get-Command setIncrement 
Get-Command : The term 'setIncrement' is not recognized as the n 
ame of a cmdlet, function, script file, or operable program. Che 
ck the spelling of the name, or if a path was included, verify t 
hat the path is correct and try again.
At line:1 char:12 
+ Get-Command <<<<  setIncrement
+ CategoryInfo          : ObjectNotFound: (setIncrement:Str
ing) [Get-Command], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException,Microsof
t.PowerShell.Commands.GetCommandCommand
Remove the module to clean up after yourself:
PS (5) > Remove-Module counter1
Here’s the rule to remember: if there are no calls to 
Export-ModuleMember
in a 
script module, all functions are exported by default and all other member types are 
private. If there’s at least one call to 
Export-ModuleMember
, whatever the cmdlet 
does overrides the default. This means that PowerShell doesn’t know exactly what set 
of functions will be exported until the script has run to completion. We’ll return to 
this concept in a minute but first let’s finish up with variables and aliases.
Controlling what variables and aliases are exported
Although functions are exported by default, variables and aliases aren’t. Again, to 
change the default set of exports, use the 
Export-ModuleMember
cmdlet. Let’s look 
at a third variation on the counter module:
PS (6) > Get-Content .\counter2.psm1 
$script:count = 0 
$script:increment = 1
Read PDF in Web Image Viewer| Online Tutorials
Extract images from PDF documents; Add, reorder pages in PDF files; detailed information for reading and editing PDF in RasterEdge Web Document Viewer
how to reorder pages in pdf online; how to move pages in a pdf file
.NET Multipage TIFF SDK| Process Multipage TIFF Files
upload to SharePoint and save to PDF documents. View, edit, insert, delete and mark up pages in multi Easily add, modify, reorder and delete TIFF tags; Perfectly
how to move pages in pdf converter professional; change pdf page order online
W
RITING
SCRIPT
MODULES
345
function Get-Count { return $script:count += $increment }
function Reset-Count { $script:count=0;  setIncrement 1 } 
New-Alias reset Reset-Count
function setIncrement ($x) {  $script:increment = $x }
Export-ModuleMember -Function *-Count -Variable increment -Alias reset
This time there are two changes to the script. First you’re defining an alias for the 
Reset-Count
function. Second, you’re using the 
Export-ModuleMember
to explic-
itly control all of the exports: functions, variables, and aliases. Now, if the member 
doesn’t appear in a call to 
Export-ModuleMember
, it won’t be exported. Let’s import 
the updated module
PS (7) > Import-Module .\counter2.psm1
and verify the contents. Are the 
*-Count
commands loaded?
PS (8) > Get-Command *-Count
CommandType     Name                     Definition 
-----------     ----                     ----------
Function        Get-Count                ... 
Function        Reset-Count              ...
Yes, they’re all there. What about 
setIncrement?
You were supposed to export it, so 
there should be an error when you try calling
PS (9) > setIncrement 10
The term 'setIncrement' is not recognized as the name of a cmdle 
t, function, script file, or operable program. Check the spellin 
g of the name, or if a path was included, verify that the path i 
s correct and try again.
At line:1 char:13 
+ setIncrement <<<<  10
+ CategoryInfo          : ObjectNotFound: (setIncrement:Str
ing) [], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
And there is. The function wasn’t exported from the module so it can’t be imported 
by the module loaded. Finally, check to see if your variables were exported properly 
by trying to display their contents:
PS (10) > $count
PS (11) > $increment 
1
You can see that the 
$count
variable wasn’t exported because nothing was displayed. 
The 
$increment
variable, on the other hand, was the value being output. 
Next, check to see if the 
reset
alias was exported. Run 
Get-Count
a few times: 
PS (12) > Get-Count 
PS (13) > Get-Count
346
CHAPTER 9
U
SING
AND
AUTHORING
MODULES
PS (14) > Get-Count 
3
And call the 
reset
command:
PS (15) > reset
You didn’t get a “command not found error,” meaning that the command exists—so 
check that the value was reset:
PS (16) > Get-Count 
PS (17) > Get-Count 
2
Once again, you can see from the output that it was.
When module exports are calculated
Now let’s return to something we mentioned earlier: the set of module members to 
export is not known until runtime. In fact, the 
Export-ModuleMember
cmdlet doesn’t 
export the function; it adds it to a list of members to export. Once execution of the 
module body is completed, the PowerShell runtime looks at the accumulated lists of 
exports and exports those functions. The export algorithm is shown in figure 9.8.
Load module script
Execute module script
Has Export -ModuleMember been called?
If yes, get accumulated exports
If no, get list of all functions that
have been defined
Build export table from list
Export selected members
Figure 9.8 The ordering of the 
steps when processing a module 
manifest. At any point prior to 
the next-to-the-last step, if an error 
occurs, module processing will 
stop and an error will be thrown.
W
RITING
SCRIPT
MODULES
347
As shown in the figure, PowerShell loads and executes the module file. As execution 
proceeds,  the module  code defines functions  and  may  or may  not  call 
Export-
ModuleMember
. If it does call 
Export-ModuleMember
, then the specified members to 
export are added to the exports list. When execution has completed, control returns 
to the module loader, which checks to see if anything was put into the export list. If 
there were no calls to 
Export-ModuleMember
, then this list is empty. In that case, the 
loader finds all the functions defined in the module’s scope and exports them. If there 
was at least one call to 
Export-ModuleMember
, then the module loader uses the 
export list to control what gets exported.
So far you’ve been loading the module using the path to the module file. This is a 
good approach for development, but eventually you need to put it into production. 
In the next section you’ll learn how.
9.4.4
Installing a module
Once you have your module debugged and ready to put into production, you need to 
know how to install it. Fortunately, unlike with snap-ins, installation is simple. All 
you have to do is create  a subdirectory of  one of  the directories in the  module 
path—the proverbial “Xcopy install” that people like to talk about. Let’s look at the 
first element of the module path:
PS (1) > ($ENV:PSModulePath -split ';')[0] 
C:\Users\brucepay\Documents\WindowsPowerShell\Modules
The  Modules  directory  in  Documents\WindowsPowerShell is  the  user’s  personal 
module repository. You’re going to install the counter module in it so you don’t have 
to load it using the full path anymore. Let’s get the repository path into a variable so 
it’s easier to use:
PS (2) > $mm = ($ENV:PSModulePath -split ';')[0]
Next create the module directory:
PS (4) > mkdir $mm/Counter
Directory: C:\Users\brucepay\Documents\WindowsPowerShell\Modules
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d----         1/31/2010   1:06 AM            Counter
Install the module by copying it into the directory just created:
PS (7) > copy .\counter.psm1 $mm/Counter
Now try it out. Use the 
-List
option on 
Get-Module
to see if the module lookup 
algorithm will find it:
PS (10) > Get-Module -List Counter | fl name, path
Name : Counter
Path : C:\Users\brucepay\Documents\WindowsPowerShell\Modules\Counter\
Counter.psm1
348
CHAPTER 9
U
SING
AND
AUTHORING
MODULES
And it does. This means you should be able to load it by name:
PS (12) > Import-Module -Verbose counter 
VERBOSE: Loading module from path 
'C:\Users\brucepay\Documents\WindowsPowerShell\Modules\counter\counte
r.psm1'.
VERBOSE: Exporting function 'Get-Count'. 
VERBOSE: Exporting function 'Reset-Count'. 
VERBOSE: Exporting function 'setIncrement'. 
VERBOSE: Importing function 'Get-Count'. 
VERBOSE: Importing function 'Reset-Count'. 
VERBOSE: Importing function 'setIncrement'.
It works. Installing a module is as simple as copying a file. You may be wondering 
why you have to put in into a directory—it’s just a single file. In chapter 10, you’ll see 
that a production module is more than just a single .psm1 file. This is why modules 
are stored in a directory—it allows all the module resources to be gathered in one 
place, making it easy to distribute a multifile module. Just zip it up and send it out.
NOTE
Downloading and installing a zipped module on Windows 7 
or Vista requires some extra steps because files downloaded using Inter-
net Explorer are blocked by default. PowerShell honors this blocking 
attribute, so you won’t be able to load the module until you unblock it. 
The  most  effective way to do this is to unblock  the  zip  file before 
unzipping it. Then, when you unzip it, all the extracted files will also 
be unblocked. To unblock a file, right-click the file in Explorer, and 
select the Properties option. When the property dialog appears, if the 
file is blocked,  you’ll  see a  message saying  that  the file  came from 
another computer. Beside the message text will be an Unblock button. 
Click this button to unblock the file, and then click OK to close the 
property dialog.
In all the exercises so far, you’ve depended on the module scoping semantics to make 
things work. Now is a good time to develop your understanding of exactly how these 
new scoping rules operate. In the next section, we’ll at how function and variable 
names are resolved when using modules.
9.4.5
How scopes work in script modules
In section 8.4, we covered how scripts introduced script-specific scoping rules. As 
you’ve seen, modules also introduce some new scoping rules. The primary goal of 
these module-specific  rules  is to insulate modules from accidental contamination 
picked up from the caller’s environment. This insulating  property makes module 
behavior more predictable and that, in turn, makes modules more reusable.
To accomplish this isolation, each module gets its own scope chain. As with the 
default  scope chain, the module  scope  chain eventually  ends  at the  global scope 
(which  means that module and default  scope  chains  both  share the same  global
W
RITING
SCRIPT
MODULES
349
variables). Walking up the module scope chain, right before you reach the global 
scope, you’ll encounter a new distinguished scope: the module scope. This scope is 
somewhat similar to the script scope except it’s only created once per loaded module 
and is used to share and preserve the state of that module. A diagram of all of these 
pieces is shown in figure 9.9.
Let’s spend some time walking through figure 9.9. In the diagram, you see boxes 
indicating three functions. The two on the left (
one
and 
two
) are defined in the 
default scope and will use the default scope chain to look up variables. The function 
shown on the right (
foo
) is defined inside a module and so uses the module scope 
chain. Now let’s call function 
one
. This function sets a local variable, 
$y
, to 20 then 
calls function 
two
.
In the body of 
two
, you’re adding 
$x
and 
$y
together. This means that you have 
to look up the variables to get their values. The smaller gray arrows in figure 9.9 show 
the order in which the scopes will be checked. Following the default scope path, the 
first instance of a variable named 
$y
is found in the local scope of function 
one
and 
has a value of 20. Next you follow the scope path to find 
$x
, and you don’t find it 
until you hit the global scope, where it resolves to 1. Now you can add them, yielding 
the value 21.
Function 
two
then calls the module function 
foo
. This function also adds 
$x 
and 
$y
, but this time you’ll use the module scope chain to look up the variables. You 
travel up the module chain and don’t find the defined variable 
$y
until you hit the 
global scope, where its value is 2. When you look up 
$x
, you find that it was set to 10 
in the module scope. You add 2 and 10 and get 12. This shows how local variables 
defined in the caller’s scope can’t have an impact on the module’s behavior. The 
module’s operations are insulated from the caller’s environment. 
Global scope: $x = 1, $y = 2
Module scope: $x = 10
Function scope:
function foo{ $x + $y }
returns 12
Function scope:
function one{ $y = 20;  two }
Function scope:
function two{ $x + $y; foo }
returns 21, 12
Default scope chain
Module scope chain
Figure 9.9 How variables are resolved in a module context. Function 
one
calls 
two
, and 
two
calls the module function 
foo
. Functions 
one
and 
two
look up vari-
ables in the default scope. The module function 
foo
uses the module scope chain.
Documents you may be interested
Documents you may be interested