Category Archives: Development

Today is Wednesday November 22, 2017
  • users

    Use StringBuilder for Complex String Manipulation

    When a string is modified, the run time will create a new string and return it, leaving the original to be garbage collected. Most of the time this is a fast and simple way to do it, but when a string is being modified repeatedly it begins to be a burden on performance: all of those allocations eventually get expensive. Here’s a simple example of a program that appends to a string 50,000 times, followed by one that uses a StringBuilder object to modify the string in place. The StringBuilder code is much faster, and if you run them it becomes immediately obvious.

    namespace ConsoleApplication1.Feedback{
      using System;
      
      public class Feedback{
        public Feedback(){
          text = "You have ordered: \n";
        }
    
        public string text;
    
        public static int Main(string[] args) {
          Feedback test = new Feedback();
          String str = test.text;
          for(int i=0;i<50000;i++){
            str = str + "My Text";
          }
          System.Console.Out.WriteLine("done");
          return 0;
        }
      }
    }
    namespace ConsoleApplication1.Feedback{
      using System;
    
      public class Feedback{
        public Feedback(){
          text = "You have ordered: \n";
        }
    
        public string text;
    
        public static int Main(string[] args) {
          Feedback test = new Feedback();
          System.Text.StringBuilder SB = 
            new System.Text.StringBuilder(test.text);
          for(int i=0;i<50000;i++){
            SB.Append("My Text");
          }
          System.Console.Out.WriteLine("done");
          return 0;
        }
      }
    }

    Try looking at Perfmon to see how much time is saved without allocating thousands of strings. Look at the “% time in GC” counter under the .NET CLR Memory list. You can also track the number of allocations you save, as well as collection statistics.

    Tradeoffs   There is some overhead associated with creating a StringBuilder object, both in time and memory. On a machine with fast memory, a StringBuilderbecomes worthwhile if you’re doing about five operations. As a rule of thumb, I would say 10 or more string operations is a justification for the overhead on any machine, even a slower one.

  • users

    JavaScript variable scope

    Most of you who are in development will be aware of JavaScript variable scoping. All the JavaScript  code which are loaded from various files are usually executed

    at a common global space, which is window in case of browser.

    You can restrict the scope of a variable using function, as how in the code below.

    var x = 1

    var TZT = function (a) {

        var y = 2;

    }

    Where the variable x as an window level scope and variable y is available within the function TZT only

    An interesting bug or peculiarity in JavaScript is a variable becomes part of global scope when it is declared without the var keyword as shown below.

    var x = 1

    var TZT = function (a) {

         y = 2;

    }

    In the above code y is accessible globally. This will cause lot of unexpected result since they can override a global variable already in existence.

    To give a measure of importance of it, I wrote a small code which collects all the global variables and based on which we have around 812 global variables at the point when the user logs in (inclusive of inbuilt variable and  third party scripts),which might increase when someone declares window level  variables.

    Since we have a single page application model for talent Oz this becomes even more important since all the variables reside in the scope at all point of time. So it’s better if we have one common global namespace for talentoz related code and be careful when you are declaring a variable.

    If you want to check a  variable already exists in global namespace then call the following function in browser address bar , before creating it.

     Javascript:TZT(‘variablename’);

  • users

    Deep Copy VS Shallow Copy in .net

    We experienced a odd behavior when we tried to copy a dictionary and perform changes to the value in a loop as show below. It showed Enumeration value can’t be modified.
     
      Dim Parent As New Dictionary(Of StringString)
     
       Parent.Add(“k1″“v1″)
       Parent.Add(“k2″“v2″)
     
      Dim copy As Dictionary(Of StringString)
     
      copy = Parent
     
      For Each kvp As KeyValuePair(Of String, String) In copy
       Parent(kvp.key) = “Test”
      Next 
     
    It’s because what that copy operation does is only copies the address of the    dictionaries memory stack and they both actually refer the same object.
     
    This is actually called as “Shallow Copy”, on further reading it came to light that there are two ways to copy objects in .net
     
    ·         Deep copy
    ·         Shallow copy
     
    You can google about it to know more about it  and how they differ
     
    So to actually perform a deep copy of the dictionary .net has provided the following way.
     
    Dim copy As New Dictionary(Of StringString)(Parent)
     
    In which the original dictionary is passed as an parameter to the constructor of new dictionary.
     
    Also please go through Icloneable Interface to know more about it.