I’ll take an exemple to explain my ugly problem, take, a [very ugly cause it's PHP] index.php, it could be retrieved by using :
http://example.com/directory/index.php
-> Got the page, 200 OK
or http://example.com/directory/
-> Got the page, 200 OK
or http://example.com/directory
-> Got a 301 Moved Permanently Location: http://example.com/directory/

Just like expected … but…

As you can see, on the captured HTTP headers below, when you POST data on a 301 target, you’ll be redirected, but unfortunately you’ll lost your POST data, even worse, your request can be reforged as a GET request !

Let me show you an example :
Request :

POST /directory HTTP/1.1
Host: example.com
[user agent, referer, cache control, origin, content type, accept, accept-encoding, blah blah ...]
Content-Length: 7

foo=bar

Response :

HTTP/1.0 301 Moved Permanently
Location: http://example.com/directory/
[... blah blah]

Reforged request :

GET /directory/ HTTP/1.1
Host: example.com

Why my data isn’t kept in the reforged one !?

So let’s read The RFC 2616 (about HTTP …)

10.3.2 301 Moved Permanently

[...]

The new permanent URI SHOULD be given by the Location field in the
response. Unless the request method was HEAD, the entity of the
response SHOULD contain a short hypertext note with a hyperlink to
the new URI(s).

If the 301 status code is received in response to a request other
than GET or HEAD, the user agent MUST NOT automatically redirect the
request unless it can be confirmed by the user, since this might
change the conditions under which the request was issued.

Note: When automatically redirecting a POST request after
receiving a 301 status code, some existing HTTP/1.0 user agents
will erroneously change it into a GET request.

Ahh, ok, so, for request other than GET or HEAD, the user agent MUST NOT automatically redirect to the request ? Ugh, it’s not the case in IE 6, 7, 8, Firefox, nor Chrome.
And, about the security, while the server recieves the data, it can do everything, for example send it to another server directly.
Then I’m wondering, why asking to the user if he allows his data to be transfered ?

Then, the RFC says an interesting thing …

Note: When automatically redirecting a POST request after
receiving a 301 status code, some existing HTTP/1.0 user agents
will erroneously change it into a GET request.

But, not only HTTP/1.0 user agents, but HTTP/1.1 user agents like browsers and frameworks (as, I encountred the problem firstly in the .NET Framework 3.5, in HttpWebRequest) )o:

OK, end of this article, have a nice day )o’,:

Enjoy !

using-alias-directive:
using identifier = namespace-or-type-name ;

You can read more about that here : csharp language specification.doc

Or just try to use it :

// As the specification show it :
namespace N1.N2
{
                class A {}
}
namespace N3
{
                using A = N1.N2.A;
                class B: A {}
}

// My foobar exemple :
namespace Foo
{
                using Bar = Dictionary<string, string>;
}

Download this code: ex.cs

Enjoy !

An exemple ? It’s safe to have a method returning a cat when you expect it to return an animal.

In C sharp it’s

public class Animal
{
}

public class Cat : Animal
{
}

public class Dog : Animal
{
}

// It's safe to say that something returns a Animal when in fact this thing returns a Cat
class Covariance
{
        void test()
        {
                Func<Animal> a = Method; // OK
                Func<Animal> b = delegate { return new Cat(); }; // OK
                Func<Animal> c = () => new Cat(); // OK
        }

        Cat Method()
        {
                return new Cat();
        }
}

Download this code: covariance.cs

So Funcs a, b, and c are returning animals which in fact are cats, which is true.

And, what is contravariance ?
Contravariance is basically using a method which takes something which is a parent of the expected type.
An exemple ? It’s safe to have a method taking an animal when you expect it to take a cat

// It's safe to say that something can take a Cat if in fact this thing can take any Animal
class Contravariance
{
        static void test()
        {
                Action<Cat> a = Method; // OK
                Action<Cat> b = delegate(Animal value) { }; // ERROR
                // From C#3 Specification :
                // $7.14.1 Anonymous function signatures :
                // [...] contra-variance of anonymous function parameter types is not supported.
                Action<Cat> d = (Animal value) => { }; // idem... anonymous... not supported.
        }

        public static void Method(Animal value)
        {
        }
}

Download this code: contravariance.cs

So Action a take Cats, but in fact can take any Animals, so it’s safe.

What you need :
 
• be familiar with Blend
• be familiar with Visual Studio
• half an hour

 
 
 

Introduction

 
Many years ago, a friend taught me how to make a flash light effect with flash.
You probably saw it in many tutorials.
 
 

 
Today, we will try to do better with silverlight :)

 
 
 

The Blend Part

 

Create a new project

 


I’m doing it with Blend, but you can use Visual Studio if you want.

 
 

Add an image

 


Add it to the project.

 
 


Resize the image to give it the same size that the LayoutRoot

 
 

Draw a rectangle

 
 


select the tool

 
 


You should get this.

 
 

Gradient Brush and Radial Gradient

 
 


Set up the rectangle background as a gradientbrush

 
 


And click on the radial gradient option

 
 


You rectangle should look like this.

 
 

Transparency

 
 


Set the first gradiant to black

 
 


For the other one, same color but set transparenrcy to half

 
 


We begin to see the final result
 
 

Draw your Flashlight

 
 


Play with gradiant and try to make something which looks like a light.

 
 


Here is the artistical part :)

 
 


Well, i think i’m fine.

 
 


For me, it looks like this.

 
 

Transform the Brush

 
 
if you want to be able to move, you have to enlarge the brush.
 


Select the “Brush Transform” tool.

 
 


Resize the brush to about one and half.

 
 
 
 

The Visual Studio part

 

 

Ok this part is ridiculous you have to add a method in FlashLight.xaml.cs to register mouse move.
 

namespace FlashLight
{
    public partial class Page : UserControl
    {
        public Page()
        {
            // Required to initialize variables
            InitializeComponent();
            LayoutRoot.MouseMove += new MouseEventHandler(LayoutRoot_MouseMove);
        }

        void LayoutRoot_MouseMove(object sender, MouseEventArgs e)
        {
            Point newPosition = e.GetPosition(this);
            RadialGradientBrush radialGradient = (RadialGradientBrush)Light.Fill;
            radialGradient.GradientOrigin = new Point(newPosition.X / 640, newPosition.Y / 400);
            Light.Fill = radialGradient;
        }
    }
}

Download this code: FlashLight.cs

 
 
 

Conclusion

 
 
Actually, i’m pretty sure that you can do the same with the last version of Flash but this tutorial is a good exercise to practice with Blend.
Thanks for reading. You can download the source code here.
 
 

In this Part, we’ll speak about Custom Control’s properties : How to databind a template property to an exposed property, and how to create new exposed properties.

The idea is to expose properties of your custom control to its users, as your custom control is inheriting another, its basically exposes the sames, in the previous article, we got
public class EditableTextBlock : Control
so our EditableTextBlock exposes Width, Height, Background …

But setting EditableTextBlock’s Background to Red does not affects the Grid’s Background Property (setted to AliceBlue) in the Template (generic.xaml), you can try it :

<ctrl:EditableTextBlock Background="Red"></ctrl:EditableTextBlock>

Download this code: Page.part.xaml

The control stay in AliceBlue …

At this point you can use some DataBinding to link the value of a property in your control template to the value of some exposed property of its parent, to do this, in generic.xaml, the Grid’s Background property must be Binded to the exposed Background Property :

<ResourceDictionary
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:controls="clr-namespace:Custom_Control_1">
    <Style TargetType="controls:EditableTextBlock">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="controls:EditableTextBlock">
                    <Grid Background="{TemplateBinding Background}">
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

Download this code: generic.xaml

Now, the Grid’s Background is binded to the exposed Background !

How to create a new property ?
You have to use a DependencyProperty to expose your property :
Basically, a DependencyPorperty look like this :

// Replace [TYPE] with your property type
// Replace [NAME] with your property name
public [TYPE] [NAME]
{
    get
    {
        return ([TYPE])GetValue([NAME]Property);
    }
    set
    {
        SetValue([NAME]Property, value);
    }
}

public static readonly DependencyProperty [NAME]Property = DependencyProperty.Register("[NAME]", typeof([TYPE]), typeof(EditableTextBlock), new PropertyMetadata([DEPEND ON THE TYPE]);
// For more informations about PropertyMetadata and DependencyProperty
// Read : http://msdn.microsoft.com/en-us/library/system.windows.dependencyproperty.aspx

Download this code: DependencyProperty.cs

So a Text Property looks like this :

public string Text
{
        get
        {
                return (string)GetValue(TextProperty);
        }
        set
        {
                SetValue(TextProperty, value);
        }
}

public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(EditableTextBlock), new PropertyMetadata(string.Empty));

Download this code: TextProperty.cs

The EditableTextBlock control now exposes a Text property which can be Binded in your Template.

• A .cs file, named with your new Custom Control name
• A directory named Themes
• A generic.xaml file in it (just delete generic.xaml.cs if it was created)

A basic custom control .cs file (the logic part):

using System.Windows.Controls;

namespace Custom_Control_1
{
    public class EditableTextBlock : Control
    {
        public EditableTextBlock()
        {
            DefaultStyleKey = typeof(EditableTextBlock);
        }
    }
}

Download this code: EditableTextBlock.cs

A basic custom control generic.xaml file (the graphic part):

<ResourceDictionary
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:controls="clr-namespace:Custom_Control_1">
    <Style TargetType="controls:EditableTextBlock">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="controls:EditableTextBlock">
                    <Grid Background="AliceBlue">
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

Download this code: generic.xaml

Now, to test, you need to add the xmlns of your namespace, and add the usercontrol :

<UserControl x:Class="Custom_Control_1.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:ctrl="clr-namespace:Custom_Control_1"
    Width="400" Height="300">
    <Grid x:Name="LayoutRoot" Background="White">
        <ctrl:EditableTextBlock></ctrl:EditableTextBlock>
    </Grid>
</UserControl>

Download this code: page.xaml

In the next article, we’ll see how to bind properties with TemplateBinding.
Don’t forgot to read the MSDN !

As i’m speaking to developers, i’ll use the C# Lambda syntax which is :
(parameter) => statement

Let’s now try our first Combinator, named the Identity Combinator
I = (a) => a;
I named it I, it takes one parameter, localy named ‘a’ and return the parameter as is.

Important Point : How to build combinator taking more than one parameter ?
In C# you should use (a, b, c) => blah blah… but the Rule 4 forbid us to give more than one paraneter, so let’s cheat, imagine :
K = (x) => (y) => x;
K is a Combinator taking x, returning a Combinator taking y and returning x.
so we have K(x) = (y) => x and K(x)(y) = x !
So K take two arguments, x and y, and returns x, but ! K can take only one argument, look at the “K(x) = (y) => x” …

Let’s try with three arguments :

S = (x) => (y) => (z) => x(z)(y(z))
can be called with one, two, or three arguments :
S(x) returns (y) => (z) => x(z)(y(z))
S(x)(y) returns (z) => x(z)(y(z))
s(x)(y)(z) returns x(z)(y(z))

In combinatory logic, they wrote :
I a = a
K x y = x
S x y z = x(z)(y(z))

then they say that in fact, I can be build from S and K :
I = SKK
Ok but what does it means ? where are arguments ? it’s easy :

I = S(K)(K);
S can take 2 parameters “S(x)(y) returns (z) => x(z)(y(z))” ok ? so :
I = (z) => K(z)(K(z))
We have to execute it from left to right, remember, K(a)(b) returns a, so (with a == z and b == K(z)) :
I = (z) => z;

Do you want more ?

Let’s try to understand
B = S (K S) K x y z
B stands for Barbara, from “Syllogism Barbara” (wikipedia says :)
Barbara :
All men are animals.
All animals are mortal.
All men are mortal.

So before all, write B as we understand it, and for readability reasons, i’ll underline parameters for the bolded combinator :
B = S (K(S)) K (x) (y) (z)
We have to execute it from left to right, and we have a S with three parameters :
S(a)(b)(c) returns a(c)(b(c)) :
B = K (S) (x) (K(x)) (y) (z)
From left to right we have a K with two parameters, S and y, it will return S :
B = S (K(x)) (y) (z)
Calling S with three parameters (K(x)), (y), (z) returns (K(x))(z)((y)(z)) :
B = K (x) (z) ((y)(z))
Calling K with two parameters (x), (z), it returns x :
B = x((y)(z))
Which can be simplified to :
B = x(y(z))

It’s time to try it !

delegate C C(C c);
static void Main(string[] args)
{
        C K = (a) => (b) => a;
        C S = (a) => (b) => (c) => a(c)(b(c));
        C I = S(K)(K);
        C B = S(K(S))(K);
}

Download this code: test.cs

It works ! Enjoy ! ! Next time, we will try a Swap combinator, a Combinator reducing to himself and progressing step to the Y Combinator !
[dramatic chord]

string pageTitle = getTitle() ? getTitle() : "Default Title";

Download this code: bad_situation.cs

You would want to call getTitle() only once, but then you wouldn’t have a simple one-lined initialization of you variable.

Actually there is a simple solution that most langages implements, the null coalescing operator; let’s replace the above C# code with this one :

string pageTitle = getTitle() ?? "Default Title";

Download this code: solution.cs

Now you have the same behaviour, but with only one call to your function. The syntax is simple :

possibly_null_value ?? value_if_null

the “??” operator is implemented in C# since C# 2.0.

You also have it in C and C++ as a GNU extension using the “?:” operator :

string pageTitle = getTitle() ?: "Default Title";

Download this code: solution.cpp

You can get the same behaviour in javascript using the “||” operator :

pageTitle = getTitle() || "Default Title";

Download this code: solution.js

You can read more about this operator here and here

Basically, a Lazy Loading allow you to predifine some paths where PHP should seek for classes to include, this allow you to directly instantiate an object without having included its file.

public static function lazyLoad($strClassName)
{
        /* some work to find the file to include mixing strClassName */

        /* include your files here... */
}
spl_autoload_register("lazyLoad");

Download this code: lazy.php