I use a VirtualPC environment for all my software development work, usually using a unique environment for every customer. This eats up the drive space in my laptop pretty darn quick. So after reading about running a VirtualPC image from a USB Flash Drive I decided to give it a try. I purchased a 32GB memory stick and plugged it in.
After a little experimenting I can now confirm it runs the VirtualPC nice and fast. But writing data to the disk and reading at the same time is horrendously slow. So you need to do two things:
a) Make sure the .vmc file is NOT located on the flash drive
b) Enable UndoDisks
These two steps will create a temporary file on your harddisk, in the folder where the .vmc is located. This means that while using the drive you only read from the flash drive, but never write.
When you shut down the VPC you can choose to commit the changes to the flash drive,
this may take a little while, so only do it when you have time to wait for it to complete.
I usually choose 'Save State' which allows me to restart the VPC where I left off.
If you're using the xsd.exe tool to generate C# code from an XML Schema you'll find that an attribute defined as an integer is generated into a string field.
The reason is listed on MSDN:
The xs:integer type is specified as a number with no upper or lower
bound on its size. For this reason, neither XML serialization nor validation map it
to the System.Int32 type. Instead, XML serialization maps the xs:integer to
a string while validation maps it to the Decimal type that is much larger than
any of the integer types in the .NET Framework.
Ted Neward offers a very good description of what a Software Architect is:
"an architect is not like a construction architect, but more like the conductor of a band or symphony. Yes, the band could play without him, but at the end of the day, the band plays better with one guy coordinating the whole thing. The larger the band, the more necessary a conductor becomes. Sometimes the conductor is the same thing as the composer (and perhaps that's the most accurate analogous way to view this), in which case it's his "vision" of how the music in his head should come out in real life, and his job is to lead the performers into contributing towards that vision. Each performer has their own skills, freedom to interpret, and so on, but within the larger vision of the work."
My article on combining AIM Call Out with geocoding a phone number to display the location of the person you're trying to call has gone live on the AOL Developer Network.
I think it turned into a very cool sample application.
Dial a number and see the location of the person you're calling!
It seems there is some controversy (1) (2) around whether Live Mesh is good or bad. Here is my 2 cents: I've installed Live Mesh Tech Preview about a month ago and am pretty impressed by it so far. It seems to me Microsoft may have found the tool that will unify the desktop (where they make their money) with the cloud (revenue?). Currently there are two features that I use and like:
a) Sync files automatically with all machines in my Live Mesh group of devices
b) If my Live Mesh device is on, then I can use Remote Desktop Connection (or a Live
Mesh version thereof) to remotely connect to that device. Even if it is behind a firewall
and on a dynamic IP DSL connection. This is great because my machines at the office
are connected to the Internet via a dynamic IP connection and now I can just connect
to them, by clicking them via the Live Mesh icon in my icon tray.
The sync files feature will be further improved in the future when Peer 2 Peer synchronization
will be supported. I suggested this
feature on MS Connect, but it was already planned :-)
Here is the response I got:
We plan to include selectable direct Peer to Peer (P2P) as a sync scenario in
a later milestone, which is in effect what you have asked for here I believe.
Thank you for this report!
Tim
I use a lot of Virtual PC images. I'm hoping I can use this P2P sync service to create continuous backups (don't know if the bandwidth needed will prove to be a killer).
What is interesting is that files on Live Mesh will sync, even if the user is not signed in. This means that on the client Live Mesh is connected to the cloud without a user logging on. This offers potential for an interesting feature like 'Live Mesh Lockdown'. Suppose my machine is stolen. I could use some other device, go to the Live Mesh Desktop on the web and mark the device as stolen. This could lead to the machine being locked for further use. I have no idea what information is stored on the server with regards to the device. Perhaps this feature could even become part of the next version of Windows. That way if the thief re-installs the machine the server can still recognize the device (based on MAC address?) and still lock the machine.
Anyway, can't wait to see what the developer API for Live Mesh looks like.
The Software Developer Network user group will be hosting it's quarterly event on Monday, June 23. The theme of the event will be Collaboration, but plenty of general topic sessions will be held as well (a total of 30 sessions!).
Go to www.sdn.nl/sde to sign up.
Here is an overview of the sessions:
|
.Net C# |
.Net VB
|
DotNetNuke
|
Inform. Worker
|
Delphi
|
User eXperience
|
|||
| 8:30 |
Registratie / Ontvangst
|
|||||||
| 9:00 |
|
Addressing non-functional requirements with aspects Gael Fraiteur |
DotNetNuke Development: meer dan modules Stefan Kamphuis |
SharePoint 2007 en WWF: Integratie van Divergerende Werelden Gustavo Velez |
VCL for the Web Hadi Hariri |
User Experience op het web
Robert Kuunders |
||
| 10:15 |
Pauze - 30 min.
|
|||||||
| 10:45 |
|
SharePoint filter webparts - theorie en praktijk Ton Stegeman |
Dynamic Localization in DotNetNuke Peter Donker |
Samenwerken, met Groove een fluitje van een cent! Dennis Vroegop |
Continuous Integration in .NET Hadi Hariri |
Adobe Flex en AIR : De kracht van Rich Internet Applications |
||
| 12:00 |
Lunch - 60 min.
|
|||||||
| 13:00 |
.NET en hardware - video capture en servo's aansturen Jeroen W. Pluimers |
Towards more complex aspects using PostSharp Gael Fraiteur |
Synching your dev and live environments Erik van Ballegoij |
Gepersonaliseerd nieuws op basis van MOSS 2007 Search Mike Fortgens & Mirjam van Olst |
Unicode in Delphi for Win32 Bob Swart |
Silverlight2 |
||
| 14:15 |
Pauze - 15 min.
|
|||||||
| 14:30 |
Microsoft Sync Framework in action Dennis van der Stelt |
Het gebruik van een Object Relational Mapper tool Diderick Oerlemans |
DotNetNuke Schedular Interface Leigh Pointer |
Bouw een Silverlight smoelenboek in SharePoint Donald Hessing & Reinhard Brongers |
Practical Delphi WOA Paweł Głowacki |
Interaction Design: What the user really wants Stefan Bookholt |
||
| 15:45 |
Pauze - 30 min.
|
|||||||
| 16:15 |
Peer-to-peer en collaboration met .NET 3.5 Alex Thissen |
Customize VSTS WorkItems within your application Mike Glaser |
Content Syndication met DotNetNuke Peter Donker |
Collaboration met Lotus Quickr en Microsoft SharePoint
Arjan Uijl & |
Delphi en het Clipboard - copy en paste meer dan tekst alleen Jeroen W. Pluimers |
Developers + Designers = User Experience Martion Tirion |
||
| 17:30 |
Einde
|
|||||||
Anyone familiar with building applications using .NET Remoting (in .NET 2.0) knows that the DataSet and DataTable classes have a property called RemotingFormat. This could be set to either XML or Binary where Binary would give you a performance boost since it is more compact.
Windows Communication Foundation does not use this property at all. The service binding dictates the serialization format, no matter what you set the RemotingFormat property to be, even if your using a NetHttpBinding.
The following configuration will setup a service to use .NET Binary formatting over Http:
<system.serviceModel>
<bindings>
<customBinding>
<binding name="NetHttpBinding">
<reliableSession />
<compositeDuplex />
<oneWay />
<binaryMessageEncoding />
<httpTransport />
</binding>
</customBinding>
</bindings>
<services>
<service behaviorConfiguration="ServiceBehavior" name="MyService">
<endpoint address="" binding="customBinding"
bindingConfiguration="NetHttpBinding" name="HttpBinding"
contract="IService" />
<endpoint address="mex" binding="mexHttpBinding"
contract="IMetadataExchange" />
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="ServiceBehavior">
<!-- To avoid disclosing metadata information,
set the value below to false and remove the metadata endpoint above before deployment
-->
<serviceMetadata httpGetEnabled="true"/>
<!-- To receive exception details in
faults for debugging purposes, set the value below to true. Set to false before
deployment to avoid disclosing exception information -->
<serviceDebug includeExceptionDetailInFaults="false"/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
So even if your service looks something like this:
public DataSet GetData()
{
DataSet ds = BuildDataSet(); // retrieve some data
here
ds.RemotingFormat = SerializationFormat.Xml;
return ds;
}
The DataSet will still get serialized as a .NET binary as defined in the binding ('binaryMessageEncoding').
The article I wrote about building a Voice over IP .NET application using AIM Call Out and the AOL Open Voice API has just gone live on the AOL Developer Network. Read it here.
A lot is being blogged about the availability of VS 2008 SP1 and TFS SP1. It contains fixes and many new features and sound almost too good to be true, but I checked, it's not an April fool's joke :-)
A little lost in the noise about new features is the fact that .NET Framework 3.5 SP1 will include .NET CLR 2.0 SP2. I've been unable to find anything about this other than this one post by Eric Eilebrecht, but any CLR update is significant.
Okay, so you read the title of this post. Perhaps you're expecting huge amounts of code, but guess what. As it turns out, this is so ridiculously easy. This will be a very short post.
Step one is to have a method that loads an RSS feed. WCF offers a new class called SyndicationFeed.
private SyndicationFeed Load( string url )
{
XmlReader reader = XmlReader.Create( url );
SyndicationFeed feed = SyndicationFeed.Load( reader );
return feed;
}
The above method will take a url and use to load a feed. Now suppose I have a list of urls and I want to take all the items in all the feeds, sort them and use them to generate a new, aggregated feed. Sounds like a fair amount of work, right.
Here is the code:
private SyndicationFeed Aggregate( List<string> urls )
{
var items = from url in urls
from item in Load( url ).Items
orderby item.PublishDate descending
select item;
SyndicationFeed feed = new SyndicationFeed( items );
return feed;
}
Cool!
Heroes Happen in Bangor! The BAND is proud to announce we will be putting on a mini-launch event for Microsoft's Heroes Happen Here launch of the 2008 products. Come to the event at Kominsky Hall at Husson College in Bangor on Tuesday, May 27 at 6:00 pm.
Greg Howe and Jeff Hall, BAND co-leaders, will be talking about Visual Studio 2008 and how it will impact your development efforts. There will be two 45-minute talks, one focusing on the web world, and one focusing on the IDE. You will leave this event knowing how you can benefit from the new products, including Windows Sever 2008 and SQL Server 2008.
More info here.
My blog runs on dasBlog version 2.x and when I started blogging I did all my typing online. Then Office 2007 came along and Word offered the feature of creating a blog entry offline and then upload it to dasBlog using the MovableType API.
This wasn't too great though, since Word markup would end up in the HTML and sometimes the publish process just froze or refused to logon to my web site. Also, uploading pictures was kind of a hack.
Last week I installed Windows Live Writer and this runs as a charm. Definitely a recommendation!
A new quiz on www.justsayhi.com says I'm:
69% GeekI heard about Live Mesh last week and decided to check it out. So I’ve signed up for Live Mesh beta program and it is pretty neat, but still fairly simple. I’ve not (yet) been accepted into the Mesh Developer beta, which is a separate program. As I understand it Live Mesh will allow you to not just share files, but Silverlight applications as well.
Current state of Live Mesh
Live Mesh allows you to turn a folder on your machine into a Mesh Folder. This in turn allows you to automatically share the folder across multiple devices. Every account has one default device: the Mesh Live Desktop, an online desktop which acts like a Windows desktop.
Mesh Folders can be shared with any Live Messenger contact. Each Mesh folder will track all changes and allows collaboration my attaching messages to the folder.
Picture of Live Mesh Desktop, I've shared the Develop-One folder which sits on my laptop. It shows up as a folder on my Live Mesh desktop.
Device support will include Windows Mobile and Mac!
For anyone that knows Office Groove, it'll be interesting to see how the final version of Live Mesh and Groove compare.
An important part of LINQ and C# 3.0 is the concept of deferred execution. What does this mean?
Let's have a look at the following code:
static
void Main( string[]
args )
{
List<int>
numbers = newList<int>
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var evenNumbers = numbers.Select( x
=> ( x % 2 == 0 ) );
foreach ( int i in evenNumbers
)
{
if ( i == 6 )
numbers.Add( 12 ); //
add a number to the list of numbers
Console.WriteLine(
i );
}
Console.ReadLine();
}
public
static
List<int>
Select( thisList<int>
numbers, Filter filter )
{
List<int>
result = newList<int>();
foreach ( int i in numbers
)
{
// call the filter method/delegate
to see if this
// number needs to be in the result
if ( filter(
i ) == true )
{
// if
i matches the filter then add it to the result
result.Add( i );
}
}
return result;
}
In the code above the extension method 'Select' will apply a filter and return a subset of the original collection of numbers. When the numbers are printed we add the number '12' to the original collection. Since the Select method created a new collection with the subset we will not see the number 12 being printed to the console. If we want a more dynamic interaction we can rewrite the Select method to return an enumerator rather than a List.
public
static
IEnumerable<int>
Select( thisList<int>
numbers, Filter filter )
{
for ( int n
= 0; n < numbers.Count; n++ )
{
if ( filter(
numbers[n] ) == true )
{
// if numbers[n] matches the filter then yield the value
yieldreturn numbers[n];
}
}
}
The code above shows that instead of returning a List of numbers we now yield the value of each number as it passes through the filter. Now when we run the same Main we will see that the value '12' is included in our output. If we put a breakpoint inside the application we can inspect the type of 'evenNumbers'.
As you can see it point to the Select methods and the Lambda has been compiled into an anonymous delegate. Rather than having a fixed result the Select method keeps being called until there are no more numbers being 'yielded'. You can preview the results by opening the 'Results View', but that will only provide a view of the iterator at that specific point in time.
There are three key things that you need to understand in order to understand Lambda expressions in C#3.0.
1. Delegates,
2. Delegates,
3. ... delegates.
Since Lambda has come to town (or C#) I've discovered that a lot of people use
delegates, but quite a few developers don't really know what a delegate is.
Understanding delegates is key to understanding what Lambdas are.
Wikipedia has the following definition:
A delegate is a form of type-safe function pointer used by the .NET Framework.
Delegates specify a method to call and optionally an object to call the method on.
They are used, among other things, to implement callbacks and event listeners.
Here is my rule of thumb definition:
A delegate definition is a signature description for a method.
It helps me to think of it as an interface definition for methods. An interface defines a number of methods, properties and/or events that need to be implemented by a class. You can use an interface definition as a type for a parameter in a method. Similarly a delegate definition defines the return type and parameters that a method needs to 'implement' (match is a better word). And a delegate can also be used as a type for a parameter in a method.
Still a lot of mumbo jumbo?
Okay, let’s take the journey from ‘traditional’ programming to C#3.0
syntax.
Consider the following program. Traditionally if you wanted to select a subset from a collection you would iterate over the collection and copy the items you're interested in into a new collection.
static
void Main(string[]
args)
{
List<int>
numbers = newList<int>
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int>
evenNumbers = GetEvenNumbers( numbers );
foreach ( int i in evenNumbers
)
{
Console.WriteLine(
i );
}
Console.ReadLine();
}
static
List<int>
GetEvenNumbers( List<int>
numbers )
{
List<int>
result = newList<int>();
foreach ( int i in numbers
)
{
if (
i % 2 == 0 )
{
//
if i matches the filter then add it to the result
result.Add( i );
}
}
return result;
}
The above code will select all the even numbers and print them to the console. Just a foreach and no delegates yet.
Instead of implementing a 'GetEvenNumbers' method, lets create a generic Select method. The method will be generic and will loop over the numbers and select only those which are selected by a filter. But how to define the filter? Lets first look at what we want our Select method to look like:
static
List<int>
Select( List<int>
numbers, Filter filter )
{
List<int>
result = newList<int>();
foreach ( int i in numbers
)
{
//
call the filter method/delegate to see if this
//
number needs to be in the result
if (
filter( i ) == true )
{
//
if i matches the filter then add it to the result
result.Add( i );
}
}
return result;
}
We want to create a method which takes a reference to another method as a parameter. This is what is known as a delegate. In our case the delegate needs to be a method which takes an Int32 as a parameter and returns a Boolean. In C# the delegate is defined using the 'delegate' keyword:
delegate bool Filter( int x );
Now, any method that takes an Integer as a parameter and returns a Boolean matches this delegate. So both methods shown below match the delegate:
static
public
bool IsEvenNumber( int number )
{
return (
number % 2 == 0 );
}
privatebool IsOddNumber( int z
)
{
return (
z % 2 == 0 );
}
Notice that the name of the method does not matter, nor does the name of the parameter, nor does the accessibility of the method. Types of the parameter(s) and the return type is all that matters when it comes to matching with the delegate.
We can now rewrite Main to use the Select method:
static
void Main( string[]
args )
{
List<int>
numbers = newList<int>
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int>
evenNumbers = Select( numbers, IsEvenNumber );
foreach ( int i in evenNumbers
)
{
Console.WriteLine(
i );
}
Console.ReadLine();
}
In C# 3.0 it has become easier to create a delegate, all you need to do is provide the name of the method, the compiler infers that you wish to create a delegate.
The old syntax was:
static
void Main( string[]
args )
{
List<int>
numbers = newList<int>
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int>
evenNumbers = Select( numbers, newFilter(
IsEvenNumber ) );
foreach ( int i in evenNumbers
)
{
Console.WriteLine(
i );
}
Console.ReadLine();
}
The syntax is shorter, and arguably more readable, but hides the fact that a delegate is in fact an object and not just a reference as the new syntax seems to suggest.
Ok, now our IsEvenNumber method is quite simple, right? So to create a whole method for that method, which will likely never be reused is a little much. This is where anonymous delegates come in. Rather than specify a method which matches the delegate we can create an anonymous delegate which also matches with the Filter delegate.
Consider the following code:
static
void Main( string[]
args )
{
List<int>
numbers = newList<int>
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int>
evenNumbers = Select( numbers, delegate( int x
) { return ( x % 2 == 0 ); } );
foreach ( int i in evenNumbers
)
{
Console.WriteLine(
i );
}
Console.ReadLine();
}
The reference to IsEvenNumber has now been replaced by the creation of an anonymous delegate. The creation and implementation of the delegate is all done in a single line.
You'll probably agree that this does not do much for readability.
Remember how I started this blog post? Lambdas are delegates. So let’s replace the delegate with a lambda.
static
void Main( string[]
args )
{
List<int>
numbers = newList<int>
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int>
evenNumbers = Select( numbers, ( x => ( x % 2 == 0 ) ) );
foreach ( int i in evenNumbers
)
{
Console.WriteLine(
i );
}
Console.ReadLine();
}
So what is happening here? Let’s look at the Lambda:
x => ( x % 2 == 0 )
We are expressing that there is an input 'x' which we want to mod by two. Since
this Lambda expression is only a single line the return statement is implied and automatically
applied to the last statement, most Lambda expressions contain only one line of code,
but any number is possible. If you want more that one line you need to use the { }
to denote the scope of the block and use the return statement (if your delegate return
anything other than void).
If we were to change the expression to:
x => ( x % 2 )
Then the result of the Lambda would be a integer and the code would not compile
since the return type Int32 does not match with the Filter delegate.
There is quite a bit of 'magic' going on for the compiler to decide which
delegate the Lambda maps onto, the intellisense will help you, because (in this sample)
it will know that 'x' is of type Int32.
So to summarize:
Lambdas are a concise notation for defining delegates.
I'm currently doing some work with MapQuest and ran into the situation that I need to define styles for point of interest. From a code point of view I would like an enumeration, but the MapQuest API defines a series of strings to specify the style you wish to use. With C#3.0 I can now add a method to an enumeration using an extension method.
The sample below shows an enumeration for stars and an extension method for getting the value of that enumeration as a string:
public enum Stars : int
{
Red = 31,
Green = 32,
Blue = 33,
Yellow = 34,
Orange = 35,
Purple = 36,
White = 37,
Black = 38,
Gray = 39,
Gold = 40
}
public static class StarsExtension
{
public static string Value( this Stars enumerator )
{
int v = (int) enumerator;
return "MQ000" + v.ToString();
}
}
I can now use this as follows:
string s = Stars.Gold.Value();
Array conversion, or reshaping of objects, seems like a cool thing to do with LINQ
and C# 3.0.
I've played around a little with the following:
sbyte[] imageBytes = GetImage();
// convert using extension method / Lambda syntax
byte[] y = imageBytes.Select( s => (byte) s ).ToArray();
// convert using LINQ syntax
byte[] x = ( from b in imageBytes select (byte) b).ToArray() ;
// convert using the Cast extension
method
byte[] z = imageBytes.Cast<byte>().ToArray();
So what is the difference? Actually approach 1 and 2 lead to the same IL.
The Cast method works quite different and in my case I got an exception from approach
3 saying the sbyte would not fit in the byte.
But of course LINQ is not needed for this simple conversion:
// convert by casting to array to byte[]
byte[] bytes = (byte[])(Array)imageBytes;
I did a quick perf check and the last option is 500 to 800 times faster.
The Maine Developer Network is hosting a Geek Lunch tomorrow at the State of Maine,
Harlow Building at 18 Elkins Ave in Augusta.
Chris Bowen will be presenting on LINQ & Language Improvements in C# 3.0/VB 9.
Sign up here.
LINQ (Language Integrated Query) is a unified approach for querying data using coding syntax that remains consistent regardless of the data source. It WILL change the way you work as a developer and architect and this session will help you on your way to using it effectively. To understand how LINQ works, we'll first navigate the new features of C# 3.0 and VB 9.0 that enable LINQ functionality. Then, we'll dive into .NET 3.5 and Visual Studio 2008 to explore the various realms of LINQ: Datasets, XML, Database/SQL, in-memory objects, and more. By the end of this session, you'll have a solid understanding of how LINQ works and what it can do for your applications.
The Boston Code Camp 9 is over and done with. It was a great two day event and kudos to Chris, Chris and all the presenters that put their time and effort into making this an excellent happening!
Here are the two presentations from the session that I did:
04-06-2008 CC9 - Building a State Machine Workflow.zip (231.61 KB)If you're interested in playing around and testing VSTS 2008 and TFS 2008, but don't want to waste too much time getting the software installed? Good news! The trial Virtual PC images have been updated! Download your play area right here.
The image will not expire until December 31st 2008.
"This virtual machine is running Windows Server 2003 Enterprise Edition, SP2. It contains a full installation of Team Foundation Server 2008, Team Build 2008, Team Explorer 2008, Visual Studio Team System 2008 Team Suite and all necessary prerequisites. In addition, it has been updated with Office 2007 SP1, current Windows Updates as of March 25, 2008, and the December Release of the TFS Power Tools. Team Foundation Server is installed in workgroup authentication mode and thus does not require a domain controller. "
Chris just posted the schedule for Boston Code Camp 9!
Go to: http://blogs.msdn.com/cbowen/archive/2008/03/28/code-camp-9-the-schedule.aspx.
See you next week!
A friend of mine asked me about what book I'd recommend for learning Windows Communication Foundation.
I've read 'Learning WCF' from Michele Leroux Bustamante and think it's great and I still use it as reference material.
The Boston Code Camp 9 "I Came, I Saw, I Coded" will be held on April 5th and 6th at Microsoft New England District: 201 Jones Rd, 6th Floor, Waltham MA USA.
There are over 50 sessions planned (http://www.thedevcommunity.org/Events/PresentationList.aspx?id=6) and I will be presenting on two topics:
Building a State Machine Workflow
Workflow Foundation offers 2 types of workflows, sequential and state machine.
This presentation walks through the process of building an application using a State
Machine workflow, including state design, state transitions, data exchange services
and handling external events.
Building applications with logic
This session presents a view on how datasets and business logic can be organized
to build a working application.
Use basic architectural patterns to enable team development and improve maintainability
of your sources.
Hope to see you there!
The 22nd of April the Maine Developer Network is organizing a Geek Lunch. We'll be meeting at the State of Maine offices in Augusta to listen to Chris Bowen present on LINQ & Language Improvements in C# 3.0/VB 9.
Pizza will be provided and attendance is free and open for everyone!
More info and RSVP here.
My article for the Software Developer Network Magazine has been printed in the magazine. If you don't receive the magazine you can read the article here.
Slowly but surely more website are starting to support CardSpace. I’ve recently blogged about using Cardspace in conjunction with an OpenID from MyOpenID.com to log on to http://dev.aol.com/. Just the other day I discovered that that my hosting provider has started a beta program allowing me to sign on to my website’s control panel using CardSpace. Never one to shy away from a beta program I gave it a swirl.
After logging in to the website using my regular username/password I proceeded to my account page. Here a new button has been added ‘Bind card to account’, after clicking the button the CardSpace cardselector on my Vista machine opened up and I was allowed to select a card. Press OK and all was good. Time for a little test. Log out of the website. Then go back to the logon page and now instead of using my username/password I can use my CardSpace card to logon. And sure enough it worked!
Next came the real test. Since I also have DiscountASP hosting the website for our
user group (Maine Developer Network) I
tried to logon to this account using my CardSpace card. While doing so I discovered
that this did not work. I could not bind the same card to two different accounts.
I had to dive in a little deeper, but soon discovered this not to be a limitation
of CardSpace, but rather, the website does not support multiple accounts to one card.
The way to solve this would be to implement an account selector which would become
available after logging using the CardSpace card. The same would be true if DiscountASP
would support OpenID. Then one ID would have to be attached to multiple accounts.
Moral of the story: We’re a long way away from the ‘one ID to rule them all’. There is more to it than replacing your username/password validation with an OpenID or CardSpace control. You will have to reconsider the relationship between user accounts and your customer.
Silverlight 2.0 beta 1 is offering a DataGrid out of the box. Kathy Kam has a a great sample app showing off all the controls in Silverlight and providing you with a view of the underlying XAML.
Haven't installed Silverlight 2.0 yet? It'll install automatically, but you will have to restart the browser (at least, I had to).
The next version of Visual Studio Team System and Team Foundation Server is codenamed "Rosario". No formal release date has been made public yet, but if you want to see and participate in upcoming features, then check out the spec-share page on MSDN: http://msdn2.microsoft.com/en-us/vstudio/bb936702.aspx.
Just a quick reminder to all who haven't RSVP-ed yet: the Maine Developer Network user group meeting this Friday is still on.
The weather forecast for Friday looks good. So hope to see you all there!
Topic
An introduction to Unit Test, Test-Driven Development and Mock Objects As software
development projects grow over the course of months and years, it can be increasingly
difficult to manage quality and consistency. With the help of Visual Studio 2005,
Test-Driven Development (TDD) can be used with very little effort to insure constant,
high-quality code is written during the lifetime of your projects. In addition, you'll
see how to create and use mock objects to logically separate development efforts on
different tiers of your application to prevent blocking issues.
Speaker
Speaker will be Russ Nemhauser.
Russ Nemhauser is a Microsoft ASP.NET MVP and a Microsoft Certified Professional,
and has served as an Architect, Developer, Team Leader, and Project Manager over the
past several years. His projects have included enterprise applications, online commerce
sites, and corporate intranets for Wall Street, Universal Studios, Microsoft, Seagram,
and others. Russ actively participates in the development community, speaking at several
conferences and user groups each year. He also writes for several technical magazines
and industry web sites.
On Friday the 28th of March 2008 the Software Developer Network in the Netherlands will host the 'Expedition 2008' Software Developer Event.
Below is an overview of the sessions. For more information and registration go to: http://www.sdn.nl/Default.aspx?tabid=280
|
C# |
Visual Basic.Net
|
DotNetNuke
|
Delphi
|
Inform. Worker
|
FoxPro
VO/Vulcan |
VS2008 launch
|
|
| 8:30 |
Registratie / Ontvangst
|
||||||
| 9:00 |
WPF Styles & Templates Jo-wen Mei |
Workflow Foundation a la 2008 Maurice de Beijer |
DotNetNuke - implementatie in de praktijk Stefan Kamphuis |
Easily migrate Delphi apps to C/S with Advantage Database 9 Joachim Dürr |
Microsoft CRM 4.0 Plug-In Architectuur
Ralf van Gellekom & |
On the Dark Side of FoxPro (Part 1) Christof Wollenhaupt |
Visual Basic 2008 - What's new André Obelink |
| 10:15 |
Pauze - 30 min.
|
||||||
| 10:45 |
Introduction Using LINQ programming model Marcel de Vries |
Ontwikkel Smart Client en Office toepassingen in Visual Studio 2008 Maarten van Stam |
Enhance your modules using Token Replace Sebastian Leupold |
Delphi Agile Techniques Pawel Glowacki |
Performance Management met Performance-Point Server Hans Geurtsen |
On the Dark Side of FoxPro (Part 2) Christof Wollenhaupt |
What’s new in SQL Server 2008 |
| 12:00 |
Lunch - 60 min.
|
||||||
| 13:00 |
C# 3.0 en Rhino Mocks maken unit testen weer interessant! Dennis Doomen |
ASP.NET 3.5 Extensions Thomas Huijer |
DotNetNuke 5: New Features Sebastian Leupold |
Samenwerking Win32 en .NET met Delphi en Hydra 3 Bob Swart |
SQL server 2008: What's hot?
Donald Hessing & |
Werken met relationele databases in .Net en Vulcan.Net Bert Dingemans |
LINQ to SQL |
| 14:15 |
Pauze - 15 min.
|
||||||
| 14:30 |
Domein Gedreven Programmeren met C# 3.0
A. Boonzaaijer & |
SQL Server 2008 - een eerste blik voor ontwikkelaars Hugo Kornelis |
Ask The Expert Leigh Pointer |
Gebruik je Delphi kennis XPlatform Thaddy de Koning |
Building Internet Sites with MOSS 2007 | ||