MPGH .NET SDK [ongoing project]

using System;
using System.Media;

public static void WavPlay(string FileName)
            {
                try //Code placed in try...catch block to catch exceptions.
                {   //Note: Not all exceptions are handled by this code. Just a common one.
                    SoundPlayer Player = new SoundPlayer(); //Instance of SoundPlayer class
                    Player.SoundLocation = FileName; //Set Soundlocation to FileName.
                    Player.Play(); //Call the Play() function on our SoundPlayer object.
                }
                catch (FileNotFoundException)
                {
                    return; //If this exception is thrown, the function simply returns.
                }
            }

using System;
using System.Net.NetworkInformation;
public static void Ping(string AddressOrHost)
            {
                try
                {
                    System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
                    ping.Send(AddressOrHost, 1000);
                }
                catch (System.Net.NetworkInformation.PingException)
                {
                    return;
                }
            }//Pings the specified IP Address or Host Name. One second timeout.
            public static void Ping(string AddressOrHost, int TimeOut)
            {
                try
                {
                    System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
                    ping.Send(AddressOrHost, TimeOut);
                }
                catch (System.Net.NetworkInformation.PingException)
                {
                    return;
                }
            }//Pings the specified IP Address or Host Name with the specified Timeout.
            public static void Ping(string AddressOrHost, int TimeOut, byte[] PingBuffer)
            {
                try
                {
                    System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
                    ping.Send(AddressOrHost, TimeOut, PingBuffer);
                }
                catch (System.Net.NetworkInformation.PingException)
                {
                    return;
                }
            }

using System;
using System.IO;

public static void DriveScan()
            {
                DriveInfo[] DriveList = System.IO.DriveInfo.GetDrives();
                try
                {
                    foreach (DriveInfo n in DriveList)
                    {///Returns info for every drive in the system.
                        if (n.IsReady == true)
                        {
                            Console.WriteLine("Drive Name: ");
                            Console.WriteLine(n.Name);
                            Console.WriteLine("Root Directory: ");
                            Console.WriteLine(n****otDirectory.FullName);
                            Console.WriteLine("File System Type/Format: ");
                            Console.WriteLine(n.DriveFormat);
                            Console.WriteLine("Total Size: ");
                            Console.WriteLine(n.TotalSize.ToString());
                            Console.WriteLine("Available Free Space: ");
                            Console.WriteLine(n.AvailableFreeSpace.ToString());
                            Console.WriteLine("Total Free Space: ");
                            Console.WriteLine(n.TotalFreeSpace.ToString());
                            Console.WriteLine("Type: ");
                            Console.WriteLine(n.DriveType.ToString());
                            Console.WriteLine("~:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:~");
                        }
                    }
                }
                catch (UnauthorizedAccessException e)
                {
                    Console.WriteLine(e.Message);
                    Console.WriteLine(e.StackTrace);
                    return;
                }
                catch (IOException e)
                {
                    Console.WriteLine(e.Message);
                    Console.WriteLine(e.StackTrace);
                    return;
                }
            }

using System;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using Microsoft.CSharp.RuntimeBinder;
using Microsoft.VisualBasic;

public static bool CompileExecutable(String sourceName)
            {
                FileInfo sourceFile = new FileInfo(sourceName);
                CodeDomProvider provider = null;
                bool compileOk = false;
            retry:
                // Select the code provider based on the input file extension.
                if (sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) == ".CS")
                {
                    provider = CodeDomProvider.CreateProvider("CSharp");
                }
                else if (sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) == ".VB")
                {
                    provider = CodeDomProvider.CreateProvider("VisualBasic");
                }
                else
                {
                    Console.WriteLine("Source file must have a .cs or .vb extension");
                    Console.ReadLine();
                    goto retry;
                }

                if (provider != null)
                {

                    // Format the executable file name.
                    // Build the output assembly path using the current directory
                    // and <source>_cs.exe or <source>_vb.exe.

                    String exeName = String.Format(@"{0}\{1}.exe", //change .exe to .dll
                        System.Environment.CurrentDirectory,
                        sourceFile.Name.Replace(".", "_"));

                    CompilerParameters cp = new CompilerParameters();

                    // Generate an executable instead of 
                    // a class library.
                    cp.GenerateExecutable = true; //change this to false to compile .dll

                    // Specify the assembly file name to generate.
                    cp.OutputAssembly = exeName;

                    // Save the assembly as a physical file.
                    cp.GenerateInMemory = false;

                    // Set whether to treat all warnings as errors.
                    cp.TreatWarningsAsErrors = false;

                    // Invoke compilation of the source file.
                    CompilerResults cr = provider.CompileAssemblyFromFile(cp,
                        sourceName);

                    if (cr.Errors.Count > 0)
                    {
                        // Display compilation errors.
                        Console.WriteLine("Errors building {0} into {1}",
                            sourceName, cr.PathToAssembly);
                        foreach (CompilerError ce in cr.Errors)
                        {
                            Console.WriteLine("  {0}", ce.ToString());
                            Console.WriteLine();
                        }
                    }
                    else
                    {
                        // Display a successful compilation message.
                        Console.WriteLine("Source {0} built into {1} successfully.",
                            sourceName, cr.PathToAssembly);
                    }

                    // Return the results of the compilation.
                    if (cr.Errors.Count > 0)
                    {
                        compileOk = false;
                    }
                    else
                    {
                        compileOk = true;
                    }
                }
                return compileOk;
            }

using System;
using System.Text;

public static string XOR_String(string TextToEncrypt, int Key)
            {
                StringBuilder InSb = new StringBuilder(TextToEncrypt);
                StringBuilder OutSb = new StringBuilder(TextToEncrypt.Length);
                char c;
                for (int i = 0; i < TextToEncrypt.Length; i++)
                {
                    c = InSb[i];
                    c = (char)(c ^ Key);
                    OutSb.Append(c);
                }
                return OutSb.ToString();
            }