mvc open pdf in browser : Convert online pdf to jpg software Library cloud windows asp.net html class Expert_.NET_Delivery_Using_NAnt_and_CruiseControl_.NET_200525-part1073

{
get{return _compareOption;}
set{_compareOption = value;}
}
[TaskAttribute("server", Required=true)]
public string Server
{
get{return _server;}
set{_server = value;}
}
[TaskAttribute("database", Required=true)]
public string Database
{
get{return _database;}
set{_database = value;}
}
[TaskAttribute("uid", Required=true)]
public string Username
{
get{return _username;}
set{_username = value;}
}
[TaskAttribute("pwd", Required=true)]
public string Password
{
get{return _password;}
set{_password = value;}
}
The key points to notice about the previous code is the use of a DirectoryInfotype for
thefolder, which NAnt can handle automatically, and the available options for the Compare➥
Option. These are not particularly friendly ways of describing the sorting options for the folder,
but are in fact the way that the .NET Framework describes the options. Since we will be using
a reflective comparer, it is easier to use the default names. The three options mentioned (Name,
LastWriteTime,CreationTime) are not exhaustive but are the most likely ordering to be needed
for our purposes (more complete code should limit these options, of course).
Note
The code for the comparer is held in the ObjectComparer.csfile.This is a useful general-purpose
comparer and is ideal for the task at hand.
CHAPTER 8 DATABASE INTEGRATION
233
Convert online 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
batch pdf to jpg online; changing file from pdf to jpg
Convert online 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
batch pdf to jpg; reader pdf to jpeg
The<execute>method then looks like this:
protected override void ExecuteTask()
{
//Get and sort the files
FileInfo[] files = _folder.GetFiles();
Array.Sort(files, new ObjectComparer(new String[]{_compareOption}));
//Execute the SQL into the database
foreach(FileInfo fi in files)
{
Log(Level.Info, fi.Name);
ExecTask e = new ExecTask();
e.Project = this.Project;
e.FileName = @"osql.exe";
e.CommandLineArguments = String.Format(@"-U {0} -P {1} -S {2} -d {3} -i {4}", ➥
this._username, this._password,➥
this._server, this._database, fi.FullName);
e.Execute();
}
}
This method is deceptively simple and makes use of the aforementioned comparer to
provide a set of ordered files followed by the internal use of the NAnt <exec>task to complete
its work. Once the files are ordered, the task loops through the list and creates a new <exec>
task, attaching it to the current project, setting the arguments as required, and then executing
the task. The effect is to dynamically generate as many tasks as required to complete the exe-
cution of all the database scripts. If written as a regular NAnt task, the <exec>task would look
like the following (as an example):
<exec
program="osql.exe"
commandline="-U sa -P w1bbl3 -S localhost -d TestDB-Integration -i ➥
C:\BookCode\Chapter8\DBTest1\Users.sql"
/>
Using the <exec>task facilities saves us from having to handle all of the SQL-DMO bits
and pieces that would otherwise be needed through this automation and therefore provides
us with a simple and elegant solution that will suffice for our current needs.
We can test this custom task in the usual way: using a NAnt script. We will create a simple
database TestDB-Development by using scripts. These scripts can then be used to update the
integration database TestDB-Integration. The database scripts are as follows. The first,
Users.sql, contains the initial CREATE script for a table Users:
CREATE TABLE [dbo].[Users] (
[ID] [uniqueidentifier] NOT NULL ,
[Name] [char] (50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL ,
[Email] [char] (255) COLLATE SQL_Latin1_General_CP1_CI_AS NULL 
CHAPTER 8 ■ DATABASE INTEGRATION
234
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
convert pdf file to jpg on; convert pdf into jpg online
Online Convert PDF to Jpeg images. Best free online PDF JPEG
Online PDF to JPEG Converter. Download Free Trial. Convert a PDF File to JPG. Drag and drop your PDF in the box above and we'll convert the files for you.
change pdf file to jpg file; changing pdf to jpg on
)
GO
ALTER TABLE [dbo].[Users] ADD CONSTRAINT [PK_Users] PRIMARY KEY CLUSTERED  ([ID])
GO
The next script, Users-AddPostcode.sql, alters the Users table and adds a new column,
PostCode, to the existing table:
ALTER TABLE [dbo].[Users] ADD [Postcode] [char] (10) COLLATE 
SQL_Latin1_General_CP1_CI_AS NULL 
GO
The NAnt script to test out the new task is as follows, and can sit in the debug/binfolder
for the extensions project:
<?xml version="1.0"?>
<project>
<loadtasks assembly="Etomic.ManualDBTasks.dll"/>
<dbIntegrate 
folder="D:\BookCode\Chapter8\DBTest1\" 
compare="CreationTime"
server="localhost"
database="TestDB-Integration"
uid="sa"
pwd="w1bbl3"
/>
</project>
Prior to the execution of the NAnt script, the database contains no user tables, as can be
seen in Figure 8-5.
Figure 8-5.Empty TestDB-Integration
CHAPTER 8 DATABASE INTEGRATION
235
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.
convert multiple pdf to jpg online; convert pdf to jpg 100 dpi
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.
batch convert pdf to jpg online; convert pdf to jpg
Executing the test NAnt script produces the following results:
---------- NAnt ----------
NAnt 0.85
Copyright (C) 2001-2004 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///NAntExtenstions.ManualDBTasks.Debug.xml
[loadtasks] Scanning assembly "Etomic.ManualDBTasks" for extensions.
[dbIntegrate] Users.sql
[exec] 1> 2> 3> 4> 5> 6> 1> 2> 3> 1> 
[dbIntegrate] Users-AddPostcode.sql
[exec] 1> 2> 1> 
BUILD SUCCEEDED
Total time: 0.9 seconds.
Output completed (2 sec consumed) - Normal Termination
The results demonstrate that the custom task assembly is loaded, and that the <dbIntegrate>
task executes the Users.sqlandUsers-AddPostcode.sqlscripts in the correct order (that is, by
CreationTime). We can also see the nested <exec>tasks being executed for each script. Follow-
ing this execution, the Users table is included in the database TestDB-Integration, as shown in
Figure 8-6.
Figure 8-6.Table Users in database TestDB-Integration
CHAPTER 8 ■ DATABASE INTEGRATION
236
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.
pdf to jpeg; convert pdf to high quality jpg
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.
changing pdf to jpg; convert pdf to jpg batch
We could tidy up and bulletproof the code for the integration task, but essentially this task
now does what we need it to do as part of the delivery process.
Note
The same script can also be used to run SQL scripts rather than DDL scripts.We will see this
lateron.
Automated Integration Task
Next we turn our attention to the automation of the migration scripts themselves. Generating
migration scripts is no small task; it is not a simple matter of exporting the database schema.
Something like that will perhaps suffice for the generation of a CREATE script for a database,
which is useful in itself, but automated migration scripts require the use of ALTER scripts,
theremoval and addition of constraints, and other tricks and techniques to modify a schema
while the database itself contains data. This is something best left to those who specialize in
that, and I certainly do not. 
Instead, the following tools are a huge boon to the task at hand. Better still, they have fully
exposed .NET APIs for programming against, and that can mean only one thing: even more
custom NAnt tasks!
The Red Gate Tools
Red Gate Software Ltd. (www.red-gate.com) produces a suite of tools known as the Red Gate
SQL Bundle, which contains various tools for SQL Server, as shown in Table 8-2.
Table 8-2.Red Gate SQL Bundle
Tool
Description
SQL Compare
Provides comparison and synchronization scripts of schemas of SQL
Server databases
SQL Data Compare
Provides comparison and synchronization scripts of data held on SQL
Server databases
DTS Compare
Provides comparisons of server and DTS configurations for SQL Server
SQL Packager
Packages a SQL Server (data and schema) into either a C# project or an
executable for deployment elsewhere
SQL Toolkit
Provides access to the API for extension and use of the SQL Compare,
SQLData Compare, and SQL Packager tools
Tip
You can download a trial 14-day version from the web site that should allow you to test the concepts
and code in this chapter.
CHAPTER 8 DATABASE INTEGRATION
237
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
VB.NET print PDF, VB.NET merge PDF files, VB.NET view PDF online, VB.NET Convert PDF to image file formats with high quality, support converting PDF to PNG
reader convert pdf to jpg; changing pdf to jpg file
VB.NET Create PDF from images Library to convert Jpeg, png images
Components to batch convert PDF documents in Visual Basic .NET class. Support create PDF from multiple image formats in VB.NET, including Jpg, Png, Bmp, Gif
convert pdf pages to jpg; pdf to jpg
Using the Tools
Let us take a quick look at the use of the tools as they come out of the box, though the majority
of the work we will do uses the APIs in order to work within NAnt.
There are two flavors of tools in the current version: the regular GUI tools and also a set
ofcommand-line tools, which are just as feature-rich and probably more accessible for rapid
comparisons and synchronization.
We will concentrate on the SQL Compare tool, which is used to compare and synchronize
database schemas. However, the SQL Data Compare and DTS Compare are very similar in
terms of operation. The Packager application is a little different—its core responsibility is not
comparison and synchronization, but instead it handles the packaging of a database into an
executable program or C# project.
Firing up the GUI produces a “nag” screen if you are using an unlicensed copy of the soft-
ware. After this, a screen asking for connection information will appear. This can be used
directly as shown in Figure 8-7, or it can be canceled and a preexisting project can be loaded. 
Figure 8-7.The SQL Comparison Settings screen
Tip
The help files that come with the product are more comprehensive than those found with many
products,although the tool is relatively straightforward to use.
After we enter the information and click OK, SQL Compare does its magic and compares
the two databases. We are dealing with very simple databases and so the information provided
is minimal. In this instance, I have removed the PostCode column from the TestDB-Integration
database; the effects of this can be seen in Figure 8-8.
CHAPTER 8 ■ DATABASE INTEGRATION
238
Figure 8-8 shows that SQL Compare detected the differences between the two databases
and produced the CREATE scripts (with highlighted differences) for the two databases. Addi-
tionally, the synchronization, or ALTER, scripts can be viewed by clicking the relevant tabs.
Clicking the Synchronize button then walks the user through a series of screens and
results in the execution of the relevant script to provide the database synchronization.
Figure8-9 shows the screen after TestDB-Integration has been updated to the latest develop-
ment version.
So that is a simple example of the use of the SQL Compare tool. Its real power and utility
comes in its continuous use to provide migration capabilities without developers having to
think too hard about it, and in its use with more complex databases. Here, for instance, it is
not possible to see how SQL Compare handles the addition and removal of constraints in the
correct order to ensure error-free schema changes.
Tip
If you make wholesale changes to database design—such as the change of a primary key data
type—then you may well run into some problems.SQL Compare cannot do everything,but it can do quite a
lot.(I would spend more time worrying about the decision to change the data type ...) The point is that SQL
same way as unit testing and continuous integration is more successful with small steps.
CHAPTER 8 DATABASE INTEGRATION
239
Figure 8-8.A simple database comparison
We can also use the command line to perform the same operations. The command-line
tool comes with an enormous amount of switches and parameter possibilities and so is easiest
to use when performing regular activities such as quick comparisons. 
We can use the command shown in Figure 8-10 to perform a comparison between the
two databases.
Figure 8-10.SQL Compare command line
CHAPTER 8 ■ DATABASE INTEGRATION
240
Figure 8-9.SQL Compare following synchronization
As can be seen, the databases are fully synchronized, as we would expect from the efforts
using the SQL Compare GUI.
Automating the Red Gate Bundle
The APIs for SQL Compare and the other tools in the bundle are well documented, and there
are also useful code samples that demonstrate how to synchronize databases.
While the previous task is useful, effectively it is simply ordering and executing a series of
SQL scripts. It is flexible and can be used as needed in whatever database scenario we have. 
This time, since we are expecting SQL Compare to do all of the work in terms of script
production as well as synchronization, we need to think a little about what the deliverables
from the process should be. In terms of sensible assets to maintain for a build, we should
probably maintain a full CREATE script for the database in the current build and then also
maintain the migration necessary for a move from the prior build to the current one. With
these two assets, we can then synchronize the integration environments or create a new inte-
gration environment as desired. 
We should also consider that, as discussed previously, we may wish to synchronize multi-
ple database instances, though we may only want to maintain synchronization assets for one
of the instances; after all, the databases should be the same. 
With these points in mind, the following task would be useful:
<dbAutoIntegrate 
folder="D:\BookCode\Chapter8\DBTest2\" 
server="localhost"
database="TestDB-Development"
uid="sa"
pwd="w1bbl3"
write="true"
caption="0"
>
<databases>
<database server="localhost" database="TestDB-Integration" ➥
uid="sa" pwd="w1bbl3" write="true"/>
<database server="localhost" database="TestDB-System" ➥
uid="sa" pwd="w1bbl3" write="true"/>
</databases>
</dbAutoIntegrate>
The task will have a few features. The attributes in the main element contain the standard
four pieces of database information (server, database, username, and password) as well as
three other pieces of information: folderis the folder in which the scripts should be stored
when produced, writetells the task whether to produce a script for that particular step (in
thecase of the main element, whether to produce the CREATE script), and captionallows us
to pass through information to assist in the naming of the produced scripts (we would ordi-
narily pass through the build number).
The task is a little more complicated by the inclusion of child elements describing multi-
ple target databases for synchronization. In the previous example I have included the regular
integration database and also a System Test database server. I have marked both to have the
CHAPTER 8 DATABASE INTEGRATION
241
scripts produced, but in fact I would probably only maintain the migration scripts for the inte-
gration database. We will make a new type to represent these child elements in the main task.
We will call this new type DBInfo. It will be a custom NAnt element that we will create to hold
the information for each target database.
Implementing the DBInfotype is straightforward (in fact, thinking of a name for the type
was harder since the SQL Compare APIs use Database):
[ElementName("database")]
public class DBInfo : Element
{
private string _server;
private string _database;
private string _username;
private string _password;
private bool _write;
[TaskAttribute("server", Required=true)]
public string Server
{
get{return _server;}
set{_server = value;}
}
[TaskAttribute("database", Required=true)]
public string Database
{
get{return _database;}
set{_database = value;}
}
[TaskAttribute("uid", Required=true)]
public string Username
{
get{return _username;}
set{_username = value;}
}
[TaskAttribute("pwd", Required=true)]
public string Password
{
get{return _password;}
set{_password = value;}
}
[TaskAttribute("write", Required=true), BooleanValidator()]
public bool Write
{
CHAPTER 8 ■ DATABASE INTEGRATION
242
Documents you may be interested
Documents you may be interested