Paulo Morgado : VisualStudio

Compiling .NET 1.1 Projects In Visual Studio 2008

Paulo Morgado — Sun, 25 Oct 2009 23:09:44 GMT

After having put my .NET 1.1 application running on the .NET 2.0 runtime (^), I’m planning on migrating it to .NET 2.0, but not all at once.

Because I don’t want to have 2 solutions (one on Visual Studio 2003 for the .NET 1.1 assemblies and another on Visual Studio 2008 for the .NET 2.0 assemblies) I decide to try using MSBee and have only one Visual Studio 2008 solution.

MSBee has a CodePlex project. You can download it from there or from Microsoft Downloads. Because the build on Microsoft Downloads seemed to be the most stable one, that was the one I downloaded and installed. The package comes with a Word document that explains all that needs to be done.

Before you can install and use MSBee you’ll need to install the .NET 1.1 SDK.

Having everything installed, I just opened the Visual Studio 2003 solution in Visual Studio 2008 and let it convert the solution and projects (near 30).

After the conversion, for building the projects with the .NET 1.1 C# compiler, the project files need to be edited to add the override the default targets with the MSBee ones by adding the MSBee imports after the default imports for the language:

<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<Import Project="$(MSBuildExtensionsPath)\MSBee\MSBuildExtras.FX1_1.CSharp.targets" />

Another change needed (for Visual Studio 2008 - I don't know if it was needed for Visual Studio 2005) is the tools version. MSBee needs version 2.0. To change that you'll have to change the ToolsVersion attribute of the project’s root element:

<Project DefaultTargets="Build" ToolsVersion="2.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

MSBee likes has own idea about output paths and I had set up custom output paths on my project. There’s information about this on the documentation but I decided to simply comment that out of the $(MSBuildExtensionsPath)\MSBee\MSBuildExtras.FX1_1.Common.targets file:

<!-- Paulo
<Choose>
  <When Condition=" '$(BaseFX1_1OutputPath)' == '' ">
    <PropertyGroup>
      <OutputPath>bin\FX1_1\</OutputPath>
    </PropertyGroup>
  </When>
  <Otherwise>
    <PropertyGroup>
      <OutputPath>$(BaseFX1_1OutputPath)</OutputPath>
      <OutputPath Condition=" !HasTrailingSlash('$(OutputPath)') ">$(OutputPath)\</OutputPath>
    </PropertyGroup>
  </Otherwise>
</Choose>
-->

<!-- Paulo
<PropertyGroup>
  <BaseIntermediateOutputPath>obj\FX1_1\</BaseIntermediateOutputPath>
  <IntermediateOutputPath Condition=" '$(PlatformName)' == 'AnyCPU' ">$(BaseIntermediateOutputPath)$(Configuration)\</IntermediateOutputPath>
  <IntermediateOutputPath Condition=" '$(PlatformName)' != 'AnyCPU' ">$(BaseIntermediateOutputPath)$(PlatformName)\$(Configuration)\</IntermediateOutputPath>

  <OutputPath Condition=" '$(PlatformName)' == 'AnyCPU' ">$(OutputPath)$(Configuration)\</OutputPath>
  <OutputPath Condition=" '$(PlatformName)' != 'AnyCPU' ">$(OutputPath)$(PlatformName)\$(Configuration)\</OutputPath>
  
  <- Once OutputPath is determined, set OutDir to its value. ->
  <OutDir>$(OutputPath)</OutDir>
</PropertyGroup>
-->

This all seemed to work fine on my old Windows XP machine without any third party Visual Studio plug-ins, but when I tried it on my Windows Vista X64 machine, I came across some problems:

License Compiler

Because I'm using Infragistics' controls, there's a licences.licx file and the build will compile it. And that proved to be a problem.

MSBee copies all the files it needs to the build process to a temporary folder, builds it in there and then copies the result to the output path.

LC.exe seemed to never be able to find all the assemblies it needed. Searching seemed to me to be an old issue (even from the .NET 1.1 times) and the solution always pointed to not compile the license file. So, I commented that part out of the $(MSBuildExtensionsPath)\MSBee\MSBuildExtras.FX1_1.Common.targets file:

<Target
    Name="CompileLicxFiles"  Condition="'@(_LicxFile)'!=''"
    DependsOnTargets="$(CompileLicxFilesDependsOn)"
    Inputs="$(MSBuildAllProjects);@(_LicxFile);@(ReferencePath);@(ReferenceDependencyPaths)"
    Outputs="$(IntermediateOutputPath)$(TargetFileName).licenses">

  <!--
  <LC
      Sources="@(_LicxFile)"
      LicenseTarget="$(TargetFileName)"
      OutputDirectory="$(IntermediateOutputPath)"
      OutputLicense="$(IntermediateOutputPath)$(TargetFileName).licenses"
      ReferencedAssemblies="@(ReferencePath);@(ReferenceDependencyPaths)"
      ToolPath="$(TargetFrameworkSDKDirectory)bin\">

    <Output TaskParameter="OutputLicense" ItemName="CompiledLicenseFile"/>
    <Output TaskParameter="OutputLicense" ItemName="FileWrites"/>

  </LC>
  -->
</Target>

Resource Generator

Although this worked fine on the command line, inside Visual Studio ResGen.exe would throw some error and needed to be closed.

Looking at the Windows Application Log I found out this:

Faulting application Resgen.exe, version 1.1.4322.573, time stamp 0x3e559b5f, faulting module MockWeaver.dll, version 0.0.0.0, time stamp 0x4adb072e, exception code 0xc0000005, fault offset 0x00018fac, process id 0x4a50, application start time 0x01ca53c14488a2fb.

MockWeaver.dll belongs to Isolator and I just disable it when building inside Visual Studio. I was hoping to start using Isolator on this project, but, for now, I can't.

I hope this can be of some help and, if you need more, you’ll probably find it at the MSBee’s CodePlex forum.

The bottom line is: You don’t need Visual Studio 2003!

Help Typemock Launch Its New Visual Basic .NET Friendly API And You Might Get A Free License

Paulo Morgado — Tue, 13 Jan 2009 21:32:00 GMT

Typemock is announcing today a new version of Typemock Isolator (5.2).

One of the coolest features in the new version is the inclusion of a new VB .NET unit testing API. This 'VB friendly' API was designed and written in VB.NET, for VB.NET developers. It uses the strengths of the VB.NET language to allow easy and intuitive use of the isolation API, for easier unit tests on any piece of .NET code.

If you are you a blogger, webmaster, or internet columnist, you can get your free personal license by helping Typemock launch their new 5.2 version for Isolator - the best tool to unit test VB.NET applications.

Although this version is targeted to unit test VB.NET applications, C# applications with unit tests built using Visual Studio 2005 can also benefit from this API.

How can you get the free license?

Post the text below on your blog (as is, with links) and tell them about it . If you are in the first 25 to mail them after posting, your license will be on its way!

If you have a VB.NET dedicated blog, you'll get a license automatically (even if more than 25 submit) during the first week of this announcement.

A few simple requirements:

You must own a website, blog space or internet column, older than 2 months, or get permission from the owner of such a site.
Your post must include the text below (including the links) between *Begin* and *End*.

*Begin*

Programming Visual Basic applications?

Typemock have released a new version of their unit testing tool, Typemock Isolator 5.2.
This version includes a new friendly VB.NET API which makes Isolator the best Isolation tool for unit testing A Visual Basic (VB) .NET application.

Isolator now allows unit testing in VB or C# for many ‘hard to test’ technologies such as SharePoint, ASP.NET MVC, partial support for Silverlight, WPF, LINQ, WF, Entity Framework, WCF unit testing and more.

Note that the first 25 bloggers who blog this text in their blog and tell us about it, will get a Free Full Isolator license (worth $139). If you post this in a VB.NET dedicated blog, you'll get a license automatically (even if more than 25 submit) during the first week of this announcement.

Go ahead, click the following link for more information on how to get your free license.

*End*

Once you post this in your site, just drop them a line at vb@typemock.com with your name and the post URL to get your free license.

Hurry up – this offer is limited to the first 25 general bloggers, or to VB.NET dedicated bloggers who will post this in the first week.

Disclaimer: This is an offer from Typemock as announced at http://blog.typemock.com/2009/01/get-free-isolator-licnese-for-helping.html. I’m just a fan.

Improving Debugging And Testing Through Assertions

Paulo Morgado — Wed, 03 Dec 2008 02:56:52 GMT

Reading through the The Typemock Insider blog, I came across this post from Gil Zilberfeld.

I myself tend to fall in Gil’s practice ("binary search" debugging), but I don’t think Kent Beck has the right solution.

Gil’s suggestion of using Isolator is tempting (I don’t miss an opportunity to use it), but still not my favorite one.

I prefer to use debug assertions. Debug assertions can be used when running a debug version of the application to pop-up assertion messages and when running unit tests to fail tests.

In order to use debug assertions in unit tests a “special” trace listener is needed to make the test fail when its Fail method is called.

public class UnitTestTraceListener : global::System.Diagnostics.DefaultTraceListener
{
     public UnitTestTraceListener() : base()
    {
        this.Name = "UnitTest";
        this.AssertUiEnabled = false;
    }

    public override void Fail(string message, string detailMessage)
    {
        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.Fail("Debug.Assert Failed: " + message + " " + detailMessage);
    }
}

Now, all you need to do is register it.

Registering the trace listener can either be done in code:

System.Diagnostics.Trace.Listeners.Remove("Default");
System.Diagnostics.Trace.Listeners.Add(new UnitTestTraceListener());

or configuration:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.diagnostics>
    <assert assertuienabled="false"/>
    <trace>
      <listeners>
        <clear/>
        <add name="UnitTest" type="UnitTestTraceListener"/>
      </listeners>
    </trace>
  </system.diagnostics>
</configuration>

And if I’m using Isolator I have the take in account the accesses made in the call to the Assert method. More fun to me.

The Future Of C#

Paulo Morgado — Wed, 03 Dec 2008 01:17:00 GMT

If you were able to attend this session at PDC or Tech-Ed EMEA Developers, you were presented with a first class presentation of the future of C#, presented, respectively, by Anders Hejlsberg and Mads Torgersen.

For the near future (.NET 4.0) C# will have:

Dynamically Typed Objects
Optional and Named Parameters
Improved COM Interoperability
Co- and Contra-variance

A preview of the compiler as a service was shown, but that’s not for the .NET 4.0 / Visual Studio 2010 timeframe. Probably, not even for the next.

Starting with .NET 4.0, C# and Visual Basic will converge in terms of features and follow a path of co-evolution going into the future.

No! That doesn’t mean that XML literals will be in C# in a foreseeable future. What that means is that the above list also applies to Visual Basic.

Talking of Visual Basic evolution, the _ line continuation character has been retired. If you have any use for the underscore, please visit http://www.unemployedunderscores.com/.

Resources:

C# Future
Microsoft Pre-release Software Visual Studio 2010 and .NET Framework 4.0 Community Technology Preview (CTP)
Charlie Calvert's Community Blog
PDC Session: TL16 - The Future of C#

Presenter: Anders Hejlsberg

PPTX | WMV-HQ | WMV | Zune | MP4
PDC Session: TL12 - Future Directions for Microsoft Visual Basic

Presenter(s): Paul Vick, Lucian Wischik

PPTX | WMV-HQ | WMV | Zune | MP4

PDC And Tech-Ed Wrap-Up

Paulo Morgado — Tue, 02 Dec 2008 00:15:57 GMT

(It might seem a bit late for this, but, lately, I’ve been having a lot on my mind. So here it goes.)

This was my first PDC. It was just as I had been told.

For those who don’t know, the PDC is all about the future. The near future (.NET 4.0 and Windows 7) and the further future (Windows Azure, “Oslo”, “Dublin”, “Geneva”).

Next year’s PDC (Yes! Apparently, there’ll be one next year) will be also held in Los Angeles from November 17 to 20, and (I suspect) will be the commercial launch of the Azure Services Platform and a better story to tell about “Oslo”.

Tech-ED EMEA Developers, on the other hand, is more about the present and the near future. But, this year, attendees were able to have a sneak peek at what had bee shown at the PDC.

Next year’s Tech-ED EMEA Developers will be held in Berlin from November 2 to 6. Probably, like in 2006, it will be the launch of .NET 4.0 and Visual Studio 2010.

And I intend to attend both.

MSDN Ramp Up Program

Paulo Morgado — Fri, 07 Nov 2008 00:53:35 GMT

I just came across this: www.MyRampUp

Ramp Up is a free, online, community-based program that can help users save time in learning Microsoft technology.

The easy-to-access content (provided by subject-matter gurus) is specifically tailored to the Ramp Up program, and offered in a variety of forms (whitepaper, v-lab, codecast and slidecast).

The currently available routes are:

Currently, there are no assessments in the program, so it's quicker than ever to graduate and receive the reward (25% off on certification and 50% off on e-Learning - only for graduates of Ramp Up).

Clone Detective For Visual Studio

Paulo Morgado — Thu, 28 Aug 2008 22:41:36 GMT

Clone Detective is a tool that integrates with Visual Studio and uses the ConQAT (Continuous Quality Assessment Toolkit) to analyze C# projects and search for duplicated source code.

Watch the videos and see if this is the tool you were looking for.

Typemock Isolator 5.0 Is Out With Its New AAA API

Paulo Morgado — Wed, 20 Aug 2008 21:33:30 GMT

Typemock has released version 5.0 of its unit testing tool: Isolator. Check out the release notes.

This new version comes with a new API: Arrange Act Assert:

I’ll have to say that I liked Isolator better over Isolate.

Also new in this version is the inclusion of the help file in the installation package.

.NET 3.5 SP1, VS2008 SP1 And TFS2008 SP1 Released

Paulo Morgado — Tue, 12 Aug 2008 00:20:32 GMT

Microsoft .NET Framework 3.5 Service Pack 1

Microsoft Visual Studio 2008 Service Pack 1 (iso)

Visual Studio 2008 Team Foundation Server Service Pack 1

Visual Studio 2008 Service Pack 1 Expected Next Week

Paulo Morgado — Fri, 08 Aug 2008 00:26:40 GMT

According to the MSDN Subscriptions home page, we should expect Visual Studio 2008 Service Pack 1 availability after August 11, 2008.

Using Random Values For Unit Testing

Paulo Morgado — Mon, 23 Jun 2008 23:40:17 GMT

When writing my unit tests I don’t like to use hard coded fixed values because I either end up using the same values or, because of that, tests may succeed by coincidence.

Over time, I have developed an helper class to generate random values for testing.

namespace PauloMorgado.VisualStudio.TestTools.UnitTesting
{
    public static class RandomGenerator
    {
        public static bool Boolean();
        public static string String();
        public static string String(string prefix);
        public static short Int8();
        public static short Int8(short maxValue);
        public static short Int8(short minValue, short maxValue);
        public static short Int16();
        public static short Int16(short maxValue);
        public static short Int16(short minValue, short maxValue);
        public static int Int32();
        public static int Int32(int maxValue);
        public static int Int32(int minValue, int maxValue);
        public static TEnum Enum<TEnum>();
        public static TEnum EnumFlagsWith<TEnum>(TEnum flagsToAdd);
        public static TEnum EnumFlagsWithout<TEnum>(TEnum flagsToRemove);
        public static TEnum Enum<TEnum>(int maxValue);
        public static TEnum Enum<TEnum>(int minValue, int maxValue);
        public static System.Guid Guid();
    }
}

This is something that I would like to find on mock frameworks (like Typemock Isolator, Rhino.Mocks or MoQ).

It’s still a work in progress, but if you want to try it, it’s on my MSDN Code Gallery: Random Generator For Unit Testing

Microsoft Source Analysis for C# (aka StyleCop)

Paulo Morgado — Wed, 04 Jun 2008 23:12:22 GMT

I’ve learned from a fellow GASPer of the release of Microsoft Source Analysis for C# (aka StyleCop).

It’s still a work in progress but it’s already very useful.

Typemock Isolator v4.2.4 Released

Paulo Morgado — Sun, 18 May 2008 23:37:52 GMT

Typemock released version 4.2.4 of its Isolator mock framework.

You can check out the release notes in The Typemock Insider blog and download it from the Typemock Isolator Download page.

Stretching Type Inference

Paulo Morgado — Tue, 22 Apr 2008 00:35:00 GMT

Note: Code in italics is not actual C# 3.0 syntax.

Local Variable Type Inference

C# 3.0 brought us local variable type inference mainly because of LINQ. The output of a query can vary from an IEnumerable<T> or an IQueryable<T> to a single instance of T where T can even be a projection which means that its type is an anonymous type.

Take the following query as an example:

from p in persons
select new { Name = p.FirstName + " " + p.LastName, Age = p.Age };

If persons is an IEnumerable<Person>, the output of the query will be an IEnumerable<T> where T is an anonymous type.

Now the question that arises is: How do I declare a variable to receive the output of the query?

The solution was the introduction of the new var keyword that instructs the compiler to determine the type of the output of the query. Now, all it takes to declare a variable to receive the output of the query is:

var q =
    from p in persons
    select new { Name = p.FirstName + " " + p.LastName, Age = p.Age };

Since the compiler can infer the type of something that looks so complex, it's obvious that it can infer the type of something so straightforward as:

var v = new Dictionary<Point, Stack<Person>>();

It's obvious that this is the same as:

Dictionary<Point, Stack<Person>> v = new Dictionary<Point, Stack<Person>>();

with less typing and margin for typing errors.

Field Type Inference

The same technique could be applied to field inference:

class Class
{
    private someDicionary = new Dictionary<string, List<string>>();

    // ...
}

with the same benefits of less typing and margin for typing errors.

If field type inference were to be applied to public fields, one constraint must be enforced though: the inferenced type cannot be or have as a type parameter an anonymous type.

But I wouldn't recommend that because it would be easy and not obvious that a small change in the field initialization could bring unobvious changes to the public interface of the class.

Method Output And Parameter Type Inference

Since type inference would be possible outside of methods, should it be allowed on method output and parameter values? Something like this:

class SomeClass
{
    private listOfStuff = new List<Stuff>();

    public void DoIt()
    {
        if (CreateList(out this.listOfStuff))
        {
            ProcessList(ref this.listOfStuff);

            this.listOfStuff = TransformList(this.listOfStuff);
        }
    }

    private bool CreateList(var out list)
    {
        list = new List<Stuff>();
        return true;
    }

    private void ProcessList(var ref list)
    {
        // ... 
    }

    private var TransformList(var list)
    {
        return list;
    }
}

which look very strange and confusing, to say the least. We shouldn't go there.

Constructor Inference

Every since I saw local variable type inference the first time, I have the feeling that more could have been done.

Let's look at this hypothetical set of declarations:

Dictionary<Point, Stack<Person>> v = new();
Point p = new(1, 2);

It's as easy to the compiler or a human reading the code that this is the same as:

Dictionary<Point, Stack<Person>> v = new Dictionary<Point, Stack<Person>>();
Point p = new Point(1, 2);

And this can be more powerful than local variable type inference and used in a lot more scenarios:

class Class
{
    private Dictionary<string, List<string>> someDicionary = new();
    private Point p;

    public Class()
    {
        this.p = new(1, 1);
    }

    public void SomeMethod()
    {
        AnotherMethod(new());
    }

    private void AnotherMethod(List<string> arg)
    {
        // ...
    }
}

Where To Stop?

The compiler could as easily infer the type of a local variable in this:

public void SomeMethod()
{
    var v = new();
    AnotherMethod(v);
}

Do we want to go there? I don't think so.

Ambiguities

C# 3.0 also brought object initializers. Instead of this:

XmlReaderSettings settings = new XmlReaderSettings();
settings.CheckCharacters = false;
settings.IgnoreWhitespace = true;

XmlReader reader = XmlReader.Create("someURI", settings);

we can just write this:

XmlReaderSettings settings = new XmlReaderSettings() { CheckCharacters = false, IgnoreWhitespace = true };

XmlReader reader = XmlReader.Create("someURI", settings);

or this:

XmlReader reader = XmlReader.Create("someURI",  new XmlReaderSettings() { CheckCharacters = false, IgnoreWhitespace = true });

Wouldn't it be nice to just write:

XmlReaderSettings settings = new() { CheckCharacters = false, IgnoreWhitespace = true };

C# 3.0 object initializers also allow constructor parenthesis to be omitted:

XmlReaderSettings settings = new XmlReaderSettings { CheckCharacters = false, IgnoreWhitespace = true };

which would lead to:

XmlReaderSettings settings = new { CheckCharacters = false, IgnoreWhitespace = true };

which looks exactly like an anonymous object creation expression and could lead to some confusion and ambiguities.

But it would be nice to just write:

XmlReader reader = XmlReader.Create("someURI", new { settings.CheckCharacters = false, settings.IgnoreWhitespace = true });

Wouldn't it?

Web Authoring Component install fails when installing Visual Studio 2008

Paulo Morgado — Sat, 22 Mar 2008 23:46:28 GMT

While trying to install Visual Studio 2008 Team Suite in my Windows XP Professional system it kept failing when installing Visual Studio because it couldn't find the Web Authoring Component (after installing having just successfully installed it).

I've looked around for occurrences of this problem but I didn't find anyone with such a problem.

I tried to install Visual Studio several times, successfully installing the Web Authoring Component (you can find it on the DVD - \WCU\WebDesignerCore\WebDesignerCore.EXE) before, but it always failed in the same step and for the same reason as before. And, even more strangely, after that, the Web Authoring Component was no longer installed.

I went through the install log file (%temp%\dd_depcheck_VS_VSTS_90.txt) and found this:

Microsoft Visual Studio Web Authoring Component ==  
    This component uses the FileRegVerCheck version check method. It will compare a given version against the version of a regkey on your machine.
    Registry key being interrogated: HKLM,SOFTWARE\Microsoft\Web Designer Tools\1033; Value: InstalledVersion; Version: 12.0.4518.1066.
    Version on user's machine:    12.0.4518.1064
    Version to be installed:    12.0.4518.1066
Microsoft Visual Studio Web Authoring Component == Component to be installed.

I went to the registry and changed the value of the installed version to the one expected by Visual Studio installer and it installed it with no problems. And looks like it's working fine.

What strikes me as the most strange is not the fact that the component on the DVD has the wrong version. What strikes me the most is the fact that I had already installed Visual Studio using the same DVD without any problems.

Good System	Bad System
Windows Vista Ultimate 64bit with SP1 (clean install)	Windows XP Professional with SP2
Office 2007 with SP1 (clean install)	Office 2007 with SP1 (upgraded from Office 2003)
	Visual Studio 2003
	Visual Studio 2005 with SP1
	Expression Web

The Web Authoring Component installer uses a Office 2007 wrapper. I wonder if that was the problem.

TypeMock Isolator 4.2 Released

Paulo Morgado — Mon, 03 Mar 2008 00:40:33 GMT

TypeMock has released version 4.2 of its mocking framework: TypeMock Insulator. Check out the release notes.

My four favorite new features in this release are:

Improved mock chaining
Debugger evaluation doesn't change the test behavior
The debugger can be run inside a recording block without confusing the test
When you step in the debugger into a mocked method, the mocked method will be painted

Improved mock chaining

(If you want to learn more about chains, read this post from Gil)

Take this class to be tested:

public class TestedClass1
{
    public IDictionary<string, object> Dictionary
    {
        get { throw new NotImplementedException(); }
    }

    public object Method(bool cond)
    {
        if (cond)
        {
            return Dictionary["true"];
        }
        else
        {
            return Dictionary["false"];
        }
    }
}

The following test:

[TestMethod]
[VerifyMocks]
public void TestMethod1()
{
    object trueObject = new object();
    object falseObject = new object();

    TestedClass1 target = RecorderManager.CreateMockedObject<TestedClass1>();

    using (RecordExpectations recorder = RecorderManager.StartRecording())
    {
        recorder.DefaultBehavior.CheckArguments();

        recorder.ExpectAndReturn(target.Dictionary["true"], trueObject);
        recorder.FailWhenCalled(target.Dictionary["false"]);
    }

    object value = target.Method(true);
    Assert.AreEqual(trueObject, value);
}

Would simply fail with:

Test method TestProject1.UnitTest1.TestMethod1 threw exception:  TypeMock.VerifyException: 
TypeMock Verification: Method TestProject1.TestedClass1.get_Dictionary() has 1 more expected calls
.

Now, it just passes.

Debugger evaluation doesn't change the test behavior

Now you can debug your code without having to change your tests. You can query mocked values without influencing your tests.

You can do this and still have the test passing:

The debugger can be run inside a recording block without confusing the test

You can now step into the recording block and debug it without affecting the recording process and the test.

When you step in the debugger into a mocked method, the mocked method will be painted

When you step into a mocked method (or property) I'll see that it's mocked.

Web Client Software Factory 2.0 shipped

Paulo Morgado — Fri, 29 Feb 2008 01:54:51 GMT

Web Client Software Factory 2.0

February 2008 Release

Resources

MSDN site: http://msdn.microsoft.com/webclientfactory
Community site: http://www.codeplex.com/websf

About the Deliverable

The Web Client Software Factory (WCSF) provides a set of guidance for architects and developers building enterprise Web applications. The factory includes samples, reusable code and a guidance package which automates key development tasks from within Visual Studio.

Using the Web Client Software Factory assets, developers can create Composite Web applications composed of independently developed and deployed modules. These modules are dynamically brought together at runtime into a common shell. Additionally the factory includes support for ASP.NET AJAX thus providing users with a richer and more responsive user experience.

New In This Release

The February 2008 release of the Web Client Software Factory has the following improvements to the June 2007 release.

Full support for Visual Studio 2008 and .NET Framework 3.5
Added ASP.NET AJAX extenders for Context Sensitive Autocomplete, AJAX Validation, and Real Time Search that can be used in existing ASP.NET sites and ASP.NET sites built using the Composite Web Application Block.
Added UI Composition capability through extending our dependency injection mechanism to support Pages, User Controls and Master Pages.
Added Dependency Injection on ASMX Web Services and JSON services.
Added a new set of Quickstarts and How-To topics on MVP, Modularity and the new AJAX extenders
Added a new Order Entry Reference application that demonstrates all of the new functionality.

In addition, this release of WCSF has the following community issues and fixes:

42 Workitems closed including the top-voted items on CodePlex
Add ASP.NET AJAX Support (97 votes)
Web Client Software Factory Support for Enterprise Library 3.1 (62 votes)
Services through configuration (32 votes)
Support for using the Validation Application Block (16 votes)
Recipe support for Visual Basic .NET (20 votes)
Added Presenter support for Master Pages (11 votes)

Techdays Portugal 2008 - For A World 2.0

Paulo Morgado — Wed, 06 Feb 2008 21:45:52 GMT

Microsoft Portugal will be hosting Techdays 2008 from Mars 12^nd to 14^th, right after the Portuguese launch of Microsoft Visual Studio 2008, Microsoft SQL Server 2008 and Microsoft Windows Server 2008 on Mars 11^th.

This is the biggest and greatest tech event in Portugal and there will be lots of national and international speakers and contests.

I'll be there. Come visit us.

Typemock Insulator Is Typemock Isolator

Paulo Morgado — Tue, 05 Feb 2008 00:07:00 GMT

Yesterday I made a mistake with the name of the next version of TypeMock. The real name is TypeMock Isolator. Whatever the name is, you should try it out.

TypeMock Insulator 4.2 Beta Publicly Available

Paulo Morgado — Sun, 03 Feb 2008 22:16:17 GMT

TypeMock (now called) Insulator 4.2 Beta is publicly available. Check out the release notes.

One of my favorite new features is the improved mock chaining.

Take this class to be tested:

public class TestedClass1
{
    public IDictionary<string, object> Dictionary
    {
        get { throw new NotImplementedException(); }
    }

    public object Method(bool cond)
    {
        if (cond)
        {
            return Dictionary["true"];
        }
        else
        {
            return Dictionary["false"];
        }
    }
}

The following test:

[TestMethod]
[VerifyMocks]
public void TestMethod1()
{
    object trueObject = new object();
    object falseObject = new object();

    TestedClass1 target = RecorderManager.CreateMockedObject<TestedClass1>();

    using (RecordExpectations recorder = RecorderManager.StartRecording())
    {
        recorder.DefaultBehavior.CheckArguments();

        recorder.ExpectAndReturn(target.Dictionary["true"], trueObject);
        recorder.FailWhenCalled(target.Dictionary["false"]);
    }

    object value = target.Method(true);
    Assert.AreEqual(trueObject, value);
}

Would simply fail with:

Test method TestProject1.UnitTest1.TestMethod1 threw exception:  TypeMock.VerifyException: 
TypeMock Verification: Method TestProject1.TestedClass1.get_Dictionary() has 1 more expected calls
.

Now, it just passes.

Visual Studio cues are nice too.