c# pdf viewer free : How to rearrange pdf pages online application Library tool html .net wpf online Windows%20Powershell%20in%20Action%202nd%20Edition42-part1497

390
CHAPTER 10
M
ODULE
MANIFESTS
AND
METADATA
unloaded you’ll want that connection to be closed. You’ll see an example of this pat-
tern when we look at implicit remoting in chapter 13. The 
PSModuleInfo
object pro-
vides a way to do this through its 
OnRemove
property.
To set up an action to execute when a module is unloaded, assign a script block 
defining  the  action to  the 
OnRemove
property on the module’s
PSModuleInfo 
object. Here’s an example that shows how this is done:
PS (1) > Get-Content .\onremove.psm1 
$mInfo = $MyInvocation.MyCommand.ScriptBlock.Module 
$mInfo.OnRemove = {
Write-Host "I was removed on $(Get-Date)"
}
You get the 
PSModuleInfo
object in the first line, and then assign a script block that 
displays a message to the 
OnRemove
property. (Note that you have to call 
Write-
Host
if you want to see the message because the output of the script block is simply 
ignored.) Let’s try it out. Import the module:
PS (2) > Import-Module .\onremove.psm1
Then remove it:
PS (3) > Remove-Module onremove 
I was removed on 01/16/2010 22:05:00
And the message from the script block was printed, confirming that the 
OnRemove 
action was executed.
And with that, we’re done with modules...well, mostly done—there are a few even 
more advanced techniques that will be covered in chapter 11. 
10.8
S
UMMARY
In this chapter, you expanded your knowledge of PowerShell modules by exploring 
features provided to support production-oriented coding in PowerShell. We looked at 
module manifests and how they’re used to add metadata to a module. Next we exam-
ined each of the manifest elements and their role in the process. Finally we investi-
gated some advanced techniques using the module information object. Here are some 
important points about using modules with manifests:
• Production modules are stored in a directory containing the module manifest 
and content. The metadata or information about a module is contained in a 
.psd1 file usually with the same name as the module directory.
• The easiest way to create a module manifest is to use the 
New-ModuleManifest 
cmdlet. A second cmdlet, 
Test-ModuleManifest
, is provided to test an exist-
ing module for issues.
• A manifest lets you define three types of information for your module: produc-
tion, construction, and content. Production metadata defines things like ver-
sion number and dependencies. Construction elements control how a module is
How to rearrange pdf pages online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change pdf page order online; change page order in pdf file
How to rearrange pdf pages online - 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 pdf pages reader; how to reorder pdf pages in
S
UMMARY
391
constructed,  including  specifying  any  nested  modules.  Content  manifest 
elements deal with other types of content in the module.
In the latter part of this chapter, we looked in more detail at how modules are repre-
sented in memory and the kinds of operations you can perform once you have the 
module information object. Here are some of the key topics we covered:
• Modules in memory are represented by a 
PSModuleInfo
object. This object 
allows you to perform a number of advanced scenarios with modules. 
• The 
PSModuleInfo
object for a module can be retrieved using 
Get-Module
Alternatively,  the  module  object  for  a  function  can  be  retrieved  using  the 
Module
property on a script block for that function.
• If you have access to the 
PSModuleInfo
object for a module, you can inject 
code into the module, where it will be executed in the module context. This 
allows you to manipulate the state of a module without having to reload it. This 
feature is primarily intended for diagnostic and debugging purposes.
• From within a script module, you can use the 
PSModuleInfo
object to directly 
set some metadata elements like the module description.
PSModuleInfo
object has an 
AccessMode
field that controls the ability to 
update or remove a module from the session. This field is set to 
ReadWrite
by 
default but can be set to 
Static
, requiring the use of the 
-Force
parameter (to 
update it) or 
Constant
(which means it can’t be removed from the session). A 
Constant
module remains in the session until the session ends.
• To set up an action to be taken when a module is removed, you can assign a 
script block to the 
OnRemove
property on the 
PSModuleInfo
object for that 
module.
Let’s stop for a minute and check where we are. With this chapter, we’ve now covered 
all the core topics necessary for understanding how to script in PowerShell. We dis-
cussed syntax, operators, and data types in chapters 2 through 6. In chapters 7 and 8, 
we covered functions and scripts, and finally, in chapters 9 and 10 we explored mod-
ules. In the next chapter, we’ll look at some more advanced programming topics that 
build on what you’ve learned. These advanced topics will not only introduce some 
powerful new ways of using PowerShell, they’ll also engender a deep understanding of 
how PowerShell works.
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.
change page order in pdf online; reorder pages in pdf preview
Online Merge PDF files. Best free online merge PDF tool.
Then press the button below and download your PDF. By dragging your pages in the editor area you can rearrange them or delete single pages.
move pages in pdf file; rearrange pages in pdf online
392
C
H
A
P T E R   1 1
Metaprogramming with 
scriptblocks and 
dynamic code
11.1  Scriptblock basics  393
11.2  Building and manipulating 
objects  400
11.3  Using the Select-Object cmdlet  410
11.4  Dynamic modules  412
11.5  Steppable pipelines  418
11.6  A closer look at the type-system 
plumbing  423
11.7  Extending the PowerShell 
language  428
11.8  Building script code at runtime  436
11.9  Compiling code with Add-Type   440
11.10  Summary  445
Philosophy have I digested, The whole of Law and Medicine, From each its secrets I 
have wrested, Theology, alas, thrown in. Poor fool, with all this sweated lore, I stand 
no wiser than I was before.
—Johann Wolfgang Goethe, Faust
Greek letters are cool... 
—Not actually a quote from Beavis and Butthead
Chapters 7 and 8 covered the basic elements of programming in PowerShell: func-
tions and scripts. Chapters 9 and 10 introduced modules as a way of aggregating your 
code into reusable pieces through modules. In this chapter, we’ll take things to the
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
change page order pdf reader; how to move pages in a pdf document
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
a PDF document which is out of order, you need to rearrange the PDF you with examples for adding an (empty) page to a PDF and adding empty pages to a
rearrange pdf pages in preview; how to move pages in pdf converter professional
S
CRIPTBLOCK
BASICS
393
next level and talk about metaprogramming. Metaprogramming is the term used to 
describe the activity of writing programs that create or manipulate other programs. If 
you’re not already familiar with this concept, you may be asking why you should care. 
In chapter 1, we talked about designing classes and how hard it is to get those designs 
right. In most environments, if the designer makes a mistake, the user is stuck with 
the result. This isn’t true in PowerShell. Metaprogramming lets you poke into the 
heart of the system and make things work the way you need them to. Here’s an anal-
ogy that should give you the full picture.
Imagine buying a computer that was welded shut. There’s still a lot you can do with 
it—run all the existing programs and even install new programs. But there are some 
things you can’t do. If it doesn’t have any 
USB
ports, you can’t add them. If it doesn’t 
have any way to capture video, you can’t add that either without opening the case. And 
even though most people buy a computer with the basic features they need and never 
add new hardware, a case that’s welded shut doesn’t allow for hardware tinkering.
Traditional programming languages are much like that welded computer. They 
have a basic set of features, and although you can extend what they do by adding librar-
ies, you can’t extend the core capabilities of the language. For example, you can’t add 
a new type of looping statement. On the other hand, in a language that supports 
metaprogramming, you can undertake such activities as adding new control structures. 
This is how the 
Where-Object
and 
ForEach-Object
cmdlets are implemented. They 
use the metaprogramming features in PowerShell to add what appear to be new lan-
guage elements. You can even create your own variations of these commands.
We’ll begin  our  investigation with a  detailed discussion of  PowerShell  script-
blocks, which are at the center of most of the metaprogramming techniques. This 
discussion takes up the first part of this chapter and lays the groundwork for the rest 
of what we’ll discuss. With that material as context, we’ll look at how and where 
scriptblocks are used in PowerShell. We’ll look at the role scriptblocks play in the 
creation of custom objects and types, and how they can be used to extend the Pow-
erShell language. We’ll cover techniques like proxy functions, dynamic modules, and 
custom objects—all of which are examples of applied metaprogramming. Then we’ll 
move on, and you’ll see how you can use similar techniques with static languages 
like 
C
# from within your scripts. Finally, we’ll look at using events—a related tech-
nique that also involves scriptblocks. But first, you need to understand scriptblocks 
themselves.
11.1
S
CRIPTBLOCK
BASICS
In this section we’ll talk about how to create and use scriptblocks. We’ll begin by 
explaining how commands are invoked so you can understand all the ways to invoke 
scriptblocks. Next, we’ll cover the syntax for scriptblock literals and the various types 
of scriptblocks you can create. This includes using scriptblocks as functions, as filters, 
and as cmdlets. Finally, we’ll discuss how you can use scriptblocks to define new func-
tions at runtime. Let’s dive into the topic by starting with definitions.
C# PowerPoint - How to Process PowerPoint
the simplest procedures, for instance, using online clear C# out useless PowerPoint document pages simply with solution to sort and rearrange PowerPoint slides
move pages in pdf document; reordering pdf pages
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages in extracting single or multiple Word pages at one & profession imaging controls, PDF document, image
how to reorder pages in pdf; change pdf page order preview
394
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
In PowerShell,  the key  to metaprogramming (writing programs  that  write or 
manipulate other programs) is the scriptblock. This is a block of script code that exists 
as an object reference but doesn’t require a name. The 
Where-Object
and 
ForEach-
Object
cmdlets rely on scriptblocks for their implementation. In the example
1..10 | foreach { $_ * 2 }
the expression in braces—
{ $_ * 2 }
—is actually a scriptblock. It’s a piece of code 
that’s passed to the 
ForEach-Object
cmdlet and is called by the cmdlet as needed.
So that’s all a scriptblock is—a piece of script in braces—but it’s the key to all the 
advanced programming features in PowerShell.
NOTE
What we call scriptblocks in PowerShell are called anonymous 
functions  or sometimes lambda  expressions in other  languages. The 
term lambda comes from the lambda calculus developed by Alonzo 
Church and Stephen Cole Kleene in the 1930s. A number of languages, 
including Python and dialects of 
LISP
, still use lambda as a language 
keyword. In designing the PowerShell language, the PowerShell team 
felt that calling a spade and spade (and a scriptblock a scriptblock) was 
more straightforward (the coolness of using Greek letters aside).
We’ve said that scriptblocks are anonymous functions, and of course functions are 
one of the four types of commands. But wait! You invoke a command by specifying 
its name. If scriptblocks are anonymous, they have no name—so how can you invoke 
them? This necessitates one more diversion before we really dig into scriptblocks. 
Let’s talk about how commands can be executed.
11.1.1
Invoking commands
The way to execute a command is just to type its name followed by a set of argu-
ments, but sometimes you can’t type the command name as is. For example, you 
might have a command with a space in the name. You can’t simply type the com-
mand because the space would cause part of the command name to be treated as an 
argument. And you can’t put it in quotes, because this turns it into a string value. So 
you have to use the call operator, 
&
. If, for instance, you have a command called 
my 
command
, you’d invoke this command by typing the following:
& "my command"
The interpreter sees the call operator and uses the value of the next argument to look 
up the command to run. This process of looking up the command is called command 
discovery.  The  result  of  this  command  discovery  operation  is  an  object  of  type 
System.Management.Automation.CommandInfo
, which tells the interpreter what 
command to execute. There are different subtypes of 
CommandInfo
for each of the 
types of PowerShell commands. In the next section, you’ll learn how to obtain these 
objects and how to use them.
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
move pdf pages; rearrange pdf pages reader
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods and powerful & profession imaging controls, PDF document, image
rearrange pages in pdf reader; move pages in pdf
S
CRIPTBLOCK
BASICS
395
Getting CommandInfo objects
You’ve used the 
Get-Command
cmdlet before as a way to attain information about a 
command. For example, to get information about the 
Get-ChildItem
cmdlet, you’d 
use the following:
PS (1) > Get-Command Get-ChildItem
CommandType     Name                     Definition 
-----------     ----                     ----------
Cmdlet          Get-ChildItem            Get-ChildItem [[-Pat...
This shows you the information about a command: the name of the command, the 
type of command, and so on. 
NOTE
In the previous 
Get-Command
example, the command’s defini-
tion was truncated to fit the book-formatting requirements. You can 
control how this information is described by using the 
Format-List 
and 
Format-Table
commands.
This is useful as a kind of lightweight help, but in addition to displaying information, 
the object returned by 
Get-Command
can be used with the call operator to invoke that 
command. This is significant. This extra degree of flexibility, invoking a command 
indirectly, is the first step on the road to metaprogramming. 
Let’s try this out—first get the 
CommandInfo
object for the 
Get-Date
command:
PS (1) > $d = Get-Command Get-Date 
PS (2) > $d.CommandType 
Cmdlet 
PS (3) > $d.Name 
Get-Date
As you can see from this example, the name 
Get-Date
resolves to a cmdlet with the 
name 
Get-Date
. Now run this command using the 
CommandInfo
object with the 
call operator:
PS (4) > & $d
Sunday, May 21, 2006 7:29:47 PM
It’s as simple as that. So why should you care about this? Because it’s a way of getting 
a handle to a specific command in the environment. Say you defined a function 
Get-
Date
:
PS (1) > function Get-Date {"Hi there"} 
PS (2) > Get-Date 
Hi there
Your new 
Get-Date
command outputs a string. Because PowerShell looks for func-
tions before it looks for cmdlets, this new function definition hides the 
Get-Date 
cmdlet. Even using 
&
with the string “Get-Date” still runs the function:
PS (3) > & "Get-Date" 
Hi there
396
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Because you created a second definition for 
Get-Date
(the function), now if you use 
Get-Command
you’ll see two definitions. So how do you unambiguously select the 
cmdlet 
Get-Date
?
PS (4) > Get-Command Get-Date
CommandType     Name                     Definition 
-----------     ----                     ----------
Cmdlet          Get-Date                 Get-Date [[-Date] <D... 
Function        Get-Date                 "Hi there"
One way is to select the 
CommandInfo
object based on the type of the command: 
PS (5) > Get-Command -CommandType cmdlet Get-Date
CommandType     Name                     Definition 
-----------     ----                     ----------
Cmdlet          Get-Date                 Get-Date [[-Date] <D...
Now put the result of this command into a variable
PS (6) > $ci = Get-command -CommandType cmdlet Get-Date
and then run it using the call operator:
PS (7) > & $ci
Sunday, May 21, 2006 7:34:33 PM
The 
Get-Date
cmdlet was run as expected. Another way to select which command to 
run, because 
Get-Command
returns a collection of objects, is to index into the collec-
tion to get the right object:
PS (8) > &(Get-Command Get-Date)[0]
Sunday, May 21, 2006 7:41:28 PM
Here you used the result of the index operation directly with the call operator to run 
the desired command.
This is all interesting, but what does it have to do with scriptblocks? We’ve dem-
onstrated that you can invoke a command through an object reference instead of by 
name. This was the problem we set out to work around. Scriptblocks are functions 
that don’t have names; so, as you might expect, the way to call a scriptblock is to use 
the call operator. Here’s what that looks like
PS (1) > & {param($x,$y) $x+$y} 2 5 
7
In this example, the scriptblock is
{param($x,$y) $x+$y}
This example used the call operator to invoke it with two arguments, 2 and 5, so the 
call returns 7. This is how you can execute a function if it doesn’t have a name. As 
long as you have access to the scriptblock, you can call it.
S
CRIPTBLOCK
BASICS
397
11.1.2
The scriptblock literal
Scriptblocks are the center of pretty much everything we do in this chapter. Because 
the most common form of scriptblock is the scriptblock literal, it’s worth investing 
some time looking at them in detail. You’ll learn how to specify a scriptblock literal 
that acts as a function, how to specify one that acts like a filter, and finally how to 
define a scriptblock cmdlet.
What you’ve been writing to create scriptblocks is called a scriptblock literal—in 
other words, a chunk of legitimate PowerShell script surrounded by braces. The syn-
tax for this literal is shown in figure 11.1.
The definition of a scriptblock looks more or less like the definition of a function, 
except the 
function
keyword and function name are missing. If the 
param
state-
ment isn’t present, the scriptblock will get its arguments through 
$args
, exactly as a 
function would.
Scriptblocks, like regular functions or scripts, can also behave like cmdlets. In other 
words, they can have one or all of the 
begin
process
, or 
end
clauses that you can
{ param ( <parameter list> ) <statementList> }
param keyword
List of parameters
to scriptblock
List of statements that make up
scriptblock body
Braces marking beginning and end
of scriptblock body
Figure 11.1 Defining a simple scriptblock. Note that the 
param
statement is optional, 
so a minimal scriptblock only has the braces.
Param vs. lambda
The param statement in PowerShell corresponds to the lambda keyword in other 
languages. For example, the PowerShell expression
& {param($x,$y) $x+$y} 2 5
is equivalent to the LISP expression 
(lambda (x y) (+ x y)) 2 5)
or the Python expression
(lambda x,y: x+y)(2,5)
Also note that, unlike Python lambdas, PowerShell scriptblocks can contain any 
collection of legal PowerShell statements.
398
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
have in a function or script. Figure 11.2 shows the most general form of the script-
block syntax, including all three clauses. 
As was the case with a regular function, you don’t have to define all the clauses. 
Here’s an example that uses only the 
process
clause:
PS (1) > 1..5 |&{process{$_ * 2}} 
10
A scriptblock written this way works like the filters you saw in chapter 7. It also works 
like the 
ForEach-Object
cmdlet, as shown here:
PS (2) > 1..5 |foreach {$_ * 2} 
10
The 
ForEach-Object
cmdlet is effectively a shortcut for the more complex script-
block construction.
As we’ve been going along, we keep talking about how scriptblocks are anony-
mous functions. This is a good time to see how scriptblocks and named functions are 
related.
11.1.3
Defining functions at runtime
In earlier sections, we said that scriptblocks were functions without names. The con-
verse is also true—functions are scriptblocks with names. So what exactly is the rela-
tionship between the two? In chapter 7, you learned how to manage the functions in 
your PowerShell session using the function: drive. To get a list of functions, you could 
do a 
dir
of that drive:
dir function:/
param ( <parameter list> )
begin { 
<statementList> 
process { 
<statementList> 
end { 
<statementList> 
}
}
param keyword
List of formal parameters
to scriptblock
List of statements to process
in begin phase
List of statements to execute
for each pipeline object
List of statements to process
during end phase
Figure 11.2 
A scriptblock that 
works like a cmdlet
S
CRIPTBLOCK
BASICS
399
You could also delete or rename functions. But we didn’t cover the whole story. In 
fact, the function: drive is, in effect, a set of variables containing scriptblocks. Let’s 
explore this further. First, let’s define our favorite function, 
foo
:
PS (1) > function foo {2+2} 
PS (2) > foo 
4
You can use the 
dir
cmdlet to get the command information from the function 
provider:
PS (3) > dir function:foo
CommandType     Name                     Definition 
-----------     ----                     ----------
Function        foo                      2+2
Now use 
Get-Member
to get more information about the object that was returned:
PS (4) > dir function:foo | Get-Membersc*
TypeName: System.Management.Automation.FunctionInfo
Name        MemberType Definition 
----        ---------- ----------
ScriptBlock Property   System.Management.Automation.ScriptBlo...
The object that came back to you was a 
FunctionInfo
object. This is the subclass of 
CommandInfo
that’s used to represent a function. As you see, one of the properties on 
the object is the scriptblock that makes up the body of the function. Retrieve that 
member:
PS (5) > (dir function:foo).ScriptBlock 
2+2
The scriptblock, when displayed as a string, shows the source code for the script-
block. Another, simpler way to get back the scriptblock that defines a function is to 
use the variable syntax:
PS (6) > $function:foo 
2+2 
PS (7) > $function:foo.GetType().Fullname 
System.Management.Automation.ScriptBlock
Now here’s the interesting part. Change the definition of this function by assigning a 
new scriptblock to the function:
PS (8) > $function:foo = {"Bye!"}
When you run the function again
PS (9) > foo
Bye!
you see that it’s changed. The function keyword is, in effect, shorthand for assigning 
to a name in the function provider.
Documents you may be interested
Documents you may be interested