Category Archive C#

ByMel

C#: Detect If You’re Running on the Server

If you ever need to detect whether your code is running on the machine that you’re talking to through IP (a server application for example), and you know the IP address for the remote machine, then this code may come in handy. It was originally written by my buddy Erin for a project we both worked on.

using System.Net;

private bool CheckIfServer(IPAddress serverIP)
{
    // Get all addresses assigned to this machine
    List ipAddresses = new List();
    ipAddresses.AddRange(Dns.GetHostAddresses(Dns.GetHostName()));

    // If desirable, also include the loopback adapter
    ipAddresses.Add(IPAddress.Loopback);

    // Detect if this machine contains the IP for the remote server
    // Note: This uses a Lambda Expression, which is only available .Net 3.x
    return ipAddresses.Exists(i => i.ToString() == serverIP.ToString());
}

If you don’t know the IP Address for your remote server you can easily get it using the server’s host name like this:

IPAddress[] addresses = Dns.GetHostAddresses("remote_host_address");

This returns an IPAddress[] which includes all the resolved addresses for that host.

ByMel

C#: Lower Case All XML Tags with Regex

Sometimes when accepting an XML document from an uncontrolled source using Linq to XML, it’s useful to convert all tags and attributes to lower case before processing the XML. This is because Linq to XML is case-sensitive and you can’t always rely on the program producing the XML to follow your casing standard for elements and attributes.

So here’s a quick and dirty single line of code that will accomplish just this in C# using a regular expression:

Regex.Replace(
    xml, 
    @"<[^<>]+>",
    m => { return m.Value.ToLower(); }, 
    RegexOptions.Multiline | RegexOptions.Singleline);

And here’s that functionality all nice and wrapped up inside of an extension for XElement:

public static class XElementExt
{
    public static string LowerCaseTags(string xml)
    {
        return Regex.Replace(
            xml,
            @"<[^<>]+>",
            m => { return m.Value.ToLower(); },
            RegexOptions.Multiline | RegexOptions.Singleline);
    }
}

Note: The Regex class is defined in System.Text.RegularExpressions

Here’s an example of the resulting affect.

Before:

<ELEMENT>
    <ChildTag>
        <inner>This text Will not Be Harmed!</inner>
    </ChildTag>
</ELEMENT>

After:

<element>
    <childtag>
        <inner>This text Will not Be Harmed!</inner>
    </childtag>
</element>

You’ll notice that with this method all text within element tags is converted to lower case. This means that attribute values will lose any special casing they may have had, which may or may not be a problem for what you’re doing.

ByMel

C#: Set File Type Association

While searching for some simple C# code to set the program and icon associated with a file type in Windows I ran across these beautiful functions that illustrate how to accomplish this by using the registry.

All credit goes to cristiscu (source).

Here’s the code:

using Microsoft.Win32;
using System.Runtime.InteropServices;

public class FileAssociation
{
    // Associate file extension with progID, description, icon and application
    public static void Associate(string extension, 
           string progID, string description, string icon, string application)
    {
        Registry.ClassesRoot.CreateSubKey(extension).SetValue("", progID);
        if (progID != null && progID.Length > 0)
            using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(progID))
            {
                if (description != null)
                    key.SetValue("", description);
                if (icon != null)
                    key.CreateSubKey("DefaultIcon").SetValue("", ToShortPathName(icon));
                if (application != null)
                    key.CreateSubKey(@"Shell\Open\Command").SetValue("", 
                                ToShortPathName(application) + " \"%1\"");
            }
    }

    // Return true if extension already associated in registry
    public static bool IsAssociated(string extension)
    {
        return (Registry.ClassesRoot.OpenSubKey(extension, false) != null);
    }

    [DllImport("Kernel32.dll")]
    private static extern uint GetShortPathName(string lpszLongPath, 
        [Out] StringBuilder lpszShortPath, uint cchBuffer);

    // Return short path format of a file name
    private static string ToShortPathName(string longName)
    {
        StringBuilder s = new StringBuilder(1000);
        uint iSize = (uint)s.Capacity;
        uint iRet = GetShortPathName(longName, s, iSize);
        return s.ToString();
    }
}

And here’s how you’d use it:

if (!FileAssociation.IsAssociated(".ext"))
   Associate(".ext", "ClassID.ProgID", "ext File", "YourIcon.ico", "YourApplication.exe");

A couple caveats to this code that I’ve noticed:

  1. The second parameter passed to Associate() can be any string you’d like to use to represent your program in the registry, just make sure you’re consistent with it.
  1. ToShortPathName() will return an empty string if the file path you pass it doesn’t exist, i.e. if you pass it a path to an icon file that doesn’t exist it won’t work.
  1. IsAssociated() will return true if the file extension is associated with any program, not just yours. If you want to be specific about it checking whether it’s associated with your program, then just check whether it’s default key is set to your programs ProgID.
ByMel

C#, Functions Creating Functions, with Lambda!

So as my knowledge pertaining to the programming language C# progresses by contributions from the people around me as well as the infinite amount of resources online, I find it more and more fascinating and powerful. It’s sort of the “do-all” language, yet it still does it all in style.

Take this little concept for example. With the use of lambda expressions much like you’d find in any other functional programming language such as F#, F#’s predecessor ML, or Haskell, you can produce some pretty slick functional code right inline with everything else. This also produces an effect that is similiar (if not exactly) known as currying.

The following code uses a set of lambda expressions to create a nested function who takes an int and returns a function that matches the event signature for a Button.Click event. This allows us to dynamicly create a new function for each Button added to the form.

void AddButtons()
{
    // Create a brand new function that takes
    // an int and returns another function that
    // matches the definition of an EventHandler.
    Func func =
        (x) => (sender, args) =>
            MessageBox.Show(x.ToString());

    // Add a list of buttons to our control/form
    // giving each a unique Click event.
    for (int i = 0; i < 10; i++)
    {
        Button btn = new Button();
        btn.Click += func(i);    // Add handler
        this.Controls.Add(btn);  // Add the button
    }
}

I know this isn’t the most useful example or most impressive, but it’s still pretty cool and serves as a nice reference. For some more slick examples of code optimization in C# you should check out some of the posts on my buddy Erin’s blog over at Random Bits of Foo.

ByMel

C#: Send Email with SMTP

So I’ve actually had to do this before for a project I was working on, and thought that I’d go ahead and post a brief example of how to accomplish it here.

This example sends a simple email to a single recipient by using GMail. Please note that the principle classes used (MailMessage, SmtpClient, and NetworkCredential) are only available in the .NET Library 2.0 or later. For .NET < 2.0 you’ll want to see the System.Web namespace.

// Create the mail object.
System.Net.Mail.MailMessage msgMail =
    new System.Net.Mail.MailMessage(
        "TestEmail@mel-gree.com",   // FROM
        "mel@mel-green.com"         // TO
    );

// Set the subject of the message
msgMail.Subject = "Hello from C#";

// Set that the body of this message will be HTML
msgMail.IsBodyHtml = true;

// Set the body of the email. Since I specified that
// I'm using HTML this will be fully qualified HTML/XHTML
msgMail.Body =
    "<html>" +
      "<body>" +
        "<h1>Hello There!</h1>" +
        "<p>
           You've been selected to receive this email. Congratulations!
         </p>" +
      "</body>" +
    "</html>";

// Now I'll create an SMTP object to send the message
// by means of a SMTP server.
System.Net.Mail.SmtpClient smtp =
    new System.Net.Mail.SmtpClient(
            "smtp.gmail.com", // Server address
            587               // Server port
        );

// GMail uses SSL
smtp.EnableSsl = true;

// GMail uses authentication
smtp.UseDefaultCredentials = false;
smtp.Credentials
    = new System.Net.NetworkCredential (
        "mastermel@gmail.com", // Account Name
        "MyPassword"           // Account Password
      );

// Finally, send the message!
smtp.Send(msgMail);

Here’s a few extra things you might want to know about…

Read More