En particulier il nous présente, bien entendu les classiques BitmapCreateOptions de la classe BitmapImage pour choisir un chargement/décodage à la demande ou immédiat.

Mais aussi le PictureDecoder, qui permet de décoder une image dans la résolution voulue, et donc de gagner en vitesse et empreinte mémoire ! Malheureusement, celui ci ne sait décoder que les JPG, et pas les PNG…

Une dernière chose, à laquelle je me suis heurté lors du développement du Tile Toolkit : le décodage d’image ne peut se faire QUE sur le thread UI et c’est fort dommage…

English readers, you’ll find the link to Codeplex (where everything about the projet is written in English), at the end of this post.

Envie d’avoir une belle tuile avec un compteur comme celles du systèmes ?
De générer un contenu de tuile dynamiquement depuis C# avec un peu de composition graphique ? Idéalement le tout décrit en XAML ?
Ou encore d’utiliser des tuiles dans l’UI de votre appli ?

Je viens de publier sur Codeplex une petite (20Ko) librairie Open source (MS-PL) qui permet tout ça !
Le but du jeu était à la base de permettre à mes copains développeurs WP7 d’avoir des tuiles identiques au pixel-près à celles des mails/SMS, mais j’ai un petit peu dévié dans le scope et la lib permet de générer une tuile avec le contenu de votre choix, le tout décrit en XAML.

Elle est livrée avec un template de Tile identique aux tuiles mails/SMS. Je suis ouvert aux feature-request et rapports de bugs, bien évidemment.

En espérant vous rendre service , vous trouverez le binaire et le sample (dans le code source) sur CodePlex.

Links

• Codeplex project home : http://wp7tiletoolkit.codeplex.com/
• NuGet project page : http://nuget.org/packages/Ree7.WPTileToolkit
• NuGet command line :

• PM> Install-Package Ree7.WPTileToolkit

Depuis que je fais de l’informatique, j’ai toujours eu un faible pour les thèmes de couleur sombres, surtout quand il s’agit d’y passer la journée…

Visual Studio ne fait pas exception, et j’en profite pour glisser un lien vers le thème que j’utilise actuellement : Monokai.

Disponible aussi (en light) sur studiostyl.es

Amis développeurs du Sud-Est (et d’ailleurs, on n’est pas sectaires !), un évènement autour de Windows Phone 7 va avoir lieu dans notre belle ville de Lyon (comme quoi à Lyon, il n’y a pas que le JUG ).

Venez nous retrouver le 22 Mars (après-midi) pour discuter de Windows Phone 7 dans une ambiance détendue (Barcamp = technologie + apérologie). Les sujets abordés seront en fonction de l’audience, cependant dans les grandes lignes :

• Fabien Decret (MVP technologies embarquées) vous parlera de développement sous WP7 (le sdk, le web, les spécificités de Windows Phone 7, …)
• Moi-même (MCP Windows Mobile) vous parlerai de développement et de design (orienté UI/UX, Expression Blend, …)
• Vincent Gaviot (marketing Adeneo Embedded) vous parlera des aspects marketplace et monétisation
• Et enfin un intervenant Microsoft viendra nous épauler sur tous ces sujets

C’est une première sur Lyon et c’est gratuit. Par contre, les places sont limitées.
Pour vous inscrire ou avoir plus d’infos, contactez-nous : training.emea[at]adeneo-embedded.com

Vous avez tout juste sorti votre nouveau téléphone de son coffret et jusque ici vous utilisiez un iPod/iPhone pour emmener votre musique avec vous ? Bien sur, avec le temps, le contenu de votre device siglé de la pomme est devenu une séléction du meilleur de votre collection musicale qui prendrait des lustres à refaire, hors de question de repartir de zéro !

La manipulation n’est pas si simple que cela, mais suivez le guide et vous pourrez retrouver votre bibliothèque sur votre Windows Phone ! (et réjouissez-vous, vous pourrez raffiner bien plus facilement votre collection musicale a l’avenir, contrairement à un iPod, WP7 sait SUPPRIMER un morceau de musique).

Note for my english-speaking readers, there’s no english version of this post so far (lack of time), but if you need one leave a comment and I’ll make one.

[cliquez sur les image pour les agrandir]

iTunes ne permettant pas de récupérer le contenu de votre iPod sous forme de mp3, il faut faire appel à ce bon vieux Winamp.
Une fois installé, son module de reconnaissance de périphérique vous montrera le contenu de vos périphériques Apple et Android.

• Affichez le contenu de votre périphérique en cliquant dessus
• Sélectionnez toutes les pistes
• Via un clic droit, affichez le menu contextuel (cf. photo 1) et sélectionnez « Copier dans les Médias Locaux ». Ceci va transférer le contenu de votre iPod dans le dossier d’export par défaut de Winamp (généralement [User]\Ma musique), pour plus de facilité, assurez-vous que ce répertoire soit vide avant de vous lancer (quitte à déplacer temporairement son contenu)

Une fois le transfert terminé, pour m’y retrouver plus facilement j’ai regroupé mes mp3 dans un sous-dossier « iPod content ». A ce stade vous devriez retrouver tous vos morceaux, nommés selon leurs tags, et proprement groupés par répertoire, merci Winamp.

Passons à Zune. Lorsque vous faites glisser un élément vers votre téléphone, par défaut, Zune va établir un groupe de synchronisation pour cet élément. C’est pas clair ? Oui je l’avoue. En clair, vous faites glisser un album de Skrillex sur votre téléphone, si jamais vous ajoutez une nouvelle piste de l’artiste Skrillex dans la collection du PC, Zune va automatiquement la copier sur le téléphone.

Gentille attention, mais qui va à l’encontre de ce que l’on veut faire ici (sinon vous allez finir avec l’intégralité de vos mp3 sur le téléphone… du moins ce qui tient dans les maigres 8 à 16Go).

Donc il faut aller dans les paramètres de Zune, section « Téléphone », « Options Sync » et pour ce qui est de la musique, cocher l’option de synchronisation « Manuel » (cf. photo 3).

Maintenant, au tour aux paramètres du logiciel en lui même (paramètres > « Logiciel » > « Collection »). Utilisateurs de Windows Vista et supérieur, par défaut les collections (musique, vidéo, image) de Zune sont couplées aux collections correspondantes de l’OS. Pratique, généralement, rien à configurer après l’installation de Zune, tout fonctionne déjà !
Mais le temps de notre manip’, il va falloir désaligner les collections Windows de celles de Zune, c’est à dire permettre de spécifier soi-même les répertoires où Zune cherchera son contenu.

Ensuite, il faut faire le vide dans la liste des répertoires surveillés pour la musique, puis ajouter uniquement le répertoire contenant les pistes de l’iPod (cf. photo 4).
Du coup, après un court instant d’analyse du contenu du dossier, la bibliothèque musicale Zune contient toutes les pistes en provenance de l’iPod/iPhone, il ne vous reste plus qu’a faire glisser l’ensemble de votre collection musicale vers l’icône du téléphone en bas à gauche de Zune, et le tour est joué ! (En passant, Zune offre la possibilité de transcoder à la volée les morceaux dont le bitrate dépasse un certain seuil, ce qui vous permettra de ne pas remplir trop vite votre téléphone avec des morceaux en 320kbps).

Vous pouvez bien sur remettre la configuration de la source de la bibliothèque musicale de Zune dans son état initiale une fois le transfert des pistes sur le téléphone terminé. Bonne écoute !

Elle est de transformer un arbre XAML en une image, seule ombre au tableau; cette classe est parfaite pour l’affichage à l’écran, en effet le contrôle Image est capable d’afficher un WriteableBitmap mais pour la sauvegarde c’est une autre paire de manche : nativement, Silverlight ne propose pas d’encodeur PNG ou JPEG pour exporter ce paquet de pixels.

Le code qui suit vous permettra de profiter de la praticité de Silverlight pour composer une image (à vous les superpositions alpha, le texte antialiasé positionné comme bon vous semble en quelques lignes, les layouts faciles à utiliser – grid, stackpanel, …) exportable en PNG non compressé (attention quand même du coup, et en passant merci à Joe Stegman pour son PNGEncoder).

Vous pourrez ensuite manipuler ces images comme bon vous semble, car deux formats de sorties sont disponibles, l’une en Stream et l’autre en Byte[]. Aucun problème pour les sérialiser (contrairement aux BitmapImage)

Code and english version of the post available below

Here’s a piece of code that could help your Silverlight developments (SL3 and newer, Windows Phone 7, …) : if you need to generate an image in your application, starting with Silverlight 3 the WriteableBitmap class is available to create an image and interact with it pixel by pixel.

WriteableBitmap can transform a XAML visual tree into an image (meaning a pixel array); this is perfect for a screen output as the Image control knows how to display it. For saving on the other hand, it’s a different story : Silverlight simply does not provide a PNG or JPEG encoder to export that pixel array.

The following code will enable you to leverage Silverlight’s convenience for composing an image (alpha overlays, antialised text, straightforward containers for your layout, …), and export it as a PNG image (uncompressed) – thanks Joe Stegman for your PNGEncoder -.

You will then be able to manipulate those images the way your want, two outputs are available, one as a Stream and the other one as a Byte[]. Unlike the BitmapImage, you’ll be able to serialize it as a part of your classes .

Preview code :

/**********************************************************
 * Control2Png.cs
 * Renders a Silverlight UIElement as an uncompressed PNG
 * stream or byte array. Relies on Joe Stegman's great
 * PNGEncoder classes.
 *
 * Written by : Pierre BELIN

 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the Lesser GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the Lesser GNU General Public License
 * along with this program.  If not, see .
 *
 **********************************************************/

using System;
using System.IO;
using System.Windows;
using System.Windows.Media.Imaging;

namespace Ree7.Utils.Imaging
{
    ///
<summary> /// See http://ree7.fr/blog/2010/10/composition-dimage-rendre-du-xaml-sous-forme-dimage/
 /// </summary>
    public class ControlToPng
    {
        public static Stream RenderAsPNGStream(UIElement e)
        {
            try
            {
                WriteableBitmap wb = new WriteableBitmap(e, null);
                EditableImage edit = new EditableImage(wb.PixelWidth, wb.PixelHeight);

                for (int y = 0; y < wb.PixelHeight; ++y)
                {
                    for (int x = 0; x < wb.PixelWidth; ++x)
                    {
                        byte[] rgba = ExtractRGBAfromPremultipliedARGB(wb.Pixels[wb.PixelWidth * y + x]);
                        edit.SetPixel(x, y, rgba[0], rgba[1], rgba[2], rgba[3]);
                    }
                }

                return edit.GetStream();

            }
            catch (Exception)
            {
                return null;
            }
        }

        public static byte[] RenderAsPNGBytes(UIElement e)
        {
            Stream s = RenderAsPNGStream(e);

            if (s == null)
                return null;

            byte[] bytes = ReadFully(s, (int)s.Length);
            return bytes;
        }

        ///
<summary> /// Convert from premultiplied alpha ARGB to a non-premultiplied RGBA (fix 12/2011)
 /// </summary>
        ///
        private static byte[] ExtractRGBAfromPremultipliedARGB(int pARGB)
        {
            byte[] sourcebytes = new byte[4];
            sourcebytes[0] = (byte)(pARGB >> 24);
            sourcebytes[1] = (byte)((pARGB & 0x00FF0000) >> 16);
            sourcebytes[2] = (byte)((pARGB & 0x0000FF00) >> 8);
            sourcebytes[3] = (byte)(pARGB & 0x000000FF);

            if (pARGB == 0) return sourcebytes; // optimization for images with many transparent pixels

            byte[] destbytes = new byte[4];

            if (sourcebytes[0] == 0 || sourcebytes[0] == 255)
            {
                destbytes[0] = sourcebytes[1];
                destbytes[1] = sourcebytes[2];
                destbytes[2] = sourcebytes[3];
                destbytes[3] = sourcebytes[0];
            }
            else
            {
                double factor = 255.0 / sourcebytes[0];
                double r = sourcebytes[1] * factor;
                double g = sourcebytes[2] * factor;
                double b = sourcebytes[3] * factor;

                destbytes[0] = Convert.ToByte(Math.Min(Byte.MaxValue, r));
                destbytes[1] = Convert.ToByte(Math.Min(Byte.MaxValue, g));
                destbytes[2] = Convert.ToByte(Math.Min(Byte.MaxValue, b));
                destbytes[3] = sourcebytes[0];
            }

            return destbytes;
        }

        ///
<summary> /// Reads data from a stream until the end is reached. The
 /// data is returned as a byte array. An IOException is
 /// thrown if any of the underlying IO calls fail.
 /// </summary>
        ///The stream to read data from
        ///The initial buffer length
        private static byte[] ReadFully(Stream stream, int initialLength)
        {
            // If we've been passed an unhelpful initial length, just
            // use 32K.
            if (initialLength < 1)
            {
                initialLength = 32768;
            }

            byte[] buffer = new byte[initialLength];
            int read = 0;

            int chunk;
            while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0)
            {
                read += chunk;

                // If we've reached the end of our buffer, check to see if there's
                // any more information
                if (read == buffer.Length)
                {
                    int nextByte = stream.ReadByte();

                    // End of stream? If so, we're done
                    if (nextByte == -1)
                    {
                        return buffer;
                    }

                    // Nope. Resize the buffer, put in the byte we've just
                    // read, and continue
                    byte[] newBuffer = new byte[buffer.Length * 2];
                    Array.Copy(buffer, newBuffer, buffer.Length);
                    newBuffer[read] = (byte)nextByte;
                    buffer = newBuffer;
                    read++;
                }
            }
            // Buffer is now too big. Shrink it.
            byte[] ret = new byte[read];
            Array.Copy(buffer, ret, read);
            return ret;
        }
    }
}

Update 01/12/2011 : Fixed the error for translucent pixels that were not looking right, I forgot to offset the color values as WritableBitmap gives premultiplied alpha pixel values.

• Source code : Control2Png.zip

Cela peut être fort gênant si vous développez une application de musique (radio), ou vidéo (bien que si vous utilisez MediaElement, les choses ont été bien faites et la lecture d’un média inhibe le lockscreen), ou encore une application de tracking GPS (#ridetracker, projet WP7 à venir sur ce blog).

Sachez que vous pouvez inhiber la veille du téléphone de deux façons :

• Microsoft.Phone.Shell.PhoneApplicationService.Current.ApplicationIdleDetectionMode = Microsoft.Phone.Shell.IdleDetectionMode.Disabled
  Permet à votre application de ne pas se faire tombstonner quand le téléphone se met en veille, en clair votre application tourne derrière le lockscreen. C’est le comportement le plus proche d’un thread d’arrière plan.
• Microsoft.Phone.Shell.PhoneApplicationService.Current.UserIdleDetectionMode = Microsoft.Phone.Shell.IdleDetectionMode.Disabled
  Permet de désactiver purement et simplement le lockscreen !

Tant que j’y suis, PhoneApplicationService contient une autre propriété intéressante : Microsoft.Phone.Shell.PhoneApplicationService.Current.StartupMode, qui permet de savoir si vous êtes dans une nouvelle instance de l’application ou bien si vous êtes réssucité d’un état tombstonné.

[English version below]

English version : Disable Windows Phone 7′s lock screen

Windows Phone 7 does not allows multitasking for 3rd-party developpers, but I think you already know about that. But say you’re looking to develop an app that keeps the phone busy for a while, without requesting any user interaction (what could have been a background thread on WM6.5 or Android, but that’s another topic…) : you’re going to have a problem, within some time the phone will go to standby mode, and your app is going to be tombstonned.

That could be a problem if you’re developping a music/radio/video app (even though the fact that you should use a MediaElement, and it’s smart enough to disable to lockscreen while a media is played), or a GPS tracking app (#ridetracker, more to come soon on this blog).

Well, you can solve this problem by using one of the following

• Microsoft.Phone.Shell.PhoneApplicationService.Current.ApplicationIdleDetectionMode = Microsoft.Phone.Shell.IdleDetectionMode.Disabled
  The shell won’t kill your process while the lockscreen is on. That’s the closest behavior to a background thread.
• Microsoft.Phone.Shell.PhoneApplicationService.Current.UserIdleDetectionMode = Microsoft.Phone.Shell.IdleDetectionMode.Disabled
  This one will simply disable the lockscreen !

And while I’m at it, there’s another interesting item in PhoneApplicationService : Microsoft.Phone.Shell.PhoneApplicationService.Current.StartupMode which value tells your application is a fresh instance or bought back to life from tombstonning.

Nativement, dans Visual Studio nous avons à notre disposition prop et propdp, bien utiles dans la vie de tous les jours du développeur Silverlight pour créer propriétés et DependencyProperties sans trop avoir à taper du code purement répétitif. Par contre rien pour les propriétés déclenchant l’évènement PropertyChanged - sans doute car l’implémentation concrète d’INotifyPropertyChanged est laissée au développeur… bien que l’on fasse quasiement tous pareil.

Pour palier à ce manque je vous propose nprop, un snippet venant s’ajouter à votre IDE et qui vous permettra du temps dans vos développements

Elle s’utilise comme n’importe quel autre snippet, tapez juste nprop puis TAB et le code apparaitra en vous invitant à remplir les trous.

• Fichier d’installation automatique .vsi
• Fichier snippet nu à placer dans votre dossier %Documents%\Visual Studio 20xx\Code Snippets\Visual C#\My Code Snippets au cas où le fichier précédent poserait problème

Cette primitive permet de savoir si le code courant tourne dans le thread d’UI ou pas, et donc si un BeginInvoke() est nécessaire ou pas.

Exemple, pour récupérer un setting de l’IsolatedStorage depuis n’importe quel thread :

public void GetSetting(string key, out object value)
        {
            if (Deployment.Current.Dispatcher.CheckAccess())
            {
                value = IsolatedStorageSettings.ApplicationSettings[key];
            }
            else
            {
                using (ManualResetEvent sync = new ManualResetEvent(false))
                {
                    object _value = null;

                    Deployment.Current.Dispatcher.BeginInvoke(() =>
                        {
                            _value = IsolatedStorageSettings.ApplicationSettings[key];
                            sync.Set();
                        });

                    sync.WaitOne();
                    value = _value;
                }
            }
        }

Et bien CheckAccess() est toujours bien là dans la classe Dispatcher, même si l’Intellisense de Visual Studio ne vous la propose pas.

Rappel : Pour les débutants en multi-threading sous Silverlight, le seul Dispatcher auquel vous avez accès depuis un autre thread que l’UI est Deployment.Current.Dispatcher. Si vous essayez de taper directement dans le Dispatcher d’un FrameworkElement vous irez tout droit à la CrossThreadException .

Source : Forums MSDN

Attention, pour le coup vous perdrez l’avantage des requêtes asynchrones et votre thread appelant sera bloqué pendant le déroulement de la requête, comme au bon vieux temps !
Tout retour de bug ou message de remerciement est le bienvenu, ce code est disponible sous licence LGPL.

If you’re looking forward to port .NET applications to Silverlight/Windows Phone 7, the following might interest you.
In Silverlight, the WebRequests are asynchronous (and that’s a good thing), but this change in the API can cause numerous changes in your code. That’s what lead me to write this C# class : HttpWebRequestSync featuring an interface as close as possible as what was there before.

Note that you’ll lose the advantage of asynchronous requests and that you’re thread will be locked waiting for the request to complete, ol’school style.
If you find any bug or just want to leave a ‘thank you’ not you’re welcome. This code is available under the LGPL license.

/**********************************************************
 * HttpWebRequestSync.cs
 * Provides an implementation close to the .NET CF (3.5)
 * synchronous HttpWebRequest with Windows Phone 7's
 * asynchronous implementation.
 * TL;DR : Abstract the dev from all the async callback.
 *
 * Written by : Pierre BELIN <pierre.belin@inbox.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the Lesser GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the Lesser GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 **********************************************************/
using System;
using System.Net;
using System.Threading;
using System.IO;

namespace Ree7.Utils.Net
{
 public class HttpWebRequestSync
 {
 private ManualResetEvent getRequestDone = new ManualResetEvent(false);
 private ManualResetEvent getResponseDone = new ManualResetEvent(false);
 private HttpWebRequest request;

 private HttpWebResponse response;
 private Stream requestStream;

 /// <summary>
 /// Private ctor, to get an HttpWebRequestSync you shall use Create()
 /// </summary>
 private HttpWebRequestSync()
 {

 }

 /// <summary>
 /// Initializes a new HttpWebRequestSync for the specified URI scheme
 /// </summary>
 public static HttpWebRequestSync Create(string url)
 {
 return Create(new Uri(url));
 }

 /// <summary>
 /// Initializes a new HttpWebRequestSync for the specified URI scheme
 /// </summary>
 public static HttpWebRequestSync Create(Uri uri)
 {
 HttpWebRequestSync wrs = new HttpWebRequestSync();
 wrs.request = (HttpWebRequest)WebRequest.Create(uri);

 return wrs;
 }

 #region HttpWebRequest Interface
 /// <summary>
 /// Summary:
 ///     Gets or sets the value of the Accept HTTP header.
 ///
 /// Returns:
 ///     The value of the Accept HTTP header. The default value is null.
 /// </summary>
 public string Accept
 {
 get
 {
 return request.Accept;
 }
 set
 {
 request.Accept = value;
 }
 }
 /// <summary>
 /// Not Implemented Yet
 /// </summary>
 public int ContentLength
 {
 get
 {
 return 0;
 }
 set
 {
 return;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets or sets the value of the Content-type HTTP header.
 ///
 /// Returns:
 ///     The value of the Content-type HTTP header. The default value is null.
 /// </summary>
 public string ContentType
 {
 get
 {
 return request.ContentType;
 }
 set
 {
 request.ContentType = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Specifies the collection of System.Net.CookieCollection objects associated
 ///     with the HTTP request.
 ///
 /// Returns:
 ///     A System.Net.CookieContainer that contains a collection of System.Net.CookieCollection
 ///     objects associated with the HTTP request.
 ///
 /// Exceptions:
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 /// </summary>
 public CookieContainer CookieContainer
 {
 get
 {
 return request.CookieContainer;
 }
 set
 {
 request.CookieContainer = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets a value that indicates whether a response has been received from an
 ///     Internet resource.
 ///
 /// Returns:
 ///     true if a response has been received; otherwise, false.
 ///
 /// Exceptions:
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 /// </summary>
 public bool HaveResponse
 {
 get
 {
 return request.HaveResponse;
 }
 }
 /// <summary>
 /// Returns the underlying HttpWebRequest (handle it with care)
 /// </summary>
 public HttpWebRequest HttpWebRequest
 {
 get
 {
 return request;
 }
 }
 /// <summary>
 /// Summary:
 ///     Specifies a collection of the name/value pairs that make up the HTTP headers.
 ///
 /// Returns:
 ///     A System.Net.WebHeaderCollection that contains the name/value pairs that
 ///     make up the headers for the HTTP request.
 ///
 /// Exceptions:
 ///   System.InvalidOperationException:
 ///     The request has been started by calling the System.Net.HttpWebRequest.BeginGetRequestStream

(System.AsyncCallback,System.Object)
 ///     or System.Net.HttpWebRequest.BeginGetResponse(System.AsyncCallback,System.Object)
 ///     method.
 /// </summary>
 public WebHeaderCollection Headers
 {
 get
 {
 return request.Headers;
 }
 set
 {
 request.Headers = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets or sets the method for the request.
 ///
 /// Returns:
 ///     The request method to use to contact the Internet resource. The default value
 ///     is GET.
 ///
 /// Exceptions:
 ///   System.ArgumentException:
 ///     No method is supplied.-or- The method string contains invalid characters.
 ///
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 ///
 ///   System.NotSupportedException:
 ///     The System.Net.HttpWebRequest.Method property is not GET or POST.
 /// </summary>
 public string Method
 {
 get
 {
 return request.Method;
 }
 set
 {
 request.Method = value;
 }
 }
 /// <summary>
 /// Summary:
 ///     Gets the original Uniform Resource Identifier (URI) of the request.
 ///
 /// Returns:
 ///     A System.Uri that contains the URI of the Internet resource passed to the
 ///     System.Net.WebRequest.Create(System.Uri) method.
 ///
 /// Exceptions:
 ///   System.NotImplementedException:
 ///     This property is not implemented.
 /// </summary>
 public Uri RequestUri
 {
 get
 {
 return request.RequestUri;
 }
 }
 #endregion

 public Stream GetRequestStream()
 {
 // start the asynchronous operation
 request.AllowReadStreamBuffering = false;
 request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), request);

 // Keep the main thread from continuing while the asynchronous
 // operation completes. A real world application
 // could do something useful such as updating its user interface.
 getRequestDone.WaitOne();

 Stream result = requestStream;

 // Avoid keeping an unnecessary ref on the stream in this object
 requestStream = null;

 return result;
 }

 private void GetRequestStreamCallback(IAsyncResult asynchronousResult)
 {
 request = (HttpWebRequest)asynchronousResult.AsyncState;
 requestStream = request.EndGetRequestStream(asynchronousResult);

 getRequestDone.Set();
 }

 public HttpWebResponse GetResponse()
 {
 // Start the asynchronous operation to get the response
 request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);

 getResponseDone.WaitOne();

 HttpWebResponse result = response;

 // Avoid keeping an unnecessary ref on the response in this object
 response = null;

 return result;
 }

 private void GetResponseCallback(IAsyncResult asynchronousResult)
 {
 request = (HttpWebRequest)asynchronousResult.AsyncState;

 // End the operation
 response = (HttpWebResponse)request.EndGetResponse(asynchronousResult);

 getResponseDone.Set();
 }

 }
}