mvc open pdf in browser : Change pdf to jpg control Library platform web page .net wpf web browser Expert_.NET_Delivery_Using_NAnt_and_CruiseControl_.NET_200510-part1057

Undoubtedly, these problems will be fixed in Visual Studio 2005 since Microsoft is launch-
ing its own build tool, MSBuild, but it is worth bearing in mind that <solution>may not be a
panacea for compilation.
Another case in which you would not want to use the <solution>task is when you are not
using VS .NET and therefore the solution structures do not exist.
Once again, there are a variety of possibilities for the application of this task, but the fol-
lowing are two common examples. The first shows a standard library, console, or Windows
solution build: 
<?xml version="1.0"?>
<project>
<solution 
solutionfile="MyLibrary.sln"
configuration="debug" 
outputdir="D:\MyLibrary" />
</project>
The task will recognize dependencies and build orders from the solution file and will out-
put the compiled assembly or assemblies in the specified debugconfiguration to the specified
output directory.
Because of the way that Visual Studio handles web projects, using the <solution>task
becomes more involved since we need to map the URL of the web project or projects to the
physical location. This is shown in the following example:
<?xml version="1.0"?>
<project>
<solution 
solutionfile="MySite.sln"
configuration="debug" 
outputdir="D:\MySite">
<webmap>
<map
url="http://localhost/MySite.csproj"
path="D:\MySourceCode\MySite\UI.csproj" />
</webmap>
</solution>
</project>
Regardless of the slight additional complexity, this task saves a significant amount of
effort when you are creating a build file. In fact, the actual building of a general system is usu-
ally trivial—it is all the supporting activities that seem to take the time!
My advice is to try the <solution>task to see if you can use the available power it has and
then move to the <csc><vbc>,or similar task for other languages as required.
One other issue with using the <solution>task is that some of the required build configu-
ration is moved out of NAnt and into the hands of the solution developer. We will see this in
action in Chapters 4 and 5 as we put a build process into practice. We will discuss this issue a
little more then, but it is worth raising now.
CHAPTER 3 IMPORTANT NANT TASKS
79
Change pdf to jpg - Convert PDF to JPEG images in C#.net, ASP.NET MVC, WinForms, WPF project
How to convert PDF to JPEG using C#.NET PDF to JPEG conversion / converter library control SDK
.pdf to jpg converter online; convert pdf image to jpg image
Change pdf to jpg - VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.net, ASP.NET MVC, WinForms, WPF project
Online Tutorial for PDF to JPEG (JPG) Conversion in VB.NET Image Application
change pdf to jpg online; convert pdf to jpg 300 dpi
I do not want to be too critical of this task—I use it constantly—but it is worth under-
standing the implications. You may find, as I have, that in fact it does the job very nicely for
your systems.
<csc> [NAnt]
Having just discussed the <solution>task, we should also look at the <csc>task. Also bear in
mind that there are equivalent tasks for Visual Basic .NET (<vbc>), C++ (<cl>), JScript .NET
(<jsc>), and J# (<vjc>). The <csc>task gives you control over the command-line compiler for
the .NET language of your choice, removing the VS .NET–introduced extras such as the solu-
tion and project constructs, and thus gives us a more controlled build. This, of course, is the
compiler option of choice for anyone using open source tools for .NET development but
should probably be your choice if you are using VS .NET in any case. 
The following <csc>code is from the NAnt documentation:
<csc target="exe" output="HelloWorld.exe"
debug="true" doc="HelloWorld.xml">
<nowarn>
<!-- do not report warnings for missing XML comments -->
<warning number="0519" />
</nowarn>
<sources>
<include name="**/*.cs" />
</sources>
<resources dynamicprefix="true" prefix="HelloWorld">
<include name="**/*.resx" />
</resources>
<references>
<include name="System.dll" />
<include name="System.Data.dll" />
</references>
</csc>
As you can see, there is a considerable amount of XML even for what is presumably a triv-
ial application. However, as we learned earlier when discussing <solution>, we now have full
control over the compiler.
Additionally, as we discussed, certain solution-specific settings are now controlled within
NAnt instead of relying on the VS .NET settings (and therefore the individual developer) to
maintain or implement build standards. Examples, which appear in bold in the code, include
the documentation output and the warning suppression, and even the name of the output
assemblies. Using the <solution>task precludes the use and control of these switches. 
The downside, as you might expect, is that maintaining the <csc>tasks as part of the
build process can become onerous for large projects. The rub here is that with Visual Studio
.NET 2005, MSBuild will likely seek to remove this shortcoming from its own build process,
and so if it wants to continue competing with Microsoft for the build process space, NAnt
should do the same. Otherwise, the risk is that NAnt will be confined to open source develop-
ment because MSBuild is “simpler.” This is a one-dimensional argument in this specific
context but will become more significant over time.
CHAPTER 3 ■ IMPORTANT NANT TASKS
80
Online Convert Jpeg to PDF file. Best free online export Jpg image
Download Free Trial. Convert a JPG to PDF. Web Security. All your JPG and PDF files will be permanently erased from our servers after one hour.
reader convert pdf to jpg; change file from pdf to jpg
Online Convert PDF to Jpeg images. Best free online PDF JPEG
Download Free Trial. Convert a PDF File to JPG. Web Security. Your PDF and JPG files will be deleted from our servers an hour after the conversion.
convert pdf to jpg c#; convert pdf to jpg for online
As you might expect, the <csc>task has many options and arguments for control. We will
be focusing on the use of the <solution>task throughout the book, so you will need to explore
these for yourself. If you are accustomed to the command-line compiler, then this should not
be a problem. You will probably find yourself working with a number of supporting tasks such
as<license>and<tlbimp>to better support the command-line compiler options.
Utility Tasks
The utility tasks are a little less specific than build tasks, but they still perform some important
functions. The difference is that these tasks can usually have several purposes depending on
the context they are applied to in the build file.
Tip
These tasks are also really handy for day-to-day automation of activities.
<echo> [NAnt]
We have already covered the <echo>task in detail. Do not forget about this task when creating
scripts; often the output to the console or log is the best source of information when things go
wrong (or even right). 
Apart from simply displaying a message, an <echo>task can have a log level set in the
same way as regular log messages. These can be Debug,Verbose,Info,Warning, or Error, with
the default being Info.
<style> [NAnt]
This task has a straightforward purpose: it takes an XML and an XSLT file and uses both to
produce the relevant output. Some tasks that output XML have an option for performing this
action as part of the task, but it is useful to know that this step can be managed independently.
The following example shows a typical use:
<?xml version="1.0"?>
<project>
<style
style="FxCopReport.xsl"
in="FxCop.xml"
out="FxCop.html"/>
</project>
<zip> [NAnt] and <unzip> [NAnt]
The utility that these tasks provide is quite obvious. As you can imagine, zipping and unzip-
ping of assets is a useful action when we are handling build and deploy processes. These tasks
can be managed simply. The <zip>task also accepts a filesetas a more complex activity.
CHAPTER 3 IMPORTANT NANT TASKS
81
C# Image Convert: How to Convert Adobe PDF to Jpeg, Png, Bmp, &
String inputFilePath = @"C:\input.pdf"; String outputFilePath = @"C:\output.jpg"; // Convert PDF to jpg. C# sample code for PDF to jpg image conversion.
convert pdf image to jpg online; bulk pdf to jpg converter online
C# Image Convert: How to Convert Tiff Image to Jpeg, Png, Bmp, &
RasterEdge.XDoc.PDF.dll. C:\input.tif"; String outputDirectory = @"C:\output\"; // Convert tiff to jpg and show How to change Tiff image to Bmp image in your C#
convert pdf pages to jpg; pdf to jpg
Let us look at a couple of ways you could use these tasks. One is to place assets in a suit-
able location:
<?xml version="1.0"?>
<project>
<unzip 
zipfile="MyAssets.zip"
todir="D:\Deploy\"/>
</project>
Our second example shows the creation of a zip file with a simple fileset:
<?xml version="1.0"?>
<project>
<zip zipfile="MyAssets.zip">
<fileset basedir="D:\MyAssets\">
<include name="**" />
</fileset>
</zip>
</project>
<xmlpeek> [NAnt] and <xmlpoke> [NAnt]
These tasks accept an XPath query and can retrieve or update the value at the node found by
the query. 
We can use <xmlpeek>to set initial properties from an XML file rather than from the com-
mand line. We can use <xmlpoke>to configure a deployed system, as the following example
demonstrates. Given a .configfile of this structure:
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<appSettings>
<add key="MyKey" value="MyValue" />
</appSettings>
</configuration>
the following will update the value of MyKey:
<?xml version="1.0"?>
<project>
<xmlpoke
file="app.config"
xpath="/configuration/appSettings/add[@key='MyKey']/@value"
value="SomeValue" />
</project>
CHAPTER 3 ■ IMPORTANT NANT TASKS
82
JPG to PNG Converter | Convert JPEG to PNG, Convert PNG to JPG
Allow to change converting image with adjusted width & height; Change image resolution Open JPEG to PNG Converter first; Load JPG images from local folders in
changing file from pdf to jpg; convert pdf to gif or jpg
C# Create PDF from images Library to convert Jpeg, png images to
Batch convert PDF documents from multiple image formats, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET Graphics, and REImage.
convert pdf to jpg file; convert pdf page to jpg
The script output looks like this:
---------- NAnt ----------
NAnt 0.85 
Copyright (C) 2001-2004 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///XmlPoke.build
[xmlpoke] Found '1' nodes matching XPath expression
'/configuration/appSettings/add[@key='MyKey']/@value'.
BUILD SUCCEEDED
Total time: 0.1 seconds.
Output completed (0 sec consumed) - Normal Termination
Theapp.configfile now looks like this:
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<appSettings>
<add key="MyKey" value="SomeValue" />
</appSettings>
</configuration>
To retrieve the new value to a property called xml.property, we can use the following:
<?xml version="1.0"?>
<project>
<xmlpeek
file="app.config"
xpath="/configuration/appSettings/add[@key='MyKey']/@value"
property="xml.property" />
</project>
For one or two properties, this can be a very useful technique, but when we have several
properties, maintaining the XPath queries may become onerous. We will explore this and
other techniques for this kind of work when we consider deployment issues in more depth.
Source Control Tasks
As I mentioned earlier, I use Visual SourceSafe (VSS) in my current role and therefore have
much greater experience with VSS than any other source control system. The set of tasks here
describe the commands that we can use for VSS, but there are similar tasks for other source
control systems in NAnt and NAntContrib. In particular, NAnt and NAntContrib provide tasks
analogous to those described here for CVS, Subversion, StarTeam, and other software configu-
ration management systems.
CHAPTER 3 IMPORTANT NANT TASKS
83
JPG to JBIG2 Converter | Convert JPEG to JBIG2, Convert JBIG2 to
Users may easily change image size, rotate image angle, set image rotation in dpi Covert JPG & JBIG2 image with high-quality; Provide user-friendly interface
best convert pdf to jpg; convert pdf to jpeg on
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Convert PDF to Jpg, Png, Bmp, Gif, Tiff and Bitmap in ASP.NET. Or directly change PDF to Gif image file in VB.NET program with this demo code.
.pdf to jpg; convert pdf into jpg
<vssget> [NAntContrib]
This is the first VSS task we will use. It obtains the source code from the VSS database, which is
the first step in the proposed build process. As you can see, the task is relatively self-explana-
tory; in fact, all of the VSS tasks are structured in the same way.
The following example shows a straightforward getof some source code:
<?xml version="1.0"?>
<project>
<vssget 
user="builder"
password="builder"
localpath="D:\SourceCode"
recursive="true"
replace="true"
dbpath="D:\VSS\srcsafe.ini"
path="$/MySolution/" />
</project>
In this instance, the user builderneeds only read-only access to the VSS database.
<vsscheckin> [NAntContrib] and <vsscheckout> [NAntContrib]
Although we will make less use of these tasks, they do have their place. Say we want to main-
tain a copy of the latest database schema for a system as part of the build process. In this case,
we may want to check out, regenerate, and check in a file containing the schema. The check-
in part of this would look like the following; you can see the similarity to the previous task:
<?xml version="1.0"?>
<project>
<vsscheckin 
user="builder" 
password="builder"
localpath="D:\SourceCode\DB-Create.sql"
recursive="false"
dbpath="D:\VSS\srcsafe.ini"
path="$/MySolution/DB-Create.sql" />
</project>
In this instance, the user builderneeds write access to the VSS database.
<vsslabel> [NAntContrib]
As part of our efforts to provide versioning for a system, the <vsslabel>task lets us handle the
source control side of the problem. A labeling task implementation may look like this:
<?xml version="1.0"?>
<project>
<vsslabel
user="builder"
CHAPTER 3 ■ IMPORTANT NANT TASKS
84
password="builder"
dbpath="D:\VSS\srcsafe.ini"
path="$/"
comment="Automated Label"
label="v1.0.0.0" />
</project>
<vssundocheckout> [NAntContrib]
As you might recall from our earlier discussion of database scripts, in the event of a failure
during the generation of the database script, the consequence for the system is that the 
DB-Create.sqlfile will remain checked out in VSS, which in turn means that all subsequent
attempts to execute the build file will result in an error since the <vsscheckout>task will fail. 
To recover from this, we can use the <vssundocheckout>task to restore the state and try
once more.
Special NAnt Tasks
Apart from tasks, NAnt has a couple of other ways of performing actions inside a build script.
These methods open up further options for handling certain aspects of the build process.
NAnt Functions
First, NAnt comes with a built-in set of functions to be used in build scripts. We came across
an example of a function call in the <ifnot>task example earlier in this chapter. NAnt func-
tions cover a variety of areas, such as date- and time-, folder- and file-, environmental-, and
NAnt-specific functions. There are many functions, and the list continues to grow. Table 3-3
shows the list of functions available under the filecategory.
Table 3-3.NAnt File Functions
Function
Description
file::exists
Determines whether the specified file exists
file::get-creation-time
Returns the creation time and date of the specified file
file::get-last-access-time
Returns the date and time the specified file was last accessed
file::get-last-write-time
Returns the date and time the specified file was last written to
file::get-length
Gets the length of the file
file::is-assembly
Checks if a given file is an assembly
file::up-to-date
Determines whether targetFile is as up-to-date (or more cur-
rent) than sourceFile
These functions can be used to perform tests as shown in the <ifnot>example, or per-
haps to perform tests on the ifandunlessattributes of properties and tasks. The functions
help us carry out decision-making and conditional processing within a NAnt script. 
CHAPTER 3 IMPORTANT NANT TASKS
85
We can revisit the <ifnot>task to see how a function is called:
<ifnot test="${property::exists('project.name')}">
<fail message="Please enter a project.name to run this file." />
</ifnot>
Within the testattribute, the function call must return a Boolean value or the script can-
not be processed. Next the ${}(dollar, curly brace, curly brace) syntax is used to encapsulate
the function call with the ::(colon, colon) notation, differentiating the function type and spe-
cific method. Finally, if you are using a property name inside a function call (which is very
likely), then the property name should be wrapped in ''(single quotes).
Functions also support the use of operators such as equals, less than, add, and subtract.
The following function, which must also return a Boolean, is straight from the NAnt docu-
mentation and uses three functions to determine whether to call the <csc>task. In this case,
the criterion for calling the task is whether the assembly has been written to (in other words,
generated) in the last hour:
<csc target="library" output="out.dll"
if="${datetime::now() file::get-last-write-time('out.dll')) 
timespan::from-hours(1)}">
...
</csc>
In this example, the operators are in bold. The NAnt documentation contains up-to-date
information on available functions and operators.
Keep in mind, as usual, that the introduction of functions such as these into build scripts
imbues the scripts with some domain logic, or basis for decision making, rather than just con-
taining process logic. In fact, there will always be a need to have this sort of functionality, but
do be mindful of the complexity, and therefore risk, introduced here.
Script Tasks
In Chapter 7 we will see how NAnt can be extended, and how easy this can be, through the
creation of assemblies that NAnt can load and reflect over (using the <loadtasks>task). NAnt
can also be extended more simply through the use of a script task. 
A script task is the embedding of code within a build file using C# or another .NET lan-
guage (except C++). The code can then be executed as a target or as a function call, depending
on the implementation. These two implementation possibilities can be seen in the following
Hello World script tasks. 
First, we can define a function that returns a string ("Hello World!"in this case) within a
build file. Consider the following build file:
<?xml version="1.0"?>
<project>
<script language="C#" prefix="etomic" >
<code><![CDATA[                 
[Function("hello-world")]
public static string HelloWorld() 
{
CHAPTER 3 ■ IMPORTANT NANT TASKS
86
return "Hello World!";
}
]]></code>
</script>
<echo message='${etomic::hello-world()}'/>
</project>
In this file we create a script block using the <script>task, which contains a codeelement
with the actual C# code. In this case we are using a simple method to return a string. We have
placed an attribute on the method to make NAnt aware of the function and its name. Addi-
tionally, we have included a prefix for the code functions: although there is only one here, the
script block could conceivably contain many functions. Therefore, when the function is called
in the <echo>task, it is called with prefix::function-namenotation, in other words etomic::
hello-world.
We have not required any other namespaces, but in fact the <script>task supports
nested elements for imports and references and by default supports the following name-
spaces:System,System.Collections,System.Collections.Specialized, System.IO,
System.Text, System.Text.RegularExpressions, and NAnt.Core.
The output from the execution of the build file is as follows:
---------- NAnt ----------
NAnt 0.85 
Copyright (C) 2001-2004 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///ScriptFunction.build
[script] Scanning assembly "2qn-tswa" for extensions.
[echo] Hello World!
BUILD SUCCEEDED
Total time: 0.2 seconds.
Output completed (0 sec consumed) - Normal Termination
As the output shows, NAnt compiles the code into a temporary assembly and then loads
the assembly for use throughout the build file. You can then see the correct execution of the
function as part of the <echo>task call.
The next type of script task is the creation of an actual target. This is analogous to the cre-
ation of an actual custom task. This time, we need to add a little extra scaffolding to the build
script. Consider the following:
<?xml version="1.0"?>
<project>
<target name="HelloWorld">
<script language="C#">
<code><![CDATA[
public static void ScriptMain(Project project)
CHAPTER 3 IMPORTANT NANT TASKS
87
{
project.Log(Level.Info, "Hello World!"); 
}
]]></code>
</script>
</target>
<call target="HelloWorld"/>
</project>
This time we have wrapped the <script>task in a targetelement. We have also created a
public static void method accepting a projecttype as part of (or in this case as the entirety)
ofthe script. We need this ScriptMainmethod as the main entry point in order for a <script>
task to be used in this way. Having the projecttype available means that you have access to
allthe aspects of the current build file. 
To invoke the <script>task, we simply call the wrapping target.
The output from the execution of this target is as follows:
---------- NAnt ----------
NAnt 0.85
Copyright (C) 2001-2004 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///ScriptTarget.build
HelloWorld:
[script] Scanning assembly "zp3qshtq" for extensions.
Hello World!
BUILD SUCCEEDED
Total time: 0.2 seconds.
Output completed (1 sec consumed) - Normal Termination
The output is similar, as you might expect, but syntactic and semantic differences exist in
the two scenarios that can be used appropriately.
Although the examples here are trivial, very complex tasks can be performed in this way.
The main challenge of script tasks involves the debugging of C# in the build file, which is not
easy. I recommend that once a script moves beyond anything other than a utility that you
compile it into an actual assembly to remove risk and complexity from the build file itself
andto enhance the clarity of its purpose.
Tip
If you would like to see some serious use of functions and script tasks,turn to Appendix B for some
NAntsweeping fun.
CHAPTER 3 ■ IMPORTANT NANT TASKS
88
Documents you may be interested
Documents you may be interested