Transform XML using XSLT file

public static string TransformXML(string transformXsltPath, string wordDocXml)
        {
            var transformedXML = new StringBuilder();
            XslCompiledTransform xslTransform = new XslCompiledTransform();

            xslTransform.Load(transformXsltPath);

            using (TextReader tr = new StringReader(wordDocXml))
            {
                // Load the xml of your main document part.
                using (XmlReader reader = XmlReader.Create(tr))
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        XmlWriterSettings settings = xslTransform.OutputSettings.Clone();

                        // Configure xml writer to omit xml declaration.
                        settings.ConformanceLevel = ConformanceLevel.Fragment;
                        settings.OmitXmlDeclaration = true;

                        XmlWriter xw = XmlWriter.Create(ms, settings);

                        // Transform our OfficeMathML to MathML.
                        xslTransform.Transform(reader, xw);
                        ms.Seek(0, SeekOrigin.Begin);

                        using (StreamReader sr = new StreamReader(ms, Encoding.UTF8))
                        {
                            transformedXML.AppendLine(XMLHelper.RemoveAllNamespaces(sr.ReadToEnd()));
                        }
                    }
                }
                return transformedXML.ToString();
            }
        }

Remove All Namespace from XML string

//Implemented based on interface, not part of algorithm
        public static string RemoveAllNamespaces(string xmlDocument)
        {
            XElement xmlDocumentWithoutNs = RemoveAllNamespaces(XElement.Parse(xmlDocument));

            return xmlDocumentWithoutNs.ToString();
        }

        //Implemented based on interface, not part of algorithm
        public static string RemoveAllNamespaces(string xmlDocument, XNamespace nameException)
        {
            XElement xmlDocumentWithoutNs = RemoveAllNamespaces(XElement.Parse(xmlDocument));

            return xmlDocumentWithoutNs.ToString();
        }

        //Core recursion function
        private static XElement RemoveAllNamespaces(XElement xmlDocument)
        {
            if (!xmlDocument.HasElements)
            {
                XElement xElement = new XElement(xmlDocument.Name.LocalName);
                xElement.Value = xmlDocument.Value;

                foreach (XAttribute attribute in xmlDocument.Attributes())
                    xElement.Add(attribute);

                return xElement;
            }
            return new XElement(xmlDocument.Name.LocalName, xmlDocument.Elements().Select(el => RemoveAllNamespaces(el)));
        }

Random String Generator C#

using System;
    using System.Security.Cryptography;

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    public class RandomStringGenerator
    {
        public bool UseSpecialCharacters { get; set; }

        public RandomStringGenerator()
        {
            UseSpecialCharacters = true;
        }

        private static int DEFAULT_MIN_PASSWORD_LENGTH = 8;
        private static int DEFAULT_MAX_PASSWORD_LENGTH = 10;

        // Define supported password characters divided into groups.
        // You can add (or remove) characters to (from) these groups.
        private const string PASSWORD_CHARS_LCASE = “abcdefgijkmnopqrstwxyz”;

        private const string PASSWORD_CHARS_UCASE = “ABCDEFGHJKLMNPQRSTWXYZ”;
        private const string PASSWORD_CHARS_NUMERIC = “23456789”;
        private const string PASSWORD_CHARS_SPECIAL = “*$-+?_&=!%{}/”;

        /// <summary>
        /// Generates a random password.
        /// </summary>
        /// <returns>
        /// Randomly generated password.
        /// </returns>
        /// <remarks>
        /// The length of the generated password will be determined at
        /// random. It will be no shorter than the minimum default and
        /// no longer than maximum default.
        /// </remarks>
        public string Generate()
        {
            return Generate(DEFAULT_MIN_PASSWORD_LENGTH,
                            DEFAULT_MAX_PASSWORD_LENGTH);
        }

        /// <summary>
        /// Generates a random password of the exact length.
        /// </summary>
        /// <param name=”length”>
        /// Exact password length.
        /// </param>
        /// <returns>
        /// Randomly generated password.
        /// </returns>
        public string Generate(int length)
        {
            length = 8;
            return Generate(length, length);
        }

        /// <summary>
        /// Generates a random password.
        /// </summary>
        /// <param name=”minLength”>
        /// Minimum password length.
        /// </param>
        /// <param name=”maxLength”>
        /// Maximum password length.
        /// </param>
        /// <returns>
        /// Randomly generated password.
        /// </returns>
        /// <remarks>
        /// The length of the generated password will be determined at
        /// random and it will fall with the range determined by the
        /// function parameters.
        /// </remarks>
        public string Generate(int minLength,
                                      int maxLength)
        {
            // Make sure that input parameters are valid.
            if (minLength <= 0 || maxLength <= 0 || minLength > maxLength)
                return null;

            // Create a local array containing supported password characters
            // grouped by types. You can remove character groups from this
            // array, but doing so will weaken the password strength.

            char[][] charGroups = new char[][]
            {
                PASSWORD_CHARS_LCASE.ToCharArray(),
                PASSWORD_CHARS_UCASE.ToCharArray(),
                PASSWORD_CHARS_NUMERIC.ToCharArray(),
            };
            if (UseSpecialCharacters)
            {
                charGroups.Append(PASSWORD_CHARS_SPECIAL.ToCharArray());
            }

            // Use this array to track the number of unused characters in each
            // character group.
            int[] charsLeftInGroup = new int[charGroups.Length];

            // Initially, all characters in each group are not used.
            for (int i = 0; i < charsLeftInGroup.Length; i++)

                charsLeftInGroup[i] = charGroups[i].Length;

            // Use this array to track (iterate through) unused character groups.
            int[] leftGroupsOrder = new int[charGroups.Length];

            // Initially, all character groups are not used.
            for (int i = 0; i < leftGroupsOrder.Length; i++)

                leftGroupsOrder[i] = i;

            // Because we cannot use the default randomizer, which is based on the
            // current time (it will produce the same “random” number within a
            // second), we will use a random number generator to seed the
            // randomizer.

            // Use a 4-byte array to fill it with random bytes and convert it then
            // to an integer value.
            byte[] randomBytes = new byte[4];

            // Generate 4 random bytes.
            var rng = new RNGCryptoServiceProvider();

            rng.GetBytes(randomBytes);

            // Convert 4 bytes into a 32-bit integer value.
            int seed = (randomBytes[0] & 0x7f) << 24 |

                       randomBytes[1] << 16 |

                       randomBytes[2] << 8 |

                       randomBytes[3];

            // Now, this is real randomization.
            Random random = new Random(seed);

            // This array will hold password characters.
            char[] password = null;

            // Allocate appropriate memory for the password.
            if (minLength < maxLength)

                password = new char[random.Next(minLength, maxLength + 1)];

            else

                password = new char[minLength];

            // Index of the next character to be added to password.
            int nextCharIdx;

            // Index of the next character group to be processed.
            int nextGroupIdx;

            // Index which will be used to track not processed character groups.
            int nextLeftGroupsOrderIdx;

            // Index of the last non-processed character in a group.
            int lastCharIdx;

            // Index of the last non-processed group.
            int lastLeftGroupsOrderIdx = leftGroupsOrder.Length – 1;

            // Generate password characters one at a time.
            for (int i = 0; i < password.Length; i++)
            {
                // If only one character group remained unprocessed, process it;
                // otherwise, pick a random character group from the unprocessed
                // group list. To allow a special character to appear in the
                // first position, increment the second parameter of the Next
                // function call by one, i.e. lastLeftGroupsOrderIdx + 1.
                if (lastLeftGroupsOrderIdx == 0)
                    nextLeftGroupsOrderIdx = 0;
                else
                    nextLeftGroupsOrderIdx = random.Next(0,
                                                         lastLeftGroupsOrderIdx);

                // Get the actual index of the character group, from which we will
                // pick the next character.
                nextGroupIdx = leftGroupsOrder[nextLeftGroupsOrderIdx];

                // Get the index of the last unprocessed characters in this group.
                lastCharIdx = charsLeftInGroup[nextGroupIdx] – 1;

                // If only one unprocessed character is left, pick it; otherwise,
                // get a random character from the unused character list.
                if (lastCharIdx == 0)
                    nextCharIdx = 0;
                else
                    nextCharIdx = random.Next(0, lastCharIdx + 1);

                // Add this character to the password.
                password[i] = charGroups[nextGroupIdx][nextCharIdx];

                // If we processed the last character in this group, start over.
                if (lastCharIdx == 0)

                    charsLeftInGroup[nextGroupIdx] =

                                              charGroups[nextGroupIdx].Length;

                // There are more unprocessed characters left.
                else
                {
                    // Swap processed character with the last unprocessed character
                    // so that we don’t pick it until we process all characters in
                    // this group.
                    if (lastCharIdx != nextCharIdx)
                    {
                        char temp = charGroups[nextGroupIdx][lastCharIdx];

                        charGroups[nextGroupIdx][lastCharIdx] =

                                    charGroups[nextGroupIdx][nextCharIdx];

                        charGroups[nextGroupIdx][nextCharIdx] = temp;
                    }

                    // Decrement the number of unprocessed characters in
                    // this group.
                    charsLeftInGroup[nextGroupIdx]–;
                }

                // If we processed the last group, start all over.
                if (lastLeftGroupsOrderIdx == 0)
                    lastLeftGroupsOrderIdx = leftGroupsOrder.Length – 1;
                // There are more unprocessed groups left.
                else
                {
                    // Swap processed group with the last unprocessed group
                    // so that we don’t pick it until we process all groups.
                    if (lastLeftGroupsOrderIdx != nextLeftGroupsOrderIdx)
                    {
                        int temp = leftGroupsOrder[lastLeftGroupsOrderIdx];

                        leftGroupsOrder[lastLeftGroupsOrderIdx] =

                                    leftGroupsOrder[nextLeftGroupsOrderIdx];

                        leftGroupsOrder[nextLeftGroupsOrderIdx] = temp;
                    }
                    // Decrement the number of unprocessed groups.
                    lastLeftGroupsOrderIdx–;
                }
            }

            // Convert password characters into a string and return the result.
            return new string(password);
        }
    }

    /// <summary>
    /// Illustrates the use of the RandomPassword class.
    /// </summary>
    ////////public class RandomPasswordTest
    ////////{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    ////////[STAThread]
    ////////private static void Main(string[] args)
    ////////{
    ////////    // Print 100 randomly generated passwords (8-to-10 char long).
    ////////    for (int i = 0; i < 100; i++)
    ////////        Console.WriteLine(RandomPassword.Generate(8, 10));
    ////////}
    ////////}

Read to End Stream, (With Error Handling)

/// <summary>
    /// TODO: Update summary.
    /// </summary>
    public class StreamHelper
    {
        public static byte[] ReadToEnd(Stream stream)
        {
            long originalPosition = 0;

            if (stream.CanSeek)
            {
                originalPosition = stream.Position;
                stream.Position = 0;
            }

            try
            {
                byte[] readBuffer = new byte[4096];

                int totalBytesRead = 0;
                int bytesRead;

                while ((bytesRead = stream.Read(readBuffer, totalBytesRead, readBuffer.Length – totalBytesRead)) > 0)
                {
                    totalBytesRead += bytesRead;

                    if (totalBytesRead == readBuffer.Length)
                    {
                        int nextByte = stream.ReadByte();
                        if (nextByte != -1)
                        {
                            byte[] temp = new byte[readBuffer.Length * 2];
                            Buffer.BlockCopy(readBuffer, 0, temp, 0, readBuffer.Length);
                            Buffer.SetByte(temp, totalBytesRead, (byte)nextByte);
                            readBuffer = temp;
                            totalBytesRead++;
                        }
                    }
                }

                byte[] buffer = readBuffer;
                if (readBuffer.Length != totalBytesRead)
                {
                    buffer = new byte[totalBytesRead];
                    Buffer.BlockCopy(readBuffer, 0, buffer, 0, totalBytesRead);
                }
                return buffer;
            }
            finally
            {
                if (stream.CanSeek)
                {
                    stream.Position = originalPosition;
                }
            }
        }
    }

Append and Prepend in IEnumerable object

/// <summary>Adds a single element to the end of an IEnumerable.</summary>
        /// <typeparam name=”T”>Type of enumerable to return.</typeparam>
        /// <returns>IEnumerable containing all the input elements, followed by the
        /// specified additional element.</returns>
        public static IEnumerable<T> Append<T>(this IEnumerable<T> source, T element)
        {
            if (source == null)
                throw new ArgumentNullException(“source”);
            return concatIterator(element, source, false);
        }

        /// <summary>Adds a single element to the start of an IEnumerable.</summary>
        /// <typeparam name=”T”>Type of enumerable to return.</typeparam>
        /// <returns>IEnumerable containing the specified additional element, followed by
        /// all the input elements.</returns>
        public static IEnumerable<T> Prepend<T>(this IEnumerable<T> tail, T head)
        {
            if (tail == null)
                throw new ArgumentNullException(“tail”);
            return concatIterator(head, tail, true);
        }

        private static IEnumerable<T> concatIterator<T>(T extraElement,
            IEnumerable<T> source, bool insertAtStart)
        {
            if (insertAtStart)
                yield return extraElement;
            foreach (var e in source)
                yield return e;
            if (!insertAtStart)
                yield return extraElement;
        }

POWER SET IN C#

Power sets in c# are strong tools to generate possible permutations.
There are numerous ways to generate it.
1. Using binary arithmetic.

using System.Collections.Generic;

namespace PowerSets
{
    class Solution1
    {
        public static IList<IList<T>> PowerSet<T>(IList<T> list)
        {
            int n = 1 << list.Count;
            IList<IList<T>> powerset = new List<IList<T>>();
            for (int i = 0; i < n; ++i)
            {
                IList<T> set = new List<T>();
                for (int bits = i, j = 0; bits != 0; bits >>= 1, ++j)
                {
                    if ((bits & 1) != 0)
                        set.Add(list[j]);
                }
                powerset.Add(set);
            }
            return powerset;
        }
    }
}

2. Using iteration.

using System.Collections.Generic;
using System.Linq;

namespace PowerSets
{
    public class Solution2
    {
        public static IList<IList<T>> PowerSet<T>(IList<T> list)
        {
            IList<IList<T>> powerset = new List<IList<T>>() { new List<T>() };
            foreach (T item in list)
            {
                foreach (IList<T> set in powerset.ToArray())
                {
                    powerset.Add(new List<T>(set) { item });
                }
            }
            return powerset;
        }
    }
}

3. Using recursion.

using System.Collections.Generic;
using System.Linq;
namespace PowerSets
{
    public class Solution3
    {
        static public IList<IList<T>> PowerSet<T>(IList<T> list)
        {
            if (list.Count == 0)
            {
                return new List<IList<T>>(new[] { new List<T>() });
            }
            else
            {
                IList<IList<T>> ps = PowerSet(list.Skip(1).ToArray());
                foreach (List<T> ss in ps.ToArray())
                {
                    ps.Add(new List<T>(ss) { list.First() });
                }
                return ps;
            }
        }
    }
}
Rosetta Code has lots of example you can refer for.

Create List Heirarchy from flat collection of entities

namespace TUEMIS.Common
{
    public static class TreeExtensions
    {
private static IEnumerable<TreeNode<TEntity>> CreateHierarchy<TEntity, TProperty>(IEnumerable<TEntity> items, TEntity parentItem,
            Func<TEntity, TProperty> idProperty, Func<TEntity, TProperty> parentIdProperty, int level, Func<TEntity, TProperty> orderBy) where TEntity : class
        {
            items = items.OrderBy(orderBy);

            IEnumerable<TEntity> childs;
            if (parentItem == null)
                childs = items.Where(i => parentIdProperty(i).Equals(default(TProperty)));
            else
                childs = items.Where(i => parentIdProperty(i).Equals(idProperty(parentItem)));

            if (childs.Any())
            {
                level++;
                foreach (var item in childs)
                {
                    yield return new TreeNode<TEntity>
                    {
                        Entity = item,
                        Children = CreateHierarchy<TEntity, TProperty>(items, item, idProperty, parentIdProperty, level, orderBy).ToList(),
                        Level = level
                    };
                }
            }
        }

        /// <summary>
        /// LINQ IEnumerable AsHierachy() extension method
        /// </summary>
        /// <typeparam name=”TEntity”>Entity class</typeparam>
        /// <typeparam name=”TProperty”>Property of entity class</typeparam>
        /// <param name=”items”>Flat collection of entities</param>
        /// <param name=”idProperty”>Reference to Id/Key of entity</param>
        /// <param name=”parentIdProperty”>Reference to parent Id/Key</param>
        /// <returns>Hierarchical structure of entities</returns>
        public static IEnumerable<TreeNode<TEntity>> AsHierarchy<TEntity, TProperty>(this IEnumerable<TEntity> items, Func<TEntity, TProperty> idProperty, Func<TEntity, TProperty> parentIdProperty, Func<TEntity, TProperty> orderBy) where TEntity : class
        {
            return CreateHierarchy(items, default(TEntity), idProperty, parentIdProperty, 0, orderBy);
        }
}
}

    public class TreeNode<T>
    {
        public TreeNode()
        {
            Children = new List<TreeNode<T>>();
        }
        public T Entity { get; set; }
        public int Level { get; set; }
        public List<TreeNode<T>> Children { get; set; }
    }

Convert a string to proper case

public static string ToProperCase(this string str)
        {
            str = str.ToText();
            return System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
        }

 public static string ToText(this object o)
        {
            if (o == null || o == DBNull.Value)
            {
                return string.Empty;
            }
            return o.ToString();
        }

Check if two date range intersects

Returns true if two date ranges intersect.

Code:

public static class DateTimeExtensions
{
    public static bool Intersects(this DateTime startDate, DateTime endDate, DateTime intersectingStartDate, DateTime intersectingEndDate)
    {
        return (intersectingEndDate >= startDate && intersectingStartDate <= endDate);
    }
}

Example:
bool eventsInterect = eventXStartDate.Intersects(eventXEndDate, eventYStartDate, eventYEndDate);

The SQL Server failed to initialize VIA support library [QLVipl.dll].

Got an error today trying to start newly installed sql express service – The SQL Server failed to initialize VIA support library [QLVipl.dll]. This normally indicates the VIA support library does not exist or is corrupted. Please repair or disable the VIA network protocol. Error: 0x7e.

Solution to the problem:

1. Open SQL server configuration manager
2. Under  SQL server network configuration node select your instance
3. Disable VIA protocol