mvc open pdf in browser : Convert pdf to jpg for control software platform web page winforms .net web browser Expert_.NET_Delivery_Using_NAnt_and_CruiseControl_.NET_200532-part1081

<sourcecontrol type="vss" autoGetSource="true">
<ssdir>"<xsl:value-of select="../../Settings/@VssFolder" />"</ssdir>
<project>$/Solutions/<xsl:value-of select="$ProjectName" />/
</project>
<username>
<xsl:value-of select="S../../Settings/@VssUsername" />
</username>
<password>
<xsl:value-of select="../../Settings/@VssPassword" />
</password>
<workingDirectory>
<xsl:value-of select="../../Settings/@EnvironmentMain" />➥
\Source\<xsl:value-of select="$ProjectName" />
</workingDirectory>
</sourcecontrol>
<build type="nant">
<baseDirectory>D:\dotNetDelivery\Chapter9\</baseDirectory>
<buildArgs>-D:debug=false</buildArgs>
<buildFile>
<xsl:value-of select="$ProjectName" />.Build.xml
</buildFile>
<targetList>
<target>ci</target>
</targetList>
<buildTimeoutSeconds>300</buildTimeoutSeconds>
</build>
<labeller type="defaultlabeller">
<prefix>1.0.</prefix>
</labeller>
<tasks>
<merge>
<files>
<file>
<xsl:value-of select="../../Settings/@EnvironmentMain" />\Reports\➥
<xsl:value-of select="$ProjectName" />\*-results.xml
</file>
<file>
<xsl:value-of select="../../Settings/@EnvironmentMain" />\Reports\➥
<xsl:value-of select="$ProjectName" />\fxcop.xml
</file>
</files>
</merge>
</tasks>
CHAPTER 9 ■ CODE GENERATION
303
Convert pdf to jpg for - 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; change pdf to jpg
Convert pdf to jpg for - 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
.pdf to jpg; change pdf to jpg on
<publishers>
<xmllogger />
</publishers>
</project>
</xsl:for-each>
</cruisecontrol>
</xsl:template>
</xsl:stylesheet>
Some areas where XSLT-specific directives are made appear in bold. Personally, I find
themix between XSLT and XML tags very confusing, though IDEs such as Altova’s XMLSpy
(www.altova.com/products_ide.html) can make life easier. Having said that, I think you will
agree that there is not too much difference otherwise.
Build Files
The last time we visited the build files, we paid considerable attention to ensuring they were
efficient, with as much commonality factored out as possible. Since then, we have looked at
adding in database steps and so on; the focus of that work was not on efficiency, however.
Code generation offers efficiency in a different way. That is to say, it does not matter how
much code there is because it does not require a developer to produce it. 
Note
This is not to say that code generators can happily be inefficient in terms of “tight code,”though—
reams and reams of code will eventually hinder performance,or the ability to trace defects,and so on!
With that in mind, let us consider the three artifacts we have to perform a current build:
Build.Core.xml. This file contains several common tasks but also handles all of the vari-
ables (or properties) for the overall process. Since we will need to pass the variables from
our data file, this file is impacted by the code-generation work.
Build.Common.xml. This file contains some useful common tasks but no real variables. We
could leave it unchanged if we desired.
<project.x>.Build.xml. This is the very file we have targeted in order to remove the
project-specific implementations of the build process. 
So what is the point of revisiting the other artifacts? Well, as we explained, we have to gen-
erate some of Build.Core.xmlin order to gain the benefits of sharing a single set of primary
data. Alternatively, we could split this file into two: one containing variables and the other the
functions. Perhaps the functions could all be moved into the Build.Common.xmlfile; we consid-
ered some of these possibilities earlier in the book.
With code generation, however, a new alternative emerges. We could in fact collapse
allthree scripts into single build scripts for each project. The common code is then repeated
across all projects, but in this case that is the point—all of the code becomes common.
CHAPTER 9 ■ CODE GENERATION
304
Online Convert Jpeg to PDF file. Best free online export Jpg image
Online JPEG to PDF Converter. Download Free Trial. Convert a JPG to PDF. You can drag and drop your JPG file in the box, and then start
change pdf file to jpg online; convert pdf to gif or jpg
Online Convert PDF to Jpeg images. Best free online PDF JPEG
Download Free Trial. Convert a PDF File to JPG. Easy converting! We try to make it as easy as possible to convert your PDF files to JPG.
convert .pdf to .jpg online; .net convert pdf to jpg
Another rationale is that using code generation to handle the structure of build scripts is rein-
forced by not having any nongenerated code. The temptation could be to tweak the core or
common files without considering that they are responsible for all projects in the same way as
the generated files are: we will end up with two artifacts handled in different ways but in fact
with the same responsibilities.
Therefore, I have chosen to join the build scripts together once more. An individual build
script will be self-contained and fully generated. This will aid independent debugging of the
templates on a project-to-project basis, and marks the strategy for the build scripts clearly.
Also, because NAnt offers no real strategy to handle these kinds of references, some of the
complexity of handling these references is removed from the delivery scenario.
Finally, before we take a look at the logic needed in the build script we should consider
the additional flexibility that code generation is introducing. Because we can perform loops,
conditionals, and other more complex functions within the generation routines, we can add
more explicit settings to the NAnt scripts themselves. This may manifest itself as less pattern
matching for files because we can name them explicitly and remove generality from them. In
this sense, an overall design should be considered. For example, I could use the functions of
code generation to provide the decision making for the script (Is a database target necessary?
Am I publishing a web or Windows application?) and leave the scripts themselves to follow a
linear process, effectively reducing the complexity of the build scripts at the expense of a more
complex data file and generation process. This is because the build scripts must perform con-
sistently many times over the course of a project without resorting to debugging and tracking
of decision paths. I am happier to spend time tracking defects while developing the genera-
tion templates than in the middle of an actual development. Removing decision making from
the scripts themselves removes risk from the process, which is always a good thing. Addition-
ally, the scripts are likely to be easier to debug.
So let us move on to the practical implementation of the build file. As you may recall, the
main issue with the specific build file was the identification of assemblies within the solution
for testing and documentation purposes.
Tip
Another way to handle this instead of code generation is to write some functionality to parse the
solution and .csprojfiles for a system to extract the names of the assemblies and inject this information
into the build script.This is perfectly possible,but the parser may lack the semantical knowledge to actually
get the decision correct.How do you know if an assembly is supposed to be documented? Perhaps if docu-
mentation settings are in place? Maybe they were missed/included by mistake? 
Assuming that we are receiving a feed of primary information, the knowledge required
about assemblies can be held in this feed. Our feed may look like the following:
<?xml version="1.0"?>
<ProjectSet xmlns="http://www.etomic.co.uk">
<Settings
CompanyName="Etomic"
CcnetUrl="http://localhost/ccnet"
VssFolder="D:\dotNetDelivery\VSS"
CHAPTER 9 ■ CODE GENERATION
305
C# Image Convert: How to Convert Adobe PDF to Jpeg, Png, Bmp, &
This demo code just converts first page to jpeg image. String inputFilePath = @"C:\input.pdf"; String outputFilePath = @"C:\output.jpg"; // Convert PDF to jpg.
pdf to jpg; c# convert pdf to jpg
C# Image Convert: How to Convert Tiff Image to Jpeg, Png, Bmp, &
RasterEdge.XDoc.PDF.dll. This demo code will convert first page to jpeg image. C:\input.tif"; String outputFilePath = @"C:\output.jpg"; // Convert tiff to jpg.
change pdf to jpg format; convert pdf to jpg c#
VssUsername="builder"
VssPassword="builder"
EnvironmentMain="D:\dotNetDelivery\BuildAreaCI"
/>
<Projects>
<Project Name="Library.Transformer" ProjectType="Library" ➥
HasDatabase="false">
<OutputAssemblies>
<OutputAssembly Name="Engine" AssemblyType="dll" ShouldTest="false" 
ShouldDocument="true"/>
<OutputAssembly Name="Tests" AssemblyType="dll" ShouldTest="true" 
ShouldDocument="false"/>
</OutputAssemblies>
</Project>
</Projects>
</ProjectSet>
Here we have included a collection of OutputAssemblies. An OutputAssemblytype captures
the name of the assembly (the full name can be derived from the company, project, and
assembly name as per the agreed standards). Also captured is the assembly type, whether it
should be unit tested, and whether it should be documented. 
The project has been extended to include information on the type of project (a library
assembly, a Windows Form application, or a web application) and whether a database is
involved.
The CodeSmith Template
This additional information is easily implemented in the serializable type with the following
changes:
public class OutputAssembly
{
[XmlAttribute]
public string AssemblyType;
[XmlAttribute]
public string Name;
[XmlAttribute]
public bool ShouldDocument;
[XmlAttribute]
public bool ShouldTest;
}
TheOutputAssemblyis a very straightforward type. It is included in the project definition
as you might expect:
CHAPTER 9 ■ CODE GENERATION
306
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 pictures to jpg; convert pdf to jpg file
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Resize converted image files in VB.NET. Convert PDF to Jpg, Png, Bmp, Gif, Tiff and Bitmap in ASP.NET. Embed PDF to image converter in viewer.
best program to convert pdf to jpg; change from pdf to jpg
public class Project
{
[XmlAttribute]
public string Name;
[XmlAttribute]
public bool HasDatabase;
[XmlAttribute]
public string ProjectType;
[XmlArray]
public OutputAssembly[] OutputAssemblies;
}
With the inclusion of this information, amending the necessary parts of the build script is
relatively easy. We have now merged the files together, so the template contains a lot of code,
but the template constructs that are relevant are covered here.
First, the injection of the data into the top-level variables looks like this:
<%
Project p = ProjectSet.Projects[ProjectNumber];
SettingCollection s = ProjectSet.Settings;
%>
<project name="<%=s["CompanyName"]%>.<%=p.Name%>" default="help">
<description>
Build file for the <%=s["CompanyName"]%>.<%=p.Name%> system.
</description>
<property name="nant.onfailure" value="fail"/>
<property name="company.name" value="<%=s["CompanyName"]%>"/>
<property name="solution.name" value="${company.name}.<%=p.Name%>"/>
<property name="core.directory" value="<%=s["EnvironmentMain"]%>"/>
<property name="core.source" 
value="${core.directory}\Source\${solution.name}"/>
<property name="core.output" 
value="${core.directory}\Output\${solution.name}"/>
<property name="core.docs" value="${core.directory}\Docs\${solution.name}"/>
<property name="core.reports" 
value="${core.directory}\Reports\${solution.name}"/>
<property name="core.distribution" 
value="${core.directory}\Distribution\${solution.name}"/>
<property name="core.publish" 
value="${core.directory}\Publish\${solution.name}"/>
CHAPTER 9 ■ CODE GENERATION
307
C# TIFF: C#.NET Code to Convert JPEG Images to TIFF
Use C# Code to Convert Jpeg to Tiff. string[] imagePaths = { @"C:\demo1.jpg", @"C:\demo2.jpg", @"C:\demo3.jpg" }; // Construct List<REImage> object.
change pdf file to jpg; convert pdf to jpg for
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
4. To Image. Convert PDF to image formats, such as PNG, JPG, BMP and GIF. Copyright © <2000-2015> by <RasterEdge.com>. All Rights Reserved.
changing file from pdf to jpg; to jpeg
<property name="vss.dbpath" value="<%=s["VssFolder"]%>\srcsafe.ini"/>
<property name="vss.path" value="$/Solutions/${solution.name}/"/>
So the ccnet.configand the build script files are now genuinely sharing a common source
of data. One point to notice here (and you may have noted the same thing in the ccnet.config
template file) is that I have not parameterized the individual folder names for the source code,
for publishing and so on. This is because the data file is designed to allow relatively arbitrary
changes to account for environment and similar changes. In fact, changing the name of pub-
lishing locations is not straightforward because these locations maintain historical artifacts
and therefore a migration process of some sort is likely needed if these variables are changed.
For the time being then, I do not allow arbitrary changes in this area. (The CCNet server URL
itself can change to allow multiple server instances from the same set of templates; otherwise
the same applies here.)
Further down the script we come to the points where identification of assets is needed.
For instance, the unit-testing task looks like this:
<nunit2>
<formatter type="Xml" usefile="true" extension=".xml" 
outputdir="${core.reports}\" />
<test>
<assemblies basedir="${core.output}\">
<%
foreach(OutputAssembly a in p.OutputAssemblies)
{
if (a.ShouldTest)
{
%>
<include
name="<%=s["CompanyName"]%>.<%=p.Name%>.<%=a.Name%>.<%=a.AssemblyType%>" />
<%
}
}
%>
</assemblies>
</test>
</nunit2>
So here is an example of explicitly stating the assemblies to be unit tested. There is now
no need to use NAnt’s pattern-matching for decision making in this area, though it might not
be a good idea to tell the developers that in the interest of keeping those standards up!
Several constructs of this type appear throughout the file, all doing the same thing. This
code repetition could undoubtedly be factored into a method in the template to return the
relevant array of assemblies.
Finally in this script is an example of the larger decision making being used in the template-
generation step. Previously, a property in the specific build file described whether or not an
application was a web application:
<property name="solution.isweb" value="true"/>
CHAPTER 9 ■ CODE GENERATION
308
This has now been removed, and this information is held in the data file as the ProjectType.
The build file template checks this information and includes the relevant target, removing the
conditional from the build file and therefore the runtime execution of the build file:
<%
if(p.ProjectType == "WebForm")
{
%>
<target name="publish">
...snipped...
</target>
<%
}
else
{
%>
<target name="publish">
...snipped...
</target>
<%
}
%>
That is about it for the build file with CodeSmith. Next up is the XSLT file.
The XSLT Template
Once again, most areas of the template are the same as CodeSmith, though with differing syn-
tax. For this reason, we will not reproduce the entire template here, though it is included with
the source code for the book. We should address one significant issue, though: the use of {}
(curly brackets). These are used by XSLT and NAnt for different purposes, and using the curly
brackets within an XSLT style sheet will cause XSLT to attempt to process the brackets and
their contents as a directive when in fact the intent was to mark a NAnt property. So this code
will not work correctly:
<property name="core.source" value="${core.directory}\Source\${solution.name}"/>
To get around this, the following XSLT syntax is required:
<property name="core.source">
<xsl:attribute name="value">${core.directory}\Source\${solution.name}
</xsl:attribute>
</property>
This means that the appearance of the generated file is a bit different under XSLT with the
inclusion of the closing tag, although in fact it is perfectly acceptable to NAnt. The use of this
syntax is a little more annoying in XSLT than CodeSmith, and certainly the curly brackets issue
is very confusing during debugging.
Some argue that properties can be avoided altogether since the build file is generated on
demand and so can be fully hard-coded. You may like to pursue this as an option if you are
using XSLT.
CHAPTER 9 ■ CODE GENERATION
309
Deployment Files
The deployment files we have generated have been less sophisticated than the build files,
although they became a little more involved with the inclusion of more complex scenarios
such as database integration. This is because NAnt is primarily a build tool, but we should
acknowledge once more that deployment quickly becomes more involved once there are
GACs to access, registry settings to change, and the like.
Another feature of the deployment files is that they are generally quite specific depending
on the project type. Even at this simple example level, the deployment of a library component
differs from the deployment of a Windows application, which in turn differs from the deploy-
ment of a web application. In this case, it may be worth having different templates for these
various scenarios; code generation best practice would probably suggest maintaining a collec-
tion of templates rather than jamming a whole bunch of complexity into one or two monolithic
templates, which also sounds like what we are doing with the build scripts themselves!
To use a different deployment template depending on the project, we could alter the
master template:
public void Go()
{
DateTime startTime = DateTime.Now;
Response.WriteLine("Beginning generation...");
_ccnetTemplate = this.GetTemplate("CCNet.cst");
_buildTemplate = this.GetTemplate("Build.cst");
_deployTemplate = this.GetTemplate("Deploy.cst");
_buildTemplate.SetProperty("ProjectSet", ProjectSet);
_deployTemplate.SetProperty("ProjectSet", ProjectSet);
for(int i = 0; i < ProjectSet.Projects.Length; i++)
{
Response.WriteLine("Preparing Build for " + ProjectSet.Projects[i].Name);
_buildTemplate.SetProperty("ProjectNumber", i);
_buildTemplate.RenderToFile(OutputDirectory + "\\" + ➥
ProjectSet.Settings["CompanyName"] +"." + ➥
ProjectSet.Projects[i].Name +".Build.xml", true);
Response.WriteLine("Preparing Deploy for " + 
ProjectSet.Projects[i].Name);
_deployTemplate.SetProperty("ProjectNumber", i);
_deployTemplate.RenderToFile(OutputDirectory + "\\" + ➥
ProjectSet.Settings["CompanyName"] +"." + ➥
ProjectSet.Projects[i].Name +".Deploy.xml", true);
}
Response.WriteLine("Preparing CCNet...");
_ccnetTemplate.SetProperty("ProjectSet", ProjectSet);
_ccnetTemplate.RenderToFile(OutputDirectory + "\\ccnet.config", true);
CHAPTER 9 ■ CODE GENERATION
310
Response.WriteLine("Generation complete. Execution time: " + ➥
(DateTime.Now - startTime).ToString());
Response.WriteLine("To view the output go here: " + OutputDirectory);
}
The deploy template is selected at the start of the process. Instead, it could be selected on
each iteration of the loop in the following way:
_deployTemplate = this.GetTemplate(String.Format("{0}.cst", ➥
ProjectSet.Projects[i].ProjectType));
I have not made this change in the source code since I am implementing only one scenario,
but the method is clear.
The deployment file requires only one additional setting to facilitate the deployment of
the library assembly we have used as an example. This requires no change to the ProjectSet
type. The final version of the ProjectSetdata file is as follows:
<?xml version="1.0"?>
<ProjectSet xmlns="http://www.etomic.co.uk">
<Settings
CompanyName="Etomic"
CcnetUrl="http://localhost/ccnet"
VssFolder="D:\dotNetDelivery\VSS"
VssUsername="builder"
VssPassword="builder"
EnvironmentMain="D:\dotNetDelivery\BuildAreaCI"
EnvironmentTempDeploy="D:\dotNetDelivery\TempDeploy"
/>
<Projects>
<Project Name="Library.Transformer" ProjectType="Library" ➥
HasDatabase="false">
<OutputAssemblies>
<OutputAssembly Name="Engine" AssemblyType="dll" ShouldTest="false" ➥
ShouldDocument="true"/>
<OutputAssembly Name="Tests" AssemblyType="dll" ShouldTest="true" ➥
ShouldDocument="false"/>
</OutputAssemblies>
</Project>
</Projects>
</ProjectSet>
So only the addition of the temporary deployment area (EnvironmentTempDeploy) has
beennecessary. The remainder of the deployment file is a matter of straightforward token
replacement.
As I was working, I discovered that there is no semantic information in the OutputAssembly
information to indicate whether or not an assembly should be deployed. In this instance I
have added a temporary fix to the template to ignore test assemblies. Also note that I should
remove the pattern-matching from the build publishtarget, which is part of this issue. Some-
times, this template tweaking takes a little time.
CHAPTER 9 ■ CODE GENERATION
311
Caution
When you are generating code,make sure you check that parameters have been introduced
into the resulting script correctly rather than running the script to find errors.Do I speak from experience?
You betcha.When constructing this chapter I left the TempDeployvariable empty and ran the deploy script.
The script deleted half my D:drive by the time I had the wherewithal to stop the NAnt process.I will leave it
to you to figure out whether good configuration management saved the day,or whether I spent half a day
repairing VS .NET,downloading lost code and realizing I had not checked in the code for the chapter for a
couple of days ...
With the three templates constructed (and debugged), the master template can be
invoked to generate the concrete build files for the defined projects.
Tip
When you are working with the templates and need to run them independently of the master
template,you can invoke them individually by passing the XML data file and a project number (default 0)
towork with.
When you run the master template in CodeSmith, you should see something like the fol-
lowing output, which is also reminiscent of the XLST NAnt script we have created:
Beginning generation...
Preparing Build for Library.Transformer
Preparing Deploy for Library.Transformer
Preparing CCNet...
Generation complete. Execution time: 00:00:01.4531529
To view the output go here: D:\dotNetDelivery\Chapter9
Investigating the content as suggested by the output reveals a screen similar to the one
shown in Figure 9-5.
Figure 9-5.Results of code generation
CHAPTER 9 ■ CODE GENERATION
312
Documents you may be interested
Documents you may be interested