ASP.NET Web Pages Using The Razor Syntax 
Chapter 8 – Working with Files 
127 
The variable 
i
is just a temporary counter that will go from zero to whatever upper limit you set. 
In this case, the upper limit is the number of files. But because the counter starts at zero, as is 
typical for counting scenarios in ASP.NET, the upper limit is actually one less than the file count. 
(If three files are uploaded, the count is zero to 2.) 
The 
uploadedCount
variable totals all the files that are successfully uploaded and saved. This 
code accounts for the possibility that an expected file may not be able to be uploaded. 
4.
Run the page in a browser. The browser displays the page and its two upload boxes.  
5.
Select two files to upload.  
6.
Click Add another file. The page displays a new upload box.  
7.
Click Upload.  
8.
In the website, right-click the project folder and then click Refresh.  
9.
Open the UploadedFiles folder to see the successfully uploaded files.  
Additional Resources
Chapter 9 - Working with Images 
Exporting to a CSV File 
ASP.NET Web Pages with Razor Syntax Reference 
Add bookmarks to pdf reader - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
create bookmark in pdf automatically; how to create bookmark in pdf with
Add bookmarks to pdf reader - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
creating bookmarks in a pdf document; how to add bookmarks to pdf document
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
128 
Chapter 9 
Working with Images 
This chapter shows you how to add, display, and manipulate images (resize, flip, and add watermarks) in 
your website.  
What you'll learn: 
How to add an image to a page dynamically. 
How to let users upload an image. 
How to resize an image. 
How to flip or rotate an image. 
How to add a watermark to an image. 
How to use an image as a watermark. 
These are the ASP.NET programming features introduced in the chapter: 
The 
WebImage
helper. 
The 
Path
object, which provides methods that let you manipulate path and file names. 
Adding an Image to a Web Page Dynamically 
You can add images to your website and to individual pages while you're developing the website. You 
can also let users upload images, which might be useful for tasks like letting them add a profile photo. 
If an image is already available on your site and you just want to display it on a page, you use an HTML 
<img>
element like this: 
<img src="images/Photo1.jpg" alt="Sample Photo" /> 
Sometimes, though, you need to be able to display images dynamically — that is, you don't know what 
image to display until the page is running. 
The procedure in this section shows how to display an image on the fly where users specify the image 
file name from a list of image names. They select the name of the image from a drop-down list, and 
when they submit the page, the image they selected is displayed. 
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. Comments, forms and multimedia. Flatten visible layers. C#.NET DLLs: Compress PDF Document. Add necessary references: RasterEdge.Imaging.Basic.dll.
export pdf bookmarks to excel; pdf reader with bookmarks
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
create pdf bookmarks; bookmarks pdf file
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
129 
1.
In WebMatrix, create a new website. 
2.
Add a new page named DynamicImage.cshtml. 
3.
In the root folder of the website, add a new folder and name it images. 
4.
Add four images to the images folder you just created. (Any images you have handy will do, but 
they should fit onto a page.) Rename the images Photo1.jpg, Photo2.jpg, Photo3.jpg, and 
Photo4.jpg. (You won't use Photo4.jpg in this procedure, but you'll use it later in the chapter.) 
5.
Verify that the four images are not marked as read-only. 
6.
Replace the existing markup in the page with the following: 
@{  var imagePath= ""; 
if( Request["photoChoice"] != null){ 
imagePath = @"images\" + Request["photoChoice"]; 
<!DOCTYPE html> 
<html> 
<head> 
<title>Display Image on the Fly</title> 
</head> 
<body> 
<h1>Displaying an Image On the Fly</h1> 
<form method="post" action=""> 
<div> 
I want to see: 
<select name="photoChoice"> 
<option value="Photo1.jpg">Photo 1</option> 
<option value="Photo2.jpg">Photo 2</option> 
<option value="Photo3.jpg">Photo 3</option> 
</select> 
&nbsp; 
<input type="submit" value="Submit" /> 
</div> 
<div style="padding:10px;"> 
@if(imagePath != ""){ 
<img src="@imagePath" alt="Sample Image" width="300px" /> 
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Add necessary references: The following VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
create bookmark pdf file; adding bookmarks in pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
Add necessary references: RasterEdge.Imaging.Basic.dll. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
creating bookmarks in pdf from word; how to add a bookmark in pdf
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
130 
</div> 
</form> 
</body> 
</html> 
The body of the page has a drop-down list (a 
<select>
element) that's named 
photoChoice
. The 
list has three options, and the 
value
attribute of each list option has the name of one of the 
images that you put in the images folder. Essentially, the list lets the user select a friendly name 
like "Photo 1", and it then passes the .jpg file name when the page is submitted. 
In the code, you can get the user's selection (in other words, the image file name) from the list 
by reading 
Request["photoChoice"]
. You first see if there's a selection at all. If there is, you 
construct a path for the image that consists of the name of the folder for the images and the 
user's image file name. (If you tried to construct a path but there was nothing in 
Request["photoChoice"]
, you'd get an error.) This results in a relative path like this: 
images/Photo1.jpg 
The path is stored in variable named 
imagePath
that you'll need later in the page. 
In the body, there's also an 
<img>
element that's used to display the image that the user picked. 
The 
src
attribute isn't set to a file name or URL, like you'd do to display a static element. 
Instead, it's set to 
@imagePath
, meaning that it gets its value from the path you set in code. 
The first time that the page runs, though, there's no image to display, because the user hasn't 
selected anything. This would normally mean that the 
src
attribute would be empty and the 
image would show up as a red "x" (or whatever the browser renders when it can't find an 
image). To prevent this, you put the 
<img>
element in an 
if
block that tests to see whether the 
imagePath
variable has anything in it. If the user made a selection, 
imagePath
contains the path. 
If the user didn't pick an image or if this is the first time the page is displayed, the 
<img>
element 
isn't even rendered. 
7.
Save the file and run the page in a browser. (Make sure the page is selected in the Files 
workspace before you run it.)  
Uploading an Image 
The previous example showed you how to display an image dynamically, but it worked only with images 
that were already on your website. This procedure shows how to let users upload an image, which is 
then displayed on the page. In ASP.NET, you can manipulate images on the fly using the 
WebImage
helper, 
which has methods that let you create, manipulate, and save images. The 
WebImage
helper supports all 
the common web image file types, including .jpg, .png, and .bmp. Throughout this chapter, you'll use 
.jpg images, but you can use any of the image types. 
.NET PDF SDK | Read & Processing PDF files
provided by this .NET Imaging PDF Reader Add-on Able to convert PDF documents into other formats Include extraction of text, hyperlinks, bookmarks and metadata;
pdf bookmarks; how to bookmark a pdf in reader
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; PDF Text Write & Extract. Insert and add text to any page of PDF document with
pdf export bookmarks; edit pdf bookmarks
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
131 
1.
Add a new page and name it UploadImage.cshtml. 
2.
Replace the existing markup in the page with the following:  
@{  WebImage photo = null; 
var newFileName = ""; 
var imagePath = ""; 
if(IsPost){ 
photo = WebImage.GetImageFromRequest(); 
if(photo != null){ 
newFileName = Guid.NewGuid().ToString() + "_" + 
Path.GetFileName(photo.FileName); 
imagePath = @"images\" + newFileName; 
photo.Save(@"~\" + imagePath); 
<!DOCTYPE html> 
<html> 
<head> 
<title>Image Upload</title> 
</head> 
<body> 
<form action="" method="post" enctype="multipart/form-data"> 
<fieldset> 
<legend> Upload Image </legend> 
<label for="Image">Image</label> 
<input type="file" name="Image" /> 
<br/> 
<input type="submit" value="Upload" /> 
</fieldset> 
</form> 
<h1>Uploaded Image</h1> 
@if(imagePath != ""){ 
<div class="result"> 
XDoc.Word for .NET, Advanced .NET Word Processing Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Word to PDF; Convert Word to HTML5; Convert Add and insert a blank page or multiple
convert excel to pdf with bookmarks; export excel to pdf with bookmarks
XDoc.PowerPoint for .NET, All Mature Features Introductions
navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert PowerPoint to PDF; Convert PowerPoint to HTML5; Add a blank page or multiple pages to
create pdf bookmarks from word; create pdf bookmarks online
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
132 
<img src="@imagePath" alt="image" /> 
</div> 
</body> 
</html> 
The body of the text has an 
<input type="file">
element, which lets users select a file to 
upload. When they click Submit, the file they picked is submitted along with the form. 
To get the uploaded image, you use the 
WebImage
helper, which has all sorts of useful methods 
for working with images. Specifically, you use 
WebImage.GetImageFromRequest
to get the 
uploaded image (if any) and store it in a variable named 
photo
A lot of the work in this example involves getting and setting file and path names. The issue is 
that you want to get the name (and just the name) of the image that the user uploaded, and 
then create a new path for where you're going to store the image. Because users could 
potentially upload multiple images that have the same name, you use a bit of extra code to 
create unique names and make sure that users don't overwrite existing pictures. 
If an image actually has been uploaded (the test 
if (photo != null)
), you get the image name 
from the image’s 
FileName
property. When the user uploads the image, 
FileName
contains the 
user's original name, which includes the path from the user's computer. It might look like this: 
C:\Users\Joe\Pictures\SamplePhoto1.jpg 
You don't want all that path information, though — you just want the actual file name 
(SamplePhoto1.jpg). You can strip out just the file from a path by using the 
Path.GetFileName
method, like this: 
Path.GetFileName(photo.FileName) 
You then create a new unique file name by adding a GUID to the original name. (For more about 
GUIDs, see About GUIDs later in this chapter.) Then you construct a complete path that you can 
use to save the image. The save path is made up of the new file name, the folder (images), and 
the current website location. 
Note   In order for your code to save files in the images folder, the application needs read-write 
permissions for that folder. On your development computer this is not typically an issue. However, 
when you publish your site to a hosting provider's web server, you might need to explicitly set those 
permissions. If you run this code on a hosting provider's server and get errors, check with the 
hosting provider to find out how to set those permissions.  
Finally, you pass the save path to the 
Save
method of the 
WebImage
helper. This stores the 
uploaded image under its new name. The save method looks like this: 
photo.Save(@"~\" + 
imagePath)
. The complete path is appended to 
@"~\"
, which is the current website location. (For 
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
133 
information about the 
~
operator, see Chapter 2 - Introduction to ASP.NET Web Programming 
Using the Razor Syntax.) 
As in the previous example, the body of the page contains an 
<img>
element to display the 
image. If 
imagePath
has been set, the 
<img>
element is rendered and its 
src
attribute is set to the 
imagePath
value. 
3.
Run the page in a browser.  
About GUIDs 
A GUID (globally-unique ID) is an identifier that looks something like this: 
936DA01F-9ABD-4d9d-80C7-
02AF85C822A8
. (Technically, it's a 16-byte/128-bit number.) When you need a GUID, you can call 
specialized code that generates a GUID for you. The idea behind GUIDs is that between the enormous 
size of the number (3.4 x 10
38
) and the algorithm for generating it, the resulting number is virtually 
guaranteed to be one of a kind. GUIDs therefore are a good way to generate names for things when you 
must guarantee that you won't use the same name twice. The downside, of course, is that GUIDs aren't 
particularly user friendly, so they tend to be used when the name is used only in code. 
Resizing an Image 
If your website accepts images from a user, you might want to resize the images before you display or 
save them. You can again use the 
WebImage
helper for this. 
This procedure shows how to resize an uploaded image to create a thumbnail and then save the 
thumbnail and original image in the website. You display the thumbnail on the page and use a hyperlink 
to redirect users to the full-sized image. 
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
134 
1.
Add a new page named Thumbnail.cshtml. 
2.
In the images folder, create a subfolder named thumbs. 
3.
Replace the existing markup in the page with the following:  
@{  WebImage photo = null; 
var newFileName = ""; 
var imagePath = ""; 
var imageThumbPath  = ""; 
if(IsPost){ 
photo = WebImage.GetImageFromRequest(); 
if(photo != null){ 
newFileName = Guid.NewGuid().ToString() + "_" + 
Path.GetFileName(photo.FileName); 
imagePath = @"images\" + newFileName; 
photo.Save(@"~\" + imagePath); 
imageThumbPath = @"images\thumbs\" + newFileName; 
photo.Resize(width: 60, height: 60, preserveAspectRatio: true, 
preventEnlarge: true); 
photo.Save(@"~\" + imageThumbPath);        } 
<!DOCTYPE html> 
<html> 
<head> 
<title>Resizing Image</title> 
</head> 
<body> 
<h1>Thumbnail Image</h1> 
<form action="" method="post" enctype="multipart/form-data"> 
<fieldset> 
<legend> Creating Thumbnail Image </legend> 
<label for="Image">Image</label> 
<input type="file" name="Image" /> 
<br/> 
<input type="submit" value="Submit" /> 
</fieldset> 
</form> 
@if(imagePath != ""){ 
<div class="result"> 
<img src="@imageThumbPath" alt="Thumbnail image" /> 
<a href="@Html.AttributeEncode(imagePath)" target="_Self"> 
View full size 
</a> 
</div> 
</body> 
</html> 
This code is similar to the code from the previous example. The difference is that this code saves 
the image twice, once normally and once after you create a thumbnail copy of the image. First 
you get the uploaded image and save it in the images folder. You then construct a new path for 
the thumbnail image. To actually create the thumbnail, you call the 
WebImage
helper's 
Resize
method to create a 60-pixel by 60-pixel image. The example shows how you preserve the aspect 
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
135 
ratio and how you can prevent the image from being enlarged (in case the new size would 
actually make the image larger). The resized image is then saved in the thumbs subfolder. 
At the end of the markup, you use the same 
<img>
element with the dynamic 
src
attribute that 
you've seen in the previous examples to conditionally show the image. In this case, you display 
the thumbnail. You also use an 
<a>
element to create a hyperlink to the big version of the image. 
As with the 
src
attribute of the 
<img>
element, you set the 
href
attribute of the 
<a>
element 
dynamically to whatever is in 
imagePath
. To make sure that the path can work as a URL, you pass 
imagePath
to the 
Html.AttributeEncode
method, which converts reserved characters in the path 
to characters that are ok in a URL. 
4.
Run the page in a browser.  
Rotating and Flipping an Image 
The 
WebImage
helper also lets you flip and rotate images. This procedure shows how to get an image 
from the server, flip the image upside down (vertically), save it, and then display the flipped image on 
the page. In this example, you're just using a file you already have on the server (Photo2.jpg). In a real 
application, you'd probably flip an image whose name you get dynamically, like you did in previous 
examples. 
1.
Add a new page named Flip.cshtml. 
2.
Replace the existing markup in the file with the following:  
@{  var imagePath= ""; 
WebImage photo = new WebImage(@"~\Images\Photo2.jpg"); 
if(photo != null){ 
imagePath = @"images\Photo2.jpg"; 
photo.FlipVertical(); 
photo.Save(@"~\" + imagePath); 
ASP.NET Web Pages Using The Razor Syntax 
Chapter 9 – Working with Images 
136 
<!DOCTYPE html> 
<html> 
<head> 
<title>Get Image From File</title> 
<meta http-equiv="content-type" content="text/html;charset=utf-8" /> 
</head> 
<body> 
<h1>Flip Image Vertically</h1> 
@if(imagePath != ""){ 
<div class="result"> 
<img src="@imagePath" alt="Image" /> 
</div> 
</body> 
</html> 
The code uses the 
WebImage
helper to get an image from the server. You create the path to the 
image using the same technique you used in earlier examples for saving images, and you pass 
that path when you create an image using 
WebImage
WebImage photo = new WebImage(@"~\Images\Photo2.jpg"); 
If an image is found, you construct a new path and file name, like you did in earlier examples. To 
flip the image, you call the 
FlipVertical
method, and then you save the image again. 
The image is again displayed on the page by using the 
<img>
element with the 
src
attribute set 
to 
imagePath
3.
Run the page in a browser. The image for Photo2.jpg is shown upside down. If you request the 
page again, the image is flipped right side up again.  
To rotate an image, you use the same code, except that instead of calling the 
FlipVertical
or 
FlipHorizontal
, you call 
RotateLeft
or 
RotateRight
Adding a Watermark to an Image 
When you add images to your website, you might want to add a watermark to the image before you 
save it or display it on a page. People often use watermarks to add copyright information to an image or 
to advertise their business name. 
Documents you may be interested
Documents you may be interested