Example on how to use C++ regex_token_iterator

 #pragma once   
 #pragma warning(disable:4996)   
 #define _SCL_SECURE_NO_WARNINGS   
 #include "stdafx.h"  
 #include <fstream>  
 #include <iostream>  
 #include <regex>  
 #include <iterator>  
 #include <algorithm>  
 using namespace std;  
 int main() {  
      string seq("tatagcagtcccgctgtgtgtacgacactggcaacatgaggtctttgctaatcttggtagctttg");  
      regex e("(tata)([gatc]*)(tag)");  
      int submatches[] = { 1, 2, 3 };  
      sregex_token_iterator rend;  
      sregex_token_iterator a(seq.begin(), seq.end(), e, submatches);  
      while (a != rend) std::cout << " [" << *a++ << "]";  
      getchar();  
      return 0;  
 }  

Are you being tracked by Facebook?

One way to find out whether the websites you are visiting has facebook tracker is to install Facebook pixel extension on your Google Chrome browser

https://chrome.google.com/webstore/detail/facebook-pixel-helper/fdgfkebogiimcoedlicjlajpkdmockpc?hl=en

You can also see it by examining your network traffic using the developer tool on your browser

String.Compare is a better method to compare strings than String.Equal

String.Compare is a better method to compare strings than String.Equal

Below example illustrates how String.Compare handles nulls better than String.Equal


    class Program
    {
        static void Main(string[] args)
        {
            string A = "Hello World";
            string B = "Hello World";
            string C = null;

            if (String.Compare(B, A) == 0) { Console.WriteLine("A equals B"); }
            if (String.Compare(C, A) == 0) { Console.WriteLine("A equals C"); }
            if (B.Equals(A)) { Console.WriteLine("A equals B"); }
            try
            {
                if (C.Equals(A)) { Console.WriteLine("A equals C"); }
            }
            catch (Exception e)
            {
                Console.Write(e.Message);
            }

            Console.ReadKey();
        }
    }

Anonymous function

 class Program  
   {  
     static void Main(string[] args)  
     {  
       Func<int, int> func1 = x => x + 1;  
       Func<int, int> func2 = x => { return x + 1; };  
       Func<int, int> func3 = (int x) => x + 1;  
       Func<int, int> func4 = (int x) => { return x + 1; };  
       Func<int, int, int> func5 = (x, y) => x * y;  
       Action func6 = () => Console.WriteLine();  
       Func<int, int> func7 = delegate (int x) { return x + 1; };  
       Func<int> func8 = delegate { return 1 + 1; };  
       Console.WriteLine(func1.Invoke(1));  
       Console.WriteLine(func2.Invoke(1));  
       Console.WriteLine(func3.Invoke(1));  
       Console.WriteLine(func4.Invoke(1));  
       Console.WriteLine(func5.Invoke(2, 2));  
       func6.Invoke();  
       Console.WriteLine(func7.Invoke(1));  
       Console.WriteLine(func8.Invoke());  
       Console.ReadLine();  
     }  

Basic Dependency Injection control

I found a simple Inversion Controller on https://timross.wordpress.com/2010/01/21/creating-a-simple-ioc-container

   

public interface IContainer  
   {  
     void Register<TTypeToResolve, TConcrete>();  
     void Register<TTypeToResolve, TConcrete>(LifeCycle lifeCycle);  
     TTypeToResolve Resolve<TTypeToResolve>();  
     object Resolve(Type typeToResolve);  
   }  
   public enum LifeCycle   
   {   
    Singleton,   
    Transient   
   }   
   public class RegisteredObject  
   {  
     public RegisteredObject(Type typeToResolve, Type concreteType, LifeCycle lifeCycle)  
     {  
       TypeToResolve = typeToResolve;  
       ConcreteType = concreteType;  
       LifeCycle = lifeCycle;  
     }  
     public Type TypeToResolve { get; private set; }  
     public Type ConcreteType { get; private set; }  
     public object Instance { get; private set; }  
     public LifeCycle LifeCycle { get; private set; }  
     public void CreateInstance(params object[] args)  
     {  
       this.Instance = Activator.CreateInstance(this.ConcreteType, args);  
     }  
   }  
   public class SimpleIocContainer : IContainer  
   {  
     private readonly IList<RegisteredObject> registeredObjects = new List<RegisteredObject>();  
     public void Register<TTypeToResolve, TConcrete>()  
     {  
       Register<TTypeToResolve, TConcrete>(LifeCycle.Singleton);  
     }  
     public void Register<TTypeToResolve, TConcrete>(LifeCycle lifeCycle)  
     {  
       registeredObjects.Add(new RegisteredObject(typeof (TTypeToResolve), typeof (TConcrete), lifeCycle));  
     }  
     public TTypeToResolve Resolve<TTypeToResolve>()  
     {  
       return (TTypeToResolve) ResolveObject(typeof (TTypeToResolve));  
     }  
     public object Resolve(Type typeToResolve)  
     {  
       return ResolveObject(typeToResolve);  
     }  
     private object ResolveObject(Type typeToResolve)  
     {  
       var registeredObject = registeredObjects.FirstOrDefault(o => o.TypeToResolve == typeToResolve);  
       if (registeredObject == null)  
       {  
         throw new TypeNotRegisteredException(string.Format(  
           "The type {0} has not been registered", typeToResolve.Name));  
       }  
       return GetInstance(registeredObject);  
     }  
     private object GetInstance(RegisteredObject registeredObject)  
     {  
       if (registeredObject.Instance == null ||   
         registeredObject.LifeCycle == LifeCycle.Transient)  
       {  
         var parameters = ResolveConstructorParameters(registeredObject);  
         registeredObject.CreateInstance(parameters.ToArray());  
       }  
       return registeredObject.Instance;  
     }  
     private IEnumerable<object> ResolveConstructorParameters(RegisteredObject registeredObject)  
     {  
       var constructorInfo = registeredObject.ConcreteType.GetConstructors().First();  
       foreach (var parameter in constructorInfo.GetParameters())  
       {  
         yield return ResolveObject(parameter.ParameterType);  
       }  
     }  
   }  
   public class TypeNotRegisteredException : Exception  
   {  
     public TypeNotRegisteredException(string message)  
       : base(message)  
     {  
     }  
   }  

Extending HtmlHelper

Helpers.cs

 using System.Web;  
 using System.Web.Mvc;  
 using System.Web.Routing;  
 namespace mvc.Helpers  
 {  
   public static class ImageHelpers  
   {  
     public static IHtmlString Image(this HtmlHelper helper, string id, string url, string alternateText)  
     {  
       return Image(helper, id, url, alternateText, null);  
     }  
     public static IHtmlString Image(this HtmlHelper helper, string id, string url, string alternateText, object htmlAttributes)  
     {  
       var builder = new TagBuilder("img");  
       builder.GenerateId(id);  
       builder.MergeAttribute("src", url);  
       builder.MergeAttribute("alt", alternateText);  
       builder.MergeAttributes(new RouteValueDictionary(htmlAttributes));  
       return new MvcHtmlString(builder.ToString(TagRenderMode.SelfClosing));  
     }  
   }  
 }  

index.cshtml

 @{  
   ViewBag.Title = "Home Page";  
 }  
 @using mvc.Helpers;  
 @Html.Image("img1", "~/Content/XBox.jpg", "XBox Console")  

Array mapping using LINQ

 namespace ConsoleApplication1  
 {  
   public class Student  
   {  
     public string FirstName;  
     public string LastName;  
   }  
   public class StudentFullName  
   {  
     public string FullName;  
     public StudentFullName(Student student)  
     {  
       FullName = student.FirstName + " " + student.LastName;  
     }  
     public override string ToString()  
     {  
       return FullName;  
     }  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       Student s1 = new Student { FirstName = "Jack", LastName = "Frost" };  
       Student s2 = new Student { FirstName = "Mary", LastName = "Wong" };  
       Student s3 = new Student { FirstName = "Ronald", LastName = "McDonalds" };  
       Student s4 = new Student { FirstName = "John", LastName = "Smith" };  
       List<Student> studentArray = new List<Student>() { s1, s2, s3, s4 };  
       List<StudentFullName> fullNameArray = studentArray.Select(a => new StudentFullName(a)).ToList();  
       string nameList = fullNameArray.OrderBy(m => m.FullName).Select(m => m.FullName).Aggregate((current, next) => current + ", " + next);  
       Console.WriteLine(nameList);  
       Console.ReadLine();  
     }  
   }  
 }  

Concatenation using LINQ

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.Linq.Expressions;  
 namespace ConsoleApplication1  
 {  
   public class Student  
   {  
     public string FirstName;  
     public string LastName;  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       Student s1 = new Student { FirstName = "Jack", LastName = "Frost" };  
       Student s2 = new Student { FirstName = "Mary", LastName = "Wong" };  
       Student s3 = new Student { FirstName = "Ronald", LastName = "McDonalds" };  
       Student s4 = new Student { FirstName = "John", LastName = "Smith" };  
       List<Student> studentArray = new List<Student>() { s1, s2, s3, s4 };  
       string nameList = studentArray.OrderBy(m => m.LastName).Select(m => m.LastName).Aggregate((current, next) => current + ", " + next);  
       Console.WriteLine(nameList);  
       Console.ReadLine();  
     }  
   }  
 }  

Class extension example

 namespace ConsoleApplication1  
 {  
   public static class MyExtensions  
   {  
     public static int WordCount(this String str)  
     {  
       return str.Split(new char[] { ' ', '.', '?' },  
         StringSplitOptions.RemoveEmptyEntries).Length;  
     }  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       string s = "1.2.3";  
       Console.WriteLine( s.WordCount().ToString());  
       Console.ReadKey();  
     }  
   }  
 }  

Fancy LINQ operation

   class Myclass  
   {  
     public string name { get; set; }  
     public decimal age { get; set; }  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       List<string> l = new List<string>();  
       l.Add("di"); l.Add("marks");  
       var list = new List<Myclass> { new Myclass { name = "di",age = 0 }, new Myclass { name = "marks", age = 0 }, new Myclass { name = "grade", age = 0 } };  
       list.Where(w => l.Contains(w.name)).ToList().ForEach(i => i.age = 10);  
       list.ForEach(i => Console.WriteLine(i.name + ":" + i.age));  
       Console.ReadKey();  
     }  
   }  

Eager loading vs Explicit loading in Entity Framework (using Northwind database)

Microsoft has an excellent article on this https://msdn.microsoft.com/en-us/library/jj574232(v=vs.113).aspx

     public string GetCategoryEagerLoading()  
     {  
       StringBuilder sb = new StringBuilder();  
       NORTHWNDEntities ctx = new NORTHWNDEntities();  
       ctx.Configuration.LazyLoadingEnabled = false;   
       var ca = ctx.Categories.Include(p => p.Products).First(c => c.CategoryID == 1);  
       foreach (Product p in ca.Products)  
       {  
         sb.Append(p.ProductName + ",");  
       }  
       return sb.ToString();  
     }  
     public string GetCategoryExplicitLoading()  
     {  
       StringBuilder sb = new StringBuilder();  
       NORTHWNDEntities ctx = new NORTHWNDEntities();  
       ctx.Configuration.LazyLoadingEnabled = false;  
       var ca = ctx.Categories.First(c => c.CategoryID == 1);  
       ctx.Entry(ca).Collection(c => c.Products).Load();  
       foreach (Product p in ca.Products)  
       {  
         sb.Append(p.ProductName + ",");  
       }  
       return sb.ToString();  
     }  

Executing stored procedure / SQL through entity framework (based on the Northwind database)

     

   static void Main(string[] args)  
   {  
       Class1 c = new Class1();  
       string s= c.GetShipper();  
       Console.Write(s);  
       Console.ReadLine();  
   }      
   class Class1  
   {  
     public string GetShipper()  
     {  
       StringBuilder sb = new StringBuilder();  
       using (var ctx = new NORTHWNDEntities())  
       {  
         var idParam = new SqlParameter  
         {  
           ParameterName = "ShipperID",  
           Value = 1  
         };  
         var ShipperList = ctx.Database.SqlQuery<Shipper>("exec GetShippers @ShipperID ", idParam).ToList<Shipper>();  
         foreach (Shipper s in ShipperList)  
         {  
           sb.Append(s.CompanyName + ",");  
         }  
         return sb.ToString();  
       }  
     }  
   }  
   public partial class Shipper  
   {  
     public Shipper()  
     {  
       this.Orders = new HashSet<Order>();  
     }  
     public int ShipperID { get; set; }  
     public string CompanyName { get; set; }  
     public string Phone { get; set; }  
     public virtual ICollection<Order> Orders { get; set; }  
   }  
 public partial class NORTHWNDEntities : DbContext  
 {  
   public NORTHWNDEntities()  
     : base("name=NORTHWNDEntities")  
   {  
   }  
   protected override void OnModelCreating(DbModelBuilder modelBuilder)  
   {  
     throw new UnintentionalCodeFirstException();  
   }  
   public virtual DbSet<Category> Categories { get; set; }  
   public virtual DbSet<CustomerDemographic> CustomerDemographics { get; set; }  
   public virtual DbSet<Customer> Customers { get; set; }  
   public virtual DbSet<Employee> Employees { get; set; }  
   public virtual DbSet<Order_Detail> Order_Details { get; set; }  
   public virtual DbSet<Order> Orders { get; set; }  
   public virtual DbSet<Product> Products { get; set; }  
   public virtual DbSet<Region> Regions { get; set; }  
   public virtual DbSet<Shipper> Shippers { get; set; }  
   public virtual DbSet<Supplier> Suppliers { get; set; }  
   public virtual DbSet<sysdiagram> sysdiagrams { get; set; }  
   public virtual DbSet<Territory> Territories { get; set; }  
 }  

SOAP VS REST

I got blind sighted recently when I was asked to explain SOAP vs REST.  Even though I have been programming them for ages, nothing was coming out of my mouth.  So here I am reproducing what I think is a really good answer.

REST(REpresentational State Transfer)
REST is an architectural style. It doesn’t define so many standards like SOAP. REST is for are exposing a public API over the internet to handle CRUD operations on data. REST is focused on accessing named resources through a single consistent interface.
SOAP(Simple Object Access Protocol)
SOAP brings it’s own protocol and focuses on exposing pieces of application logic (not data) as services. SOAP exposes operations. SOAP is focused on accessing named operations, each implement some business logic through different interfaces. Though SOAP is commonly referred to as web services this is a misnomer. SOAP has very little if anything to do with the Web. REST provides true Web services based on URIs and HTTP.
Why Rest?

• Since REST uses standard HTTP it is much simpler in just about ever way.
• REST permits many different data formats where as SOAP only permits XML.
• REST allows better support for browser clients due to it’s support for JSON.
• REST has better performance and scalability. REST reads can be cached, SOAP based reads cannot be cached.
• If security is not a major concern and we have limited resources. Or we want to create an API that will be easily used by other developers publicly then we should go with REST web services.

Why SOAP?

• WS-Security: While SOAP supports SSL (just like REST) it also supports WS-Security which adds some enterprise security features.
• WS-AtomicTransaction: Need ACID Transactions over a service, you’re going to need SOAP.
• WS-ReliableMessaging: Rest doesn’t have a standard messaging system and expects clients to deal with communication failures by retrying.
• SOAP is highly secure as it defines its own security.
• If the security is a major concern and the resources are not limited then we should use SOAP web services. Like if we are creating a web service for banking related work then we should go with SOAP as here high security is needed.

This is how you do Agile software development :)

Access html elements in the same table row using jQuery

   <table>  
     <tr>  
       <td>Mary</td>  
       <td><div id="parentTimer"></div></td>  
       <td id="td">  
         <button id="btnStart" type="button" onclick="handleStart(event, this);">Start</button>  
         <input id="inputValue" value="Test" />  
       </td>  
     </tr>  
   </table>  

   <script>  
     function handleStart(event, sender)  
     {  
       var $row = $(sender).parents('tr');  
       var desc = $row.find('#inputValue').val();  
       var div = $row.find('#parentTimer');  
       div.html('started');  
       alert(desc);  
     }  
   </script>  

Seamless HTML page transition

With more and more complex HTML + CSS3 + jQuery page design these days, it is very easy to have clunky webpages which take a while to load, with components like jQuery tab controls display partially before they are formatted. A way to get around that is to display web pages after they are fully rendered.

 CSS:  
 <style>  
   html { visibility:hidden; } /*html is initially hidden*/  
   /*fade in effect*/  
   body {  
     opacity: 1;   
     transition: 1s opacity;  
   }  
   body.fade-out {  
     opacity: 0;  
     transition: none;  
   }  
 </style>  
 JavaScript  
 <script>  
 $(document).ready(function() {  
  /*show html after page load*/  
  document.getElementsByTagName("html")[0].style.visibility = "visible";  
 });  
 </script>