Retrieve last occurance of string

reverse(left(reverse(column_name), charindex('delimiter', reverse(column_name)) -1))

onbeforeunload remove session data

$(window).bind('beforeunload', function(){ 
     var path = $(location).attr('pathname') + "/RemoveSessionData"; 
     $.ajax({ type: "POST", url: path, async: false });
}); 

[System.Web.Services.WebMethod(EnableSession = true),  System.Web.Script.Services.ScriptMethod(UseHttpGet=false)]
public static void RemoveSessionData()
{
       HttpContext.Current.Session.Remove(SessionMember1);
       HttpContext.Current.Session.Remove(SessionMember2);
}

Xml Shredder

SELECT
[Parent] = T.C.value('local-name(../../..)', 'varchar(50)')
, [ParentID] = T.C.value('../../../@ID', 'uniqueidentifier')
, [Node] = T.C.value('local-name(..)', 'varchar(50)')
, [ID] = T.C.value('../@ID', 'uniqueidentifier')
, [ChildNode] = T.C.value('local-name(.)', 'VARCHAR(50)')
, [Value] = T.C.value('.', 'nvarchar(max)')
FROM @xml.nodes('//Transfer/*/*/*') T(C);

Terremotos Iquique

Terremotos Iquique durante Marzo y Abril

 

http://earthquake.usgs.gov/earthquakes/map/#%7B%22feed%22%3A%2230day_m25%22%2C%22search%22%3Anull%2C%22sort%22%3A%22newest%22%2C%22basemap%22%3A%22terrain%22%2C%22autoUpdate%22%3Atrue%2C%22restrictListToMap%22%3Atrue%2C%22timeZone%22%3A%22local%22%2C%22mapposition%22%3A%5B%5B-21.081937360616074%2C-72.16094970703125%5D%2C%5B-18.88030044453507%2C-68.64532470703125%5D%5D%2C%22overlays%22%3A%7B%22plates%22%3Atrue%7D%2C%22viewModes%22%3A%7B%22map%22%3Atrue%2C%22list%22%3Atrue%2C%22settings%22%3Atrue%2C%22help%22%3Afalse%7D%7D

The FOR XML clause is not allowed in a INSERT statement

DECLARE @sql nvarchar(max);
DECLARE @TRANSFER_TYPE_CD nvarchar(50) = 'SF1151';
DECLARE @Transfers XML, @results XML;

DECLARE @tmpTable TABLE (data XML);
DECLARE @nodes TABLE (match XML);

INSERT @tmpTable SELECT ('');
SELECT * FROM @tmpTable;

-- wrap select with select()
select @sql = N'
DECLARE @TRANSFER_TYPE_CD nvarchar(50)=''' + @TRANSFER_TYPE_CD + ''';
SELECT(SELECT
[TRANSFER_XML].query(''//Transfer[@Type=sql:variable("@TRANSFER_TYPE_CD")]'')
FROM [dbo].[IMART_TRANSFER]
FOR XML PATH(''''))';

INSERT into @nodes exec(@sql);
SELECT * from @nodes;

SELECT @results = (SELECT * from @nodes);

UPDATE @tmpTable
SET data.modify('insert sql:variable("@results") into (/root/Transfers)[1]');
SELECT * FROM @tmpTable;

XQuery modify attribute

declare
@transferID uniqueidentifier
,@transferIDchar nvarchar(37)
,@xmlString nvarchar(max)
,@hdoc int
,@xmlDoc xml
,@idx int;
declare @tmpTable table (id uniqueidentifier, data xml);

select @xmlString = N'';

select @transferID = NEWID();
select @transferIDchar = CONVERT(nvarchar(37), @transferID);

insert @tmpTable (id, data)
values (@transferID, @xmlString);

update @tmpTable
set data.modify('replace value of (/Transfer/@ID)[1] with sql:variable("@transferID")');

select 
*
from @tmpTable; 

Asp.Net client side Page_Validators reset

function btnReset_onClick(group) {

    Page_IsValid = false;  // Required by ValidationSummaryOnSubmit

    if (typeof (Page_Validators) != "undefined") {

        for (var i = 0; i < Page_Validators.length; i++) {

            var validator = Page_Validators[i];

            validator.isvalid = false;

            ValidatorUpdateDisplay(validator);

        }

    }

    ValidationSummaryOnSubmit('FileValidationGroup');

}

Generic Xml De/Serialization

/// Helper class for serializing / deserializing

///

/// var helper=new XmlSerializerHelper();

/// object

public class XmlSerializerHelper : IDisposable

{

       public Type _type;

              public XmlSerializerHelper()

       {

              _type = typeof(T);

       }

       /// Returns serialized xml string

       ///

       ///

       /// xml string

       public string GetXml(object objectToSerialize)

       {

              if (objectToSerialize == null)

              {

                     return string.Empty;

              }

              else

              {

                     var stringWriter = new StringWriter();

                     XmlWriterSettings settings = new XmlWriterSettings();

                     settings.OmitXmlDeclaration = true;

                     settings.Indent = false;

                     using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))

                     {

                           XmlSerializerNamespaces ns = new XmlSerializerNamespaces();

                           ns.Add(string.Empty, string.Empty);

                           XmlSerializer xmlSerializer = new XmlSerializer(objectToSerialize.GetType());

                           xmlSerializer.Serialize(writer, objectToSerialize, ns);

                           return stringWriter.ToString();

                     }

              }

       }

       ///

       /// Returns deserialized object instance from xml

       ///

       /// xml string from data record

       /// object T

       public T GetObject(string xmlString)

       {

              T result;

              var reader = new StringReader(xmlString);

              XmlSerializer serializer = new XmlSerializer(_type);

              result = (T)serializer.Deserialize(reader);

              return result;

       }

}

///

/// Converter for enumerable objects to System.Data.DataTable

///

/// var shredder = new ObjectShredder();

/// DataTable dt = shredder.Shred((IEnumerable) source, null, null);

/// Object to be converted

public class ObjectShredder : IDisposable

{

       private System.Reflection.FieldInfo[] _fi;

       private System.Reflection.PropertyInfo[] _pi;

       private System.Collections.Generic.Dictionary<string, int> _ordinalMap;

       private System.Type _type;

              // ObjectShredder constructor.

       public ObjectShredder()

       {

              _type = typeof(T);

              _fi = _type.GetFields();

              _pi = _type.GetProperties();

              _ordinalMap = new Dictionary<string, int>();

       }

              ~ObjectShredder()

       {

              Dispose(false);

}

/// Loads a DataTable from a sequence of objects.

/// The sequence of objects to load into the DataTable.

/// The input table. The schema of the table must match that

/// the type T.  If the table is null, a new table is created with a schema 

/// created from the public properties and fields of the type T.

/// Specifies how values from the source sequence will be applied to

/// existing rows in the table.

/// A DataTable created from the source sequence.

public DataTable Shred(IEnumerable source, DataTable table, LoadOption? options)

{

       // Load the table from the scalar sequence if T is a primitive type.

       if (typeof(T).IsPrimitive)

       {

              return ShredPrimitive(source, table, options);

       }

       // Create a new table if the input table is null.

       if (table == null)

       {

              table = new DataTable(typeof(T).Name);

       }

       // Initialize the ordinal map and extend the table schema based on type T.

       table = ExtendTable(table, typeof(T));

       // Enumerate the source sequence and load the object values into rows.

       table.BeginLoadData();

       using (IEnumerator e = source.GetEnumerator())

       {

              while (e.MoveNext())

              {

                     if (options != null)

                     {

                                  table.LoadDataRow(ShredObject(table, e.Current), (LoadOption)options);

                           }

                           else

                           {

                                  table.LoadDataRow(ShredObject(table, e.Current), true);

                           }

                     }

              }

              table.EndLoadData();

              // Return the table.

              return table;

       }

       private DataTable ShredPrimitive(IEnumerable source, DataTable table, LoadOption? options)

       {

              // Create a new table if the input table is null.

              if (table == null)

              {

                     table = new DataTable(typeof(T).Name);

              }

              if (!table.Columns.Contains("Value"))

              {

                     table.Columns.Add("Value", typeof(T));

              }

              // Enumerate the source sequence and load the scalar values into rows.

              table.BeginLoadData();

              using (IEnumerator e = source.GetEnumerator())

              {

                     Object[] values = new object[table.Columns.Count];

                     while (e.MoveNext())

                     {

                           values[table.Columns["Value"].Ordinal] = e.Current;

                           if (options != null)

                           {

                                  table.LoadDataRow(values, (LoadOption)options);

                           }

                           else

                           {

                                  table.LoadDataRow(values, true);

                           }

                     }

              }

              table.EndLoadData();

              // Return the table.

              return table;

       }

       public object[] ShredObject(DataTable table, T instance)

       {

              System.Reflection.FieldInfo[] fi = _fi;

              System.Reflection.PropertyInfo[] pi = _pi;

              if (instance.GetType() != typeof(T))

              {

                     // If the instance is derived from T, extend the table schema

                     // and get the properties and fields.

                     ExtendTable(table, instance.GetType());

                     fi = instance.GetType().GetFields();

                     pi = instance.GetType().GetProperties();

              }

              // Add the property and field values of the instance to an array.

              Object[] values = new object[table.Columns.Count];

              foreach (System.Reflection.FieldInfo f in fi)

              {

                     values[_ordinalMap[f.Name]] = f.GetValue(instance);

              }

              foreach (System.Reflection.PropertyInfo p in pi)

              {

                     if (!p.PropertyType.IsGenericType)

                     {

                           values[_ordinalMap[p.Name]] = p.GetValue(instance, null);

                     }

              }

              // Return the property and field values of the instance.

              return values;

       }

       private DataTable ExtendTable(DataTable table, Type type)

       {

              // Extend the table schema if the input table was null or if the value 

              // in the sequence is derived from type T.                   

              foreach (System.Reflection.FieldInfo f in type.GetFields())

              {

                     if (!_ordinalMap.ContainsKey(f.Name))

                     {

                           // Add the field as a column in the table if it doesn't exist

                           // already.

                           DataColumn dc = table.Columns.Contains(f.Name) ? table.Columns[f.Name]

                                  : table.Columns.Add(f.Name, f.FieldType);

                           // Add the field to the ordinal map.

                           _ordinalMap.Add(f.Name, dc.Ordinal);

                     }

              }

              foreach (System.Reflection.PropertyInfo p in type.GetProperties())

              {

                     if (!p.PropertyType.IsGenericType && !_ordinalMap.ContainsKey(p.Name))

                     {

                           // Add the property as a column in the table if it doesn't exist

                           // already.

                           DataColumn dc = table.Columns.Contains(p.Name) ? table.Columns[p.Name]

                                  : table.Columns.Add(p.Name, p.PropertyType);

                           // Add the property to the ordinal map.

                           _ordinalMap.Add(p.Name, dc.Ordinal);

                     }

              }

              // Return the table.

              return table;

       }

       public void Dispose()

       {

              Dispose(true);

              GC.SuppressFinalize(this);

       }

       protected virtual void Dispose(bool disposing)

       {

              if (disposing)

              {

                     _type = null;

                     _fi = null;

                     _pi = null;

                     _ordinalMap.Clear();

                     _ordinalMap = null;

              }

       }

}

jQuery noConflicts

This saved my bacon one day:
jQuery.noConflict( true );

I was able to resolve different version of jQuery in the same project.
Having that fix then I was able to do a jQuery dialog:

jQuery("#dialog").dialog({
            modal: true,
            draggable: false,
            resizable: false,
            position: ['center', 150], //center, top
            width: 500,
            dialogClass: 'ui-dialog',
            closeOnEscape: false, //diable escape key
            buttons:
                [{ text: "GO", click: function () {
                    // do something
                    }
                    else {
                        return false;
                    }
                }
                }],
            open: function (event, ui) {
                // do somthing
            },
            close: function (event, ui) {
                    __doPostBack("", "");
            }

        });