DataSet.Copy() and DataSet.Clone()

DataSet.Copy() : Copies both the structure (tables, relations etc) and the data.

DataSet.Clone() : Copies Only the structure of the DataSet, including all DataTable schemas, relations, and constraints. Does not copy any data.

e.g.

DataTable table1 = new DataTable(“Employee”);

table1.Columns.Add(“Name”);

table1.Columns.Add(“EmpId”);

table1.Rows.Add(“XYZ”, 1);

DataTable table2 = new DataTable(“Projects”);

table2.Columns.Add(“EmpId”);

table2.Columns.Add(“ProjectAllocated”);

table2.Rows.Add(1, “ProjectOne”);

// Create a DataSet.

DataSet set = new DataSet(“Office”);

set.Tables.Add(table1);

set.Tables.Add(table2);

  // Copy the DataSet.

DataSet copyDataSet = set.Copy();

// Get a clone of the original DataSet.

DataSet cloneSet = dataSet.Clone();

String Vs StringBuilder …… point by point

1) Namespace :

String class belongs to the System namespace i.e. System.String

StringBuilder class belongs to the System.Text i.e. System.String.StringBuilder

2) Store Location :

String , StringBuilder both being reference types , Stored on Heap memory

3) Mutable/Immutable :

The System.String class is immutable, i.e once created its state cannot be altered. i.e. All .NET stings are immutable. You cannot modify any string at all. All string operations create yet another string.in simple words any change to string causes a runtime to create a new string and abandon old one

Consider the following example:

class MyClass

{

public static void Main() {

string sampleString = “CollectedDotNet”;

sampleString = “Hello World”;

Console.WriteLine(sampleString);

}

}

Output will be: Hello World

In this sample, we have created a string called sampleString. We initially assigned the value “CollectedDotNet”. And then we overwrite its value with “Hello World” , which we got as output. But in the memory 2 string are got created when we createed the string “CollectedDotNet”, this string gets created in the memory, but when we tried to change the value to new values , at that time new string “Hello World” got created in memory and reference got assigned to sampleString.

Lets see another example ,

string s1 = “CollectedDotNet”;

string s2 = s1;

s1 = “Hello World”;

Now what happens is a new string object is created for s1 to point to.Hence, s1 equals “Hello World” , whereas s2 still equals “CollectedDotNet”

Advantages of Immutability:

  • Thread Safety ,

Sharing ,

  • Less error prone

 For StringBuilder,

On contrast with String , StringBuilder class is mutable.

StringBuilder sampleStringBuilder = new StringBuilder(“CollectedDotNet”);

Console.WriteLine(sampleStringBuilder);

sampleStringBuilder = new StringBuilder(“Hello World”);

Console.WriteLine(sampleStringBuilder);

Output will be :

CollectedDotNet

Hello World

In this sample , we have created a string called sampleStringBuilder. We initialized with value “CollectedDotNet”.And then we created new with “Hello World” , in this case no new strings will be created in the memory.

Further Reading Reference :

http://www.codeproject.com/Articles/406046/Why-strings-are-immutable-and-what-are-the-implica

http://forums.asp.net/t/1158680.aspx/1

4) Assigning/Appending String:

You can directly assign a string to string class instance.

e.g.  string sampleString = “CollectedDotNet”;

is Valid for String but not for StringBuilder.

For StringBuilder,

You cannot directly assign a string to StringBuilder instance.

e.g.  StringBuilder sampleStringBuilder = “CollectedDotNet”;

The above line will return the following error on compilation :
“Cannot implicitly convert type ‘string’ to ‘System.Text.StringBuilder'”cannot implicitly convert type

You can assign a string to StringBuilder using the following way

StringBuilder sampleStringBuilder = new StringBuilder(“CollectedDotNet “);

5) Concatenation /Capacity :

String concatenation is done using + operator.

E.g. string sampleString = “Hello”;

sampleString += ” World!!”;

Console.WriteLine(sampleString);

Output : Hello World!!

The same can be achieved using sampleString = sampleString + “ World!!”;

During string concatenation,additional memory will be allocated.You cannot set a limit (specifying how many strings can be concatenated) to a string object using string class In Case for StringBuilder Concatenation is done using Append() Method.

StringBuilder sampleStringBuilder = new StringBuilder(“Hello”);

sampleStringBuilder.Append(” World!!”);

Console.WriteLine(sampleStringBuilder);

Output : Hello World!!

For StringBuilder ,

During string concatenation, additional memory will be allocated if and only if the string buffer’s capacity is reached. You can set a limit to StringBuilder using the property called capacity which will by default have the value 16. You can override it to any number. The maximum value acceptable is equivalent to MaxValue of Int32.  If you feel that you do not want to reserve 16 as the capacity then you can very well redefine it. However the capacity will dynamically grow based on the number of strings that you append.

The StringBuilder dynamically allocates more space when required and increases Capacity accordingly. For performance reasons, a StringBuildermight allocate more memory than needed. The amount of memory allocated is implementation-specific.

Reading References

.net String vs. StringBuilder – concatenation performance

So, when should you use StringBuilder, and when should you use the string concatenation operators?

Refer the following link .. explained nicely

http://yoda.arachsys.com/csharp/stringbuilder.html

%d bloggers like this: