One of my favorites in the PHP libraries is the strip_tags function. Not only does it neatly remove HTML from an input it also allows you to specify which tags should stay. This is great if you are allowing your visitors to apply some basic HTML tags to their comments. This post explores two issues: using C# to remove unwanted tags, and cleaning up unwanted attributes that might be hidden in the allowed tags.

I wanted to clean some comments posted to a website from unwanted HTML tags. The users are allowed to <B> or <I> and even <A href=”"></a> their posts but anything else must be stripped before it is posted to the site. I found several regular expressions for C# that allow you to strip HTML but these magically wipe all the HTML and leave nothing.

Below is the end result of of some hacking, and of course much love-hate with the regular expression library.

string StripTags(string Input, string[] AllowedTags)

The StripTags method takes an input string, and an array of allowed tags. It returns the input as a string, minus all not wanted tags.

string test1 = StripTags("<p>George</p><b>W</b><i>Bush</i>", new string[]{"i","b"});
string test2 = StripTags("<p>George <img src='someimage.png' onmouseover='someFunction()'>W <i>Bush</i></p>", new string[]{"p"});
string test3 = StripTags("<a href='http://www.dijksterhuis.org'>Martijn <b>Dijksterhuis</b></a>", new string[]{"a"});

Using the above example code returns the following:

string StripTagsAndAttributes(string Input, string[] AllowedTags)

The above StripTags function is similar to the original PHP strip_tags function in having the same weakness: It is still possible for a malicious user to insert attributes into each of the tags. Think “style=” and “id=”. We would be somewhat saver if we cleaned these as well. The StripTagsAndAttributes method does just that.

It first runs the input through StripTags, and for the remaining tags is strips out all but a restricted set of attributes.

string test4 = "<a class=\"classof69\" onClick='crosssite.boom()' href='http://www.dijksterhuis.org'>Martijn Dijksterhuis</a>";
Console.WriteLine(StripTagsAndAttributes(test4, new string[]{"a"}));

That “OnClick” attribute looks mighty unsafe. Running the above string through StripTagsAndAttributes as in the example above returns:

This function probably needs some tuning if you want to allow, or restrict things even further.

A word of caution

Regular expressions are voodoo, very cool, but still voodoo. The above functions work for the tests I have applied to them, but your mileage may vary! If you have a special situation that doesn’t work leave a note below and maybe we can work out the problems.

Credits

The strip_tags function is of course inspired by the PHP version , and a Javascript implementation thereof by Kevin van Sonderveld. The attribute stripping routine is based on the regular expressions by mdw252 in one of the strip_tags manual page comments.

Source code

The complete source code for the StripTags function and StripTagsAndAttributes function with my test code can be found below:

using System;
using System.Text.RegularExpressions;

namespace StripHTML
{
	class MainClass
	{

        private static string ReplaceFirst(string haystack, string needle, string replacement)
        {
       		int pos = haystack.IndexOf(needle);
            if (pos < 0) return haystack;
            return haystack.Substring(0,pos) + replacement + haystack.Substring(pos+needle.Length);
        }

		private static string ReplaceAll(string haystack, string needle, string replacement)
        {
             int pos;
			 // Avoid a possible infinite loop
             if (needle == replacement) return haystack;
              while((pos = haystack.IndexOf(needle))>0)
                       haystack = haystack.Substring(0,pos) + replacement + haystack.Substring(pos+needle.Length);
                        return haystack;
        }		

		public static string StripTags(string Input, string[] AllowedTags)
		{
			Regex StripHTMLExp = new Regex(@"(<\/?[^>]+>)");
		    string Output = Input;

			foreach(Match Tag in StripHTMLExp.Matches(Input))
			{
				string HTMLTag = Tag.Value.ToLower();
				bool IsAllowed = false;

				foreach(string AllowedTag in AllowedTags)
				{
					int offset = -1;

					// Determine if it is an allowed tag
					// "<tag>" , "<tag " and "</tag"
					if (offset!=0) offset = HTMLTag.IndexOf('<'+AllowedTag+'>');
					if (offset!=0) offset = HTMLTag.IndexOf('<'+AllowedTag+' ');
					if (offset!=0) offset = HTMLTag.IndexOf("</"+AllowedTag);

					// If it matched any of the above the tag is allowed
					if (offset==0)
					{
					 	IsAllowed = true;
						break;
					}
				}

				// Remove tags that are not allowed
				if (!IsAllowed) Output = ReplaceFirst(Output,Tag.Value,"");
			}

			return Output;
		}

		public static string StripTagsAndAttributes(string Input, string[] AllowedTags)
		{
			/* Remove all unwanted tags first */
			string Output = StripTags(Input,AllowedTags);

			/* Lambda functions */
			MatchEvaluator HrefMatch = m => m.Groups[1].Value + "href..;,;.." + m.Groups[2].Value;
			MatchEvaluator ClassMatch = m => m.Groups[1].Value + "class..;,;.." + m.Groups[2].Value;
			MatchEvaluator UnsafeMatch = m => m.Groups[1].Value + m.Groups[4].Value;

			/* Allow the "href" attribute */
			Output = new Regex("(<a.*)href=(.*>)").Replace(Output,HrefMatch);

			/* Allow the "class" attribute */
			Output = new Regex("(<a.*)class=(.*>)").Replace(Output,ClassMatch);

			/* Remove unsafe attributes in any of the remaining tags */
			Output = new Regex(@"(<.*) .*=(\'|\""|\w)[\w|.|(|)]*(\'|\""|\w)(.*>)").Replace(Output,UnsafeMatch);

			/* Return the allowed tags to their proper form */
			Output = ReplaceAll(Output,"..;,;..", "=");

			return Output;
		}

		public static void Main(string[] args)
		{
			string test1 = StripTags("<p>George</p><b>W</b><i>Bush</i>", new string[]{"i","b"});
			string test2 = StripTags("<p>George <img src='someimage.png' onmouseover='someFunction()'>W <i>Bush</i></p>", new string[]{"p"});
			string test3 = StripTags("<a href='http://www.dijksterhuis.org'>Martijn <b>Dijksterhuis</b></a>", new string[]{"a"});

			Console.WriteLine(test1);
			Console.WriteLine(test2);
			Console.WriteLine(test3);

			string test4 = "<a class=\"classof69\" onClick='crosssite.boom()' href='http://www.dijksterhuis.org'>Martijn Dijksterhuis</a>";
			Console.WriteLine(StripTagsAndAttributes(test4, new string[]{"a"}));
		}
	}

Image credit: Jesper Rønn-Jensen’s

This is a post from Martijn's C# Coding Blog.

Sending an e-mail is pretty old news by now so it should come as no surprise that .NET contains a significant SMTP mail client. One old programming truth still holds: All programs will expand to eventually include sending (and receiving) e-mails. So how about adding e-mail to your program ? This post explores how we can use the System.Mail.SmtpClient to send formatted e-mails. There are plenty of options available and we will explore most of them.

In another lifetime together with friends I wrote a massive e-mail parser for the then popular FidoNet, and the (for us) new RFC822 based Internet. Written in Pascal for DOS it chewed its way through megabytes of modem downloaded Usenet groups and e-mail for our local BBS, night after night. It was fun and I learned that when it comes to e-mail that there are no real standards, just broken implementations.

Some 15 years later things have become quite a bit easier. Sending an e-mail is as straightforward as calling a few basic library functions and .NET of course includes a solid implementation.

Quickly sending an e-mail

If you are in a hurry then the following constructor will create a simple mail message from just 4 string parameters:

// public client.Send(string from,string to,string subject,string body)
using System.Net.Mail;
SmtpClient client = new SmtpClient();
client.Send("martijn@dijksterhuis.org","test@dijksterhuis.org","Testing!","If this break again,.. I won't know what to do");

In the above example the e-mail is send using the system default settings as discovered by the .NET framework. If you are curious which system acted as the Default SMTP server you can query SmtpClient.Host

Console.WriteLine(”Default SMTP Server: {0}”,client.Host);

Note that there is a good chance that the .NET libraries are unable to work out the SMTP host and will fail with an System.InvalidOperationException (The SMTP host was not specified) when you attempt to send the e-mail.

Sending a proper e-mail

An basic e-mail is build up out of a sender, one or more recipients, a message body and one or more attachments. And of course the e-mail is probably encoded in an outdated Russian font.

The e-mail sender and receiver are represented by the MailAddress class. So of course you need an e-mail address, optionally a name, and in case you really want to send a Russian formatted name, a proper encoding format.

MailAddress toUser = new MailAddress("martijn@dijksterhuis.org");
MailAddress toUser2 = new MailAddress("martijn@dijksterhuis.org","Martijn Dijksterhuis");
MailAddress toUser3 = new MailAddress("martijn@dijksterhuis.org","Martijn Dijksterhuis", System.Text.Encoding.UTF8);

My name doesn’t include any funky characters so I specified the default UTF-8 encoding.

Sending an e-mail with only a single sender and receiver

If your e-mail only contains a single sender and a single receiver the MailMessage(MailAddress From,MailAddress To) constructor provides all you need. It creates a new e-mail message structure, assigning the sending and receiver in the constructor.

MailAddress toUser = new MailAddress("myfriend@yahoo.com");
MailAddress fromUser = new MailAddress("martijn@dijksterhuis.org");
MailMessage msg  = new MailMessage(fromUser,toUser);

Adding more receivers to the same e-mail

A single recipient is probably not sufficient. Not to worry, you can add as many To’s, CC’s, BCC’s etc to the e-mail as you would like:

msg.To.Add( new MailAddress("second_to@dijksterhuis.org") );
msg.CC.Add( new MailAddress("first_cc@dijksterhuis.org") );
msg.CC.Add( new MailAddress("second_cc@dijksterhuis.org") );
msg.Bcc.Add( new MailAddress("first_bcc@dijksterhuis.org") );

Setting the E-mail subject and body content

Setting the subject of the e-mail is not hard, just set it from Msg.Subject. And if you would like to encode that in a format other the Unicode, say BIG-5 Chinese:

msg.Subject = "一分鐘換一年"
msg.SubjectEncoding = Encoding.GetEncoding("big5");

(The above Chinese came from my junk box and to the best of my knowledge its harmless)

Setting the actual message body works in a very similar fashion:

msg.Body = "Dear Customer, " + Environment.NewLine + Environment.NewLine;
msg.Body += "Because of repeated violations of our terms and conditions we had no choice but to";
msg.Body += "terminate your account with us." + Environment.NewLine + Environment.NewLine;
msg.Body += "The Management";
msg.BodyEncoding = System.Text.Encoding.UTF8;

Adding an attachment to the e-mail

An e-mail can have more than one attachment, and each attachment is represented by the System.Net.Mail.Attachment class. You can add them to the attachment collection of the message by calling “Attachments.Add()”

using System.Net.Mime;
Attachment firstAttachment = new Attachment("document.doc",MediaTypeNames.Application.Octet);
MailMessage msg  = new MailMessage(fromUser,toUser);
msg.Attachments.Add(firstAttachement);

The first parameter passed to the constructor is the path to the attachment to include. If no full path is given, the current working directory is tried. The file type is defined in System.Net.Mime — available options are:

If the type of file is not specified use MediaTypesNames.Application.Octet , which stands for “data is not interpreted”.

Adding custom e-mail headers to your e-mail

The Msg.Header property allows you to query and add to the e-mail headers set  by the .NET framework. A brand new e-mail will only contain a single header: “Mime: 1.0″. Adding your own custom header to this is trivial as is shown in the following code example:

MailMessage Msg = new MailMessage(new               MailAddress("martijn@dijksterhuis.org"),new MailAddress("martijn@dijksterhuis.org"));

// Add a custom header to the e-mail
Msg.Headers.Add("X-Header","2.0");

// Display all the message headers.
string[] Keys = Msg.Headers.AllKeys;
foreach (string s in Keys)

Console.WriteLine("{0}: {1}", s,Msg.Headers[s]);

Sending your e-mail with SmtpClient

The hard work of delivering the e-mail is done through the SmtpClient class and the most basic delivery only takes two lines:

SmtpClient client = new SmtpClient();
client.Send(Msg);

It might be wise to catch exceptions at this point because sending an SMTP e-mail can throw a number:

1. SmtpFailedRecipientsException: The message could not be delivered to one or more of the recipients in To, CC, or Bcc.


2. SmtpException : Connection failed, authentication failed or a time-out


3. ArgumentNullException / ArgumentOutOfRangeException / InvalidOperationException : Something wrong with the input fields of the e-mail

If you do not specify any parameters the default SmtpClient constructor will lookup the SMTP server to use through the .NET environment.

You can specify a specific server and optional port through the second constructor:

SmtpClient client = new SmtpClient(”mail.dijksterhuis.org”,3000);

The above SmtpClient.Send call is a blocking call — your application halts while the e-mail is being send. Naturally there is also an asynchronous call: SmtpClient.SendAsync.

Using SmtpClient.SendAsync is a little more work. How to do this is shown in the following example:

using System;
using System.Net.Mail;
using System.Threading;
using System.ComponentModel;

namespace SnmpMailer
{
    class MainClass
    {
        static Semaphore mailSendSemaphore;

        private static void MailSendCallback(object sender, AsyncCompletedEventArgs arg)
        {
            // Get our unique token for this asynchronous operation.
            String token = (string) arg.UserState;

            // Did the user abort the sent ?
            if (arg.Cancelled)
                Console.WriteLine("[{0}] Send canceled.", token);
            // Did an error occur during the send?
            if (arg.Error != null)
                 Console.WriteLine("[{0}] {1}", token, arg.Error.ToString());
            else
                Console.WriteLine("Message sent succesfully!");

            // Release the main thread
            mailSendSemaphore.Release();
        }

        public static void Main(string[] args)
        {
            mailSendSemaphore = new Semaphore(0,1);

            /* Create the mail message with to & from */
            MailMessage Msg = new MailMessage(new MailAddress("noreply@dijksterhuis.org"),
                                              new MailAddress("martijn@dijksterhuis.org"));

            Msg.Body = "Dear Customer, " + Environment.NewLine + Environment.NewLine;
            Msg.Body += "Because of repeated violations of our terms and conditions we had no choice but to";
            Msg.Body += "terminate your account with us." + Environment.NewLine + Environment.NewLine;
            Msg.Body += "The Management";
            Msg.BodyEncoding = System.Text.Encoding.UTF8;

            /* Set the subject */
            Msg.Subject = "Termination of service notice";

            /* Add our own header */
            Msg.Headers.Add("X-Deliverator","Terminator");

            /* Deliver the message in an asynchronous fashion */
            SmtpClient Deliverator = new SmtpClient("mymailserver.com");

            /* Print the default client */
            Console.WriteLine("Default SMTP Server: {0}",Deliverator.Host);

            /* Specify the call back function */
            Deliverator.SendCompleted += new SendCompletedEventHandler(MailSendCallback);

            /* For an asyncronous call we can pass a token to help us determine the message being send */
            Deliverator.SendAsync(Msg,"Msg ID 1212");

            /* Because we have little else to do, we set a semaphore and wait */
            mailSendSemaphore.WaitOne();

            Console.WriteLine("Mail delivery finished");
        }
    }
}

Image credit: Mzelle Biscotte

This is a post from Martijn's C# Coding Blog.

If you like to submit a POST form to your server the following will explain how to do create the program.

To help with debugging I created a tiny test script on my server to see if my code was working as advertised: http://www.dijksterhuis.org/test/post.php Please feel free to use this script to see if your program is working correctly.

My wrapper code is easy to use and allows for you to add any number of parameters to the POST request:

			WebPostRequest myPost = new WebPostRequest("http://www.dijksterhuis.org/test/post.php");
			myPost.Add("keyword","void");
			myPost.Add("data","hello&+-[]");

I use the HttpUtility.UrlEncode method to ensure that all parameters containing weird symbols survive their trip over the Internet intact.

string Response = myPost.GetResponse();

The above function call executes the query and returns any response from the server. The test script simply echoes the parameters and their values.

using System;
using System.Net;
using System.Web;
using System.Collections;
using System.IO;

namespace WebRequestExample
{

	class WebPostRequest
	{
		WebRequest theRequest;
		HttpWebResponse theResponse;
		ArrayList  theQueryData;

		public WebPostRequest(string url)
		{
			theRequest = WebRequest.Create(url);
			theRequest.Method = "POST";
			theQueryData = new ArrayList();
		}

		public void Add(string key, string value)
		{
			theQueryData.Add(String.Format("{0}={1}",key,HttpUtility.UrlEncode(value)));
		}

		public string GetResponse()
		{
			// Set the encoding type
			theRequest.ContentType="application/x-www-form-urlencoded";

			// Build a string containing all the parameters
			string Parameters = String.Join("&",(String[]) theQueryData.ToArray(typeof(string)));
			theRequest.ContentLength = Parameters.Length;

			// We write the parameters into the request
			StreamWriter sw = new StreamWriter(theRequest.GetRequestStream());
  			sw.Write(Parameters);
  			sw.Close();

			// Execute the query
			theResponse =  (HttpWebResponse)theRequest.GetResponse();
  			StreamReader sr = new StreamReader(theResponse.GetResponseStream());
   			return sr.ReadToEnd();
		}

	}

	class MainClass
	{
		public static void Main(string[] args)
		{
			WebPostRequest myPost = new WebPostRequest("http://www.dijksterhuis.org/test/post.php");
			myPost.Add("keyword","void");
			myPost.Add("data","hello&+-[]");
			Console.WriteLine(myPost.GetResponse());
		}
	}
}

This is a post from Martijn's C# Coding Blog.

At the end of this post you will find my BasicFTPClient class that implements the uploading and downloading code.

1. Download an FTP file to disk

If you have a file called “fileonftpserver.txt” and would like to download it to “/tmp/mydownload.txt” use the “DownloadFile” method:

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
     MyClient.DownloadFile("fileonftpserver.txt","/tmp/mydownload.txt"); // c:\temp\mydownload.txt for Windows
}
catch (WebException e)
{
     Console.WriteLine(e.ToString());
}

2. Download an FTP file to memory

If you would like to directly process the file you have downloaded (and don’t need to save it to disk first) the “DownloadData” method is your friend. If you would like to print the contents of the file to the console you could try this:

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
    byte[] Data = MyClient.DownloadData("download.test");

    // Convert the data to a string
    String s = System.Text.Encoding.UTF8.GetString(Data);
    Console.WriteLine(s);
}
catch (WebException e)
{
    Console.WriteLine(e.ToString());
}

3. Upload a file to the FTP server

If you have a file on disk and would like to upload it to an FTP server then use the “UploadFile” method.

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
    MyClient.UploadFile("upload.test","/tmp/output.txt");
}
catch (WebException e)
{
    Console.WriteLine(e.ToString());
}

4. Upload a byte[] to the FTP server

The “UploadData” method takes a byte array as the source of its data, allowing you to create something in memory and then save it to an FTP server. Usefull for those reports you have just generated.

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
    string MyReport = "Sales figures for October 2010";
    byte[] Data = System.Text.Encoding.UTF8.GetBytes(MyReport);
    MyClient.UploadData("upload.test",Data);
}
catch (WebException e)
{
    Console.WriteLine(e.ToString());
}

The Mono angle

All of the above examples work on Mono just as well as on Microsoft’s .NET. With a catch: I found two bugs in the Mono class libraries that made things quite impossible. Both were fixed by the mono team within hours of reporting them (thanks!). So if you are using the Mono CVS code for Mono 2.4 you are in luck, otherwise the following code is not going to work until the next Mono release.

If you come across a problem with Mono reporting a bug is trivial, you can report them at bugzilla.novell.com

The BasicFTPClient class

using System;
using System.Net;
using System.IO;

namespace BasicFTPClientNamespace
{
    class BasicFTPClient
    {
        public string Username;
        public string Password;
        public string Host;
        public int Port;

        public BasicFTPClient()
        {
            Username = "anonymous";
            Password = "anonymous@internet.com";
            Port = 21;
            Host = "";
        }

        public BasicFTPClient(string theUser, string thePassword, string theHost)
        {
            Username = theUser;
            Password = thePassword;
            Host = theHost;
            Port = 21;
        }

        private Uri BuildServerUri(string Path)
        {
            return new Uri(String.Format("ftp://{0}:{1}/{2}", Host, Port, Path));
        }

        /// <summary>
        /// This method downloads the given file name from the FTP server
        /// and returns a byte array containing its contents.
        /// Throws a WebException on encountering a network error.
        /// </summary>

        public byte[] DownloadData(string path)
        {
            // Get the object used to communicate with the server.
            WebClient request = new WebClient();

            // Logon to the server using username + password
            request.Credentials = new NetworkCredential(Username, Password);
            return request.DownloadData(BuildServerUri(path));
        }

        /// <summary>
        /// This method downloads the FTP file specified by "ftppath" and saves
        /// it to "destfile".
        /// Throws a WebException on encountering a network error.
        /// </summary>
        public void DownloadFile(string ftppath, string destfile)
        {
            // Download the data
            byte[] Data = DownloadData(ftppath);

            // Save the data to disk
            FileStream fs = new FileStream(destfile, FileMode.Create);
            fs.Write(Data, 0, Data.Length);
            fs.Close();
        }

        /// <summary>
        /// Upload a byte[] to the FTP server
        /// </summary>
        /// <param name="path">Path on the FTP server (upload/myfile.txt)</param>
        /// <param name="Data">A byte[] containing the data to upload</param>
        /// <returns>The server response in a byte[]</returns>

        public byte[] UploadData(string path, byte[] Data)
        {
            // Get the object used to communicate with the server.
            WebClient request = new WebClient();

            // Logon to the server using username + password
            request.Credentials = new NetworkCredential(Username, Password);
            return request.UploadData(BuildServerUri(path), Data);
        }

        /// <summary>
        /// Load a file from disk and upload it to the FTP server
        /// </summary>
        /// <param name="ftppath">Path on the FTP server (/upload/myfile.txt)</param>
        /// <param name="srcfile">File on the local harddisk to upload</param>
        /// <returns>The server response in a byte[]</returns>

        public byte[] UploadFile(string ftppath, string srcfile)
        {
            // Read the data from disk
            FileStream fs = new FileStream(srcfile, FileMode.Open);
            byte[] FileData = new byte[fs.Length];

            int numBytesToRead = (int)fs.Length;
            int numBytesRead = 0;
            while (numBytesToRead > 0)
            {
                // Read may return anything from 0 to numBytesToRead.
                int n = fs.Read(FileData, numBytesRead, numBytesToRead);

                // Break when the end of the file is reached.
                if (n == 0) break;

                numBytesRead += n;
                numBytesToRead -= n;
            }
            numBytesToRead = FileData.Length;
            fs.Close();

            // Upload the data from the buffer
            return UploadData(ftppath, FileData);
        }

    }
}

This is a post from Martijn's C# Coding Blog.

To understand why you would want to do this, a little history: One of the good things about C is that it works on every imaginable platform, the bad thing was of course that it works on every imaginable platform. There was always a little tweaking required to get your code to compile. Your program might have needed to compile on Amiga, DOS , OS/2, Windows or Linux. The invention of the preprocessor made this much easier. As a separate step prior to compilation it combs through the source code and modifies it according to the pre-processing instructions found in the source code. The C compiler never gets to see the things that don’t apply to it.

In C# there is no separate preprocessor step instead the compiler itself skims through the code as it reads it. Fortunately it is also nowhere near as complex as the C pre-processor.

Contents

• The #define and #undef directives
• Unlike C and C++ there are no macros in C#
• Conditional Compilation with #if / #else / #endif
• Avoid the clutter – use conditional attributes instead
• Using #error and #warning during compilation
• Generated code builds and error reporting with #line
• Region Directives

The #define and #undef directives

The basis of the C# preprocessor directives are #define and #undef. They allow you to create and destroy symbols used by the preprocessing step.

#define TESTVERSION
#undef DEBUG

A common use is for a programmer to turn on and off the inclusion of debugging code. When you are coding and debugging this allow you to test your code but this code shouldn’t be present in the production version of your software.

It is possible to set symbols using /define on the compilers command line allowing you to build scripts that produce different versions of your code. For example a “full version” and a limited “demo” version.

C# does not have any pre-defined symbols, except for maybe DEBUG

If you are used to your C/C++ compiler setting large numbers of symbols so that you could identify the compiler and version you will puzzled to discover the C# doesn’t have any. So you cannot check for the .NET version from a pre-defined symbol and branch your code based on that. (The closest that you can do is to check for the execution environment at runtime, for example if you want to know if you a running under mono.)

If you are compiling your code in the Visual C# / MonoDevelop environment there will be one symbol defined you can use: DEBUG. This is set in the project options and if you are building your code you can select if you want to build the Debug or Release version.

Unlike C and C++ there are no macros in C#

The following is not going to fly on C#. Macro’s are commonly used to expand expressions while compiling C code. A common problem is that C doesn’t have a boolean type. So the first thing most programmers do when starting a new project is to define their own as shown in the next little C code snippet:

#include <stdio.h>

#define BOOL  int
#define TRUE   1
#define FALSE  0
#define IS_TRUE(x) (x == TRUE)

void main()
{
        if (IS_TRUE(TRUE))
        {
          printf("It is TRUE!");
        }
}

When the C preprocessor comes across this it would replace “BOOL” with int, FALSE with 0 and TRUE with 1. The compiler never saw the BOOL, or the TRUE or FALSE. But lets not hang around here — as said, this is not supported by C#

Conditional Compilation with #if / #else / #endif

Of course, if you can define symbols you need to be able to test for them as well. The #if / #else / #endif directives do just that. If you are building the debug version of your code, you can check for the DEBUG symbol:

#if DEBUG
Console.WriteLine(”Things are not going so well!”);
#endif

If you are not building the Debug version of your code — the above line is never seen by the compiler, and thus is not included in the assembly. All #if statements need to be closed by an #endif, and of course you can also use an #else statement:

#if DEBUG
Console.WriteLine(”Things are not going so well, some more debugging is needed!”);
#else
Console.WriteLine(”Fatal Error: Please call free support (0800) 123 123″);
#endif

The #eif directive is a short form for “#else #if #endif”, it works the same but you can save some space as you do not need to end with another #endif. If your project has a more complicated release schedule with alpha, beta and production releases you could try this:

#if (!RELEASE)
Console.WriteLine(”This is not a release version”);
#if (BETA)
Console.WriteLine(”Beta, for limited release only”);
#eif (ALPHA)
Console.WriteLine(”Alpha, for internal testing only”);
#endif
#else
Console.WriteLine(”Welcome to Widgets 1.0″);
#endif

As can be seen you can apply several operators to the symbols: ! (not),== (equality), != (inequality), && (and) and || (or).

Avoid the clutter – use conditional attributes instead

Even a small program has many potential spots where you might like to introduce a debug statement or a log function. If you have to put each of them into a seperate #if DEBUG / #endif block they will start to take up a lot of space in your code. C# has its own slightly more elegant solution to this problem: conditional attributes. They are included in the System.Diagnostics namespace.

In the following program the “LogLine” function will only ever run if the “DEBUG” symbol has been set.

using System;
using System.Diagnostics;

namespace MyNameSpace
{
    class MainClass
    {
        [ Conditional("DEBUG") ]
        public static void LogLine(string msg,string detail)
        {
            Console.WriteLine("Log: {0} = {1}",msg,detail);
        }

        public static void Main(string[] args)
        {
            int Total = 0;
            for(int Lp = 1; Lp < 10; Lp++)
            {
                LogLine("Total",Total.ToString());
                Total = Total + Lp;
            }
        }
    }
}

You can also define combinations chained together with OR to decide if the code is enabled:

[ Conditional("ALPHA"),Conditional("BETA") ]
public static void LogLine(string msg,string detail)

Conditionals work differently from the #if/#endif directives that in the above example the “LogLine” code will still be included in the assembly. It will never get called however. The compiler will ensure that the LogLine method isn’t called. In fact if you use a dissasembler (like monodis) the code for Main will look like this:

        public static void Main(string[] args)
        {
            int Total = 0;
            for(int Lp = 1; Lp < 10; Lp++)
                Total = Total + Lp;
        }

Using #error and #warning during compilation

C# provides the #error and #warning directives to output messages during compilation. As you can expect, if the compiler encounters an #error it will report the problem and stop compiling. The #warning directive just causes a log entry to be displayed in the build output.

#if !DEBUG
#warning This code is NOT production ready
#endif

Generated code builds and error reporting with #line

In regular coding there are not many uses for #line. This directive is mostly useful when you build a code generator that turns one source file into another. Microsoft uses this for example for ASP.NET. Normally if something breaks during such an intermediate step, the compiler would report the error as being in the intermediate file.

The #line directive can force the compiler to report the error as coming from a different line numer, or even a completely different source file.

        public static void Main(string[] args)
        {

#line 250
#if DEBUG
#error This code is NOT production ready
#endif

Even though in my original test code the warning was given at line 19 in the source file, the #line directive forces the compiler to report 250 instead.

Region Directives

The Visual Studio suite, and the newer MonoDevelop versions allow for outlining of code blocks. You click the little (+) next to the code and it expands the class or method. The #region and #endregion directives allow you to define your own outlined blocks.

#region myregion
        public static void Main(string[] args)
        {
            int Total = 0;
            for(int Lp = 1; Lp < 10; Lp++)
{
                LogLine("Total",Total.ToString());
                Total = Total + Lp;
            }
        }
#endregion

This is a post from Martijn's C# Coding Blog.

• The ReplaceFirst method replaces the first occurrence of “needle” in a string and replaces it with “replacement”.
• The ReplaceAll function is similar: it steps through the string modifying it each time it finds “needle” and replaces it. To avoid a possible infinite loop it first checks whether “needle” is equivalent to “replacement”.

using System;
using System.Collections;

namespace StringItems
{
        static class StringExt
        {
                public static string ReplaceFirst(this string haystack, string needle, string replacement)
                {
                        int pos = haystack.IndexOf(needle);
                        if (pos < 0) return haystack;

                        return haystack.Substring(0,pos) + replacement + haystack.Substring(pos+needle.Length);
                }

                public static string ReplaceAll(this string haystack, string needle, string replacement)
                {
                        int pos;
                        // Avoid a possible infinite loop
                        if (needle == replacement) return haystack;
                        while((pos = haystack.IndexOf(needle))>0)
                                haystack = haystack.Substring(0,pos) + replacement + haystack.Substring(pos+needle.Length);
                        return haystack;
                }

        }
}

Both methods are implemented using a class extension. (for more on creating class extensions see also Finding all occurrences of a string within another string) After you include these methods into your project you can call them directly from any string instance:

string myString = “Hello World”;
string myModifiedString = myString.ReplaceFirst(”World”,”People”);
Console.WriteLine(”{0}”,myModifiedString); // Writes: “Hello People”

An example use of the ReplaceAll method:

string myString = “boo foo is not foo boo or foo boo foo”;
string myModifiedString = myString.ReplaceFirst(”boo”,”goo”);
Console.WriteLine(”{0}”,myModifiedString); // Writes: “goo foo is not foo goo or foo goo foo”;

Why not just use a regular expression?

If you are familiar with the RegEx class in C# you can easily write a regular expression to achieve the same string replacement result:

using System.Text.RegularExpressions;
Regex regex = new Regex(”boo”);
string result = regex.Replace(”boo foo is not foo boo or foo boo foo”, “goo”);

Regular expressions are flexible and if you do anything more complex than just a basic string replacement they are your only choice. But they come at a hefty performance price. To run a regular expression it needs to be compiled first and then executed. The .NET runtime caches the expression for performance but using a regular expression for string replacement is still much slower.

How much slower are regular expressions for string replacement?

In an earlier post I described the Stopwatch class in System.Diagnostics. It is ideal for a little benchmark testing — so lets compare my string replacement methods with the build-in regular expression library:

string haystack = "boo foo is not foo boo or foo boo foo";
string result;
Stopwatch sw = Stopwatch.StartNew();
for (int Lp = 0; Lp < 100000; Lp++)
result = regex.Replace($haystack, "goo");
sw.Stop();
Console.WriteLine("Time used (float): {0} ms",sw.Elapsed.TotalMilliseconds);

And the same for the string replacement functions:

string haystack = "boo foo is not foo boo or foo boo foo";
string result;
Stopwatch sw = Stopwatch.StartNew();
for(int Lp = 0; Lp < 100000; Lp++)
result = haystack.ReplaceAll("boo","goo");
sw.Stop();
Console.WriteLine("Time used (float): {0} ms",sw.Elapsed.TotalMilliseconds);

The regular expression code needed 1100ms , whereas the string replacement code needed just 27ms. So for this particular example, the string replacement was 40 times faster than a regular expression.

This is a post from Martijn's C# Coding Blog.

Because you might want to use this code throughout your project it is implemented as an Extension class. Simply put: the IndexOfAll method is attached to the String class. So if we want to call it we can just use .IndexOfAll(needle)

To be able to define an extension we need to create a static method and put it into a static class. The first parameter of the method identifies the class the method should associate with. In our case: string. We do this by defining it as “this string”.

using System;
using System.Collections;

namespace StringItems
{
    static class StringExt
    {
        public static IEnumerable IndexOfAll(this string haystack, string needle)
        {
            int pos,offset = 0;
            while ((pos = haystack.IndexOf(needle))>0)
            {
                haystack = haystack.Substring(pos+needle.Length);
                offset += pos;
                yield return offset;
            }
        }
    }

    class MainClass
    {
        public static void Main(string[] args)
        {
            string needle = "x";
            string haystack = "3 x 4 = 2 x 6 = 1 x 12";
            foreach(int Pos in haystack.IndexOfAll(needle))
                Console.WriteLine("Offset: {0}",Pos);
        }
    }
}

This is a post from Martijn's C# Coding Blog.

To understand how LINQ works, and to realize that its more than just syntactic sugar added to C# we first need to review a couple of basic concepts that when combined lead to LINQ.

Simple definitions, simplified

In typical C# you will always carefully spell out your definitions:

string MyString = “Hello World”;

From the right side of the declaration it is obvious that only one type (string) will ever match this definition. So instead of us doing the work, why not let the compiler figure this out?

var MyString = “Hello World”;

The above definition will also create a string variable named “MyString”. It is important to note that C# is still strongly typed — unlike scripted languages such as Visual Basic (or PHP) once you have assigned the variable type it sticks. The following will not work:

var MyString2 = “Hello World”;
MyString2 = 123; // Nice try, but no banana

The compiler will throw an implicit conversion error as 123 cannot be assigned to a string.

The above was an impressive (if somewhat pointless) example of what an anonymous type is. For simple types such as strings, integers etc anonymous types offer little benefits. It is even possible to argue that it reduces your code readability.

Using anonymous types for creating arrays

We are not limited to simple types – the following example show how we can create an anonymous array of integers:

int[] myIntArray = new int[] { 1 , 2 , 3 , 4 , 5 , 6 };
var myIntArrayVar = new [] { 1 , 2 , 3 , 4 , 5 , 6 };

The above two examples are equivalent. You still need to specify that you want to create an array using new. You are however limited by how flexible the compiler is. A mixed array is a little too much and we need to force it down to an object array:

var myMixedArray = new [] { 1, “two” , 3 , “four” , 5 }; // this does NOT work
object[] myMixedArray = new object[] { 1, “two” , 3 , “four” , 5 }; // this is OK

Saving time and code with anonymous types

One very powerful feature of anonymous types it that they can save you a lot of work. Instead of having to type out everything explicitly, you can have the compiler infer the definition of a complete class:

using System;
class MainClass
{
        public static void Main(string[] args)
        {
            var Person = new { Name = "Michael", Age = 23 };
            Console.WriteLine("Name: {0} Age: {1}",Person.Name,Person.Age);
        }
}

The compiler creates an anonymous definition of a class and assigns to it Name and Age as public fields. We can combine anonymous classes and anonymous arrays to create an Employee data structure. Note that we use a “Var” in the ForEach loop. Because we are combining anonymous types it is impossible to determine the correct type to loop over each element in the array. Thankfully we can ask the compiler to fill in the correct iterator type for us:

    using System;
    class MainClass
    {
        public static void Main(string[] args)
        {
            var Person1 = new { Name = "Michael", Age = 23 };
            var Person2 = new { Name = "Sandra", Age = 33 };
            var Employees = new [] { Person1, Person2 };

            foreach (var P in Employees)
                Console.WriteLine("Name: {0} Age: {1}",P.Name,P.Age);

        }
    }

As Employees is an array we can use an iterator to step through it as shown above, but we can just as easily use a for loop:

    using System;
    class MainClass
    {
        public static void Main(string[] args)
        {
            var Person1 = new { Name = "Michael", Age = 23 };
            var Person2 = new { Name = "Sandra", Age = 33 };
            var Employees = new [] { Person1, Person2 };

            for(int Lp = 0; Lp < Employees.Length; Lp++)
              Console.WriteLine("Name: {0} Age: {1}",Employees[Lp].Name,Employees[Lp].Age);
        }
    }

Lambda expressions and anonymous methods

Lambda expressions are an extension of Anonymous Methods which were introduced in C# 2.0 Lambda expressions add a lot of power to C#, but they can be hard to understand. They are however great for small filters than can be passed on to functions as variables as we will see in the following example:

Func<int,bool> mySeniorStaffFilter = a => a > 35;
Console.WriteLine(”36 is senior? {0}”,mySeniorStaffFilter(36));

The above function can be defined anywhere inside your code. It takes a single integer as a parameter and returns a boolean. The integer is defined as “a”, and the function checks whether a is larger than 35.

Using the “old” anonymous methods we could have written the above as:

Func<int,bool> mySeniorStaffFilter = delegate(int a) { return a > 35; };

The Lambda expression syntax is the same, but shorter and this make them slightly easier to understand.

Combining Lambda expressions with Queries

If you have used Intellisense in Visual Studio or the greatly improved object browser in MonoDevelop 2.0 you will discover that with C# 3.0 arrays have a much larger set of methods associated with them. One of these methods is “Where”. It takes a filter as an argument ; and then simply applies each member of the array to the filter. If the filter returns “true” the value is yielded and returned in a sub-set.

In plain language: If you have an array of employees you can pass mySeniorStaffFilter function to the Where method. It checks every staff member to see if their age is over 35 and then returns an array containing only those members of staff.

var SeniorStaff = Employees.Where(s => s.Age > 35);

The following code example shows how this works:

   using System;
   using System.Linq;

    class MainClass
    {
        public static void Main(string[] args)
        {
            var Employees = new [] { new { Name = "Michael", Age = 23 },
                                     new { Name = "Anton", Age = 43 },
                                     new { Name = "Nadia", Age = 36 },
                                     new { Name = "Lydia", Age = 34 } };

            var SeniorStaff = Employees.Where(s => s.Age > 35);          

            foreach(var Member in SeniorStaff)
             Console.WriteLine("Name: {0} Age: {1}",Member.Name,Member.Age);

        }
    }

From the above you can see that the compiler needs to infers,create and apply several anonymous types to create a working code sample. We thankfully can use “var” to specify our SeniorStaff sub-set. Behind the scenes the compiler has created an anonymous IEnumberable for SeniorStaff that contains our Employee records with anonymous staff members. And for the Where method it applied an anonymous delegate to create the correct filter.

And this leads us to the first real “LINQ” statement.

var SeniorStaff = from S in Employees where S.Age > 35 select S;

When you take away the syntactic sugar the C# compiler will build from this the same (or very similar) “Employees.Where(s => s.Age > 35)” statement. Using the same anonymous methods, variables and functions as we used earlier.

This took a lot of getting to. It is however important to understand that LINQ is implemented in C# through basic, strongly typed variables and methods.

To keep the complexity of our C# code down the “var” keyword was added allowing the programmer to focus on coding the logic of the program instead of having to write long hand type definitions for each variable.

Q. Is var typesafe?

There’s no concern about type-safety, as the variable created is not dynamic. It’s just compiler magic and any type unsafe calls you make will get caught.

Q. Is there a performance penalty for using “var” ?

The var keyword only tells the compiler to infer the type from the assignment, there’s no runtime difference, so no, there’s no penalty performance wise.

Q. On using anonymous definitions in large projects

Anonymous types cannot be shared across assembly boundaries. The compiler ensures that there is at most one anonymous type for a given sequence of property name/type pairs within each assembly. To pass structures between assemblies you will need to properly define them.

References

1. http://msdn.microsoft.com/en-us/library/bb308959.aspx

This is a post from Martijn's C# Coding Blog.

Cutting a string using a delimiter

string Msg = “1997,Ford,E350,Super luxurious truck”;

The String.Split function allows you to specify one or more separators. If we want to cut the above string at each comma we would do the following:

string Msg = "1997,Ford,E350,Super luxurious truck";
string[] Data = Msg.Split(new char[] {','});
int Cnt = 0;
foreach(string Field in Data)
Console.WriteLine("{0} = {1}",Cnt++,Field);

This outputs:

0 = 1997
1 = Ford
2 = E350
3 = Super luxurious truck

The split method takes an array of char[] as its parameter. It is possible to specify more than one separator. So if you would like to split a string on both comma’s and exclamation marks you could do the following:

string Msg = "The world is not enough ! I have one, two, no three! plans for conquering it";
string[] Data = Msg.Split(new char[] {',','!'});

If you specify nothing at all then String.Split() will break on a predefined set of separators. These include spaces (all Unicode defined spaces), line breaks, tabs etc.

If you don’t want the returned array to contain empty strings, you can specify StringSplitOptions.RemoveEmptyEntries

string Msg = "One,Two,,Four,,,Six,,Eight";
string[] Data = Msg.Split(new char[] {','},StringSplitOptions.RemoveEmptyEntries);

Putting things back together again using String.Join()

To quickly put things back together again we just String.Join(), its use is simple: You specify the character you would like to use to join, and pass an array of strings and the first element in the array to use. Lastly it is possible to limit the number of items Joined together.

String[] val = {”ape”,”monkey”,”lion”,”human”,”woman”};
Console.WriteLine(”{0}”, String.Join(”|”,val,0,4));

This results in:

ape|monkey|lion|human

Building a Comma Separated Values (CSV) reader / writer using String.Split and String.Join

Comma Seperated Values files are created by spreadsheets (such as Excel, OpenOffice Calc), databases (Microsoft Access). They are used to quickly transport data between different programs.   As we can now split input, and put it back together again I have created a very simple CSV reader and writer. It can read and write a CSV file and for good measure display to contents on the console.

Note that this reader is very simple, it does not deal with many potential data formatting issues that are perfectly legal for a CSV file. If you intend to import large data sets from databases you will want to create something stronger.

To play with this code the following data set provides a little bit of history on Japanese car manufacturers. It contains the name of the company, its founding year, current number of employees and founders name.

Data.CSV

Toyota,1937,316000,Kiichiro Toyoda
Mazda,1920,39364,Jujiro Matsuda
Honda,1948,167231,Soichiro Honda

using System;
using System.IO;
using System.Collections;
using System.Text;

namespace consoleoutput
{
	class MainClass
	{

		public static ArrayList ReadCSV(string FileName)
		{
			ArrayList DataRows = new ArrayList();

		    // Create a Streamreader and open the file
		    using (StreamReader sr = new StreamReader(FileName))
            {
                String line;
                // Read lines from the file until the end of
                // the file is reached.
                while ((line = sr.ReadLine()) != null)
                {
					// Skip over empty lines
					if (line.Length == 0) continue;

					// Split the line at the comma
					string[] DataColumn = line.Split(new char[] {','});

					// Add the row of data to the ArrayList
					DataRows.Add(DataColumn);
                }
            }

			return DataRows;
		}

		public static void WriteCSV(string FileName, ArrayList CSVData)
		{
		    // Create a StreamWriter and open the file
		    using (StreamWriter sw = new StreamWriter(FileName))
            {
				foreach(string[] CSVRow in CSVData)
				{
					string line = String.Join(",",CSVRow);
					sw.WriteLine(line);
				}
			}
		}

		public static void PrintCVS(ArrayList CSVData)
		{
			foreach(string[] CSVRow in CSVData)
			{
				string line = String.Join(",",CSVRow);
				Console.WriteLine(line);
			}
		}
		public static void Main(string[] args)
		{
			ArrayList myArrayList = ReadCSV("/home/martijn/cars.csv");
			PrintCVS(myArrayList);
			WriteCSV("/home/martijn/output.csv",myArrayList);
		}
	}
}

Image credit: Kacey

This is a post from Martijn's C# Coding Blog.

String.Format is a very powerful method but the documentation at MSDN is quite wordy and spreads the details over many pages. For this post I have made quick reference to its many specifiers and for good measure added some examples to help get you started.If you would like to format a date, currency, number or just the time, String.Format is your friend.

For a trip down memory lane a little example how we did things in C. The C sprintf function takes a buffer, a formatting string, a couple of parameters and munches them together:

#include <stdio.h>
int main()
{
char buffer[255];
sprintf(buffer,"Customer %d lives is %d years old and owns us %2.2f dollars", 1024, 96, 125.6f);
printf("%s",buffer);
}

This results in the following output:

Customer 1024 is 96 years old and owns us 125.50

Of course, if we made the buffer too small and the string expanded too much we might have created a buffer overrun once of C’s pesky little annoyances. And of course for each parameter we need to specify how to format them (%d for integers, %s for strings and %f for floats). Get the type wrong and things will go funny fast.

Enter String.Format and Console.WriteLine

So how do things work in C#? The String.Format method takes care of all our needs and a little more. Similar to the relationships between sprintf and printf the methods String.Format and Console.WriteLine work similary. String.Format returns a string whereas Console.WriteLine sends the resulting string to the console output.

The following should be a familiar example:

int ResultValue = 123;
string myString = String.Format(”The value is {0}”,ResultValue);
Console.WriteLine(”The value is {0}”,ResultValue);

The Index

The {0} is an index and refers to the first parameter given following the formatting string. {1},{2} to the second, third etc. You can also refer to a parameter more than once. The following is perfectly acceptable:

Console.WriteLine(”First {0}, Second {1}, Third {2}, And again the First {0}”,Value1,Value2,Value2);

Aligning the output

C# provides an alignment value that allows you to left or right align the output. Handy for screen or print formatting.

If you specify an alignment of 10 characters the resulting string will always be 10 characters even if the number only took up 4 places. The remainder is padded with spaces. If the value we want to display is longer than our given alignment size the alignment value is ignored.

Console.WriteLine(”The value is {0,10} – continue from here”,9999);

The above will output the value “9999″, and allocate 10 spaces for it. The output is right-aligned, the format method will simply add sufficient spaces to make sure the total length adds up to 10 characters.

To make the output left-aligned we need to make the number negative:

Console.WriteLine(”The value is {0,-10} – continue from here”,9999);

Displaying enumerated types

One very interesting feature of C# is the ability to display enumerated types.If you make your own enumeration wouldn’t it be nice if you could just print the values as a string literals? In fact you can as shown by the following example:

class MainClass
{
public enum Transport {Car = 1, Plane = 2, Motorcycle = 3}

public static void Main(string[] args)
{
Transport peopleMover = Transport.Plane;

Console.WriteLine("{0:G}",peopleMover);  // string literal
Console.WriteLine("{0:f}",peopleMover);   // flag -- not clear
Console.WriteLine("{0:d}",peopleMover);  // decimal
Console.WriteLine("{0:x}",peopleMover);   // hexadecimal
}
}

This outputs:

Plane

Plane

2
00000002

Basic number formatting

When no format is specified the String.Format method applies the “g” (General) type, which results in any value passed being rendered into a standard string. The following table shows what is possible:

If the table lists (error) it means that the String.Format method threw a String.Formatting exception. This happens if the number cannot be converted properly.

Custom number formatting

Of course, your preferred format is not listed above and you need a few modifications made. Not a problem. Custom formatting allows for any kind of number-to-string conversion you might need:

Date formats

The following table show the basic date formats obtained from calling DateTime.Now and then formatting the result. Note that different systems might produce different results depending on how the operating system is configured (think Chinese/Japanese/etc systems).

Custom Date formatting

The custom format strings allow DateTime objects to be formatted when the standard formatting strings are not useful and you need some special.

Image credit: easement

This is a post from Martijn's C# Coding Blog.