Tag Archives: .net

Save WPF control as XPS and fit it into an A4 papersize page.

NET%20LogoA little code snippet to export to XPS a WPF control, for instance your view, and fit it into an A4 standard page, in example for printing purpose. (in this case, take care of the margins !!)

public void SaveCurrentViewToXPS()
{
	// Configure save file dialog box
	Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
	dlg.FileName = String.Format("MyFile{0:ddMMyyyyHHmmss}", DateTime.Now); // Default file name
	dlg.DefaultExt = ".xps"; // Default file extension
	dlg.Filter = "XPS Documents (.xps)|*.xps"; // Filter files by extension

	// Show save file dialog box
	Nullable<bool> result = dlg.ShowDialog();

	// Process save file dialog box results
	if (result == true)
	{
		// Save document
		string filename = dlg.FileName;

		// Initialize the xps document structure
		FixedDocument fixedDoc = new FixedDocument();
		PageContent pageContent = new PageContent();
		FixedPage fixedPage = new FixedPage();

		// Create the document and set the datacontext
		AnalysisView view = new AnalysisView();                
		view.DataContext = theControlDataContext;
		view.UpdateLayout();
		
		// Get the page size of an A4 document
		var pageSize = new Size(8.5 * 96.0, 11.0 * 96.0);
		
		// We just fit it horizontally, so only the width is set here
		//view.Height = pageSize.Height;
		view.Width = pageSize.Width;
		view.UpdateLayout();

		//Create first page of document
		fixedPage.Children.Add(view);
		((System.Windows.Markup.IAddChild)pageContent).AddChild(fixedPage);
		fixedDoc.Pages.Add(pageContent);
		
		// Create the xps file and write it
		XpsDocument xpsd = new XpsDocument(filename, FileAccess.ReadWrite);
		XpsDocumentWriter xw = XpsDocument.CreateXpsDocumentWriter(xpsd);
		xw.Write(fixedDoc);
		xpsd.Close();
	}
}

Send SMS in C# with Xamarin MonoForAndroid

Android_robot.svg I’ve started to develop android app’s in C# with the ubber great Xamarin MonoForAndroid framework which allow us to develop android apps in C#/.Net. If you don’t know it yet, take a look at their website, a truly great product 🙂
Anyway, I just share to you a little code snippet to send SMS from your MonoForAndroid app’s with two different mode. The first one, “Direct mode”, directly send the sms without asking the user to take a decision. The second one, based on android intent, will request the user to pick a sending service (i.e. Sms, Facebook, LinkedIn, Twitter), and will start the selected apps.

So to send the sms in direct mode, we just need these two lines of code :

                    PendingIntent pendingIntent = PendingIntent.GetActivity(this, 0, new Intent(this, typeof(/*Type of the activity*/)), 0);
                    SmsManager.Default.SendTextMessage(number, null, textToSend, pendingIntent, null);

And then, the intent mode, not more complex, but require few additional lines :

            var smsUri = Android.Net.Uri.Parse(String.Format("smsto:{0}", number));
            var smsIntent = new Intent(Intent.ActionSendto, smsUri);
            smsIntent.PutExtra("sms_body", textToSend);
            smsIntent.AddFlags(ActivityFlags.NewTask);
            StartActivity(smsIntent);

Send a file trough bluetooth in C# with 32Feet.NET

32feet Once again, another article about this little puppy called 32Feet.NET. In the previous article I show you how to download a file, now we will send a file to the remote device. Once again, proceed in two steps. First one, as in the previous article (https://istacee.wordpress.com/2013/02/22/download-a-file-through-bluetooth-in-c-with-32feet-net/) juste retrieve the BluetoothDeviceInfo object. And here’s the upload method 🙂

        public void SendFile(BluetoothDeviceInfo device, string fileToSend, string destinationPath)
        {
            // Build te OBEX uri and create an OBEX web request
            var obexUri = new Uri("obex://" + device.DeviceAddress + "/" + destinationPath);
            var request = new ObexWebRequest(obexUri);

            // Fill the request with the file data
            request.ReadFile(fileToSend);

            // Send the request to the targeted bluetooth device
            var response = request.GetResponse() as ObexWebResponse;
            response.Close();
        }

Download a file through bluetooth in C# with 32Feet.NET

32feetHi folks, my first article in english. I finally switch from french to english. Just hope my indexing will not be too impacted ^^

So, here I’ll briefly show you how to download a file from a remote device through bluetooth with the 32feet.net library (available here). I proceed in two steps. The first one, I display a dialog box to the user in which he’s able to pick a bluetooth device. Once it’s done, I get back a BluetoothDeviceInfo object which will be used to establish the connection to the remote device and download the file. So, here we go !

Retreive the BluetoothDeviceInfo object

var sbdd = new SelectBluetoothDeviceDialog();
sbdd.ShowAuthenticated = true;
sbdd.ShowRemembered = true;
sbdd.ShowUnknown = true;

BluetoothDeviceInfo deviceInfo = null;

if (sbdd.ShowDialog() == DialogResult.OK)
     deviceInfo = sbdd.SelectedDevice;

And here’s the code to download the file. I think he’s self explanatory :p

        public void DownloadFile(BluetoothDeviceInfo device, string remoteFilePath, string remoteFileName, string localFileName)
        {
            // Create client object
            BluetoothClient cli = new BluetoothClient();

            // Connect to the given device in FileTranfer mode
            cli.Connect(new BluetoothEndPoint(device.DeviceAddress, InTheHand.Net.Bluetooth.BluetoothService.ObexFileTransfer));

            // Create a remote session and navigate to the bluetooth directory
            ObexClientSession sess = new ObexClientSession(cli.GetStream(), UInt16.MaxValue);
            sess.Connect(ObexConstant.Target.FolderBrowsing);
            // Navigate to the file location on the remote device
            sess.SetPath(remoteFilePath);

            // Create a filestream and write the content of the file into it, then filename is returned
            FileStream fs = new FileStream(localFileName, FileMode.OpenOrCreate, FileAccess.Write);
            sess.GetTo(fs, remoteFileName, null);
        }

MSMQ : Architecture et principes

Présentation de MSMQ

MSMQ, acronyme de Microsoft Message Queuing est une implémentation Microsoft de Message Queue. Une Message Queue est un ensemble de techniques permettant l’échange asynchrone de messages. Par exemple, une boite mail peut être considérée comme un MQS (j’utiliserai par la suite cette abréviation pour parler de manière générique des message queuing system), càd un endroit où l’on peut déposer de l’information dans le but d’être traité plus tard. Ainsi, dans sa version basique, l’émetteur ne se soucie pas des actions entreprises par le destinataire, tablant sur le fait que le message étant présent dans le queue, il sera traité par qui de droit quand il en sera capable. C’est donc un composant utilisé pour communiquer de l’information entre différent processus ou différent thread d’un même processus permettant.

C’est queues prennent souvent la forme de « stack » et donc hérite des propriétés de ces dernières. Bien que majoritairement de type FIFO, les 3 opérations standards des stack (push/pop/peek) ainsi que les opérations utilitaires (status/count/clear/dup/swap) sont implémentées par les fournisseurs de Message Queue. Si ces notions vous sont étrangères et souhaitez utiliser activement des systèmes de queue, je vous conseils de faire un petit tour par wikipedia 😉

Dans la pratique, on ne développe que rarement ses propres systèmes de queues et l’on préfère déployer des solutions existantes fonctionnant « off-the-shelf » comme IBM Webshpere MQ/Message Broker, MSMQ, JMS, RabbitMQ,… Ensuite on définit des queues nommées dans lesquels les applications viendront déposer leurs messages dans le but d’être traitées par d’autres systèmes ensuite. On délègue la responsabilité de la gestion des messages (envoi, routing, ACK, …) et de l’infrastructure au système de message queuing  ce qui permet découpler de souvent l’application cliente et serveur en utilisant le MQS comme « interlocuteur privilégié ».

Pour résumer, je vais refaire mon analogie avec la boite mail du point de vue de l’emetteur et du destinataire, remplacez boite mail par queue, mail par messages et le tour est joué 😉

Une boite mail est un espace de stockage de message accessible par des applications et gérée par une application serveur. Quand je veux envoyer un mail à quelqu’un, j’indique l’adresse de sa boite mail, écrit mon mail et envoi ensuite le mail au serveur d’envoi qui le transfert vers le serveur du destinataire qui, basé sur l’adresse de la boite mail principalement, peut placer le message dans un espace accessible par le propriétaire de l’adresse. Lorsque j’envoie un mail, je ne me soucie ni de l’emplacement de mon destinataire, ni du client de messagerie qu’il utilise ni de sa disponibilité. Je n’ai besoin que d’un protocole commun d’échange (SMTP pour le mail) compris par les deux parties. Je pars du principe que le mail étant envoyé, mon destinataire le lira quand il ira relever son courrier.

Le destinataire lui, lorsqu’il consulte sa boite mail, vas souvent du plus ancien non-lu au plus récent, (accès séquentiel). Mais rien ne m’empêche d’accéder directement (accès aléatoire) au message qui m’intéresse en me basant sur par exemple les métas données du mail (émetteur, objet du message, flag d’importance, …) Un fois le message consulté, je le supprime de ma boite mail (plus actuellement avec les boites mail illimité) ou le place dans un dossier de tri pour le consulter plus tards.

MSMQ, c’est une sorte de service mail pour les applications. Lancé depuis NT4 et Windows 95, MSMQ  tire parti de l’intégration au système microsoft et en fait un système d’échange de message très correct pour beaucoups de besoins. MSMQ à une déclinaison cloud pour Azure, appelé Azure Storage queue et AppFabric Service Bus. Des systèmes de messaging complexe sont aussi disponibles par exemple pour les ESB, mais cela dépasse de loin le scope de cet article.

Propriétés d’MSMQ

Le diagramme ci-dessus résumé l’échange de messages MSMQ. On y distingue deux types d’applications. Les applications d’envois et celles de réceptions. Voici les caractéristiques et options principales de chacune :

Sending Receiving
(non)/Transactionnel Lecture local ou remote
Express/Recoverability (non)/Transactionnel
Envoi direct ou en store and forward (une copie sur   chaque intermédiaire) Lecture synchrone ou asynchrone
Authentification Lecture en peek ou retreive
Encryption Online ou Offline
Online ou Offline  

 

Je vais détailler certains points qui peuvent sembler peu explicite.

Express/Recoverability permet de stocker une copie du message et d’attendre un ACK de la part du destinataire. SI le ACK ne parvient pas, le message sera ré-envoyé jusqu’au moment où le destinataire
confirmera la bonne réception du message. C’est un peu comparable à UDP/TCP.

Direct/Store-and-forward. En store-and-forward une copie du message est gardée sur chaque intermédiaire. Cela permet par exemple de ne pas interrompre l’envoi du message dans le cas où un des intermédiaires serait inaccessible.

Peek/Retrieve. En Peek, le message est conservé dans la queue alors qu’en retreive l’accès à un message le supprime de la queue.

Conclusion

Nous avons maintenant une idée globale de ce que propose MSMQ. Dans le prochain article je vous ferai une petite démo de comment utiliser MSMQ depuis du C# sur un scénario simple pour une application de chat. A bientôt 🙂

Visual Studio Code Snippet : Dependency Property et NotifyPropertyChange

UPDATE 1 : Pour des raisons que je ne détaillerai pas ici, certaines snippets ne référençait pas “http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet&#8221; comme xmlns. Le code et le zip est màj avec le “bon” xmlns.

Voici une série de code snippet que je me propose de partager avec vous. Elles sont souvent simples et certaines peuvent sembler un peu outdated, mais comme souvent, le developpement de snippet passe après la documentation et le nettoyage du clavier (vive les sandwich “croustillants” 😉 ). J’ai dev ces snippets au passage à VS2010 et leur migration vers VS2012 s’est déroulée avec succès, j’espère qu’elles vous seront toutes aussi utiles qu’à moi 🙂 La première c’est une snippet de Dprop pour WPF, une configProperty et les 3 autres sont des 3 styles de NotifPropChange dépendant de la version et du contexte d’utilisation. Je reviendrai certainement dans les jours qui suivent avec d’autres.

Dependency Property

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>dprop</Title>
      <Shortcut>dprop</Shortcut>
      <Description>Code snippet for dependecy property</Description>
      <Author>Emmanuel Istace</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>name</ID>
          <ToolTip>Property name</ToolTip>
          <Default>Property</Default>
        </Literal>
        <Literal>
          <ID>type</ID>
          <ToolTip>Property Type</ToolTip>
          <Default>object</Default>
        </Literal>
        <Literal Editable="false">
          <ID>classname</ID>
          <ToolTip>Class name</ToolTip>
          <Function>ClassName()</Function>
          <Default>ClassNamePlaceholder</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[
        
        public static readonly DependencyProperty $name$Property = DependencyProperty.Register("$name$", typeof($type$), typeof($classname$));

        public $type$ $name$
        {
            get { return ($type$)GetValue($name$Property); }
            set { SetValue($name$Property, value); }
        }

        $end$
]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Configuration Property

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>configprop</Title>
      <Shortcut>configprop</Shortcut>
      <Description>Add a configuration property</Description>
      <Author>Emmanuel Istace</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
          <Literal>
            <ID>Name</ID>
            <ToolTip>Property Name</ToolTip>
            <Default>MyProperty</Default>
          </Literal>    
          <Literal>
            <ID>type</ID>
            <ToolTip>Property Type</ToolTip>
            <Default>string</Default>
          </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[
        [ConfigurationProperty("$Name$", IsRequired = true)]
        public $type$ $Name$
        {
          get { return ($type$)this["$Name$"]; }
          set { this["$Name$"] = value; }
        }
        $end$
]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

INotifyPropertyChanged simple implementation

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>nchangeimpl</Title>
      <Shortcut>nchangeimpl</Shortcut>
      <Description>Code snippet for INotifyPropertyChanged Simple implementation</Description>
      <Author>Emmanuel Istace</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Code Language="csharp">
        <![CDATA[
        #region INotifyPropertyChanged Implementation
        public event PropertyChangedEventHandler PropertyChanged;
        protected void NotifyPropertyChanged(string sProp)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(sProp));
            }
        }
        #endregion]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Property Changed Event raising

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
	<CodeSnippet Format="1.0.0">
		<Header>
			<Title>nprop</Title>
			<Shortcut>nprop</Shortcut>
			<Description>Code snippet for property with property change event raised</Description>
			<Author>Istace Emmanuel</Author>
			<SnippetTypes>
        <SnippetType>Expansion</SnippetType>
			</SnippetTypes>
		</Header>
		<Snippet>
			<Declarations>
				<Literal>
					<ID>type</ID>
					<ToolTip>Type exposed by the dependency property</ToolTip>
					<Default>object</Default>
				</Literal>
				<Literal>
					<ID>name</ID>
					<ToolTip>Name of the dependency property</ToolTip>
					<Default>dprop</Default>
				</Literal>
			</Declarations>
			<Code Language="csharp">
				<![CDATA[
				
				#region $name$ property
				private $type$ _$name$ { get; set; }
				public $type$ $name$
				{
					get { return _$name$; }
					set
					{
					 if(value != _$name$)
					 {
					  _$name$ = value;
					  NotifyPropertyChanged("$name$");
					 }
					}
				}
				#endregion
				$end$
				
				]]>
			</Code>
		</Snippet>
	</CodeSnippet>
</CodeSnippets>

MVVM Property Changed event raising

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
	<CodeSnippet Format="1.0.0">
		<Header>
			<Title>mvvmlightprop</Title>
			<Shortcut>mvvmlightprop</Shortcut>
			<Description>Code snippet for MVVM view model property with property change event raised</Description>
			<Author>Istace Emmanuel</Author>
			<SnippetTypes>
        <SnippetType>Expansion</SnippetType>
			</SnippetTypes>
		</Header>
		<Snippet>
			<Declarations>
				<Literal>
					<ID>type</ID>
					<ToolTip>Type exposed by the dependency property</ToolTip>
					<Default>object</Default>
				</Literal>
				<Literal>
					<ID>name</ID>
					<ToolTip>Name of the dependency property</ToolTip>
					<Default>dprop</Default>
				</Literal>
			</Declarations>
			<Code Language="csharp">
				<![CDATA[
				
				#region $name$ property
				private $type$ _$name$ { get; set; }
				public $type$ $name$
				{
				  get { return _$name$; }
				  set
				  {
					  if(value != _$name$)
					  {
						  $type$ oldValue = _$name$;
						  _$name$ = value;
						  RaisePropertyChanged<$type$>("$name$", oldValue, value, false);
					  }
				  }
				}
				#endregion
				$end$
				]]>
			</Code>
		</Snippet>
	</CodeSnippet>
</CodeSnippets>

Télécharger l'archive contenant les snippets. (SkyDrive)Télécharger l’archive contenant les snippets. (SkyDrive)

WebSocket avec ASP.NET 4.5 et Microsoft.Websockets

Websocket est un standard qui permet de « développer un canal de communication bidirectionnel et full-duplex sur un socket TCP pour les navigateurs et les serveurs web. » C’est que l’on fait actuellement lorsque l’on utilise des XMLHttpRequest avec Ajax. En dotnet SignalR permettait déjà de profiter de ces features, maintenant il est possible de le faire en dotnet avec ASP.NET 4.5 à certaines conditions :

–          Application sur un IIS 8 avec la feature WebSockets

–          .NET 4.5

–          Un client compatible (IE10, Chrome 13+, Safari 5+, Opera 5+)

Premièrement, assurez-vous que le WebSocket est activé sur IIS.  Ensuite, créez un projet ASP.net et ajoutez le package NuGet Microsoft.Websockets. C’est la manière la plus simple d’obtenir l’assembly vu le DLL Hell de Microsoft.Websockets. Ajoutez aussi le package JQuery (1.8.2 dans ce cas-ci), il nous fournit une API JavaScript nous permettant de consommer des WebSockets.

Pour le reste il nous faut 3 fichiers ici. Un index.html qui contiendra le formulaire de chat ainsi que le code javascript pour l’établissement de la connexion et l’envoi/reception des données avec le websocket, un HTTPhandler qui fournira le websocket au httpcontext et notre implémentation du websocket basé sur Microsoft.Web.WebSockets.WebSocketHandler qui se base sur l’API Websocket du W3C. Pour le reste, je vous laisse lire les commentaires détaillés du code. La solution est également disponible via mon skydrive.

index.html

<!doctype html>
    <head>
        <script src="Scripts/jquery-1.8.2.min.js" type="text/javascript"></script>
        <script type="text/javascript">
            
            $(document).ready(function () {
                // Obtention du pseudo
                var name = prompt('Pseudo :');
                
                // Url du websocket, pour de l'https utiliser wss://
                var url = 'ws://' + window.location.hostname + window.location.pathname.replace('index.htm', 'socket.ashx') + '?name=' + name;
                
                //Affichage de l'url de connection et création websocket
                alert('Connecting to: ' + url);
                
                ws = new WebSocket(url);
        
                // On Websocket open, notification utilisateur
                ws.onopen = function () {
                    $('#messages').prepend('Connected <br/>');
                    // On Click on Send, envoi du contenu de txtMessage
                    $('#cmdSend').click(function () {
                        ws.send($('#txtMessage').val());
                        $('#txtMessage').val('');
                    });
                };
        
                // On Receive message on websocket, Ajouter le message à la chat box
                ws.onmessage = function (e) {
                    $('#chatMessages').prepend(e.data + '<br/>');
                };

                // On Click on Leave Button, fermer le websocket
                $('#cmdLeave').click(function () {
                    ws.close();
                });

                // On Close websocket, notification utilisateur
                ws.onclose = function () { $('#chatMessages').prepend('Closed <br/>'); };

                // On Error on the websocket, notification utilisateur
                ws.onerror = function (e) { $('#chatMessages').prepend('Oops something went wront <br/>'); };

            });

        </script>
    </head>
    <body>
        <input id="txtMessage" />
        <input id="cmdSend" type="button" value="Send" />
        <input id="cmdLeave" type="button" value="Leave" />
        <br />
        <div id="chatMessages" />
    </body>
</html>

TestWebSocketHandler.cs

using Microsoft.Web.WebSockets;

namespace Istace.Blog.WebSockets
{
    /// <summary>
    /// WebSocket Handler
    /// </summary>
    /// <remarks>
    /// Implémentation de la W3C WebSocket API
    /// http://www.w3.org/TR/2009/WD-websockets-20091222/
    /// </remarks>
    public class TestWebSocketHandler : WebSocketHandler
    {
        /// <summary>
        /// List of the connected connectedClients.
        /// </summary>
        private static readonly WebSocketCollection ConnectedClients = new WebSocketCollection();

        /// <summary>
        /// Socket Name
        /// </summary>
        private string _name;

        /// <summary>
        /// Occurs when WebSocket open.
        /// </summary>
        public override void OnOpen()
        {
            // Get the name
            _name = WebSocketContext.QueryString["name"];
            // Add client to the client list
            ConnectedClients.Add(this);
            // Broadcast to connected connectedClients the connection message
            ConnectedClients.Broadcast(_name + " has connected.");
        }

        /// <summary>
        /// Occurs when WebSocket receieve message
        /// </summary>
        /// <param name="message"></param>
        public override void OnMessage(string message)
        {
            // broadcast the message to the registred connectedClients
            ConnectedClients.Broadcast(string.Format("{0} said: {1}", _name, message));
        }

        /// <summary>
        /// Occurs when the WebSocket close
        /// </summary>
        public override void OnClose()
        {
            // Remove the instance from the connected client list.
            ConnectedClients.Remove(this);
            // Broadcast the deconnection message to the registred clients.
            ConnectedClients.Broadcast(string.Format("{0} has gone away.", _name));
        }
    }
}

socket.ashx

using System.Web;
using Microsoft.Web.WebSockets;

namespace Istace.Blog.WebSockets
{
    /// <summary>
    /// WebSocket HTTP Handler
    /// </summary>
    public class WSHttpHandler : IHttpHandler
    {
        public void ProcessRequest(HttpContext context)
        {
            if (context.IsWebSocketRequest)
                context.AcceptWebSocketRequest(new TestWebSocketHandler());
        }

        public bool IsReusable { get { return false; } }
    }
}

Websockets with ASP.net 4.5 and Visual Studio 2012
WebSocket on MSDN
W3C WebSocket API Reference