c# pdf viewer free : How to move pdf pages around software Library dll winforms .net html web forms Windows%20Powershell%20in%20Action%202nd%20Edition53-part1509

500
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
You get the expected 
x86
result, indicating a 32-bit session, and on the 64-bit config-
uration
PS (11) > Invoke-Command -ConfigurationName microsoft.powershell ` 
>> -ComputerName localhost { $ENV:PROCESSOR_ARCHITECTURE } 
>>
AMD64
you get 
AMD64
, indicating a 64-bit configuration.
This is the last remoting consideration we’re going to look at in this chapter. 
Don’t let these issues scare you—they’re mostly edge cases. With some attention to 
detail, the typical script should have no problems working as well remotely as it does 
locally. The PowerShell remoting system goes to great lengths to facilitate a seamless 
remote execution experience. But it’s always better to have a heads up on some of the 
issues so you’ll know where to start looking if you run into a problem. In chapters 14 
and 15, we’ll dig further into the whole PowerShell diagnostic and debugging story. 
12.7
S
UMMARY
In this chapter we introduced PowerShell remoting and the kinds of things you can 
do with it. We covered these topics:
• The basic concepts and terminology used in PowerShell remoting
• How to enable remoting in both domain-joined and private workgroup envi-
ronments using the 
Enable-PSRemoting
cmdlet
• How to apply remoting to build a multimachine monitoring solution
• How to create and manage persistent connections to remote machines using the 
New-PSSession
cmdlet
• How to establish an interactive session using 
Enter-PSSession
Then we moved on to look at PowerShell jobs, which allow you to run tasks in the 
background. In this part of the chapter, we explored the following:
• The basic concepts behind jobs and the commands that you can use to create 
and manage jobs using the 
Start-Job
Stop-Job
Receive-Job
, and 
Remove-
Job
cmdlets
• How to create jobs on remote machines
• How to apply the job concept to implement concurrent solutions for problems 
you might encounter
We closed this chapter by looking into some of the issues you might encounter when 
using remoting to solve management problems:
• Differences in startup directories
• The fact that user profiles aren’t run by default in a remote session
• Some issues using external applications or executables in a remote session
How to move pdf pages around - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reordering pages in pdf; how to rearrange pages in pdf document
How to move pdf pages around - 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 rearrange pages in a pdf document; pdf reverse page order
S
UMMARY
501
• Differences in behavior due to the fact that remote objects are always serialized 
before returning them to the caller
• Differences that occur due to different processor architectures being used on the 
remote end
The information we covered in this chapter is sufficient to apply PowerShell remoting 
effectively for most distributed management tasks. That said, our focus in the chapter 
has been confined to the “remoting client” user perspective. There are some additional 
advanced application and service scenarios that we didn’t cover here. In chapter 13, 
we’ll introduce a new role where you switch from being the user of existing remoting 
configurations to authoring your own custom applications and services. We’ll show 
you how to create custom configurations and how to use these configurations to build 
solutions for delegated administration tasks.
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract, Copy and Paste PDF Pages. View PDF document in continuous pages display mode. 10. Zoom out.
how to rearrange pdf pages reader; rearrange pages in pdf document
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF Pages. Page: Rotate a PDF Page. View PDF document in continuous pages display mode.
change page order in pdf file; move pages in pdf document
502
C
H
A
P T E R   1 3
Remoting: configuring 
applications and services
13.1  Remoting infrastructure in depth  503
13.2  Building custom remoting
services  527
13.3  Summary  551
He who is outside his door already has a hard part of his journey 
behind him.
—Dutch proverb
In chapter 12, we explained how you can use PowerShell’s remoting capabilities to 
monitor and manage remote computers. Now we’re going to switch from service con-
sumer to remote service/application creator. Our goal is that, by the end of this chap-
ter, you’ll be able to build your own custom remoting services with PowerShell. But 
before you can start building those services, we need to look at some additional back-
ground material.
Our first topic is how PowerShell remoting works. We’ll pay special attention to 
Web Services for Management (
WSM
an) and see how it fits into this infrastructure. 
You’ll learn how to manage the Windows 
WSM
an implementation using cmdlets 
and the 
WSM
an provider. This material will help you to understand and debug issues 
in the infrastructure.
C# WPF PDF Viewer SDK to view PDF document in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract extract, copy, paste, C#.NET rotate PDF pages, C#.NET document on RasterEdge C#.NET WPF PDF Viewer
reorder pdf pages in preview; how to move pages within a pdf
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy extract, copy, paste, C#.NET rotate PDF pages, C#.NET document on RasterEdge VB.NET WPF PDF Viewer.
pdf reverse page order; how to reorder pages in pdf preview
R
EMOTING
INFRASTRUCTURE
IN
DEPTH
503
If you want your services to be usable, among other aspects you need to be sure 
that they’re secure and reliable. Among the factors related to security that you must 
take into account are authentication (who’s connecting to the service) and authoriza-
tion (what they’re allowed to do). 
The  other  aspect—reliability—entails managing and controlling resource con-
sumption. We looked at resource consumption from the user perspective when we 
discussed command-level throttling in chapter 12. In this chapter, we’ll look at how 
to control resource consumption from the application end.
Once we’re done with the background material, we’ll show you how to construct 
services by building custom named remoting configurations that users can connect 
to. We’ll explain how to create these configurations and how to define the set of com-
mands these configurations expose. We’ll look at configurations with extended com-
mand sets where commands are added to the default set PowerShell that exposes and, 
more important, how to restrict the set of commands that can be accessed through an 
endpoint configuration. This second scenario is important because it allows you to 
securely create applications like self-service kiosks. Let’s start with the infrastructure 
investigation and see how you can achieve these goals.
13.1
R
EMOTING
INFRASTRUCTURE
IN
DEPTH
Before you start building services and applications with PowerShell remoting, you 
must develop a good understanding for how everything works. Understanding how 
things work will help you design and deploy your services more effectively. You’ll have 
the knowledge to make sure your services are available to the service consumer, and 
you’ll be able to effectively debug what’s gone wrong when something doesn’t work 
the way it’s expected.
We’ll begin our infrastructure exploration by looking at the protocol stack—the 
layers of networking technology used to enable PowerShell remoting. Because basic 
connectivity for PowerShell remoting is provided by the 
WSM
an layer, the next thing 
we’ll explore are the cmdlets that you can use to configure and manage 
WSM
an.
Then we’ll describe how authentication is handled, both from the client and from 
the servers’ perspective. We’ll look at how targets are addressed and the concerns that 
you need to be aware of in this area. Finally, we’ll end this section by looking at man-
aging connection-related issues such as resource consumption. These topics will help 
you build your services in such a way that your end user can depend on them. Let’s 
begin by looking at the protocol stack. 
13.1.1
The PowerShell remoting protocol stack 
Most networked applications are built on top of multiple layers of software, and Pow-
erShell remoting is no different. In this section, we’ll describe the various components 
used by PowerShell remoting.
For remoting to work, there must be layers of software to provide the transport 
mechanism for sending messages between the client and the server. These layers are
504
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
called the protocol layers, which are organized in a protocol stack. Within this stack, 
higher  layers  build  on the services  provided by the  lower layers.  For PowerShell 
remoting, there are five layers to the stack. The top layer is 
MS-PSRP
, the PowerShell 
Remoting Protocol. 
MS-PSRP
is built on top of 
WSM
an. 
WSM
an is, in turn, built on 
top of the Simple Object Access Protocol 
(SOAP)
SOAP
is built on top of the Hyper-
text Transport Protocol 
(HTTP)
, or  more precisely,  Secure 
HTTP
(HTTPS)
, and 
finally the hypertext transfer protocols are in turn based on 
TCP/IP
. The complete 
stack of protocols is shown in figure 13.1.
The  PowerShell  Remoting  Protocol  uses  Microsoft’s  implementation  of  the 
WSM
an protocol, designated Web Services Management Protocol Extensions for Win-
dows Vista 
(MS-WSMV)
to establish a connection and transfer data between the client 
and the server. 
MS-WSMV
is built on top of the standard protocols shown in table 13.1.
Table 13.1 The standard protocols used by PowerShell remoting
Protocol
Standards body
Specification
SOAP (Version 1.2)
World Wide Web Consortium (W3C)
SOAP 1.2/1
Hypertext Transfer Protocol (HTTP/1.1)
Internet Engineering Task Force (IETF)
RFC 2616
HTTP over TLS
IETF
RFC 2818
Transmission Control Protocol
IETF
RFC 793
Internet Protocol
IETF
RFC 791
PowerShell Remoting Protocol
(MS-PSRP)
Web Services for Management
(MS-WSMV)
Simple Object Access Protocol
(SOAP)
PowerShell client
(Secure) Hypertext Transport
Protocol (HTTP/HTTPS)
Transmission Control Protocol/
Internet Protocol (TCP/IP)
Encoded client request
Encoded server response
PowerShell server
PowerShell Remoting Protocol
(MS-PSRP)
Web Services for Management
(MS-WSMV)
Simple Object Access Protocol
(SOAP)
(Secure) Hypertext Transport
Protocol (HTTP/HTTPS)
Transmission Control Protocol/
Internet Protocol (TCP/IP)
Figure 13.1 The PowerShell remoting protocol stack. The PowerShell Re-
moting Protocol (MS-PSRP) is based on industry-standard “firewall friend-
ly” protocols simplifying deployment in an enterprise environment.
R
EMOTING
INFRASTRUCTURE
IN
DEPTH
505
Although 
MS-PSRP
is a proprietary protocol, it’s fully documented and this docu-
mentation is freely available. The complete specification for the PowerShell remoting-
protocol is available at http://mng.bz/b4eo.
Likewise, the complete documentation for  the specific  implementation  of  the 
WSM
an protocol that PowerShell uses for 
MS-WSMV
is available at http://mng.bz/ 
92fo.
NOTE
These protocols are made available under the Microsoft Com-
munications Protocol Program. The goal of this program is to facilitate 
to interoperation and communications natively with Windows Server 
operating systems.
Protocol operation
When the user passes a PowerShell scriptblock to the remoting cmdlets for execution, 
the scriptblock will first be encoded by the remoting layers as structured 
XML
text. 
(The structure, or schema, for this 
XML
is documented in 
MS-PSRP
.) The encoded 
text is then sent to the target computer where it’s decoded or rehydrated into a pipe-
line that can be executed on the remote machine.
Along with the commands in the pipeline, the encoded pipeline needs to include 
any arguments to the commands. Although encoding the commands is relatively 
easy, encoding the arguments is more difficult because they can be any arbitrary type. 
Here’s the issue you’ll run into: as mentioned in chapter 12, serializing an object so 
you can get the same type of object at the destination requires that the type metadata 
for that object be present on both ends of the connection. If the original type descrip-
tion doesn’t exist at the receiver, then the object  can’t be completely  rehydrated 
because there’s no concrete type definition to rehydrate to. In the systems manage-
ment world, this situation is quite common because servers tend to be assigned to dif-
ferent roles. For example, an Exchange server will have a different set of types than a 
database server, and the client that’s managing both of these servers may not have any 
of these types. To mitigate this problem, PowerShell takes a different approach to 
sharing objects among different computers.
NOTE
We say mitigate here because there really isn’t a perfect solu-
tion with an unbounded set of types. If you restrict the types, you lose 
functionality, and if you require all types everywhere, systems become 
unmanageably complex. By the way, you’ll see the term mitigate again 
in chapter 21 when we discuss another problem that can’t be com-
pletely resolved: security.
Representing objects and types in the protocol
Instead of trying to accommodate all possible types, PowerShell defines a core set of 
types that are required to be on both ends of the connection. Any object that’s one of
506
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
these types will be rehydrated into the correct type. For any types that aren’t in this 
core set, a different approach is used. These objects are “shredded” into property bags 
of type 
PSObject
. (We discussed 
PSObject
at length in chapter 11.) The algorithm 
for doing this is described in detail in section 2.2.5 of 
MS-PSRP
. The types that are 
serialized with fidelity are shown in table 13.2.
There are also some types of collections that are serialized with some level of fidelity. 
These types are listed in table 13.3.
Table 13.2 The types that are serialized with fidelity by the PowerShell remoting protocol
MS-PSRP 
Protocol element
Corresponding PowerShell/.NET type
2.2.5.1.1
String
[string]
2.2.5.1.2 
Character
[char]
2.2.5.1.3 
Boolean
[bool]
2.2.5.1.4
Date/Time 
[DateTime]
2.2.5.1.5 
Duration
[TimeSpan]
2.2.5.1.6 
Unsigned Byte
[byte]
2.2.5.1.7 
Signed Byte
[sbyte]
2.2.5.1.8 
Unsigned Short
[uint16]
2.2.5.1.9 
Signed Short
[int16]
2.2.5.1.10 
Unsigned Int
[uint32]
2.2.5.1.11 
Signed Int
[int32]
2.2.5.1.12 
Unsigned Long
[int64]
2.2.5.1.13 
Signed Long
[uint64]
2.2.5.1.14 
Float
[float] or [single]
2.2.5.1.15 
Double
[double]
2.2.5.1.16 
Decimal
[decimal]
2.2.5.1.17 
Array of Bytes
[byte[]]
2.2.5.1.18 
GUID
[Guid]
2.2.5.1.19 
URI
[Uri]
2.2.5.1.20 
Null Value
$null
2.2.5.1.21 
Version
[Version]
2.2.5.1.22 
XML Document
[xml]
2.2.5.1.23 
ScriptBlock
[ScriptBlock]
2.2.5.1.24 
Secure String
[System.Security.SecureString]
2.2.5.1.25 
Progress Record
[System.Management.Automation.ProgressRecord]
2.2.5.2.7 
Enums
[int32]
R
EMOTING
INFRASTRUCTURE
IN
DEPTH
507
Note that table 13.3 lists different types for encoding and decoding in two cases: 
List 
and 
Dictionary
. In case you’re wondering what that means, here’s an explanation. On 
the sender’s side, any object that implements the 
IList
interface will be encoded as 
List
when serialized. On the receiver’s side, PowerShell will always decode the collec-
tion into an instance of type 
System.Collections.ArrayList
. For example:
PS (1) > $r = Invoke-Command localhost { 
>>     ,(1,2,3) 
>>     } 
>>
In this example, you’re sending a collection of integers through the remoting layer.
NOTE
The leading comma in this example is not a typo. The unary 
comma operator (see section 5.2) wraps its argument in a one-element 
array. This is necessary to make sure the array is passed as a single array 
object instead of as a sequence of numbers.
Let’s look at the type of object the receiver actually gets:
PS (2) > $r.GetType().FullName 
System.Collections.ArrayList
Even though you send a simple array of numbers, the remoting layer decoded it into 
an 
ArrayList
. This behavior applies to more complex list types as well. In the next 
example, you’re sending a generic collection of integers. This collection also comes 
back as 
System.Collections.ArrayList
on the receiving end:
PS (3) > $r = Invoke-Command localhost { 
>>     $l = New-Object System.Collections.Generic.List[int] 
>>     1..10 | %{ $l.Add($_) } 
>>     ,$l 
>>     } 
>>
PS (4) > $r.GetType().FullName 
System.Collections.ArrayList
Similarly,  any  .
NET
type  that  implements  the  interface 
System.Collections 
.IDictionary
will be encoded as 
Dictionary
and decoded into 
[hashtable]
.
Table 13.3 Collection types handled by the serializer
Protocol 
type
Encoded type
Decoded type
Stack
[System.Collections.Stack]
[System.Collections.Stack]
Queue
[System.Collections.Queue]
[System.Collections.Queue]
List
[System.Collections.IList]
[System.Collections.ArrayList]
Dictionaries [System.Collections.IDictionary] [hashtable]
508
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
When you’re sending an object that isn’t in the known type pool, you get a prop-
erty bag back instead of an instance of the original type. For example, let’s return a 
Process
object through the remoting channel:
PS (1) > $r = Invoke-Command localhost { (Get-Process csrss)[0] }
Now look at the output:
PS (2) > $r | fl
Id             : 568
Handles        : 956 
CPU            : 39.0626504 
Name           : csrss 
PSComputerName : localhost
It appears to return the same set of members as a real 
Process
object would, but 
there are some differences. For example, look at the 
VM
property:
PS (3) > $r | Get-Member vm
TypeName: Deserialized.System.Diagnostics.Process
Name MemberType   Definition 
---- ----------   ----------
VM   NoteProperty System.Int32 VM=77340672
Now compare this output to a real 
Process
object:
PS (4) > Get-Process | Get-Member vm
TypeName: System.Diagnostics.Process
Name MemberType    Definition 
---- ----------    ----------
VM   AliasProperty VM = VirtualMemorySize
In the deserialized case, the type of the object is shown prefixed with 
Deserialized 
and the 
VM
property is a 
NoteProperty
containing a fixed integer value. On the live 
Process
object, you see that the 
VM
property is an alias that points to the 
Virtual-
MemorySize
property on the object. Another difference is that the deserialized object 
has fewer members on it:
PS (5) > ($r | Get-Member).count 
66 
PS (6) > (Get-Process csrss | Get-Member).count 
90
In particular, the deserialized object has only one method in it, 
ToString()
PS (7) > @($r | Get-Member -type method).count 
1
as opposed to the live object, which has the full set of methods defined for the type:
PS (8) > @(Get-Process csrss | Get-Member -type method).count 
19
R
EMOTING
INFRASTRUCTURE
IN
DEPTH
509
Because the object isn’t live (meaning that there’s no connection to the 
Process 
object, it was derived from on the remote machine), propagating the methods makes 
no sense. And, for performance reasons, not all the properties are included and, if an 
included property is itself a complex type, the deserialized version may only contain 
the 
ToString()
of the value of the live property. This compression of properties is 
done to reduce the amount of information transmitted, thereby improving perfor-
mance in the remoting layer.
This approach works well in that it allows for easy operation between the various 
clients and servers but with the downside that a certain amount of information is lost. 
But because of the way PowerShell parameter binding works, this “lossy serialization” 
isn’t usually a problem. PowerShell functions and cmdlets don’t care what type the 
object is as long as the required properties are there. 
Now that you have a good grasp of how the PowerShell protocol layer works, let’s 
move down the protocol stack to the 
WSM
an layer. We won’t be digging into the 
details of the protocol itself—that’s beyond the scope of this chapter. What you really 
need to know is how the 
WSM
an layer is managed, so that’s what we’ll focus on.
13.1.2
Using the WSMan cmdlets and providers
Because  PowerShell  remoting  is  built  on  top  of  Microsoft’s  implementation  of 
WSM
an, in this section we’ll look at configuring and managing the 
WSM
an service 
on a computer. The management interface for 
WSM
an is exposed through cmdlets 
and  through  the 
WSM
an  provider,  which  implements  the 
WSM
an:  drive.  The 
WSM
an cmdlets are listed in table 13.4.
Table 13.4 Cmdlets for working with WSMan
Cmdlet name
Description
Test-WSMan
Submits an identification request that determines whether the WinRM 
service is running on a local or remote computer. If the tested com-
puter is running the service, the cmdlet displays the WSMan identity 
schema, protocol version, product vendor, and the product version of 
the tested service.
Connect-WSMan
Disconnect-WSMan
The Connect-WSMan cmdlet establishes a persistent connection to 
the WinRM service on a remote computer. Once the connection is 
established, the remote computer will appear as a subdirectory of the 
root directory of the WSMan: drive. Use the Disconnect-WSMan
cmdlet to terminate the connection to the remote computer.
Get-WSManCredSSP
Enable-WSManCredSSP 
Disable-WSManCredSSP
The Get-WSManCredSPP cmdlet gets the Credential Security Service 
Provider (CredSSP) status for the machine on which it is run. The out-
put shows the machines status for both the client role (will or won’t 
forward credentials) and the server role (will or won’t accept for-
warded credentials). Use the Enable-WSManCredSSP cmdlet to 
enable the CredSSP delegation on either the client or server. Use the 
Disable-WSManCredSSP to disable CredSSP on a server.
New-WSManSession-
Option
Creates a WSMan session option hashtable, which can be passed into 
WSMan cmdlets, including Connect-WSMan.
Documents you may be interested
Documents you may be interested