ASP/.NET

How to upload files in .NET programing?

Thu, 12 Jun 2008 04:28:28 +0000

General things

The first version of Microsoft ASP.NET was 1.0. Since then the team worked for introducing possibilities to create web applications that had the ability to upload files to the hosting server. This was done through the use of the FileField HTML server control. Now we refer to the 2.0 version of ASP.NET.This article try to introduce you to the new FileUpload server control.

FileUpload Server Control Example

If you want to use the FileField control in ASP.NET 1.x version you must know that you had to take a few extra steps to get everything in line and working. In ASP .NET 2.0 version things are ease to be done. The new version of FileUpload server control makes the process of uploading files to the hosting server as simple as possible.

I will show you how to use the FileUpload control to upload files to the server. Here are two examples of using FileUploade: one of them is wrote in Microsoft Visual Basic and the other one in Microsoft Visual C#:

Visual Basic Example:

<%@ Page Language="VB" %>





    Upload Files

Visual C# Example:

<%@ Page Language="C#" %>





    Upload Files

Running this you will obtain the source code generated from the FileUpload control:



   Upload Files

As you can see ASP.NET 2.0 modified the page’s

element on your behalf by adding the appropriate enctype attribute. Another important thing to remark here is that the FileUpload control was converted to an HTML element.
If you run the file from the examples you can upload files to the server by clicking on the Upload File button and selecting the file that you want to upload and that’s a very ease job.

Sending Authenticated Emails in .NET 2.0

Thu, 21 Feb 2008 14:17:28 +0000

Sending e-mails in the .NET Framework 2.0 is about the same as in version 1.x. There are just a couple of variations. First, all the functionality is within the new System.Net.Mail namespace. The System.Web.Mail namespace, which was used in the 1.x frameworks is now considered obsolete.

Below is the code. It’s really straight forward and self explanatory:

MailMessage oMsg = new MailMessage();// Set the message sender
oMsg.From = new MailAddress(“xavier@devel.oping.net”, “Xavier Larrea”);
// The .To property is a generic collection,

// so we can add as many recipients as we like.

oMsg.To.Add(new MailAddress(“fox@foxcorp.org”,“John Doe”));

// Set the content

oMsg.Subject = “My First .NET email”;

oMsg.Body = “Test body - .NET Rocks!”;

oMsg.IsBodyHtml = true;

SmtpClient oSmtp = new SmtpClient(“smtp.myserver.com”);

//You can choose several delivery methods.

//Here we will use direct network delivery.

oSmtp.DeliveryMethod = SmtpDeliveryMethod.Network;

//Some SMTP server will require that you first

//authenticate against the server.

NetworkCredential oCredential = new NetworkCredential(“myusername”,“mypassword”);

oSmtp.UseDefaultCredentials = false;

oSmtp.Credentials = oCredential;

//Let’s send it already

oSmtp.Send(oMsg);

Very easy, right? Remember always to use the Try-Catch block when sending emails because lot of things can cause an exception: bad email addresses, authentication errors, network failure, etc.

I hope you find this code useful. Happy coding!

Here is the source of this article.

Take Advantage of SQLXML with ASP.NET

Mon, 03 Dec 2007 17:29:42 +0000

Looking for advantages of SQLXML I found some interesting things:

“SQLXML is a set of supplemental tools that extend SQL Server’s existing support for retrieving and storing XML data. With SQLXML 3.0, you are now able to use SQL Server to expose Web services. SQLXML’s Web services let you execute stored procedures, user-defined functions, and they support templates.

While SQLXML’s Web services capabilities do not offer the flexibility or portability that can be gained by developing your own Web service applications to access data, they are ideal for rapid application development because you can offer SQLXML Web services without writing any code! In addition, the technology is well-suited for exposing reports over the Web. You can develop a client application that consumes SQLXML Web services with very little client-side code. From there, you have a number of options to shape, format, or parse the result set.

In this article you’ll see how to expose a stored procedure as a Web service and build a simple ASP.NET Web Form-based client to access and test the Web service.

You should have a basic of understanding of SQL Server 2000 and IIS, including knowledge of how to setup a virtual directory in IIS and how to grant permissions to a user in SQL Server. You can find basic documentation on these subjects in SQL Server 2000 Books Online and in the SQLXML 3.0 Documentation . To begin, you need an instance of SQL Server 2000, a Windows 2000 server running IIS, Microsoft’s MSXML 4.0 XML parser, the SQLXML 3.0 toolkit, and Visual Studio .NET (VS.NET). You can download the XML parser and SQLXML tools and documentation from the SQLXML resource link in the Resources column of this article.

Configuring a Web Service
The demonstration application for this article uses the Northwind sample database that’s installed by default with SQL Server. To get started, follow the instructions in the SQLXML 3.0 Documentation, available for download with the SQLXML 3.0 installer.

First, perform the steps in the procedure labeled Creating the nwind Virtual Directory under the topic IIS Virtual Directory Management for SQL Server in the SQLXML 3.0 documentation.

Go to the Configure IIS Support MMC snap-in application under the SQLXML 3.0 program group.

Select the default web site for your server, go to the Action menu and select New, then click on Virtual Directory.

Create a virtual directory named nwind under IIS that supports SQLXML applications accessing the Northwind database.

Configure the security settings to support the access to the Northwind database by the virtual directory application.

Under the Settings tab, check the Allow Post option. This allows HTTP POST requests, which are required to support SQLXML Web.

Under this virtual directory, you can configure different types of SQLXML applications, including templates, schemas, and dbobjects, which support template execution, XPath queries against a mapping schema file, and direct access of database objects respectively. These different types of applications under the virtual directory are called virtual name types. There is also a SOAP virtual name type that identifies Web services using SOAP messaging. Create a SOAP virtual name type and name it MyWebService. Now you need to follow the steps in the section labeled Step 2: Configuring the Virtual Name under the topic Initial Setup for Sending SOAP Requests.

Enter MyWebService as the name for the new virtual directory application and select the virtual name type SOAP. This creates a reference to the Web Service extensions of the Northwind database. Configuring MyWebService creates a WSDL (Web Services Definition Language) file and a SQL Server Configuration (.ssc) configuration file for your Web service. The .ssc file describes the virtual name type configuration, and SQLXML uses it to generate the WSDL file. The WSDL file describes the Web services and the methods that your client application can call when using the service.

After setting up a SOAP virtual name type, select the Configure option under the Virtual Names tab of the IIS Virtual Directory management tool for SQLXML 3.0. To set up a stored procedure method mapping type for your soap virtual name type, select the CustOrdersDetail stored procedure under SP/Template option and select the Save option. Saving the stored procedure mapping adds a CustOrdersDetail method to MyWebService. After completing this step, browse to your nwind virtual directory and look for a file named soap.wsdl, which is the XML-formatted WSDL file that describes the services you configured. In a text editor the file looks like this:

See the source.

ASP.NET 2.0 Performance Tuning Considerations

Fri, 16 Nov 2007 16:36:06 +0000

ASP.NET 2.0 has started picking up the momentum and already there are a large scale of companies using it for developing cutting edge web applications.

While the features have been very good, the decisive factor in web applications development is performance.

ASP.NET 2.0 in general has a lot of performance enhancement feature starting from compilation model to ADO.NET 2.0 DataSets which is comparatively faster than its predecessor. Here below are some of the performance considerations:

Paging through Records
Always use Custom Paging and dont rely on the default built-in paging mechanism for GridView, DataGrid etc.,

Turn off Session State
ASP.NET uses a built-in session state mechanism as well as supports your Custom Session State model. However, the cost of Session storage becomes heavy when the users, objects stored increase significantly. Turn off Session State for pages which dont require Session. Typically in a web application there may be static as well as dynamic pages. In the static pages, which dont require Session, the Session State can be turned off. Wherever, you just require Session Data as ReadOnly (where you wont be updating the Session Data), the SessionState can be made ReadOnly.

To turn off Session State at page level,

<%@ Page EnableSessionState=”False” %>

To make it ReadOnly at page level,

<%@ Page EnableSessionState=”ReadOnly” %>

If your Website has a lot of content pages which are static and only certain pages require Session Data, try considering Turning off SessionState at the Web.Config level and only enable it for those pages which require Session Data. Always the Page settings will override the web.config settings. Session State can be turned off in the web.config as follows:-

Turn off View State
View State is the wonderful mechanism which stores the page as well as controls’ data, state etc., across round trips. However, the View State can grow heavy significantly increasing the load and hence, View State must be turned off for pages which dont require the same. ViewState can be turned off at page level as follows:-

<%@ Page EnableViewState=”False” %>

Use Caching
Cache your pages wherever possible. When implementing OutputCache, set a longer duration than setting a shorter duration. A longer duration Cache is much more better than quick short duration caches.

When the content of page can change, try using Cache with Dependency. There are various dependency techniques such as FileDependency, Database Dependency etc., to invalidate the cache.

Use IsPostBack
The IsPostBack is your best friend in controlling when to load the controls, populate data. ASP.NET, by default postbacks to the server for any/all operations and the number of Page_Loads you would be having will be significant. When using IsPostBack, it validates that the DataBinding methods are called only the first time the page loads and not for subsequent PostBacks.

if(!IsPostBack)
{
// Data Bind your Controls
}

Use DataSources
The Provider model and the DataSource controls in ASP.NET 2.0 not only simplify the Data Binding techniques but also provide significant performance enhancements by caching the Data as well as reducing the number of DB hits required to populate similar data on different controls. The Provider model eliminates the Control from the underlying Data Model thereby making it a thin layer which just represents whatever is bound to it.

When using SqlDataSource, ObjectDataSource etc., an important point to note is that, you dont need to bind the Data explicitly to the controls using DataBind.Ex.-

GridView1.DataSourceId = SqlDataSource1 // where SqlDataSource1 is the ID of the Datasource control.

That is all required. You dont require the GridView1.DataBind(); method which we are very familiar from .NET 1.0. The reason is that, the DataBind method is implicitly called by the EnsureDataBound method of the DataSource control. If we call it explicitly, then it results in a double binding of Data.

Please note that some of the points are not specific to ASP.NET 2.0 but do apply for ASP.NET 1.x versions as well. Secondly the performance considerations are mentioned assuming the implementations are done in the proper way with best practices in coding standards etc.,
See the source…

Performance Tuning Tips

Fri, 26 Oct 2007 20:32:56 +0000

Any programming model has its common performance pitfalls, and ASP.NET is no exception. This section describes some of the ways in which you can avoid performance bottlenecks in your code.

Disable Session State when not in use: Not all applications or pages require per-user session state. If it is not required, disable it completely. This is easily accomplished using a page-level directive, such as the following:

<%@ Page EnableSessionState="false" %>
Note: If a page requires access to session variables but does not create or modify them, set the value of the directive to ReadOnly. Session State can also be disabled for XML Web service methods. See Using Objects and Intrinsics in the XML Web services section.
Choose your Session State provider carefully: ASP.NET provides three distinct ways to store session data for your application: in-process session state, out-of-process session state as a Windows Service, and out-of-process session state in a SQL database. Each has its advantages, but in-process session state is by far the fastest solution. If you are only storing small amounts of volatile data in session state you should use the in-process provider. The out-of-process solutions are primarily useful in Web garden and Web farm scenarios or in situations in which data cannot be lost in the event of a server/process restart.
Avoid excessive round trips to the server: The Web Forms page framework is one of the best features of ASP.NET, because it can dramatically reduce the amount of code you need to write to accomplish a task. Programmatic access to page elements using server controls and the postback event handling model are arguably the most time-saving features. However, there are appropriate and inappropriate ways to use these features, and it is important to know when it is appropriate to use them.An application typically needs to make a round trip to the server only when retrieving data or storing data. Most data manipulations can take place on the client between round trips. For example, validating form entries can often take place on the client before the user submits data. In general, if you do not need to relay information back to the server, then you should not make a round trip to the server.If you are writing your own server controls, consider having them render client-side code for up-level (ECMAScript-capable) browsers. By employing “smart” controls, you can dramatically reduce the number of unecessary hits to your Web server.
Use Page.IsPostback to avoid extra work on a round trip: If you are handling server control postbacks, you often need to execute different code the first time the page is requested from the code you do use for the round trip when an event is fired. If you check the Page.IsPostBack property, your code can execute conditionally, depending on whether there is an initial request for the page or a responce to a server control event. It might seem obvious to do this, but in practice it is possible to omit this check without changing the behavior of the page. For example:
```
  


  
```
The Page_Load event executes on every request, so we checked Page.IsPostBack so that the first query does not execute when we process the Button_Click event postback. Note that even without this check our page would behave identically, since the binding from the first query would be overturned by the call to DataBind in the event handler. Keep in mind that it can be easy to overlook this simple performance improvement when you write your pages.
Use server controls sparingly and appropriately: Even though it is extremely easy to use, a server control might not always be the best choice. In many cases, a simple rendering or databinding substitution will accomplish the same thing. For example:
```
<%--the span and img server controls are unecessary...--%>

The path to the image is: 


' runat="server"/>





<%-- use databinding to substitute literals instead...--%>

The path to the image is: <%# imagePath %>


' />





<%-- or a simple rendering expression...--%>

The path to the image is: <%= imagePath %>


' />
```
In this example, a server control is not needed to substitute values into the resulting HTML sent back to the client. There are many other cases where this technique works just fine, even in server control templates. However, if you want to programmatically manipulate the control’s properties, handle events from it, or take advantage of its state preservation, then a server control would be appropriate. You should examine your use of server controls and look for code you can optimize.
Avoid excessive server control view state: Automatic state management is a feature that enables server controls to re-populate their values on a round trip without requiring you to write any code. This feature is not free however, since the state of a control is passed to and from the server in a hidden form field. You should be aware of when ViewState is helping you and when it is not. For example, if you are binding a control to data on every round trip (as in the datagrid example in tip #4), then you do not need the control to maintain it’s view state, since you will wipe out any re-populated data in any case.ViewState is enabled for all server controls by default. To disable it, set the EnableViewState property of the control to false, as in the following example:
You can also turn ViewState off at the page level. This is useful when you do not post back from a page at all, as in the following example:
```
<%@ Page EnableViewState="false" %>
```
Note that this attribute is also supported by the User Control directive. To analyze the amount of view state used by the server controls on your page, enable tracing and look at the View State column of the Control Hierarchy table. For more information about the Trace feature and how to enable it, see the Application-level Trace Logging feature.
Use Response.Write for String concatenation: Use the HttpResponse.Write method in your pages or user controls for string concatenation. This method offers buffering and concatenation services that are very efficient. If you are performing extensive concatenation, however, the technique in the following example, using multiple calls to Response.Write, is faster than concatenating a string with a single call to the Response.Write method.
Do not rely on exceptions in your code: Exceptions are very expensive and should rarely occur in your code. You should never use exceptions as a way to control normal program flow. If it is possible to detect in code a condition that would cause an exception, you should do that instead of waiting to catch the exception before handling that condition. Common scenarios include checking for null, assigning to a string that will be parsed into a numeric value, or checking for specific values before applying math operations.
Use early binding in Visual Basic or JScript code: One of the advantages of Visual Basic, VBScript, and JScript is their typeless nature. Variables can be created simply by using them and need no explicit type declaration. When assigning from one type to another, conversions are performed automatically, as well. This can be both an advantage and a disadvantage, since late binding is a very expensive convenience in terms of performance.The Visual Basic language now supports type-safe programming through the use of a special Option Strict compiler directive. For backward compatibility, ASP.NET does not enable Option Strict by default. However, for optimal perfomance, you should enable Option Strict for your pages by using a Strict attribute on the page or Control directive:
```
<%@ Page Language="VB" Strict="true" %><%

Dim B

Dim C As String

' This causes a compiler error:

A = "Hello"

' This causes a compiler error:

B = "World"

' This does not:

C = "!!!!!!"

' But this does:

C = 0
```
JScript also supports typeless programming, though it offers no compiler directive to force early binding. A variable is late-bound if:
- It is declared explicitly as an object.
- It is a field of a class with no type declaration.
- It is a private function/method member with no explicit type declaration and the type cannot be inferred from its use.
The last distinction is complicated. The JScript compiler optimizes if it can figure out the type, based on how a variable is used. In the following example, the variable A is early-bound but the variable B is late-bound:
```
var A;

var B;A = "Hello";

B = "World";

B = 0;
```
For the best performance, declare your JScript variables as having a type. For example, “var A : String”.
```
%>
```
JScript also supports typeless programming, though it offers no compiler directive to force early binding. A variable is late-bound if:
- It is declared explicitly as an object.
- It is a field of a class with no type declaration.
- It is a private function/method member with no explicit type declaration and the type cannot be inferred from its use.
The last distinction is complicated. The JScript compiler optimizes if it can figure out the type, based on how a variable is used. In the following example, the variable A is early-bound but the variable B is late-bound:
```
var A;

var B;A = "Hello";

B = "World";

B = 0;
```
For the best performance, declare your JScript variables as having a type. For example, “var A : String”.
Port call-intensive COM components to managed code: The .NET Framework provides a remarkably easy way to interoperate with traditional COM components. The benefit is that you can take advantage of the new platform while preserving your existing code. However, there are some circumstances in which the performance cost of keeping your old components is greater than the cost to migrate your components to managed code. Every situation is unique, and the best way to decide what needs to be changed is to measure site performance. In general, however, the performance impact of COM interoperability is proportional to the number of function calls made or the amount of data marshaled from unmanaged to managed code. A component that requires a high volume of calls to interact with it is called “chatty,” due to the number of communications between layers. You should consider porting such components to fully managed code to benefit from the performance gains provided by the .NET platform. Alternatively, you might consider redesigning your component to require fewer calls or to marshal more data at once.
Use SQL stored procedures for data access: Of all the data access methods provided by the .NET Framework, SQL-based data access is the best choice for building scalable web applications with the best performance. When using the managed SQL provider, you can get an additional performance boost by using compiled stored procedures instead of ad hoc queries.
Use SqlDataReader for a fast-forward, read-only data cursor: A SqlDataReader object provides a forward, read-only cursor over data retrieved from a SQL database. SqlDataReader is a more performant option than using a DataSet if it can be used for your scenario. Because SqlDataReader supports the IEnumerableSqlDataReader.

interface, you can even bind server controls, as well. For an example of using
Cache data and output wherever possible: The ASP.NET programming model provides a simple mechanism for caching page output or data when it does not need to be dynamically computed for every request. You can design your pages with caching in mind to optimize those places in your application that you expect to have the most traffic. More than any feature of the .NET Framework, the appropriate use of caching can enhance the performance of your site, sometimes by an order of magnitude or more. For more information about how to use caching.
Enable Web gardening for multiprocessor computers: The ASP.NET process model helps enable scalability on multiprocessor machines by distributing the work to several processes, one for each CPU, each with processor affinity set to its CPU. The technique is called Web gardening, and can dramatically improve the performance of some applications.
Do not forget to disable Debug mode: The section in ASP.NET configuration controls whether an application is compiled in Debug mode, or not. Debug mode degrades performance significantly. Always remember to disable Debug mode before you deploy a production application or measure performance.

Read the full article…

Uploading files in ASP .NET 2.0. Is it safe?

Wed, 19 Sep 2007 21:27:57 +0000

Choosing to upload files with ASP .NET proved to be inefficient. The way IIS 5 and IIS 6 runs is: when you pick a file in the form, IIS need to “absorb” the whole file and you can have access to the file properties only after. IIS 7 promised to be more like Apache in this case, but until then we have to wait for a long upload and the worst thing is u can’t display a progress bar. If you want to see how a file is uploaded using PHP read the full article here.

Another bad thing is that you cannot upload more than 4MB without raising the limit in maxRequestLength in the config section. We have to be careful because isn’t enough to raise the limit for upload; we also should know that we have to increase executionTimeout, otherwise ASP.NET close requests that take too long. How should an user know whose fault is for an unsuccessful upload? One solution is to override Page.OnError and inspect the HTTP code, which should be 400, if the exception happens to be of type HttpException. You may also implement an HttpModule, set up its BeginRequest handler and compare Request.ContentLength with the size limit. If ContentLength is too high, redirect to a page with a meaningful error message.

Uploading Multiple Files

Uploading more than one files is made via the Request.Files collection:

HttpFileCollection uploads = HttpContext.Current.Request.Files;

Let’s have an example for uploading multiple files:

<form id=“form” runat=“server” enctype=“multipart/form-data”>
<p id=“upload”>
   <input type=“file” runat=“server” size=“60″ />
p>

<p><a href=“#” onclick=“addFile(); return false;”>Add a filea>p>

<p><asp:Button ID=“butSubmit” runat=“server” Text=“Upload Here” OnClick=“butSubmit_Click” />p>
class=”coloredcode”><script type=“text/javascript”>
class=”coloredcode”>function addFile(){
    if (!document.getElementById || !document.createElement)
        return false;

    var uploadArea = document.getElementById (”upload”);

    if (!uploadArea)
        return;

    var newLine = document.createElement (”br”);
    uploadArea.appendChild (newLine);

    var newUpload = document.createElement (”input”);
	newUpload.type = “file”;
        newUpload.size = “70″;

    if (!addFile.lastAssignedId)
        addFile.lastAssignedId = 100;

    newUpload.setAttribute (”id”, “dynamic” + addFile.lastAssignedId);
    newUpload.setAttribute (”name”, “dynamic:” + addFile.lastAssignedId);
    uploadArea.appendChild (newUpload);

    addFile.lastAssignedId++;
}
script>

<script type=“text/C#” runat=“server”>
void butSubmit_Click(object sender, EventArgs e){
    HttpFileCollection uploads = HttpContext.Current.Request.Files;

    for (int i = 0; i < uploads.Count; i++){
        HttpPostedFile upload = uploads[i];

        if (upload.ContentLength == 0)
            continue;
    }
}
script>

form>

How to Easily Use FTP in WSH

Mon, 10 Sep 2007 22:13:59 +0000

In my last article I showed you a work around that allowed you to use FTP in WSH. This time I’m going to show you a much easier, more flexible approach using a third-party ActiveX control designed to expand WSH. ActiveX controls can be used to add functionality to WSH that it does not have natively. The ActiveX must be written for this purpose and must provide a COM interface.

Once the ActiveX control is instantiated in your script, you will be able to access all of the methods and properties that it provides. ActiveX controls must be installed on the system on which they are being used. Simply referencing a file is not enough. To install an ActiveX control, it must be registered, meaning that a set of registry keys must be created that reference it as a COM object.

Many third parties will include installers for this. If your ActiveX control does not have an installer, you can register it yourself from the command line. Navigate to the directory where your control is located and use the command regsvr32 activex.ocx with the name of your control. We’ll be using Chilkat’s Free FTP ActiveX control. This ActiveX control acts as a sort of scriptable FTP client that provides access to the most common FTP functions. There are two versions—one free and one commercial.

While we’ll be using the free control for this demonstration, the paid version offers some very cool functionality. Once you’ve installed the control, you’ll be able to access it through its COM interface by connecting to the ChilkatFTP.ChilkatFTP namespace.

Set objFtp = CreateObject("ChilkatFTP.ChilkatFTP")

Next you’ll want to make a connection. To do that you’ll need to provide the hostname, username, and password. The FTP control provides properties for this.

objFtp.Hostname = "ftp.mysite.com"objFtp.Username = USERNAME

objFtp.Password = PASSWORD

success = objFtp.Connect()

Finally, the Connect method makes the connection. Be sure to catch the return code for error handling purposes.

If (success <> 1) Then

Wscript.Echo objFtp.LastErrorText

Wscript.Quit

End If

It’s obviously not enough to just connect to an FTP server. You undoubtedly have some task to perform. One of the most common is a file download. Let’s take a look at how to create a simple function for performing file downloads with the Chilkat FTP component.

In order to download a file we need to provide three pieces of information: what file to download, where to save it locally, and where to find it on the remote server. We’ll pass these values as parameters to our function.

Our function first needs to navigate to the proper remote directory. We can do this with the ChangeRemoteDir method provided by the Chilkat component.

Read the full article