ASP.NET

Jump Start Your Web Site Development with the ASP.NET Starter Kits

Paul Litwin

Code download available at:StarterKits.exe(141 KB)

This article assumes you're familiar with Web Development

Level of Difficulty123

SUMMARY

If you're building an ASP.NET Web site you could probably use a good, solid code foundation to start with and build upon. Wouldn't it be nice to start with a complete site, make a few tweaks and customizations, and go live? The ASP.NET Starter Kits are packaged solutions that let you do just that. The five kits—Community, Reports, Commerce, Portal, and Time Tracker—supply full, reusable code that can be easily customized. In addition, there are a number of ISPs that support automatic deployment of ASP.NET Starter Kit Web sites, leaving you with little left to do when you have to get there fast. Here, the author introduces the ASP.NET Starter Kits and builds a community Web site with lots of advanced features such as ratings, user polls, upload quotas, change notifications, and themes.

Contents

The Commerce and Portal Starter Kits
The Time Tracker Starter Kit
The Reports Starter Kit
The Community Starter Kit
Creating a Community
The Community Starter Kit Architecture
Working with Themes
Creating a New Module
Conclusion

ASP.NET and Visual Studio® .NET have certainly made Web application development simpler. However, creating an ASP.NET Web site still involves some effort on your part. You still need to design a sound application and develop it with solid and reusable code and thorough testing. In the midst of this process you might ask yourself, "Hasn't anyone else ever tackled this problem before? Am I just reinventing the wheel?" Some scenarios are common to most ASP.NET developers, like putting together a community site, tracking time on a project, or creating a portal for your company. It would be nice to build upon a well-designed foundation rather than have to design the application from scratch even if it means customizing and extending the solution. That's exactly the idea behind the ASP.NET Starter Kits.

The ASP.NET Starter Kits are a set of five packaged sample applications from Microsoft that you can download from https://www.asp.net/starterkits. They include an e-commerce storefront app, a community Web site, a portal site, sample reports, and a project time-tracking app. The purpose of the starter kits is to provide several useful starter Web sites and some solid ASP.NET code samples that you can learn from and build upon. All five starter kits come with complete source code, work with SQL Server™ or Microsoft® Data Engine (MSDE) as the data store, and are available in Visual Basic®, C#, and J# versions. Additionally, the starter kits are available in both Visual Studio .NET versions (with separate .aspx and codebehind pages) and SDK versions (without codebehind pages). Thus, you can use your favorite development environment to work with the starter kits, whether it be Visual Studio .NET, the ASP.NET Web Matrix Project, or some other editor. In this article, I will introduce the five ASP.NET Starter Kits. Then I will focus on the Community Starter Kit in order to show you how you can extend it for your particular needs.

The Commerce and Portal Starter Kits

The Commerce Starter Kit creates an e-commerce storefront application for a fictitious spy company, IBuySpy. The application employs a three-tier architecture, caching, forms authentication, and a shopping cart. The Commerce Starter Kit also includes a B2B Web Service component. This is a great application to study and learn from, especially if you need to build an e-commerce application of your own.

The Portal Starter Kit creates the portal application for IBuySpy, the same fictitious spy company featured in the Commerce Starter Kit. The Portal Starter Kit features 10 portal modules: announcements, contacts, discussion, events, html/text, image, links, quicklinks, xml/xsl, and a custom module.

The Time Tracker Starter Kit

The Time Tracker Starter Kit (see Figure 1) is essentially a time and billing intranet application without the billing component. It is pretty straightforward. It has three tabs: Log, Reports, and Administration. You use the Administration tab to configure projects, the Log tab for logging hours, and the Reports tab for generating reports by project or individual.

Figure 1** Log Tab in Time Tracker Starter Kit **

The Time Tracker Starter Kit shows off a number of interesting ASP.NET architectural features including a three-tier design, Windows® and forms authentication, dynamic chart generation using GDI+, and a mobile front end.

The Reports Starter Kit

The Reports Starter Kit differs from the other starter kits in that it is not a single cohesive application. Rather, it's a series of eight reports that you can read about, run against sample data, and examine the source code from. In addition, you can copy and paste the source into your own applications. This kit works similarly to the ASP.NET QuickStarts that ship with the Microsoft .NET Framework SDK and Visual Studio .NET. The reporting examples include simple tabular reports, two styles of hierarchical drill-down reports, cross tabs, and several GDI+ charts.

The Community Starter Kit

The Community Starter Kit may well be the star of the show. Without much effort or knowledge of how it works, you can use it to quickly put together a community site for your user group, club, family, or community. You could also use it to put together a simple news and information site. In some ways, it overlaps with the functionality provided by the Portal Starter Kit, but it focuses more on the noncommercial organization and is easier to set up and manage.

The Community Starter Kit supports a number of different types of content, including articles, photo galleries, and event listings. In addition, it supports a number of optional features that are standard on many community sites, including advertisements, moderation, upload quotas, ratings, comments, user polls, content change notifications, automatic transformations, topics, Web boxes, syndication, newsletters, skins, and security.

Advertising is handled by a couple of AdRotator controls, one at the standard banner size of 468×60 pixels and the other at 125×125 pixels. If you enable moderation for a section, the content must be approved by a moderator before it is displayed on the site. You can set upload quotas for each user to limit the number of images and files that can be uploaded to the site. The Community Starter Kit also supports an upload quota for the entire community. This allows an ISP to host a number of communities on a single box without letting one site hog all the available disk space.

You have the option to turn on user ratings and comments for a particular type of content, such as books or articles. Users can rate a content item on a scale of 1 to 5 or, if they prefer, they can enter a comment instead of or in addition to the rating.

The Community Starter Kit supports the creation and reporting of user polls. Thus, you can poll users with questions like "What is your favorite .NET-targeted development language?" or "What was the name of Led Zeppelin's original drummer?" You can also notify users automatically when new content becomes available in a section. You can even specify transformations so that foul language is automatically cleaned up from submissions and comments without requiring any intervention on your part.

The Community Starter Kit has an option that allows you to create a list of topics so that users are required to categorize contributions as they are added. Thus, your .NET Framework-based news site might have topics such as ASP.NET, managed C++, Web Services, and so on.

The Community Starter Kit lets you add highlights of content in the margins of pages by enabling various Web boxes. For example, you could use a Web box to display the most popular or newest articles, links, downloads, or photos on the home page. You can also use the quote Web box to display random quotes on a page.

The Community Starter Kit supports content replication via two mechanisms: service subscriptions and Web Service boxes. Using a service subscription, you can aggregate content from a section of another Community Starter Kit site and display it on your site. For example, you might subscribe to the discussion section of another community site and display it on your site as if it were your own discussion section. Like Web boxes, Web Service boxes display excerpted information in the margins of a page; however, Web Service boxes can obtain their content from other sites. You can subscribe to another Community Starter Kit site that has published its content as an XML Web Service or you can subscribe to RSS services such as https://msdn.microsoft.com/msdnmag/rss/rss.aspx. You can publish any section of your site as a community service employing XML Web Services and the SOAP protocol (but not currently the RSS protocol). Published sections can be consumed as either a service subscription or a Web Service box.

You can send newsletters to community members. The newsletter component supports templates and the embedding of special tags that you can use to include fields such as Username, FullName, and Password, as well as content-specific fields like NewArticles, NewBooks, and NewDownloads.

The Community Starter Kit engine supports the concept of skins or themes, letting you radically change the look of the site by choosing a different theme from the admin page. Skins and themes are discussed later in this article.

The Community Starter Kit supports an extensive security system that classifies members according to their roles: anonymous, authenticated, moderator, and administrator, or according to your own custom roles. You can also secure any section of the site so that only certain types of users can view, add, edit, or delete content.

Figure 2** Community Web Site Example **

Figure 2 illustrates a number of the community features supported by the Community Starter Kit. This community, a fictitious user group called Ballard .NET, uses the Professional theme. Notice the user poll displayed at the top of the page and the community service feed box entitled ".NET Tips & Tricks" at the lower-right side of the page.

Creating a Community

After downloading and installing the Community Starter Kit, the first thing you will want to do is remove the sample site data. You can do this by clicking the Login link at the bottom of the navigation bar and logging in as user Admin with a password of Admin. (Change this password as soon as possible, since it's a security risk.) After successfully logging in, a new link (Admin) will appear on the navigation bar. Click this link to jump to the administration portion of the site and scroll down to find the Delete Content link.

When you return to the community home page after deleting content, you will notice that some sample content remains. To replace the home page content with your own, you will need to return to the admin page, click Edit Sections, click the Home section, and provide a site title, description, and logo. You can also use this Edit Sections option to change the basic layout of the home page, choose a theme, or enable a number of optional features (such as the display of Web boxes or Web Service boxes) for the home page.

After laying out the home page, you can add sections to your site. A site can have an unlimited number of sections. The various types of sections (or modules) you can create are listed in Figure 3.

Figure 3 Community Starter Kit Modules

To add a section, click the Edit Sections link from the admin page. You can create multiple sections of the same type. For example, the community shown in Figure 2 includes two article sections, News and Articles. You can use a parent section to help organize a group of similar sections. For example, if you wanted to separate your downloads by general category, you could create a parent section that contained several download sections, such as User Contributions, Controls, and Speaker Presentations.

From the Edit Sections page, you can enable various optional features that apply to the particular section, such as moderation or e-mail notifications. You can also opt to publish the contents of the section as a community Web Service.

The Community Starter Kit Architecture

While many Web sites are data-driven and dynamically generated, most are still largely static. While that's not necessarily a bad thing, the more content that's dynamically generated on a site, the more customizable it is. The Community Starter Kit is completely data-driven. Not counting the pages used for site administration, the Community Starter Kit contains exactly one .aspx page, which is devoid of content. All content is stored in a SQL Server or MSDE database. A single installation of the Community Starter Kit supports multiple communities which can be configured using the special ISPAdmin account.

When a request for a Community Starter Kit page comes into the Web server, an HTTPModule named CommunitiesModule handles the request and determines the community, section, page, and user associated with the request, populating the CommunityInfo, SectionInfo, PageInfo, and UserInfo objects, respectively. These objects are members of the Items collection of the Context object. Because the Context object is persisted across all modules and handlers that participate in a request, this data will be available to the page that handles the request (for more details on the Context object, see "ASP.NET: Nine Options for Managing Persistent User State in Your ASP.NET Application" by Steven Smith in the April 2003 issue of MSDN® Magazine). The CommunitiesModule then redirects the request to the communityDefault.aspx page, which is responsible for building the response dynamically using the aforementioned objects, a number of user controls, supporting classes, and style sheets.

Right out of the box, the Community Starter Kit probably doesn't do everything you might want, but the kit was built with extensibility in mind. If you don't like how it does something, you can easily change it. After all, it ships with the complete source code in Visual Basic .NET, C#, and J#. The themes and modules elements of this kit are particularly suited for customization.

Working with Themes

The design of the Community Starter Kit is based on the ASP.NET Forums application, and like the Forums application, it uses themes (also referred to as skins) to separate the user interface from the code. A theme is quite a bit more than a stylesheet. In fact, without themes there would be no content because themes contain all the controls that are displayed on the site. A theme is made up of the elements listed in Figure 4.

Figure 4 Elements of a Theme

To create a new theme, you need to add a folder underneath the Communities\Common\Themes folder. The name of the theme is derived from the folder name. Beneath this folder, create the folders shown in Figure 4. Fortunately, you don't have to populate every folder for a theme because all themes inherit from the base theme, Default. Thus, if you don't supply a skin that is needed by a theme, the Community Starter Kit uses a skin from the Default theme.

Although the Default theme contains more than 75 files, you can create a basic theme by providing just a few files. I created a basic theme, named Small, which is a knock-off of the Default theme. The basic differences from the Default theme are smaller fonts, a color change from blue to red, and a different layout for portions of the default page. My new theme consists of the six files that are listed here:

• Communities\Common\Themes\Small\Images\ redshiny3dsquarebullet_7x7.jpg
• Communities\Common\Themes\Small\Skins\ControlSkins\ Sections_SectionMenu.ascx
• Communities\Common\Themes\Small\Skins\PageSkins\Default.ascx
• Communities\Common\Themes\Small\Styles\an_red_arrow.gif
• Communities\Common\Themes\Small\Styles\Default.css
• Communities\Common\Themes\Small\Styles\redyellowstar.gif

Of course, the more elements you supply, the more complete your theme will be. For example, if you drill down into one of the sections using the Small theme, you will still see controls with a blue background. If I hadn't changed the color scheme of the theme, however, no one would be the wiser. The easiest way to create a new theme is to model your theme on an existing one and then modify its skins and styles.

Creating a New Module

While it's a bit more involved than creating a theme, you can also create a new module for your community. For example, I created a module named Jobs, which tracks job postings.

To create a new module, first add a new table to the CommunityStarterKit database and name it Community_module (where module is the name of the new module) that will be used to track the new module items. The primary key of this table should be named module_ContentPageID, along with the names of additional fields you want to collect for the module.

You'll need stored procedures that can be used to add a new module item, edit an exiting item, retrieve a list of items, and retrieve all of the fields for a single item. The stored procedures for the Jobs module are named Community_JobsAddJob, Community_JobsEditJob, Community_JobsGetJobs, and Community_JobsGetJob. I copied the stored procedures for the Articles module and used them as a model for the Jobs stored procedures, adding the additional fields needed to track job postings. Community_JobsGetJobs is used to retrieve the list of jobs for the Jobs_Section page. This module calls the Community_GetPagedSortedContent function to paginate the output (see Figure 5).

Figure 5 Community_JobsGetJobs Stored Procedure

CREATE PROCEDURE Community_JobsGetJobs ( @communityID int, @username NVarchar(50), @sectionID int, @pageSize int, @pageIndex int, @sortOrder NVarchar(50) ) AS DECLARE @currentDate DATETIME SET @currentDate = GetUtcDate() — Get the Articles SELECT Job_Company, Job_TempStatus, Job_TempMonths, Job_StartDate, Job_Location, Job_Education, Job_Experience, Job_Salary, Job_ContactName, Job_ContactPhone, Job_ContactEmail, Job_ContactWeb, Content.* FROM dbo.Community_GetPagedSortedContent ( @communityID, @username, @sectionID, @currentDate, @sortOrder, @pageSize, @pageIndex, default ) Content JOIN Community_Jobs ON Job_ContentPageID = ContentPage_ID ORDER BY IndexID

Create a new folder under Engine\Modules that will contain the module code. Under this folder, you should have three subfolders named Components, Content, and Controls. For the Jobs module, I created the Engine\Modules\Jobs\Components, Engine\Modules\Jobs\Content, and Engine\Modules\Jobs\Controls folders. The Components folder should contain two class libraries, the first containing a class that derives from the ContentInfo class, and a second containing a utility class that is responsible for calling each of the module's stored procedures.

Using the Visual Basic .NET version of the Community Starter Kit, I created a class library named JobInfo.vb, which contains a single class (JobInfo). I used the ArticleInfo.vb class library as a model for my class library. The JobInfo constructor takes a single parameter, a DataReader, with which it grabs each of the fields from the Jobs table and places them into private variables which are then exposed as a series of properties of the JobInfo class (see the code in Figure 6).

Figure 6 JobInfo Class (Excerpted)

Imports System Imports System.Data.SqlClient Public Class JobInfo Inherits ContentInfo Private _company As String Private _tempStatus As Boolean Private _tempMonths As String = String.Empty Private _startDate As String = String.Empty Private _location As String = String.Empty Private _education As String = String.Empty Private _experience As String = String.Empty Private _salary As String = String.Empty Private _contactName As String = String.Empty Private _contactPhone As String = String.Empty Private _contactEmail As String = String.Empty Private _contactWeb As String = String.Empty Public Sub New(ByVal dr As SqlDataReader) MyBase.New(dr) ' Populate required fields _company = CStr(dr("Job_Company")) _tempStatus = CStr(dr("Job_TempStatus")) ' Populate optional fields If Not (dr("Job_TempMonths") Is DBNull.Value) Then _tempMonths = CStr(dr("Job_TempMonths")) End If If Not (dr("Job_StartDate") Is DBNull.Value) Then _startDate = CStr(dr("Job_StartDate")) End If If Not (dr("Job_Location") Is DBNull.Value) Then _location = CStr(dr("Job_Location")) End If If Not (dr("Job_Education") Is DBNull.Value) Then _education = CStr(dr("Job_Education")) End If If Not (dr("Job_Experience") Is DBNull.Value) Then _experience = CStr(dr("Job_Experience")) End If If Not (dr("Job_Salary") Is DBNull.Value) Then _salary = CStr(dr("Job_Salary")) End If If Not (dr("Job_ContactName") Is DBNull.Value) Then _contactName = CStr(dr("Job_ContactName")) End If If Not (dr("Job_ContactPhone") Is DBNull.Value) Then _contactPhone = CStr(dr("Job_ContactPhone")) End If If Not (dr("Job_ContactEmail") Is DBNull.Value) Then _contactEmail = CStr(dr("Job_ContactEmail")) End If If Not (dr("Job_ContactWeb") Is DBNull.Value) Then _contactWeb = CStr(dr("Job_ContactWeb")) End If End Sub 'New Public Property Company() As String Get Return _company End Get Set(ByVal Value As String) _company = Value End Set End Property ' ... continues with the remaining properties

The JobUtility class provides the interface between the Jobs module and the Jobs stored procedures. It contains a single class, JobUtility, with four methods: AddJob, EditJob, GetJobs, and GetJobInfo. The GetJobs method is responsible for calling the Community_JobsGetJobs stored procedure and returning an ArrayList of JobInfo objects (see Figure 7).

Figure 7 GetJobs Method of the JobUtility Class

Public Shared Function GetJobs(ByVal username As String, _ ByVal sectionID As Integer, ByVal pageSize As Integer, _ ByVal pageIndex As Integer, ByVal sortOrder As String) As ArrayList Dim conPortal As New _ SqlConnection(CommunityGlobals.ConnectionString) Dim cmdGet As New SqlCommand("Community_JobsGetJobs", conPortal) cmdGet.CommandType = CommandType.StoredProcedure cmdGet.Parameters.Add("@communityID", CommunityGlobals.CommunityID) cmdGet.Parameters.Add("@username", username) cmdGet.Parameters.Add("@sectionID", sectionID) cmdGet.Parameters.Add("@pageSize", pageSize) cmdGet.Parameters.Add("@pageIndex", pageIndex) cmdGet.Parameters.Add("@sortOrder", sortOrder) Dim colJobs As New ArrayList() conPortal.Open() Dim dr As SqlDataReader = cmdGet.ExecuteReader() While dr.Read() colJobs.Add(New JobInfo(dr)) End While conPortal.Close() Return colJobs End Function 'GetJobs

The Content folder should contain one class library for each basic type of page that's supported by the module. These classes will become the code behind the user controls that you will create later. At a bare minimum, your module needs to supply classes for each of the following types of pages: add item, edit item, display a list of items (for the section page), and display an individual item (for the item drilldown page). These classes need to derive from the ContentAddPage, ContentEditPage, ContentListPage, or ContentItemPage, respectively. As you may have noticed, the Content classes tend to have a one-to-one correspondence with the stored procedures that they call.

I created four class libraries, AddJob.vb, EditJob.vb, JobSection.vb, and Job.vb, each modeled on the Articles content class libraries. The content classes are the glue between the JobInfo class and the user control skins. The Job class from the Job.vb class library is responsible for displaying the complete information for a particular job listing (see Figure 8).

Figure 8 Job.vb Class Library

Imports System Imports System.Web.UI Imports System.Web.UI.WebControls Imports ASPNET.StarterKit.Communities Namespace Jobs Public Class Job Inherits ContentItemPage Private _skinFileName As String = "Jobs_Job.ascx" Private _getContentItem As New _ GetContentItemDelegate(AddressOf JobUtility.GetJobInfo) Public Sub New() SkinFileName = _skinFileName GetContentItem = _getContentItem End Sub 'New End Class 'Job End Namespace

The Controls folder will contain custom server controls for each of the job items displayed on the Job and JobSection pages. I created the following server controls for the Job page: JobCompany, JobTempStatus, JobTempMonths, JobStartDate, JobLocation, JobEducation, JobExperience, JobSalary, JobContactName, JobContactPhone, JobContactEmail, JobContactWeb, and JobEditContent. For the JobSection page, I created the ItemJobLocation control. The JobCompany custom control is shown in Figure 9.

Figure 9 The JobCompany.vb Custom Server Control

Imports System Imports System.Web Imports System.Web.UI Imports System.Web.UI.WebControls Imports System.ComponentModel Imports ASPNET.StarterKit.Communities.Jobs <Designer(GetType(ASPNET.StarterKit.Communities.CommunityDesigner))> _ Public Class JobCompany Inherits WebControl Private _text As String Public Sub New() CssClass = "jobOtherFields" ' Get ContentInfo object If Not (Context Is Nothing) Then Dim objJobCompany As JobInfo = _ CType(Context.Items("ContentInfo"), JobInfo) If Not (objJobCompany Is Nothing) Then _text = objJobCompany.Company End If End If End Sub 'New Public Property [Text]() As String Get Return _text End Get Set(ByVal Value As String) _text = value End Set End Property Protected Overrides Sub RenderContents( _ ByVal writer As HtmlTextWriter) writer.Write(HttpUtility.HtmlEncode(_text)) End Sub 'RenderContents End Class 'JobCompany

Now you need to create user controls that represent the content skins for each of the basic module pages that correspond to the SkinnedCommunityControl classes created in the previous step. At a minimum, you must provide one set of content skin user controls for the Default theme. You may also provide content skin user controls for additional themes.

I created three user controls under the Themes\Default\Skins\ContentSkins folder: Jobs_AddJob.ascx, Jobs_JobSection.ascx, and Jobs_Job.ascx. There is no user control for editing a job because the Jobs_AddJob.ascx control does double duty, providing support for both adding and editing jobs. An excerpt of the Jobs_Job.ascx user control is shown in Figure 10. Notice the references to the custom server controls named JobCompany and JobTempStatus from the Engine\Modules\Jobs\Controls folder.

Figure 10 The Jobs_Job.ascx User Control

<%@ Control %> <%@ Register TagPrefix="Community" Namespace="ASPNET.StarterKit.Communities" Assembly="ASPNET.StarterKit.Communities" %> <table cellPadding=5 width=520> <tr> <td align=right colSpan=2><community:displaytopic id=topicPreview runat="Server"></community:DisplayTopic></TD></TR> <tr> <td class="Job_Label" colSpan=2><community:title id=lblPreviewTitle CssClass="Job_Title" Runat="Server"></community:Title></TD></TR> <tr> <td class="Job_Label">Description: </TD> <td><community:briefdescription id=lblPreviewBriefDescription CssClass="Job_BriefDescription" Runat="Server"> </community:BriefDescription></TD></TR> <tr> <td class=Job_Label>Company:</TD> <td><community:jobcompany id=lblPreviewCompany CssClass="Job_OtherFields" Runat="Server"></community:JobCompany> </TD></TR> <tr> <td class="Job_Label">Temporary Job?</TD> <td><community:jobtempstatus id=lblPreviewTempStatus CssClass="Job_OtherFields" Runat="Server"> </community:JobTempStatus></TD></TR> <!-- .. ascx page continues ... -->

At this point, I added styles to the default style sheet (Themes\theme\ Styles\default.css) for the new content controls. Several of these new styles are shown in Figure 11.

Figure 11 Subset of New Styles for Jobs Module

.JobSection_SectionTitle {font-weight: bold; font-size: 17px; font-variant: small-caps;} .JobSection_SectionDescription {font-family: verdana, arial, helvetica, sans-serif; font-size: 12px; font-weight: normal;} .Job_Table {border: none;} .Job_IntroCell {background-color:#EEEEEE;border:#CCCCFF solid 1px;} .Job_BodyCell {background-color:#FFFFFF;} .Job_Title {font-weight: bold; font-size: 17px; font-variant: small-caps;} .Job_BriefDescription {font-size: 12px; font-style: italic} .Job_Label {font-size: 12px; font-weight: bold; font-style: italic; background-color:#FFFFFF;} .Job_OtherFields {font-size: 12px; color: #333333}

Finally, I added entries for the item and item section pages to the Community_PageTypes and Community_NamedPages tables in the database. This step is relatively easy thanks to the stored procedure named Community_ MaintenanceInitializeJobs that I patterned after the existing Community_MaintenanceInitializeArticles stored procedure. Running this stored procedure created the necessary table entries.

Figure 12** JobSection Page **

Figure 12 shows the JobSection page for the Ballard .NET community site. If you click on the Read More link under a job posting, the Job page will display as shown in Figure 13.

Figure 13** Job Page **

Download a copy of the files that make up the Jobs module (as well as the Small theme) from the link at the top of this article.

Conclusion

The ASP.NET Starter Kits provide several prepackaged sample applications that offer both functional Web site templates and handy sample code in Visual Basic .NET, C#, and J#. The kits represent the most common Web apps, including community, commerce, portal, reporting, and project time-tracking sites. This article discussed the installation and use of the starter kits, as well as ways to customize and extend the Community Starter Kit through code (even if you don't own a copy of Visual Studio .NET). If you're looking for a way to jump start your ASP.NET site, these kits might be the set of jumper cables you're looking for. It's also worth mentioning that several Web hosting companies are offering automatic deployment of the starter kits along with account registration. See https://www.asp.net/hosters for details.

Thanks to Stephen Walther for his help with this article.

For background information see:
ASP.NET Starter Kits
https://msdn.microsoft.com/aspnet

Paul Litwin is the CEO and a senior trainer for Deep Training, a .NET training company. He is the conference chair for Microsoft ASP.NET Connections and has authored and co-authored a number of books, including ASP.NET for Developers (SAMS, 2001). He is currently working on a new book about ASP.NET. You can reach Paul at paull@deeptraining.com.