….

localhost.MyWebService myService = new localhost.MyWebService();

System.Net.CredentialCache myCredentials = new System.Net.CredentialCache();
NetworkCredential netCred = new NetworkCredential(“UserName”, “Password”);
myCredentials.Add(new Uri(myService.Url), “Basic”, netCred);
myService.Credentials = myCredentials;

// Now call methods on the myService object….

You should be aware that by using Basic Authentication the user name and password are sent as Base 64 encoded text. That is as secure as sending it as plain text, so the best way to use this authentication mechanism is in combination with SSL. This way, the data is encrypted and is save from prying eyes….

In this article, I had used SQL Server 2005 as back end and C# as front end. SQL Server has “Image” data type to store the image. In Oracle and some other database you can use a data type which is used to store binary value (may be BLOB). I have created a simple aspx which has File upload control and a button. When user selects a file to upload, I am checking it for valid image type and converting it to array of Bytes. Then I will store that byte array into database. Below is the code,

if (objFileUpload.PostedFile !=null)
{
if (objFileUpload.PostedFile.ContentLength > 0)
{
// Get Posted File.
HttpPostedFile objHttpPostedFile = objFileUpload.PostedFile;

// Check valid Image type. Create this function according to your need
if (CheckValidFileType(objHttpPostedFile.FileName))
{
// Find its length and convert it to byte array
int intContentlength = objHttpPostedFile.ContentLength;

// Create Byte Array
Byte[] bytImage =new Byte[intContentlength];

// Read Uploaded file in Byte Array
objHttpPostedFile.InputStream.Read(bytImage, 0,
intContentlength);

}
}

}

Fig – (1) Read Uploaded file (here Image) in Byte Array

Pass this Byte array to you DAL and use it for storing image in database. I am using Enterprise Library as DAL so my code will look like,

Database db =DatabaseFactory.CreateDatabase();

string sqlCommand =“StoredProcedureName”;

DbCommand dbCommandWrapper = db.GetStoredProcCommand(sqlCommand);

db.AddInParameter(dbCommandWrapper,“@Image”,DbType.Binary,
bytImage );

try
{
db.ExecuteNonQuery(dbCommandWrapper);
}
catch {throw; }

Fig – (2) Insert Image in to database

This is how you can store the Image in database. Retrieving the image is the same process. Write a SP which will return your image. Store this value in a Byte Array. Once you get the image in Byte array, you just have to write it on form as shown below,

Byte[] bytImage =Byte array retrieved from database.
if (bytImage !=null)
{
Response.ContentType =“image/jpeg”;
Response.Expires = 0; Response.Buffer =true;
Response.Clear();
Response.BinaryWrite(bytImage);
Response.End();
}

Fig – (3) Code to display Byte array as Image on form.

To use this at multiple places in your application, you create a page to which you can pass ID of Image and it will retrieve image from database and create image. To do this copy paste above code in aspx.cs file. Now on every page you require to show this image take <asp:Image> on that page and set its ImageURL property to the path of newly created user control. See the code below,
<asp:Image ID=”ViewImage” runat=”server” />

Fig – (4) Image control on any aspx page (Lets say Sample.aspx).

string strURL =“~/ViewImage.aspx?ID= 1 “ ;
ViewImage.ImageUrl = strURL;
Happy Programing.

Creating the GridView Control

Checkbox selection inside the GridView control with no paging can be accomplished by writing a few lines of code. In this article, I will demonstrate how you can maintain the state of the CheckBoxes that are present inside the GridView with paging enabled.

The first thing you need to do is to create the GridView control. This can be done simply by dragging and dropping the GridView from the Toolbox onto the web form. Once you have the GridView, you can edit its columns using the smart tag or the HTML view of the page. I will add two bound columns and one template column. The bound columns “CategoryID” and “CategoryName” will be bound to the database fields “CategoryID” and “CategoryName” respectively. The template column will be used to display the CheckBoxes in the GridView control.

After adding the columns, the html source of the GridView control looks like this.

Listing 1: GridView HTML Code

AutoGenerateColumns=”False” AllowPaging=”True”
PageSize=”5″ Width=”324px” DataKeyNames=”CategoryID”
OnPageIndexChanging=”GridView1_PageIndexChanging”>
Please also note that the paging is enabled in the GridView control, and the DataKeyNames property has been set to “CategoryID,” since it’s the primary key in the database. The PageSize property has been set to 5, which means that after one page of the GridView can only contain 5 records/rows. The ItemTemplate tag contains the CheckBox whose ID is “CheckBox1,” which means that CheckBoxes will be displayed for the last column.

Populating the GridView Control

Let’s first see how I am populating the GridView control. I have defined a query as a private string constant, which is shown below.

Listing 2: Query to Retrieve Information from the Categories Table

/* QUERY */
private const string QUERY_SELECT_ALL_CATEGORIES = “SELECT * FROM Categories”;

The above query is used in the BindData method, which simply populates the GridView control with the DataSet object.

Listing 3: BindData Method to Populate the GridView Control

private void BindData()
{
SqlConnection myConnection = new SqlConnection(ConnectionString);
SqlDataAdapter ad = new SqlDataAdapter(QUERY_SELECT_ALL_CATEGORIES,
myConnection);
DataSet ds = new DataSet();
ad.Fill(ds, “Categories”);
GridView1.DataSource = ds;
GridView1.DataBind();
}

Remember Checked Values

The application will work fine if the number of pages is less than the page size. As soon as the paging kicks in, the GridView control will forget all the checked values of the old pages. You need some mechanism to store the previously checked values of the CheckBoxes. Fortunately, the Session variable can be used to store the checked values between postbacks.

Below, I have created a method, RememberOldValues, which iterates through the GridView rows and finds which values are checked. Once it gets the checked value, it stores the primary key of the table inside the Session object.

Listing 4: Save Checked Values

private void RememberOldValues()
{
ArrayList categoryIDList = new ArrayList();
int index = -1;
foreach (GridViewRow row in GridView1.Rows)
{
index = (int) GridView1.DataKeys[row.RowIndex].Value;
bool result = ((CheckBox)row.FindControl(“CheckBox1″)).Checked;

// Check in the Session
if (Session[CHECKED_ITEMS] != null)
categoryIDList = (ArrayList)Session[CHECKED_ITEMS];
if (result)
{
if (!categoryIDList.Contains(index))
categoryIDList.Add(index);
}
else
categoryIDList.Remove(index);
}
if (categoryIDList != null && categoryIDList.Count > 0)
Session[CHECKED_ITEMS] = categoryIDList;
}

Analysis

The first thing I did is to make an object of the ArrayList so that I can store the primary keys in it. You will need to include the System.Collections namespace in order to work with an ArrayList. After that, I loop through the GridView rows, checking to see which CheckBox is checked. Once I find the CheckBox that is checked, I insert the primary key, which in this case is “CategoryID,” into the ArrayList. If the row is not checked, I get the “CategoryID” and remove it from the ArrayList. If the ArrayList is not null, then I put the ArrayList inside the Session object.

Re-Populate CheckBoxes

In the last method, RememberOldValues, we captured and saved the primary keys of all the rows that were checked. In the RePopulateValues method, we will retrieve the saved values and assign them to the CheckBoxes.

Listing 5: Re-Populate CheckBoxes

private void RePopulateValues()
{
ArrayList categoryIDList = (ArrayList)Session[CHECKED_ITEMS];
if (categoryIDList != null && categoryIDList.Count > 0)
{
foreach (GridViewRow row in GridView1.Rows)
{
int index = (int)GridView1.DataKeys[row.RowIndex].Value;
if (categoryIDList.Contains(index))
{
CheckBox myCheckBox = (CheckBox) row.FindControl(“CheckBox1″);
myCheckBox.Checked = true;
}
}
}
}

Analysis

The RePopulateValues method is quite simple. All we do is retrieve the ArrayList that is stored inside the Session object. After checking that the ArrayList is not null and contains some items, we iterate through the GridView control row by row. If the ArrayList contains the primary key of the row, then it means that row should have its CheckBox in a checked state. This is done by using the Contains method of the ArrayList. If the ArrayList contains the primary key, then we extract the control using the row.FindControl method and assign its checked property to true.

Implementing GridView Page_IndexChangingEvent

The last thing that we need to implement is the Page_IndexChangingEvent of the GridView control. Page_IndexChangingEvent is fired whenever paging occurs. The implementation of this method is given below.

Listing 6: GridView Page_IndexChanging Event

protected void GridView1_PageIndexChanging(object sender, GridViewPageEventArgs e)
{
RememberOldValues();
GridView1.PageIndex = e.NewPageIndex;
BindData();
RePopulateValues();
}

Analysis

The above method first calls RememberOldValues so that all primary keys of the checked CheckBoxes will be saved in a Session object. Next ,the page goes to the new GridView page, and finally, we populate the CheckBoxes using the RePopulateValues method.

System.Net.FtpWebRequest ftpClient=System.Net.FtpWebRequest.Create(“ftp://Yoursite.com/yourdirectory/”+”Filename”);
ftpClient.Credentials = new System.Net.NetworkCredential(“loginname”, “password”);
ftpClient.Method=System.Net.WebRequestMethods.Ftp.UploadFile;
ftpClient.UseBinary=true;
System.IO.FileInfo fi= new System.IO.FileInfo(“Local FilePath to be Uploaded”);
ftpClient.ContentLength=fi.Length;
int bufferSize=2048;
byte[] content= new byte[bufferSize-1];
int dataread;
System.IO.FileStream fs=fi.OpenRead();
try
{
}
catch (Exception ex)
{
System.IO.Stream rs=ftpClient.GetRequestStream();
do{
dataread=fs.Read(content,0,bufferSize);
rs.Write(content,0,dataread);
}while(dataread}

finally
{
fs.Close();
}

public static void Create_Thumbnails(int size, string FilePath, string ThumbPath)
{// create an image object, using the filename we just retrieved
System.Drawing.Image image = System.Drawing.Image.FromFile(FilePath);
try{int thumbHeight, thumbWidth;
decimal h = image.Height;
decimal w = image.Width;
if (image.Height > image.Width){thumbHeight = size;
decimal tWidth = (w / h) * thumbHeight;
thumbWidth = Convert.ToInt32(tWidth);
}
else
{
thumbWidth = size;
decimal tHeight = (h / w) * thumbWidth;
thumbHeight = Convert.ToInt32(tHeight);
}// create the actual thumbnail image
System.Drawing.Image thumbnailImage = image.GetThumbnailImage(thumbWidth, thumbHeight, null, IntPtr.Zero);
image.Dispose();// put the image into the memory stream
thumbnailImage.Save(ThumbPath, System.Drawing.Imaging.ImageFormat.Jpeg);
}
catch (Exception ex){image.Dispose();throw ex;}
}

This article describes a quick and simple approach to creating a custom web control used to display Microsoft Visio files within an ASP.NET page using Internet Explorer. 

It is entirely possible to code the page to display a Visio diagram without using a custom control, having the control handy simplifies the process to the point where someone using it need only drop it onto the page and set a file path property within the IDE (or at runtime) to bring the Visio diagram into the page.

Further, it is possible to open a Visio file directly into Microsoft Internet Explorer; to do this, one need only create hyperlink and set it to navigate directly to the Visio file. Of course Visio files may also be converted to a web page or image format and displayed as images added to a web page. The only advantage to using a custom control is that it allows the developer to build a page and add the Visio file to that page as content rather than to merely open the diagram as a standalone page. Also, if the Visio diagram is converted to an image, the image will not have the control options available (e.g., scrolling, panning, etc.) when viewing the diagram in the control.

Getting Started:

In order to get started, open up the Visual Studio 2005 IDE and start a new project. From the new project dialog (Figure 1), under project types, select the “Windows” node from beneath “C#”, then select the “Web Control Library” template in the right hand pane. Key in a name for the project and then click “OK”.

Once the project has opened; right click on the solution and click on the “Add” menu option, and then select “New Item”. When the “Add New Item” dialog appears (Figure 2), select the “Web Custom Control” template, after selecting the template, key “ShowVisio.cs” into the name field and then click “Add” to close the dialog. You may now delete the default web control that was created  when the project was originally initialized from the template.

At this point, we should have an open web control library project with a single web control named “ShowVisio.cs” in that project. One last step prior to writing the code for this project will be to add in one needed reference. To add this reference, right click on the references folder in the solution explorer and then click on the “Add Reference” menu option. When the “Add Reference” dialog opens, select the .NET tab, and search down the list until you find the “System.Design” reference. Select this library and click on the “OK” button.

Figure 1:  Visual Studio 2005 New Project Dialog

Figure 2: Add New Item DialogCode:  Show Vision Control

Navigate back to the “ShowVisio.cs” file and, at the top of the file, add in the import statement highlighted below:

using System;using System.Collections.Generic;using System.ComponentModel;using System.Text;using System.Web;using System.Web.UI;using System.Web.UI.WebControls;using System.Web.UI.Design; namespace IEWebObjects{     [ToolboxData("<{0}:ShowVisio runat=server></{0}:ShowVisio>")]    public class ShowVisio : WebControl    {We are now ready to add the code necessary to make this control functional. First off, we need to create a single private member variable; this variable will be used to contain the path to the Visio diagram file that the user wants to pass to the control. To accomplish this step, create a “Declarations” region and key in the following variable declaration:#Region “Declarations”     Private mFilePath As String #End Region

Once the variable is declared, we  will need to provide a public property to expose the control property to the control user; in order to accomplish this step, create a “Properties” region and key in the following code:

#region “Properties”     [Category("Source File")]    [Browsable(true)]    [Description("Set path to source file.")]    [Editor(typeof(System.Web.UI.Design.UrlEditor),     typeof(System.Drawing.Design.UITypeEditor))]    public string FilePath    {        get        {            return mFilePath;        }        set        {            if(value == string.Empty)            {                mFilePath = string.Empty;            }            else            {                int tilde = -1;                tilde = value.IndexOf(‘~’);                if(tilde != -1)                {                    mFilePath = value.Substring((tilde + 2)).Trim();                }                else                {                    mFilePath = value;                }            }        }    }   // end FilePath property 

#endregion

Note that, in the attributes section, the code specifies an editor and further that the editor specified is defined as the URL Editor. Adding this attribute to the control specifies to the IDE how the property is to be edited; in this instance, when the control user sets the File Path property for the control, the property grid will display a button with an ellipsis in it at the right hand side of the text box. If the user clicks on the button, the IDE will open the URL editor and will permit the user to use that editor to navigate to the SWF file and set the File Path property through that editor’s dialog. Properties set in this manner will be persisted within the control user’s project. 

Notice also that the set side of the property strips the tilde character from the beginning of any file path sent to the property; if the value does not contain a tilde, the property is set to contain the path as it is sent. The control will not work if the tilde is left in place as it will not be able to locate the file.

At this point, the only thing left to do is to define how the control will be rendered. To complete this step, create a “Rendering” region and within this region, override the RenderContents sub with the following code:

#region “Rendering”     protected override void RenderContents(HtmlTextWriter writer)    {        try        {            StringBuilder sb = new StringBuilder();            sb.Append(“<object classid=clsid:279D6C9A-652E-4833-BEFC-312CA8887857  id=vviewer “);            sb.Append(“codebase=http://download.microsoft.com/download/              4/5/2/452f8090-413f-408f-83c0-edd66db786ee/vviewer.exe Width = “ +             Width.Value.ToString() + ” Height = “ + Height.Value.ToString() +  ” > “);            sb.Append(“<param name=SRC value=” + FilePath.ToString() + “> “);            sb.Append(“<param name=HighQualityRender value=1> “);            sb.Append(“<param name=BackColor value=#000000> “);            sb.Append(“<param name=PageColor value=#000000> “);            sb.Append(“<param name=PageVisible value=1> “);            sb.Append(“<param name=AlertsEnabled value=1> “);            sb.Append(“<param name=ContextMenuEnabled value=1> “);            sb.Append(“<param name=GridVisible value=1> “);            sb.Append(“<param name=PropertyDialogEnabled value=1> “);            sb.Append(“<param name=ScrollbarsVisible value=1> “);            sb.Append(“<param name=ToolbarVisible value=1> “);            sb.Append(“<param name=CurrentPageIndex value=1> “);            sb.Append(“<param name=Zoom value=-1> “);            sb.Append(“</object>”);            writer.RenderBeginTag(HtmlTextWriterTag.Div);            writer.Write(sb.ToString());            writer.RenderEndTag();        }        catch        {            // with no properties set, this will render “Display Visio Control”                               // in a box on the page            writer.RenderBeginTag(HtmlTextWriterTag.Div);            writer.Write(“Display Visio Control”);            writer.RenderEndTag();        }  // end try-catch    }   // end RenderContents 

#endregion

Within this code there are a few things worth looking at; first, you can see how the embedded object tag is created  and it does not take too much imagination to figure out that you can embed any valid object using this same approach. The string builder collects three variables from the control, the File Path is passed to the object’s source  and the controls height and width are also collected and passed to the object tag. The rest of the parameters are canned in this demonstration but could be replaced with additional properties which could also be set at design time if so desired.

The height and width of the control are set using the height and width properties of the web control; no additional properties were added in order to support setting the height and width. In use, the developer using the control could set the control’s height and width property to any fixed or percentage value and when rendered, the control will expand to fill the available size.

Having defined the contents of the object tag, the only detail remaining is to put the control on the rendered page. This is accomplished in the three lines following the definition of the string builder:

writer.RenderBeginTag(HtmlTextWriterTag.Div);
writer.Write(sb.ToString());
writer.RenderEndTag();

The control is now complete. Prior to testing the control, rebuild the project. Once that has been completed and any errors encountered are repaired, it is time to test the control. To test the control, add a new web site project to the web control library project currently open. Once the test web site has been created, set the test project as the start up project by right clicking on the web site solution in the solution explorer and selecting the “Set as Start Up Project” menu option. Next, locate the Default.aspx page in the web site solution, right click on this page and select the “Set as Start Page” menu option.

Open the Default.aspx page for editing. Locate the newly created control in the toolbox (it should be at the top) and drag the “ShowVisio” control onto the page (Figure 3).

Figure 3: Custom Control in Toolbox 

You may now click on the “ShowVisio” control and set its height, width, and file path properties. If you are working with the demo project included with the download, there is a Visio folder with two Visio diagrams included in that folder. You can set the file path property to point to one of these files.

The demo project also includes a hyperlink, you can point the NavigateUrl property to the other Visio diagram. Internet Explorer will open Visio diagrams into a new web page but the web page will contain only the Visio diagram. If you just want to display a plain diagram without controlling the appearance of the web page containing the diagram, then this an easier way to get there. If you want to display the diagram in a formatted page, then the use of the custom control is a better way to go about it.

Build the application and run it; you should now be looking at a Visio diagram displayed within the custom control (Figure 4).

Figure 4: Visio Displayed in the Custom Control Summary

This example project demonstrated an approach to displaying a Visio diagram within a custom control embedded into a web page. It is possible to navigate directly to a Visio diagram from Internet Explorer and Internet Explorer will attempt to render the diagram in the Visio viewer control if possible. This functionality is not supported in non-Microsoft browsers however, when browsers such as FireFox encounter the diagram, they prompt the user to download the file where it may be viewed locally but any user with Visio installed (in Internet Explorer).

While Internet Explorer can navigate to and display a Visio file; packaging the Visio Viewer control up as a custom control allows the developer using the control the option of embedding the control into a formatted and populated web page.

using System.Web;

using System.Net.Mail;

Thats all..and then..

1)How do you send a simple plain text email ?

//create the mail message
MailMessage mail = new MailMessage();//set the addresses
mail.From = new MailAddress("me@mycompany.com");
mail.To.Add("you@yourcompany.com");//set the content
mail.Subject = "This is an email";
mail.Body = "this is a sample body";//send the message
SmtpClient smtp = new SmtpClient("127.0.0.1");
smtp.Send(mail);The above code is provided in C# and should be written in the back end file (default.aspx.cs)

//create the mail message
 MailMessage mail = new MailMessage();//set the addresses
 mail.From = new MailAddress("me@mycompany.com");
 mail.To.Add("you@yourcompany.com");//set the content
 mail.Subject = "This is an email";
 mail.Body = "this is a sample body with html in it. This is bold This is blue";
 mail.IsBodyHtml = true;//send the message
 SmtpClient smtp = new SmtpClient("127.0.0.1");
 smtp.Send(mail);
The above code should also be in (default.aspx.cs) file.

static void AttachmentFromFile()
{
//create the mail message
MailMessage mail = new MailMessage();//set the addresses
mail.From = new MailAddress("me@mycompany.com");
mail.To.Add("you@yourcompany.com");//set the content
mail.Subject = "This is an email";
mail.Body = "this content is in the body";