c# pdf viewer itextsharp : How to move pages within a pdf application software tool html windows winforms online Windows%20Powershell%20in%20Action%202nd%20Edition76-part1534

730
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
Because we had to ship well before .
NET
4 was out, we decided to wait 
one more release  and let the dust  settle. We’re  keeping our  fingers 
crossed that we’ll finally get native type definition capabilities into v3 
(actually fingers, toes, eyes, and any other anatomical protuberances 
that come to mind).
In addition to providing a mechanism for loading assemblies, the 
Add-Type
cmdlet 
provides a workaround of sorts for this inability to create new types. In fact 
Add-Type 
offers a variety of ways to create types. We’ll cover each mechanism in the following 
subsections.
Creating singleton member definitions 
The first approach for creating types with the 
Add-Type
cmdlet is to define a single 
member, typically a method. The signature for this use is shown in figure 17.3.
With this signature, you’re creating a member whose name is specified by the 
-Name
parameter and whose source code is specified by the 
-MemberDefinition 
parameter. Because the member definition is just a string, you also have to specify the 
language used to define the member. You can do so with the 
-Language
parameter, 
which supports four languages in v2, selected by passing in one of the following strings: 
CS
harp”, “
CS
harp
V
ersion3”, “
V
isual
B
asic”, or “
JS
cript”. These are the four base lan-
guages shipped by Microsoft with .
NET
. If nothing is specified, v2 defaults to 
C
#.
Because types in .
NET
are organized by namespaces, you can use the 
-Namespace 
parameter to put the member into a specific namespace.
Next, you have to specify what the member definition depends on. The point of 
this variant is that you only need to write a fragment of a source file, so you can’t 
specify the dependencies in  the source. Instead, you  do  it  through  the 
-Using-
Namespace
parameter.
Add-Type 
[-Name] <string> 
[-MemberDefinition] <string[]>
[-Namespace <string>] 
[-UsingNamespace <string[]>] 
[-Language <SourceLanguage>]
[-CodeDomProvider <CodeDomProvider>]
[-CompilerParameters <CompilerParameters>]
[-OutputAssembly <Filename>]
[-OutputType <OutputAssemblyType>]
[-ReferencedAssemblies <string[]>]
[-IgnoreWarnings] 
[-PassThru]
Pass generated assembly object
through to output stream
Code generator to
use when compiling
Name of output
assembly file to 
create
Type of output file
(library, console app, 
or Windows app)
Additional assemblies
to reference when 
compiling
Parameters to pass
to the compiler
Ignore any compile
time warnings
Name of class
to create
Namespaces to include
when compiling
Properties and
methods to create
Compiler to use
(e.g. C#, VB)
Namespace 
to place class in
Figure 17.3 This signature for the 
Add-Type
cmdlet allows you to create type members 
without having to include all the other details needed to build the containing class.
How to move pages within a pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
move pages in a pdf; reverse page order pdf
How to move pages within a 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
pdf reverse page order online; pdf change page order acrobat
U
SING
.NET 
FROM
P
OWER
S
HELL
731
The remaining parameters are common across all the variations of the cmdlet and 
allow you to specify additional assemblies that the member depends on (all of the 
PowerShell assemblies are included by default so they never need to be explicitly 
added). You can also choose to ignore any compiler warnings using the 
-Ignore-
Warnings
parameter.
Let’s try out what you’ve learned so far. First, you need a method definition. The 
following string defines a 
C
# method that takes an array of integers as its argument, 
sums them up, and then returns the result:
PS (1) > $sumMethod = @' 
>>   static public int Sum(int[] na) 
>>   { 
>>       int result = 0; 
>>       if (na == null || na.Length == 0) 
>>       { 
>>         return 0; 
>>       } 
>>       foreach (int n in na) 
>>       { 
>>         result += n; 
>>       } 
>>       return result; 
>>   } 
>> '@ 
>>
Let’s use 
Add-Type
to compile this method as part of the class 
Utils
:
PS (2) > Add-Type -Name Utils -MemberDefinition $sumMethod
Try to run it:
PS (3) > [utils]::Sum((1..10))
Unable to find type [utils]: make sure that the assembly containing 
this type is loaded.
At line:1 char:8 
+ [utils] <<<< ::Sum((1..10))
+ CategoryInfo          : InvalidOperation: (utils:String) [], 
RuntimeException
+ FullyQualifiedErrorId : TypeNotFound
You get an error! So what happened here? Why did you not find the type? Well, as it 
turns out, 
-Namespace
has a somewhat unwieldy default value, resulting in the type 
name:
'Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes'
By properly specifying this full type name, you’re able to call the new method: 
PS (4) > ` 
[Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes.Utils]::Sum(
(1..10)) 
55
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Able to add and insert one or multiple pages to existing adobe PDF of adding and inserting a new blank page to the existing PDF document within a well
change page order in pdf reader; how to reorder pdf pages in reader
C# PowerPoint - How to Process PowerPoint
It enables you to move out useless PowerPoint document pages simply with a dealing solution to sort and rearrange PowerPoint slides order within C#.NET
change page order in pdf online; how to reorder pages in pdf file
732
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
Note that the preceding command is a one-line expression but it wraps here. Even so, 
this approach is a bit awkward. Fix this by recompiling the member, specifying 
WPIA 
as the namespace for the class:
PS (5) > Add-Type -Name Utils -MemberDefinition $sumMethod ` 
>>   -Namespace WPIA 
>>
Now it’s much easier to run:
PS (6) > [WPIA.Utils]::Sum((1..100)) 
5050
As an experiment, let’s try this method on floating-point numbers:
PS (7) > [WPIA.Utils]::Sum((3.14,2,33.6)) 
39
Note that, even though the arguments are floating-point numbers, you still got an 
integer back. Because there’s no overload for floating-point arguments, the array was 
coerced to integers and passed to the integer 
Sum()
function. To fix this, you can cre-
ate a new overload that takes doubles. In fact, you can just use the 
-replace
operator 
to change 
'int'
to 
'double'
in the original code and then recompile:
PS (8) > $fsumMethod = $sumMethod -replace 'int','double'
Now let’s compile the new overload:
PS (9) > Add-Type -Name Utils -MemberDefinition $fsumMethod ` 
>>   -Namespace WPIA 
>>
Add-Type : Cannot add type. The type name 'WPIA.Utils' already exists 
.
At line:1 char:9 
+ Add-Type <<<<  -Name Utils -MemberDefinition $fsumMethod `
+ CategoryInfo          : InvalidOperation: (WPIA.Utils:String)
[Add-Type], Exception
+ FullyQualifiedErrorId : TYPE_ALREADY_EXISTS,Microsoft. 
PowerShell.Commands.AddTypeCommand
This resulted in an error because once a type is defined, .
NET
doesn’t allow new 
methods to be added to that type. (This is one of the reasons the PowerShell extended 
type system exists: to support this scenario.) So to add this new method, change the 
class name from 
Utils
to 
Utils2
and rerun the command:
PS (10) > Add-Type -Name Utils2 -MemberDefinition $fsumMethod ` 
>>   -Namespace WPIA 
>>
PS (11) > [WPIA.Utils2]::Sum((3.14,2,33.6))
38.74
This time the compile was successful and you were able to run the method. Try 
rerunning the command that compiled the original integer method:
PS (12) > Add-Type -Name Utils -MemberDefinition $sumMethod 
PS (13) >
C# TIFF: C#.NET Code to Process TIFF, RasterEdge XDoc.Tiff for .
Our supported image and document formats are: TIFF, JPEG, GIF, BMP, PNG, PDF, Word and DICOM. It represents a high-level model of the pages within a Tiff file.
how to move pages around in a pdf document; reordering pages in pdf document
C# TIFF: How to Delete Page(s) from Multi-page TIFF File Using
Word, Excel, PowerPoint to Tiff. Convert PDF to Tiff. Page Edit. Insert Pages into Tiff File. Delete Tiff Pages. Move Tiff Page Position. Rotate a Tiff Page. Extract
switch page order pdf; rearrange pdf pages
U
SING
.NET 
FROM
P
OWER
S
HELL
733
And, somewhat unexpectedly, it compiles without error. The reason is that 
Add-Type 
records the code that defined the method originally. If it sees the same source code 
again, it knows not to recompile and just exits with success. But if you change the 
method definition even slightly
PS (14) > $sumMethod = @' 
>>   static public int Sum(int[] na) 
>>   { 
>>       int result = 0; 
>>         if (na != null && na.Length > 0) 
>>         { 
>>         foreach (int n in na) 
>>         { 
>>           result += n; 
>>         } 
>>       } 
>>       return result; 
>>   } 
>> '@ 
>>
and try to compile it again
PS (15) > Add-Type -Name Utils -MemberDefinition $sumMethod 
Add-Type : Cannot add type. The type name 'Microsoft.PowerShell. 
Commands.AddType.AutoGeneratedTypes.Utils' already exists.
At line:1 char:9 
+ Add-Type <<<<  -Name Utils -MemberDefinition $sumMethod
+ CategoryInfo          : InvalidOperation: (Microsoft.Power...a
tedTypes.Utils:String) [Add-Type], Exception
+ FullyQualifiedErrorId : TYPE_ALREADY_EXISTS,
Microsoft.PowerShe ll.Commands.AddTypeCommand
you get the same error as when you tried to add the floating-point version. In .
NET
once a method has been defined, it can’t be redefined or removed.
From this example, it would seem that this is a pretty awkward way to define a 
type.  In  practice,  this  variant  is  primarily  intended  to  address  Platform  Invoke 
(
P/I
nvoke) scenarios. 
P/I
nvoke is the powerful mechanism that .
NET
uses to interop-
erate with the native Windows system calls.
NOTE
At this point, we’re crossing into programmer territory. This 
kind of  stuff is great for  enabling complex scenarios in PowerShell 
scripts but is definitely not something most programmers (let alone 
IT 
pros) will do every day. But at least you should be aware that the capa-
bility exists. If you find that you do need to do this kind of thing, there 
are a number of excellent resources, including the P/Invoke wiki at 
http://pinvoke.net/, which provides a list of the 
P/I
nvoke signatures for 
each 
API
.
Let’s take a look at an example showing what you can do with 
P/I
nvoke.
C# Image: C# Code to Encode & Decode JBIG2 Images in RasterEdge .
images codec into PDF documents for a better PDF compression; RasterEdge JBIG2 codec SDK controls within C# project Move license text to the new project folder
how to move pages in pdf converter professional; how to reorder pages in pdf online
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Thumbnails can be created from PDF pages. quickly convert a large-size multi-page PDF document to of high-quality separate JPEG image files within .NET projects
move pages in a pdf file; how to rearrange pdf pages in preview
734
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
Being able to run scripts in a hidden window is a fairly standard automation 
requirement. This is because it keeps users from inadvertently stopping a script by 
closing the console window before the script can finish. Out of the box, neither 
PowerShell nor the .
NET
[System.Console]
class has built-in ways of minimizing, 
maximizing, or hiding a console window.
NOTE
Yes, Microsoft added the 
-WindowStyle
parameter to 
Power-
Shell.exe
for the purpose of using hidden windows. The 
Start-
Process
cmdlet also has a 
-WindowStyle
parameter allowing new 
processes  to  be  launched  with  hidden  windows.  But  these  features 
don’t allow a script to show the console, read input from a user, and 
then hide it again after the information has been received and the pro-
cessing can start.
Interoperation using Add-Type and P/Invoke 
Let’s see how you can use 
Add-Type
and P/Invoke to add these features to your ses-
sion. First you need to know what functions to import. In this case you need 
Get-
ConsoleWindow()
to get the console handle and 
ShowWindow()
to change the state 
of the window. Here are the commands to add these functions to your session:
PS (1) > Add-Type -Name ConsoleUtils -Namespace WPIA ` 
>>  -MemberDefinition @' 
>>     [DllImport("Kernel32.dll")] 
>>     public static extern IntPtr GetConsoleWindow(); 
>>     [DllImport("user32.dll")] 
>>     public static extern bool ShowWindow(IntPtr hWnd, Int32 nCmdShow); 
>> '@ 
>>
This code is importing the two functions—
GetConsoleWindow()
from Kernel32.dll 
and 
ShowWindow()
from user32.dll—into a class called 
[WPIA.ConsoleUtils]
.
Next, you need to know what values you should pass to 
ShowWindow()
to accom-
plish what you want. You’ll define a hashtable to hold these values for convenience:
PS (2) > $ConsoleMode = @{ 
>>     HIDDEN = 0; 
>>     NORMAL = 1; 
>>     MINIMIZED = 2; 
>>     MAXIMIZED = 3; 
>>     SHOW = 5 
>>     RESTORE = 9 
>> } 
>>
Now you’re ready to call your 
API
s. Use 
GetConsoleWindow()
to get the console 
window handle
PS (3) > $hWnd = [WPIA.ConsoleUtils]::GetConsoleWindow()
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract View PDF document in continuous pages display mode Search text within file by using Ignore case or
change page order in pdf file; pdf reverse page order preview
C# Word - Process Word Document in C#
It enables you to move out useless Word document pages simply with a You are capable of extracting pages from Microsoft Word document within C#.NET
pdf rearrange pages online; pdf reverse page order online
U
SING
.NET 
FROM
P
OWER
S
HELL
735
and display the value you get back:
PS (4) > $hWnd 
22877126
Let’s maximize the console with 
ShowWindow()
, passing in the value from the 
$Con-
soleMode
needed to do this:
PS (5) > [WPIA.ConsoleUtils]::ShowWindow($hWnd, $ConsoleMode.MAXIMIZED) 
True
The method call should succeed and return true, and the console window will be 
maximized. With the following lines,  you  step through each option in sequence, 
waiting 2 seconds between each call:
PS (6) > Start-Sleep 2
PS (7) > [WPIA.ConsoleUtils]::ShowWindow($hWnd, $ConsoleMode.NORMAL) 
True 
PS (8) > Start-Sleep 2 
PS (9) > [WPIA.ConsoleUtils]::ShowWindow($hWnd, $ConsoleMode.MINIMIZED) 
True 
PS (10) > Start-Sleep 2 
PS (11) > [WPIA.ConsoleUtils]::ShowWindow($hWnd, $ConsoleMode.RESTORE) 
True 
PS (12) > Start-Sleep 2 
PS (13) > [WPIA.ConsoleUtils]::ShowWindow($hWnd, $ConsoleMode.HIDDEN) 
True 
PS (14) > Start-Sleep 2 
PS (15) > [WPIA.ConsoleUtils]::ShowWindow($hWnd, $ConsoleMode.SHOW) 
False 
PS (16) >
This  sequence  will  cause the console  to  be  restored  to  normal,  then  minimized, 
restored, hidden, and then shown again. (This sequence is more fun to run than 
describe—trust me.) 
CAUTION
These examples work with the console 
API
s—which means 
that they’re only appropriate to run from a console application like 
PowerShell.exe
. Running them in a graphical application like the 
ISE may produce unexpected results up to and including causing the 
application to crash. Using 
P/I
nvoke means that you’re poking holes in 
the .
NET
safety layer and interacting directly with the Win32 layer. 
This is powerful stuff, but it requires working without a safety net. The 
worst-case scenario involves crashing or hanging your process, so when 
playing with 
P/I
nvoke, save early and save often. 
Now that we’ve got member definitions out of the way, we’ll look at the 
-Type-
Definition
variant next.
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy View PDF document in continuous pages display mode. Search text within file by using Ignore case or
move pages in pdf acrobat; reorder pages in pdf online
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
NET code. All PDF pages can be converted to separate Word files within a short time in VB.NET class application. In addition, texts
rearrange pages in pdf; rearrange pdf pages in preview
736
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
The -TypeDefinition parameter set
This parameter set is designed to allow for larger pieces of inline code than just a cou-
ple of member definitions. Looking at the parameter set in figure 17.4, this time you 
have the 
-TypeDefinition
parameter instead of the 
-Name
-MemberDefinition, 
-Namespace
,
and 
-UsingNamespace
parameters. 
With this variation, you have to provide the full definition of the class, including 
the namespace and any 
using
statements that are required. You’ll rewrite the previous 
examples for use with 
-TypeDefinition
. The code to do so looks like the following:
PS (1) > $utils = @' 
>> using System; 
>> using System.Runtime.InteropServices; 
>> 
>> namespace WPIA { 
>>   public static class Utils 
>>   { 
>>     static public int Sum(int[] na) 
>>     { 
>>       int result = 0; 
>>       if (na == null || na.Length == 0) 
>>         return 0; 
>>       foreach (int n in na) 
>>       { 
>>         result += n; 
>>       } 
>>       return result; 
>>     } 
>> 
>>     static public double Sum(double[] na) 
>>     { 
>>       double result = 0; 
>>       if (na == null || na.Length == 0) 
>>         return 0; 
>>       foreach (double n in na)
Pass generated assembly
object through to output stream
Add-Type 
[-TypeDefinition] <string> 
[-Language <targetLanguage>]
[-CodeDomProvider <CodeDomProvider>]
[-CompilerParameters <paramList>]
[-OutputAssembly <string>] 
[-OutputType <type>]
[-ReferencedAssemblies <listOfAssemblies>]
[-IgnoreWarnings] 
[-PassThru]
Source language
being used
Name of output
assembly file to create
Type of output file
(library, console app,
or Windows app)
Additional
assemblies to 
reference when
compiling
Parameters to pass
to compiler
Ignore any compile-
time warnings
Source text to compile
Code document object
model to use for compiling
Figure 17.4 The 
Add-Type
type definition parameter set allows you to define a 
complete class or classes.
U
SING
.NET 
FROM
P
OWER
S
HELL
737
>>       { 
>>         result += n; 
>>       } 
>>       return result; 
>>    } 
>>  } 
>> 
>>  public static class ConsoleUtils 
>>  { 
>>     [DllImport("Kernel32.dll")] 
>>     public static extern IntPtr GetConsoleWindow(); 
>>     [DllImport("user32.dll")] 
>>     public static extern bool ShowWindow( 
>>         IntPtr hWnd, Int32 nCmdShow); 
>>   } 
>> } 
>> '@ 
>>
This  source text defines the two classes  you  created previously: 
WPIA.Utils
and 
WPIA.ConsoleUtils
. Now you can compile everything with a single command:
PS (14) > Add-Type -TypeDefinition $utils
In fact, because this is the default parameter set, it simply becomes
PS (15) > Add-Type $utils 
PS (16) >
Next, let’s look at the final parameter set for 
Add-Type
with the 
-Path
parameter.
The -Path parameter set
The last parameter set for 
Add-Type
is the 
-Path
parameter set. This parameter set is 
much like 
-TypeDefinition
except that instead of including the code to compile 
inline in  the  script, you’ll load  the file specified by 
-Path
. This parameter set is 
shown in figure 17.5.
This parameter set is even simpler than the one for 
-TypeDefinition
. Because 
you’re reading the code from a file, you can use the file’s extension to determine what
Add-Type 
[-Path] <pathsToSrcFiles>
[-CompilerParameters <paramlist>]
[-OutputAssembly <string>] 
[-OutputType <type>]
[-ReferencedAssemblies <listOfAssemblies>] 
[-IgnoreWarnings] 
[-PassThru] 
Pass generated assembly object
through to output stream
Path to file(s) to
compile
Name of output
assembly file to create
Type of output file
(library, console app, 
or Windows app)
Additional
assemblies to
reference when
compiling
Parameters to pass
to the compiler
Ignore any compile-
time warnings
Figure 17.5 The 
Add-Type -Path
parameter set reads the input source from a file. 
It uses the file extension to select the source language.
738
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
language to expect. If you write the code you saved in the 
$utils
variable earlier to a 
file, you can try using 
-Path
:
PS (4) > $utils > wpia.utils.cs 
PS (5) > Add-Type -Path wpia.utils.cs 
Add-Type : Cannot add type. The type name 'WPIA.Utils' already exists 
.
At line:1 char:9 
+ Add-Type <<<<  -Path wpia.utils.cs
+ CategoryInfo          : InvalidOperation: (WPIA.Utils:String)
[Add-Type], Exception
+ FullyQualifiedErrorId : TYPE_ALREADY_EXISTS,Microsoft.PowerShe
ll.Commands.AddTypeCommand
You get an error because, although the text is the same, it comes from a different 
source, resulting in a “type already exists” error. You can, however, load it into a new 
PowerShell process:
PS (7) > powershell 'Add-Type -Path wpia.utils.cs; [WPIA.Utils]::Sum( 
>> (1..10))' 
55
The other thing you can do is have the file compiled into an assembly on disk instead 
of in memory. You do this with the 
-OutputAssembly
parameter:
PS (8) > Add-Type -Path wpiautils.cs -OutputAssembly wpiautils.dll ` 
>> -OutputType library
This time you didn’t get the error because the assembly wasn’t being loaded. You can 
use the 
dir
command to see what was produced:
PS (9) > dir wpiautils.*
Directory: C:\Users\brucepay
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          8/1/2010   6:50 PM       1564 wpiautils.cs 
-a---          8/1/2010   6:50 PM       3584 wpiautils.dll 
-a---          8/1/2010   6:50 PM      13824 wpiautils.pdb
Notice  that, as well  as the wpiautils.dll file, you also have  the  file wpiautils.pdb, 
which  contains  debugging  information.  This  file  is  created  because  the  default 
parameters that are passed to the compiler include the 
/debug
flag.
You used the 
-Path
parameter to load and compile the source file but you can 
also use it to load an already compiled 
DLL
:
PS (10) > powershell ' 
>>    Add-Type -Path $PWD\wpiautils.dll 
>>    [WPIA.Utils]::Sum((1..10)) 
>> ' 
>> 
55 
PS (11) >
U
SING
.NET 
FROM
P
OWER
S
HELL
739
Again you did it in a child process to avoid getting the type-collision error. The 
DLL 
loads, the 
Sum()
method is called, and you see the sum 55 displayed on the console.
TIP
In section 17.1.2, you used 
-AssemblyName
to load assemblies 
into the process. You might expect that you’d also use this parameter to 
load assemblies by path. But that assumptions isn’t correct. You have 
to  use 
-Path
to load an assembly by path (or 
Import-Module
). 
Remembering this may save you some frustration. 
To recap, you’ve loaded assemblies, found and instantiated existing types, and used 
Add-Type
to define new ones. There’s one last piece you need to look at to complete 
our picture of types: generic types. Because generic types are used frequently in the 
.
NET F
ramework, you’ll need to know something about them.
17.1.6
Working with generic types
With version 2.0 of .
NET
, a feature was added to the 
CLR
type system called generic 
types (or simply generics). Generics introduce the idea of a type parameter. Instead of 
passing objects as arguments when creating an instance of type, generics also require 
you to pass in type parameters that are used to determine the final types of some part 
of the object. This concept is rather confusing if you haven’t encountered it before. As 
usual, an example should make things clearer. 
Generics  are  easiest  to  understand  when  you  talk  about  creating  collections. 
Before the introduction of generics, if you wanted to create a collection class either 
you had to write a new version of the class for each type of object you wanted it to 
store or you had to allow it to hold any type of object, which meant that you had to 
do your own error checking. With generics, you can write a collection that can be 
constrained to only contain integers or strings or hashtables. 
In PowerShell v1, though it was reasonably easy to work with existing instances of 
generic types, it was difficult to express generic type names or create new instances of 
these types. This issue was fixed in PowerShell v2, and you can now create generic 
types naturally. Let’s look at some examples.
Creating instances of generic types
We’ll start by creating a list, specifically a list of integers. To do this, you need to 
know the base type of the collection and the type parameter you need to pass when 
creating an instance of the  collection. The base type you’re  going to use is 
Sys-
tem.Collections.Generic.List
, which takes a single type argument. To create an 
instance of the collection, you pass the “closed” type name to 
New-Object
. By closed, 
I mean that a concrete type has been specified as the type parameter. For a collection 
of integer, this looks like
$ilist = New-Object System.Collections.Generic.List[int]
Documents you may be interested
Documents you may be interested