Category Archives: Dot Net

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

    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.