This is default featured post 1 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 2 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 3 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 4 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 5 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

Showing posts with label ASP.Net Core. Show all posts
Showing posts with label ASP.Net Core. Show all posts

Truncate Vs Delete in SQL Server


Introduction

In this article let us try and understand the difference between "Delete" and "Truncate" statement in Microsoft SQL Server.Truncate table is functionally identical to delete statement with no "where clause". But there is lot of difference in functional wise.


Differences ...

• We cannot use where clause in Truncate command to Delete conditioned Rows. where useing Delete we can delete only some rows of table. So we can say Truncate deletes whole data of the table where Delete can delete whole or Some of the data only.

• Delete table is a logged operation, so the deletion of each row gets logged in the transaction log, which makes it slow.

• Truncate table also deletes all the rows in a table, but it won't log the deletion of each row, instead it logs the de-allocation of the data pages of the table, which makes it faster.

• Truncate table cannot be rolled back.


• Truncate table removes all rows from a table, but the table structure and its columns, constraints, indexes etc., remains as it is.

• In truncate table the counter used by an identity column for new rows is reset to the seed for the column.

• If you want to retain the identity counter, use delete statement instead.

• If you want to remove table definition and its data, use the drop table statement.

• You cannot use truncate table on a table referenced by a foreign key constraint; instead, use delete statement without a where clause. Because truncate table is not logged, it cannot activate a trigger.

• Truncate table may not be used on tables participating in an indexed view.

State Management Priority

Viewstate
Session Variables
Application Variables
Cache
Cookies

Now the question arises that when to use what?
1- Viewstate
Viewstateis a hidden fields in an ASP.NET page, contains state of those controlson a page whose "EnableViewstate" property is "true".
You can also explicitly add values in it, on an ASP.NET page like:
Viewstate.Add( "TotalStudents", "87″ );
Viewstateshould be used when you want to save a value between differentroundtrips of a single page as viewstate of a page is not accessible byanother page.
BecauseViewstate renders with the page, it consumes bandwidth, so be carefulto use it in applications to be run on low bandwidth.
2- Session Variable
Session variables are usually the most commonly used.
When a user visits a site, it's sessions starts and when the user become idle or leave the site, the session ends.
Session variables should be used to save and retrieve user specific information required on multiple pages.
Sessionvariables consumes server memory, so if your may have a huge amountvisitors, use session very carefully and instead of put large values init try to put IDs and references
for more information  :- http://support.microsoft.com/kb/307598


3- Application variables
Application variables are shared variables among all users of a web application
Applicationvariables behave like static variables and they are substitute ofstatic variables as static variables are stateless in web applications
Onlyshared values should be persisted in Application variables, and as soonas they are not in use they should be removed explicitly.

4- Cache
Cache is probably the least used state feature of ASP.NET.
Cacheis basically a resource specific state persistence feature, meansunlike session it stick with resource instead of user, for instance:pages, controls etc.
Cache should be used or frequently used pages, controls, and data structures
Data cache can be used to cache frequently used list of values e.g. list of products

5- Cookies
Cookies are some values saved in browsers by the website to retrivbbe and use afterwards.
Usually cookies are used to help dynamic websites to identify visitors and retrieve their saved preferences.
Cookies are also used to facilitate auto login by persisting user id in a cookie save in user's browser.
Becausecookies have been saved at client side, they do not create performanceissues but may create security issues as they can be hacked frombrowser.

Finally remember the following points on your finger-tips:
Viewstate is bandwidth hungry
Session variables are memory hungry as per number of users
Applications variables are shared
Cache is memory hungry as per number of resources
Cookies are the least secure

Access Previous Page Postback Values ( Cross-Page Posting )

       Well this Article explains you how we can post back the one page values. Before going to this .Let's first understand what will happen while the page is post back to the server. Think that someone requests an ASP.NET Web page (.aspx file), as soon as the request will be sent to the server and the page runs as a program on the Web server. While the page is running, it can perform any task that your Web site requires, including calculating values, reading or writing database information, or calling other programs. As its output, the page dynamically produces markup (elements in HTML or another markup language) and sends this dynamic output to the browser. This we can call as Round Trip or Post back.

The processing cycle for an ASP.NET Web page is this:

1.      The user requests the page. (The page is requested using an HTTP GET method.) The page runs for the first time, performing preliminary processing if you have programmed it to do so.

2.      The page dynamically renders markup to the browser, which the user sees as a Web page similar to any other page.

3.      The user types information or selects from available choices and then clicks a button. (If users click a link instead of a button, the page might simply navigate to another page, and no further processing takes place on the first page.)

4.      The page is posted to the Web server. (The browser performs an HTTP POST method, which in ASP.NET is referred to as a postback.) Specifically, the page is posted back to itself. For example, if the user is working with the page Default.aspx, clicking a button on the page posts the page back to the server with a target of Default.aspx.

5.      On the Web server, the page runs again. The information that the user typed or selected is available to the page.

6.      The page performs the processing that you have programmed it to do.

7.      The page renders itself back to the browser.

This cycle continues as long as the user is working in the page. Each time the user clicks a button, the information in the page is posted to the Web server and the page runs again. Each cycle is referred to as a round trip. Because page processing occurs on the Web server, each action that the page can do requires a round trip to the server.

Under some circumstances, you might want a page to post to a different page, not to itself. This is referred to as cross-page posting. For example, you might be creating a series of pages that process a customer order. Each page can post to the next page in the sequence. In that case, you can configure certain controls (like Button control) on the page to post to a different target page.

Cross-page posting provides some advantages over using the Transfer method to redirect to another page.

Because cross-page posting is configured for individual controls, you can create a page that posts to different pages depending on which button the user clicks.

 

When you configure a page for cross-page posting, you frequently want to get information from the source page. This might include the information from controls on the page—that is, the information being posted by the browser—as well as public properties of the source page.

  

Let's see how we can do this Cross Page post backing in Two methods, it up to you to use your convenient method:

 

Method 1:

 

This is enabled by a button on the first page setting PostBackUrl property to the page that will handle the postback. Once in the second page you can access the controls from the previous page by accessing the Page.PreviousPage property. Here's a sample that's like most of the documentation I've seen:

// Page1.aspx


<form id="form1" runat="server">

    <div>

        First Name :<asp:TextBox ID="Fname" runat="server"></asp:TextBox><br />

   

        Last Name :<asp:TextBox ID="Lname" runat="server"></asp:TextBox>

        <asp:Button ID="btnGo" runat="server" Text="Leave Me" PostBackUrl="~/CrossPostBack/page2.aspx" />

    </div>

    </form>

 

// Page2.aspx

<form id="form1" runat="server">

    <div>

   <h1> Hi ...<asp:Label ID="lblName" runat="server" Text="Label"></asp:Label> !!!!

     </h1>

    

   <p>  Welcome To New Page..........

     <a href="Page1.aspx">Click Here</a> To GoBack..</p>

    

    </div>

</form>

In Code Behind Method:

protected void Page_Load(object sender, EventArgs e)

{

        TextBox txtFname = (TextBox)PreviousPage.FindControl("Fname");

        TextBox txtLname = (TextBox)PreviousPage.FindControl("Lname");

        lblName.Text = txtFname.Text + " " + txtLname.Text;

 }

 

I find this to be entirely too tedious primarily because this approach still loses out of the declarative server side object model. The second page has to re-declare the same controls as local variables to access the properties. I don't think it will be how people write their second page to handle the post back. Instead the more useful approach will be to use the <%@ PreviousPageType %> directive in the second page:

Method 2:

 

// Page1.aspx

 

Add the Public Variable to access it in new page.


<script runat="server">

public string Sum

{

    get

    {

        string result=Fname.Text + Lname.Text;

        return result;

    }

}

</script>


<form id="form1" runat="server">

    <div>

        First Name :<asp:TextBox ID="Fname" runat="server"></asp:TextBox><br />

   

        Last Name :<asp:TextBox ID="Lname" runat="server"></asp:TextBox>

        <asp:Button ID="btnGo" runat="server" Text="Leave Me" PostBackUrl="~/CrossPostBack/page2.aspx" />

    </div>

    </form>

 

 


// Page2.aspx


<%@ PreviousPageType VirtualPath="~/CrossPostBack/Page1.aspx" %>

 

<div>

   <h1> Hi ...<asp:Label ID="lblName" runat="server" Text="Label"></asp:Label> !!!!

     </h1>

    

   <p>  Welcome To New Page..........

     <a href="Page1.aspx">Click Here</a> To GoBack..</p>

    

    </div>

In Code behind :

protected void Page_Load(object sender, EventArgs e)

{

        lblName.Text = PreviousPage.Sum.ToString();

}

 

The first page utilizes the posted data via the declarative controls and it provides the necessary information to the second page a public property. Now this is much better since we now get to reuse the declarative controls. I really think this will be the preferred style of using cross page postbacks in ASP.NET 2.0.

One very interesting thing I've noticed about cross page postbacks is the life cycle of the first page when posting back to the second. The first time the second page accesses Page.PreviousPage ASP.NET needs to make a page object available. So it, in essence, creates the Page.PreviousPage object and calls ProcessChildRequest , which is similar to ProcessRequest except it stops processing prior to PreRender and a fake Response object is created so that no Write s are emitted. This has some interesting side effects, one of which is that all of the server side events of the first page fire. This includes Page_Init , Page_Load and any control events like Button.Click events (if the Button has an OnClick event declared). This blew me away and it's certainly something to keep in mind when using cross page postbacks. One way to detect if your page is being accessed as a PreviousPage is to check Page.IsCrossPagePostBack .

One last thing to note about cross page postbacks is that, the PreviousPage's Trace messages end up mixed with the current page's Trace messages.  

Post Back And Cross-Page Posting

       Well this Article explains you how we can post back the one page values. Before going to this .Let's first understand what will happen while the page is post back to the server. Think that someone requests an ASP.NET Web page (.aspx file), as soon as the request will be sent to the server and the page runs as a program on the Web server. While the page is running, it can perform any task that your Web site requires, including calculating values, reading or writing database information, or calling other programs. As its output, the page dynamically produces markup (elements in HTML or another markup language) and sends this dynamic output to the browser. This we can call as Round Trip or Post back.

The processing cycle for an ASP.NET Web page is this:

1.      The user requests the page. (The page is requested using an HTTP GET method.) The page runs for the first time, performing preliminary processing if you have programmed it to do so.

2.      The page dynamically renders markup to the browser, which the user sees as a Web page similar to any other page.

3.      The user types information or selects from available choices and then clicks a button. (If users click a link instead of a button, the page might simply navigate to another page, and no further processing takes place on the first page.)

4.      The page is posted to the Web server. (The browser performs an HTTP POST method, which in ASP.NET is referred to as a postback.) Specifically, the page is posted back to itself. For example, if the user is working with the page Default.aspx, clicking a button on the page posts the page back to the server with a target of Default.aspx.

5.      On the Web server, the page runs again. The information that the user typed or selected is available to the page.

6.      The page performs the processing that you have programmed it to do.

7.      The page renders itself back to the browser.

This cycle continues as long as the user is working in the page. Each time the user clicks a button, the information in the page is posted to the Web server and the page runs again. Each cycle is referred to as a round trip. Because page processing occurs on the Web server, each action that the page can do requires a round trip to the server.

Under some circumstances, you might want a page to post to a different page, not to itself. This is referred to as cross-page posting. For example, you might be creating a series of pages that process a customer order. Each page can post to the next page in the sequence. In that case, you can configure certain controls (like Button control) on the page to post to a different target page.

Cross-page posting provides some advantages over using the Transfer method to redirect to another page.

Because cross-page posting is configured for individual controls, you can create a page that posts to different pages depending on which button the user clicks.

 

When you configure a page for cross-page posting, you frequently want to get information from the source page. This might include the information from controls on the page—that is, the information being posted by the browser—as well as public properties of the source page.

 

 

Let's see how we can do this Cross Page post backing in Two methods, it up to you to use your convenient method:

 

Method 1:

 

This is enabled by a button on the first page setting PostBackUrl property to the page that will handle the postback. Once in the second page you can access the controls from the previous page by accessing the Page.PreviousPage property. Here's a sample that's like most of the documentation I've seen:

// Page1.aspx


<form id="form1" runat="server">

    <div>

        First Name :<asp:TextBox ID="Fname" runat="server"></asp:TextBox><br />

   

        Last Name :<asp:TextBox ID="Lname" runat="server"></asp:TextBox>

        <asp:Button ID="btnGo" runat="server" Text="Leave Me" PostBackUrl="~/CrossPostBack/page2.aspx" />

    </div>

    </form>

 

// Page2.aspx

<form id="form1" runat="server">

    <div>

   <h1> Hi ...<asp:Label ID="lblName" runat="server" Text="Label"></asp:Label> !!!!

     </h1>

    

   <p>  Welcome To New Page..........

     <a href="Page1.aspx">Click Here</a> To GoBack..</p>

    

    </div>

</form>

In Code Behind Method:

protected void Page_Load(object sender, EventArgs e)

{

        TextBox txtFname = (TextBox)PreviousPage.FindControl("Fname");

        TextBox txtLname = (TextBox)PreviousPage.FindControl("Lname");

        lblName.Text = txtFname.Text + " " + txtLname.Text;

 }

 

I find this to be entirely too tedious primarily because this approach still loses out of the declarative server side object model. The second page has to re-declare the same controls as local variables to access the properties. I don't think it will be how people write their second page to handle the post back. Instead the more useful approach will be to use the <%@ PreviousPageType %> directive in the second page:

Method 2:

 

// Page1.aspx

 

Add the Public Variable to access it in new page.


<script runat="server">

public string Sum

{

    get

    {

        string result=Fname.Text + Lname.Text;

        return result;

    }

}

</script>


<form id="form1" runat="server">

    <div>

        First Name :<asp:TextBox ID="Fname" runat="server"></asp:TextBox><br />

   

        Last Name :<asp:TextBox ID="Lname" runat="server"></asp:TextBox>

        <asp:Button ID="btnGo" runat="server" Text="Leave Me" PostBackUrl="~/CrossPostBack/page2.aspx" />

    </div>

    </form>

 

 


// Page2.aspx


<%@ PreviousPageType VirtualPath="~/CrossPostBack/Page1.aspx" %>

 

<div>

   <h1> Hi ...<asp:Label ID="lblName" runat="server" Text="Label"></asp:Label> !!!!

     </h1>

    

   <p>  Welcome To New Page..........

     <a href="Page1.aspx">Click Here</a> To GoBack..</p>

    

    </div>

In Code behind :

protected void Page_Load(object sender, EventArgs e)

{

        lblName.Text = PreviousPage.Sum.ToString();

}

 

The first page utilizes the posted data via the declarative controls and it provides the necessary information to the second page a public property. Now this is much better since we now get to reuse the declarative controls. I really think this will be the preferred style of using cross page postbacks in ASP.NET 2.0.

One very interesting thing I've noticed about cross page postbacks is the life cycle of the first page when posting back to the second. The first time the second page accesses Page.PreviousPage ASP.NET needs to make a page object available. So it, in essence, creates the Page.PreviousPage object and calls ProcessChildRequest , which is similar to ProcessRequest except it stops processing prior to PreRender and a fake Response object is created so that no Write s are emitted. This has some interesting side effects, one of which is that all of the server side events of the first page fire. This includes Page_Init , Page_Load and any control events like Button.Click events (if the Button has an OnClick event declared). This blew me away and it's certainly something to keep in mind when using cross page postbacks. One way to detect if your page is being accessed as a PreviousPage is to check Page.IsCrossPagePostBack .

One last thing to note about cross page postbacks is that, the PreviousPage's Trace messages end up mixed with the current page's Trace messages.

 

Params Used For......in C#

Sometimes we may require a variable number of arguments to be passed to a function. For example we may require a sum function which calculates the total of the numbers passed to it no matter how many numbers are passed.

In C# we can use the Params keyword and pass variable no of arguments to a function. It's much like using ParamArray in VisualBasic language. The syntax of params arguments is:
params datatype[] argument name

Note that the argument passed using params argument should be an single dimension array also it should be the last argument in the argument list for the function.

The params parmeter can then be accessed as an normal array.
 
 
Example

class ParamsTest

    {

        static void Main(string[] args)

        {

            System.Console.WriteLine(sum(2, 3, 4)); /* Three Arguments Passed*/

            System.Console.WriteLine(sum(10, 20, 30, 40, 50, 60));/*Six Arguments*/

            Console.ReadLine();

        }

        static int sum(params int[] num)

        {

            int tot = 0;

            foreach (int i in num)

            {

                tot = tot + i;

            }

            return tot;

        }

    }

 
 
Out Put:
----------
 
9
210
------------------------------

Serialization / Deserialization

Welcome to all here we'll explore serialization and deserialization with the Microsoft .NET Framework. We'll look at the reasons for using serialization and techniques for utilizing it within your applications. It will involve using classes located in the System.Runtime.Serialization namespace.

Definition of Serialization

Serialization is the process of taking an object and converting it to a format in which it can be transported across a network or persisted to a storage location. The storage location could be as simple as using a file or a database. The serialized format contains the object's state information. Deserialization is the process of using the serialized state information to reconstruct the object from the serialized state to its original state. In essence, the process of serialization allows an object to be serialized, shipped across the network for remoting or persisted in a storage location such as the ASP.NET cache, and then be reconstructed for use at a later point in time.

Serialization Formats

There are three formats provided by the Microsoft .NET framework to which objects can be serialized. The formats are binary, SOAP, and XML. The format is controlled based upon what object is used to perform the serialization. The XML format is produced by using the System.Xml.Serialization.XmlSerializer class. The SOAP and binary formats are produced by using classes under the System.Runtime.Serialization.Formatters namespace.

There are subtle differences among the serialized formats. The binary-based format is the most compact and light of the three formats. The XML formatter only serializes public fields and properties, while binary and SOAP do not adhere to that limitation.

Controlling XML Serialization with Attributes

Attributes can be used to control the serialization of an object performed by the XmlSerializer. Some of the attributes available are as follows:

  • XmlAttributeAttribute—The member will be serialized as an XML attribute
  • XmlElementAttribute—The field or property will be serialized as an XML element
  • XmlIgnoreAttribute—The field or property will be ignored when serializing
  • XmlRootAttribute—Represents the XML document's root element name, only applies to a class

XML Serialization Sample Code

The following code defines a class that demonstrates the use of some of the XML serialization controlling attributes.

using System;
using System.Xml.Serialization;

namespace CodeGuru.Serialization
{
[XmlRoot("TestDataXml")]
public class TestData
{
private int _Identity = 0;

private string _Name = "";
[XmlElement("DataName")]
public string Name
{
get { return this._Name; }
set { this._Name = value; }
}

private string _IgnoreMe = "";
[XmlIgnore]
public string IgnoreMe
{
get { return this._IgnoreMe; }
set { this._IgnoreMe = value; }
}

public TestData()
{
}
}
}

Test XML Serialization Code

The following code will serialize the sample class defined above and store the information in a file on the local drive.

TestData obj = new TestData();
obj.Name = "testing";
obj.IgnoreMe = "ignore";
XmlSerializer serializer =
new XmlSerializer(obj.GetType());
Stream stream =
new FileStream("c:\\MyFile.xml", FileMode.Create,
FileAccess.Write, FileShare.None);
serializer.Serialize(stream, obj);
stream.Close();

Resulting XML

Notice how the private fields and properties are not included in the XML. The XmlSerializer behaves this way by design.

<?xml version="1.0"?>
<TestDataXml xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<DataName>testing</DataName>
</TestDataXml>


Using SOAP and Binary Serialization

SOAP and binary serialization are essential if you are planning to transport objects across a network. The SOAP formatter is ideal for sending the object via HTTP, while the binary is more ideal because of its more lightweight and compact nature. The XML serializer cannot prepare an object for transportation by itself. It also ignores private member fields and properties.

XML Serialization Sample Code

By simply adding the [Serializable] attribute to the top of the sample class above, we now can use the SOAP or binary formatter to serialize our object to the respective format. The following code demonstrates using the SOAP formatter.

TestData obj = new TestData(); obj.Name = "testing"; obj.IgnoreMe = "ignore";
IFormatter formatter =
new System.Runtime.Serialization.Formatters.Soap.SoapFormatter(); Stream stream = new FileStream("c:\\MyFile.xml", FileMode.Create, FileAccess.Write, FileShare.None);
formatter.Serialize(stream, obj);
 stream.Close();

Resulting SOAP

It is important to notice how the SoapFormatter does not pay any attention to any of the XML attributes we had previously assigned our class above.

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle= "http://schemas.xmlsoap.org/soap/encoding/"> <SOAP-ENV:Body> <a1:TestData id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/ CodeGuru.Serialization/ CodeGuru.Serialization%2C%20Version%3D1.0.1404.42352%2C%20 Culture%3Dneutral%2C%20PublicKeyToken%3Dnull"> <_Identity>0</_Identity> <_Name id="ref-3">testing</_Name> <_IgnoreMe id="ref-4">ignore</_IgnoreMe> </a1:TestData> </SOAP-ENV:Body> </SOAP-ENV:Envelope>

Implementing the ISerializable Interface

Simply putting the [Serializable] attribute on top of a class is a simple way to make an object serializable. This alone works great if you have basic needs when serializing an object. What happens when you need control over the serialization process and what is ultimately put into the serialized format? This is the purpose of the ISerializable interface. It provides an interface that gives you complete flexibility in the items contained within the serialized format. The interface requires that a constructor be overridden that is used to recreate an instance of the object from a serialized version of the data, also known as deserialization. The second method involved is GetObjectData, which is responsible for controlling the actual values put into the serialized version of the object.

ISerializable Interface Sample Code

The following code refines our sample class defined earlier. It now implements an additional constructor used to deserialize an object, and the GetObjectData method is used to control the serialization process. Now, when the SOAP or binary formatter objects are used to serialize an object, they produce the version controlled by the GetObjectData method.

using System; using System.Runtime.Serialization;
using System.Xml.Serialization;
namespace CodeGuru.Serialization
 {
   [Serializable]
public class TestData : ISerializable
    {
      
private int _Identity = 0;
      
private string _Name = "";
      
public string Name { get { return this._Name; } set { this._Name = value; } }
      
private string _IgnoreMe = "";
      
public string IgnoreMe
              {
                  get
        
{
           
return this._IgnoreMe;
         }
        
set
        
{ 
          
this._IgnoreMe = value;
          }
       }

        public
TestData() { }
        protected
TestData(SerializationInfo info, StreamingContext context)
        {
        
this._Identity = info.GetInt32("_Identity");
        
this._Name = info.GetString("_Name");
        }
       
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
                {
                  info.AddValue("_Identity", this._Identity);
         info.AddValue("_Name",
this._Name);
        }
    }
  }

Resulting SOAP

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle= "http://schemas.xmlsoap.org/soap/encoding/"> <SOAP-ENV:Body> <a1:TestData id="ref-1" xmlns:a1= "http://schemas.microsoft.com/clr/nsassem/CodeGuru.Serialization/ CodeGuru.Serialization%2C%20Version%3D1.0.1404.42999%2C%20 Culture%3Dneutral%2C%20PublicKeyToken%3Dnull"> <_Identity>0</_Identity> <_Name id="ref-3">testing</_Name> </a1:TestData> </SOAP-ENV:Body> </SOAP-ENV:Envelope>

Summary

You now have seen various ways in which objects can be serialized. This will allow you to store objects in a file, a database, or in an ASP session state and then deserialize them back into original form.

Future Columns

The topic of the next column is yet to be determined. If you have something in particular that you would like to see explained here, you could reach me at mstrawmyer@crowechizek.com.

About the Author

Mark Strawmyer, MCSD, MCSE, MCDBA is a Senior Architect of .NET applications for large- and mid-size organizations. Mark is a technology leader with Crowe Chizek in Indianapolis, Indiana. He specializes in architecture, design, and development of Microsoft-based solutions. You can reach Mark at mstrawmyer@crowechizek.com.


Share

Twitter Delicious Facebook Digg Stumbleupon Favorites