Smart Client Software Factory Features and Resources

Architects and developers can quickly incorporate many of the proven practices and patterns of building composite smart client applications. These practices and patterns have been identified during the development of many smart client applications and their components.

Downloads
· Smart Client Software Factory
· Smart Client Software Factory Documentation
· Archive Version: Smart Client Software Factory – June 2006
Whitepaper
· Designing Smart Clients with the Composite UI Application Block & the Smart Client Software Factory
Getting Started
· Instructions for installing the Smart Client Software Factory
· Getting Started with the Smart Client Software Factory
· Overview of Composite UI Application Block
· Guidance Automation
Community
· Smart Client Software Factory Community
License
· End User Licensing Agreement (EULA)

By using the software factory, architects and developers can focus their efforts on business opportunities and create smart client applications that effectively address the needs of their organizations.

The Smart Client Software Factory provides an integrated set of guidance that assists architects and developers create composite smart client applications. These applications have one or more of the following characteristics:

They have a rich user interface that takes advantage of the power of the Microsoft Windows desktop.
They connect to multiple back-end systems to exchange data with them.
They present information coming from multiple and diverse sources through an integrated user interface, so the data looks like it came from one back-end system.
They take advantage of local storage and processing resources to enable operation during periods of no network connectivity or intermittent network connectivity.
They are easily deployed and configured.

Continue reading »

Web Services Software Factory-WSSF

What Is the Service Factory?

Generally speaking, software factories represent a collection of guidance that helps architects and developers build a specific kind of application. Therefore, the Service Factory helps developers and architects build Web service applications. Web service applications are more than just the technologies that send and receive SOAP messages and expose WSDL contracts—they also include the functionality that is needed to fulfill the service's behavior. Figure 1 illustrates the parts of the application, and their relationship with one another, the Service Factory will help you build.

Figure 1. Structure of a service built with the Service Factory

If you are already building services using WCF, the Service Factory also helps you build and secure those services.

The Service Factory provides the following benefits:

· Increased quality. It provides tested and accepted reusable assets, guidance, and examples that address common scenarios and challenges. It is based on patterns derived from proven industry and Microsoft practices.

· Increased predictability. The patterns & practices team works closely with the development teams responsible for building current and future generations of service and data access technologies. All services built with the Service Factory will be built in a predictable way, arrive at a predictable result, and will enable a predictable migration path to future technologies.

· Increased productivity. It includes automated code and configuration file generation for Visual Studio 2005. With this automation, developers can easily apply guidance in consistent and repeatable ways. Developers can also effectively use the .NET Framework without having to devote significant time to learning the necessary APIs.

· Increased flexibility.

The Service Factory is carefully designed according to proven practices, but it is also open and highly customizable. Architects and development leads can customize the factory to include the conventions, policies, and practices specific to a team or organization. Continue reading »

Microsoft .NET Web Application using CruiseControl.NET and NAnt

1 Abstract

The implementation of a reliable build and deployment process is the most important part of the Software Development Life Cycle (SDLC). It is difficult and inconvenient to build and deploy .NET application having multiple projects. Such application complicates the process during manual build and deployment. The CruiseControl.NET and NAnt tools are used to automate the complex build and deployment process.

The CruiseControl.NET is an automated continuous integration server implemented using the Microsoft .NET Framework. It can be used to customize the build process by modifying configuration file (ccnet.config) and also help integration with other external tools like NAnt and Visual Studio. NAnt is an advanced cross-platform XML build system for .NET software. The integration of NAnt script with CruiseControl.NET provides automation to build and deployment process.

This article is about providing ideas, practices, and a platform for standardizing approaches to build and deploy processes. In this article, we’ll review the configuration of CruiseControl.NET with NAnt scripts and executing build and deployment. We’ll see how to create NAnt script and also explore CruiseControl.NET configuration file.

System Architects and .NET developers are the targeted audience for this article who has knowledge of Visual Studio 2005 and XML.

2 cruisecontrol.net and NANT

2.1 CruiseControl.NET

2.2 NAnt

2.3 Why and When to use?

3 build and deployment process

3.1 Create a sample .NET Web Application

3.2 Create NAnt scripts for the build and deployment

3.3 Configure NAnt scripts with CruiseControl.Net

3.4 Execute build and deploy

4 Best Practices

5 Conclusion

6 abbrEvations, Acronyms and Nomenclature

7 Disclaimer

2 cruisecontrol.net and NANT

This section describes the significance of CruiseControl.NET and NAnt tools.

2.1 CruiseControl.NET

CruiseControl.NET is an Automated Continuous Integration [ACI] server implemented using the Microsoft .NET Framework. ACI is a process which monitors the version control system for changes/modifications and automatically runs the build process. CruiseControl.NET can be configured to run build and deployment automatically by setting its config file to run at particular time.

The CruiseControl.NET has a user interface called “Web Dashboard” using which one can execute and schedual build projects. It also provides consolidated log report for each execution and maintains the history.

Advantages of CruiseControl.NET

Integration with Visual Source Safe control (VSS)
Integration with other external tools, such as NAnt and Visual Studio
Can build multiple projects on one server
Can execute the build manually or schedule it at a suitable daytime
The scheduling of the build is as easy as modifying a XML based configuration file
The build report and logs are available at one place which makes it easy to track the history of all the builds.

2.2 NAnt

NAnt is an advanced cross-platform XML build system for .NET software available free as an open source. NAnt parses XML build files and executes the instructions gained from the file. The XML build file consists of a set of instructions for the build of a .NET solution. The build process includes tasks like compiling source code, running unit tests, configuring build-specific settings, etc. NAnt, as a tool, helps automate the build process by providing necessary power and flexibility to highly customized build actions of specific applications.

A normal build process mentioned below can be automated using NAnt.

Extract the latest source from Visual Source Safe (VSS)
Configure the build (Output of the build into a directory, the build number, scheduling, log, etc)
Compile the code
In order to deploy, package the output

NAnt enables one to automate the aforementioned steps instead of manual process of running commands and copying files. The NAnt script doesn’t require any special editor, can be created using Notepad (or XML editor) and saved as “.build” extension.

Advantages of NAnt:

Used to build, compile and run the .NET projects
It can easily handle the build although different modules of the project written in different languages like C#, VB, etc.
NAnt can easily integrate with NUnit testing tool - NUnit 2.0
NAnt can also perform other tasks like creating, deleting, copying files or directories, sending emails, zipping files, etc.
It allows to integrate .NET assemblies in the script which makes it easy to call any customized Method or Function.

2.3 Why and When to use?

The CruiseControl.NET and NAnt have some advantages over the new build and deployment tools like Visual Studio Team System (VSTS) and Team Foundation Server (TFS). Due to cost effective, reusability, open source and minimum infrastructure requirements makes CruiseControl.NET and NAnt more effective for the low budget and less resources project.

The comparison between tools, CruiseControl.NET/NAnt and VSTS/TFS used for build and deployment process is mentioned below:

Attributes	CruiseControl.NET, NAnt (using VSS)	VSTS, TFS
Cost	Free and Open Source	Requires License
Operation System	Windows 2000, XP or higher	Windows 2003
Installation & Configuration	Simple	Time consuming and complex
Source Control	Visual Source Safe (VSS)	Inbuilt, Team Foundation Version Source Control (TFVC)
Security	VSS based security on Source files	Windows/ Active Directory based security
Storage	File System ( VSS)	SQL Server 2005 (TFVC)
Features :
Multiple Check Out	Not Supported by VSS	Supported
File Merge	Not Supported by VSS	Supported, Manual and Automated Merge
File Lock	Exclusive Lock. Once file check-out, no one can check out or in	Lock Types: None: shared check-out Check-in: Others can check-out, but not check-in Check-out: exclusive lock, no one can check out or in
Shelving (Process of saving partial\ incomplete code in source control without Check-In)	Not Supported by VSS	Supported by Team Foundation Version Control
NAnt script knowledge	Required	Not required

Table 2.3.1: Comparison between the tools CruiseControl.NET/NAnt and VSTS/TFS.

If you have small team size and require cost effective build and deployment option, then CruiseControl.NET and NAnt can be effective. The correct methodology of implementation of build and deployment process using NAnt scripts makes it reusable for the other projects with less effort.

The next section will guide you to create build and deployment process for the sample Web Application.

3 build and deployment process

This section provides information on the steps to be followed in order to create build and deployment process for a sample Web Application using CruiseControl.NET and NAnt.

3.1 Create a sample .NET Web Application

In Visual Studio 2005, create a new web application “DemoBuildandDeployment” and provide the path c:\demo\demoBuildandDeployment
Add the “DemoBuildDeployment” project to Visual Source Safe (VSS)

3.2 Create NAnt scripts for the build and deployment

NAnt script file has the XML command tags, which make it very easy and convenient to write. NAnt script file starts with the <project> tag where the project name can be defined as an attribute. This is a root node of a build script and each script has one <project> tag.

</project>

<project> can have multiple <target> tags. A target is a discrete piece of work that can consist of zero or more tasks to be executed. Targets can be dependent on each other. Targets behave like a “Method” in .NET code which means they can be called within the build file or from another build file.

<project name="AutoBuild">
<target name="NewBuild">
</target>
</project>
<nant> tag is used to call particular task of build file whereas <property> tag is used to provide an input parameter to the build file. As shown below example, target <NewBuild> of Execute.build file is called using <nant> tag and the “branch” and “source.path” are passed as input parameter to Excecute.build file using <property> tag.
<project name="AutoBuild">
<target name="NewBuild">
<echo>Create New Build and Deployment</echo>
<nant buildfile="Execute.build" target="NewBuild">
<properties>
<property name="branch" value="$/demo/"/>
<property name="source.path" value="C:\demo\"/>
</properties>
</nant>
</target>
</project>

As mentioned below, <vssget> tag is used to get the latest source code from Visual Source Safe (VSS).

<vssget
username=”<User ID of VSS>”
password="<Password of VSS>"
localpath="<Working root directory on local system>"
recursive="true"
replace="true"
writable="false"
removedeleted="true"
dbpath="<Full srcsafe.ini path>"
path="<VSS path>"/>

The Visual Studio 2005 has an executable ‘MSBuild.exe’ used to compile and build application. The <msbuild> tag is used to build the project.

In order to simplify the build and deployment process of the sample Web Application, create four build scripts as mentioned below.

1. Main.build

This script would contain all the information of input parameters such as source code path, Visual Source Safe path, and deployment folder.

2. ApplicationBuild.build

This file would contain the commands to build the web application project in debug and release mode.

3. Deployment.build

This file would contain information to deploy the Web Application to virtual directory path of Web Application. (c:\Apps\Demo\DemoBuildandDeployment)

4. Execute.build

This file would be used to get the latest version of source code from VSS. It would call ApplicationBuild.build to build the latest source code and Deploy.build to deploy the project.

The logical flow of script execution is shown below.

Figure 3.2.1: Logical flow of build scripts

Detail implementation of each script is explained as below:

1. Main.build:

Main.build script is responsible for initiating the build by setting the input parameters.

Input parameters:

branch: VSS root branch path

source.path: Working directory path for Web Application where source code is located.

destination.path: Path of folder where virtual directory is mapped for website.

Figure 3.2.2: Main.build file

Execution of Main.build file will call “NewBuild” target of Execute.build file and

provides the input parameters.

NOTE:

<echo> tag is used to provide comments in log file or on command prompt

2. Execute.build

Execute.build script is responsible to call another script step by step. This script calls ApplicationBuild.build to build the web application then call deploy.build to deploy web application at destination location.

Figure 3.2.3: Exceute.build file

NOTE:

The property {db} is set to the VSS path where the srcsafe.ini file is located.

3. ApplicationBuild.build

ApplicationBuild.build script is responsible for building the Web Application, in the real sense, using <msbuild> command in debug and release mode.

Figure 3.2.4: ApplicationBuild.build file

<delete> tag is used to delete all the existing DLLs and other files residing in Debug and Release folder. In <msbuid> tag, argument “/property: Configuration” is used to define the mode of build. It can be set as either debug or release.

4. Deploy.build

Deploy.build script is responsible for deploying the DLLs and configuration files to destination folder.

Figure 3.2.5: Deploy.build file

Once all scripts are ready, they would require configuring with CruiseControl.NET to execute. The next section 3.3 describes the configuration of scripts.

3.3 Configure NAnt scripts with CruiseControl.Net

CruiseControl.NET tool has a configuration file (ccnet.config) which can be configured to run the NAnt scripts. Multiple projects can be configured to execute using this file.

The ccnet.config file is located at C:\Program Files\CruiseControl.NET\server\ccnet.config.

Some of the important XML tages used in ccnet.config file are as mentioned below:

XML Tags

Description

<project>

Define the project. ccnet.config file can be configured for multiple project execution using this tag

<webURL>

Web URL of CruiseControl.NET

<BuildFile>

NAnt script files which require to call

<targetList>

Target to call from NAnt script

<baseDirectory>

Location of build scripts

<publishers>

Logging the executable error

<triggers>

Call the Nant script at defined schedule

Table 3.3.1: XML tages used in ccnet.config file

Below is the config file configured to run our build and deployment process.

<cruisecontrol>
<project name="Demo Build and Deployment project">
<workingDirectory>C:\Demo\</workingDirectory>
<webURL>http://localhost/ccnet/</webURL>
<tasks>
<nant>
<executable>C:\Program Files\nant\bin\nant.exe</executable>
<baseDirectory>C:\demo\Operations</baseDirectory>
<buildArgs>-v</buildArgs>
<nologo>false</nologo>
<buildFile>main.build</buildFile>
<targetList>
<target>NewBuild</target>
</targetList>
<buildTimeoutSeconds>12000</buildTimeoutSeconds>
</nant>
</tasks>
<publishers>
<xmllogger logDir="C:\Demo\Log\" />
</publishers>
<triggers>
<scheduleTrigger time="15:00" buildCondition="ForceBuild">
<scheduleTrigger time="20:00" buildCondition="ForceBuild">
        <weekDays>
<weekDay>Wednesday</weekDay>
        </weekDays>
      </scheduleTrigger>
</triggers>
</project>
</cruisecontrol>

3.4 Execute build and deploy

To execute the Build and Deployment project access, the CruiseControl.NET Web Dashboard through the web address http://localhost/ccnet/ViewFarmReport.aspx.

Figure 4.4.1: Snapshot of CruiseControl.NET Web Dashboard before execution of the project

Click the “Force” button to start the build and deployment process and the “Activity” column status will change from “Sleeping” to “Building” which will revert back to “Sleeping” once the job is finished.

As shown in Figure 4.4.2 below, the status for “Last Build Status” column will change to “Success” once build is complete without any error. In order to view the log file of specific project, click on Project Name link which would provide the details of execution logs and in case of errors helps debugging.

Figure 4.4.2: CruiseControl.NET Web Dashboard after executing the project

NOTE:

The automated build and deployment can also be executed using manual command prompt as below:

"C:\Program Files\NAnt\bin\NAnt.exe" -buildfile:Main.build -v NewBuild

4 Best Practices

This section provides the details of some of the best practices that should be followed for automated build and deployment using CruiseControl.NET and NAnt.

· Based on the deployment environment, the configurable file like “Web.config” should be created at run time. In order to achieve this, a console .NET application can be created to generate the Web.config file which can be called from NAnt script. This will avoid manual modification of Web.config file for the different environments (Like development, Integration, System Acceptance Test, Test for Production, Production, etc.).

· Create separate NAnt script for each build and deployment process so that Build folder (Containing DLLs, aspx, etc.) is created only once and that can be used for deployment of different environments using deployment scripts. This will avoid building project multiple times for the different environments.

· VSS files can be marked with a Label to mention the build version which will help track the file used in a particular version of build.

• In order to receive a notification for the successful completion of the build and

deployment process, one can add <email> section in ccnet.config for the project.

5 Conclusion

In this article we learned to create NAnt script, configure NAnt scripts to CruiseControl.NET and explore ccnet.config file. The automated build and deployment process of .NET application using a CruiseControl.NET and NAnt tools is cost effective, reusable, easily configurable and requires minimal or no additional infrastructure setup. To make the build and deployment reusable for different projects, NAnt scripts should be divided based on logical task.

The next step would be to advance the build and deployment implementation based on your project requirements and using suggested best practices in this article.

6 abbrEvations, Acronyms and Nomenclature

Terminology and Description

ACI Automated Continuous Integration
IIS Internet Information Services
TFS Team Foundation Server
TFVC Team Foundation Version Control
VSS Visual Source Safe
VSTS Visual Studio Team System
XML Extensible Markup Language

NAnt script/ build script/ build file
An XML file consist of a set of instructions for the build of a .NET solution

7 Disclaimer

This paper should not be interpreted as an endorsement of any software products.

Continue reading »

Enterprise Library 4.0 Features

Enterprise Library 4.0 is released this month. There are few new features added in EL 4.0. One of those is new application block (The Unity Application Block). Unity is a lightweight, extensible dependency injection container with support for constructor, property, and method call injection.

You can use the Unity Application Block as a stand-alone dependency injection mechanism without requiring installation of Enterprise Library.

Here are some new features added in EL 4.0.

1. New Unity Application Block

2. Performance improvements

3. Pluggable Cache Manager

4. Windows Management Instrumentation (WMI) 2.0 support and improved instrumentation

5. VS 2008 support

6. Bug fixes in previous versions

To download/details visit

Enterprise Library 4.0 – May 2008 contains the following application blocks:

Caching Application Block. Developers can use this application block to incorporate a cache in their applications. Pluggable cache providers are supported.
Cryptography Application Block. Developers can use this application block to incorporate hashing and symmetric encryption in their applications.
Data Access Application Block. Developers can use this application block to incorporate standard database functionality in their applications.
Exception Handling Application Block. Developers and policy makers can use this application block to create a consistent strategy for processing exceptions that occur throughout the architectural layers of enterprise applications.
Logging Application Block. Developers can use this application block to include standard logging functionality in their applications.
Policy Injection Application Block. Developers can use this application block to implement interception policies that can be used to streamline the implementation of common features, such as logging, caching, exception handling, and validation, across a system.
Security Application Block. Developers can use this application block to incorporate authorization and security caching functionality in their applications.
Unity Application Block. Developers can use this application block as a lightweight and extensible dependency injection container with support for constructor, property, and method call injection.
Validation Application Block. Developers can use this application block to create validation rules for business objects that can be used across different layers of their applications.

Continue reading »

Training on Windows Vista: Register for free!

Continue reading »

Download and use Unity Application Block

Overview
The Unity Application Block addresses the issues in component-based software engineering. It provides simplified object creation, especially for hierarchical object structures and dependencies. For example, an object that processes customer information may depend on other objects that access the data store, validate the information, and check that the user is authorized to perform updates. Dependency injection techniques can ensure that the customer class correctly instantiates and populates all of these objects, especially where the dependencies may be abstract. It can read configuration information from standard configuration systems, such as XML files, and use it to configure the container. It supports custom container extensions that developers can implement
Unity Application Block exposes two methods.
RegisterType: This method registers a type with the container.
RegisterInstance: This method registers with the container an existing instance of a type that you specify, with the lifetime that you specify.

Using Unity Application Block
Using Register Type method

IUnityContainer myContainer = new UnityContainer();
myContainer.RegisterType();
IMyService myServiceInstance = myContainer.Resolve();

Using Register Instance method

IUnityContainer myContainer = new UnityContainer();
LoggingService myExistingObject = new LoggingService();
myContainer.RegisterInstance(myExistingObject);
IMyService myServiceInstance = myContainer.Resolve();
Download Unity Application Block at Read More at

Continue reading »

Unable to start debugging on the web server. Debugging failed because integrated Windows authentication is not enabled.

Are you getting Error while running the Website in .NET framework on VISTA

Error Screenshot:

Here is the Solution:

1. Open IIS. Click “Default Web Sites”.
2. Check if “Anonymous Authentication” is enabled.
3. Enable “Windows Authentication” as well.

Update: Related Article Links have been added

A Debugging of ASP.NET applications on IIS7
B Debugging of ASP.NET applications on IIS7

Continue reading »

Unable to create a website. The Web server does not appear to have the FrontPage server extensions installed.

Are you getting Error while creating a website in .NET framework on VISTA with IIS7

Here is the Solution:
1. Check if IIS is properly configured
a) Open the Control Panel and click on Programs and Features. In the left pane, click Turn Windows features on or off.
b) Expand Internet Information Services. Expand Web Management Tools and then expand IIS 6 Management Compatibility.
c) Select the IIS Metabase and IIS 6 Configuration Compatibility check box.
d) Click OK to start the installation process.

2. Check if the logged on account has “Administrative” rights. Else assign administrative rights.
Or else
a) Explicitly run Visual Studio as administrator. We must run Visual Studio 2005 in the context of an administrator account before we can develop web applications on Windows Vista. By default, Windows runs applications in a limited-privilege user account even when you are logged on to the computer as an administrator.
b) To run Visual Studio 2005 with administrative privileges in Windows Vista, click Start -> All Programs. Then, right-click on Microsoft Visual Studio 2005, and then click Run as administrator. Update: Related Article Links have been added
Read Also:
IIS 7.0 New features
22 New Features of Visual Studio 2008 for .NET Professionals
Top 10 Internet Explorer 8 features
ReaderWriterLock in C#.NET using System.Threading
Microsoft Dynamics Overview Continue reading »

Implement a simple captcha in C#.NET

1. Create a page with name “Captcha.aspx”

2. Place the following html code in body part of the page

          1: IMG height="30" alt="" src=BuildCaptcha.aspx width="80">

         2: asp:TextBox runat="Server" ID="txtCaptcha">

         3: <asp:Button runat="Server" ID="btnSubmit" 

         4:            OnClick="btnSubmit_Click" 

         5:            Text="Submit" />

         6:  

         7: 3. On “btnSubmit_Click” place the following code

         8:  

         9: if (Page.IsValid && (txtCaptcha.Text.ToString() == 

        10:      Session["RandomStr"].ToString()))

        11: {

        12:   Response.Write("Code verification Successful");

        13: }

        14: else

        15: {

        16:   Response.Write( "Please enter info correctly");

        17: }

3. Include the following code in “BuildCaptcha.aspx

         1: Bitmap objBMP = new Bitmap(60, 20);

         2: Graphics objGraphics = Graphics.FromImage(objBMP);

         3: objGraphics.Clear(Color.Wheat);

         4: objGraphics.TextRenderingHint = TextRenderingHint.AntiAlias;

         5:  

         6:  

         7: //' Configure font to use for text

         8: Font objFont = new Font("Arial", 8, FontStyle.Italic);

         9: string randomStr = "";

        10: char[] myArray = new char[5];

        11: int x;

        12:  

        13: //That is to create the random # and add it to our string

        14: Random autoRand = new Random();

        15: for (x = 0; x < 5; x++)

        16: {

        17:   myArray[x] = System.Convert.ToChar(autoRand.Next(65,90));

        18:   randomStr += (myArray[x].ToString());

        19: }

        20:  

        21: //This is to add the string to session, to be compared later

        22: Session.Add("RandomStr", randomStr);

        23:  

        24: //' Write out the text

        25: objGraphics.DrawString(randomStr, objFont, Brushes.Red, 3, 3);

        26:  

        27: //' Set the content type and return the image

        28: Response.ContentType = "image/GIF";

        29: objBMP.Save(Response.OutputStream, ImageFormat.Gif);

        30: objFont.Dispose();

        31: objGraphics.Dispose();

        32: objBMP.Dispose();

4. There you go you can test the page with captcha. Happy Programming! Continue reading »

Basic .NET, C#.NET, ASP.NET interview questions

What is an AppDomain? What is a process? What is thread? What is the difference between AppDomain and process?

Process: A computer program is a set of instructions. Operating system executes a computer program by allocating a process for a program. Several processes may be associated with the execution of a single program. A process is an instance of machine code associated with a program. It has memory for instructions, data, a call stack and a heap

AppDomain: An AppDomain is a light-weight process which separates one application in .NET with another. CLR creates an AppDomain when an application is loaded. Each application will have an AppDomain associated. Each AppDomain can have different threads running in it. Each app domain will have its associated code, data and configuration. Hence when one application crashes, it does not affect other.

Thread: Each process can have multiple threads. Multiple threads can share same execution code and resources. A multi-threaded process can perform several tasks concurrently.

What is a runtime host?

.NET framework supports different type of applications like Web, windows, console etc,. Each type of application needs a runtime host to start it. This runtime host loads the runtime into a process, creates the application with in the process and loads the application code into the process.

Runtime hosts included in .NET framework are

ASP.NET: It loads the runtime that can handle a web request into the process. ASP.NET also creates an application domain for each Web application that will ru

Microsoft .NET Support

	Microsoft .NET Support EMail Subscription Subscribe RSS