VB.NET and C# Comparison

Sometimes we need a simple VB.NET & C# side by side comparison. This sheet doesn't include all features, but its great place to start with.

Preview Of The Next TFS Power Tools Release

For a preview of the next TFS Power Tools release, please read Brian Harry’s blog.

The next version is really amazing!

From Brian’s post:

There are 3 major new components to the October Power Tools release and the usual incremental improvements.

• Team Members - We've added a new node to the Team Explorer called "Team Members".  It appears under each Team Project and is used to identify who are the people who work on the project.  It serves as a "pivot point" for information about and operations on people and teams.
• Windows Shell Extension - We've built a Windows shell extension that allows you to do the core version control operations directly inside the Windows Explorer without using the Team Explorer.
• PowerShell Support - We've started working on a PowerShell pipeline and commandlets for TFS.  Our initial set support basic version control operations but over time we plan to add work item tracking, administration, build and more.

This is one of the best Power Tools releases so far.

Read Brian’s post for full details.

I'm a Microsoft MVP!!!!

There are few emails that one will receive in his lifetime that will render him  completely speechless. I am delighted to find out that I have been awarded with 2009 Microsoft® MVP Award.
This is the email I received:

Subject: Congratulations 2009 Microsoft MVP!

Dear Maor David,
Congratulations! We are pleased to present you with the 2009 Microsoft® MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others.

I am really very excited and I want to take this opportunity to thank the community that supported me over the past year. Special thanks goes to Guy Burstein who has nominated me for the MVP program. Off course I’d like to thank to my company – SRL, that encourage excellence and sharing the knowledge with the community.

My MVP Profile page: https://mvp.support.microsoft.com/profile/Maor.David

Thanks!!!

Data Dude + Developer Edition = Team Developer

{From My VSTS KB}

In today's press release titled: "Visual Studio 2010 and .NET Framework 4.0 Overview" MS also announced the merge of the Developer Edition and Database Edition SKU's.

From Gert’s post:

What does this mean?

In the next release of Visual Studio Team System we will be merging the feature sets of the Development Edition and the Database Edition into a single product. The new product – part of Visual Studio Team System codename “Rosario” – will include all of the features in the Development Edition and the Database Edition as well as new capabilities delivering even more value in a single product. This will provide a more complete set of capabilities for building software in today’s data-driven environments. Bringing these two feature sets together enables you to take advantage of the core tools for application development as well as the necessary tools for database development, including performance profiling, code analysis, code metrics, code coverage, database refactoring, Schema Compare, Data Compare, and more.

As an MSDN subscriber we want you to realize the benefit of this merged feature set now, which is why we are extending this exclusive offer. If you have either the Visual Studio Team System 2008 Development Edition with MSDN Premium subscription or the Visual Studio Team System 2008 Database Edition with MSDN Premium subscription, on October 1, 2008 you will have access to both the Development Edition and Database Edition through MSDN Subscriber Downloads. This change also applies to customers who purchased Visual Studio 2005 Team Edition for Software Developers with MSDN Premium Subscription and Visual Studio 2005 Team Edition for Database Professionals with MSDN Premium Subscription.

Announcing Visual Studio Team System 2010

Published on My VSTS KB

Microsoft has officially named the Visual Studio Team System Code-name 'Rosario' suite of tools to "Visual Studio Team System 2010" in an announcement on 29-Sep-2008.  They have also posted information on MSDN and Channel 9.

The 2010 release will be a huge step forward for the tools in the ALM space. The new architect tools look great, the build system will be improved, the tools for project management will (finally) get support for hierarchical structures, test management... The list just goes on and on...

The complete announcement can be found here.

And Brian Harry of course has some more to add about this in this post.

Here are some links to the announcements, feature sets, goodies and articles:

• Microsoft PressPass - Microsoft Unveils Next Version of Visual Studio and .NET Framework
• Brian Harry's Blog - Shining the Light on Rosario
• MSDN - Visual Studio Team System 2010 Overview
• MSDN - Visual Studio 2010 and the .Net Framework 4.0 Overview
• Channel 9 - Norm Guadagno: Announcing Visual Studio Team System 2010
• Channel 9 - Visual Studio Team System 2010 Week on Channel 9!

Brian Harry also posted also that there would be another CTP this fall.

Data Dude:Deploy Action On CTP16 Does Not Deploy The Database To Target

A lot of users confused and don’t understand why the database does not appear on the target server when they do deploy.

The reason is that in CTP 16, the default deploy mechanism is to deploy to script. If you want to deploy to database you have to change the 'Deploy action' on the project properties, deploy tab to 'Create a deployment script (.sql) and deploy to the database.'

Team Foundation Menu Doesn't Exist In VB6 After MSSCCI Isntallation

I spent hours to understand why it happened…

My customer has VB6 SP5, we installed Team Explorer 2008, MSSCCI provider…and nothing! I started the VB6 IDE, but I cannot find any source control or Team Foundation menu's.

Then I found this thread.

The Solution:

Add the line:

vbscc=1

To c:\windows\vbaddin.ini

Then restart VB6, and you get a new menu item: Tools, Team Foundation.

Expression Blend & Team System

Many customers ask me the same question: does Expression Blend can talk with Team System / Source Control?

The answer, unfortunately, is no. Blend does not have the ability to use a source control repository and actually strips out any source control binding it finds in a project file.

The First Android Phone Will Be Launched Next Week

HTC Dream, the first mobile device that uses Android will be introduced on September 23 by T-Mobile at a press conference in New York. "HTC says it expects to ship 600,000 to 700,000 units of the smart phone, dubbed the Dream, this year," according to Wall Street Journal.
The phone will be available at the end of October, but you can see a demo from Google Developer Day in London.

Andy Rubin, Google's director of mobile platforms, is aware that the first Android-powered mobile phone is very important for the public perception. "If we come out with a dud, people will go, 'Well, that was a waste of time'". Reuters reports that the device will ship with a beta version of the Android application marketplace and Google will not make money from selling applications. "We made a strategic decision not to revenue share with the developers. We will basically pass through any revenue to the carrier or the developer."
{ via Google Operating System }

Virtual Team System User Group

From: http://vstskb.net  - http://feeds.feedburner.com/~r/vstskb/~3/394418841/

Paul Hacker and Dave McKinstry have started a virtual Team System user group. The user group will use Live Meeting for demos and talks, holding the social side of the user group meeting over in Second Life.  For more information and to register visit: http://www.tsug-ve.com/

The first meeting will be held on September 18, 2008 at 6:00 PM SLT.

For the meeting time in other time zones, click here.

Data Dude On RadioTFS

From http://vstskb.net - http://feeds.feedburner.com/~r/vstskb/~3/394424099/

Just published over on Radio TFS  a special episode on the Database Edition of Team System with the Data Dude man - Gert Drapers.  In the show Gert talks how the product got started, where it is now, where it is going in the future, the latest CTP of the Database Edition GDR and more.

<TestContainer> Works With WebTest & LoadTest In Team Build 2008 With SP1

Published on: http://vstskb.net/blog/2008/09/testcontainer-works-with-webtest-loadtest-team-build-2008-with-sp1/

The new <TestContainer> item in Team Build 2008 in a great way to run tests without test metadata file (*.vsmdi).

You can specify the following to run all unit tests found in assemblies matching the pattern *.Tests.dll and even specify .LoadTest and .WebTest files as well:

<ItemGroup>
  <TestContainer Include="$(Outdir)*.Tests.dll" />
  <TestContainer Include="$(Outdir)WebTest1.webtest" />
  <TestContainer Include="$(Outdir)LoadTest1.loadtest" />
</ItemGroup>

But if you try to run it in Team Build 2008, you will get an error like: Could not load file or assembly.

That's because the task tries to do an Assembly.LoadFrom() on whatever files you include in the <TestContainer> item. This obviously fails because .LoadTest and .WebTest are XML files, not assemblies.

This problem has been solved in TFS 2008 SP1. All you need to do is to apply the TFS SP1 patch to the build machine (If you don’t want, it’s not necessary to install TFS SP1 on TF Server to get the fix).

Team Build and ClickOnce

The other day I got a question: How can I deploy an app via ClickOnce using Team Build?

There is not out of box way to do that, but we can do it with a simple workaround:

we should overload the target AfterCompile in TFSBuild.Proj to call MSBuild Task Publish and can pass the PublishDir property:

<Target Name="AfterCompile">
  <MSBuild
  Condition=" '@(SolutionToBuild)'!='' "
  Projects="@(SolutionToBuild)"
  Properties="Configuration=%(ConfigurationToBuild.FlavorToBuild);
    Platform=%(ConfigurationToBuild.PlatformToBuild);
    SkipInvalidConfigurations=true;
    VCBuildOverride=$(MSBuildProjectDirectory)\TFSBuild.vsprops;
    FxCopDir=$(FxCopDir);OutDir=$(OutDir);
    PublishDir=$(OutDir);
    ReferencePath=$(ReferencePath);
    TeamBuildConstants=$(TeamBuildConstants);
    $(CodeAnalysisOption);PublishDir=\\qa1Srv\drops\publishedVers\ "
  Targets="Publish" />
</Target>

From: http://vstskb.net/blog/2008/09/team-build-and-clickonce/

Team System Web Access 2008 SP1

The Team System Web Access team had released SP1 last week.

Some of the cool new features include:

• Ability to run multi-language in a single TSWA instance.
• 10 languages supported
• Work Item only view for users without a CAL!!
• more

Ed Hintz’s announcement to see what’s new in this release:http://blogs.msdn.com/edhintz/archive/2008/08/29/team-system-web-access-2008-sp1-power-tool.aspx

 

Download: http://www.microsoft.com/downloads/details.aspx?FamilyId=3ECD00BA-972B-4120-A8D5-3D38311893DE

Dealing with Security Issues

Guest Post  - by Heather Johnson

No sooner is one fixed than another turns up, and if you’re not careful, you could end up losing all the data on your computer and the money in your bank. Viruses, Trojan horses, worms and other malware that are floating around on the Internet are morphing into new forms each time someone comes up with an antidote for those that are discovered. Not everyone is savvy about protecting their systems from being breached by hackers who are some of the best in the business.

Security suites and anti virus software offer some form of protection, and as they are updated regularly as and when new virus signatures are discovered. But even if your security software is up to date and reliable, there are ways that hackers can get at your system if you are not careful.

• Don’t log in to your computer as an administrator as this leaves your system vulnerable to attacks. When you surf the web and hit a strange or untrusted site, you could end up with a formatted hard disk. Hackers could also create their own user accounts with administrative privileges. When you need to perform tasks that require administrative privileges, you can log in temporarily as an administrator from a non administrative account.
• Do not click on links in emails from strangers.
• Do not open attachments without scanning them for malware.
• Do not share your passwords with even friends and family.
• Be up to date in applying security patches and system updates.
• Log out of your accounts, email, bank and others, when done.
• Do not use public computers to conduct sensitive transactions.
• Use secure sites that offer encryption when using your credit card to order goods and services online.
• Do not provide sensitive information online even if the request seems to come from trusted sources.
• Do not enable file and print sharing.
• Lock your computer or log out when leaving your desk.
• Shut down your computer when done for the day.
• Do not download software that is on offer from a source you cannot trust.
• Remove programs and applications that you do not use.
• Protect your home network from sniffers if you use a wireless router to connect.

By-line:

This article is contributed by Heather Johnson, who regularly writes on ATT Yahoo. She invites your questions and writing job opportunities at her personal email address: heatherjohnson2323 at gmail dot com.

VSTSDB 2008 GDR CTP16

Gert just posted about the release of CTP16 of the Visual Studio Team System 2008 Database Edition GDR release.

From Gert’s post:

This release adds the following features:

• VSDBCMD.EXE
  • We added independent commandline deployment and reverse engineer, which can be used on machines that do not have Visual Studio installed, in order to deploy the results of a database project build (.dbschema file), or if you need to generate a .dbschema file so you can for example compare it, this commandline tool will let you do that as well.
• Database Project (.dbproj) Upgrades
  • CTP15 enabled upgrade of project files, but did not included updating Data Generation Plans (.DGEN files), which now be upgraded when they are opened the first time inside the DGEN designer.
• Schema Compare
  • You can now choose the SQL Command Variables (SQLCMD) to use during a Schema Compare session by clicking the “Specify SQLCMD variables” button on the Schema Compare toolbar. This will allow you to compare projects that are using SQLCMD variables and provide the contextual information via the variable values.
  • You can now set the Schema Compare options at the session level, in addition to Tools->Options, by clicking the Settings button on the Schema Compare toolbar.
  • And you can now save your Schema Compare session and reopen it again. We also added an item template for this, name "Schema Comparison"
    
• Extensibility
  • We finished the namespace and assembly naming cleanup. As a result all assembly names and namespaces have been changed. This means if you have code leveraging our extensibility mechanisms you need to update the assembly references and namespaces in your code.
  • We added the ability to add your own refactoring types! So now you can create your own refactoring command and have it change all the required references inside the schema. This is above and beyond the ability to create your own refactoring targets (the sources your want to change by an refactoring type), static code analysis rules, data generators, data distributions and test conditions.
  • We now also offer public access to our TSQL parsers for SQL Server 2000, 2005 and 2008, including the script generator functionality.
• And then there are many more enhancements in the parser, interpreter, validation, build and deploy.

Pre-requisites:

CTP16 requires the following components to be installed:

• Visual Studio 2008 SP1 RTM
• Microsoft SQL Server Compact Edition 3.5 SP1

Download location:

You can download CTP16 from the following location:

• http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/setup.exe
• http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Readme.mht
• http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/VSTS 2008 Database Edition GDR Documentation.zip

NOTE: If you have a previous version of the GDR installed, you will have to first uninstall this and then install the latest CTP16 bits.

TFS SP1 – Whats New? Want To Know Camano?

The Israeli ALM user group is back! I’m proud to be one of the 2 managers of this user group - my colleague is Sarit Tamir.

Next meeting (8 September 2008, 17:30) will be focused on the new features that were delivered with VSTS 2008 SP1 and the new Power Tools. We will also introduce the new testing suite (Camano) that will be shipped with the next version of TFS – Rosario.

Shahar Bracha will talk about Visual Studio Team System Power Tools which enables us better usage and ease when working with TFS.

During his session we will go over the new Power Tools and Service pack features  (such as: Web access enhancements, notifications support,  build, folder mapping and much more…)

For our second session, Eran Ruso will go over CTP 12 of Rosario in general and focus on Camano, a new standalone testing suite in Rosario.  Eran will also describe his experience as part of the first group that uses Rosario and Camano in production environments.

About the lecturers:

Shahar  is the ALM Manger at SRL Group, specializes in Microsoft technologies with an emphasis on the Team System, .NET framework and Web application architecture.

Eran  is a Senior Consultant at SRL Group, specializes in QA methodologies  and testing lifecycle.

 

I’ll be happy to meet you there!

Maor

 

Please register here to the event:

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032384162&culture=he-IL

Visual Studio 2008 Service Pack 1 and .NET Framework 3.5 Service Pack 1

Introduction

Visual Studio 2008 and the .NET Framework 3.5 enable developers to rapidly create connected applications that deliver high quality and rich user experiences. Visual Studio 2008 enables organizations of every size to rapidly create secure, manageable, and reliable applications that are optimized for Windows Vista™, SQL Server, the Microsoft 2007 Office system and the Web.

Visual Studio 2008 Service Pack 1 (SP1) and .NET Framework 3.5 SP1 continue Microsoft’s investment in market leading development tools and developer platform. SP1 addresses issues that were found through a combination of customer and partner feedback, as well as internal testing. These service packs offer customers improvements in responsiveness, stability and performance.

Overview

.NET-based Windows application development benefits from increased Windows Presentation Foundation (WPF) designer performance and updated components for Visual Basic and Visual C++ (including a MFC-based Office 2007 Ribbon).  Web development improvements include enhanced the client-side script tooling (JavaScript IntelliSense). In addition to IDE performance improvements SP1 fully supports SQL Server 2008 and the ADO.NET Entity Framework.

The .NET Framework 3.5 Service Pack 1 (SP1) delivers more controls, a streamlined setup, improved start-up performance, and powerful new graphics features for client development and rich data scaffolding, improved AJAX support, and other improvements for Web development. Additionally it introduces support for the ADO.NET Entity Framework and ADO.NET Data Services, which simplify data access code in applications by providing an extensible, conceptual model for data from any data source and enabling this model to closely reflect business requirements.

Visual Studio 2008 SP1 delivers:

• Improved WPF designers
• SQL Server 2008 support
• ADO.NET Entity Designer
• Visual Basic and Visual C++ components and tools (including an MFC-based Office 2007 style ‘Ribbon’)
• Visual Studio Team System Team Foundation Server (TFS) addresses customer feedback on version control usability and performance, email integration with work item tracking and full support for hosting on SQL Server 2008
• Richer JavaScript support, enhanced AJAX and data tools, and Web site deployment improvements

The .NET Framework 3.5 SP1 delivers:

• Performance increases between 20-45% for WPF-based applications – without having to change any code
• WCF improvements that give developers more control over the way they access data and services
• Streamlined installation experience for client applications
• Improvements in the area of data platform, such as the ADO.NET Entity Framework, ADO.NET Data Services and support for SQL Server 2008’s new features

Additional Details

WPF and visual designer improvements

Cold startup performance improvement ranging between 20-45% depending on application size without needing to modify any code.

Additional WPF support for text and graphics, and media to deliver better performance. For example, effects like DropShadow and Blur were implemented using software rendering; with SP1 these are now implemented using hardware acceleration. Other examples include:

• Text, especially when used in Visual and DrawingBrush, is substantially faster,
• Scrolling improvements with Container Recycling, improved working set with TreeView virtualization
• A much improved WriteableBitmap that enables real-time bitmap updates from a software surface,
• Designer support for the event tab within the property grid for control events,
• Toolbox support within source mode.

.NET Framework 3.5 SP1 Optimized Client Runtime

SP1 provides a .NET Framework install version that is optimized for .NET-based client applications. The size of this optimized runtime is less than 28 MB.

New ADO.NET Data Features

ADO.NET Entity Framework

The ADO.NET Entity Framework is the next evolution of ADO.NET, raising the level of abstraction at which programmers work with data, and allowing the database structure or data source to evolve without significant impact to the application code.

Rather than coding against rows and columns, the ADO.NET Entity Framework allows the definition of a higher-level Entity Data Model over your relational data, and allows developers to then program in terms of this model. Developers get to deal with the data in the shapes that make sense for the application, and those shapes are expressed in a richer vocabulary that includes concepts like inheritance, complex types, and explicit relationships.

Use LINQ to Entities with the Entity Framework for queries that help create easy to maintain code that retrieves and works with strongly typed data objects or business entities.

ADO.NET Data Services

The Microsoft ADO.NET Data Services framework provides a first-class infrastructure for developing the next wave of dynamic internet applications by enabling data to be exposed as REST-based data services that can be consumed by client applications (ASP.NET, AJAX, Silverlight) in corporate networks and across the internet. Easily build applications using a comprehensive set of Microsoft .NET libraries and client components, accessing data through uniform URI syntax and using standard HTTP verbs to operate on the resource.

ADO.NET Data Services provides a framework to build data services for relational data sources, such as Microsoft SQL Server, MySQL, DB2, and Oracle, using the built-in support for the ADO.NET Entity Framework, or for non-relational data sources using the pluggable provider model.

TFS improvements

A number of improvements have been made to Visual Studio Team System 2008 Team Foundation including:

Version Control

• Simplified the user experience through cleaner “Add to Source Control” dialogs, drag and drop support to the Source Control Explorer and a much easier to use “Workspace” dialog for working folder mappings.
• Version control now automatically supports non-solution controlled files.
• Various changes to the Source Control Explorer such as a new checkin date/time display column, local path hyperlink support and en editable source location field.

Work Item Tracking

• Microsoft Office 2007 integration is now done using the standard Office “Ribbon” delivering a cleaner and easier to use integration to the different Microsoft Office 2007 products.
• Email integration for work items and links for Team system Web Access to make it easier to use email as part of the development lifecycle.

Visual SourceSafe migration tool

• The migration tool has been dramatically improved through many performance and reliability improvements. SP1 provides support for the elimination of namespace conflicts, automatic solution rebinding, improves timestamp coherency and increases the amount of migration logging information available.

Additional Features

• Support for using SQL Server 2008 with Team Foundation Server.
• Team System Web Access provides “live” links to work items and checkin emails. This improves the customer experience for users who do not use Team Explorer.
• Scripting support for the creation of Team Projects.

Performance and scalability

• With SP1 a large part of the focus was to improve the performance and scalability of Team Foundation Server through changes such as faster synchronization with Active Directory, improved checkin concurrency, a faster way to create source tree branches, online index rebuilding for less maintenance downtime and better support for very large checkin sets.
• Improvements in the number of projects a server can support that make not only the scalability of the server better but also the client experience when connecting to a server with a large number of projects on it.

 

from http://msdn.microsoft.com/en-us/vstudio/products/cc533447.aspx

CTP15 of the GDR release of VSTSDB is available

Gert just announced that they just released a new CTP of the upcoming 2008 update, Microsoft® Visual Studio Team System 2008 Database Edition GDR.

You can download it from MSDN:
http://www.microsoft.com/downloads/details.aspx?FamilyID=bb3ad767-5f69-4db9-b1c9-8f55759846ed&displaylang=en

Most important changes:

• Project upgrade is now in place.
• Mixed projects are no longer supported, from now on server projects represent only server creatable objects and user objects that need to be deployed to “master”. Another change is that server options will not get deployed; we only validate the settings as pre-requisites for a deployment. As such server options (sp_configure) have been added to the project system.
• The interpreter now understands temporary tables, table variables and select into column sources.
• The Static Code Analysis MSBuild task was added
• XSD Reference user interface support is enable, but it does not yet create XML Schema Collections
• And lots of fixes since CTP14

 

Share this post :

VSTS 2008 Team Foundation Server Power Tools - July 2008 Release

The Visual Studio Team System 2008 Team Foundation Server Power Tools is a set of enhancements, tools and command line utilities that improve the Team Foundation Server user experience.

The latest power tools release can be found here: TFS July 2008 Power Tools. 

See BHarry’s blog for an overview of all the great enhancements and make sure you download and install it.

The following tools are installed with the tfpt.msi package:

• Command line tool (TFPT.EXE)
• Team Explorer IDE menu additions
• Build Notification tool
• TFS Best Practices Analyzer
• Process Template Editor
• Work Item Templates
• Custom check-in policies
• TFS Server Manager
• TFS Users tool
• Alert Editor

Also available is the WssExt64Bit installer which provides the ability to install the Team Foundation Server WSS extensions into a 64-bit WSS instance. The RTM version of the WssExt installer that ships with Team Foundation Server 2008 does not support 64-bit WSS sites.

For more information, see Visual Studio Team System 2008 Team Foundation Server Power Tools.

Share this post :

LINQPad – Cool Utility For LINQ

Maybe you know about this, but I saw it first few days a go. I feel in love.

LINQPad is a cool little utility that was mainly created to allow you to test LINQ expressions and see them produce a  result and output the results in a nice easy to visualize format. It's great for running LINQ Queries without having to fire up Visual Studio.

LINQPad is also a great way to learn LINQ: it comes preloaded with 200 examples from the book,"C# 3.0 in a Nutshell" written by Joseph Albahari, the author of LINQPad.  There's no better way to experience the coolness of LINQ and functional programming.

LINQPad is more than just a LINQ query tool: it's a code snippet IDE. Instantly execute any C# 3 or VB 9 expression or statement block! LINQPad does a great job at LINQ execution and visualization, but it has a lot more uses than just a LINQ query tool. It's basically a snippet editor that allows you to save snippets and more importantly, execute just about any code that you can write as an expression or single function block.

For example, LINQ to SQL results:

Output can be displayed both as a result table view, the raw SQL (from .ToString()) and a useful code conversion from the LINQ Expression syntax to LINQ command syntax using command chaining of the various LINQ extensions methods.

Other example (from the preloaded examples):

There's no installation - it's a single self contained EXE you can copy anywhere assuming you have .NET 3.5 installed.

Download it here.

 

Share this post :

Configure Team Foundation Build for an Incremental Build

A question I got today: "How can I configure my Team Build for an incremental build?".

So, it's simple.

Team Build 2005

Add the PropertyGroup definition to the end of the TFSBuild.proj file, before the closing </project> tag.

Set the following properties:

   <PropertyGroup>
      <SkipClean>true</SkipClean>
      <SkipInitializeWorkspace>true</SkipInitializeWorkspace>
      <ForceGet>false</ForceGet>
   </PropertyGroup>

 

Team Build 2008

Set IncrementalBuild property to true. To do it, add the PropertyGroup definition to the end of the TFSBuild.proj file, before the closing </project> tag.

   <PropertyGroup>
      <IncrementalBuild>true</IncrementalBuild>
   </PropertyGroup>

 

Source - msdn:

Team Build 2005: http://msdn.microsoft.com/en-us/library/aa833876(VS.80).aspx

Team Build 2008: http://msdn.microsoft.com/en-us/library/aa833876.aspx

Templex-Sharing Team System Process Templates

We always asked for a library of process templates available and also easy way to share ones we created.

Templex is a new CodePlex project has just been created for this purpose. 

From the project’s page:

This CodePlex projects serves as a repository for open source Team Foundation Server (TFS) process templates, work item type definitions and report definitions. TFS uses process templates to configure new team projects. Each process template includes the following:

• TFS Security groups and permissions
• Initial set of Areas and Iterations
• Work item type definitions
• Initial set of work items
• Work item querys
• MS Project Mappings
• Version control permissions and settings for check-out and check-in
• Project portal document library settings, including an initial set of documents
• SQL Reporting Services report definitions

Once a team project is created, the following configuration items can be imported, exported and modified:

• Work item type definitions
• Work item queries
• Report definitions

 

 

http://www.codeplex.com/templex

VSTS 2008 Database Edition GDR June CTP

Yesterday, at TechEd 2008 Developer, Data Dude team announced the immediate availability of the first public CTP of the Visual Studio Team System 2008 Database Edition GDR (General Distribution Release).

 

The GDR is available now for download but before you install it, make sure read the installation requirements. If you have DBPro Power Tools installed, uninstall it first. AND you'll need to have Visual Studio 2008 Service Pack 1 Beta installed

 

 

From Gert's post:

What is in the GDR?

In addition to enabling SQL Server 2008 database projects, the GDR release incorporates many of the previously released Power Tools functionality as well as several new features. The new features include explicit separation of Build and Deploy, separation of Database and Server project, improved project reference support, T-SQL Static Code Analysis and integration with SQL-CLR projects.

Architectural changes

• No more DesignDB; one of the most important architectural changes is that the Database Edition no longer requires a local SQL Server instance to host the "Design Database" to open and validate a database project.
• Single model, everything is now loaded in a single model representation. The model now represents all object types, which removes the need to have certain objects represented as Pre or Post Deployment scripts. This means that for example logins, rules, defaults, asymmetric keys, symmetric keys, certificates, etc. are now schema objects and therefore fully participate in schema comparison and build/deploy. Pre or Post Deployment scripts still exist, but are only used to perform none schema object related operations.
• The model is no longer 100% memory resident, in today's version all model information has to reside in memory, this change dramatically lowers the memory consumption of the product.
• Provider based, the underlying implementation of the project system and schema model are changed to be provider based. Providers are refer to as "Database Schema Providers" or DSP's for short. The GDR release will ship with 3 providers supporting SQL Server: 2000, 2005 and 2008. However if you watch the Tech*Ed keynote this morning, you saw that IBM is working on a provider to support DB2 and there are others that are working on providers for other database management systems.
  • Providers are not restricted to relational database systems, in the future we will be adding providers that support dimensional and hierarchal data stores.

Project System

• Database & Server project separation
  • We separated out the existing database project in to two project flavors: database and server. The server project represent those schema objects that are server wide, for example logins, linked servers, server side DDL triggers etc. Database projects represent the objects inside the user database. The split enables a team to define a standard a configuration for their SQL servers and reference it from their Database Projects. The goals is to have a single point of definition and to be able to share this definition between projects and deployments.
    • The separation is implemented using a property inside the project file. There are effectively 3 modes: server, database and hybrid. The hybrid project represents the overloaded project model as it exists today where server and database objects are mixed inside a single project. This model is there to support existing project upgrades.
• Partial projects
  • Allow code sharing between projects by including files from a different project, where the code is included "as-is" from the originating project and the source code control ownership remains with the originating project. This enables code reuse between projects and while resulting in a single deployment unit.
• Composite projects
  • Composite projects, enables database projects and/or .dbschema files to contribute to another project. This enables the separation of development roles and responsibilities and composition of Databases using multiple projects. It extends the existing database reference implementation, by allowing to contribute in to the same database, where the existing database projects have to represent 3 or 4 part name references.
• Single sourcing of external artifacts
  • You can now create a reference to a SQL-CLR (VB.NET or C#) project, or the binary output of a project and turn it in to a ASSEMBLY inside the project. This enables single sourcing of artifacts that are developed outside the context of the database project. For the final release we will also allow references to XSD files which will become XML Schema Collections inside the database schema.

SQL Server 2008 Support

• The GDR adds a new project for supporting SQL Server 2008. The June CTP has support of the new SQL Server 2008 data types, both intrinsic (date, datetime2, datetimeoffset, time), build-in SQL-CLR types (geography, geometry, hierarchyid), support for the new DML MERGE syntax and support for table typed parameters. The remaining SQL Server 2008 syntax and functionality will be added in future CTP's.

Build & Deploy

• One of the other main changes in the GDR is the separation of the build and deployment process. Build now produces a single portable artifact file, a .DBSCHEMA file. The DBSCHEMA file is an XML representation of your complete schema. The DBSCHEMA is then fed in to the redistributable deployment engine.
• The deployment engine now uses the exact same database model as Schema Compare, which guarantees the same results between the two parts of the system.

Refactoring

• The biggest change in refactoring is the addition of a patented implementation of a feature named "Preservation of Intent". This enables the deployment of refactoring changes as intended by the user. For users this means that renames are deployed as renames not as drop/add statements, move aschemas as move schemas etc.
• Besides that we are adding new refactoring types that we previously in the Power Tools:
  • Wildcard Expansion
  • Move Schema
  • Fully Qualify
• And we are enabling extensibility for refactoring which enables users to develop and deploy custom refactoring types and targets.
  • Types are the refactoring operations, where targets are the artifacts you want to apply the refactoring operation to. An example of a refactoring type is: table split or upper case all keywords. An example of a refactoring target is an Reporting Services RDL file, which contains references to database schema objects, which if you change thos, you want to update them as part of the refactoring operation.

Schema Compare

• Schema Compare now uses the same underlying database model as build and deploy, guaranteeing fidelity between the results. This allows the user to compare any combination of Database Projects (.dbprj), live Databases or .DBSCHEMA files.  So comparing project to project, project with a DBSCHEMA file, or a DBSCHEMA file with a live database.
• We added the ability to limited the schema comparison based on object types (Object Type Filtering) and we added additional Ignore filtering options.
• We also enabled the substitution of SQLCMD variables, allowing correct comparison when using SQLCMD variables for references or in other parts of your code.

T-SQL Static Code Analysis

• T-SQL Static Code Analysis, and the accompanying MSBuild task, are now part of the main product.
• And we added the ability to develop and deploy your own custom T-SQL Static Code Analysis rules.

Dependency Viewer

• The Power Tools to view the dependency relationship between objects inside your schema, is now part of the base product.

Database Unit Testing

• Database unit testing now supports execution of tests using different ADO.NET providers and it also enables unit testing when using multiple database projects.

• Data Generation

• We made some general design-time enhancements Data Generation like adding support for undo/redo and separation of the population status into new display window.
• The Foreign key generator can now be replaced by custom generator.
• And we made some runtime enhancements, by default the Data Generator now uses the SqlBulkCopy interface to populate target tables, which results in a general performance improvement during data load time.
• We also introduced the concept of Data Sinks which allow the user to register different outputs, for example we can generate data to files instead of to a live database, so data can be loaded out-of-band using BCP or BULK INSERT. 
• And last but not least we were able to significantly trim the size of the .DGEN file. 

Public extensibility:

• The last piece we changed in the GDR is to expose more extensibility points in to the system. In the GDR we are not allowing new providers to be plugged in this will be available in the next release, but we do allow users to extend the system by writing their own:
  • Data Generators
  • (Statistical) Data Distributions
  • Test Conditions
  • T-SQL Static Code Analysis Rules
  • Refactoring Types
  • Refactoring Target
• We also made the deployment engine a redistributable component, so you can deploy DBSCHEMA files programmatically.

Microsoft Source Analysis for C#

Microsoft announce the public release of a new developer tool -  Source Analysis for C#.

Inside Microsoft this tool's name is StyleCop and it enforces code style guidelines on the code we write

Source Analysis comes with a set of default rules analyzers covering approximately 200 best practice rules. These rules are full compatible with the default layout settings in Visual Studio 2005 and Visual Studio 2008.

Specifically, these rules cover the following, in no particular order:

• Layout of elements, statements, expressions, and query clauses
• Placement of curly brackets, parenthesis, square brackets, etc
• Spacing around keywords and operator symbols
• Line spacing
• Placement of method parameters within method declarations or method calls
• Standard ordering of elements within a class
• Formatting of documentation within element headers and file headers
• Naming of elements, fields and variables
• Use of the built-in types
• Use of access modifiers
• Allowed contents of files
• Debugging text

After installation, Source Analysis can be run from within the Visual Studio IDE. You can set this up to be run as a part of your build process as documented here. Since this is plugged in as a MsBuild project you can use it in as a part of Team Foundation Build process as well.

 

Running Source Analysis:

And the results are:

 

Download it from: http://code.msdn.microsoft.com/sourceanalysis

Read full details:http://blogs.msdn.com/sourceanalysis/archive/2008/05/23/announcing-the-release-of-microsoft-source-analysis.aspx

Search File System Using LINQ

Do you want to search a file or file type in the file system ? Nice way to do it is using LINQ.

var files = from file in new DirectoryInfo(@"D:\temp").GetFiles()
            where file.Name == "MyFile.txt"
            select file;

Or even search after specific file extension :

var files = from file in new DirectoryInfo(@"D:\temp").GetFiles()
            where file.Extension == ".txt"
            select file; 

Enjoy,

Maor

Rosario Preview #4: Tester Edition

Visual Studio Team System Code Name "Rosario" Test Edition provides new functionality that lets you easily create, manage, edit and run manual tests. Read about manual tests here.

The new Tester Edition is great that address the needs of the UI testers.  This post is a preview of the main features in this edition.

(Click on images to enlarge)

 

Planning a Testing Effort

Camano is a standalone application that allows users the ability to author, plan and manage a testing effort from a simple UI specialized for displaying test artifacts.  Planning a testing effort gives you the ability to manage your manual testing efforts and report on your progress. By using this functionality, you can create test plans that show what you plan to test for a specified period of time. Also, you can create test configurations that specify the test environments for your tests.

 

 

Camano's main window

 

Test Case Planning

 

Test Suite

The manual test cases you create are associated with a specific team project. You can add test steps, validation steps, and parameterized data to the manual test case.

You organize the manual tests into test suites, and then you create a test plan to define which test suites will be run on specific test configurations. You can select the tests you want to run from the test plan.

 

Executing Manual Test Cases

When you run a manual test, you can optionally make a video recording of the test case. You can add comments, screenshots, and other files as you run the test. If the test fails, you can create a bug. This bug is automatically populated with any of the following information associated with this specific run of the test case:

• Test steps

• Validation data

• System information

• Video recording

• Screenshots

• Log files

• Action log

 

Because this functionality is integrated with the other parts of the Visual Studio Team System, you can publish the results to your Team Foundation Server.

 

 

Automate a manual test & add validation

Suppose we asked to convert the test into a coded UI test that can run in un-attended mode, we can generate the code from the background recording & then adds validation code using Visual Studio:

 

Create new UI Element

 

Adding validation code

 

Related posts:

• Download the VPC.
• Preview #1 - Source Control Features.
• Preview #2 - Team Build
• Preview #3 - Development Edition

Team Foundation Server 2008 SP1 Preview

Brian Harry just posted about the many new impressive features and changes coming out in TFS 2008 service pack 1. It is quite a comprehensive blog post and well worth the time to read through it. Check it out at "Team Foundation Server 2008 SP1 Preview".

 

List of features:

Version Control

• Add to Source Control
• Drag & Drop
• Version control of unbound files
• Simpler working folder mappings
• Checkin date/time column
• Local Path is now a link
• Editable source location
• Download files to a stream

Work Item Tracking

• Ribbon support for Office 2007
• Easily email work items

TFS Build

• Easily locate TFSBuild.proj file
• Conditionalize builds on the trigger
• Detect test result
• Dynamically created properties
• Reduce build log noise
• Query build definitions across Team Projects

Visual SourceSafe migration tool (vssconverter.exe)

• Elimination of namespace conflicts
• Automatic solution rebinding
• Correction of timestamp issues
• Improved logging

Other areas

• SQL 2008 support
• Team System Web Access links
• # of projects per sever
• Create Team Projects with a script

Performance & Scale

• Improved syncing identities from Active Directory
• Improved checkin concurrency
• tf branch /checkin
• Online index rebuilding
• Team build support for very large checkins
• Faster security manager
• tf get /remap

 

You can't download any prerelease version of the Service Pack yet, but it shouldn't be too long now.

Error when Creating Database Projects

Recently I got a question about permissions error that  occurred when trying to create database project in the local instance of Microsoft SQL Server used for design-time validation. The error was: "CREATE DATABASE permission denied in database 'master'".

Workaround

To create database you must be a member of the dbcreator and securityadmin fixed server roles in the server instance that you specified for design-time validation.

First, ensure that the instance name that is specified for your design-time validation database is correct.

Second, a user with sysadmin permissions should run the following script on your design-time validation database:

USE master
GO
GRANT EXECUTE ON sp_detach_db TO public
GO

For more information read Required Permissions in Database Edition.

How To Deploy Data Dude Project Changes using Team Foundation Build

When you want to build and deploy database projects with team build you need to edit the database project file and the Team Build file. That's because database projects store any non-default values for the TargetDatabase, TargetConnectionString, and DefaultDataPath properties in a <ProjectName>.dbproj.user file.  *.user files are not checked into version control in order to let every user use different values.

 

Step 1 - Modify build project file (team build .proj file)

Open the BuildDefinition.proj file, and at the bottom of the file, between the </ItemGroup> element and the </Project> element, add the following:

<Target Name="AfterDropBuild">
  <MSBuild Projects="$(SolutionRoot)\SolutionName\ProjectName\ProjectName.dbproj" 
      Properties="Configuration=Default;OutDir=$(SolutionRoot)\..\binaries\Default\" Targets="Deploy" />
</Target>

 

Step 2 - modify the database project file

The target connection and database are stored in the ProjectName.dbproj.user file, which is user specific and not typically checked in to version control. You require those settings to deploy your database. Therefore, you must modify the ProjectName.dbproj file manually to specify the target connection and database.

Copy the lines that contain the definitions for the TargetDatabase and TargetConnectionString properties from the section in the ProjectName.dbproj.user file for the configuration that you want to build. These lines will resemble the following:

<TargetDatabase>MyTargetDatabaseName</TargetDatabase>
<TargetConnectionString>Data Source=ServerName\InstanceName;Integrated Security=True;Pooling=False</TargetConnectionString>

If TargetDatabase and TargetConnectionString already contain empty elements, you should overwrite those entries.

 

More into at the msdn page.

New Rosario Specifications

In addition to my previous post about influencing on TFS future, the TFS team has just uploaded two of the new Rosario Specifications:

• Organize team queries and my queries using a folder hierarchy and
• Team Foundation Server Bug Submission Portal.

 

To post feedback or ask questions about these Forums please use the forum located at: Discuss and Provide Feedback Here

1. Resolve Improvements
2. Core Linking Work Item Tracking
3. Send Mail from TFS
4. Add to Source Control
5. Enterprise Team Foundation Server Management
6. History Improvements
7. Improved Label Dialog
8. Organize team queries and my queries using a folder hierarchy
9. Team Foundation Server Bug Submission Portal

BDW, You can taste Rosario here!

Visual Studio 2008 Product Comparison Guide, v1.08 + Updates

A new version of the Visual Studio 2008 Product Comparison Guide is now available. Version 1.08 includes updates to a number or line items, but in particular it includes a lot of fixes in the debugging section and adds a section on 64-bit development features.

March 2008 TFS Power Tools now available

Brian Harry has just announced that the March 2008 Team Foundation Power Tools have been released:

We've just released a new version of the TFS Power Tools.  This new Power Tool release will work only with the VS/Team Explorer 2008 client (but against either a TFS 2005 or TFS 2008 server).  If you haven't taken the time to upgrade yet, I highly recommend it - you are missing out on lots of great new value we are delivering.

This release includes:

• Process Template Editor support for custom work item controls
• TFSServerManager client
• TFS BPA support for Windows Server 2008
• Work Item Template improvements Scriptable Team Project creation
• Support for 64-bit Sharepoint farms
• Unshelve to a different branch
• Improvements to tfpt review
• Delete global lists in the work item tracking system
• Update bound Microsoft Office docs when the TFS server name changes
• Performance improvements in tfpt online

Click here to download.

Enjoy!

Rosario Preview #3 - Developer Edition

The 3rd preview of Rosario's April 2008 CTP will focus on the Development Edition. This edition has some great features, my favorites are: Historical Debugger, Standalone Debugger and Rule Sets for Code Analysis.

(Click on image to enlarge it)

Historical Debugger

Visual Studio Historical Debugger captures and records what the application does while it is running. When an error occurs, you can quickly find the root cause by investigating the information that was recorded by the Historical Debugger. At any time during debugging, you can go backward and forward in time to determine where an error occurred.

Historical Debugger increases debugging productivity by reducing the time it takes to reproduce and diagnose an error in your code.

 

Code Analysis with Rule Sets

We are presented with a list of built-in rule sets when we configure Code Analysis. We can either use the minimum recommended rules, or we can select alternative rule sets that relate to our project type. In either case, the rule sets can also be customized to fit your project requirements
For example, you can select a rule set that is suited for scanning code for a publicly available API.

 

Available Rule Sets

Rule Set	Description
All Rules	This rule set has all rules enabled.
General API Design Guidelines	This rule set contains rules that apply to any API, especially if the API is intended for external use. These rules closely follow the design guidelines for the .NET Framework. Use this rule set if you are building a programming interface such as a class library, Web service, WCF service or workflow library.
General Web Development Guidelines	This rule set contains rules that apply to Web development. This includes Web applications, server controls, AJAX and Web services. This rule set enables additional security and performance rules that help ensure that your Web site is reliable.
General Windows Application Guidelines	This rule set contains rules that apply to Windows application programming. Use this rule set to help you assess the quality of your Windows application. This rule set applies to Windows Forms applications, console applications, WCF applications, WPF applications and workflow applications.
Legacy Code Cleanup	This rule set contains rules that can help clean up legacy code. The rules that are violated can be fixed without having to change the public interfaces of your code. Therefore, they are ideally suited to cleaning up a legacy code base. These rules apply across all project types for which analysis is enabled.
Minimum Recommended Rules	This rule set has the minimum set of rules enabled. If you encounter warnings when a scan with this rule set is enabled, it is likely that there is an error in your code.
Release Criteria	This rule set contains rules that should be applied to an application that is undergoing final checks before release.

 

Debugging with the Standalone Debugger

Visual Studio Stand-Alone Debugger is a lightweight, stand-alone debugger that allows you to quickly diagnose problems in development, test, and production environments.

Visual Studio Stand-Alone Debugger (VSSD) does not require setup or configuration, which makes it ideal for situations where it is important to have minimal impact on the environment. In addition, deploying Visual Studio Stand-Alone Debugger is as simple as copying a few files. We can carry Visual Studio Stand-Alone Debugger on a USB thumb drive for “Just-In-Time” troubleshooting....

Creating the Standalone Debugger

 

Wizard ...

 

 

This is the wizard's product - folder which contains the debugger...

 

And the debugger!!

 

Once the Standalone Debugger is running, we can click the “Attach: Process” link on the start page to start debugging.

Additionally, the VSSD does not touch the system's registry. The VSSD uses most of the features that are available in the Visual Studio Debugger.

Summary

The development edition  has several new features, most of them in the area of the debugging and testing. I'm sure that the productivity of the developers and the quality of code will increased.

 

Enjoy!!

 

Posts about Rosario:

• Download Rosario CTP 12 VPC
• April 2008 CTP page
• Rosario's tag

Rosario Preview #2 - Team Build

This is the second post in a series about April CTP of Rosario's.

Team Build System Based on Windows WorkFlow Foundation

The new Team Build system in Rosario built on Windows Workflow Foundation, featuring dynamic build machine allocation from a machine pool and distributed build functionality.

 

New Term - “Build Controller”

In Rosario, Team Build uses an agent/controller architecture where the controller is responsible for managing a pool of agents. Notice the notion of “Tags” which let you define metadata for a build controller/agent. Then you can target your builds at agents/controllers that have a specified tag.

Controller that hosts a build execution is the pool of build machines where the build will run. Additionally, the workflow that comprises your build process will run on both the controller and the agent with coordination activities occurring on the controller.

No doubt, Rosario's Team Build introduce interesting issues especially the support in WF - it seems that most of the problems in the area of custom task(s) can be handled by this issue. I'll check it out and post about it later.

Enjoy!!

Posts about Rosario:

• Download Rosario CTP 12 VPC
• Rosario's page
• Rosario's tag

Team System Web Access 2008 SP1 and Work Item Web Access 2008 CTP's Available

Community Technology Previews (CTP) for Team System Web Access 2008 SP1 and Work Item Web Access has just released by Hakan Eskici and TFS team.

Team System Web Access (TSWA) 2008 SP1 (CTP)

• What's new in TSWA 2008 SP1
• Download the CTP for TSWA 2008 SP1

Work Item Web Access (WIWA) 2008 (CTP)

• What's WIWA?
• Download the CTP for WIWA 2008

Rosario Preview #1 - Exciting Enhancements Of The Version Control

This is the first post in a series I'm writing about Rosario's tidings.

The first taster will be about the new enhancements in the Source Control area.

So, what's new there?

• Editable source location field

 

this enables us to navigate to other place in the tree easier, also copy this location.

• Last checkin column

we don't need to open the history in order to know when the file was checked-in.

• Hyperlinks to local working folders

great feature - click on this link opens the local mapped folder .

• Simplified workspace mappings

  • Now you can  cloak folders from the mappings
  • Mapping a folder from the source control itself without opening the workspace manager.

Map to local folder:

Cloak folder:

 

• A new Add Files to Source Control wizard and support for drag and drop from Windows Explorer to Source Control Explorer

We can add files from the tree and a wizard is opened. The wizard helps us to map a folder if it's not mapped and even exclude items.

 

• Enhanced, non-modal conflict resolution experience, integrated into the pending changes tool window

• New history view that shows labels applied to a file