C#

using System.Linq;
public static string[] ParseArray (object[] arr)
{
  return arr.Select(o => o.ToString()).ToArray();
}

using System.Text;
using System.Text.RegularExpressions;

public static class StringExtensions
{
    public static string ReplaceAll(this string originalString, string[] findValues, string replacementPattern)
    {
        string joined = string.Join('|', findValues);

        string pattern = $"{joined}";

        var r = new Regex(pattern, RegexOptions.IgnoreCase);

        string updatedString = r.Replace(originalString, replacementPattern);

        return updatedString;
    }
}

using System.Text;
using System.Text.RegularExpressions;
public static class StringExtensions
{
    public static string ReplaceFirstInstance(this string originalString, string[] findValues, string replacementPattern)
    {
        string joined = string.Join('|', findValues);

        string pattern = $"{joined}";

        var r = new Regex(pattern, RegexOptions.IgnoreCase);

        string updatedString = r.Replace(originalString, replacementPattern, 1);

        return updatedString;
    }
}

using System.Text;
using System.Text.RegularExpressions;
public static class StringExtensions
{
    public static string ReplaceFirstInstance(this string originalString, string[] findValues, string replacementPattern)
    {
        string joined = string.Join('|', findValues);

        string pattern = $"{joined}";

        var r = new Regex(pattern, RegexOptions.IgnoreCase);

        string updatedString = r.Replace(originalString, replacementPattern, 1);

        return updatedString;
    }
}

using System.Text;
using System.Text.RegularExpressions;
public static class StringExtensions
{
public static string ToShortDescription(this string ls, int length)
    {
        if (!string.IsNullOrEmpty(ls.Trim()))
        {
            ls = ls.Trim().StripSpecialCharacters();

            if (ls.Length > length)
            {
                ls = ls.Substring(0, length - 3); //-3 for dots
                ls = ls.Remove(ls.LastIndexOf(" "), (ls.Length - ls.LastIndexOf(" ")));
                ls += "...";
            }

            return ls;
        }
        return string.Empty;
    }


public static string StripSpecialCharacters(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        Regex r = new Regex(@"\s+");//remove all whitespace
        s = r.Replace(s, " ");	// to a single space

        MatchCollection mc = Regex.Matches(s, @"[A-Za-z0-9]|\s+", RegexOptions.IgnoreCase);
        s = string.Empty;
        foreach (Match m in mc)
        {
            s += m.ToString();
        }

        return s;
    }
  
}

using System.Text;
using System.Text.RegularExpressions;

public static class StringExtensions
{
    public static string StripSpecialCharacters(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        Regex r = new Regex(@"\s+");//remove all whitespace
        s = r.Replace(s, " ");	// to a single space

        MatchCollection mc = Regex.Matches(s, @"[A-Za-z0-9]|\s+", RegexOptions.IgnoreCase);
        s = string.Empty;
        foreach (Match m in mc)
        {
            s += m.ToString();
        }

        return s;
    }
  
}

using System.Text;
using System.Text.RegularExpressions;

public static class StringExtensions
{
    public static string StripExtraSpaces(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        Regex r = new Regex(@"\s+");//remove all whitespace
        s = r.Replace(s, " ");	// to a single space

        return s;
    }
}

public static class StringExtensions
{
    public static string Left(this string value, int maxLength)
    {
        if (string.IsNullOrEmpty(value)) return value;
        maxLength = Math.Abs(maxLength);

        return ( value.Length <= maxLength 
               ? value 
               : value.Substring(0, maxLength)
               );
    }
}

function grid_product_filter(element) {
    build_gridfilter(element, '/Products/GridFilterRead');
}


function build_gridfilter(element, url) {
   
    var combobox = element.kendoComboBox({

    placeholder: "Select",
    autoBind: true,
    filter: "contains",

        dataTextField: "Name",
        dataValueField: "Name",

        dataSource: {
            type: "aspnetmvc-ajax",
            sort: { field: "Name", dir: "asc" },
            transport: {
                read: {
                    url: url,
                }
            },
            schema: {
                data: "Data",
                total: "Total"
            },
            pageSize: 200,
            serverPaging: true,
            serverFiltering: true,
            serverSorting: true
        }
    });
    setdropdownwidth(combobox);
}
var standardfilterwidth = 300;
function setdropdownwidth(combobox) {
    if (combobox.data("kendoComboBox"))
        combobox.data("kendoComboBox").list.width(standardfilterwidth);
    else if (combobox.data("kendoExtendedComboBox"))
        combobox.data("kendoExtendedComboBox").list.width(standardfilterwidth);
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Caching;
using System.Web;

namespace Common
{
    public static class CacheHelper
    {
        public static void AddOrUpdate(string key, object value, int expiresinhours)
        {
            if (HttpContext.Current != null)
            {
                if (HttpContext.Current.Cache[key] != null)
                {
                    HttpContext.Current.Cache[key] = value;
                }
                else
                {
                    HttpContext.Current.Cache.Add(key, value, null, DateTime.Now.AddHours(expiresinhours), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Normal, null);
                }
            }
            else if (MemoryCache.Default != null)
            {
                if (MemoryCache.Default[key] != null)
                {
                    MemoryCache.Default[key] = value;
                }
                else
                {
                    CacheItemPolicy policy = new CacheItemPolicy();
                    policy.AbsoluteExpiration = DateTime.Now.AddHours(expiresinhours);
                    MemoryCache.Default.Set(key, value, policy);
                }
            }
        }

        public static object Get(string key)
        {
            ObjectCache cache = MemoryCache.Default;
    
            if (HttpContext.Current!= null && HttpContext.Current.Cache[key] != null)
            {
                return HttpContext.Current.Cache[key];
            }
            else if (MemoryCache.Default != null && MemoryCache.Default[key] != null)
            {
                return MemoryCache.Default[key];
            }

            return null;
        }

        public static void DeleteCacheThatContains(string value)
        {
            if (HttpContext.Current != null)
            {
                List<string> keys = new List<string>();

                // retrieve application Cache enumerator
                IDictionaryEnumerator enumerator = HttpContext.Current.Cache.GetEnumerator();

                // copy all keys that currently exist in Cache
                while (enumerator.MoveNext())
                {
                    if (enumerator.Key.ToString().Contains(value))
                        keys.Add(enumerator.Key.ToString());
                }

                // delete every key from cache
                for (int i = 0; i < keys.Count; i++)
                {
                    HttpContext.Current.Cache.Remove(keys[i]);
                }
            }
        }


        public static void ClearAllCache()
        {
            if (HttpContext.Current != null)
            {
                List<string> keys = new List<string>();

                // retrieve application Cache enumerator
                IDictionaryEnumerator enumerator = HttpContext.Current.Cache.GetEnumerator();

                // copy all keys that currently exist in Cache
                while (enumerator.MoveNext())
                {
                    keys.Add(enumerator.Key.ToString());
                }

                // delete every key from cache
                for (int i = 0; i < keys.Count; i++)
                {
                    HttpContext.Current.Cache.Remove(keys[i]);
                }
            }
        }
    }
}

using System;


/// <summary>
/// Common DateTime Methods.
/// </summary>
/// 

public enum Quarter
    {
        First = 1,
        Second = 2,
        Third = 3,
        Fourth = 4
    }

    public enum Month
    {
        January = 1,
        February = 2,
        March = 3,
        April = 4,
        May = 5,
        June = 6,
        July = 7,
        August = 8,
        September = 9,
        October = 10,
        November = 11,
        December = 12
    }

    

    public enum DateRangeType {
    [StringValue("Today")]
    Today = 1,
    [StringValue("Yesterday")]
    Yesterday = 2 ,
    [StringValue("Last 7 Days")]
    Last7Days = 3 ,
    [StringValue("Last Week")]
    LastWeek = 4 ,
    [StringValue("Month to Date")]
    MonthToDate = 5 ,
    [StringValue("Previous Month")]
    PreviousMonth = 6 ,
    [StringValue("Year to Date")]
    YearToDate = 7  ,
    [StringValue("Previous Year")]
    PreviousYear = 8        
} 
namespace Pqdm.Common
{
    public class DateRangeHelper
    {
        private DateRangeType _type { get; set; }
        
       


        public static readonly DateTime SqlMinDate = new DateTime(1753, 1, 1);
        public static readonly DateTime SqlMaxDate = new DateTime(9999, 12, 31);


        public DateTime MinDate = SqlMinDate;
        public DateTime MaxDate = SqlMaxDate;



        #region Quarters

        public static DateTime GetStartOfQuarter(int Year, Quarter Qtr)
        {
            if (Qtr == Quarter.First)    // 1st Quarter = January 1 to March 31

                return new DateTime(Year, 1, 1, 0, 0, 0, 0);
            else if (Qtr == Quarter.Second) // 2nd Quarter = April 1 to June 30

                return new DateTime(Year, 4, 1, 0, 0, 0, 0);
            else if (Qtr == Quarter.Third) // 3rd Quarter = July 1 to September 30

                return new DateTime(Year, 7, 1, 0, 0, 0, 0);
            else // 4th Quarter = October 1 to December 31

                return new DateTime(Year, 10, 1, 0, 0, 0, 0);
        }

        public static DateTime GetEndOfQuarter(int Year, Quarter Qtr)
        {
            if (Qtr == Quarter.First)    // 1st Quarter = January 1 to March 31

                return new DateTime(Year, 3, DateTime.DaysInMonth(Year, 3), 23, 59, 59, 999);
            else if (Qtr == Quarter.Second) // 2nd Quarter = April 1 to June 30

                return new DateTime(Year, 6, DateTime.DaysInMonth(Year, 6), 23, 59, 59, 999);
            else if (Qtr == Quarter.Third) // 3rd Quarter = July 1 to September 30

                return new DateTime(Year, 9, DateTime.DaysInMonth(Year, 9), 23, 59, 59, 999);
            else // 4th Quarter = October 1 to December 31

                return new DateTime(Year, 12, DateTime.DaysInMonth(Year, 12), 23, 59, 59, 999);
        }

        public static Quarter GetQuarter(Month Month)
        {
            if (Month <= Month.March)
                // 1st Quarter = January 1 to March 31

                return Quarter.First;
            else if ((Month >= Month.April) && (Month <= Month.June))
                // 2nd Quarter = April 1 to June 30

                return Quarter.Second;
            else if ((Month >= Month.July) && (Month <= Month.September))
                // 3rd Quarter = July 1 to September 30

                return Quarter.Third;
            else // 4th Quarter = October 1 to December 31

                return Quarter.Fourth;
        }

        public static DateTime GetEndOfLastQuarter()
        {
            if ((Month)DateTime.Now.Month <= Month.March)
                //go to last quarter of previous year

                return GetEndOfQuarter(DateTime.Now.Year - 1, Quarter.Fourth);
            else //return last quarter of current year

                return GetEndOfQuarter(DateTime.Now.Year, GetQuarter((Month)DateTime.Now.Month));
        }

        public static DateTime GetStartOfLastQuarter()
        {
            if ((Month)DateTime.Now.Month <= Month.March)
                //go to last quarter of previous year

                return GetStartOfQuarter(DateTime.Now.Year - 1, Quarter.Fourth);
            else //return last quarter of current year

                return GetStartOfQuarter(DateTime.Now.Year, GetQuarter((Month)DateTime.Now.Month));
        }

        public static DateTime GetStartOfCurrentQuarter()
        {
            return GetStartOfQuarter(DateTime.Now.Year, GetQuarter((Month)DateTime.Now.Month));
        }

        public static DateTime GetEndOfCurrentQuarter()
        {
            return GetEndOfQuarter(DateTime.Now.Year, GetQuarter((Month)DateTime.Now.Month));
        }

        #endregion

        #region Weeks
        public static DateTime GetStartOfLastWeek()
        {
            int DaysToSubtract = (int)DateTime.Now.DayOfWeek + 7;
            DateTime dt = DateTime.Now.Subtract(System.TimeSpan.FromDays(DaysToSubtract));
            return new DateTime(dt.Year, dt.Month, dt.Day, 0, 0, 0, 0);
        }

        public static DateTime GetEndOfLastWeek()
        {
            DateTime dt = GetStartOfLastWeek().AddDays(6);
            return new DateTime(dt.Year, dt.Month, dt.Day, 23, 59, 59, 999);
        }

        public static DateTime GetStartOfCurrentWeek()
        {
            int DaysToSubtract = (int)DateTime.Now.DayOfWeek;
            DateTime dt = DateTime.Now.Subtract(System.TimeSpan.FromDays(DaysToSubtract));
            return new DateTime(dt.Year, dt.Month, dt.Day, 0, 0, 0, 0);
        }

        public static DateTime GetEndOfCurrentWeek()
        {
            DateTime dt = GetStartOfCurrentWeek().AddDays(6);
            return new DateTime(dt.Year, dt.Month, dt.Day, 23, 59, 59, 999);
        }
        #endregion

        #region Months

        public static DateTime GetStartOfMonth(Month Month, int Year)
        {
            return GetStartOfMonth(Year, (int)Month);
        }

        public static DateTime GetStartOfMonth(int Month, int Year)
        {
            return new DateTime(Year, Month, 1, 0, 0, 0, 0);
        }

        public static DateTime GetEndOfMonth(Month Month, int Year)
        {
            return GetEndOfMonth(Year, (int)Month);
        }

        public static DateTime GetEndOfMonth(int Month, int Year)
        {
            return new DateTime(Year, Month, DateTime.DaysInMonth(Year, Month), 23, 59, 59, 999);
        }

        public static DateTime GetStartOfLastMonth()
        {
            if (DateTime.Now.Month == 1)
                return GetStartOfMonth(Month.December, DateTime.Now.Year - 1);
            else
                return GetStartOfMonth(DateTime.Now.Month - 1, DateTime.Now.Year);
        }

        public static DateTime GetEndOfLastMonth()
        {
            if (DateTime.Now.Month == 1)
                return GetEndOfMonth(12, DateTime.Now.Year - 1);
            else
                return GetEndOfMonth(DateTime.Now.Month - 1, DateTime.Now.Year);
        }

        public static DateTime GetStartOfCurrentMonth()
        {
            return GetStartOfMonth(DateTime.Now.Month, DateTime.Now.Year);
        }

        public static DateTime GetEndOfCurrentMonth()
        {
            return GetEndOfMonth(DateTime.Now.Month, DateTime.Now.Year);
        }
        #endregion

        #region Years
        public static DateTime GetStartOfYear(int Year)
        {
            return new DateTime(Year, 1, 1, 0, 0, 0, 0);
        }

        public static DateTime GetEndOfYear(int Year)
        {
            return new DateTime(Year, 12, DateTime.DaysInMonth(Year, 12), 23, 59, 59, 999);
        }

        public static DateTime GetStartOfLastYear()
        {
            return GetStartOfYear(DateTime.Now.Year - 1);
        }

        public static DateTime GetEndOfLastYear()
        {
            return GetEndOfYear(DateTime.Now.Year - 1);
        }

        public static DateTime GetStartOfCurrentYear()
        {
            return GetStartOfYear(DateTime.Now.Year);
        }

        public static DateTime GetEndOfCurrentYear()
        {
            return GetEndOfYear(DateTime.Now.Year);
        }
        #endregion

        #region Days
        public static DateTime GetStartOfDay(DateTime date)
        {
            return new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, 0);
        }

        public static DateTime GetEndOfDay(DateTime date)
        {
            return new DateTime(date.Year, date.Month, date.Day, 23, 59, 59, 999);
        }
        #endregion

        public static DateTime GetMinDate(DateRangeType type)
        {
            DateTime returnvalue = DateTime.MaxValue;
            switch (type)
            {
                case (DateRangeType.Today):
                    returnvalue = GetStartOfDay(DateTime.Now);
                    break;
                case (DateRangeType.Yesterday):
                    returnvalue = GetStartOfDay(DateTime.Now.AddDays(-1));
                    break;
                case (DateRangeType.Last7Days):
                    returnvalue = GetStartOfDay(DateTime.Now.AddDays(-7));
                    break;
                case (DateRangeType.LastWeek):
                    returnvalue = GetStartOfLastWeek();
                    break;
                case (DateRangeType.MonthToDate):
                    returnvalue = GetStartOfMonth(DateTime.Now.Month, DateTime.Now.Year);
                    break;
                case (DateRangeType.PreviousMonth):
                    returnvalue = GetStartOfMonth(DateTime.Now.AddMonths(-1).Month, DateTime.Now.AddMonths(-1).Year);
                    break;
                case (DateRangeType.YearToDate):
                    returnvalue = GetStartOfYear(DateTime.Now.Year);
                    break;
                case (DateRangeType.PreviousYear):
                    returnvalue = GetStartOfMonth(DateTime.Now.AddYears(-1).Month, DateTime.Now.AddYears(-1).Year);
                    break;
            }
            return returnvalue;
        }

        public static DateTime GetMaxDate(DateRangeType type)
        {
            DateTime returnvalue = DateTime.MaxValue;
            switch (type)
            {
                case (DateRangeType.Today):
                    returnvalue = GetEndOfDay(DateTime.Now);
                    break;
                case (DateRangeType.Yesterday):
                    returnvalue = GetEndOfDay(DateTime.Now.AddDays(-1));
                    break;
                case (DateRangeType.Last7Days):
                    returnvalue= GetEndOfDay(DateTime.Now);
                    break;
                case (DateRangeType.LastWeek):
                    returnvalue = GetEndOfLastWeek();
                    break;
                case (DateRangeType.MonthToDate):
                    returnvalue= GetEndOfDay(DateTime.Now);
                    break;                    
                case (DateRangeType.PreviousMonth):
                    returnvalue = GetEndOfMonth(DateTime.Now.AddMonths(-1).Month, DateTime.Now.AddMonths(-1).Year);
                    break;
                case (DateRangeType.YearToDate):
                    returnvalue = GetEndOfDay(DateTime.Now);
                    break;
                case (DateRangeType.PreviousYear):
                   returnvalue = GetEndOfMonth(DateTime.Now.AddYears(-1).Month, DateTime.Now.AddYears(-1).Year);
                   break;
            }
            return returnvalue;
        }



        public DateRangeHelper(DateRangeType type)
        {
            _type = type;

            MinDate = GetMinDate(type);
            MaxDate = GetMaxDate(type);

        }


    }
}

using System.Collections.Generic;


/// <summary>
/// Compares two sequences.
/// </summary>
/// <typeparam name="T">Type of item in the sequences.</typeparam>
/// <remarks>
/// Compares elements from the two input sequences in turn. If we
/// run out of list before finding unequal elements, then the shorter
/// list is deemed to be the lesser list.
/// </remarks>
public class EnumerableComparer<T> : IComparer<IEnumerable<T>>
{
    /// <summary>
    /// Create a sequence comparer using the default comparer for T.
    /// </summary>
    public EnumerableComparer()
    {
        comp = Comparer<T>.Default;
    }

    /// <summary>
    /// Create a sequence comparer, using the specified item comparer
    /// for T.
    /// </summary>
    /// <param name="comparer">Comparer for comparing each pair of
    /// items from the sequences.</param>
    public EnumerableComparer(IComparer<T> comparer)
    {
        comp = comparer;
    }

    /// <summary>
    /// Object used for comparing each element.
    /// </summary>
    private IComparer<T> comp;


    /// <summary>
    /// Compare two sequences of T.
    /// </summary>
    /// <param name="x">First sequence.</param>
    /// <param name="y">Second sequence.</param>
    public int Compare(IEnumerable<T> x, IEnumerable<T> y)
    {
        using (IEnumerator<T> leftIt = x.GetEnumerator())
        using (IEnumerator<T> rightIt = y.GetEnumerator())
        {
            while (true)
            {
                bool left = leftIt.MoveNext();
                bool right = rightIt.MoveNext();

                if (!(left || right)) return 0;

                if (!left) return -1;
                if (!right) return 1;

                int itemResult = comp.Compare(leftIt.Current, rightIt.Current);
                if (itemResult != 0) return itemResult;
            }
        }
    }
}

using System;
using System.Data;
using System.Linq;
using System.Text.RegularExpressions;

/// <summary>
/// This static class provides statics methods to naturally sort a datatable column. 
/// </summary>
public static class NaturalSortService
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="table">DataTable with DataRows to be sorted</param>
    /// <param name="ColumnToSort">The name of the column to sort</param>
    /// <returns>Returns an EnumerableRowCollection of a DataRow type. The Collection is sorted naturally in a single column.</returns>
    public static System.Data.EnumerableRowCollection<System.Data.DataRow> Sort(DataTable table, string ColumnToSort)
    {
        //Used to determine numerical values which are placed first in importance.
        Func<string, object> convert = str =>
        {
            int returnInt = 0;
            if (int.TryParse(str, out returnInt))
                return returnInt;
            else
                return str;
        };

        //Using the EnumerableComparer from TestSampleResults.Domain.Services.EnumerableComparer
        var sorted = (from t in table.AsEnumerable()
                        select t).OrderBy(
                    str => Regex.Split(str.Field<string>(ColumnToSort).Replace(" ", ""), "([0-9]+)").Select(convert),
                    new EnumerableComparer<object>());


        return sorted;
    }
}

public static bool IsPlural(string instring)
    {
        return System.Data.Entity.Design.PluralizationServices.PluralizationService.CreateService(System.Globalization.CultureInfo.CurrentUICulture).IsPlural(instring);
    } 

 public static string Pluralize(string instring)
    {
        string outstring = string.Empty;

        outstring = System.Data.Entity.Design.PluralizationServices.PluralizationService.CreateService(System.Globalization.CultureInfo.CurrentUICulture).Pluralize(instring);

        return outstring;
    } 

public static string Singularize(string instring)
    {
        string outstring = string.Empty;

        outstring = System.Data.Entity.Design.PluralizationServices.PluralizationService.CreateService(System.Globalization.CultureInfo.CurrentUICulture).Singularize(instring);

        return outstring;
    } 

 public static bool IsSingular(string instring)
    {
        return System.Data.Entity.Design.PluralizationServices.PluralizationService.CreateService(System.Globalization.CultureInfo.CurrentUICulture).IsSingular(instring);
    } 

/// <summary>
    /// Get a formatted abbreviation. 
    /// </summary>
    /// <param name="input">input string</param>
    /// <returns>shortened string ...</returns>
    public static string Abbreviate(string input)
    {
        string output = string.Empty;

        //Replace all special characters with spaces
        input = ReplaceSpecialCharactersWithSpaces(input.Trim());

        //Replace extra spaces with since space
        input = StripExtraSpaces(input);

        //ZIPasdf asdf R33b asdf

        char[] characters = input.ToCharArray();

        //for each word grab first letter. for numbers grab whole number
        bool keepLetter = true;
        foreach (char c in characters)
        {
            if (Char.IsNumber(c))
            {
                output += c.ToString();
                keepLetter = true;
            }
            else if (Char.IsWhiteSpace(c)) { keepLetter = true; }
            else if (Char.IsLetter(c) && Char.IsUpper(c))
            {
                output += c.ToString().ToUpper();
                keepLetter = false;
            }            
            else if (keepLetter && Char.IsLetter(c))
            {
                output += c.ToString().ToUpper();
                keepLetter = false;
            }
        }

        if (output.Length > 50)
        {
            output = output.Substring(0, 50);            
        }

        return output;
    }

public static class Retry
    {
        public static void Do(
            Action action,
            TimeSpan retryInterval,
            int retryCount = 3)
        {
            Do<object>(() =>
            {
                action();
                return null;
            }, retryInterval, retryCount);
        }

        public static T Do<T>(
            Func<T> action,
            TimeSpan retryInterval,
            int retryCount = 3)
        {
            var exceptions = new List<Exception>();

            for (int retry = 0; retry < retryCount; retry++)
            {
                try
                {
                    if (retry > 0)
                        Thread.Sleep(retryInterval);
                    return action();
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            throw new AggregateException(exceptions);
        }
    }

/// <summary>
/// Retrieves full url path to the exact application path. ex: http://www.somesite.com/webapplication
/// </summary>
/// <returns>url</returns>
public static string FullyQualifiedApplicationPath()
{

	//Return variable declaration
	string appPath = null;

	//Getting the current context of HTTP request
	HttpContext context = HttpContext.Current;

	//Checking the current context content
	if (context != null)
	{
		//Formatting the fully qualified website url/name
		appPath = string.Format("{0}://{1}{2}{3}", context.Request.Url.Scheme, context.Request.Url.Host, context.Request.Url.Port == 80 ? string.Empty : ":" + context.Request.Url.Port.ToString(), context.Request.ApplicationPath);
	}

	if (!appPath.EndsWith("/"))
	{
		appPath += "/";
	}

	return appPath;
}

/// <summary>
/// Retrieves full url path of the host. ex: http://www.somesite.com/
/// </summary>
/// <returns>url</returns>
public static string FullyQualifiedHostWebAddress()
{

	//Return variable declaration
	string appPath = null;

	//Getting the current context of HTTP request
	HttpContext context = HttpContext.Current;

	//Checking the current context content
	if (context != null)
	{
		//Formatting the fully qualified website url/name
		appPath = string.Format("{0}://{1}{2}", context.Request.Url.Scheme, context.Request.Url.Host, context.Request.Url.Port == 80 ? string.Empty : ":" + context.Request.Url.Port.ToString());
	}

	if (!appPath.EndsWith("/"))
	{
		appPath += "/";
	}

	return appPath;
}

public bool IsDivisible(int x, int n)
{
   return (x % n) == 0;
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
					
public class Program
{
	public static void Main()
	{
		List<QueueItem> queueItems = new List<QueueItem>() { new QueueItem("test1"), new QueueItem("test2") };
		var dataTableColumnName = "MainColumn";
		var dataTableToCompare = new DataTable();
		var dc = new DataColumn(dataTableColumnName);
		dataTableToCompare.Columns.Add(dc);
		
        DataRow dr = dataTableToCompare.NewRow();
                dr[dataTableColumnName] = "test1";
                dataTableToCompare.Rows.Add(dr);
		
		dr = dataTableToCompare.NewRow();
                dr[dataTableColumnName] = "test3";
                dataTableToCompare.Rows.Add(dr);
		
		dr = dataTableToCompare.NewRow();
                dr[dataTableColumnName] = "test4";
                dataTableToCompare.Rows.Add(dr);
		
		var queueNames = queueItems.Select(s => String.Concat("'",s.QueueName,"'")).ToList();
        DataRow[] filtered = dataTableToCompare.Select(String.Format("{0} NOT IN ({1}) ",dataTableColumnName,String.Join(",", queueNames)));
		
		  foreach(DataRow r in filtered)
                {
                    Console.WriteLine(r[dataTableColumnName].ToString());
                }
		
	}
}


public class QueueItem{
 public string QueueName{get;set;}
	
	public QueueItem(string queueName){
	
		QueueName = queueName;
		
	}
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Data.DataSetExtensions;
public class Program
{
	public static void Main()
	{
		var dictionary1 = new Dictionary<string, object>();
		dictionary1.Add("Main Column", "test1");
		var dictionary2 = new Dictionary<string, object>();
		dictionary2.Add("Main Column", "test2");
		
		
		List<QueueItem> queueItems = new List<QueueItem>() { new QueueItem("QueueName", dictionary1), new QueueItem("QueueName", dictionary2) };
		string queueSpecificContentKey = "Main Column";
		
		
		var dataTableColumnName = "Main Column";
		var dataTableToCompare = new DataTable();
		var dc = new DataColumn(dataTableColumnName);
		dataTableToCompare.Columns.Add(dc);
		
        DataRow dr = dataTableToCompare.NewRow();
                dr[dataTableColumnName] = "test1";
                dataTableToCompare.Rows.Add(dr);
		
		dr = dataTableToCompare.NewRow();
                dr[dataTableColumnName] = "test3";
                dataTableToCompare.Rows.Add(dr);
		
		dr = dataTableToCompare.NewRow();
                dr[dataTableColumnName] = "test4";
                dataTableToCompare.Rows.Add(dr);
		
		//var queueNames = queueItems.Select(s => String.Concat("'",s.QueueName,"'")).ToList();
        //DataRow[] filtered = dataTableToCompare.Select(String.Format("[{0}] NOT IN ({1}) ",dataTableColumnName,String.Join(",", queueNames)));
		
		
		var filteredRows = from row in dataTableToCompare.AsEnumerable()
                                   join queueItem in queueItems
                                   on row.Field<string>(dataTableColumnName) equals queueItem.SpecificContent[queueSpecificContentKey] into rowLevelID
                                   from subrow in rowLevelID.DefaultIfEmpty()
                                   where subrow == null
                                   select row;
		
		  foreach(DataRow r in filteredRows)
                {
                    Console.WriteLine(r[dataTableColumnName].ToString());
                }
		
	}
}


public class QueueItem{
	
 public string QueueName{get;set;}
 public Dictionary<string, object> SpecificContent{get;set;}
	
	public QueueItem(string queueName, Dictionary<string, object> specificContent){
	
		QueueName = queueName;
		SpecificContent = specificContent;
		
	}
}

Array.ConvertAll<string, int>(value.Split(','), Convert.ToInt32);

public static string GetLastInstanceOf(string sentence)
        {
            string returnValue = sentence;

            var matches = System.Text.RegularExpressions.Regex.Matches(sentence, @"\(([^)]*)\)");
            if (matches.Count > 0)
            {
                returnValue = matches.Last().Groups[1].Value;
            }

            return returnValue;

        }

public static DateTime? ToNullableDateTime(this string text) => DateTime.TryParse(text, out var date) ? date : (DateTime?)null;

    static void CloneSheet(SpreadsheetDocument spreadsheetDocument, string sheetName, string clonedSheetName)
    {
        WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart;
        WorksheetPart sourceSheetPart = GetWorkSheetPart(workbookPart, sheetName);
        Sheets sheets = workbookPart.Workbook.GetFirstChild<Sheets>();

        SpreadsheetDocument tempSheet = SpreadsheetDocument.Create(new MemoryStream(), spreadsheetDocument.DocumentType);
        WorkbookPart tempWorkbookPart = tempSheet.AddWorkbookPart();
        WorksheetPart tempWorksheetPart = tempWorkbookPart.AddPart(sourceSheetPart);
        WorksheetPart clonedSheet = workbookPart.AddPart(tempWorksheetPart);

        Sheet copiedSheet = new Sheet();
        copiedSheet.Name = clonedSheetName;
        copiedSheet.Id = workbookPart.GetIdOfPart(clonedSheet);
        copiedSheet.SheetId = (uint)sheets.ChildElements.Count + 1;
        sheets.Append(copiedSheet);
    }

/// <summary>
/// If you want to find items in larger list that are not present in small list
/// </summary>
/// <param name="largerList">"A","B","C"</param>
/// <param name="smallerList">"A"</param>
/// <returns>"B","C"</returns>
public static string[] FindItemsNotInSmallerStringArray(this string[] largerList, string[] smallerList) => largerList.Except(smallerList).ToArray();

public static Nullable<T> ToNullable<T>(this string s) where T: struct
{
    Nullable<T> result = new Nullable<T>();
    try
    {
        if (!string.IsNullOrEmpty(s) && s.Trim().Length > 0)
        {
            TypeConverter conv = TypeDescriptor.GetConverter(typeof(T));
            result = (T)conv.ConvertFrom(s);
        }
    }
    catch { } 
    return result;
}