John Liao's Blog

Translating If-Then-Else Control Flow Idiom to F#

2012-01-20T17:52:00.000-08:00

I was reading through Juval Löwy's Programming WCF Services book and wondering if I should do a series of WCF blog posts in F# based on Löwy's book when I ran into a common construct found in C# programs. That construct looks something like the following C# code:

    public static void MyMethod(String oldstuff, String newstuff, bool flag)
    {
        if (oldstuff == null)
         throw new Exception("oldstuff is null!");

        if (newstuff == null)  {
            DoSomething("Default");
            return;
        }
        if (flag == false)  {
            DoSomething(oldstuff);
            return;
        }
        DoSomething(newstuff);
    }

This is a construct that I oftened have used in the past and have never thought about it much. But when you translate the above code directly into F#, it becomes a lot more verbose because F# requires you to implement the then clause. A direct translation to F# as follows:

let mymethod oldstuff newstuff flag =
    if oldstuff = null then 
        raise (new Exception("oldstuff is null!"))
    else
        if newstuff = null then
            DoSomething("Default")
        else
            if flag = false then
                DoSomething(oldstuff)
            else
                DoSomething(newstuff)

If I had a lot of these if-then-else statements in my C# method, then my F# version would disappear off the screen to the right if I tried to implement it by direct translation. I thought about how I could implement this in F# and came up with this following possibility:

let revised_mymethod oldstuff newstuff flag =
    let (_,action) =
        [(oldstuff=null,  lazy (raise (new Exception("oldstuff is null!"))));
         (newstuff=null,  lazy (DoSomething("Default")));
         (flag=false,     lazy (DoSomething(oldstuff)));
         (flag=true,      lazy (DoSomething(newstuff)))]
        |> List.filter fst
        |> List.head
    action.Force()

Rewriting the C# code in this fashion makes me think of rules engines and after refactoring out some common code, I could rewrite the above F# code as follows:

let followrules (xs:(bool*Lazy<unit>) list) =
    (xs |> List.filter fst |> List.head |> snd).Force()

let revised_mymethod2 oldstuff newstuff flag =
    [(oldstuff=null , lazy (raise (new Exception("oldstuff is null!"))));
     (newstuff=null,  lazy (DoSomething("Default")));
     (flag=false,     lazy (DoSomething(oldstuff)));
     (flag=true,      lazy (DoSomething(newstuff)))]
    |> followrules

With this new construct, I can easily re-arrange the order of evaluation, add or remove new conditions. This new construct just seems to have more advantages than the old if-then-else construct in F#.

Testing Coherence with Clojure

2012-01-11T10:32:00.000-08:00

A developer came to me the other day asking for help in diagnosing some issues with their application and the interaction with Oracle's Coherence product. I wanted to write some testing harness to quickly test some Coherence configuration and gave some thought about how I would go and try to replicate the issues that the application had. I wanted a REPL environment so that I can interactive manipulate the Coherence API and dump outputs on demand. I decided to use Clojure to experiment with Coherence, although I could have used JRuby, Jython, Groovy or Scala. From purely a familiarity perspective, I would rank my usage of these listed languages in the order of Ruby first, Python second, Groovy third, Clojure fourth and Scala last. But for some unknown, deep-seated and probably emotional reasons, I like Clojure more and relish the opportunity to use it. One of the first thing I tried with Clojure and Coherence is to perform a timing test on adding data to a 2 node distributed cache in serial vs concurrent mode. Here's the example Clojure script:

(import '(org.apache.commons.lang3 RandomStringUtils) 
        '(java.math BigInteger)
        '(java.util Random Date HashMap)
        '(com.tangosol.net NamedCache CacheFactory CacheService Cluster))

(CacheFactory/ensureCluster)
(def cache (CacheFactory/getCache "sandbox"))

(defn random-text [] (RandomStringUtils/randomAlphanumeric 1048576))
(defn random-key [] (RandomStringUtils/randomAlphanumeric 12))


; Testing serial puts
(new Date)
(dotimes [_ 200] (.put cache (random-key) (random-text)))
(new Date)

; Testing concurrent puts
(def buffer (new HashMap))
(new Date)
(dotimes [_ 200] (.put buffer (random-key) (random-text)))
(.putAll cache buffer)
(new Date)

Running this code showed a 2x gain in speed of data load. On one of the Coherence nodes, I had JVisualVM connected to it and watched the realtime GC behaviors with VisualGC. It has been fascinating to watch the behaviorial differences between serial vs parallel data load and the memory activities of the Coherence node when my Clojure script was idle. I hope to conduct more tests in the future looking at GC behaviors and leverage my Clojure script as load driver in my testing efforts and assist me in GC tuning of Coherence instances.

Revisiting the SharePoint collection adapter for F#

2011-11-11T16:41:00.000-08:00

Recently, I got to work with SharePoint 2007 again and I revisited a previously written blog Exploring SharePoint 2007 Object Model with F#. In that blog, I complained about the fact that SharePoint collections did not implement IEnumerable, causing me to implement a type specific collection adapter as pilfered from Asfar Sadewa. However, as I started to work with more different SharePoint collections, I realized that I need a generic SharePoint collection adapter. But once again, I was foiled by SharePoint's library designers. I wanted to ensure some level of type safety for my generic collection adapter and wanted to bound the collection item generic type variable so the client code is restricted to types such as SPWeb, SPList, etc. Looking up the hierarchy, I see the type SPSecurableObject. Unfortunately, SharePoint library designers did not make SPSecurableObject visible to others and the next level up that hierarchy is the Object type. So I'm stuck with an unbounded generic type for the collection item in my generic version SharePoint collection adapter. Actually, what I really want is to ensure that the collection item type is consistent with the collection type. I haven't quite figure out if that's even possible to apply that kind of type parameter constraints in C#. Here is generic version of the SharePoint collection adapter (with the runtime type error leakages) implementation:

using System;
using System.Collections.Generic;
using Microsoft.SharePoint;

namespace SharePoint.Utility
{
    // I really wanted to apply constraint to TPart to SPSecurableObject
    public class SPCollectionAdapter<TPart, TCollection> : List<TPart> where TCollection : SPBaseCollection
    {
        private TCollection _listCol;

        public SPCollectionAdapter(TCollection listCol)
        {
            _listCol = listCol;
            Refresh();
        }

        private void Refresh()
        {
            this.Clear();
            this.Capacity = _listCol.Count;

            foreach (TPart item in _listCol)
            {
                this.Add(item);
            }
        }

    }
}

This allows me to write my F# code as follows:

open Microsoft.SharePoint
open SharePoint.Utility

let path="http://localhost/"
let collection = new SPSite(path)
let site = collection.RootWeb
let lists = SPCollectionAdapter<SPList,SPListCollection>(site.Lists)
Seq.iter (fun (x:SPList) -> printf "%s\n" x.Title) lists

Porting the Log Analysis Code to Haskell

2011-05-09T17:24:00.000-07:00

My coworker approached me the other day and ask what open source log analysis tools would I recommend. I personally do not have much experience with a general purpose open source log analysis tools so I would have probably recommended him to take a look at Splunk. Since I've recently written a customized log analysis software, I became curious and asked him what he intend to do with the log analysis software.

My coworker said that he needed to analyze Tibco EMS logs. Tibco EMS logs incoming messages in the order it receives. My coworker is interested in a set of related messages that is identified by the message ID tag. His particular issue is that the logs entries that he's interested in are interspersed with other log entries that he's not interested. He wanted a log file where the log entries are grouped by message id in historical order.

Once I understood his needs, I realize that he did not need the Splunk and that I could quickly adapt my F# log analysis software written in the previous blog post for his need. When I gave him the modified F# code, he asked me if I could port it to Linux. That threw me for a loop. I briefly entertained the idea of building a Mono system and compile F# on Mono but decided against it for now. I thought it would be easier to just port it to Haskell, which I already have on Linux.

Here's the ported Haskell log analysis software with modifications to work with Tibco log entries.


import Data.Time.Calendar
import Data.Time.LocalTime
import Data.Time.Parse
import List
import System.Environment

type Category = String
type Entry = [String]
type TimeStamp = (LocalTime,String)
type LogHeader = (TimeStamp, Category)

alphaTime = LocalTime (fromGregorian 2000 1 1) midnight 

data LogEntry = LogEntry (TimeStamp, String) [String]
                deriving (Show)

{- Grab label -}
categorize (_ : _ : label : _) = label
categorize words = ""

{- Grab timestamp -}
timestamp (date : time : _ )  = strptime "%Y-%m-%d %H:%M:%S" (date ++ " " ++ time)
timestamp words  = Nothing
           
{- header :: String -> (String, Maybe (LocalTime, String)) -}           
header line = (timestamp tokens, categorize tokens)    
    where tokens = words line

{- Concrete implementation of Tibco log parser -}    
logparser :: [String] -> LogHeader -> [String] -> [LogEntry] -> [LogEntry]
logparser (line : rest) xheader entry entries  = process (header line)    
    where process (Just (ts),label) = 
              logparser rest h [line] ((LogEntry xheader (reverse entry)):entries ) where h = (ts,label)
          process (Nothing,_) = logparser rest xheader (line : entry) entries

logparser [] xheader entry entries = reverse ((LogEntry xheader entry) : entries) 

{- Utility method  to pull items out of LogEntry -}
entry (LogEntry _ entries) = entries    
category (LogEntry (_,label) _) = label

{- comparator based on category -}
categorysort (LogEntry (_,a) _) (LogEntry (_,b) _) 
    | a > b = GT
    | a < b = LT
    | otherwise = EQ

parselog parser lines = parser lines ((alphaTime,".000"),"STARTFLAG") [] []
    
processlog = unlines
             . map (unlines . entry)
             . sortBy categorysort
             . (parselog logparser)
             . lines 

main = do (filename:_) <- getArgs
          contents <- readFile filename
          putStr (processlog contents)

Log Analysis with F#

2011-03-21T12:36:00.000-07:00

I am often pulled into investigative teams to resolve performance issues. In one particular instance, I was involved in troubleshooting a Java-based batch job that had experience performance issue after it migrated from an older database platform to a newer database platform. Typically in these performance related issues, I would analyze the logs to see if I can spot tell tale signs of performance issues. Some of these log files can range up to millions of lines of text. In this particular case, I received a log file with of almost 4 million lines of text. I do not want to wade through these log files by hand. In the past, I would have use a scripting language like perl or ruby to help parse these logs. But lately, I have leaned more towards F# to analyze log files. The following describes my experience with developing my log analysis software in F#.

The log files that I have received have sample entries with the following pattern:

02/04/11 21:15:55 xyz 123 CATEGORY_LABEL Lorem ipsum dolor sit amet 
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
    Aliquam varius mollis purus, vel molestie lorem pellentesque sed.

where CATEGORY_LABEL categorizes the jobs performed and each log entry always starts with a timestamp. Typically, multiple jobs are running at the same time so the log entries have data interspersed. To start this effort, I want to capture the timestamp information, the category label and the entire log entry. To model this, I created the following type to capture a log entry:


type LogEntry =
    {
        Timestamp : DateTime;
        Category  : string;
        Entry     : string list;
    }

I want to be able to easily access Timestamp and Category label information while retaining the entire log entry for that timestamp/category. I decided to model the log entry as a list of strings. I had hope to leverage list operations later on to perform filtering capability. One of the drawbacks to this model for log entry is if the log file had text that split across 2 lines.

The first problem is to extract the timestamp and the category information. To capture the timestamp information, I implemented the following functions:


let parsedate datestring = DateTime.TryParse(datestring)

let getTimestamp (words:string []) =
    if words.Length > 2 then
        let timestamp = sprintf "%s %s" words.[0] words.[1]
        match parsedate timestamp with
            | true, d -> Some(d)
            | false,_ -> None
    else None

I leveraged F#'s Option type to return either a valid timestamp or None if no timestamp are found. You can see later how I use this as a filter to determine if I'm at the start of a log entry or not. Here's the code to get the category label:

let getCategory (words:string []) =
    if words.Length > 4 then 
        let tokens = words.[4].Split[|':'|]
        tokens.[0]
    // Once in a while, there is log entry with no labels
    else ""

I know that the category label always is the 5th token, but once in a while the category label shows up in the log as CATEGORY_LABEL:Lorem, therefore I have to split the word with the token ":" to extract just the category label.

With these 2 functions, I can now build my getheader function which would extract the timestamp and category label:

    
// Get the timestamp and the job category     
let getHeader (line:string) =
    let words = line.Trim().Split[| ' ' |]
    let timestamp = getTimestamp words
    let category = getCategory words
    (timestamp,category)

I now have all the pieces to be able to build my log parser:


// Utility function to create log entry
let createLogEntry (timestamp,category)  entry =
    {Timestamp = timestamp;  Category=category;  Entry = List.rev entry}      
    
    
// Core parser engine to parse the log files
let rec logparser lines oldheader entry (acc:LogEntry list) =
    match lines with
    | line :: rest -> 
        // Check with we got new timestamp with this line
        let header = getHeader line
        match header with
        | (Some(ts),category) -> 
            // Found new timestamp,create log entry from the collected lines
            let logentry = createLogEntry oldheader (line::entry)
            //  Begin new log entry collections
            logparser rest (ts,category) [] (logentry::acc)
        | (None,_) -> 
            // Add new entry to line
            logparser rest oldheader (line::entry) acc
    // We're done with all line processing!
    | [] -> 
        let logentry = createLogEntry oldheader entry
        logentry :: acc |> List.rev

This log parser would recursively processed each line in the log file and build a list of LogEntry to return. When I find a header, I would begin a new LogEntry. Because I built the list using the :: (cons) operator, I need to reverse the list when I finish building the list. I would use the above parser engine as shown in the following code, which would return to me list of all log entries.

let parselog file parser =
    let lines = File.ReadAllLines(file)
    let past = DateTime.Now
    parser (Array.toList lines) (past,"") [] []

Now I have all the pieces to begin performing log analysis. I typically begin by chopping the log into smaller pieces. In the following example, I'm looking for a specific category on specific dates, one before the database migration and one after the database migration.

let (_,premigration) = DateTime.TryParse("03/11/2011")
let (_,postmigration) = DateTime.TryParse("03/14/2011")

// Extraction engine to pull logs related to specific job @ specific date
let extract targetdate label file processor =
    parselog file logparser
    |> List.filter (fun x -> x.Timestamp.Date.Equals(targetdate))
    |> List.filter (fun x -> x.Category.Trim().Equals(label))
    |> processor

// End log entry text to file
let send2file file entries=
    entries 
    |> List.map (fun x -> x.Entry)
    |> List.concat
    |> List.toArray
    |> writefile file

// smaller working file - premigration for JOB A
(send2file @"JOBA.premigration.log") |>
extract premigration.Date "JOBA" @"jobs.log" 

// smaller working file - postmigration for JOB A
(send2file @"JOBA.postmigration.log") |>
extract postmigration.Date "JOBA" @"jobs.log"

Here's another example usage where I wanted to grab clusters of log entries along the time dimension (e.g. unique sets of Timestamp,Category pairs).

let getEntryClusters targetdate infile outfile  =
    parselog infile logparser
    |> List.filter (fun x -> x.Timestamp.Date.Equals(targetdate))
    |> List.map (fun entry -> (entry.Timestamp,entry.Category))
    |> Set.ofList |> Set.toList
    |> List.map (fun (ts,category) -> sprintf "%s,%s" (ts.ToString()) category)
    |> List.toArray 
    |> writefile outfile

getEntryClusters postmigration.Date @"jobs.log" @"clusters.log"

The interactive capability of F# in Visual Studio made building this log analysis tool a lot easier than I expected. While I can do similar interactive work with Ruby's irb, or Python's interactive mode, Visual Studio and F# just makes it feel much more productive than either of Ruby or Python's interactive environment. If I had to analyze another log file with a different format, I can certainly reuse my code and maybe just changed the logparser implementation. Indeed, just a few days after later, I was able to apply this code to look into some Tibco logs with minimal amount of changes.

Exploring Java AES encryption algorithm with Clojure

2010-08-30T09:37:00.000-07:00

Encryption is one of those library that I use infrequently. It seems that every time I need to work with some encryption algorithm, it passes memory expiration date of my last implementation usage of some encryption algorithm. Recently, I had to implement some password encryption tool in Java and again, I had to revisit Java’s encryption library. In the past, for exploring unfamiliar libraries, I would normally write some code sprinkled with print statements, compile it and run the compiled code and adjust my code afterwards. But in the past couple years, I’ve become a big fan of REPL development environment for purposes of library exploration. In the .NET environment, I would use F# Interactive, Ruby & Python have their own REPL environment. For Java, I could have picked either Groovy or Clojure. I’ve scripted Groovy in the past and certainly liked the shorthand expressions to a lot of the Java code. However, I have heard a lot of positive blog posts about Clojure such that I wanted to try it out.

I never had the chance to program in Lisp in the past. But I have read some of Paul Graham’s articles which seems to make Lisp a programmer’s great secret weapon in becoming a better than average programmer. So I figure Clojure can get my feet wet with another variant of Lisp and help me accomplish my day job goals at the same time. The hardest part about learning Clojure was learning the API. The program structure was not hard to figure out. I used an RPN based HP 11C calculator while in college and Clojure program structure reminds me a lot of working with RPN calculators (albeit with a lot more parenthesis). Once I got the hang of the basic Clojure syntax, it became a great environment to work in. I would define a function, run the code and then interactively explore properties or call methods. After exploring in Clojure, it became fairly trivial task to translate that to the Java code.

While it was certainly fun to work in Clojure, I'm not sure I can substantiate Paul Graham's claim that knowing Lisp makes you a better than average programmer. Maybe it's more of the concept that a polyglot programmer generally makes a better programmer simply because the programmer that goes and learns multiple programming languages has a self driven desire to become a better programmer and therefore becomes a better programmer. I'll leave that discussion to the programmer philosophers out there and return to the more pragmmatic code construction.

Here’s the prototype AES encryption code in Clojure:

(import (javax.crypto KeyGenerator SecretKey Cipher))
(import (javax.crypto.spec SecretKeySpec))
(import (java.io File FileOutputStream DataInputStream FileInputStream))
(import (java.util Properties))
(import (org.apache.commons.codec.binary Base64))

(def msg "Hello encryption world!")
(defn encode-base64 [raw] (. (new Base64) encode raw))
(defn decode-base64 [coded] (. (new Base64) decode coded))

(def aes (. KeyGenerator getInstance "AES"))
(def cipher (. Cipher getInstance "AES"))
(def encrypt (. Cipher ENCRYPT_MODE))
(def decrypt (. Cipher DECRYPT_MODE))

(defn writekey [rawkey filename]     
    ( let [out (new FileOutputStream (new File filename))]
          (do (. out write rawkey)
              (. out close))))
    
(defn readkey [filename]
    (let [file (new File filename)
          rawkey (byte-array (. file length))
          in  (new DataInputStream (new FileInputStream file))]
          (do (. in readFully rawkey)
              (. in close)
              rawkey
          )))
          
(defn get-propfile [filename]   
    (let [prop (new Properties)]
        (do (. prop load (new FileInputStream filename)))
        prop))
    

(defn genkey [keygen] 
    (do (. keygen init  128)
        (. (. keygen generateKey ) getEncoded)
    )
)    
    
(defn do-encrypt [rawkey plaintext]
    (let [cipher (. Cipher getInstance "AES")]
        (do (. cipher init encrypt (new SecretKeySpec rawkey "AES"))
            (. cipher doFinal (. plaintext getBytes)))))
    
(defn do-decrypt [rawkey ciphertext]
    (let [cipher (. Cipher getInstance "AES")]
        (do (. cipher init  decrypt (new SecretKeySpec rawkey "AES"))
            (new String(. cipher doFinal ciphertext)))))
            
            
(defn get-password [key rawkey filename]
    (let [ props (get-propfile filename)
           coded (. props getProperty key)
           cipher (decode-base64 coded)]
         (do (do-decrypt rawkey cipher))))
         
(comment "Example usage"
(get-password "jms" (readkey "test.key") "data.out")
)

F# FileInfo, DirectoryInfo and DriveInfo

2010-05-14T15:12:00.000-07:00

Recent changes in my day job have sidetracked me from doing much development or working with F#. However, to prevent myself from getting rusty with F# development, I decided to pick up the book Visual C# 2010 Recipes by Allen Jones, Adam Freeman, Matthew MacDonald, and Rakesh Rajan and randomly work through some of the recipes in F#. I've also incorporated Alex Gorbatchev's Syntax Highligher along with Steve Gilham's F# brush in this blog so source code syntax coloring will start to look very different from before.

Here is a translation of Recipe 5.1 to F# 2.0:

(*  Recipe 5.1. Retrieve Information About a File, Directory or Drive *)
// An interesting aspect when writing this recipe was trying to write
// the display function.  A StackOverflow entry help me to understand
// the printf format string.
// http://stackoverflow.com/questions/2162081/type-of-printfn-in-f-static-vs-dynamic-string
open System
open System.IO

(* Having some fun with pipeline operators... *)
let display  (stuff : (string * string) list) =
    List.iter (fun (fmt,text) ->  Printf.TextWriterFormat unit>(fmt) |> printfn  <| text) stuff

let displayFile (file:FileInfo) =
    [("File created: %s",file.CreationTime.ToString());
     ("File last updated: %s",file.LastWriteTime.ToString());
     ("File last accessed: %s",file.LastAccessTime.ToString());
     ("File size (bytes): %s",file.Length.ToString());
     ("File attribute list: %s",file.Attributes.ToString());]
    |> display
    
let displayDirectory  (dir:DirectoryInfo) =
    [("Directory created: %s ",dir.CreationTime.ToString());
     ("Directory last updated: %s",dir.LastWriteTime.ToString());
     ("Directory last accessed: %s",dir.LastAccessTime.ToString());
     ("Directory attribute list: %s",dir.Attributes.ToString());
     ("Directory contains: %s files",dir.GetFiles().Length.ToString());]
    |> display

let displayDrive (drive:DriveInfo) =
    [("Drive type: %s", drive.DriveType.ToString());
     ("Drive format: %s", drive.DriveFormat.ToString());
     ("Drive free space: %s", drive.AvailableFreeSpace.ToString());]
    |> display
    

let args = fsi.CommandLineArgs
if args.Length = 1 then
    printfn "Please supply a filename."
    exit 1
    
let file = new FileInfo(args.[1])
if file.Exists then
    displayFile file

    
let dir = file.Directory
[("Checking directory: %s",dir.Name);
 ("In directory: %s",dir.Parent.Name);
 ("Directory exists : %s",dir.Exists.ToString());]
|> display 

if dir.Exists then
    displayDirectory dir
    
let drv = new DriveInfo(file.FullName)

[("Drive: %s",drv.Name);] |> display
if drv.IsReady then
    displayDrive drv
    
Environment.NewLine |> Console.WriteLine
"Main method completed. Press Enter" |> printfn "%s"
Console.ReadLine()

F# and WCF

2009-06-11T22:29:00.001-07:00

I recently had to implement some self hosted workflows on WF that leverages WCF for inter-process communication. I’ve found the book Learning WCF by Michele Bustamante helpful for learning and implementing WCF parts of the code and Pro WF by Bruce Bukovics useful for implementing the workflows. I became curious on how to implement WCF in F#. I suspect that WCF services in F# is probably one more likely scenarios for me to introduce F# usage in the corporate environment.

For the following sample code, I took the last example with DataGrid and stripped out the portion that retrieves a list of Person from the database and implemented it as a WCF hosted on a separate executable. There are many other blogs on F# and WCF including those by Ray Vernagus, Nick Holmes and Ted Neward. This blogs were immensely helpful in aiding me to build my own example.

The blog entry by Ray Vernagus seemed to indicate that I needed to define my data contract for Person record with DataContract attribute. It did not seem like that is necessary in this simple scenario. However, when I ran my example client code, I did get the following error:

stdin(0,1): error FS0082: Could not resolve this reference. Could not locate the assembly "PersonService.XmlSerializers.dll". Check to make sure the assembly exists on disk. If this reference is required by your code, you may get compilation errors. (Code=MSB3245)
stopped due to error

The client code still works and subsequent runs does not generate this error. I was unable to track down what caused this error message and what impact it has on the application. Even after I added the DataContract attributes to Person type, I still get the same error message. However, I did not see any impact to the client application due to this error. I got this error with version 1.9.6.2 of the F# compiler. My next step would be to try this out with VS2010 beta version of F# compiler.

Here’s the WCF server code that serves up a list of Person:


#light

namespace WCF.Test

open System
open System.Data.Common
open System.Data.Sql
open System.Data.SqlClient
open System.ServiceModel
open System.Runtime.Serialization

type Person = 
    {FirstName:string; 
     LastName:string; 
     Email:string; 
     PhoneNumber:string}

module DB = 
    let connString =  @"Data Source=.\SQLEXPRESS;Initial Catalog=AdventureWorks;Integrated Security=True;"
    let conn = new SqlConnection(connString)
    let query () = 
        seq { use conn = new SqlConnection(connString)
              do conn.Open()
              use comm = new SqlCommand("SELECT top 50 * FROM Person.Contact",conn)
              use reader = comm.ExecuteReader()
              while reader.Read() do
                 yield ({FirstName = reader.GetString 3;
                         LastName = reader.GetString 5;
                         Email = reader.GetString 7;
                         PhoneNumber = reader.GetString 9}) }
  
[<ServiceContract()>]
type IPersonService = interface
   [<OperationContract()>]
   abstract GetPersons: unit -> Person array
end

[<ServiceBehavior(Name="PersonService",InstanceContextMode=InstanceContextMode.Single)>]
type PersonService() =
   interface IPersonService with
      member v.GetPersons () = 
          Console.WriteLine("Retrieving people list...")      
          DB.query() |> Seq.to_array
        

do
    Console.WriteLine("PersonService")
    let serviceType = typeof<PersonService>
    let address = new Uri("http://localhost:28888/PersonService")
    let host = new ServiceHost(serviceType,[|address|])
    host.Open()
    Console.WriteLine("Press <ENTER> to terminate the host application")
    Console.ReadLine() |> ignore
    host.Close()

Here’s the configuration file for the WCF service:


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <!-- here is the base address of our service -->
  <appSettings>
    <add key ="baseAddress" value="http://localhost:28888/PersonService"/>
  </appSettings>
  <system.serviceModel>
    <services>
      <service name="WCF.Test.PersonService" behaviorConfiguration="PersonServiceBehaviors">
        <endpoint address="http://localhost:28888/PersonService"
                  binding="basicHttpBinding"
                  contract="WCF.Test.IPersonService"/>
        <endpoint contract="IMetadataExchange" binding="mexHttpBinding" address="mex" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="PersonServiceBehaviors" >
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug httpHelpPageEnabled="true"
                        includeExceptionDetailInFaults="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Here’s the client code:


#light
#I @"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0"
#I @"C:\WINNT\Microsoft.NET\Framework\v2.0.50727"
#r @"WindowsBase.dll"
#r @"PresentationCore.dll"
#r @"PresentationFramework.dll"
#r @"C:\Program Files\WPF Toolkit\v3.5.40320.1\WPFToolkit.dll"
#r @"c:\dev\webservice\PersonService.dll"  // Generated with wsdl tool

open Microsoft.Windows.Controls
open System
open System.Windows
open System.Windows.Controls


let service = new PersonService()
let persons = service.GetPersons()
            
let win = new Window(Title="Test DataGrid w/WCF")

let datagrid = DataGrid()
datagrid.HeadersVisibility <- DataGridHeadersVisibility.Column
datagrid.ItemsSource <- persons

 
win.Content <- new ScrollViewer(Content=datagrid)
win.Show()

Exploring WPF Toolkit's DataGrid with F#

2009-06-05T16:52:00.000-07:00

I recently received an invitation from Martin Szummer to take a look at the DataGrid control that's part of the WPF Toolkit. That got me curious and I quickly mocked up some code to start exploring the DataGrid with some F# script. Here's is the F# script that I'm using to explore this control:


#light
#I @"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0"
#r @"WindowsBase.dll"
#r @"PresentationCore.dll"
#r @"PresentationFramework.dll"
#r "C:\Program Files\WPF Toolkit\v3.5.40320.1\WPFToolkit.dll"

open Microsoft.Windows.Controls
open System
open System.Data.Common
open System.Data.Sql
open System.Data.SqlClient
open System.Windows
open System.Windows.Controls

let connString =  @"Data Source=.\SQLEXPRESS;Initial Catalog=AdventureWorks;Integrated Security=True;"

let conn = new SqlConnection(connString)

type Person = 
    {FirstName:string; LastName:string; Email:string; PhoneNumber:string}


let query () = 
    seq { use conn = new SqlConnection(connString)
          do conn.Open()
          use comm = new SqlCommand("SELECT top 100 *  FROM Person.Contact",conn)
          use reader = comm.ExecuteReader()
          while reader.Read() do
             yield ({FirstName = reader.GetString 3;
                     LastName = reader.GetString 5;
                     Email = reader.GetString 7;
                     PhoneNumber = reader.GetString 9}) }
             
let win = new Window(Title="Test DataGrid")


let datagrid = DataGrid()
datagrid.HeadersVisibility <- DataGridHeadersVisibility.Column
datagrid.ItemsSource <- query() |> Seq.to_array

win.Content <- new ScrollViewer(Content=datagrid)
win.Show()

Silverlight with F#: Handling Keyboard Input

2009-04-15T19:29:00.001-07:00

Recipe 3-15 of the book Silverlight 2 Recipes illustrates handling keyboard input. The code is suppose to allow you to move a spinning ball with the directional keys. When I initially implement it, I ran into some issues in trying to capture keyboard input. As I understand keyboard events from reading Chapter 4 of the book Pro Silverlight 2 in C# 2008, they are suppose to bubble up to the top level control. However, when I attach code to the KeyUp event to the Canvas control, nothing happened. I eventually realized that I did not know where is the input focus when I generate the keyboard event. The only control that I am sure will receive the keyboard event is at the top level control. In my scaffolding code for Silverlight, I had MyPage added as a children of a StackPanel that I called rootPanel, so even my custom UserControl was not getting the keyboard events. For this particular example, I had to get rid of the rootPanel and then I could capture the keyboard input from my custom UserControl.

Just to verify that keyboard events do bubble up, I mocked up another small code where I embed a TextBox deep inside a visual hierarchy. When I set my focus to the TextBox and press a key, all the containing controls were able to receive the keyboard events; thereby validating, for my benefit, the fact that keyboard events bubble up.

The other thing to point out is in the last blog entry, I did not properly dispose the created StreamReader object. In this post, I change the let binding to StreamReader to use binding to resolve the problem.

Here’s the working F# code along with the XAML code :


#light
namespace SilverLightFSharp

open System
open System.Resources
open System.Reflection
open System.IO
open System.Windows
open System.Windows.Browser
open System.Windows.Controls
open System.Windows.Markup
open System.Windows.Input
open System.Windows.Media
open System.Windows.Media.Animation
open System.Windows.Shapes
open List


// Recipe 3-15 of the Silverlight 2 Recipes book
type MyPage = class
    inherit UserControl
    
    new () as this = {} then
        
        let xamlControls = 
            let assembly = Assembly.GetExecutingAssembly();
            use sr = new StreamReader(assembly.GetManifestResourceStream("page.xaml"));
            sr.ReadToEnd()

        // Load xaml dynamically        
        let canvas = XamlReader.Load(xamlControls) :?>  Canvas
        let clicktoplay = canvas.FindName("ClickToPlay") :?> Border
        let ball = canvas.FindName("RadioactiveBall") :?> Ellipse
        let welcomeMessage = canvas.FindName("WelcomeMessage") :?> Border
        let gameMessage = canvas.FindName("GameMessage") :?> TextBlock

        let storyboard = canvas.Resources.["SpinGameBallStoryboard"] :?> Storyboard

        this.Width <- 600.0
        this.Height <- 400.0
        this.Content <- canvas
        
       
        let moveSpeed = 10.0
        
        let getPosition (b:Ellipse) = 
            ((b.GetValue(Canvas.LeftProperty) :?> double), (b.GetValue(Canvas.TopProperty) :?> double))
         
        let draw (x,y) =
            (Canvas.LeftProperty,x) |> ball.SetValue
            (Canvas.TopProperty,y) |> ball.SetValue
            
        
        clicktoplay.MouseLeftButtonDown.Add(fun e ->
            clicktoplay.Visibility <- Visibility.Collapsed
            //welcomeMessage.Visibility <- Visibility.Collapsed
            gameMessage.Text <- "Left mouse button down!"
            ball.Visibility <- Visibility.Visible
            this.IsEnabled <- true
            storyboard.Begin())
            
        let leftborder = ball.Width * 0.25
        let rightborder = this.Width - ball.Width*1.25
        let topborder = ball.Height*0.25
        let bottomborder = this.Height - ball.Height*1.25
 
        let moveLeft (x,y) = 
           (max [x-moveSpeed;leftborder],y)
           
        let moveRight (x,y) = 
            (min [x+moveSpeed;rightborder],y)
            
        let moveUp (x,y) = 
            (x,max [y-moveSpeed;topborder])
            
        let moveDown (x,y) = 
            (x,min [y+moveSpeed;bottomborder])
               
        this.KeyUp.Add(fun e ->
            let pt = getPosition ball
            let newpos = match (e.Key) with
                         | Key.Right -> moveRight pt
                         | Key.Left ->  moveLeft pt
                         | Key.Up -> moveUp pt
                         | Key.Down -> moveDown pt
                         | _ -> pt
            gameMessage.Text <- sprintf "Ball at  %4.1f %4.1f " (fst newpos)  (snd newpos)
            draw newpos
            )
               
end

type ErrorPage = class
    inherit UserControl
    
    new (msg:string ) as this = {} then
    
        let textarea = new TextBlock(Text=msg,
                                     TextWrapping=TextWrapping.Wrap,
                                     Margin=new Thickness(4.0,4.0,4.0,4.0))
    
        let sp = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                Margin=new Thickness(8.0,8.0,10.0,8.0))
        sp.Children.Add(textarea)                                

        base.Width <- 600.0
        base.Height <- 400.0
        base.Content <- sp
end    


type MyApp = class
    inherit Application

    new () as this = {} then
        this.Startup.Add(fun _ ->  this.RootVisual <- new MyPage())
end



<Canvas 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"     
        x:Name="GameCanvas" >
        <Canvas.Resources>
            <RadialGradientBrush x:Key="IceBrush">
                <GradientStop Color="#FFFFFFFF"/>
                <GradientStop Color="#FF6F74AB" Offset="1"/>
            </RadialGradientBrush>
            <LinearGradientBrush x:Key="MessageBorderBrush" EndPoint="0.501999974250793,1"
                             StartPoint="0.497999995946884,0">
                <GradientStop Color="#FF000000"/>
                <GradientStop Color="#33FFFFFF" Offset="1"/>
            </LinearGradientBrush>
            <Storyboard x:Name="SpinGameBallStoryboard" x:Key="SpinGameBallStoryboard" RepeatBehavior="Forever">
                <DoubleAnimationUsingKeyFrames BeginTime="00:00:00" 
             Storyboard.TargetName="RadioactiveBall" 
             Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[2].(RotateTransform.Angle)">
                    <SplineDoubleKeyFrame KeyTime="00:00:00" Value="0"/>
                    <SplineDoubleKeyFrame KeyTime="00:00:02" Value="360">
                        <SplineDoubleKeyFrame.KeySpline>
                            <KeySpline ControlPoint1="0,0" ControlPoint2="1,1"/>
                        </SplineDoubleKeyFrame.KeySpline>
                    </SplineDoubleKeyFrame>
                </DoubleAnimationUsingKeyFrames>
            </Storyboard>
        </Canvas.Resources>

        <Canvas.Background>
            <RadialGradientBrush>
                <GradientStop Color="#FFFFFFFF"/>
                <GradientStop Color="#FFB3BBE8" Offset="1"/>
            </RadialGradientBrush>
        </Canvas.Background>
        <Border Background="{StaticResource MessageBorderBrush}" Height="Auto"
          x:Name="WelcomeMessage" Width="Auto" Canvas.Left="173" Canvas.Top="119" 
          CornerRadius="10,10,10,10">
            <TextBlock x:Name="GameMessage" Height="Auto" Width="Auto" FontFamily="Comic Sans MS" 
           FontSize="24" Text="Welcome to !" TextWrapping="Wrap" 
           Padding="2,2,2,2" Foreground="#FF044FB5" Margin="2,2,2,2"/>
        </Border>
        <Border x:Name="ClickToPlay" Height="77" Width="169" Canvas.Top="178" 
          Canvas.Left="207" CornerRadius="10,10,10,10" Background=
          "{StaticResource MessageBorderBrush}" Margin="0,0,0,0" >
            <TextBlock Height="Auto" Width="Auto" FontSize="24" Text="Click to Play" 
          TextWrapping="Wrap" Margin="4,10,4,4" Padding="2,2,2,2" Foreground="#FF044FB5" 
                       HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
        </Border>
        <Ellipse Height="50" Width="50" Canvas.Left="259" Canvas.Top="168.879" 
          Stroke="#FF000000" Visibility="Collapsed" x:Name="RadioactiveBall" 
          RenderTransformOrigin="0.5,0.5">
            <Ellipse.RenderTransform>
                <TransformGroup>
                    <ScaleTransform/>
                    <SkewTransform/>
                    <RotateTransform/>
                    <TranslateTransform/>
                </TransformGroup>
            </Ellipse.RenderTransform>
            <Ellipse.Fill>
                <LinearGradientBrush EndPoint="0.959999978542328,0.0219999998807907" 
              StartPoint="0.0199999995529652,1.06200003623962">
                    <GradientStop Color="#FFAED4B2"/>
                    <GradientStop Color="#FFAED4B2" Offset="1"/>
                    <GradientStop Color="#FF4A9B53" Offset="0.179"/>
                    <GradientStop Color="#FF4A9B53" Offset="0.75"/>
                    <GradientStop Color="#FF98BD9D" Offset="0.4869999885559082"/>
                </LinearGradientBrush>
            </Ellipse.Fill>
        </Ellipse>
        <Path Height="399" Width="25" Stretch="Fill" Stroke="#FF000000" 
         Data="M0,0 L24,10 L16,18 L21,29 L11,38 L21,54 L14,63 L19,84 L6,90 L15,103 L9,119 L15,136 L9,145 L18,155 L7,165 L23,178 L7,184 L19,200 L10,211 L17,221 L9,234 L17,240 L9,255 L15,264 L9,275 L17,286 L7,293 L17,304 L9,313 L19,329 L10,337 L15,345 L12,361 L13,371 L8,382 L12,389 L0,398 z" Canvas.Top="-0.5" Canvas.Left="-0.5" Fill="{StaticResource IceBrush}" x:Name="LeftIceCaveWall"/>
        <Path Height="30" Width="598" Canvas.Left="0.5" Canvas.Top="368.5" 
         Fill="{StaticResource IceBrush}" Stretch="Fill" Stroke="#FF000000" 
         Data="M1,397 L20,382 L30,387 L47,381 L63,388 L76,380 L90,385 L100,388 L110,376 L115,384 L127,378 L140,388 L155,381 L166,388 L179,378 L190,386 L206,375 L218,388 L230,372 L235,382 L249,376 L268,386 L284,375 L295,386 L309,374 L321,383 L334,369 L345,381 L357,382 L368,378 L378,391 L392,382 L412,388 L441,380 L456,390 L478,383 L494,389 L501,382 L515,390 L524,375 L534,386 L541,373 L553,369 L567,376 L576,381 L598,398 z" x:Name="IceCaveWallFloor"/>
        <Path Height="398" Width="40" Canvas.Left="558.5" Canvas.Top="-0.5" 
         Fill="{StaticResource IceBrush}" Stretch="Fill" Stroke="#FF000000" 
         Data="M598,397 L578,389 L572,367 L559,355 L570,339 L559,324 L574,313 L581,294 L576,281 L584,262 L584,243 L573,229 L586,217 L575,206 L584,192 L567,182 L587,161 L576,152 L583,139 L570,131 L578,124 L568,103 L581,76 L568,56 L577,49 L573,20 L584,12 L597,0 z" x:Name="RightIceCaveWall"/>
        <Path Height="53" Width="596" Canvas.Left="0.5" Canvas.Top="-0.5" 
         Fill="{StaticResource IceBrush}" Stretch="Fill" Stroke="#FF000000" 
         Data="M1,1 L21,19 L34,5 L43,13 L54,11 L65,8 L77,8 L86,11 L106,11 L115,8 L126,8 L138,12 L156,10 L171,8 L184,13 L197,7 L217,14 L231,8 L252,13 L259,8 L283,13 L295,8 L327,12 L336,18 L353,11 L365,30 L375,10 L393,16 L418,10 L437,15 L451,5 L468,17 L483,6 L501,18 L514,32 L526,19 L544,31 L556,26 L596,19 L596,0 z" x:Name="IceCaveCeiling"/>
</Canvas>

Silverlight with F#: Managing embedded resources

2009-04-09T18:19:00.001-07:00

One of my blog reader asked why I inline XAML instead of putting it into a separate file and hooking up the variables manually in F#. My answer was laziness: I did not spend the time to figure out how. (If you subscribe to Larry Wall’s philosophy, laziness is a virtue …) Well, that question prompted me to look into how to externalize the xaml file and load it in. This dovetailed nicely with recipe 2.14 of the book Silverlight 2 Recipes, which shows how to load embedded resources. I put the xaml code in a separate file called page.xaml and added the following compiler flag:

 --resource page.xaml

Here’s the xaml file:


<Canvas 
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"    
    x:Name="LayoutRoot" Background="White">
    <TextBlock>Hi There Reader</TextBlock>
    <TextBlock Canvas.Left="20" Canvas.Top="20">Hi There</TextBlock>
    <TextBlock Canvas.Left="40"
     Canvas.Top="40">Silverlight</TextBlock>
    <TextBlock Canvas.Left="60" Canvas.Top="60">
     Silverlight</TextBlock>
    <TextBlock Canvas.Left="80" Canvas.Top="80">
     Silverlight</TextBlock>
    <TextBlock Canvas.Left="100" Canvas.Top="100">
     Silverlight</TextBlock>
</Canvas>

Here's the code that loads the xaml file and hook the control with a variable:


#light
namespace SilverLightFSharp

open System
open System.Resources
open System.Reflection
open System.IO
open System.Windows
open System.Windows.Browser
open System.Windows.Controls
open System.Windows.Markup
open List

// Recipe 2-14 and XAML from Recipe 3-3 of the Silverlight 2 Recipes book
type MyPage() = class
    inherit UserControl()
    
    do
       
        let assembly = Assembly.GetExecutingAssembly();
        let sr = new StreamReader(assembly.GetManifestResourceStream("page.xaml"));
        let xamlControls = sr.ReadToEnd()

        // Load xaml dynamically        
        let canvas = XamlReader.Load(xamlControls) :?> Canvas

       
        base.Width <- 400.0
        base.Height <- 300.0
        base.Content <- canvas
end

type ErrorPage = class
    inherit UserControl
    
    new (msg:string ) as this = {} then
    
        let textarea = new TextBlock(Text=msg,
                                     TextWrapping=TextWrapping.Wrap,
                                     Margin=new Thickness(4.0,4.0,4.0,4.0))
    
        let sp = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                Margin=new Thickness(8.0,8.0,10.0,8.0))
        sp.Children.Add(textarea)                                

        base.Width <- 600.0
        base.Height <- 1000.0
        base.Content <- sp
end    


type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ -> 
            let rootPanel = new StackPanel()
            try 
                this.RootVisual <- rootPanel
                rootPanel.Children.Add(new MyPage())
            with _ as e ->
               let msg = e.Message + e.StackTrace
               rootPanel.Children.Clear()
               rootPanel.Children.Add(new ErrorPage(msg)))

        this.UnhandledException.Add(fun args ->
           args.Handled <- true
           try
               let msg = args.ExceptionObject.Message + args.ExceptionObject.StackTrace
               let errmsg = msg.Replace('"','\'').Replace("\r\n",@"\n") 
               "throw new Error(\"Unhandled error in Silverlight 2 Application " + msg + "\");"
               |> HtmlPage.Window.Eval |> ignore
           with _  -> HtmlPage.Window.Eval("throw new Error(\"Custom Error!\");") |> ignore)
end

Silverlight with F#: Animation via XAML (revisited)

2009-04-01T19:08:00.001-07:00

I should have took the time to read Matthew MacDonald’s book Pro Silverlight 2 in C# 2008 before I started tackling recipe 2.11 in the book Silverlight 2 Recipes. The code I created in the last blog post was made more complex due to my poor workaround to extracting the Storyboard object from XAML. After reading chapter 2 of the book Pro Silverlight 2 in C# 2008, it was obvious that in order to extract the Storyboard object from XAML, all I had to do was add the Key attribute to the Storyboard markup and add the Storyboard markup to the Grid.Resources property.

In addition, I’m reading through Chapter 13 of Don Syme’s book Expert F# trying to understand more how concurrency works with F#. I decided to try to replicate the Iterative Worker example in the book, replacing the simple BackgroundWorker example in recipe 2.11.

Here is the revised code with Storyboard as part of the resources of the Grid object and the reworked background worker code.


#light
namespace SilverLightFSharp

open System
open System.ComponentModel
open System.ServiceModel
open System.Windows
open System.Windows.Browser
open System.Windows.Controls
open System.Windows.Markup
open System.Windows.Media
open System.Windows.Media.Animation
open System.Windows.Shapes
open List

// SimulateBackgroundWorker modelled after
// IterativeBackgroundWorker example from Chapter 13 of Expert F#
type SimulateBackgroundWorker<'a>(delay:int, numIterations:int) =
    let worker = new BackgroundWorker(WorkerReportsProgress=true,
                                      WorkerSupportsCancellation=true)
    let triggerCompleted,completed = Event.create()
    let triggerError    ,error     = Event.create()
    let triggerCancelled,cancelled = Event.create()
    let triggerProgress ,progress  = Event.create()
   
    do worker.DoWork.Add(fun args ->
        let rec iterate i =
            if worker.CancellationPending then
                args.Cancel <- true
            elif i < numIterations then
                System.Threading.Thread.Sleep(delay)
                
                // Report the percentage computation
                let percent = int((float (i+1)/float numIterations) * 100.0)
                do worker.ReportProgress(percent)
                iterate (i+1)
            else ()
        iterate 0)

    do worker.RunWorkerCompleted.Add(fun args ->
        if   args.Cancelled    then triggerCancelled()
        elif args.Error<> null then triggerError args.Error      
        else triggerCompleted())

    do worker.ProgressChanged.Add(fun args ->
        triggerProgress(args.ProgressPercentage))

    member x.WorkerCompleted = completed             
    member x.WorkerCancelled = cancelled
    member x.WorkerError     = error
    member x.ProgressChanged = progress
    
    // Delegate the remaining memebers to the underlying worker
    member x.RunWorkerAsync() = worker.RunWorkerAsync()
    member x.CancelAsync()    = worker.CancelAsync()
    member x.IsBusy = worker.IsBusy
              
              


// Recipe 2-11 from Silverlight 2 Recipes book
// Using XAML to configure the animation
type MyPage() = class
    inherit UserControl()
    
    do
        // added x:Key='AnimateStatusEllipse' to Storyboard
        let xamlControls = 
         "<Grid 
              xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
              xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
          x:Name='LayoutRoot' Background='#FFFFFFFF'>
          <Grid.Resources>
            <Storyboard x:Name='AnimateStatusEllipse' x:Key='AnimateStatusEllipse'>
              <ColorAnimationUsingKeyFrames BeginTime='00:00:00' Storyboard.TargetName='StatusEllipse' 
                   Storyboard.TargetProperty='(Shape.Fill).(SolidColorBrush.Color)'>
                <SplineColorKeyFrame KeyTime='00:00:00' Value='#FF008000'/>
                <SplineColorKeyFrame KeyTime='00:00:01.5000000' Value='#FFFFFF00'/>
                <SplineColorKeyFrame KeyTime='00:00:03' Value='#FF008000'/>
                <SplineColorKeyFrame KeyTime='00:00:04.5000000' Value='#FF008000'/>
                <SplineColorKeyFrame KeyTime='00:00:06' Value='#FFFFFF00'/>
                <SplineColorKeyFrame KeyTime='00:00:07.5000000' Value='#FF008000'/>
              </ColorAnimationUsingKeyFrames>
              <DoubleAnimationUsingKeyFrames BeginTime='00:00:00' Storyboard.TargetName='StatusEllipse' 
                Storyboard.TargetProperty='(UIElement.Opacity)'>
                <SplineDoubleKeyFrame KeyTime='00:00:00' Value='0.7'/>
                <SplineDoubleKeyFrame KeyTime='00:00:01.5000000' Value='0.5'/>
                <SplineDoubleKeyFrame KeyTime='00:00:03' Value='0.5'/>
                <SplineDoubleKeyFrame KeyTime='00:00:04.5000000' Value='0.7'/>
                <SplineDoubleKeyFrame KeyTime='00:00:06' Value='0.5'/>
                <SplineDoubleKeyFrame KeyTime='00:00:07.5000000' Value='0.5'/>
              </DoubleAnimationUsingKeyFrames>
              <DoubleAnimationUsingKeyFrames BeginTime='00:00:00' Storyboard.TargetName='StatusEllipse' 
                   Storyboard.TargetProperty='(UIElement.RenderTransform).(TransformGroup.Children)[1].(SkewTransform.AngleX)'>
                <SplineDoubleKeyFrame KeyTime='00:00:00' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:01.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:03' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:04.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:06' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:07.5000000' Value='0'/>
              </DoubleAnimationUsingKeyFrames>
              <DoubleAnimationUsingKeyFrames BeginTime='00:00:00' Storyboard.TargetName='StatusEllipse' 
                   Storyboard.TargetProperty='(UIElement.RenderTransform).(TransformGroup.Children)[1].(SkewTransform.AngleY)'>
                <SplineDoubleKeyFrame KeyTime='00:00:00' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:01.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:03' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:04.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:06' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:07.5000000' Value='0'/>
              </DoubleAnimationUsingKeyFrames>
            </Storyboard>
          </Grid.Resources>
            <Grid.ColumnDefinitions>
              <ColumnDefinition Width='0.068*'/>
              <ColumnDefinition Width='0.438*'/>
              <ColumnDefinition Width='0.495*'/>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
              <RowDefinition Height='0.08*'/>
              <RowDefinition Height='0.217*'/>
              <RowDefinition Height='0.61*'/>
              <RowDefinition Height='0.093*'/>
            </Grid.RowDefinitions>
            <Button HorizontalAlignment='Stretch' Margin='5,8,5,8' VerticalAlignment='Stretch' 
                Grid.Column='1' Grid.Row='1' Content='Save Form Data'/>
            <StackPanel HorizontalAlignment='Stretch' Margin='4.8270001411438,8,6.19799995422363,8' 
                Grid.Column='1' Grid.Row='2'>
              <TextBlock Height='Auto' Width='Auto' Text='Work Results Appear Below' TextWrapping='Wrap' Margin='4,4,4,4'/>
              <TextBox Height='103' Width='Auto' Text='' TextWrapping='Wrap' Margin='4,4,4,4' x:Name='WorkResultsTextData'/>
            </StackPanel>
            <Button HorizontalAlignment='Stretch' Margin='12,8,8,8' VerticalAlignment='Stretch' Grid.Column='2' Grid.Row='1' Content='Load Form Data'/>
            <Button HorizontalAlignment='Stretch' Margin='10,2,8,6' VerticalAlignment='Stretch' Grid.Column='1' Grid.Row='3' Content='Kick Off Work' x:Name='DoWorkButton'/>
            <Border Grid.Column='2' Grid.Row='2' Grid.RowSpan='2' CornerRadius='10,10,10,10' Margin='1.80200004577637,2,2,2'>
              <Border.Background>
                <LinearGradientBrush EndPoint='0.560000002384186,0.00300000002607703' StartPoint='0.439999997615814,0.996999979019165'>
                  <GradientStop Color='#FF586C57'/>
                  <GradientStop Color='#FFA3BDA3' Offset='0.536'/>
                  <GradientStop Color='#FF586C57' Offset='0.968999981880188'/>
                </LinearGradientBrush>
              </Border.Background>
              <StackPanel Margin='4,4,4,4'  x:Name='FormData'>
                <TextBlock Height='Auto' Width='Auto' Text='First Name:' TextWrapping='Wrap' Margin='2,2,2,0'/>
                <TextBox Height='Auto' Width='Auto' Text='' TextWrapping='Wrap' x:Name='Field1' Margin='2,0,2,4'/>
                <TextBlock Height='Auto' Width='Auto' Text='Last Name:' TextWrapping='Wrap' Margin='2,4,2,0'/>
                <TextBox Height='Auto' x:Name='Field2' Width='Auto' Text='' TextWrapping='Wrap' Margin='2,0,2,4'/>
                <TextBlock Height='Auto' Width='Auto' Text='Company:' TextWrapping='Wrap' Margin='2,4,2,0'/>
                <TextBox Height='Auto' x:Name='Field3' Width='Auto' Text='' TextWrapping='Wrap' Margin='2,0,2,2'/>
                <TextBlock Height='22.537' Width='182' Text='Title:' TextWrapping='Wrap' Margin='2,4,2,0'/>
                <TextBox Height='20.772' x:Name='Field4' Width='182' Text='' TextWrapping='Wrap' Margin='2,0,2,2'/>
              </StackPanel>
            </Border>
            <Ellipse x:Name='StatusEllipse' Margin='4,2,2,2' Grid.Row='3' Stroke='#FF000000' Fill='#FF2D4DE0' RenderTransformOrigin='0.5,0.5' >
              <Ellipse.RenderTransform>
                <TransformGroup>
                  <ScaleTransform/>
                  <SkewTransform/>
                  <RotateTransform/>
                  <TranslateTransform/>
                </TransformGroup>
              </Ellipse.RenderTransform>
              <ToolTipService.ToolTip>
                <ToolTip Content='Click button to start work.' />
              </ToolTipService.ToolTip>
            </Ellipse>
            <Canvas HorizontalAlignment='Stretch' Margin='0,0,2,8' Grid.RowSpan='4' Grid.ColumnSpan='3' x:Name='PromptCancelCanvas' Visibility='Collapsed'>
              <Rectangle Height='300' Width='400' Fill='#FF808080' Stroke='#FF000000' Stretch='Fill' Opacity='0.6'/>
              <Canvas Height='106' Width='289' Canvas.Left='46' Canvas.Top='85'>
                <Rectangle Height='106' Width='289' Fill='#FFFFFFFF' Stroke='#FF000000' RadiusX='23' RadiusY='23' Opacity='0.85'/>
                <Button Height='34' x:Name='ButtonConfirmCancelYes' Width='100' Canvas.Left='15' Canvas.Top='49' Content='Yes'/>
                <Button Height='34' x:Name='ButtonConfirmCancelNo' Width='100' Canvas.Left='164' Canvas.Top='49' Content='No'/>
                <TextBlock Width='134.835' Canvas.Left='75' Canvas.Top='12.463' Text='Cancel Operation?' TextWrapping='Wrap'/>
              </Canvas>
            </Canvas>
            <TextBlock Margin='67.8270034790039,0,-88.802001953125,0' Grid.Column='1' Grid.ColumnSpan='1' Text='BackgroundWorker Thread' TextWrapping='Wrap'/>
          </Grid>"

        // Load xaml dynamically        
        let grid = XamlReader.Load(xamlControls) :?> Grid

        // Find the controls...
        let statusEllipse = grid.FindName("StatusEllipse") :?> Ellipse 
        let textarea = grid.FindName("WorkResultsTextData") :?> TextBox 
        let doWorkButton = grid.FindName("DoWorkButton") :?> Button 
        let cancelNoButton = grid.FindName("ButtonConfirmCancelNo") :?> Button         
        let cancelYesButton = grid.FindName("ButtonConfirmCancelYes") :?> Button 
        let cancelCanvas = grid.FindName("PromptCancelCanvas") :?> Canvas 

        // Grab storyboard from grid resources with the extra key specified..        
        let storyboard = grid.Resources.["AnimateStatusEllipse"] :?> Storyboard
        
        // Remove code to add storyboard children objects...
        
        // SimulateBackgroundWorker modelled after Don Syme's Iterative Background worker 
        let worker = new SimulateBackgroundWorker<_>(1000,30)

        doWorkButton.Click.Add(fun e ->
            worker.RunWorkerAsync()
            textarea.Text <- sprintf "(2) Started : %s"  (DateTime.Now.ToString())
            storyboard.AutoReverse <- true
            storyboard.RepeatBehavior <- RepeatBehavior.Forever
            storyboard.Begin())

        cancelYesButton.Click.Add(fun e ->
            worker.CancelAsync()
            cancelCanvas.Visibility <- Visibility.Collapsed)
        
        cancelNoButton.Click.Add(fun e ->
            cancelCanvas.Visibility <- Visibility.Collapsed)

        statusEllipse.MouseLeftButtonDown.Add(fun e ->
            if worker.IsBusy = true then
                cancelCanvas.Visibility <- Visibility.Visible)
            
        worker.WorkerCompleted.Add(fun () ->
                statusEllipse.Fill <- new SolidColorBrush(Color.FromArgb(255uy,0uy,255uy,0uy))
                let msg = sprintf "\nCompleted : %s" (DateTime.Now.ToString())
                textarea.Text <- textarea.Text + msg
                ToolTipService.SetToolTip(statusEllipse, "Work Complete.")
           )

        worker.ProgressChanged.Add(fun (progressPercentage) ->
            if cancelCanvas.Visibility = Visibility.Collapsed then
                let msg = sprintf "%i Percent Complete.  Click to cancel..." progressPercentage
                ToolTipService.SetToolTip(statusEllipse, msg))
                
        worker.WorkerCancelled.Add(fun () ->
                statusEllipse.Fill <- new SolidColorBrush(Color.FromArgb(255uy,255uy,255uy,0uy))
                let msg = sprintf "%s \nCanceled@: %s" textarea.Text <| DateTime.Now.ToString()
                textarea.Text <- msg
                ToolTipService.SetToolTip(statusEllipse, msg))
       
        base.Width <- 400.0
        base.Height <- 300.0
        base.Content <- grid
end

type ErrorPage = class
    inherit UserControl
    
    new (msg:string ) as this = {} then
    
        let textarea = new TextBlock(Text=msg,
                                     TextWrapping=TextWrapping.Wrap,
                                     Margin=new Thickness(4.0,4.0,4.0,4.0))
    
        let sp = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                Margin=new Thickness(8.0,8.0,10.0,8.0))
        sp.Children.Add(textarea)                                

        base.Width <- 600.0
        base.Height <- 1000.0
        base.Content <- sp
end    


type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ -> 
            let rootPanel = new StackPanel()
            try 
                this.RootVisual <- rootPanel
                rootPanel.Children.Add(new MyPage())
            with _ as e ->
               let msg = e.Message + e.StackTrace
               rootPanel.Children.Clear()
               rootPanel.Children.Add(new ErrorPage(msg)))

        this.UnhandledException.Add(fun args ->
           args.Handled <- true
           try
               let msg = args.ExceptionObject.Message + args.ExceptionObject.StackTrace
               let errmsg = msg.Replace('"','\'').Replace("\r\n",@"\n") 
               "throw new Error(\"Unhandled error in Silverlight 2 Application " + msg + "\");"
               |> HtmlPage.Window.Eval |> ignore
           with _  -> HtmlPage.Window.Eval("throw new Error(\"Custom Error!\");") |> ignore)
end

Silverlight with F#: Animation via XAML

2009-03-22T17:46:00.001-07:00

In my previous blog, I was unable to fully implement recipe 2.11 of the book Silverlight 2 Recipes with F# code due to problems with getting PropertyPath to work as shown in various Silverlight books. Just to make sure that this is not just a Silverlight issue, I tried the code with WPF and still had the same problem. I decided to approach this differently and implement the animation in XAML instead and got it to work. Here’s the code:


#light
namespace SilverLightFSharp

open System
open System.ComponentModel
open System.IO
open System.IO.IsolatedStorage
open System.ServiceModel
open System.Windows
open System.Windows.Browser
open System.Windows.Controls
open System.Windows.Markup
open System.Windows.Media
open System.Windows.Media.Animation
open System.Windows.Shapes
open List

// Recipe 2-11 from Silverlight 2 Recipes book
// Using XAML to configure the animation
type MyPage() = class
    inherit UserControl()
    
    do
        let xamlControls = 
                "<Grid xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
                       xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
                       xmlns:d='http://schemas.microsoft.com/expression/blend/2008' 
                       xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006' 
                       mc:Ignorable='d'
                       >
                    <Grid.ColumnDefinitions>
                      <ColumnDefinition Width='0.068*'/>
                      <ColumnDefinition Width='0.438*'/>
                      <ColumnDefinition Width='0.495*'/>
                    </Grid.ColumnDefinitions>
                    <Grid.RowDefinitions>
                      <RowDefinition Height='0.08*'/>
                      <RowDefinition Height='0.217*'/>
                      <RowDefinition Height='0.61*'/>
                      <RowDefinition Height='0.093*'/>
                    </Grid.RowDefinitions>
                    <Button HorizontalAlignment='Stretch' Margin='5,8,5,8'
                     VerticalAlignment='Stretch' Grid.Column='1' Grid.Row='1'
                      Content='Save Form Data'/>
                    <StackPanel HorizontalAlignment='Stretch'
                      Margin='5,8,6,8' Grid.Column='1' Grid.Row='2'>
                      <TextBlock Height='Auto' Width='Auto' Text='Work Results Appear Below'
                      TextWrapping='Wrap' Margin='4,4,4,4'/>
                      <TextBox Height='103' Width='Auto' Text='' TextWrapping='Wrap'
                      Margin='4,4,4,4' x:Name='WorkResultsTextData'/>
                    </StackPanel>
                    <Button HorizontalAlignment='Stretch' Margin='12,8,8,8'
                      VerticalAlignment='Stretch'
                     Grid.Column='2' Grid.Row='1' Content='Load Form Data' />
                    <Button HorizontalAlignment='Stretch' Margin='10,2,8,6'
                      VerticalAlignment='Stretch'
                       Grid.Column='1' Grid.Row='3' Content='Kick Off Work' x:Name='DoWorkButton'/>
                    <Border Grid.Column='2' Grid.Row='2' Grid.RowSpan='2' CornerRadius='10,10,10,10'
                       Margin='1.80200004577637,2,2,2'>
                      <Border.Background>
                        <LinearGradientBrush EndPoint='0.560000002384186,0.00300000002607703'
                           StartPoint='0.439999997615814,0.996999979019165'>
                          <GradientStop Color='#FF586C57'/>
                          <GradientStop Color='#FFA3BDA3' Offset='0.536'/>
                          <GradientStop Color='#FF586C57' Offset='0.968999981880188'/>
                        </LinearGradientBrush>
                      </Border.Background>
                      <StackPanel Margin='4,4,4,4' x:Name='FormData'>
                        <TextBlock Height='Auto' Width='Auto' Text='First Name:' TextWrapping='Wrap'
                        Margin='2,2,2,0'/>
                        <TextBox Height='Auto' Width='Auto' Text='' TextWrapping='Wrap' 
                          x:Name='Field1' Margin='2,0,2,4'/>
                        <TextBlock Height='Auto' Width='Auto' Text='Last Name:'
                           TextWrapping='Wrap' Margin='2,4,2,0'/>
                        <TextBox Height='Auto' x:Name='Field2' Width='Auto' Text=''
                          TextWrapping='Wrap' Margin='2,0,2,4'/>
                        <TextBlock Height='Auto' Width='Auto' Text='Company:'
                          TextWrapping='Wrap' Margin='2,4,2,0'/>
                        <TextBox Height='Auto' x:Name='Field3' Width='Auto' Text=''
                          TextWrapping='Wrap' Margin='2,0,2,2'/>
                        <TextBlock Height='22.537' Width='182' Text='Title:'
                          TextWrapping='Wrap' Margin='2,4,2,0'/>
                        <TextBox Height='20.772' x:Name='Field4' Width='182' Text=''
                          TextWrapping='Wrap' Margin='2,0,2,2'/>
                      </StackPanel>
                    </Border>
                    <Ellipse x:Name='StatusEllipse' Margin='4,2,2,2' Grid.Row='3' Stroke='#FF000000'
                      Fill='#FF2D4DE0' RenderTransformOrigin='0.5,0.5' >
                      <Ellipse.RenderTransform>
                        <TransformGroup>
                          <ScaleTransform/>
                          <SkewTransform/>
                          <RotateTransform/>
                          <TranslateTransform/>
                        </TransformGroup>
                      </Ellipse.RenderTransform>
                      <ToolTipService.ToolTip>
                        <ToolTip Content='Click button to start work.' />
                      </ToolTipService.ToolTip>
                    </Ellipse>
                    <Canvas HorizontalAlignment='Stretch' Margin='0,0,2,8' Grid.RowSpan='4'
                      Grid.ColumnSpan='3' x:Name='PromptCancelCanvas' Visibility='Collapsed'>
                      <Rectangle Height='300' Width='400' Fill='#FF808080' Stroke='#FF000000'
                        Stretch='Fill' Opacity='0.6'/>
                      <Canvas Height='106' Width='289' Canvas.Left='46' Canvas.Top='85'>
                        <Rectangle Height='106' Width='289' Fill='#FFFFFFFF' Stroke='#FF000000'
                          RadiusX='23' RadiusY='23' Opacity='0.85'/>
                        <Button Height='34' x:Name='ButtonConfirmCancelYes' Width='100'
                          Canvas.Left='15' Canvas.Top='49' Content='Yes'/>
                        <Button Height='34' x:Name='ButtonConfirmCancelNo' Width='100'
                          Canvas.Left='164' Canvas.Top='49' Content='No' />
                        <TextBlock Width='134.835' Canvas.Left='75' Canvas.Top='12.463'
                          Text='Cancel Operation?' TextWrapping='Wrap'/>
                      </Canvas>
                    </Canvas>
                    <TextBlock Margin='67.8270034790039,0,-88.802001953125,0' Grid.Column='1'
                      Grid.ColumnSpan='1' Text='BackgroundWorker Thread' TextWrapping='Wrap'/>                                                        
                  </Grid>"


        // Load xaml dynamically        
        let grid = XamlReader.Load(xamlControls) :?> Grid

        // Find the controls...
        let statusEllipse = grid.FindName("StatusEllipse") :?> Ellipse 
        let textarea = grid.FindName("WorkResultsTextData") :?> TextBox 
        let doWorkButton = grid.FindName("DoWorkButton") :?> Button 
        let cancelNoButton = grid.FindName("ButtonConfirmCancelNo") :?> Button         
        let cancelYesButton = grid.FindName("ButtonConfirmCancelYes") :?> Button 
        let cancelCanvas = grid.FindName("PromptCancelCanvas") :?> Canvas 
        
        let storyboard = new Storyboard()
        
        (let xaml = 
             "<ColorAnimationUsingKeyFrames 
                 xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
                 xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
                 xmlns:d='http://schemas.microsoft.com/expression/blend/2008' 
                 xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006'              
                 BeginTime='00:00:00' 
                 Storyboard.TargetProperty='(Shape.Fill).(SolidColorBrush.Color)'>
                <SplineColorKeyFrame KeyTime='00:00:00' Value='#FF008000'/>
                <SplineColorKeyFrame KeyTime='00:00:01.5000000' Value='#FFFFFF00'/>
                <SplineColorKeyFrame KeyTime='00:00:03' Value='#FF008000'/>
                <SplineColorKeyFrame KeyTime='00:00:04.5000000' Value='#FF008000'/>
                <SplineColorKeyFrame KeyTime='00:00:06' Value='#FFFFFF00'/>
                <SplineColorKeyFrame KeyTime='00:00:07.5000000' Value='#FF008000'/>
              </ColorAnimationUsingKeyFrames>"
         let animation = XamlReader.Load(xaml) :?> ColorAnimationUsingKeyFrames
         Storyboard.SetTarget(animation,statusEllipse)
         animation
         ) |> storyboard.Children.Add
           
        (let xaml = 
             "<DoubleAnimationUsingKeyFrames
                 xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
                 xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
                 xmlns:d='http://schemas.microsoft.com/expression/blend/2008' 
                 xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006'              
                 BeginTime='00:00:00' Storyboard.TargetProperty='(UIElement.Opacity)'>
                <SplineDoubleKeyFrame KeyTime='00:00:00' Value='0.7'/>
                <SplineDoubleKeyFrame KeyTime='00:00:01.5000000' Value='0.5'/>
                <SplineDoubleKeyFrame KeyTime='00:00:03' Value='0.5'/>
                <SplineDoubleKeyFrame KeyTime='00:00:04.5000000' Value='0.7'/>
                <SplineDoubleKeyFrame KeyTime='00:00:06' Value='0.5'/>
                <SplineDoubleKeyFrame KeyTime='00:00:07.5000000' Value='0.5'/>
              </DoubleAnimationUsingKeyFrames>"
         let animation = XamlReader.Load(xaml) :?> DoubleAnimationUsingKeyFrames
         Storyboard.SetTarget(animation,statusEllipse)
         animation
         ) |> storyboard.Children.Add
        
        (let xaml = 
             "<DoubleAnimationUsingKeyFrames
                 xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
                 xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
                 xmlns:d='http://schemas.microsoft.com/expression/blend/2008' 
                 xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006'              
                 BeginTime='00:00:00' 
                 Storyboard.TargetProperty='(UIElement.RenderTransform).(TransformGroup.Children)[1].(SkewTransform.AngleX)'>
                <SplineDoubleKeyFrame KeyTime='00:00:00' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:01.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:03' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:04.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:06' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:07.5000000' Value='0'/>
              </DoubleAnimationUsingKeyFrames>"
         let animation = XamlReader.Load(xaml) :?> DoubleAnimationUsingKeyFrames
         Storyboard.SetTarget(animation,statusEllipse)
         animation
         ) |> storyboard.Children.Add

        (let xaml = 
             "<DoubleAnimationUsingKeyFrames
                 xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
                 xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
                 xmlns:d='http://schemas.microsoft.com/expression/blend/2008' 
                 xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006'              
                 BeginTime='00:00:00' 
                 Storyboard.TargetProperty='(UIElement.RenderTransform).(TransformGroup.Children)[1].(SkewTransform.AngleY)'>
                <SplineDoubleKeyFrame KeyTime='00:00:00' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:01.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:03' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:04.5000000' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:06' Value='0'/>
                <SplineDoubleKeyFrame KeyTime='00:00:07.5000000' Value='0'/>
              </DoubleAnimationUsingKeyFrames>"
         let animation = XamlReader.Load(xaml) :?> DoubleAnimationUsingKeyFrames
         Storyboard.SetTarget(animation,statusEllipse)
         animation
         ) |> storyboard.Children.Add
        
        let worker = new BackgroundWorker(WorkerReportsProgress = true,
                                          WorkerSupportsCancellation = true)


        // Implent DoWorkButton_Click
        doWorkButton.Click.Add(fun e ->
            if worker.IsBusy = false then
                textarea.Text <- sprintf "Started : %s"  (DateTime.Now.ToString())
                worker.RunWorkerAsync(textarea.Text)
                storyboard.AutoReverse <- true
                storyboard.RepeatBehavior <- RepeatBehavior.Forever
                storyboard.Begin()
                )
                
        // Implement ButtonConfirmCancelYes_Click
        cancelYesButton.Click.Add(fun e ->
            worker.CancelAsync()
            cancelCanvas.Visibility <- Visibility.Collapsed)
        
        // Implement ButtonConfirmCancelNo_Click
        cancelNoButton.Click.Add(fun e ->
            cancelCanvas.Visibility <- Visibility.Collapsed)
        
        // Implement StatusEllipse_MouseLeftButtonDown
        statusEllipse.MouseLeftButtonDown.Add(fun e ->
            if worker.IsBusy = true then
                cancelCanvas.Visibility <- Visibility.Visible)

        // Implement DoWork                                          
        worker.DoWork.Add(fun e -> 
           [1..30] |> iter (fun i ->
               if worker.CancellationPending = true then
                  e.Cancel <- false
               else
                  System.Threading.Thread.Sleep(1000);
                  (int (floor (float i)*100.0/30.0))
                  |> worker.ReportProgress)
           e.Result <- sprintf "\nCompleted : %s" (DateTime.Now.ToString()))
           
        // Implement RunWorkerCompleted
        worker.RunWorkerCompleted.Add(fun e ->
            storyboard.Stop()
            if e.Cancelled = false then
                statusEllipse.Fill <- new SolidColorBrush(Color.FromArgb(255uy,0uy,255uy,0uy))
                textarea.Text <- textarea.Text + e.Result.ToString()
                ToolTipService.SetToolTip(statusEllipse, "Work Complete.")
            else 
                statusEllipse.Fill <- new SolidColorBrush(Color.FromArgb(255uy,255uy,255uy,0uy))
                let msg = sprintf "%s \nCanceled@: %s" textarea.Text <| DateTime.Now.ToString()
                ToolTipService.SetToolTip(statusEllipse, msg))
                                          
        // Implement ProgressChanged
        worker.ProgressChanged.Add(fun e ->
            if cancelCanvas.Visibility = Visibility.Collapsed then
                let msg = sprintf "%s Percent Complete.  Click to cancel..." (e.ProgressPercentage.ToString())
                ToolTipService.SetToolTip(statusEllipse, msg))
        
        base.Width <- 400.0
        base.Height <- 300.0
        base.Content <- grid
        //base.Content <- testerror
end

type ErrorPage = class
    inherit UserControl
    
    new (msg:string ) as this = {} then
    
        let textarea = new TextBlock(Text=msg,
                                     TextWrapping=TextWrapping.Wrap,
                                     Margin=new Thickness(4.0,4.0,4.0,4.0))
    
        let sp = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                Margin=new Thickness(8.0,8.0,10.0,8.0))
        sp.Children.Add(textarea)                                

        base.Width <- 600.0
        base.Height <- 1000.0
        base.Content <- sp
end    


type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ -> 
            let rootPanel = new StackPanel()
            try 
                this.RootVisual <- rootPanel
                rootPanel.Children.Add(new MyPage())
            with _ as e ->
               let msg = e.Message + e.StackTrace
               rootPanel.Children.Clear()
               rootPanel.Children.Add(new ErrorPage(msg)))

        this.UnhandledException.Add(fun args ->
           args.Handled <- true
           try
               let msg = args.ExceptionObject.Message + args.ExceptionObject.StackTrace
               let errmsg = msg.Replace('"','\'').Replace("\r\n",@"\n") 
               "throw new Error(\"Unhandled error in Silverlight 2 Application " + msg + "\");"
               |> HtmlPage.Window.Eval |> ignore
           with _  -> HtmlPage.Window.Eval("throw new Error(\"Custom Error!\");") |> ignore)
end

Silverlight with F#: Background Thread and Animation

2009-03-17T06:54:00.001-07:00

I am working through recipe 2.11 in the book Silverlight 2 Recipes, which introduce concepts of background threads and animation in Silverlight. In developing recipe 2.11 in F#, I ran into problems getting animation to work. I managed to narrow the problem down to use of PropertyPath in my code. If I use the following line of code, the Silverlight application would work.

Storyboard.SetTargetProperty(animation,new PropertyPath(UIElement.OpacityProperty))

But if I use the following line of code:

Storyboard.SetTargetProperty(animation,new PropertyPath("(UIElement.Opacity)"))

it would fail with the following message:

Matthew MacDonald seemed to support the second usage of PropertyPath in chapter 9 of his book Pro Silverlight 2 in C# 2008. I’m not sure right now what’s causing it to break when using that code form with F#. Due to problems I’ve encountered with PropertyPath, I’m not able to implement recipe 2.11 completely. I did managed to implement a stripped down version of recipe 2.11 that demonstrates background threads with animation. Here’s the code that did work for me:


#light
namespace SilverLightFSharp

open System
open System.ComponentModel
open System.IO
open System.IO.IsolatedStorage
open System.ServiceModel
open System.Windows
open System.Windows.Browser
open System.Windows.Controls
open System.Windows.Markup
open System.Windows.Media
open System.Windows.Media.Animation
open System.Windows.Shapes
open List

// Recipe 2-11 from Silverlight 2 Recipes book
// Executing work on a background thread with updates
// Simplified due to problems with Storyboard.SetTargetProperty and PropertyPath
// Added error page for debugging purposes
type MyPage() = class
    inherit UserControl()
    
    do
        let xamlControls = 
                "<Grid xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' 
                       xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
                       xmlns:d='http://schemas.microsoft.com/expression/blend/2008' 
                       xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006' 
                       mc:Ignorable='d'
                       >
                    <Grid.ColumnDefinitions>
                      <ColumnDefinition Width='0.068*'/>
                      <ColumnDefinition Width='0.438*'/>
                      <ColumnDefinition Width='0.495*'/>
                    </Grid.ColumnDefinitions>
                    <Grid.RowDefinitions>
                      <RowDefinition Height='0.08*'/>
                      <RowDefinition Height='0.217*'/>
                      <RowDefinition Height='0.61*'/>
                      <RowDefinition Height='0.093*'/>
                    </Grid.RowDefinitions>
                    <Button HorizontalAlignment='Stretch' Margin='5,8,5,8'
                     VerticalAlignment='Stretch' Grid.Column='1' Grid.Row='1'
                      Content='Save Form Data'/>
                    <StackPanel HorizontalAlignment='Stretch'
                      Margin='5,8,6,8' Grid.Column='1' Grid.Row='2'>
                      <TextBlock Height='Auto' Width='Auto' Text='Work Results Appear Below'
                      TextWrapping='Wrap' Margin='4,4,4,4'/>
                      <TextBox Height='103' Width='Auto' Text='' TextWrapping='Wrap'
                      Margin='4,4,4,4' x:Name='WorkResultsTextData'/>
                    </StackPanel>
                    <Button HorizontalAlignment='Stretch' Margin='12,8,8,8'
                      VerticalAlignment='Stretch'
                     Grid.Column='2' Grid.Row='1' Content='Load Form Data' />
                    <Button HorizontalAlignment='Stretch' Margin='10,2,8,6'
                      VerticalAlignment='Stretch'
                       Grid.Column='1' Grid.Row='3' Content='Kick Off Work' x:Name='DoWorkButton'/>
                    <Border Grid.Column='2' Grid.Row='2' Grid.RowSpan='2' CornerRadius='10,10,10,10'
                       Margin='1.80200004577637,2,2,2'>
                      <Border.Background>
                        <LinearGradientBrush EndPoint='0.560000002384186,0.00300000002607703'
                           StartPoint='0.439999997615814,0.996999979019165'>
                          <GradientStop Color='#FF586C57'/>
                          <GradientStop Color='#FFA3BDA3' Offset='0.536'/>
                          <GradientStop Color='#FF586C57' Offset='0.968999981880188'/>
                        </LinearGradientBrush>
                      </Border.Background>
                      <StackPanel Margin='4,4,4,4' x:Name='FormData'>
                        <TextBlock Height='Auto' Width='Auto' Text='First Name:' TextWrapping='Wrap'
                        Margin='2,2,2,0'/>
                        <TextBox Height='Auto' Width='Auto' Text='' TextWrapping='Wrap' 
                          x:Name='Field1' Margin='2,0,2,4'/>
                        <TextBlock Height='Auto' Width='Auto' Text='Last Name:'
                           TextWrapping='Wrap' Margin='2,4,2,0'/>
                        <TextBox Height='Auto' x:Name='Field2' Width='Auto' Text=''
                          TextWrapping='Wrap' Margin='2,0,2,4'/>
                        <TextBlock Height='Auto' Width='Auto' Text='Company:'
                          TextWrapping='Wrap' Margin='2,4,2,0'/>
                        <TextBox Height='Auto' x:Name='Field3' Width='Auto' Text=''
                          TextWrapping='Wrap' Margin='2,0,2,2'/>
                        <TextBlock Height='22.537' Width='182' Text='Title:'
                          TextWrapping='Wrap' Margin='2,4,2,0'/>
                        <TextBox Height='20.772' x:Name='Field4' Width='182' Text=''
                          TextWrapping='Wrap' Margin='2,0,2,2'/>
                      </StackPanel>
                    </Border>
                    <Ellipse x:Name='StatusEllipse' Margin='4,2,2,2' Grid.Row='3' Stroke='#FF000000'
                      Fill='#FF2D4DE0' RenderTransformOrigin='0.5,0.5' >
                      <Ellipse.RenderTransform>
                        <TransformGroup>
                          <ScaleTransform/>
                          <SkewTransform/>
                          <RotateTransform/>
                          <TranslateTransform/>
                        </TransformGroup>
                      </Ellipse.RenderTransform>
                      <ToolTipService.ToolTip>
                        <ToolTip Content='Click button to start work.' />
                      </ToolTipService.ToolTip>
                    </Ellipse>
                    <Canvas HorizontalAlignment='Stretch' Margin='0,0,2,8' Grid.RowSpan='4'
                      Grid.ColumnSpan='3' x:Name='PromptCancelCanvas' Visibility='Collapsed'>
                      <Rectangle Height='300' Width='400' Fill='#FF808080' Stroke='#FF000000'
                        Stretch='Fill' Opacity='0.6'/>
                      <Canvas Height='106' Width='289' Canvas.Left='46' Canvas.Top='85'>
                        <Rectangle Height='106' Width='289' Fill='#FFFFFFFF' Stroke='#FF000000'
                          RadiusX='23' RadiusY='23' Opacity='0.85'/>
                        <Button Height='34' x:Name='ButtonConfirmCancelYes' Width='100'
                          Canvas.Left='15' Canvas.Top='49' Content='Yes'/>
                        <Button Height='34' x:Name='ButtonConfirmCancelNo' Width='100'
                          Canvas.Left='164' Canvas.Top='49' Content='No' />
                        <TextBlock Width='134.835' Canvas.Left='75' Canvas.Top='12.463'
                          Text='Cancel Operation?' TextWrapping='Wrap'/>
                      </Canvas>
                    </Canvas>
                    <TextBlock Margin='67.8270034790039,0,-88.802001953125,0' Grid.Column='1'
                      Grid.ColumnSpan='1' Text='BackgroundWorker Thread' TextWrapping='Wrap'/>                                                        
                  </Grid>"


        // Load xaml dynamically        
        let grid = XamlReader.Load(xamlControls) :?> Grid

        // Find the controls...
        let statusEllipse = grid.FindName("StatusEllipse") :?> Ellipse 
        let textarea = grid.FindName("WorkResultsTextData") :?> TextBox 
        let doWorkButton = grid.FindName("DoWorkButton") :?> Button 
        let cancelNoButton = grid.FindName("ButtonConfirmCancelNo") :?> Button         
        let cancelYesButton = grid.FindName("ButtonConfirmCancelYes") :?> Button 
        let cancelCanvas = grid.FindName("PromptCancelCanvas") :?> Canvas 
        
        //let storyboard = Resources.createStoryBoard()
        // Must preset opacity value
        statusEllipse.Opacity <- 0.2
        let storyboard = new Storyboard()
        let animation = new DoubleAnimation(From=new Nullable<float>(0.2),
                                            To=new Nullable<float>(1.0),
                                            Duration= new Duration(TimeSpan.FromSeconds(5.0)))
        Storyboard.SetTarget(animation,statusEllipse)        
        // This following line of code does not work - gives NullReference exception
        //Storyboard.SetTargetProperty(animation,new PropertyPath("(UIElement.Opacity)"))
        Storyboard.SetTargetProperty(animation,new PropertyPath(UIElement.OpacityProperty))
        storyboard.Children.Add(animation)
        
        let worker = new BackgroundWorker(WorkerReportsProgress = true,
                                          WorkerSupportsCancellation = true)


        // Implement DoWorkButton_Click
        doWorkButton.Click.Add(fun e ->
            if worker.IsBusy = false then
                textarea.Text <- sprintf "Started : %s"  (DateTime.Now.ToString())
                worker.RunWorkerAsync(textarea.Text)
                storyboard.AutoReverse <- true
                storyboard.RepeatBehavior <- RepeatBehavior.Forever
                storyboard.Begin()
                )
                
        // Implement ButtonConfirmCancelYes_Click
        cancelYesButton.Click.Add(fun e ->
            worker.CancelAsync()
            cancelCanvas.Visibility <- Visibility.Collapsed)
        
        // Implement ButtonConfirmCancelNo_Click
        cancelNoButton.Click.Add(fun e ->
            cancelCanvas.Visibility <- Visibility.Collapsed)
        
        // Implement StatusEllipse_MouseLeftButtonDown
        statusEllipse.MouseLeftButtonDown.Add(fun e ->
            if worker.IsBusy = true then
                cancelCanvas.Visibility <- Visibility.Visible)

        // Implement DoWork                                          
        worker.DoWork.Add(fun e -> 
           [1..30] |> iter (fun i ->
               if worker.CancellationPending = true then
                  e.Cancel <- false
               else
                  System.Threading.Thread.Sleep(1000);
                  (int (floor (float i)*100.0/30.0))
                  |> worker.ReportProgress)
           e.Result <- sprintf "\nCompleted : %s" (DateTime.Now.ToString()))
           
        // Implement RunWorkerCompleted
        worker.RunWorkerCompleted.Add(fun e ->
            storyboard.Stop()
            if e.Cancelled = false then
                statusEllipse.Fill <- new SolidColorBrush(Color.FromArgb(255uy,0uy,255uy,0uy))
                textarea.Text <- textarea.Text + e.Result.ToString()
                ToolTipService.SetToolTip(statusEllipse, "Work Complete.")
            else 
                statusEllipse.Fill <- new SolidColorBrush(Color.FromArgb(255uy,255uy,255uy,0uy))
                let msg = sprintf "%s \nCanceled@: %s" textarea.Text <| DateTime.Now.ToString()
                ToolTipService.SetToolTip(statusEllipse, msg))
                                          
        // Implement ProgressChanged
        worker.ProgressChanged.Add(fun e ->
            if cancelCanvas.Visibility = Visibility.Collapsed then
                let msg = sprintf "%s Percent Complete.  Click to cancel..." (e.ProgressPercentage.ToString())
                ToolTipService.SetToolTip(statusEllipse, msg))
        
        base.Width <- 400.0
        base.Height <- 300.0
        base.Content <- grid
        //base.Content <- testerror
end

type ErrorPage = class
    inherit UserControl
    
    new (msg:string ) as this = {} then
    
        let textarea = new TextBlock(Text=msg,
                                     TextWrapping=TextWrapping.Wrap,
                                     Margin=new Thickness(4.0,4.0,4.0,4.0))
    
        let sp = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                Margin=new Thickness(8.0,8.0,10.0,8.0))
        sp.Children.Add(textarea)                                

        base.Width <- 600.0
        base.Height <- 1000.0
        base.Content <- sp
end    


type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ -> 
            let rootPanel = new StackPanel()
            try 
                this.RootVisual <- rootPanel
                rootPanel.Children.Add(new MyPage())
            with _ as e ->
               let msg = e.Message + e.StackTrace
               rootPanel.Children.Clear()
               rootPanel.Children.Add(new ErrorPage(msg)))

        this.UnhandledException.Add(fun args ->
           args.Handled <- true
           try
               let msg = args.ExceptionObject.Message + args.ExceptionObject.StackTrace
               let errmsg = msg.Replace('"','\'').Replace("\r\n",@"\n") 
               "throw new Error(\"Unhandled error in Silverlight 2 Application " + msg + "\");"
               |> HtmlPage.Window.Eval |> ignore
           with _  -> HtmlPage.Window.Eval("throw new Error(\"Custom Error!\");") |> ignore)
end

F# Silverlight, XAML and opening local files

2009-03-08T15:24:00.001-07:00

I’m working through more examples in the book Silverlight 2 Recipes. While it has been an interesting exercise to manually convert the XAML examples into F# code, it detracted me from learning about other aspects of Silverlight technology. In this particular sample code, I decided to take the XAML output and dynamically load it as per the example from recipe 2-5. Of course, once you load the UI controls via XAML, you’ll need to find those controls as per example from recipe 2-3 from the book. Finally, the recipe I really wanted to develop is recipe 2-7 where the Silverlight app loads local files. Below is the sample code:


#light
namespace SilverLightFSharp

open System
open System.IO
open System.IO.IsolatedStorage
open System.Windows
open System.Windows.Controls
open System.Windows.Media
open System.ServiceModel
open System.Windows.Markup
open System.Windows.Browser
open List

// Combining recipes 2-3,2-5 and 2-7 from Silverlight 2 Recipes book
// Dynamically loading XAML from managed code
// Find an element in XAML
// Opening local files
type MyPage() = class
    inherit UserControl()
    
    do
        let xaml = 
            "<Grid xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
                   xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
                   xmlns:d='http://schemas.microsoft.com/expression/blend/2008'
                   xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006'
                   mc:Ignorable='d'>
                <Grid.Background>
                  <LinearGradientBrush EndPoint='0.5,1' StartPoint='0.5,0'>
                    <GradientStop Color='#FF000000'/>
                    <GradientStop Color='#FFFFFFFF' Offset='1'/>
                  </LinearGradientBrush>
                </Grid.Background>
                <Grid.RowDefinitions>
                  <RowDefinition Height='0.117*'/>
                  <RowDefinition Height='0.79*'/>
                  <RowDefinition Height='0.093*'/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                  <ColumnDefinition Width='0.058*'/>
                  <ColumnDefinition Width='0.252*'/>
                  <ColumnDefinition Width='0.64*'/>
                  <ColumnDefinition Width='0.05*'/>
                </Grid.ColumnDefinitions>
                <Button Height='28.9' HorizontalAlignment='Stretch' Margin='8,8,11,0'
                 VerticalAlignment='Top' Width='81.8' Grid.Column='1' Grid.Row='1'
                 Content='Select Files' d:LayoutOverrides='Height' x:Name='ButtonSelectFiles'/>
                <TextBlock Margin='4,2,2,2' Grid.Column='1' Grid.Row='2' Text='Status'
                   TextWrapping='Wrap' Grid.ColumnSpan='2' x:Name='StatusLabel'/>
                <Border Grid.Column='2' Grid.Row='1' Margin='0,0,0,0' CornerRadius='12'>
                  <Border.Background>
                    <LinearGradientBrush EndPoint='0.916999995708466,0.0890000015497208'
                       StartPoint='-0.0489999987185001,2.12400007247925'>
                      <GradientStop Color='#FF1D351E'/>
                      <GradientStop Color='#FF1D351E' Offset='1'/>
                      <GradientStop Color='#FFB7D8BA' Offset='0.50900000333786011'/>
                    </LinearGradientBrush>
                  </Border.Background>
                  <ListBox x:Name='FileList' Foreground='#FF000000' Height='217'
                    Width='236' Opacity='1'/>
                </Border>
              </Grid>"

        // Load xaml dynamically        
        let grid = XamlReader.Load(xaml) :?> Grid
        
        // Find the controls...
        let status = grid.FindName("StatusLabel") :?> TextBlock
        let btnSelect = grid.FindName("ButtonSelectFiles") :?> Button
        let fileslist = grid.FindName("FileList") :?> ListBox
        
        //  open local files
        btnSelect.Click.Add(fun e -> 
            let fileDlg = new OpenFileDialog(Filter="Image Files (*.jpg)|*.jpg|All Files (*.*)|*.*",
                                             Multiselect=true,
                                             FilterIndex=1)
                                             
            let (=?!) (x: Nullable<'a>) (y:'a) = x.HasValue && x.Value = y                                             
            
            if (fileDlg.ShowDialog() =?! true )             
            then let files = fileDlg.Files
                 status.Text <- (files |> Seq.length |> sprintf "%i file(s) selected")
                 files |> Seq.iter (fileslist.Items.Add)
            )
        
        base.Width <- 400.0
        base.Height <- 300.0
        base.Content <- grid
       
       
end


type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ -> this.RootVisual <- new MyPage())            
        //base.Exit.Add( fun _ -> ()) //this.Application_Exit)
        //this.InitializeComponent()
end

F# Silverlight 2 and Isolated Storage

2009-02-26T11:10:00.000-08:00

I recently picked up a copy of the book Silverlight 2 Recipes and wanted to try out some of the recipes by building F# version of them. One of the first recipes that caught my eye was recipe 2.6 which talks about working with IsolatedStorage. One of the main issues I had with implementing this recipe in F# is the fact that the public methods for IsolatedStorageFile is different between .NET Framework 3.5 and for Silverlight 2. Therefore, I was unable to call the CreateFile method of IsolatedStorageFile . But thankfully, this problem was already resolved by Michael Giagnocavo in his blog on F# 1.9.6.2 and Silverlight 2. All I had to do is goto Project->[ProjectName] Properties –> Build and enter the following flag in “Other flags:”

--cliroot "C:\Program Files\Microsoft Silverlight\2.0.31005.0"

After configuring the ––cliroot flag, the source file compiled without problems. Here’s the F# implementation of recipe 2.6 from the book:


#light
namespace SilverLightFSharp

open System.IO
open System.IO.IsolatedStorage
open System.Windows
open System.Windows.Controls
open System.Windows.Media
open System.ServiceModel
open List

// Recipe 2-6 from Silverlight 2 Recipes book
// Persisting Data on the Client

type MyPage() = class
    inherit UserControl()
    
    let settings = IsolatedStorageSettings.ApplicationSettings
    let setting = "MySettings"
    let filename = "FormFields.data"
    let dataDirectory = "FormData"
    let filepath = System.IO.Path.Combine(dataDirectory, filename)
    
    //new () as this = {} then
    do
        let buildgrid color =
            let grid = new Grid(Background = new SolidColorBrush(color))
            let star = GridUnitType.Star
            
            // Add column definitions
            [0.06;0.455;0.485] 
            |> map (fun w -> new ColumnDefinition(Width=new GridLength(w,star)))
            |> iter grid.ColumnDefinitions.Add
            
            // Add row definitions
            [0.08;0.217;0.61;0.093]
            |> map (fun h -> new RowDefinition(Height=new GridLength(h,star)))
            |> iter grid.RowDefinitions.Add
            
            grid
            
        let grid =  buildgrid Colors.Gray
        
        let gridadd (ui:#UIElement) row col =
            grid.Children.Add(ui)
            Grid.SetRow(ui,row)
            Grid.SetColumn(ui,col)
            

        
        let sp = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                Margin=new Thickness(8.0,8.0,10.0,8.0))
        
        
        new TextBlock(Text="Enter Setting Value",
                      TextWrapping=TextWrapping.Wrap,
                      Margin=new Thickness(4.0,4.0,4.0,4.0))
        |> sp.Children.Add
        
        let textdata = new TextBox(Height=126.0,
                                   Text="",
                                   TextWrapping=TextWrapping.Wrap,
                                   Margin=new Thickness(4.0,4.0,4.0,4.0))
        textdata |> sp.Children.Add

        gridadd sp 2 1
        
        
        // Build Form
        let buildform () =
            let brush = new LinearGradientBrush
                         (StartPoint = new Point(0.439999997615814,0.996999979019165),
                          EndPoint = new Point(0.560000002384186,0.00300000002607703))
                                                
            [((255uy,58uy,108uy,87uy),0.0);
             ((255uy,163uy,189uy,163uy),0.536);
             ((255uy,58uy,108uy,87uy),0.968999981880188)]
            |> map (fun (color,offset) -> new GradientStop(Color=(color |> Color.FromArgb), Offset=offset))
            |> iter brush.GradientStops.Add
            
            let form = new StackPanel(HorizontalAlignment = HorizontalAlignment.Stretch,
                                      VerticalAlignment = VerticalAlignment.Stretch,
                                      Margin = new Thickness(4.0,4.0,4.0,4.0))
            let border = new Border
                          (HorizontalAlignment = HorizontalAlignment.Stretch,
                           Margin = new Thickness(8.0,8.0,10.0,8.0),
                           VerticalAlignment = VerticalAlignment.Stretch,
                           CornerRadius = new CornerRadius(10.0,10.0,10.0,10.0),
                           Child=form,
                           Background=brush)
            gridadd border 2 2
            Grid.SetRowSpan(border,2)
            
            let createLabel label = new TextBlock(Text=label, 
                                                  TextWrapping=TextWrapping.Wrap,
                                                  Margin = new Thickness(2.0,4.0,2.0,0.0))
            let createTextbox () = new TextBox(TextWrapping=TextWrapping.Wrap,
                                               Margin = new Thickness(2.0,0.0,2.0,2.0))
                                               
                                                                                       
            let formelements = 
               ["First Name:";"Last Name:"; "Company:"; "Title:"]
               |> map (fun label -> (createLabel label, createTextbox ()))

            
            formelements |> iter (fun (label,tb) -> 
               form.Children.Add(label)
               form.Children.Add(tb))

            formelements
        
        
        let createbtn thickness row col content fn =
        
            let btn = new Button(HorizontalAlignment = HorizontalAlignment.Stretch,
                                 Margin=thickness,
                                 Content=content)
            btn.Click.Add(fn)
            btn.Click.Add(fun evt -> ())
            gridadd btn row col
         

        let form = buildform()
        let fields = form |> map (fun (label,tb) -> tb)
        
        // SaveFormData_Click
        createbtn (new Thickness(8.0)) 1 1 "Save Form Data"
        <| (fun evt -> 
                try
                    use store = IsolatedStorageFile.GetUserStoreForApplication()
                    store.CreateDirectory(dataDirectory)
                    use stream = store.CreateFile(filepath)
                    use writer = new StreamWriter(stream)
                    writer.AutoFlush <- true
                    let data = fields |> map (fun field -> field.Text + "|")  
                               |> fold_left (+) ""
                    data |> writer.WriteLine
                    textdata.Text <- "Data saved to : " + filepath + "\n" + data
                with 
                   | :? IsolatedStorageException as ex ->  textdata.Text <- "Error saving setting: " + ex.Message
                   | _ -> textdata.Text <- "Unable to open file... ")
        
        // ReadFormData_Click
        createbtn (new Thickness(8.0)) 1 2 "Load Form Data"
        <| (fun evt -> 
                try
                   use store = IsolatedStorageFile.GetUserStoreForApplication()
                   use file = new IsolatedStorageFileStream(filepath,FileMode.Open, store)
                   use reader = new StreamReader(file)
                   let storedvalues = reader.ReadToEnd();
                   let data = storedvalues.Split([|'|'|]) 
                              |> Array.to_seq |> Seq.take (List.length fields) 
                              |> Seq.to_list
                   zip fields data |> iter (fun (tb,data) -> tb.Text <- data)
                   // For checking...
                   textdata.Text <- storedvalues
                with
                   | :? IsolatedStorageException as ex ->  textdata.Text <- "Error saving setting: " + ex.Message
                   | _ -> textdata.Text <- "Unable to open file... ")
       
        // ButtonUpdateSetting - repurposed for diagnostics
        createbtn (new Thickness(4.0,4.0,14.0,4.0)) 3 1 "Update Setting"
        <| (fun evt -> 
               use store = IsolatedStorageFile.GetUserStoreForApplication()
               let dirs = store.GetDirectoryNames("*")
               let files = store.GetFileNames("*")
               let dirtext = "Directories = " + (dirs |> Array.to_list |> map (fun t -> "\n"+t)  |>fold_left (+) "")
               let filetext = "Filenames = " + (files |> Array.to_list |> map (fun t -> "\n"+t)  |>fold_left (+) "")
               textdata.Text <- dirtext + "\n" + filetext)
                
        base.Width <- 400.0
        base.Height <- 300.0
        base.Content <- grid
        
        // Loaded...
        try
            if settings.Keys.Count <> 0 then
               textdata.Text <- settings.[setting].ToString()
        with _  as ex -> textdata.Text <- "Error saving setting: " + ex.Message
        
end

type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ ->  this.RootVisual <- new MyPage())
        //base.Exit.Add( fun _ -> ()) //this.Application_Exit)
        //this.InitializeComponent()
end

Interoperability – F# + Silverlight 2 on Apache + Metro Web Services on Tomcat

2009-02-18T17:46:00.000-08:00

I bought the books Silverlight 2 in Action and Pro Silverlight 2 in C# 2008 for a while now and did not have a chance to work with Silverlight for the past several weeks. However, recently I had to investigate using GlassFish’s Metro library to build web services as it was highly recommended by colleagues. I have previous familiarity with using Apache Axis to build web services as that web services stack had strong plugin support with Eclipse, my IDE of choice when it comes to Java development. I thought this was a great opportunity to build an sample web service using Metro and build the web service client on Silverlight platform.

My sample web service code was intentionally simple and the java code is as follows:

package sample.ws.metro;

import javax.jws.WebService;

@WebService
public class HelloWorldService {

    public String hello(String name)
    {
        return "Hello, " + name; 
    }

}

I followed the instructions on the web to create the applicationContext.xml and web.xml file and deployed it to my Tomcat server. However, I had a hard time getting this simple example to work. In the end, I downloaded Netbeans and created the web service solution in that IDE. Netbeans generated the applicationContext.xml and web.xml file for me and it worked like a charm. Once I have those configuration files, I could easily do subsequent changes in Eclipse without any problems. This demonstrated how tool support can make life a lot easier for developers. Once the initial setup is completed, it’s much simpler to build and modify from a working solution. Here are the configuration files for those who might be interested:

applicationContext.xml:


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:ws="http://jax-ws.dev.java.net/spring/core"
       xmlns:wss="http://jax-ws.dev.java.net/spring/servlet"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://jax-ws.dev.java.net/spring/core http://jax-ws.dev.java.net/spring/core.xsd
       http://jax-ws.dev.java.net/spring/servlet http://jax-ws.dev.java.net/spring/servlet.xsd">

  <wss:binding url="/helloworld">
     <wss:service>
        <ws:service bean="#HelloWorldService">
           <ref bean="#HelloWorldService">
           </ref>
        </ws:service>
     </wss:service>
  </wss:binding>

  <!-- this bean implements web service methods -->
  <bean id="HelloWorldService" class="sample.ws.metro.HelloWorldService" />
</beans>

web.xml:


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>metropilot</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <!-- this is for Spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
  <!-- these are for JAX-WS -->
  <servlet>
    <servlet-name>jaxws-servlet</servlet-name>
    <servlet-class>com.sun.xml.ws.transport.http.servlet.WSSpringServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>jaxws-servlet</servlet-name>
    <url-pattern>/ws</url-pattern>
  </servlet-mapping> 
</web-app>

Similarly, on the Silverlight side…I needed the tools support in Silverlight on Visual Studio 2008 to help me generate the Service Reference library. I opened up Visual Studio 2008, right-click my Silverlight library project and chose Add Service Reference… and then put in the url of my web service, which in my case was hosted at http://localhost:8080/metropilot/ws/hello?wsdl. I would then build it as a Silverlight library that I can reference in the F# project. I assume and hope that when Visual Studio 2010 arrives, I can do all of this without leaving the F# environment. Now I can write my F# Silverlight client which asks the user to type in a name that will be sent to the web service and display the returned greeting. The F# client code is as follows:


#light
namespace SilverLightFSharp

open System
open System.Windows
open System.Windows.Controls
open System.ServiceModel
open List


// Data Binding example
type MyPage = class
    inherit UserControl
    
    new () as this = {} then

        let sp = new StackPanel()
        
        let textblock = new TextBlock()
        textblock.Text <- "Please enter your name:"
        sp.Children.Add(textblock)
        
        let textbox = new TextBox()
        sp.Children.Add(textbox)
        
        
        let button = new Button(Content="Get Greeting...")
        sp.Children.Add(button)

        button.Click.Add(fun e ->
            let binding = new BasicHttpBinding();
            let endpoint = new EndpointAddress("http://localhost:8080/metropilot/ws/hello?wsdl");
            let service = new ServiceLibrary.MetroPilotService.HelloWorldServiceClient(binding,endpoint)
            service.helloCompleted.Add(fun e ->
                    textblock.Text <- e.Result.ToString()
                    service.CloseAsync())
            service.helloAsync(textbox.Text))
                
        this.Width <- 400.0
        this.Height <- 300.0
        this.Content <- sp
end


type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ ->  this.RootVisual <- new MyPage())
        //base.Exit.Add( fun _ -> ()) //this.Application_Exit)
        //this.InitializeComponent()
end

My application.xap file has the following files:

AppManifest.xaml
FSharp.Core.dll
ServiceLibrary.dll – this was the library generated using Visual Studio 2008 via Add Reference…
SilverlightFSharp.dll – the compiled client code

Since I’m running this Silverlight client on an Apache web server that’s running on port 8000 and my web services was running on a Tomcat server on port 8080, I had to create the clientaccesspolicy.xml and crossdomain.xml file and put it in the root folder of the Tomcat server or the Silverlight client would refuse to access the web service on my Tomcat server.

My clientaccesspolicy.xml is as follows:


<?xml version="1.0" encoding="utf-8"?>
<access-policy>
  <cross-domain-access>
    <policy>
      <allow-from http-request-headers="*">
        <domain uri="*"/>
      </allow-from>
      <grant-to>
        <resource path="/" include-subpaths="true"/>
      </grant-to>
    </policy>
  </cross-domain-access>
</access-policy>

My crossdomain.xml file is as follows:


<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
  <allow-http-request-headers-from domain="*" headers="*"/>
</cross-domain-policy>

Finally, after all these configurations, I got my F# Silverlight 2 client code running on Apache web server talking to my Java based web services running on Tomcat.

Hosting Silverlight Applications on Apache Web Server

2009-01-08T17:20:00.000-08:00

My previous posting prompted a reader to ask me why I'm hosting my Silverlight application on IIS on Windows Server 2008. I did not have a good answer for that. I simply chose Windows Server 2008 because I wanted to install Windows 2008 Server and play around in that environment. In retrospect, it was a good first choice as it allowed to build and deploy Silverlight application with the least amount of fuss and configuration. That success encourage me to explore building Silverlight application further.

However, recently I've been investigating this hosting issue more and fortuitously discover Chris Craft's blog entry on hosting Silverlight application. All I needed was to register additional mime types! I immediately went and added the following mime types to my Apache Web Server:

manifest	application/manifest
.xaml	application/xaml+xml
.dll	application/x-msdownload
.application	application/x-ms-application
.xbap	application/x-ms-xbap
.deploy	application/octet-stream

Now I can run my Silverlight application from an Apache web server! It wasn't until now that I realize that the Silverlight application runs entirely on the client. That means that I no longer need to develop the middle tier with .NET technology and can easily have my Silverlight application interact with a Java middle tier. For work environments that mandate Java middle tier, I can now promote Silverlight as a presentation tier solution.

Simple Video Hosting with F# and Silverlight 2

2008-12-23T16:35:00.000-08:00

I use to hate household maintenance projects such as replacing a leaky faucet or fixing a clogged water pipe. I typically get frustrated because I would run into problems disassembling the plumbing components or find out that I don’t have the right tools to reassemble the plumbing components. Lately, however, I have had much more success with my household plumbing projects. When my kitchen faucet broke, I had a relatively painless experience in replacing the hardware. I attribute this painless experience to the fact that I followed a video tutorial instead of printed material and come to appreciate the power and benefits of a video tutorial.

And similarly, I find myself looking for videos tutorials when it comes learning about complex technologies. Lately, I have looked at SharePoint video tutorials and found them immensely helpful. This got me interested in how finding out easy it is to host video content in Silverlight 2. The answer is that it’s extremely easy and here’s a simple F# implementation of a video player in Silverlight 2.


#light
namespace SilverLightFSharp
open System
open System.Windows
open System.Windows.Controls
open System.Windows.Controls.Primitives
open System.Windows.Data
open System.Windows.Media
open List

// Simple Video Player Example in Silverlight 2 with F#
type MyPage = class
    inherit UserControl
    
    new () as this = {} then
    
        this.Width <- 400.0
        this.Height <- 400.0

        let textbox = new TextBox(TextAlignment =TextAlignment.Center,
                                  VerticalAlignment=VerticalAlignment.Top,
                                  Text="Silverlight Video Example")
                               
        let media = new MediaElement(VerticalAlignment=VerticalAlignment.Center,
                                     HorizontalAlignment=HorizontalAlignment.Center,
                                     Width=400.0,Height=300.0)
        

           
        let playButton = new Button(Content="Play")
        let pauseButton = new Button(Content="Pause")
        let stopButton = new Button(Content="Stop")

        playButton.Click.Add(fun _ -> media.Play())
        pauseButton.Click.Add(fun _ -> media.Pause())
        stopButton.Click.Add(fun _ -> media.Stop())

        let createGrid numrows numcols = 
            let grid = new Grid()
            [1..numrows] |> iter (fun _ ->
               new RowDefinition(Height=GridLength.Auto) |> grid.RowDefinitions.Add)
            [1..numcols] |> iter (fun _ ->
               new ColumnDefinition(Width=GridLength.Auto) |> grid.ColumnDefinitions.Add)
            grid
        

        let addTo (grid:Grid) item row column =
            grid.Children.Add(item) 
            Grid.SetRow(item,row)
            Grid.SetColumn(item,column)
        
        let grid = createGrid 1 3
        
        addTo grid playButton 0 0
        addTo grid pauseButton 0 1
        addTo grid stopButton 0 2
        
        media.Source <- new Uri("test.wmv",UriKind.Relative)
        
        media.DownloadProgressChanged.Add(fun e ->
            let percentage = media.DownloadProgress*100.0
            let status = (Printf.sprintf "%3.2f percent done" percentage)
            textbox.Text <-status)

        let stack = new StackPanel(Background=new SolidColorBrush(Colors.White))
        

        textbox |> stack.Children.Add     
        media |> stack.Children.Add 
        grid |> stack.Children.Add
        
        this.Content <- stack                  
end

type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ ->  this.RootVisual <- new MyPage())

end

In order to get this to work, I had to add system.dll and System.Core.dll to the .xap file. Make sure you grab these dll files from the Silverlight 2 SDK and not from the .Net Framework.

I had a request to post the .xap file and here are they are. The zip files contain both the source file along with the .xap and testpage.html file that is deployed on the server. The deployment items are in the webdeploy folder of the zip file. The file simplebutton.zip is the source and deployment content for the previous post the file simplevideo.zip is the source and deployment content for this post.

simplebutton.zip

simplevideo.zip

F# and Silverlight 2.0

2008-11-20T15:06:00.000-08:00

One of the appeal of learning WPF is that now I can leverage what I learned in WPF and apply them to building web applications via Silverlight 2.0. This blog talks about setting up a very simple Silverlight 2.0 web application with F#.

Since my laptop is running Windows XP, I needed to build an environment with which I can host my Silverlight application. I decided to build a Virtual PC environment running Windows Server 2008. I'm using F# version 1.9.6.2 to build this sample Silverlight application.

Below is the simple Silverlight application with only a single clickable button:


#light
namespace SilverLightFSharp
open System
open System.Windows
open System.Windows.Controls

type MyPage = class
    inherit UserControl
    
    new () as this = {} then
        // Add button and do something with it...
        let btn = new Button(HorizontalAlignment = HorizontalAlignment.Center,
                             VerticalAlignment = VerticalAlignment.Center)
        btn.Content <- "Click me"                             
        btn.Click.Add(fun _ ->
                      btn.Content <- "The button has been clicked!")
        this.Content <- btn
        
end

type MyApp = class
    inherit Application
    
    new () as this = {} then
        this.Startup.Add(fun _ ->  this.RootVisual <- new MyPage())
        //base.Exit.Add( fun _ -> ()) //this.Application_Exit)
        //this.InitializeComponent()

end

I also needed some scaffolding in order to get this Silverlight application to run. One of the scaffolding pieces I need is the AppManifest.xaml file. Below is the content of that AppManifest.xml file with the EntryPointAssembly and EntryPointType attributes set to my F# code.


<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment" 
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
            EntryPointAssembly="SilverLightFSharp" 
            EntryPointType="SilverLightFSharp.MyApp" RuntimeVersion="2.0.31005.0">
  <Deployment.Parts>
    <AssemblyPart x:Name="SilverLightFSharp" Source="SilverLightFSharp.dll" />
    <AssemblyPart x:Name="FSharp.Core" Source="FSharp.Core.dll" />
    <AssemblyPart x:Name="System.Windows.Controls" Source="System.Windows.Controls.dll" />
  </Deployment.Parts>
</Deployment>

I'll also need a test html page to host my silverlight application. I created a TestPage.html to host my Silverlight application. Please note that for the Silverlight control host has the source referencing the file simplebutton.xap. Not to worry, simplebutton.xap is merely a zip file that contains the following files:

AppManifest.xaml
FSharp.Core.dll
System.Windows.Control.dll
SilverlightFsharp.dll

Here's the TestPage.html code:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<!-- saved from url=(0014)about:internet -->
<head>
    <title>SilverlightFSharp</title>

    <style type="text/css">
    html, body {
    height: 100%;
    overflow: auto;
    }
    body {
    padding: 0;
    margin: 0;
    }
    #silverlightControlHost {
    height: 100%;
    }
    </style>
    
    <script type="text/javascript">
        function onSilverlightError(sender, args) {
        
            var appSource = "";
            if (sender != null && sender != 0) {
                appSource = sender.getHost().Source;
            } 
            var errorType = args.ErrorType;
            var iErrorCode = args.ErrorCode;
            
            var errMsg = "Unhandled Error in Silverlight 2 Application " +  appSource + "\n" ;

            errMsg += "Code: "+ iErrorCode + "    \n";
            errMsg += "Category: " + errorType + "       \n";
            errMsg += "Message: " + args.ErrorMessage + "     \n";

            if (errorType == "ParserError")
            {
                errMsg += "File: " + args.xamlFile + "     \n";
                errMsg += "Line: " + args.lineNumber + "     \n";
                errMsg += "Position: " + args.charPosition + "     \n";
            }
            else if (errorType == "RuntimeError")
            {           
                if (args.lineNumber != 0)
                {
                    errMsg += "Line: " + args.lineNumber + "     \n";
                    errMsg += "Position: " +  args.charPosition + "     \n";
                }
                errMsg += "MethodName: " + args.methodName + "     \n";
            }

            throw new Error(errMsg);
        }
    </script>
</head>

<body>
    <!-- Runtime errors from Silverlight will be displayed here.
This will contain debugging information and should be removed or hidden when debugging is completed -->
<div id='errorLocation' style="font-size: small;color: Gray;"></div>

    <div id="silverlightControlHost">
<object data="data:application/x-silverlight," type="application/x-silverlight-2" width="100%" height="100%">
<param name="source" value="simplebutton.xap"/>
<param name="onerror" value="onSilverlightError" />
<param name="background" value="white" />
<param name="minRuntimeVersion" value="2.0.31005.0" />
<param name="autoUpgrade" value="true" />
<a href="http://go.microsoft.com/fwlink/?LinkID=124807" style="text-decoration: none;">
     <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight" style="border-style: none"/>
</a>
</object>
<iframe style='visibility:hidden;height:0;width:0;border:0px'></iframe>
    </div>
</body>
</html>

After I copy simplebutton.xap and TestPage.html to my IIS webserver, I am rewarded with the following results:

Create SharePoint BDC connector for AdventureWorks database with F# Script

2008-10-28T17:37:00.000-07:00

I have been exploring how to create Business Data Catalog in the SharePoint environment. It seems the best way to create BDC application definition file is via a tool called BDC Meta Man, which provides a graphical environment to create the definition file. For my own understanding, I tried to script the creation of the BDC application definition file. In the F# script below, I created the BDC to the HR data in the sample AdventureWorks SQL Server database. This script loosely follows Chapter 4 of Patrick Tisseghem's book Inside Microsoft Office SharePoint Server 2007.


#light
#I @"C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI"
#r @"Microsoft.SharePoint.dll"
#r @"Microsoft.SharePoint.Portal.dll"
#r @"Microsoft.Office.Server.dll"

open Microsoft.Office.Server.ApplicationRegistry.Administration
open Microsoft.Office.Server.ApplicationRegistry.Infrastructure
open Microsoft.Office.Server.ApplicationRegistry.SystemSpecific.Db
open List
open System.Data

SqlSessionProvider.Instance().SetSharedResourceProviderToUse("SharedServices1")

// Create LOB System
let lobsystem = 
   ("Adventure Works Human Resources Data",
    false,
    "Microsoft.Office.Server.ApplicationRegistry.SystemSpecific.Db.DbSystemUtility",
    "Microsoft.Office.Server.ApplicationRegistry.SystemSpecific.Db.DbConnectionManager",
    "Microsoft.Office.Server.ApplicationRegistry.SystemSpecific.Db.DbEntityInstance") 
   |> ApplicationRegistry.Instance.LobSystems.Create


// Add property defining the character % will be replacing the * wildcar entered by users
("WildcardCharacter","%") |> lobsystem.Properties.Add
lobsystem.Update()


// Create LOB System instance
let sysInstance = lobsystem.LobSystemInstances.Create("HR data",true)

("AuthenticationMode",DbAuthenticationMode.RevertToSelf) |> sysInstance.Properties.Add 
("DatabaseAccessProvider", DbAccessProvider.SqlServer) |> sysInstance.Properties.Add 

[("RdbConnection Data Source", "MOSS");
 ("RdbConnection Initial Catalog","AdventureWorks");
 ("RdbConnection Integrated Security", "SSPI")]
|> iter (fun (k,v) -> sysInstance.Properties.Add (k,v)) 

sysInstance.Update()

// Create Employee Entity
let entity = lobsystem.Entities.Create("Employee",true)
let identifier = entity.Identifiers.Create("[EmployeeID]",true,"System.Int32")
let mthd = entity.Methods.Create("GetEmployees",true,true)

("RdbCommandText",
 @"Select [EmployeeID],[Title],[FirstName],[MiddleName],[LastName],[Suffix],[JobTitle],[Phone],[EmailAddress],[EmailPromotion],[AddressLine1],[AddressLine2],[City],[StateProvinceName],[PostalCode],[CountryRegionName],[AdditionalContactInfo] From HumanResources.[vEmployee]"
) |> mthd.Properties.Add

("RdbCommandType",CommandType.Text)  |> mthd.Properties.Add



let createParameter (thismethod:Method) name direction =
     (name,true,direction,
      "Microsoft.Office.Server.ApplicationRegistry.Infrastructure.DotNetTypeReflector")
      |> thismethod.Parameters.Create
      

let parEmployees =  createParameter mthd "Employees" Microsoft.Office.Server.ApplicationRegistry.MetadataModel.DirectionType.Return

let tdEmployees =
   let root = 
       ("EmployeeDataReader",true,
        "System.Data.IDataReader, System.Data, Version=2.0.3600.0,Culture=neutral, PublicKeyToken=b77a5c561934e089",
        null,null,true)
       |> parEmployees.CreateRootTypeDescriptor
   let node = 
       ("EmployeeDataRecord",true,
        "System.Data.IDataRecord, System.Data, Version=2.0.3600.0,Culture=neutral, PublicKeyToken=b77a5c561934e089",
        null,null,false)
       |> root.ChildTypeDescriptors.Create
   
   (("EmployeeID", true, "System.Int32", identifier, null, false)
    |> node.ChildTypeDescriptors.Create).LocalizedDisplayName <- "Employee ID"
   
   let firstname = 
      ("FirstName", true, "System.String", null, null, false)
     |> node.ChildTypeDescriptors.Create
   firstname.LocalizedDisplayName <- "First Name"
   firstname.Update()
    
   let lastname = 
      ("LastName", true, "System.String", null, null, false)
      |> node.ChildTypeDescriptors.Create
   lastname.LocalizedDisplayName <- "Last Name"
   lastname.Update()
   
   [("JobTitle","System.String","Job Title");
    ("Phone","System.String","Phone");
    ("EmailAddress","System.String","Email");   
    ("AddressLine1","System.String","Address");   
    ("City","System.String","City");       
    ("StateProvinceName","System.String","State");       
    ("PostalCode","System.String","Zip");       
    ] |> iter (fun (label,typename,display) ->
       ((label, true, typename, null, null, false)
       |> node.ChildTypeDescriptors.Create).LocalizedDisplayName <- display)
   root

   
// Create method instances
let getEmployees = 
   ("EmployeeFinderInstance",true,tdEmployees,Microsoft.Office.Server.ApplicationRegistry.MetadataModel.MethodInstanceType.Finder)
   |> mthd.MethodInstances.Create

Add Web Part to SharePoint with F# Script

2008-10-13T17:13:00.000-07:00

In building deployment scripts for SharePoint, there are times when I want to automate the deployment of webparts by building a script to automatically add web parts to specific web pages. I found a book that talked about writing these types of scripts in Mark Gerow's SharePoint 2007 Development Recipes, which had many other useful examples of scripting SharePoint 2007. He's already written a C# version of this script that I've decided to implement in F# for contrast.

Here's the F# version of the code:


#light
#I @"C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI"
#r @"Microsoft.SharePoint.dll"

open Microsoft.SharePoint
open Microsoft.SharePoint.WebPartPages
open System.Web.UI.WebControls.WebParts
open System.Xml

let addWebPart page wp zone order pscope (web:SPWeb) =
      let webparts = (page, pscope) |> web.GetLimitedWebPartManager
      (wp,zone,order) |> webparts.AddWebPart
      wp |> webparts.SaveChanges
      
let disableCheckout (splist:SPList) spOperation =
  let oldvalue = splist.ForceCheckout
  splist.ForceCheckout <- false
  splist.Update()
  
  spOperation 

  splist.ForceCheckout <- oldvalue
  splist.Update()

let spUnsafeUpdate spOperation (siteurl:string) (webname:string) doclib  =
   let site = new SPSite(siteurl)
   let web = site.OpenWeb(webname)
   web.AllowUnsafeUpdates <- true
   
   // Disable versioning when updating Document Library
   match doclib with
   | "" ->
       spOperation web
   | _ ->
       disableCheckout
       <| web.Lists.Item(doclib)
       <| spOperation web 

   web.Update()
   web.Dispose()
   site.Dispose()
  

let siteurl = "http://localhost/"
let webname = "recipes"
let doclibName=""

// Add page viewer web part
let viewer = new PageViewerWebPart(SourceType=PathPattern.URL,
                                   ContentLink="http://msdn.microsoft.com/en-us/fsharp/default.aspx")

// Add webpart using unsafe updates...
// Experimenting with ranges of expression with F#'s pipeline operators.  
// Traditional format for the following  code would be
// spUnsafeUpdate siteurl webname doclibName (addWebPart "Default.aspx" editor "Right" 0 Personalization.Shared)
//
addWebPart
  <| "Default.aspx"
  <| viewer
  <| "Left"
  <| 0
  <| PersonalizationScope.Shared
|> spUnsafeUpdate 
  <| siteurl 
  <| webname 
  <| doclibName 


// Add content editor web part
let xmlDoc = new XmlDocument()
let xmlElem = xmlDoc.CreateElement("xmlElem")
xmlElem.InnerText <- "Test content editor web part"
let editor = new ContentEditorWebPart(Content=xmlElem)

addWebPart
  <| "Default.aspx"
  <| editor
  <| "Right"
  <| 0
  <| PersonalizationScope.Shared
|> spUnsafeUpdate 
  <| siteurl 
  <| webname 
  <| doclibName

More SharePoint scripting with F#

2008-10-01T08:35:00.000-07:00

F# Interactive mode in Visual Studio is a great way to interactively script SharePoint objects. I'd almost compare this to using sql query editor against a database. I can write the SharePoint code in Visual Studio and have all the code completion and type checking features. I can select the portion of the source code and execute it by pressing Alt+Enter. It's pretty sweet. Combine this with queries built with CAML statements, I can basically do ad hoc queries against SharePoint objects. I don't know any other tool in the SharePoint tool suite that can do this. I can easily imagine a SharePoint management studio tool built with customized Visual Studio plugins that provide a way to explore the SharePoint objects graphically similar to what SQL Server Management Studio does for SQL Server database and uses F# to manipulate SharePoint similar to how SQL manipulates the database.

Here are some example scripts adapted from the book Inside Microsoft Windows SharePoint Services 3.0 by Ted Pattison and Daniel Larson


#light
#I @"C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI"
#r @"Microsoft.SharePoint.dll"

open System
open Microsoft.SharePoint

// Utility functions to convert SPxCollection to seq<SPx>
let SPListToSeq (splist:SPListCollection) =       
    seq { for i in 0 .. (splist.Count-1) -> splist.get_Item(i)}

let SPFieldToSeq (splist:SPFieldCollection) =       
    seq { for i in 0 .. (splist.Count-1) -> splist.get_Item(i)}

let SPListItemToSeq (splist:SPListItemCollection) =       
    seq { for i in 0 .. (splist.Count-1) -> splist.get_Item(i)}

let SPContentTypeToSeq (splist:SPContentTypeCollection) =       
    seq { for i in 0 .. (splist.Count-1) -> splist.get_Item(i)}
    
let site = new SPSite("http://localhost/")
let web = site.OpenWeb()

// Add new SharePoint List called "F# SharePoint News
let id = ("F# SharePoint News",
          "List for news on F# and SharePoint items.",
          SPListTemplateType.Announcements)
         |> web.Lists.Add
let list = web.Lists.[id]
list.OnQuickLaunch <- true
list.Update()

// Add news item to the newly created SharePoint List
let newItem = list.Items.Add()
newItem.["Title"] <-"Check for expired items today!"
newItem.["Body"] <- "We're are expiring this today and see if our query works!"
newItem.["Expires"] <- DateTime.Now 
newItem.Update()


// Checking all items in "F# SharePoint News" list that expires today
let queryClause = 
 @"<Where>
      <Eq>
         <FieldRef Name='Expires' />
         <Value Type='DateTime'><Today /></Value>
      </Eq>
 </Where>"

let query = new SPQuery(ViewFields = @"<FieldRef Name='Title'/><FieldRef Name='Expires'/>",
                        Query=queryClause) 

let mylist = web.Lists.["F# Sharepoint News"]
SPListItemToSeq (mylist.GetItems(query))
|> Seq.iter (fun x -> printf "%s\n" x.Title)

// Checking available content types
SPContentTypeToSeq web.AvailableContentTypes
|> Seq.iter (fun x -> printf "%s\n\tDescription = %s\n\tID=%s\n" x.Name x.Description (x.Id.ToString()))

web.Close()
site.Close()