A simple post on a simple subject

Today Vin just tweeted "FI(Fluent Interface) - when you use method chaining, after finishing the functionality, "return this", and that's how you make it fluent".

Thought about writing a detailed post on this, just to demonstrate various possibilities of Fluent programming.

Chaining Methods - A Simple Scenario

    /// 

    /// Anything that is trainable
    /// 
    public interface ITrainable
    {
        ITrainable Train(string skill);
        ITrainable Do(string skill);
    }

    /// 

    /// Our simple dog class
    /// 
    public class Dog : ITrainable
    {
        public string Name { get; set; }
        public List Skills { get; set; }

        public Dog(string name)
        {
            Console.WriteLine();
            Console.WriteLine("Dog " + name +
                   " created");

            Name = name;
            Skills = new List();
        }

        //Let us train this skill to our dog
        //Note that we are returning 'this', so that
        //we can continue training or ask the dog to perform
        public ITrainable Train(string skill)
        {
            Console.WriteLine("Dog " + Name +
                    " learned " + skill);
            this.Skills.Add(skill);
            return this;
        }

        //Let us ask the dog to perform this skill
        public ITrainable Do(string skill)
        {
            if (Skills.Contains(skill))
                Console.WriteLine("Dog " + Name + 
                    " is doing " + skill);
            else
                Console.WriteLine("Dog " + Name + 
                    ": Don't know how to " + skill);

            return this;

        }
    }

           //Train one dog, Hope your name is not Bobby ;)
            var dog = new Dog("Bobby");
            dog.Train("Running").Train("Eating")
                .Do("Running").Do("Eating");

Dog Bobby created
Dog Bobby learned Running
Dog Bobby learned Eating
Dog Bobby is doing Running
Dog Bobby is doing Eating

Chaining Methods - For Collections

    /// 

    /// Let us fluently train a bunch of Trainable
    /// animals
    /// 
    public static class TrainableExtensions
    {
        //Note that we are returning the IEnumerable
        public static IEnumerable
            Train(this IEnumerable flock, string skill)
        {
            foreach (var member in flock)
                member.Train(skill);
            Console.WriteLine();
            return flock;
        }

        //Ask all members to perform a skill
        public static IEnumerable
            Do(this IEnumerable flock, string skill)
        {
            foreach (var member in flock)
                member.Do(skill); 
            Console.WriteLine();
            return flock;
        }

    }

           //Let us create the dogs and train them
            var dogs = new List{new Dog("Jimmy"),
                                     new Dog("Sando"),
                                     new Dog("Rob")};

            //Now train them
            dogs.Train("EatingFood").Train("Running")
                 .Do("EatingFood")
                 .Train("JumpingToRing").Do("Running");

Dog Jimmy created
Dog Sando created
Dog Rob created

Dog Jimmy learned EatingFood
Dog Sando learned EatingFood
Dog Rob learned EatingFood

Dog Jimmy learned Running
Dog Sando learned Running
Dog Rob learned Running

Dog Jimmy is doing EatingFood
Dog Sando is doing EatingFood
Dog Rob is doing EatingFood

Dog Jimmy learned JumpingToRing
Dog Sando learned JumpingToRing
Dog Rob learned JumpingToRing

Dog Jimmy is doing Running
Dog Sando is doing Running
Dog Rob is doing Running

            dogs.Train("EatingFood").Skip(2)
                 .Train("JumpingRing").Union(dogs)
                 .Train("TakingPaper");

Dog Jimmy learned EatingFood
Dog Sando learned EatingFood
Dog Rob learned EatingFood

Dog Rob learned JumpingRing

Dog Rob learned TakingPaper
Dog Jimmy learned TakingPaper
Dog Sando learned TakingPaper

• Rhino Mocks
• ReadableRex - A fluent Regex API 
• Tweet# - A fluent client API for Twitter

As well known, the instance context mode property of Service Behavior can have these three values.

• PerCall - New instance is created for each client request.
• PerSession -  New instance is created for each new client session, and will be available throughout the session
• Single - Only one instance handles for all client requests throughout the application 

[ServiceBehavior(
     InstanceContextMode = InstanceContextMode.PerSession)]
 public class Service1 : IService1
    { 
       ...
    }

• MEF enables greater reuse of applications and components. Using MEF, .NET applications can make the shift from being statically compiled to dynamically composed. If you are building extensible applications, extensible frameworks and application extensions, then MEF is for you.

• A good list of free tools available for .NET development

• An LOB reference application in Silverlight

• Good read if you are interested in Silverlight and Live Mesh 

• Started with a weekend hack on creating a Live Mesh application. If you want to start with Live Mesh, download this SDK and tools

• Glimmer helps you create nice JQuery interfaces quickly and easily. Must see if you are a fan of JQuery

• Have a look at this silverlight twitter client.

• Some good intro towards starting building your on Live Mesh silver light application.

Something interesting about the Dynamic Language Runtime API in .NET 4.0

Dynamic objects can't be used with LINQ queries. If you look at it one way, this seems obvious. Consider this following code

dynamic dogList =GetMyDynamicList();

//Trying to find first dog with age 2, but this doesn't work
var result = dogList.FindFirst(dog => dog.Age==2);

dynamic list = new List<string>() { "10", "20" };
dynamic converted = list.ConvertAll((Func<string, int>) (x => int.Parse(x)));

• Ability to visualize and create user experiences, and to translate them to UI designs using Expression Blend
• Excellent understanding of XAML and capabilities of Silverlight
• Excellent understanding of creating and applying styles and templates
• Ideal candidate will have been working with Silverlight 1.0 since its inception, with examples showing level of expertise with an understanding of enhancements made with 2.0 and 3.0.

• Ability to guide the team by putting in place the required tools and frameworks (end to end) for Silverlight specific projects
• Experience using Expression Blend and Visual Studio for Silverlight application development
• Good understanding of XAML Styles, Triggers, Observable Collection, Data Binding Methods, Model View View-Model (MVVM) pattern, Navigation patterns
• XML and LINQ within Silverlight
• All aspects of Silverlight framework including DLR, Isolated storage etc
• Understanding about essential application blocks like Composite application block (Prism) Excellent understanding on using RIA, WCF services and ADO.NET Entity framework services with Silverlight
• Excellent knowledge of development within .NET 3.0 & 3.5 Framework
• Must understand the fundamentals of software development, including best practices and OOP design patterns. An understanding of cross-browser Front-end development issues is important
• Knowledge about 3rd party UI libraries
• Familiarity in Live Mesh technologies

• Experience using Expression Blend and Visual Studio for Silverlight application development
• Excellent C# and XAML skills
• Experience in using MVVM
• Strong JavaScript skills
• Working knowledge of development within .NET 3.0 & 3.5 Framework

Aggregated some of my earlier articles on design patterns (I published in code project), and published an e-book on the same over Scribd. The objective is to introduce software design patterns to you in a simple, human readable, and funny (?) way - in the context of designing a soccer engine - By discussing the thought process behind applying design patterns

Software Design Patterns Made Simple

One major feature that lacked in Silverlight implementation when compared to WPF infrastructure is support for Commanding. The Composite Application Block for Silverlight [Here] provides Commanding support for Silverlight using attached behaviors. The implementation is quite simple.

Here is how to create reference to the CAL from your Silverlight Project

1. Download Prism from here
2. Open and build the solution CompositeApplicationLibrary.sln
3. Add a reference to the following dlls from your Silverlight application
• Microsoft.Practices.Composite
  
• Microsoft.Practices.Composite.Presentation
  
• Microsoft.Practices.Composite.UnityExtensions
  
• Microsoft.Practices.ServiceLocation
  
• Microsoft.Practices.Unity

<UserControl x:Class="MyApp.Toolbar"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:cmd=
     "clr-namespace:Microsoft.Practices.Composite.Presentation.Commands; 
     assembly=Microsoft.Practices.Composite.Presentation"
    >

</UserControl>

And once you have the Commands namespace imported in Xaml, you can bind your command to an element like this.

 <Button cmd:Click.Command="{Binding OpenCommand}" 
    cmd:Click.CommandParameter=
              "{Binding SelectedItem, ElementName=cmbForm}">
 </Button>

Note that I'm using Element binding to pass the command parameter, obviously I'm using Silverlight 3.0 beta. :)

Some 'Beginner's' stuff. One good thing about WPF is the ability to specify custom converters, when you do the binding.

Here is a simple IValueConverter implementation, to convert an int value (1 or 0) to corresponding bool values (true or false).

Useful if you want to bind a check box or something to a property of numeric type.

 
public class NumToBoolConverter : IValueConverter
    {

        #region IValueConverter Members

        public object Convert(object value, Type targetType, 
            object parameter, System.Globalization.CultureInfo culture)
        {
            if (value!=null && value is int )
            {
                var val = (int)value;
                return (val==0) ? false : true;
            }
            return null;

        }

        public object ConvertBack(object value, Type targetType, 
            object parameter, System.Globalization.CultureInfo culture)
        {
            if (value!=null && value is bool )
            {
                var val = (bool)value;
                return val ? 1 : 0;
            }
            return null;
        }

        #endregion
    }

Now, to do the binding in Xaml, you can just create a resource,

<Window.Resources >
        <local:NumToBoolConverter x:Key="IntConverter"/>
    </Window.Resources>

And then do the binding. Simple and easy.

<CheckBox Name="chkBox" 
IsChecked="{Binding Path=IntProperty,Mode=TwoWay, 
Converter={StaticResource IntConverter}}"/>

Today I did a small experiment to see how we can use PDF to generate XAML files. I wanted to mimic the pdf form entry in Silverlight.

Here is the summary of what I've done.

• Created a new Silver light Project in Expression Blend 3.0 Beta
  
• As Expression Blend can import adobe illustrator files, I simply renamed a pdf file's extension from pdf to ai
  
• Clicked File-> Import Adobe Illustrator files in Blend, and imported to my active window.
  
• Cool, I've the whole form imported as graphical paths, preserving the whole layout.
  

If you want to convert something to string, what is the best way?.

Here is a neat extension method for all your objects, so that it'll find the appropriate converter if one exists, or otherwise, fall back to ToString() :)

public static class ConverterExtension
    {
        public static string ConvertToString(this object value)
        {
            TypeConverter converter = 
              TypeDescriptor.GetConverter(value.GetType());

            // Can converter convert this type to string?
            if (converter.CanConvertTo(typeof(string)))
            {
                // Convert it
                return converter.ConvertTo(value, 
                        typeof(string)) as string;
            }

            return value.ToString();
        }
    }

Color val = Color.Red;

//Call our extension method
string result1 = val.ConvertToString();

//Try with ToString()
string result2=val.ToString();

This weekend I was playing with some entries in Mixtify 10 K Gallery, and it is cool. Really got some fresh thoughts. Loving it. Click here to check out

Here are a couple of interesting stuff.

Silverlight Turtle

  

  

  

As I was recently working with TFS Client APIs, here are few thoughts on the same.

Logging Into TFS Server

To log in to the TFS Server using the TFS Client APIs, you can either use the domain authentication, or provide the username or password explicitly

- Logging in using the current windows user

TeamFoundationServer _tfsServer = new TeamFoundationServer("serverUrl");
_tfsServer.Authenticate();

- Logging in using a specific network credential

 _tfsServer = new TeamFoundationServer(
                        "serverUrl", 
                       new System.Net.NetworkCredential
                               ("userName", "password", "domain"));
 _tfsServer.EnsureAuthenticated();

Getting all the projects - Using VersionControlServer

After logging in, you can get all the projects and project items in TFS as shown below. We are reading the latest version for each item

VersionControlServer _versonControlServer=_tfsServer.GetService
                (typeof(VersionControlServer)) as VersionControlServer;

 foreach (var teamProject in 
             _versonControlServer.GetAllTeamProjects(true)) 
 {
       //Get all the items in the project
       ItemSet items = 
              _versonControlServer.GetItems
               (teamProject.ServerItem, VersionSpec.Latest, 
                                         RecursionType.OneLevel);
       foreach (Item item in items.Items)
                        { //do your stuff with each project item }
 

 }

Reading all users - Using GroupSecurityService Now, you can read all users using the IGroupSecurityService, as shown.

   IGroupSecurityService _groupSecurityService = 
_tfsServer.GetService(typeof(IGroupSecurityService)) 
             as IGroupSecurityService;

Identity identity = _groupSecurityService.ReadIdentity
  (SearchFactor.EveryoneApplicationGroup, null, QueryMembership.Expanded);

foreach (Identity user in _groupSecurityService.ReadIdentities
          (SearchFactor.Sid, identity.Members, QueryMembership.None))
                {
                   //do something with the users
                }

This is a nice one. Click Full screen mode and enjoy

Re-visit my article on Architecture Considerations, it might be interesting.