NirajRules

Dear All,

        I am moving my blog to Wordpress. http://nirajrules.wordpress.com/. See you there.

Life is so beautiful!!!

Success,

Niraj

       I was trying to dig into the Rules Framework of .NET WF. Below are the some of the important framework classes.

Rule Class

        Condition

               (RuleCondition <- RuleExpressionCondition)

        ThenActions

               IList<RuleAction>

        ElseActions (Optional)

               IList<RuleAction>

        Name

        Priority 

        ReevaluationBehavior

RuleAction (Abstract Class)

        RuleStatementAction

        RuleHaltAction

        RuleUpdateAction

RuleSet

        Rules (ICollection<Rule>)

        ChainingBehavior

RuleReadAttribute

RuleWriteAttribute

RuleInvokeAttribute 

A Link worth checking out - http://www.inrule.com/products/InRule_Workflow_Foundation.aspx

I was recently stuck up getting started with Silverlight. One of the first applications I tired was to invoke a WCF Service using Silverlight. Although it’s well documented that Silverlight supports only basicHttpBinding due to its sandbox execution, it didn’t seem quite easy to get one sample up & running. The most of samples I came across on sites were adding the .svc file to the same project that was hosting siverlight control. I wanted a complete separate project for WCF Service as that is what would be a normal real word scenario.

And on doing that I got a strange exception:

Line: 377

Char 17:

Error: Sys.InvalidationOperationException: ManagedRuntimeError error #4002 in control ‘Xaml1’: System.Exception: [AsyncCallbackException]

[UnexpectedHttpResponseCode] Arguments:Not Found Debugging resource strings are unavailable. Often the key and arguments provide sufficient information to diagnose the problem. See http://go.microsoft.com/fwlink/?linkid=106663&Version=2.0.30226.2&File=System.ServiceModel.dll&Key=UnexpectedHttpResponseCode

And here I was with no clue. After looking over the web I found that Silverlight doesn’t allow to make a call to a service which is located outside its hosting domain. The best explanation is available here & it talks about doing this via 2 files called ClientAccessPolicy.xml & CrossDomain.xml. I created those 2 files but the article wasn’t particularly helpful for me as to where I would place these two xml files.

After lot of trial & error (with help of fiddler) I found that you have to place those 2 in your %wwwroot folder (e.g. C:\Inetput\wwwroot). After placing the ClientAccessPolicy.xml file there (listed below) things worked fine for me.  Hope they do for you too.

<?xml version="1.0" encoding="utf-8"?>

<access-policy>

  <cross-domain-access>

    <policy>

      <allow-from>

        <domain uri="*"/>

      </allow-from>

      <grant-to>

        <resource path="/" include-subpaths="true"/>

      </grant-to>

    </policy>

  </cross-domain-access>

</access-policy>

(P.S. To add, things still didn’t work for me as I guess there was some problem with my Domain Controller. I had changed URL to localhost in the Silverlight project’s config file but somehow that URL was not being used. So finally I altered the proxy code giving the binding & Uri explicitly as below.)

            PeopleService.Service1Client proxy = new

                PeopleService.Service1Client(

                new BasicHttpBinding(),

                new EndpointAddress("http://localhost/WCFSilverService/Service.svc")

                );

            proxy.GetDataCompleted += new

                EventHandler<SilverLightWithWCF.PeopleService.

                GetDataCompletedEventArgs>(proxy_GetDataCompleted);

            proxy.GetDataAsync();

Implicit type variables:

                 var keyword is used for variable, array & collections. There is no '[]', etc., required with var's usage.
                 var a = new int [] {1, 2, 3, 4, 5};

Object Initializers :

                var p = new Point { x = 10, y = 20 }; //Eliminates need of constructors to initialize properties & collections

Auto Implemented Properties:

public int x { get; set; } //same as abstract properties declaration but with no keyword. N.B. the missing private variable in the above code.

Lambda Expressions:

                Simpler syntax then Anonymous methods. Unlike Anonymous methods parameters are not optional though Parameter types are.

button1.Click += (o, e) => MessageBox.Show("Hello World"); //expression lambda

button1.Click += (o, e) => { MessageBox.Show("Hello World"); return; } //statement lambda

delegate int Add(int i, int j); Add a = (int i , int j) => i + j; //return is implicit, parameters type is explicit

=> can be read as “goes to” (i.e. this parameter goes to this expression / statements)

Anonymous Types:

Combination of Implicit Type & Object Initializers.

 E.g. var p = new { x = 10, y = 20 };

Above creates an implicit type which has 2 properties x & y with values set to 10 & 20 respectively. It’s important to note that Anonymous types are immutable & you can’t pass their instances as method parameters or return types (unless you are using type Object in those places).

Extension Methods:

                They allow extending an existing class with additional behavior (method). Looks similar to Visitor pattern. The new method has to be static defined inside a static class with first parameter being the type which you want to extend. The first parameter is suffixed with keyword ‘this’.

E.g. I

static class MyClass

{

        public static int ToInt32(this String s)

        {

            return Convert.ToInt32(s);

        }

}

E.g. II

List<int> li = new List<int>() { 1, 2, 5, 3, 4 };

//OrderByDescending is an extension method defined in Enumberable class (System.Linq namespace)

IOrderedEnumerable<int> results = li.OrderByDescending(x => x);

/*

//Original API

public static IOrderedSequence<TSource>OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)

//TSource is always taken as a collection type (type inference), Key also can be type inferred depending //upon the return of Lambda expression.

li.OrderByDescending<int, Int64>((int x) => x));

*/

foreach (int num in results)

{

                Console.WriteLine(num);

}

Partial Methods:

                Hm... this is a tricky feature. If you think of template method pattern & hooks, their implementation normally carries a bunch of methods, which you can ovverride in deriving classes if you need them.

E.g. class BeverageRecipe {

                  public virtual void PourMilk() {} // A step in algo / hook

                  public void Prepare() {

                                        PourMilk(); // Call the hook at this step, the derived class implementation will be called if it's available else it will call the base class's do nothing implementation.

                  }

        }

        Drawbacks of the above are it makes a lot of do-nothing calls when derived class comes with no implementation. Another important observation here is the only way to implement the hook is to have a derived class. Of course from pattern's persective we want the algorithm to remain static, hence base class is always justified there. But in cases where the hooks are specific implementation which you want to leave it your team members you can make the method partial.

E.g. partial class BeverageRecipe {

                  partial void PourMilk();  // A step in algo / hook with no implementation

                  public void Prepare() {

                                        PourMilk(); // Call the hook at this step. N.B. That this call along with PourMilk declaration will be entirely removed in case there isn't a another partial class implementing PourMilk method.

                  }

         Hope this will serve as a starting point.

        }

     Lately was trying to understand the underlying framework WCF is built on. Below were some of the important findings which I converted to Class Diagrams. Hope you find them useful.

(P.S. If you are not able to view the Class Diagram clearly leave a comment; I will mail the image files to your id).