• Microsoft .NET Framework 3.0 Redistributable Package (SP2)
• The Visual Studio 2005 extensions for.NET Framework 3.0 (WCF & WPF), November 2006 CTP 3

The problem with the later is that Microsoft no longer supports it. Visual Studio 2008 is supposed to be used for developing such projects. The license for the CTP has expired on June 30th 2008. You can read more about that here. What that means is that you can no longer develop WCF applications in Visual Studio 2005 and should upgrade to Visual Studio 2008. However, as an exercise, I wanted to see if I could still install the WCF extensions in Visual Studio 2005 and have it work side by side with Visual Studio 2008.

First, I had to find the old CTP with the Visual Studio 2005 extensions. It can be downloaded from here. However, when I run it, I got the following error:

WCF Extensions for Visual Studio 2005 Setup Error

The curious thing was that .NET 3.0 was already installed on my machine. I soon realized I was having .NET 3.0 SP2, and the installer was looking for .NET 3.0. Of course, you cannot install 3.0 when a newer version (such as 3.0 SP2) is already installed. So the only option was to change the installer.

Orca is a database editor, allowing you to create and edit MSI files and merge modules. It is provided as a part of Windows Installer SDK. But you can also find stand alone downloads, such as this.

After installing Orca, you can open the MSI file. From Tools > Validate… one can run a validation on the installer. It shown the following errors:

ICE08 ERROR Component: WCFSvcConfigEditor_dll has a duplicate GUID: {714D044E-3136-457E-ADD7-AE3D0FEF021A}
ICE16 ERROR ProductName: ‘Visual Studio 2005 extensions for .NET Framework 3.0 (WCF & WPF), November 2006 CTP’ is greater than 63 characters in length. Current length: 83
ICE77 ERROR CA_CommitHelpTransactionNoRB.3643236F_FC70_11D3_A536_0090278A1BB8 is a in-script custom action. It must be sequenced in between the InstallInitialize action and the InstallFinalize action in the InstallExecuteSequence table

I had to do the following fixes:

• replace the first occurrence of this GUID {714D044E-3136-457E-ADD7-AE3D0FEF021A} with another one
• trim the name “Visual Studio 2005 extensions for .NET Framework 3.0 (WCF & WPF), November 2006 CTP” to “Visual Studio 2005 extensions for .NET Framework 3.0 SP2″
• change the Sequence number of the CA_CommitHelpTransactionNoRB.3643236F_FC70_11D3_A536_0090278A1BB8 action in he InstallExecuteSequence table from 6601 to 6599 so that it is in between InstallInitialize (1500) and InstallFinalize (6600)

But then, came the biggest problem: making the installer work with .NET 3.5 SP2. It was looking in registry for the following key: SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{15095BF3-A3D7-4DDF-B193-3A496881E003}. The GUID {15095BF3-A3D7-4DDF-B193-3A496881E003} corresponds to .NET 3.0. So in order to make it work with .NET 3.0 SP2 one needs to replace the GUID with {A3051CD0-2F64-3813-A88D-B8DCCDE8F8C7} for the SearchForWinFXruntimeX86Install signature in the RegLocator table.

Once those changes are made all you have to do is save. However, the “Copy embedded steams during ‘Save As’” option should be checked from Tools > Options > Database, before doing the saving. Otherwise the embedded CAB is not copied and the installation won’t work.

Running the modified installer works successfully.

Setup start page

Setup finished

If you start Visual Studio 2005 you can create a new project from one of the WCF project templates.

WCF Project Templates

You can download the altered MSI file from here: The Visual Studio 2005 extensions for.NET Framework 3.0 SP2 (WCF & WPF) (1688).

Note: I must say this again: this scenario is no longer supported. The license for this CTP for WCF extensions for Visual Studio 2005 has expired in 2008. You should upgrade to Visual Studio 2008 to develop WCF applications.

Here is an example for using static_assert. Suppose you want to create a template vector class, but you don’t want to allow vectors with a size smaller than 4. Then you can use a static assertion to enforce that.

template < class T, int Size >
class Vector
{
   static_assert(Size > 3, "Vector size is too small!");

   T m_values[Size];
};

int _tmain(int argc, _TCHAR* argv[])
{
   Vector< int, 4 > four;
   Vector< short, 2 > two;

   return 0;
}

Compiling this program triggers an error at the second declaration.

c:\projects\cpp_demo\cpp_demo.cpp(17) : error C2338: Vector size is too small!
  c:\projects\cpp_demo\cpp_demo.cpp(33) : see reference to class template instantiation 'Vector< T,Size >'
  being compiled
  with
  [
     T=short,
     Size=2
  ]

Most of the use cases for this feature, in my opinion, would be to test on the size of different types. For instance this sample is taken from the C++0x draft.

static_assert(sizeof(long) >= 8, "64-bit code generation required for this library.");

To me, static_assert looks like a niche feature. It would have been great if this could be used together with some other features to enfore compile time constraints on types. For instance, I want to restrict the possible types for a template class or function to only those that are derived from IListener (a fictive class).

template < class T >
class foo
{
   static_assert(convertible_from< IListener >(decltype(T)), "Type is not a correct type!");
};

Perhaps a future standard version will offer support for such things.

What is a lambda expression? It’s basically a function. In F# it’s an anonymous function, in C# it’s an anonymous delegate; in C++ it’s in fact an anonymous function object. Whenever you create a new lambda function, the compiler creates a function object for you.

int main()
{
   auto l_pow2 = [](int n) {return n*n;};

   std::cout << "5 pow 2 = " << l_pow2(5) << std::endl;
}

That is equivalent to:

struct LambdaFunctor
{
   int operator()(int n) const
   {
      return n * n;
   }
};

int main()
{
   LambdaFunctor l_pow2;
   std::cout << "5 pow 2 = " << l_pow2(5) << std::endl;
}

Of course, the lambda functor can be more complicated, when the lambda function captures state from the local scope. However, that is beyond the scope of my post. I recommend that you read more about lambdas in C++ on the VC++ blog.

Question is, what are these lambdas good for? Well, they mostly come in handly with algorithms that take predicates (function objects) as arguments. I'll try to give you some examples in this post.

Let's first consider a filter function, that takes a sequence (vector of T) and a predicate that indicates what values should be filtered, and returns a new sequence. That would look like this:

template < class T >
std::vector< T > Filter(const std::vector< T >& sequence,
                        std::tr1::function< bool (T) > predicate)
{
   std::vector< T > result;

   for(auto it = sequence.begin(); it != sequence.end(); ++it)
      if(predicate(*it))
         result.push_back(*it);

   return result;
}

We can use this filter function to extract the odds numbers from a sequence (vector).

#include < iostream >
#include < vector >
#include < algorithm >
#include < functional >

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
   std::vector< int > nums;
   for(int i = 0; i < 10; ++i)
      nums.push_back(i);

   // get the odds numbers
   std::vector< int > odds = Filter< int >(nums, [](int i) {return (i % 2) == 1;});

   // print the new sequence
   for_each(odds.begin(), odds.end(), [](int n){std::cout << n << std::endl;});

   return 0;
}

1
3
5
7
9

You could see in the above example that a second lambda function is used for printing the numbers to the console.

Since the Filter function is a template function it could be used with other types too. In the next example we'll see how to filter words that have at least 4 letters from a sequence of words.

#include < iostream >
#include < vector >
#include < algorithm >
#include < functional >
#include < string >

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
   std::vector< string > snums;
   snums.push_back("one");
   snums.push_back("two");
   snums.push_back("three");
   snums.push_back("four");
   snums.push_back("five");

   // filter the words, notice the new lambda
   std::vector< string > bigwords = Filter< string >(snums, [](string w) {return w.length() > 3;});

   // print the selected words
   for_each(bigwords.begin(), bigwords.end(), [](string s){std::cout << s << std::endl;});

   return 0;
}

three
four
five

Let's consider a second example, a Find (template) function, that takes a sequence and a predicate (that checks a condition for an element), and returns the first element in the sequence for which the predicate returned true.

template < class T >
T Find(const std::vector< T >& sequence,
       std::tr1::function< bool (T) > predicate)
{
   for(auto it = sequence.begin(); it != sequence.end(); ++it)
      if(predicate(*it))
         return *it;

   throw std::runtime_error("Item not found");
}

We'll use this function to find the first element in a sequence that is greater than a given value.

int _tmain(int argc, _TCHAR* argv[])
{
   std::vector< int > nums;
   nums.push_back(1);
   nums.push_back(3);
   nums.push_back(5);
   nums.push_back(7);
   nums.push_back(9);

   int min;
   cout << "find first after: ";
   cin >> min;

   try
   {
      int val = Find< int >(odds, [min](int i){return i > min;});
      cout << val << endl;
   }
   catch(std::runtime_error& ex)
   {
      cout << ex.what() << endl;
   }

   return 0;
}

If you input 4 for instance, it will return 5. If you input 10, an exception will be thrown. You can see that this time the lambda function is [min](int i){return i > min;}. This means that it captures by value the min variable from the local scope, so that it can compare each element with that given value.

The last example I'm going to show is an accumulator function (also known as aggregate or fold). This function takes a sequence of elements, a seed (or initial value) and a function that specifies how to aggregate the elements, and returns the aggregate.

template < class TSource, class TAccumulate >
TAccumulate Aggregate(const std::vector< TSource >& sequence,
                      TAccumulate seed,
                      std::tr1::function< TAccumulate (TSource, TAccumulate) > func)
{
   TAccumulate acc = seed;
   for(auto it = sequence.begin(); it != sequence.end(); ++it)
      acc = func(acc, *it);

   return acc;
}

First, we can use it to compute the sum of all elements in a sequence.

int _tmain(int argc, _TCHAR* argv[])
{
   std::vector< int > nums;
   for(int i = 1; i <= 10; ++i)
      nums.push_back(i);

   int sum = Aggregate< int, int >(nums, 0, [](int e, int acc) {return e + acc;});
   cout << "sum = " << sum << endl;

   int prod = Aggregate< int, int >(nums, 1, [](int e, int acc) {return e * acc;});
   cout << "prod = " << prod << endl;

   return 0;
}

sum = 55
prod = 3628800

The first lambda function above sums the current element with the previous sum, which initially is given as 0. The result is 55. The second lambda function multiplies the current element with the previous product, which initially is 1. The result is 3628800.

But the Aggregate function can be used with other types too. Here is a last example with strings.

int _tmain(int argc, _TCHAR* argv[])
{
   std::vector< string > words;
   words.push_back("the");
   words.push_back("quick");
   words.push_back("brown");
   words.push_back("fox");
   words.push_back("jumps");
   words.push_back("over");
   words.push_back("the");
   words.push_back("lazy");
   words.push_back("dog");

   string sentence = Aggregate< string, string >(
      words,
      "",
      [](string workingSentence, string next){return next + " " + workingSentence;});

   cout << sentence << endl;

   return 0;
}

dog lazy the over jumps fox brown quick the

These were several examples of how lambda functions help us write more generic, and less verbose code. I suggest you read more about lambdas in C++ here.

class Logger
{
   public void LogMessage(string error, bool addNewLine)
   {
      Console.Write(error);
      if (addNewLine) Console.WriteLine();
   }

   public void LogMessage(string error)
   {
      LogMessage(error, true);
   }
};

class Program
{
   static void Main(string[] args)
   {
      Logger log = new Logger();
      log.LogMessage("trying to connect...", false);
      // do more stuff here
      log.LogMessage("SUCCESS");
   }
}

trying to connect...SUCCESS
Press any key to continue . . .

C# 4.0, that will be released with Visual Studio 2010, and is for now available with the Visual Studio 2010 CTP, supports, just like C++, optional arguments. So instead of using overloaded functions, you can specify a default value for a parameter. When doing the call, if you don’t provide a value for the argument, the default one will be used.

The Logger class below is identical from the functionality point of view with the one above. (The previous Main() function doesn’t have to change.)

class Logger
{
   public void LogMessage(string error, bool addNewLine = true)
   {
      Console.Write(error);
      if (addNewLine) Console.WriteLine();
   }
};

The only restriction is that optional parameters have to appear in the function after all required parameters. In other words, this is not legal:

class foo
{
   public void func(int a, int b = 0, int c)
   {
   }
}

error CS1737: Optional parameters must appear after all required parameters

Considering this implementation of foo

class foo
{
   public void func(int a, int b = 0, int c = 1)
   {
   }
}

the following calls can be made:

var f = new foo();
f.func(42, 3, 4);          // f.func(42, 3, 4)
f.func(42);                // f.func(42, 0, 1)
f.func(42, 100);           // f.func(42, 100, 1)

But this is not all. C# 4.0 brings another feature: named parameters (and this does not exist in C++). It means that when you make a call, you can specify an argument by its name, not by position. In this case you use the parameter’s name followed by ‘:’ and the value. Here are several examples:

var f = new foo();
f.func(42, c: 4);          // f.func(42, 0, 4)
f.func(42, c: 4, b: 3);    // f.func(42, 3, 4)
f.func(c: 3, a: 1, b: 2);  // f.func(1, 2, 3)

Of course, this can be used regardless the function has optional parameters or not. However, I would not use this feature for anything else than specifying an optional parameter when I would have to first suply values for other several optional parameters. In other words:

var f = new foo();
f.func(42, c: 4);          // this is good, skip b, provide value for c
f.func(42, c: 4, b: 3);    // don't like this, rather call f.func(42, 3, 4)
f.func(c: 3, a: 1, b: 2);  // don't like this, rather call f.func(1, 2, 3)

Here is a comparison between auto in C++ and var in C#.

int _tmain(int argc, _TCHAR* argv[])
{
   auto i = 42;
   auto s = "Hello world!";
   auto d = 12.50;
   auto l = [](int n) {return n * n;};

   cout << "i = " << i << endl;
   cout << "s = " << s << endl;
   cout << "d = " << d << endl;
   cout << "l(i) = " << l(i) << endl;

   return 0;
}

class Program
{
   static void Main(string[] args)
   {
      var i = 42;
      var s = "hello world";
      var d = 12.50;
      //var l = (n) => n * n; // error CS0815

      Console.WriteLine("i = {0}", i);
      Console.WriteLine("s = {0}", s);
      Console.WriteLine("d = {0}", d);
   }
}

with the output

i = 42
s = Hello world!
d = 12.5
l(i) = 1764

i = 42
s = Hello world!
d = 12.5

As you can see, the use is very similar, except that in C++ you can use auto for a lambda expression, while in C# you cannot. The C# compiler raises an error, CS0815, when you try to use var with an anonymous function expressions, a lambda expression, a method group expressions, or the null literal expression, because these don't have a type.

Just like with var, you can only use auto locally, and not as return type from a function, or parameter to a function.

auto power(int n)
{
   return n * n;
}

error C3532: 'auto (int)': incorrect usage of 'auto'

int power(auto n)
{
   return n * n;
}

error C3533: 'auto': a parameter cannot have a type that contains 'auto'

While it might not be of that much help for ints or strings, using auto for instead of vector< int >::iterator, or map< string, list< string >>::const_iterator comes in handy. The auto type inference helps us write less verbose code.

vector< string > words;
words.push_back("hello");
words.push_back("world");

for(auto it = words.begin(); it != words.end(); ++it)
   cout << *it << endl;

In addition to auto, the C++0x standard introduces a new keyword, called decltype (think of it as 'typeof'), that can be used to determine the type of an expression at compile time.

auto i = 42;
decltype(i) i2 = 44;

However, this new keyword was not yet introduced in Visual Studio 2010 CTP. According to Stephan T. Lavavej from the VC++ team, it might be possible to be introduced in a next CTP or beta version.

Implementing auto doesn't implement decltype (C++0x's name for what was previously called typeof) for free.

Paraphrasing our libraries and compiler front-end program manager Damien Watkins, the CTP is only the first look at our VC10 functionality and there is definitely more to come. We understand that certain features "go together", and that adding complementary features is a good thing in general. As always, customer feedback is a vital resource in forming our plans.