c# pdf viewer free : Change page order in pdf file application control utility html azure .net visual studio Windows%20Powershell%20in%20Action%202nd%20Edition50-part1506

470
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
As soon as you enter interactive mode, you  see that the prompt changes: it now 
displays the name of the machine you’re connected to and the current directory.
NOTE
The default prompt can be changed in the remote session in 
the same way it can be changed in the local session. If you  have a 
prompt definition in your profile, you may be wondering why that 
wasn’t used. We’ll get to that later in section 12.6.2, when we look at 
some of the things you need to keep in mind when using remoting.
Now let’s check out the value of 
$x
:
[localhost]: PS C:\Users\brucepay\Documents> $x 
1234
It’s 1234, which is the last value you set it to using 
Invoke-Command
in the previous 
section. The remote session state has been preserved and is now available to you inter-
actively. Let’s try running the 
hi
function you defined:
[localhost]: PS C:\Users\brucepay\Documents> hi
Hello there, x is 1234
It also works. In addition to examining the state of things, you can change them. 
Change the value of 
$x
, and then rerun the 
hi
function, which uses 
$x
in its output:
[localhost]: PS C:\Users\brucepay\Documents> $x=6 
[localhost]: PS C:\Users\brucepay\Documents> hi 
Hello there, x is 6
The changed value is displayed in the output. You can exit an interactive remote ses-
sion either by using the 
exit
keyword or by using the 
Exit-PSSession
cmdlet (sec-
tion 13.2.6 explains why there are two ways to do this):
[localhost]: PS C:\Users\brucepay\Documents> exit
You see that the prompt changed back, and when you try to run the 
hi
function
PS (11) > hi
The term 'hi' is not recognized as the name of a cmdlet, function, 
script file, or operable program. Check the spelling of the name, 
or if a path was included, verify that the path is correct 
and try again.
At line:1 char:3 
+ hi <<<<
+ CategoryInfo          : ObjectNotFound: (hi:String) [], 
CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
you get an error because the function was only defined in the remote environment. 
Now try to reenter the session:
PS (12) > Enter-PSSession $s 
[localhost]: PS C:\Users\brucepay\Documents> $x 
6
Change page order in pdf file - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reorder pages in pdf reader; reorder pages in pdf preview
Change page order in pdf file - 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
how to reverse page order in pdf; change page order pdf reader
S
ESSIONS
AND
PERSISTENT
CONNECTIONS
471
When you reenter the session, the environment is exactly as you left it. You can run 
the 
hi
function
[localhost]: PS C:\Users\brucepay\Documents> hi 
Hello there, x is 6
and it works. Now you can exit it again
[localhost]: PS C:\Users\brucepay\Documents> exit 
PS (13) >
and you’re back in your local environment. You can enter and exit a session as often as 
you need to as long as it’s not removed in the interim.
Another useful feature to consider is the fact that you can have more than one ses-
sion open at a time. This means that you can pop back and forth between multiple 
computers as needed. In chapter 15, you’ll see how the PowerShell 
ISE
takes advan-
tage of this capability, allowing you to have different sessions open in different tabs. 
The  ability  to  have  multiple  concurrent  sessions  makes  dealing  with  multiple 
machines very convenient.
Additional  differences  exist  between  the  pattern  where  you  used 
Invoke-
Command
for each command and the interactive mode. In the noninteractive 
Invoke-Command
case, the remote commands send objects back, where they’re for-
matted on the local machine. In the interactive remoting case, the objects are format-
ted on the remote machine and simple strings are sent to the local machine to be 
displayed. This process is illustrated in figure 12.6.
Remote machine
Local machine
Explicit remoting
Pipeline
processor
Formatter
User sends commands to remote host for execution
Formatted strings
Interactive remoting
Remote machine
Local machine
Pipeline
processor
Formatter
output objects
Formatted strings
Output objects
Output objects
User
User
User sends commands to remote host for execution
Figure 12.6 When using explicit remoting (top), objects are returned from the remote host 
and formatted locally. With interactive remoting (bottom), the objects are formatted on the 
remote machine and the formatted strings are sent back to the local machine.
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# File: Split PDF; C# Page: Insert PDF pages
how to reorder pdf pages; how to move pages in pdf acrobat
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
splitting PDF pages and Files, adding a page into PDF document, deleting unnecessary page from PDF file and changing the position, orientation and order of PDF
change pdf page order; rearrange pdf pages online
472
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
The differences in behavior this process may cause are somewhat subtle. Most of the 
time the process is  invisible. Situations where  you  might experience some conse-
quences are when the local session and the remote session are in different locales—that 
is, the sessions have different language and cultural settings. In this case, things like 
dates will be displayed differently in the local and remote cases. The other scenario 
where there could be a visible difference is when there’s formatting information for the 
objects you’re working with that’s different (or missing) on one end or the other.
Finally, as with the noninteractive remoting case, you can run an interactive ses-
sion in a temporary session by passing the name of the computer instead of an exist-
ing 
PSSession
. Using the 
PSSession
has the advantage that you can enter and exit 
the remote session and have the remote state preserved between activities. If the name 
of the computer is passed in, the connection will be torn down when you exit the ses-
sion. Because a remote session involved creating a remote host process, forgetting to 
close your sessions can lead to wasting resources. At any point, you can use the 
Get-
PSSession
to get a list of the open sessions you currently have and use 
Remove-
PSSession
to close them as appropriate.
By now, you should be comfortable with creating and using persistent remote ses-
sions. What we haven’t spent much time on is how to manage all these connections 
you’re creating. We’ll expand our discussion to include these topics in the next section.
12.3.4
Managing PowerShell sessions
Each 
PSSession
is associated with an underlying 
Windows
process. As such, it con-
sumes significant resources even when no commands are being executed in it. To 
limit the load on the remote system, you should delete 
PSSession
s that are no longer 
needed and maintain only the ones currently in use. This step reduces the memory 
usage and similar  drains  on the  remote  system.  At  the same  time,  creating  new 
PSSession
s also puts a load on the system, consuming additional 
CPU
resources to 
create each new process. When managing your resource consumption, you need to 
balance the cost of creating new sessions against the overhead of maintaining multiple 
sessions. There’s no hard-and-fast rule for deciding what this balance should be. In 
the end, you should decide on an application-by-application basis. Let’s review the 
tools you have for session management.
To get a list of the existing 
PSSession
s, you use the 
Get-PSSession
command, 
and to remove sessions that are no longer needed, you use the 
Remove-PSSession 
cmdlet. The 
Remove-PSSession
cmdlet closes the 
PSSession
, which  causes the 
remote process to exit and frees up all the resources it held. Removing the session 
also frees up local resources like the  network  connection used  to  connect to the 
remote session. 
So far, the focus of our resource management discussion has been on managing 
connections from the client end. On the client end, if you don’t explicitly remove the 
sessions or set timeouts, local sessions will remain open until you end your Power-
Shell session. But what happens if the client fails for some reason without closing its
C# Word - Process Word Document in C#
For example, you may change your Word document order from 1, 2, 3, 4, 5 to 3, 5, 4, 2,1 with C# coding. C#.NET: Extracting Page(s) from Word.
change page order pdf preview; reorder pages pdf file
VB.NET Word: Change Word Page Order & Sort Word Document Pages
Note: if you are trying to change the order of a you want to see other VB.NET Word document editing controls, please read this Word reading page which has
move pdf pages in preview; how to move pdf pages around
I
MPLICIT
REMOTING
473
sessions? If these sessions are allowed to persist without some mechanism for closing 
them, eventually the remote server’s resources could become exhausted. In this sce-
nario you can’t rely on being able to reconnect to the remote machine, which means 
you need a mechanism to allow it to do its own cleanup.
To address this problem, the PowerShell remoting infrastructure uses a “heart-
beat” pulse sent between the local and remote machines to make sure that the con-
nection  between  the  machines  is  still  valid. The  heartbeat  pulse  is  sent  every  3 
minutes to validate the connection. If the client computer doesn’t respond to the 
pulse within 4 minutes, the 
PSSession
associated with that connection will be closed 
automatically. This allows the remote machine to prevent “orphaned” processes that 
are no longer being used by the client from eventually exhausting its resource.
At this point, let’s review what we’ve covered. We’ve looked at the basic remoting 
concepts. We’ve examined the use of transient and persistent sessions in noninterac-
tive and interactive scenarios. In the next section, we’ll explore another feature that 
lets you merge local and remote operations in an almost seamless way.
12.4
I
MPLICIT
REMOTING
When doing noninteractive remoting, you have to call 
Invoke-Command
every time 
you want to execute a remote operation. You can avoid this task by using 
Enter-
PSSession
to set up a remote interactive session. This approach makes remote exe-
cution easy but at the cost of making local operations difficult. In this section, we’ll 
look at a mechanism that makes both local and remote command execution easy. 
This mechanism is called implicit remoting.
NOTE
For implicit remoting to work, the execution policy on the cli-
ent machine has to be configured to allow scripts to run, typically by 
setting it to 
RemoteSigned
. This is necessary because implicit remot-
ing generates a temporary module, and PowerShell must be allowed to 
execute scripts in order to load this module. If execution policy is set to 
Restricted
or 
AllSigned
, it won’t be able to do this. This require-
ment only applies to the local client machine. A remote server can still 
use a more restrictive policy. See section 21.3.2 for more information 
about execution policy.
The goal of implicit remoting is to make the fact that remote operations are occur-
ring invisible to the user and to have all operations look as much like local opera-
tions as possible. You can accomplish this goal by generating local proxy functions 
that run  the  remote commands under the covers. The user  calls  the  local proxy, 
which takes care of the details involved in making the remote command invoca-
tion, as shown in figure 12.7.
The net effect is that everything looks like a local operation because everything is a 
local operation. In the next section, you’ll see how to use this facility.
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Embedded page thumbnails. In order to run the sample code, the following ops.MonochromeImageOptions.TargetResolution = 150F; // to change image compression
reorder pages in pdf; pdf change page order acrobat
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
several PowerPoint document pages, or just change the position PPTXDocument(filepath); // Swap page 0 and page 1. doc PowerPoint Pages with a Certain Order in C#
how to reverse pages in pdf; reverse page order pdf
474
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
12.4.1
Using implicit remoting
To set up the remote proxy functions mentioned in the previous section, use the 
Import-PSSession
cmdlet. The syntax for this cmdlet is shown in figure 12.8.
Let’s explore how this cmdlet works by walking through an example. You’ll create 
PSSession
and then define a function in that session. The goal is to be able to exe-
cute this remote function as though it was defined locally. In other words, you want 
to implicitly remote the function. To accomplish this, you call 
Import-PSSession
which generates a function that you can call locally. This local function does the 
remote call on your behalf—it acts as your proxy. The steps in this process are shown 
in figure 12.9.
You’ll begin by creating the connection to a remote machine. To do this, you may 
need to get credentials for the remote host.
Remote machine
Local machine
Actual
remote 
command
User executes local command
Remote invocation request
Local
proxy 
function
Local request
Local output
User
Output objects returned from remote cmd
Figure 12.7 With implicit remoting, the user calls a local proxy command. This command 
takes care of making the remote invocation. The user need not be concerned with the details 
of the remote invocation.
Import-PSSession 
[-Session] <PSSession> 
[[-CommandName] <String[]>]
[[-FormatTypeName] <String[]>] 
[-Prefix <String>]
[-DisableNameChecking] 
[-AllowClobber] [-ArgumentList <Object[]>]
[-CommandType <CommandTypes>] 
[-Module <String[]>]
Figure 12.8 The syntax for the 
Import-PSSession
cmdlet. This cmdlet 
is used to create local proxy commands that invoke the corresponding 
remote command on the target computer.
C# Word - Sort Word Pages Order in C#.NET
or several Word document pages, or just change the position DOCXDocument(filepath); // Swap page 0 and page 1. doc Multiple Word Pages with a Certain Order in C#
reverse pdf page order online; change page order in pdf reader
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via Change PDF original password. In order to run the sample code, the following steps would be
pdf change page order; move pages within pdf
I
MPLICIT
REMOTING
475
NOTE
In a domain environment, this step is unnecessary as long as your 
user account has sufficient privileges to access the remote end point. But 
if you want to log on as a different used, credentials will be required.
The 
Get-Credential
cmdlet will prompt you for your username and password:
PS (1) > $cred = Get-Credential
cmdlet Get-Credential at command pipeline position 1 
Supply values for the following parameters: 
Credential
Now that you have the credential object in 
$cred
, you can establish a session on the 
remote machine:
PS (2) > $s = New-PSSession brucepay64h -Credential $cred
Next, you’ll use 
Invoke-Command
to define a new function on the remote machine. 
This is the command you’ll import:
PS (3) > Invoke-Command $s { 
>> function Get-Bios { Get-WmiObject Win32_Bios }
Remote machine
New-PSSession creates connection
PSSession created
Use Invoke-Command to define Get-Bios on remote machine
> } 
>
he new remote function is called 
Get-Bios
and uses 
WMI
(chapter 19) to retrieve 
nformation about the 
BIOS
on the remote machine. Invoke this function through 
xplicit remoting using 
Invoke-Command
so you can see what it does:
S (4) > Invoke-Command $s {Get-Bios}
MBIOSBIOSVersion : 3.34
anufacturer      : Phoenix Technologies, LTD 
ame              : Phoenix - Award BIOS v6.00PG 
erialNumber      : MXK5380BK3 NA580 
ersion           : HP-CPC - 42302e31 
SComputerName    : brucepay64h
returns a set of information about the 
BIOS
on the remote machine. Now you’re set 
p to use 
Import-PSSession
to create a local proxy for this command:
S (5) > Import-PSSession -Session $s -CommandName Get-Bios
oduleType Name                      ExportedCommands 
--------- ----                      ----------------
remoting types are passed along. This metadata is received by the local machine’s proxy 
function generator. It uses this metadata to generate a function that will implicitly call 
Remote machine
Local machine
Command
table on 
remote
machine
User calls Import-Session $s -Command c
Proxy
function 
generator
Request to import cis sent to remote machine
Processed cmetadata 
Import
request 
processor
Look up c
Raw cmetadata
Local
command
table
Add c
User
Figure 12.10 How remote commands are imported by the implicit remoting mechanism. 
Import-PSSession
works by sending a message to the remote computer to retrieve the 
metadata for the requested command. This metadata is processed and returned to the local 
machine, where a proxy advanced function is generated.
478
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
@clientSideParameters `
-HideComputerName `
-Session (Get-PSImplicitRemotingSession `
-CommandName 'Get-Bios') `
-Arg ('Get-Bios', $PSBoundParameters,
$positionalArguments) `
-Script { param($name, $boundParams,
$unboundParams)
& $name @boundParams @unboundParams}}
$steppablePipeline = $scriptCmd.GetSteppablePipeline(
$myInvocation.CommandOrigin)
$steppablePipeline.Begin($myInvocation.ExpectingInput,
$ExecutionContext)
} catch {
throw
process {
try {
$steppablePipeline.Process($_)
} catch {
throw
end {
try {
$steppablePipeline.End()
} catch {
throw
}
Even though this output has been reformatted a bit to make it more readable, it’s a 
pretty complex function and uses many of the more sophisticated features we’ve cov-
ered in previous  chapters. It  uses advanced functions, splatting,  scriptblocks, and 
steppable pipelines. Fortunately, you never have to write these functions yourself.
NOTE
You don’t have to create proxy functions for this particular sce-
nario, but back in section 11.5.2 you saw how this technique can be 
very powerful in extending the PowerShell environment.
The 
Import-PSSession
cmdlet does this for you. It will create a proxy function for 
each command it’s importing, which could lead to a lot of commands. Managing a 
lot of new commands in your environment could be a problem, so let’s go back to 
looking at exactly what the output from 
Import-PSSession 
was. We commented at 
the time that it looked like the output from 
Import-Module
, and this is exactly what 
it is. As  well as  generating  proxy functions  on  your  behalf, 
Import-PSSession
I
MPLICIT
REMOTING
479
creates a module to contain these functions. You’ll use 
Get-Module
to verify this and 
format the output as a list to see all the details:
PS (9) > Get-Module | Format-List *
ExportedCommands    : {Get-Bios}
Name                : tmp_00288002-bcec-43fd-853f-8059edfd2430_y
hv1i4f4.ogw
Path                : C:\Users\brucepay\AppData\Local\Temp\tmp_0
0288002-bcec-43fd-853f-8059edfd2430_yhv1i4
f4.ogw\tmp_00288002-bcec-43fd-853f-8059edf
d2430_yhv1i4f4.ogw.psm1
Description         : Implicit remoting for http://brucepay64h/w
sman
Guid                : 00288002-bcec-43fd-853f-8059edfd2430 
ModuleBase          : C:\Users\brucepay\AppData\Local\Temp\tmp_0
0288002-bcec-43fd-853f-8059edfd2430_yhv1i4
f4.ogw
PrivateData         : {ImplicitRemoting}
Version             : 1.0 
ModuleType          : Script 
AccessMode          : ReadWrite 
ExportedFunctions   : {[Get-Bios, Get-Bios]}
ExportedCmdlets     : {}
NestedModules       : {}
RequiredModules     : {}
ExportedVariables   : {}
ExportedAliases     : {}
SessionState        : System.Management.Automation.SessionState 
OnRemove            :
$sourceIdentifier = 
[system.management.automation.wildcardpattern]::
Escape(
$eventSubscriber.SourceIdentifier)
Unregister-Event -SourceIdentifier `
$sourceIdentifier -Force -ErrorAction `
SilentlyContinue
if ($previousScript -ne $null)
{
& $previousScript $args
}
ExportedFormatFiles : {C:\Users\brucepay\AppData\Local\Temp\tmp_
00288002-bcec-43fd-853f-8059edfd2430_yhv1i
4f4.ogw\tmp_00288002-bcec-43fd-853f-8059ed
fd2430_yhv1i4f4.ogw.format.ps1xml} 
ExportedTypeFiles   : {}
PS (10) >
Documents you may be interested
Documents you may be interested