Christian Nagel's OneNotes

Windows 7 Installation Experience

CNagel — Tue, 17 Feb 2009 16:15:00 GMT

Now I'm running Windows 7 on several systems. I'm now running the Beta version on my major system.

The installation experience and stability depends on the hardware. Of course, that's a usual experience with a Beta version.

The best experience is with my newest tablet PC: Fujitsu Siemens Lifebook T5010.
Installation (upgrade from Windows Vista) was smooth, every device is available, so far no major issues. I could also run Microsoft OneCare after telling the application it's running on Windows Vista.

With a slightly older model (Lifebook T4220) installation (upgrade as well) was hanging near the end of the installation during a check of the graphics card. After turning off and on again the installation completed without problems. Checking the Windows Experience Index on this system either results in a hang or a blue screen. However, for normal daily operations this system doesn't have issues.

On a old notebook (HP Compaq NX7000) a new installation of Windows 7 was running fine. For the graphics card just a standard driver was installed during installation. With an update the driver for ATI Mobility Radeon 9000 was installed, and as a result the screen on the display flickered. The display on an external monitor is ok. Rollback the driver. The standard driver just has a Windows Experience Index of 1, but the system is fine for non-display related tasks. I checked the HP Website for drivers, but only Windows XP drivers are offered for this notebook. I used this system for Windows Server 2003 which was fine. It's great that Windows 7 is running on this system as well!

Here is a link for the experience with other systems: Sammelpost: Erfahrungsberichte zu Windows 7 Beta

Christian

3. Software Development Day in Wien

CNagel — Sun, 08 Feb 2009 17:51:00 GMT

Bereits zum dritten mal gibt es den Software Development Day, zum zweiten mal im Euro Plaza! Auch diesmal wieder mit Einblicken in die Zukunft aber auch Informationen über Technologien die bereits jetzt eingesetzt werden sollten!

Max Knor, Andreas Pollak, Georg Drogny und Christian Nagel über Windows Azure, Live Mesh, Silverlight, Windows 7, ADO.NET Data Services, .NET 4.0, C# 4.0 und vieles mehr!

Dienstag, 24. Februar 2009
Konferenzzentrum Euro Plaza in Wien
Details und Anmeldung hier: 3. Development Day in Wien

Christian

Separation of Algorithms and Containers (Collections)

CNagel — Mon, 02 Feb 2009 10:47:00 GMT

The C++ Standard Template Library (STL) separates algorithms from containers. C++ algorithms are defined within the header file can be used with containers depending on the iterator that is needed by the algorithm and the iterator supported by the container. search, search_n, reverse, rotate, copy, count, count_if, find, find_first_of, for_each, max, min, merge are just a few of the algorithms. These are global functions that accept iterators from container classes to iterate all elements.

With .NET 3.5 algorithms are separated from collections as well. Static methods such as Count, Max, Min, First, Skip… are implemented by the Enumerable class. These methods are all extension methods based on the IEnumerable interface and thus can be used with every collection.

Let’s compare the implementation of C++ accumulate with .NET Aggregate. Both have several overloads, but I just want to compare just one. The others are very similar.

C++ aggregate is a template function with four parameters. The first two parameters mark the begin and end of the iteration. This algorithm requires an Input Iterator that implements the operators !=, ++, and *. The third parameter is used as initialization of the aggregation, and the last parameter accepts a function object that has two parameters (BinaryOperation). With a for loop every element that is enumerated is accessed, the binary operation invoked, and the result of the operation accumulated.

template
Type accumulate(InputIterator _First, InputIterator _Last, Type _Val, BinaryOperation _Binary_op) 
{
   for (; _First != _Last; ++_First)
      _Val = _Binary_op(_Val, *_First);
   return (_Val);
}

Using the accumulate method a binary function can be defined that is invoked by accumulate, e.g. a simple multiplier.

int action(int x, int y)
{
   return x * y;
}

Calling the accumulate function requires the begin and end for the iteration that is returned from the begin and end methods of the vector class. For multiplying every integer in a vector, the initial value is set to 1, and the address of the action function is passed: int result = accumulate(v1.begin(), v1.end(), 1, action); The .NET version of the C++ accumulate does not differ a lot. Instead of having a begin and end of an iterator, here the IEnumerable interface is used. With C++ iterators just a naming convention is used to give the requirements of the iterator. C++ differentiates input, output, forward, bidirectional, and random access iterators that define what operators must be implemented. With .NET it’s clearly defined what methods must be implemented by the collection by the definition of the IEnumerable interface. The initial value that is passed is similar to the C++ implementation. The last parameter defines the signature of the method that is invoked by Aggregate: a method with two input parameters and a result. Instead of a for loop, .NET makes use of the foreach loop that is converted by the compiler to use the methods of the IEnumerable interface.

public static TAccumulate Aggregate(this IEnumerable source,  
   TAccumulate seed, Func func)
{
   TAccumulate local = seed;
   foreach (TSource local2 in source)
   {
      local = func(local, local2);
   }
   return local;
}

Because the Aggregate method is an extension method, it can be invoked like a member of the collection class to aggregate all values from the collection. The functionality that is invoked with every instance can be implemented by using a Lambda expression.

int result = coll.Aggregate(1, (x, y) => x * y);

C++ and .NET have very similar implementations to separate the algorithms from containers. Lambda expressions are not yet available with C++, but will be with a future version C++0x. Algorithms that are available in one place (e.g. C++) can easily be implemented in the other (e.g. .NET).

Christian

Thoughts about 2009

CNagel — Sat, 31 Jan 2009 14:26:00 GMT

It's nearly February, I'm a little late for my thoughts about the year 2009. Still I'm writing down what I'm expecting, my thoughts about important things to come.

In the first month of the New Year I've already covered a lot of different technologies in the first workshops: Team Foundation Server, WPF, ASP.NET AJAX, and C++.

What are the most important products I'm working on in the New Year? The first on my list of course is Windows 7, the successor of Windows Vista. I'm running the Beta already on several of my systems. Depending on the hardware used there are some small issues (e.g. on an old HP Compaq NX7000 with the graphics driver, some issues on a Fujitsu Siemens Tablet T4220 in regard to the graphics card as well), but of course that's usual with a Beta product. In summary I'm really happy with Windows 7.
Primarily it's based on the code from Windows Vista with some good enhancements. Because the code is based primarily on Windows Vista and not a complete rewrite we can expect that it’s really running stable this is already the experience from many Beta testers. I expect shorter Beta cycles which I’m also reading out from Our Next Engineering Milestone. RC will be the next version for download. Windows 7 has a great new calculator (hey, is there a problem the calculator is included with the operating system?). WordPad has the ribbon controls! Even more important – WordPad can save OOXML and ODT. The new toolbar is really cool. There are many more great features... I’m already running Windows Vista from the early beginnings (of course Beta editions). Now I’m expecting many companies to move from Windows XP to Windows 7. Do you wait until SP1 or do the move earlier? Now is the time to not only find out if your applications run on Windows Vista (which was already done by most companies) because of the UAC, but also what advantages the application can get by running on Windows Vista and Windows 7. I offer a Workshop on this :-)

Another product I’m spending a lot of time with is Windows Azure. Paying just for the resources that are needed can be a big improvement for startup companies. How many systems should we add to the Web server so the users get acceptable performance? Twitter, why don’t you just increment this configuration value instead of returning errors? I don’t think Windows Azure is just for startup companies. I would like to access my data from everywhere; I would like to use some CPU and disk resources just for specified time frames (e.g. the registration process for a conference). In current different economy times it might be a good decision to outsource some IT management and just pay for what’s needed.

Since the end of last year I’m running Windows Home Server. Every home should have one. It’s really easy to configure that and all your PC’s are backed up, data on network shares is duplicated on different hard disks, and the data is even accessible from the road. Easy to use systems and applications are important! I remember the days where I had to change some switches and jumpers before I could put a module inside a system. The Micro PDP 11 made things a lot easier – a lot easier to configure than PCs at that time. Now I’m adding hardware to systems by connecting them to the USB. No more configurations necessary, no search for drivers… Windows Media Center is – in my opinion – a lot easier to use than getting to know how to use several different remote controls to turn on and switch to the correct mode with Receiver, TV, and a DVD/hard disk recorder. Many users are lost to find the correct settings with that many remote controls. It’s still getting easier. Silverlight brings completely new user interfaces to Web applications. Rich client experience that can be completely different to the experience we had with Web applications that have been used before - Silverlight for Web applications; WPF for Windows applications. The user can be knowledgeable of its problem domain but no longer need to know how to use a Windows application. Not every person is a Word and Excel user.

Of course I’m not forgetting Visual Studio 2010 and .NET 4.0. These are the products I’m using on my main system during this year so my customers can use my experience with this technology as soon as they need it. I’m already working for some time on the next edition of the Professional C# book: Professional C# 4.0 and .NET 4.0. .NET 4.0 gives a lot to cover with the next edition! I just received the Chinese version of Professional C# 2008. You can start the next translation early next year :-)

Windows 7, Windows Azure, Visual Studio 2010, .NET 4.0, Silverlight 3.0... I still didn’t mention my most important... I can give you the expected arrival date: 3-June-2009. It can arrive a little earlier or later. Around that time I don’t do any travel, expecting a baby girl with my girlfriend Angela. This is going to be a really great year :-D

Christian

Windows Azure bei der .NET User Group Austria

CNagel — Mon, 10 Nov 2008 21:39:00 GMT

Aktuellste Informationen von
Peter Koen, Senior Program Manager bei Microsoft
bei der .NET User Group Austria:
Microsoft Windows Azure und Cloud Computing!
11.11.2008, 18 Uhr
und mehr als 30 angemeldete Teilnehmer!

Christian

PDC 2008 - XAML with .NET 4.0

CNagel — Fri, 31 Oct 2008 00:54:00 GMT

from #pdc2008: XAML enhancements!
XAML nowadays is used with the UI (WPF, Silverlight), Workflows (WF), and Electronic Paper (XPS).
XPS is just going to be an ECMA standard!

With all these uses XAML is going into a language evolution. Goals of this is to make XAML faster and easier to use.

The XAML language extensions are defined by this list:

improved named references
support for built-in types
full generics support
support for arbitrary dictionary values
declarative events without compiling
declarative definition of types
arguments for non-default constructors
factory methods

The notepad for XAML, XAMLPad, has been enhanced. Besides the XML and object box it now gives a DOM box to display the DOM model. With the F12 key, a visual representation of the XAML type is shown.

For reading/writing/processing XAML, .NET 4.0 includes the System.Xaml.dll assembly. It contains XamlXmlReader, XamlXmlWriter, BamlReader, BamlWriter, DomReader, DomWriter, ObjectReader, ObjectWriter. Now it's easier to develop e.g. a SVG conversion. To convert from SVG to XAML, the SVGReader and XamlXmlWriter come into play. For creating objects on the fly out of SVG, SVGReader and ObjectWriter are used.
The System.Xaml assembly will be available here: http://go.microsoft.com/fwlink/?LinkId=132499

In the early days of XAML and WPF, simple applications have been shown that just need XAML code but no code-behind. Now it is possible to write an application that makes use of WPF, WF, and WCF purely using XAML.

Christian

PDC 2008 - Parallel Extensions to the .NET Framework

CNagel — Wed, 29 Oct 2008 20:10:00 GMT

From #pdc2008, Parallel extensions to the .NET Framework are part of .NET 4.0!

The thread pool has been enhanced with great new features. The new features can be accessed from the Task API. The Task API can be used similar to the Thread class and offers some advanced features. For the tasks to queue up, the pool now not only includes a global queue but also a local queue for every thread in the pool. This can enhance performance because of data cached in the CPU.
With the new API, other than starting tasks some more features: tasks can be started in a parent/child relationship, it is possible to suspend/continue/wait/cancel tasks, and get results from the task (using the Future class). This class might be renamed to Task as well (in the future).

Tasks are well integrated into Visual Studio 2010. For debugging tasks new windows Parallel Tasks and Parallel Stacks are available.

A common pattern is using threads in a loop to perform some actions on a list of items. The Parallel class gives an implementation of this pattern. Parallel.ForEach offers several overloads to do several actions in parallel with the thread pool.

Declarative data parallelism allows LINQ queries to run in parallel. This feature is for LINQ to objects thus collections that implement IEnumerable. All that needs to be done is to invoke the AsParallel method that does nothing more than casting the IEnumerale interface to IParallelEnumerable. The class ParallelEnumerable then offers extension methods for the IParallelEnumerable interface to call the LINQ operators using threads from the pool.

Christian

PDC2008 - Type System Changes with CLR 4.0

CNagel — Wed, 29 Oct 2008 15:25:00 GMT

From #pdc2008: the CLR type system is changed regarding "type embedding" and "type equivalence". The primary idea was easier use of COM interop, but the features are also useful with pure managed code.

An issue that we have today regarding COM interop is the deployment of Primary Interop Assemblies (PIO). An application that uses Excel 2007, the primary interop assembly required by the application requires 1.2 MB. In reality you need to install the Office 2007 PIA Redist that requires 6.3 MB. And this is just for Office 2007. The next version requires another PIA redist install.
This is one of the issues solved with the new type embedding feature.

With type embedding PIAs are no longer required. Type embedding is possible by the new CLR and a new compiler switch.

The second feature for the CLR type system is type equivalence. Type equivalence is useful both with COM objects and .NET managed code. Interfaces marked with an GUID attribute are treated equivalent if the same GUID is used. Multi-targeting through interfaces. Does this influence System.AddIn? I've to try this out!

Christian

PDC 2008 - C# Futures

CNagel — Tue, 28 Oct 2008 00:58:00 GMT

Again, Anders Hejlsberg had a great session at #pdc2008. This time about C# 4.0 and C# 5.0!

C# 1.0 was the core about OO, C# 2.0 added generics. With C# 3.0 is the first version with new language features - LINQ, and this is expands with the future versions. C# is a multi-paradigm language. Of course, it's an OO language (since 1.0), since 3.0 it can also be used as functional language. The main areas of enhancements are in these areas:

declarative
dynamic
concurrent

Microsoft is doing a shift in regard to C# and VB to recognize reality. Features from C# are brought into VB, and features from VB into C# - because the demand is here!

C# 4.0 adds dynamic programming. With this it is easy to call not only .NET objects but also easily COM objects, JavaScript, Python...
The enhancements can be grouped into these areas:

dynamic keyword
optional and named parameters
co- and contra variance

With the new dynamic keyword, a variable can be declared in C# that references a object that is created during runtime, e.g. from COM or JavaScript.

dynamic calc = GetCalculator();
int sum = calc.Add(10, 20);

Every method that is invoked on a dynamic object returns a dynamic result that is dynamically cast to the type the return variable is declared (e.g. an int in the example). A great feature here is the syntax looks the same, no matter if the calculator is a COM object, JavaScript, Python or Ruby. Binders for each of these variants are available, and custom binders can be written as well.
Using C# it is also possible to create dynamic runtime-objects by implementing the interface IDynamicObject or deriving from the base class DynamicObject.

A many times requested feature that is available with C# 4.0 is optional and named parameters. Instead of defining several overloads, optional parameters can be defined:

StreamReader OpenTextFile(
   string path,
   Encoding encoding = null,
   bool detectEncoding = true,
   int bufferSize = 1024);

this can be called wih only the mandatory parameter:

OpenTextFile("foo.txt");

and also with named arguments:

OpenTextfile("foo.txt", bufferSize : 4096);

Of course, named arguments must be after the mandatory parameters.

Optional and named parameters have a great COM Interop story. No more ref missing parameters. "It took 10 years to get back where we were".

Covariance and contra-variance is another new feature. co-variance or contra-variance information can be added to generics, e.g. and . means that T can be used only in output positions, only in input positions. Existing interfaces and delegates such as IEnumerably and IComparable are changed to the new notation. A blog entry with samples about this feature follows here!

Anders also demonstrated C# 5.0 features. C# 5.0 opens up the compiler to offer modern ways for meta-programming - compiler as a service!

More information about C# futures:http://code.msdn.microsoft.com/csharpfuture

Christian

LINQ in Norway

CNagel — Sat, 25 Oct 2008 04:07:00 GMT

15 to 17 December 2008 I'm doing a LINQ training in Norway:

C# 3.0
LINQ to Objects
LINQ to XML
LINQ to SQL
ADO.NET Entity Framework
ADO.NET Data Services

Are you there?

Detailed information is here:
www.programutvikling.no

Christian

ADC08

CNagel — Mon, 13 Oct 2008 12:33:00 GMT

Thinktecture and post-Thinktecture sessions at the ADC 08 in Germany:

Christian Weyer, WCF - Kommunikationsmuster illustriert
Christian Nagel, C# 3.0 in LINQ
Christian Nagel, Threading und Synchronization
Neno Loje, Windows-Anwendungen ohne Kopfschmerzen verteilen: mit ClickOnce
Christian Weyer, WCF und WF gemeinsam einstzen
Jörg Neumann, Erweiterbare Anwendungen mit dem Managed Add-In Framework
Ingo Rammer, .NET Production Debugging - Erste Schritte
Dominick Baier, Autorisierung und Identität in Service-orientierten Anwendungen
Ingo Rammer, .NET Production Debugging - Tips und Fortgeschrittenes
Dominick Baier, Advanced IIS 7 Development

And that's just the first day

Christian

WPF TextBlock Strikethrough

CNagel — Sun, 01 Jun 2008 18:46:00 GMT

Scott Hanselman is looking for WPF TextBlock with stroke text.
With WPF this is a really easy and flexible task to do. What needs to be done is to set the Decorations of the TextBlock:

<TextBlock FontSize="18">
  <TextBlock.TextDecorations>
    <TextDecoration Location="Strikethrough">
      <TextDecoration.Pen>
        <Pen Brush="Red" />
      </TextDecoration.Pen>
    </TextDecoration>
  </TextBlock.TextDecorations>
  Sample
</TextBlock>

Christian

Twitter

CNagel — Sun, 01 Jun 2008 18:33:00 GMT

I thought this is nothing for me. Instead I should write more entries to my blog.
However, I give it a try: http://twitter.com/ChristianNagel.

Christian

XPS Printing

CNagel — Sat, 24 May 2008 11:26:00 GMT

I've stored an invoice from the Internet as XPS for later printing. Now printing with the XPSViewer.exe fails with an exception because it demands permission for UnmanagedCode.
Instead trying to find a fix for the application I've written a small program to print XPS:

PrintDialog dlg = new PrintDialog();
if (dlg.ShowDialog() == true)
{
XpsDocument doc = new XpsDocument(fileName, System.IO.FileAccess.Read);
dlg.PrintDocument(doc.GetFixedDocumentSequence().DocumentPaginator, "Test");
}

It's really easy to work with XPS. XpsDocument is part of .NET 3.5 in the assembly ReachFramework, namespace System.Windows.Xps.Packaging.
Christian

Twelve Core Processors in 2010

CNagel — Thu, 08 May 2008 09:24:00 GMT

The AMD Server Workstation Roadmap lists processors with 6-core (Istanbul, 2009), and twelve-core (Magny Cours, 2010).
Parallel computing is becoming more and more important, e.g. Parallel LINQ.

Christian