Mastering Visual Studio .NET 1002003 [Electronic resources] نسخه متنی

1.1 Solutions

A
solution
contains a collection of projects, along with information on
dependencies between those projects. The projects themselves contain
files. This structure is illustrated in Figure 1-1.
You can have as many projects as you like in a solution, but there
can be only one solution open at a time in a particular instance of
VS.NET. (You can, of course, open multiple solutions by running
multiple instances of VS.NET.)

Figure 1-1. A solution, its projects, and their files

Solutions contain only projectsyou cannot nest one solution
inside another. However, projects can belong to multiple solutions,
as Figure 1-2 shows, which gives you great
flexibility for organizing your builds, particularly in large
applications.

Figure 1-2. Projects that belong to multiple solutions

With Microsoft's previous generation of development
tools, each language had its
own integrated development environment. Now
there is just one unified environment. In addition, there are no
restrictions on the range of different project types any single
solution can contain, so you can work on, say, an unmanaged C++ DLL
in the same solution as a VB.NET Window Forms application, which can
greatly simplify development, debugging, and deployment. But before
we get too excited about that, let us see how to create a solution.

1.1.1 Creating a Solution

A
new solution may be created in many ways in VS.NET. The simplest is
to create a new projectby default, Visual Studio .NET will
create a new solution with the same name as the project, placing the
solution files[2] in the
same directory as the project. Although this works fine for small
projects, it isn't well suited to more complex
applications. Since a solution is a container of projects, it does
not make sense for the solution file to be inside the project
directory. For multiproject solutions, having the directory structure
reflect the solution structure usually makes more senseit is
best to have a directory that contains your solution file, with
subdirectories for each individual project.

[2] Two files are typically created for
each solution. The .sln file contains a complete
description of the contents of the solution. The
.suo file just contains information such as
editor window positions and breakpoint settings. The
.suo file is essentially dispensable since it is
not required in order to build the projects in the solution; unlike
.sln files, .suo files are
not normally checked into source control.

Visual Studio .NET is happy to create this type of directory
structure for you. When you create a new project by using the New
Project dialog box (Ctrl-Shift-N), you can bring up additional
options by clicking on the More button in the lower-lefthand corner
of the dialog. These options are shown in Figure 1-3. (The More button turns into a Less button
when the extra options are visible.) If you select the Create
directory for Solution checkbox, Visual Studio .NET will not place
the solution files in the same directory as the project. Instead, it
will create a folder for your solution and inside this will create a
second folder containing your project. The New Solution Name text box
determines the name of both the solution and the solution folder.
(You pick the project template you want to create as your first
project and type its name in the Name text box as usual.)

Figure 1-3. The New Project dialog box showing more options

You cannot select the Create directory for Solution option when creating a new ASP.NET project. With web projects, you will need to create a blank solution first in order to make your directory structure match your solution structure. To create a blank solution, use FileNewBlank Solutionthis will show the New Project dialog box with the Blank Solution template selected (see Figure 1-4). You can use the Location text box to choose the path for this New Solution Name and the Name text box to give it a name. A folder with your chosen name will be created at the specified path, and a new solution file (with the same name as the folder) will be placed there.

Figure 1-4. Blank Solution dialog box

Matching the file structure of a solution and its contained projects
to the logical structure has the advantage of making it easier to put
together a zip file of the whole solution. Consider what happens if
you just allow VS.NET to put new projects in the default locations
when you create a new project and then add a second project to the
solution. If you zip the first project directory, the zip file will
contain the solution file, but that solution file will refer to the
second project directory. However, the second project directory will
not be present in the zip file, because, by default, VS.NET will make
it a peer of the first project directory instead of a child. However,
if you make the directory structure reflect the logical structure,
with the project directories all being children of the solution
directory, you can simply zip up the solution directory, and the zip
file will contain all of the projects that belong to the solution.

Figure 1-5 illustrates how the physical directory
structure can reflect the logical structure of a project. Figure 1-6 shows how Visual Studio .NET will organize the
directory structure if left to its own devicesthe physical
structure is less closely related to the logical structure. The
solution file is located in an arbitrary project directory.
(Specifically, it is in the first project that was created in the
solution.) The project directories themselves may well be in the same
directory as other, unrelated directories or files. So, to avoid the
mess shown in Figure 1-6, be sure to check the
Create directory for solution checkbox.

Figure 1-5. Solution structure and directory structure in harmony

Figure 1-6. Solution structure and directory structure in discord (default)

1.1.2 Saving Web-Based Projects

By
default, VS.NET creates all new solutions beneath
the Visual Studio Projects folder inside of your
My Documents folder.[3] However, it is a bad idea to put solutions
that contain web-based projects here. Visual Studio .NET requires web
projects to reside in a directory with Web Sharing enabled, and in
Windows XP, you cannot turn on Web Sharing for directories underneath
the My Documents folder.

[3] You can
permanently change this default by going to Tools
Options, then going to Environment Projects and
Solutions and changing the path of the Visual Studio Projects text
box.

A certain amount of planning is required if you want to keep control
over where web projects end up, because although the default
locations chosen by VS.NET for your files will work, they may not be
the locations you were expecting, particularly if you let it create a
new solution for a new web project. When you create a new web-based
project, VS.NET communicates with the web server and checks to see
whether an application already exists for the URL you specified. If
not, it creates a new folder for the project under the root folder of
the web server (which is usually
%SystemDrive%\inetpub\wwwroot). The solution
files, however, will be elsewhereif you allow VS.NET to create
a new solution for your web project (and it will by default), it will
create a directory for your solution in the default location,
underneath your My Documents folder. It offers
you no choice over the location and doesn't even
tell you where it will go!

If you want to remain in control of the location of your web projects
and their solutions, you must first create a new blank solution. Then
use Windows Explorer to create a folder for your web-based project
inside of your solution folder. Enable web sharing on the new folder
using the Web Sharing tab on the folder's property
page, as shown in Figure 1-7. (You can get to the
property page by right-clicking on the folder in Windows Explorer and
selecting Properties.) Alternatively, you can use the IIS
administration tool to set the new directory up as a web application.

Figure 1-7. Web Sharing properties page

Once you have created the web shared folder, add a new web project to
your solution. (Use File Add Project
New Project. Alternatively, use the New Project
dialog (Ctrl-Shift-N) but select the Add to Solution radio
buttonthis will add the new project to your existing blank
solution instead of creating a new solution.) You must specify the
URL of the web share you created as the project location. This will
cause Visual Studio .NET to use your existing web folder instead of
creating a new one. When you create web projects in this way, all of
the files needed for that web project and the solution that contains
it are kept in one place rather than two.[4]

[4] Of course,
if your environment requires that you develop on a common web server
rather than from your local machine, this will not be a viable
solution, since the web project will be stored on another machine
(the web server). In this case, Visual Studio .NET's
default behavior for new web projects is perfectly reasonable,
although it does make it impossible to keep the solution and all its
projects in a single directory.

When you create a folder that will contain a web-based project, you must make sure that the ASP.NET worker process will be able to access that folder. The ASP.NET worker process runs as the ASPNET user by default, so make sure that user account has permission to read and write files in that directory.