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;

        }

Similiar Collections

Python strftime reference pandas.Period.strftime python - Formatting Quarter time in pandas columns - Stack Overflow python - Pandas: Change day - Stack Overflow python - Check if multiple columns exist in a df - Stack Overflow Pandas DataFrame apply() - sending arguments examples python - How to filter a dataframe of dates by a particular month/day? - Stack Overflow python - replace a value in the entire pandas data frame - Stack Overflow python - Replacing blank values (white space) with NaN in pandas - Stack Overflow python - get list from pandas dataframe column - Stack Overflow python - How to drop rows of Pandas DataFrame whose value in a certain column is NaN - Stack Overflow python - How to drop rows of Pandas DataFrame whose value in a certain column is NaN - Stack Overflow python - How to lowercase a pandas dataframe string column if it has missing values? - Stack Overflow How to Convert Integers to Strings in Pandas DataFrame - Data to Fish How to Convert Integers to Strings in Pandas DataFrame - Data to Fish create a dictionary of two pandas Dataframe columns? - Stack Overflow python - ValueError: No axis named node2 for object type <class 'pandas.core.frame.DataFrame'> - Stack Overflow Python Pandas iterate over rows and access column names - Stack Overflow python - Creating dataframe from a dictionary where entries have different lengths - Stack Overflow python - Deleting DataFrame row in Pandas based on column value - Stack Overflow python - How to check if a column exists in Pandas - Stack Overflow python - Import pandas dataframe column as string not int - Stack Overflow python - What is the most efficient way to create a dictionary of two pandas Dataframe columns? - Stack Overflow Python Loop through Excel sheets, place into one df - Stack Overflow python - How do I get the row count of a Pandas DataFrame? - Stack Overflow python - How to save a new sheet in an existing excel file, using Pandas? - Stack Overflow Python Loop through Excel sheets, place into one df - Stack Overflow How do I select a subset of a DataFrame? — pandas 1.2.4 documentation python - Delete column from pandas DataFrame - Stack Overflow python - Convert list of dictionaries to a pandas DataFrame - Stack Overflow How to Add or Insert Row to Pandas DataFrame? - Python Examples python - Check if a value exists in pandas dataframe index - Stack Overflow python - Set value for particular cell in pandas DataFrame using index - Stack Overflow python - Pandas Dataframe How to cut off float decimal points without rounding? - Stack Overflow python - Pandas: Change day - Stack Overflow python - Clean way to convert quarterly periods to datetime in pandas - Stack Overflow Pandas - Number of Months Between Two Dates - Stack Overflow python - MonthEnd object result in <11 * MonthEnds> instead of number - Stack Overflow python - Extracting the first day of month of a datetime type column in pandas - Stack Overflow
MySQL MULTIPLES INNER JOIN How to Use EXISTS, UNIQUE, DISTINCT, and OVERLAPS in SQL Statements - dummies postgresql - SQL OVERLAPS PostgreSQL Joins: Inner, Outer, Left, Right, Natural with Examples PostgreSQL Joins: A Visual Explanation of PostgreSQL Joins PL/pgSQL Variables ( Format Dates ) The Ultimate Guide to PostgreSQL Date By Examples Data Type Formatting Functions PostgreSQL - How to calculate difference between two timestamps? | TablePlus Date/Time Functions and Operators PostgreSQL - DATEDIFF - Datetime Difference in Seconds, Days, Months, Weeks etc - SQLines CASE Statements in PostgreSQL - DataCamp SQL Optimizations in PostgreSQL: IN vs EXISTS vs ANY/ALL vs JOIN PostgreSQL DESCRIBE TABLE Quick and best way to Compare Two Tables in SQL - DWgeek.com sql - Best way to select random rows PostgreSQL - Stack Overflow PostgreSQL: Documentation: 13: 70.1. Row Estimation Examples Faster PostgreSQL Counting How to Add a Default Value to a Column in PostgreSQL - PopSQL How to Add a Default Value to a Column in PostgreSQL - PopSQL SQL Subquery - Dofactory SQL IN - SQL NOT IN - JournalDev DROP FUNCTION (Transact-SQL) - SQL Server | Microsoft Docs SQL : Multiple Row and Column Subqueries - w3resource PostgreSQL: Documentation: 9.5: CREATE FUNCTION PostgreSQL CREATE FUNCTION By Practical Examples datetime - PHP Sort a multidimensional array by element containing date - Stack Overflow database - Oracle order NULL LAST by default - Stack Overflow PostgreSQL: Documentation: 9.5: Modifying Tables PostgreSQL: Documentation: 14: SELECT
PostgreSQL POSITION() function PostgresQL ANY / SOME Operator ( IN vs ANY ) PostgreSQL Substring - Extracting a substring from a String How to add an auto-incrementing primary key to an existing table, in PostgreSQL PostgreSQL STRING_TO_ARRAY()function mysql FIND_IN_SET equivalent to postgresql PL/pgSQL Variables ( Format Dates ) The Ultimate Guide to PostgreSQL Date By Examples Data Type Formatting Functions PostgreSQL - How to calculate difference between two timestamps? | TablePlus Date/Time Functions and Operators PostgreSQL - DATEDIFF - Datetime Difference in Seconds, Days, Months, Weeks etc - SQLines CASE Statements in PostgreSQL - DataCamp SQL Optimizations in PostgreSQL: IN vs EXISTS vs ANY/ALL vs JOIN PL/pgSQL Variables PostgreSQL: Documentation: 11: CREATE PROCEDURE Reading a Postgres EXPLAIN ANALYZE Query Plan Faster PostgreSQL Counting sql - Fast way to discover the row count of a table in PostgreSQL - Stack Overflow PostgreSQL: Documentation: 9.1: tablefunc PostgreSQL DESCRIBE TABLE Quick and best way to Compare Two Tables in SQL - DWgeek.com sql - Best way to select random rows PostgreSQL - Stack Overflow How to Add a Default Value to a Column in PostgreSQL - PopSQL How to Add a Default Value to a Column in PostgreSQL - PopSQL PL/pgSQL IF Statement PostgreSQL: Documentation: 9.1: Declarations SQL Subquery - Dofactory SQL IN - SQL NOT IN - JournalDev PostgreSQL - IF Statement - GeeksforGeeks How to work with control structures in PostgreSQL stored procedures: Using IF, CASE, and LOOP statements | EDB PL/pgSQL IF Statement How to combine multiple selects in one query - Databases - ( loop reference ) DROP FUNCTION (Transact-SQL) - SQL Server | Microsoft Docs SQL : Multiple Row and Column Subqueries - w3resource PostgreSQL: Documentation: 9.5: CREATE FUNCTION PostgreSQL CREATE FUNCTION By Practical Examples datetime - PHP Sort a multidimensional array by element containing date - Stack Overflow database - Oracle order NULL LAST by default - Stack Overflow PostgreSQL: Documentation: 9.5: Modifying Tables PostgreSQL: Documentation: 14: SELECT PostgreSQL Array: The ANY and Contains trick - Postgres OnLine Journal
כמה עוד נשאר למשלוח חינם גם לעגלה ולצקאאוט הוספת צ'קבוקס לאישור דיוור בצ'קאאוט הסתרת אפשרויות משלוח אחרות כאשר משלוח חינם זמין דילוג על מילוי כתובת במקרה שנבחרה אפשרות איסוף עצמי הוספת צ'קבוקס לאישור דיוור בצ'קאאוט שינוי האפשרויות בתפריט ה-סידור לפי בווקומרס שינוי הטקסט "אזל מהמלאי" הערה אישית לסוף עמוד העגלה הגבלת רכישה לכל המוצרים למקסימום 1 מכל מוצר קבלת שם המוצר לפי ה-ID בעזרת שורטקוד הוספת כפתור וואטסאפ לקנייה בלופ ארכיון מוצרים הפיכה של מיקוד בצ'קאאוט ללא חובה מעבר ישיר לצ'קאאוט בלחיתה על הוספה לסל (דילוג עגלה) התראה לקבלת משלוח חינם בדף עגלת הקניות גרסה 1 התראה לקבלת משלוח חינם בדף עגלת הקניות גרסה 2 קביעה של מחיר הזמנה מינימלי (מוצג בעגלה ובצ'קאאוט) העברת קוד הקופון ל-ORDER REVIEW העברת קוד הקופון ל-ORDER REVIEW Kadence WooCommerce Email Designer קביעת פונט אסיסנט לכל המייל בתוסף מוצרים שאזלו מהמלאי - יופיעו מסומנים באתר, אבל בתחתית הארכיון הוספת כפתור "קנה עכשיו" למוצרים הסתרת אפשרויות משלוח אחרות כאשר משלוח חינם זמין שיטה 2 שינוי סימן מטבע ש"ח ל-ILS להפוך סטטוס הזמנה מ"השהייה" ל"הושלם" באופן אוטומטי תצוגת הנחה באחוזים שינוי טקסט "בחר אפשרויות" במוצרים עם וריאציות חיפוש מוצר לפי מק"ט שינוי תמונת מוצר לפי וריאציה אחרי בחירה של וריאציה אחת במקרה של וריאציות מרובות הנחה קבועה לפי תפקיד בתעריף קבוע הנחה קבועה לפי תפקיד באחוזים הסרה של שדות משלוח לקבצים וירטואליים הסתרת טאבים מעמוד מוצר הצגת תגית "אזל מהמלאי" בלופ המוצרים להפוך שדות ל-לא חובה בצ'קאאוט שינוי טקסט "אזל מהמלאי" לוריאציות שינוי צבע ההודעות המובנות של ווקומרס הצגת ה-ID של קטגוריות המוצרים בעמוד הקטגוריות אזל מהמלאי- שינוי ההודעה, תגית בלופ, הודעה בדף המוצר והוספת אזל מהמלאי על וריאציה הוספת שדה מחיר ספק לדף העריכה שינוי טקסט אזל מהמלאי תמונות מוצר במאונך לצד תמונת המוצר הראשית באלמנטור הוספת כפתור קנה עכשיו לעמוד המוצר בקניה הזו חסכת XX ש''ח לאפשר למנהל חנות לנקות קאש ברוקט לאפשר רק מוצר אחד בעגלת קניות הוספת סימון אריזת מתנה ואזור להוראות בצ'קאאוט של ווקומרס הצגת הנחה במספר (גודל ההנחה)
החלפת טקסט באתר (מתאים גם לתרגום נקודתי) הסרת פונטים של גוגל מתבנית KAVA ביטול התראות במייל על עדכון וורדפרס אוטומטי הוספת תמיכה בקבצי VCF באתר (קבצי איש קשר VCARD) - חלק 1 להחריג קטגוריה מסוימת מתוצאות החיפוש שליפת תוכן של ריפיטר יצירת כפתור שיתוף למובייל זיהוי אלו אלמנטים גורמים לגלילה אופקית התקנת SMTP הגדרת טקסט חלופי לתמונות לפי שם הקובץ הוספת התאמת תוספים לגרסת WP הוספת טור ID למשתמשים הסרת כותרת בתבנית HELLO הסרת תגובות באופן גורף הרשאת SVG חילוץ החלק האחרון של כתובת העמוד הנוכחי חילוץ הסלאג של העמוד חילוץ כתובת העמוד הנוכחי מניעת יצירת תמונות מוקטנות התקנת SMTP הצגת ה-ID של קטגוריות בעמוד הקטגוריות להוריד מתפריט הניהול עמודים הוספת Favicon שונה לכל דף ודף הוספת אפשרות שכפול פוסטים ובכלל (של שמעון סביר) הסרת תגובות באופן גורף 2 בקניה הזו חסכת XX ש''ח חיפוש אלמנטים סוררים, גלישה צדית במובייל שיטה 1 לאפשר רק מוצר אחד בעגלת קניות הצגת הנחה במספר (גודל ההנחה)
הודעת שגיאה מותאמת אישית בטפסים להפוך כל סקשן/עמודה לקליקבילית (לחיצה) - שיטה 1 להפוך כל סקשן/עמודה לקליקבילית (לחיצה) - שיטה 2 שינוי הגבלת הזיכרון בשרת הוספת לינק להורדת מסמך מהאתר במייל הנשלח ללקוח להפוך כל סקשן/עמודה לקליקבילית (לחיצה) - שיטה 3 יצירת כפתור שיתוף למובייל פתיחת דף תודה בטאב חדש בזמן שליחת טופס אלמנטור - טופס בודד בדף פתיחת דף תודה בטאב חדש בזמן שליחת טופס אלמנטור - טפסים מרובים בדף ביי ביי לאריק ג'ונס (חסימת ספאם בטפסים) זיהוי אלו אלמנטים גורמים לגלילה אופקית לייבלים מרחפים בטפסי אלמנטור יצירת אנימציה של "חדשות רצות" בג'ט (marquee) שינוי פונט באופן דינאמי בג'ט פונקציה ששולפת שדות מטא מתוך JET ומאפשרת לשים הכל בתוך שדה SELECT בטופס אלמנטור הוספת קו בין רכיבי התפריט בדסקטופ ולדציה למספרי טלפון בטפסי אלמנטור חיבור שני שדות בטופס לשדה אחד שאיבת נתון מתוך כתובת ה-URL לתוך שדה בטופס וקידוד לעברית מדיה קוורי למובייל לייבלים מרחפים בטפסי אלמנטור תמונות מוצר במאונך לצד תמונת המוצר הראשית באלמנטור הצגת תאריך עברי פורמט תאריך מותאם אישית תיקון שדה תאריך בטופס אלמנטור במובייל שאיבת פרמטר מתוך הכתובת והזנתו לתוך שדה בטופס (PARAMETER, URL, INPUT)