Sam Beauvois

Quick tip : Enable wordpress mail feature on windows hosting

admin — Wed, 11 Apr 2012 09:25:01 +0000

When you install a wordpress on a windows server (using IIS), the php mail() function may be disabled.

A simple workaround is to use the wp mail smtp plugin.

Install-it, then go to the settings :

You can test it directly from the settings page.

Simple proxy to bypass cors

admin — Mon, 12 Mar 2012 13:16:18 +0000

CORS is a pain in the ass, all works great with chrome and firefox,but, as often, internet explorer doesn’t (it should work with ie 10 but you know…)

So the proxy solution is simple and works, even if I would prefer a full html/jquery solution.

To create a proxy for the get requests it’s simple.

Create an asp.net webform, add this in the pageload.


protected void Page_Load(object sender, EventArgs e)
{
 string serviceUrl = HttpContext.Current.Request.Params["service"];
 if (string.IsNullOrEmpty(serviceUrl))
 {
  return;
 }

 string query = string.Empty;
 int firstParamIndex = HttpContext.Current.Request.Url.Query.IndexOf('&');

 if (firstParamIndex > -1)
 {
  query = HttpContext.Current.Request.Url.Query.Remove(0,firstParamIndex+1);
 }

 string service = serviceUrl + "?" + query;

 WebClient client = new WebClient();

 foreach (string headerKey in HttpContext.Current.Request.Headers.Keys)
 {
  try
  {
    client.Headers[headerKey] = HttpContext.Current.Request.Headers[headerKey];
  }
  catch (Exception ex)
  {
    System.Diagnostics.Debug.WriteLine(ex.Message);
  }
 }

 // specify encoding : avoid special characters to be unrecognized.
 client.Encoding = Encoding.UTF8;
 string resultString = client.DownloadString(service);

 // carriage returns.
 Response.Write(resultString.Replace(@"\u000d\u000d", "
"));
}

you can restrict some headers this way


protected void Page_Load(object sender, EventArgs e)
{
 string[] allowedHeaders =
 {
  "x-headers1",
  "x-headers2",
  "x-headers3"
 };

 string serviceUrl = HttpContext.Current.Request.Params["service"];
 if (string.IsNullOrEmpty(serviceUrl))
 {
  return;
 }

 string query = string.Empty;
 int firstParamIndex = HttpContext.Current.Request.Url.Query.IndexOf('&');

 if (firstParamIndex > -1)
 {
 query = HttpContext.Current.Request.Url.Query.Remove(0,firstParamIndex+1);
 }

 string service = serviceUrl + "?" + query;

 WebClient client = new WebClient();

 foreach (string headerKey in HttpContext.Current.Request.Headers.Keys)
 {
  if (allowedHeaders.Contains(headerKey))
  {
   try
   {
     client.Headers[headerKey] = HttpContext.Current.Request.Headers[headerKey];
   }
   catch (Exception ex)
   {
     System.Diagnostics.Debug.WriteLine(ex.Message);
   }
  }
 }

 // specify encoding : avoid special characters to be unrecognized.
 client.Encoding = Encoding.UTF8;
 string resultString = client.DownloadString(service);

 // carriage returns.
 Response.Write(resultString.Replace(@"\u000d\u000d", "
"));
}

In your web client :


if (jQuery.support.ajax)
{
 $.ajax({
 headers:
 {
  "x-headers1": "header value 1",
  "x-headers2": "header value 2",
  "x-headers3": "header value 3"
 },
 contentType: "application/json; charset=utf-8",
 dataType: "json",
 url: "youpage.aspx?service=yourservicecompleteurl",
 data:
 {
  param1: value1,
  param2: value2
 },
 success: function (msg)
 {
  callback(msg);
 },
 error: function (errormsg)
 {
  if (errorCallback != 'undefined')
  {
  errorCallback(errormsg);
  }
 }
 });
 }
 else
 {
  alert('You browser doesnt support ajax.');
 }

I could use a webservice, but it would force me to do POST requests and I doesn’t want to make changes in my jscripts.

[Update 20120405 ]

Here is the full proxy code, which handles both get and post requests :


using System;
using System.Linq;
using System.Web;
using System.Text;
using System.Net;
using System.IO;

namespace yournamespace
{
 public partial class Proxy : System.Web.UI.Page
{
/// 
/// Definition of the headers to transfer.
/// 
private static string[] requiredHeaders =
{
"x-your-required-header-1",
"x-your-required-header-2",
"x-your-required-header-3",
"Content-type"
};

/// 
/// Overrides the onload event to handle get and post requests.
/// 
/// 
protected override void OnLoad(EventArgs e)
{
bool isPost = string.Equals(HttpContext.Current.Request.HttpMethod, "POST", StringComparison.OrdinalIgnoreCase);
string serviceUrl = HttpContext.Current.Request.Params["service"];
if (string.IsNullOrEmpty(serviceUrl))
{
return;
}

string service = serviceUrl + (isPost ? "" : "?" + GetQuery());
WebClient client = new WebClient();

// copy required headers
foreach (string headerKey in HttpContext.Current.Request.Headers.Keys)
{
if (requiredHeaders.Contains(headerKey))
{
try
{
client.Headers[headerKey] = HttpContext.Current.Request.Headers[headerKey];
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
}

// specify encoding : avoid special characters to be unrecognized.
client.Encoding = Encoding.UTF8;
string resultString = string.Empty;
try
{
if (isPost)
{
client.Headers.Add(HttpRequestHeader.ContentType, "application/json");

using (MemoryStream str = new MemoryStream())
{
HttpContext.Current.Request.InputStream.CopyTo(str);
byte[] result = client.UploadData(service, str.ToArray());
resultString += Encoding.UTF8.GetString(result);
}
}
else // GET
{
resultString = client.DownloadString(service);
}
}
catch (WebException wex)
{
System.Diagnostics.Debug.Write(wex);
resultString = "An error occured : " + wex.Message + "";
resultString += "
Status : " + wex.Status;
if (wex.Status == WebExceptionStatus.ProtocolError)
{
HttpWebResponse httpResponse = wex.Response as HttpWebResponse;
if (httpResponse != null)
{
resultString += string.Format("
Status Code : {0}", httpResponse.StatusCode);
resultString += string.Format("
Status Description : {0}", httpResponse.StatusDescription);
}
}
resultString += "

Requested service : " + service;
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
resultString = "An error occured : " + ex.Message + "";
resultString = ex.GetFullMessage();
resultString += "

requested service : " + service;
}
finally
{
client.Dispose();
}
Response.Clear();
Response.Write(resultString);
}

/// 
/// Gets the query part.
/// 
/// 
private static string GetQuery()
{
string query = string.Empty;
int firstParamIndex = HttpContext.Current.Request.Url.Query.IndexOf('&');
if (firstParamIndex > -1)
{
query = HttpContext.Current.Request.Url.Query.Remove(0, firstParamIndex + 1);
}

return query;
}
}
}

Dynamic is magic : A solution to use the ASP.NET profile in web applications.

admin — Tue, 31 Jan 2012 13:38:32 +0000

Profiles are not auto generated with Web Applications, so you can’t just add them in the web.config and use them directly. (unless …)

The WebSite project do a magic thing : when you add properties to the profile in the web.config file, a class is autogenerated and allow the developer to access these properties. The web application project don’t do that.

You can find some workarounds over the web, here is some

The “dynamic” keyword help us here.

So, no more chit chat, here is the code snippets for a profile with 3 parameters : LastName, FirstName and GSM

web.config:

A “business” class, I called it “ProfilePresenter”, it returns the profile of the logged user and allow modifications:


public class ProfilePresenter
{
 public dynamic GetProfile()
 {
 return HttpContext.Current.Profile;
 }
 public dynamic UpdateProfile(string FirstName, string LastName, string GSM)
 {
 HttpContext.Current.Profile.SetPropertyValue("FirstName", FirstName);
 HttpContext.Current.Profile.SetPropertyValue("LastName", LastName);
 HttpContext.Current.Profile.SetPropertyValue("GSM", GSM);
 HttpContext.Current.Profile.Save();
 return HttpContext.Current.Profile;
 }
}

A page that uses the ProfilePresenter class : displaying the profile properties, and edit them

ObjectDataSource:




FormView: Display part
 
 
 
 No profil datas
 
 
 
 
 Profil informations
 
 
 
 
 
 
 Infos
 
 
 
 
 
 
 LastName
 
 
 <%# Eval("LastName")%>
 
 
 
 
 FirstName
 
 
 <%# Eval("FirstName")%>
 
 
 
 
 GSM
 
 
 <%# Eval("GSM")%>
 
 
 
 
 

FormView : the Edit part
 
 
 Profil Update
 
 
 
 
 
 
 
Infos
 
 
 
 
 
 
 LastName
 
 
 
 
 
 
 
 FirstName
 
 
 
 
 
 
 
 GSM
 
 
 
 
 
 
 
 
 

A simple use :

dynamic profil = HttpContext.Current.Profile;
if (profil != null)
{
 Console.Writeline(profil.GSM);
}

Another example : retrieve the gsm numbers from  members of a security role. It shows how to retrieve the profile of an other user

string[] users = Roles.GetUsersInRole(role);

List gsm = new List();
foreach (string user in users)
{
 dynamic profil = HttpContext.Current.Profile;
 dynamic profi = profil.GetProfile(user);
 if (profi != null)
 {
 if (!string.IsNullOrEmpty(profi.GSM))
 {
 gsm.Add(profi.GSM);
 }
 }
}

Let me know what you think !

Infos
LastName	<%# Eval("LastName")%>
FirstName	<%# Eval("FirstName")%>
GSM	<%# Eval("GSM")%>

Infos
LastName
FirstName
GSM

Different Ways to Transfer Data between pages by Peter Bromberg

admin — Fri, 30 Dec 2011 08:46:31 +0000

It’s a common question when working with asp.net, and Peter Bromberg has done a nice job by grouping eight methods to do it!

Read his article here : http://www.eggheadcafe.com/tutorials/asp-net/e653f028-01fb-4d0e-843b-058deae562a2/eight-different-ways-to-transfer-data-from-one-page-to-another-page.aspx

Bring a bit of the Subsonic power to Entity Framework by adding automatic audit and logical delete fields

admin — Fri, 04 Nov 2011 16:04:07 +0000

Here is the code to do the same thing than in my previous article “Bring a bit of the Subsonic power to Linq to sql by adding automatic audit and logical delete fields”


namespace YouNamespace.DAL
{
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Data;
 using System.Data.Common;
 using System.Data.Objects;
 using System.Linq;

 public partial class YOURCONTEXTEntities
 {
 /// 
 /// System fields for automatic audit and logical delete
 /// 
 private struct SystemFields
 {
 public const string CreatedOn = "CREATEDON";
 public const string ModifiedOn = "MODIFIEDON";
 public const string CreatedBy = "CREATEDBY";
 public const string ModifiedBy = "MODIFIEDBY";
 public const string IsDeleted = "ISDELETED";
 }

 /// 
 /// Overriding the SaveChanges method to automaticaly set system fields if any.
 /// 
 /// 
 /// 
 public override int SaveChanges(System.Data.Objects.SaveOptions options)
 {
 IEnumerable newEntries = this.ObjectStateManager.GetObjectStateEntries(EntityState.Added);

 foreach (ObjectStateEntry entry in newEntries)
 {
 ReadOnlyCollection fieldsMetaData = entry.CurrentValues
 .DataRecordInfo.FieldMetadata;

 FieldMetadata createdOnField = fieldsMetaData
 .Where(f => string.Equals(f.FieldType.Name, SystemFields.CreatedOn, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

 if (createdOnField.FieldType != null)
 {
 entry.CurrentValues.SetValue(createdOnField.Ordinal, DateTime.Now);
 }

 FieldMetadata createdByField = fieldsMetaData
 .Where(f => string.Equals(f.FieldType.Name, SystemFields.CreatedBy, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

 if (createdByField.FieldType != null)
 {
 entry.CurrentValues.SetValue(createdByField.Ordinal, "Sam");
 }

 FieldMetadata deletedField = fieldsMetaData
 .Where(f => string.Equals(f.FieldType.Name, SystemFields.IsDeleted, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

 if (deletedField.FieldType != null)
 {
 entry.CurrentValues.SetValue(deletedField.Ordinal, false);
 }
 }

 IEnumerable modifiedEntries = this.ObjectStateManager.GetObjectStateEntries(EntityState.Modified);
 foreach (ObjectStateEntry entry in modifiedEntries)
 {
 ReadOnlyCollection fieldsMetaData = entry.CurrentValues
 .DataRecordInfo.FieldMetadata;

 FieldMetadata createdOnField = fieldsMetaData
 .Where(f => string.Equals(f.FieldType.Name, SystemFields.ModifiedOn, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

 if (createdOnField.FieldType != null)
 {
 entry.CurrentValues.SetValue(createdOnField.Ordinal, DateTime.Now);
 }

 FieldMetadata createdByField = fieldsMetaData
 .Where(f => string.Equals(f.FieldType.Name, SystemFields.ModifiedBy, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

 if (createdByField.FieldType != null)
 {
 entry.CurrentValues.SetValue(createdByField.Ordinal, "Sam");
 }
 }

 IEnumerable deletedEntries = this.ObjectStateManager.GetObjectStateEntries(EntityState.Deleted);
 foreach (ObjectStateEntry entry in deletedEntries)
 {
 // change from deleted to modified (!important)
 this.ObjectStateManager.ChangeObjectState(entry.Entity, EntityState.Modified);

 ReadOnlyCollection fieldsMetaData = entry.CurrentValues
 .DataRecordInfo.FieldMetadata;

 FieldMetadata deletedField = fieldsMetaData
 .Where(f => string.Equals(f.FieldType.Name, SystemFields.IsDeleted, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

 if (deletedField.FieldType != null)
 {
 entry.CurrentValues.SetValue(deletedField.Ordinal, true);
 }
else
 {
 // change back from modified to deleted (!important)
 this.ObjectStateManager.ChangeObjectState(entry.Entity, EntityState.Deleted);
 }
 }

 return base.SaveChanges(options);
 }
 }
}

Enum HasFlag method extension for < 4.0 Framework

admin — Wed, 03 Aug 2011 19:52:46 +0000

In the same idea than the previous article, here is an extension method to mimic the 4.0 HasFlag method (http://msdn.microsoft.com/en-us/library/system.enum.hasflag.aspx).

     /// 
    /// Extentions for enums.
    /// 
    public static class EnumExtensions
    {
        /// 
        /// A FX 3.5 way to mimic the FX4 "HasFlag" method.
        /// 
        /// The tested enum.
        /// The value to test.
        /// True if the flag is set. Otherwise false.
        public static bool HasFlag(this Enum variable, Enum value)
        {
            // check if from the same type.
            if (variable.GetType() != value.GetType())
            {
                throw new ArgumentException("The checked flag is not from the same type as the checked variable.");
            }

            Convert.ToUInt64(value);
            ulong num = Convert.ToUInt64(value);
            ulong num2 = Convert.ToUInt64(variable);

            return (num2 & num) == num;
        }
    }

Stream.CopyTo method for < 4.0 framework

Sam Beauvois — Tue, 02 Aug 2011 18:47:19 +0000

The .NET Framework 4.0 introduced the CopyTo() method for the Stream class. (http://msdn.microsoft.com/en-us/library/system.io.stream.copyto.aspx)

You copy a stream into one other this way:


   MemoryStream memoryStream = new MemoryStream();
   using (Stream stream = new FileStream(@"c:\input.txt", FileMode.Open))
   {
      stream.CopyTo(memoryStream);
   }

If you are stucked with a lower version of the framework, you might want to use it anyway.

A bit of reflector is realy usefull to see how the implementation is done in 4.0.

The CopyTo method :


public void CopyTo(Stream destination)
{
    if (destination == null)
    {
        throw new ArgumentNullException("destination");
    }
    if (!this.CanRead && !this.CanWrite)
    {
        throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_StreamClosed"));
    }
    if (!destination.CanRead && !destination.CanWrite)
    {
        throw new ObjectDisposedException("destination", Environment.GetResourceString("ObjectDisposed_StreamClosed"));
    }
    if (!this.CanRead)
    {
        throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnreadableStream"));
    }
    if (!destination.CanWrite)
    {
        throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnwritableStream"));
    }
    this.InternalCopyTo(destination, 0x1000);
}

We see that the InternalCopyTo is used :


private void InternalCopyTo(Stream destination, int bufferSize)
{
    int num;
    byte[] buffer = new byte[bufferSize];
    while ((num = this.Read(buffer, 0, buffer.Length)) != 0)
    {
        destination.Write(buffer, 0, num);
    }
}

Remark :
0×1000 is in hexadecimal, which corresponds to 4096 in decimal.

So we can retrieve that for use with lower versions of the language

For .NET FX >= 3.0 you can create an extension method


    using System;
    using System.IO;

    /// 
    /// Extension methods for streams.
    /// 
    public static class StreamExtensions
    {
        /// 
        /// Reads all the bytes from the current stream and writes them to the destination stream.
        /// 
        /// The current stream.
        /// The stream that will contain the contents of the current stream.
        /// Destination is null.
        /// The current stream does not support reading.-or-destination does not support Writing.
        /// Either the current stream or destination were closed before the System.IO.Stream.CopyTo(System.IO.Stream) method was called.
        /// An I/O error occurred.
        public static void CopyTo(this Stream original, Stream destination)
        {
            if (destination == null)
            {
                throw new ArgumentNullException("destination");
            }
            if (!original.CanRead && !original.CanWrite)
            {
                throw new ObjectDisposedException("ObjectDisposedException");
            }
            if (!destination.CanRead && !destination.CanWrite)
            {
                throw new ObjectDisposedException("ObjectDisposedException");
            }
            if (!original.CanRead)
            {
                throw new NotSupportedException("NotSupportedException source");
            }
            if (!destination.CanWrite)
            {
                throw new NotSupportedException("NotSupportedException destination");
            }

            byte[] array = new byte[4096];
            int count;
            while ((count = original.Read(array, 0, array.Length)) != 0)
            {
                destination.Write(array, 0, count);
            }
        }
    }

You use it this way (same ways as the FX 4.0):


   MemoryStream memoryStream = new MemoryStream();
   using (Stream stream = new FileStream(@"c:\input.txt", FileMode.Open))
   {
      stream.CopyTo(memoryStream);
   }

For lower version, you can create an helper class.


    using System;
    using System.IO;

    /// 
    /// An helper class for streams.
    /// 
    public class StreamHelper
    {
        /// 
        /// Reads all the bytes from the current stream and writes them to the destination stream.
        /// 
        /// The original stream.
        /// The stream that will contain the contents of the current stream.
        /// Destination is null.
        /// The current stream does not support reading.-or-destination does not support Writing.
        /// Either the current stream or destination were closed before the System.IO.Stream.CopyTo(System.IO.Stream) method was called.
        /// An I/O error occurred.
        public static void CopyStreamTo(Stream original, Stream destination)
        {
            if (destination == null)
            {
                throw new ArgumentNullException("destination");
            }
            if (!original.CanRead && !original.CanWrite)
            {
                throw new ObjectDisposedException("ObjectDisposedException");
            }
            if (!destination.CanRead && !destination.CanWrite)
            {
                throw new ObjectDisposedException("ObjectDisposedException");
            }
            if (!original.CanRead)
            {
                throw new NotSupportedException("NotSupportedException source");
            }
            if (!destination.CanWrite)
            {
                throw new NotSupportedException("NotSupportedException destination");
            }

            byte[] array = new byte[4096];
            int count;
            while ((count = original.Read(array, 0, array.Length)) != 0)
            {
                destination.Write(array, 0, count);
            }
        }
    }

Use it this way:


   MemoryStream memoryStream = new MemoryStream();
   using (Stream stream = new FileStream(@"c:\input.txt", FileMode.Open))
   {
        StreamHelper.CopyStreamTo(stream, memoryStream);
   }

Chanel 9 | Rx Workshop: Unified Programming Model

admin — Tue, 02 Aug 2011 14:46:36 +0000

Learn how to wrap existing event sources, including tasks, asynchronous methods, .NET events, etc. in observable sequences.

ASP.NET videos : Choosing the Right Programming Model

Sam Beauvois — Sun, 12 Jun 2011 20:34:09 +0000

As mentioned by Kris van der Mast on the asp.net forums, this video was on the get started page before, but don’t appears to be there anymore.

This video is great to know in 5 minutes which model is good for you.

So, because I don’t want to search for it, I post this video here :

(direct link)

One line how to’s : Save text in a file, or read text from a file.

Sam Beauvois — Sun, 12 Jun 2011 20:25:08 +0000

Sometimes your solution lies in a single line.

How to save a string in a text file


System.IO.File.WriteAllText("c://yourfile.txt",
"here is the content of my file !");

How to read a text file


string content =  System.IO.File.ReadAllText("c://yourfile.txt");

How does it work ?

A bit or Reflector gives us :

For the write method


public static void WriteAllText(string path, string contents)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
if (path.Length == 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EmptyPath"));
}
InternalWriteAllText(path, contents, StreamWriter.UTF8NoBOM);
}

and the “InternalWriteAllText” method :


private static void InternalWriteAllText(string path, string contents, Encoding encoding)
{
using (StreamWriter writer = new StreamWriter(path, false, encoding))
{
writer.Write(contents);
}
}

For the Read method :

public static string ReadAllText(string path)
{
    if (path == null)
    {
        throw new ArgumentNullException("path");
    }
    if (path.Length == 0)
    {
        throw new ArgumentException(Environment.GetResourceString("Argument_EmptyPath"));
    }
    return InternalReadAllText(path, Encoding.UTF8);
}

And the “InternalReadAllText” :

private static string InternalReadAllText(string path, Encoding encoding)
{
    using (StreamReader reader = new StreamReader(path, encoding))
    {
        return reader.ReadToEnd();
    }
}

As you can see it don’t check if the file exists, so you have to check it by yourself :


if (System.IO.File.Exists("your file path"))
{
string content = System.IO.File.ReadAllText("your file path");
}

public static string ReadAllText(string path) { if (path == null) { throw new ArgumentNullException(“path”); } if (path.Length == 0) { throw new ArgumentException(Environment.GetResourceString(“Argument_EmptyPath”)); } return InternalReadAllText(path, Encoding.UTF8); }