Send webrequest with parameter in asp.net c#

Here the below code will generate webrequest and send with parameter in asp.net C#.

Stream objStream;
StreamReader objSR;
System.Text.Encoding encode = System.Text.Encoding.GetEncoding("utf-8");

string str = "http://domaninname.com/YourPage.aspx?name=" + "abc";
HttpWebRequest wrquest = (HttpWebRequest)WebRequest.Create(str);
HttpWebResponse getresponse = null;
getresponse = (HttpWebResponse)wrquest.GetResponse();

objStream = getresponse.GetResponseStream();
objSR = new StreamReader(objStream, encode, true);
string strResponse = objSR.ReadToEnd();
Response.Write(strResponse);

How to convert string into MD5 hash?

MD5 is an acronym for Message-Digest 5-- a fast and powerful method of increasing security to file transfers and message request transfers.
The way it works is the user enters an input string, and the md5 algorithm will generate a 32-character string in hexadecimal characters. The characters will always be hexidecimal, and the string will always be 32 characters in length.
Once a string is hashed into an md5 hash, it cannot be unhashed via any "un-md5" algorithm. The only way is to use an MD5 cracker tool, which queries a large database of strings and their associated md5 hashes.
Once your md5 hash code is generated, you can deliver it to the expected receiver and they can use that hash to match against their result of performing an md5 hash on their own values. If the hashes match, then you can be confident that the data was sent correctly.

CODE :

using System.Text;
using System.Security.Cryptography;
public static string ConvertStringtoMD5(string strword)
{
 MD5 md5 = MD5.Create();
 byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(strword);
 byte[] hash = md5.ComputeHash(inputBytes);
 StringBuilder sb = new StringBuilder();
 for (int i = 0; i < hash.Length; i++)
 {
   sb.Append(hash[i].ToString("x2"));
 }
 return sb.ToString();
}

ASP.NET MVC3 Attributes

I am currently working on a project where we're porting an existing SharePoint 2010 site to ASP.NET MVC3. Coming from an ASP.NET Web Forms background, this is an interesting experience. ASP.NET MVC is quite different from the Web Forms model, with one of the biggest differences being its emphasis on "convention over configuration".

Having played with MVC2 in the past, the work on this project has been smooth sailing. I'm particularly enjoying the level of control that the MVC development model provides over the resulting HTML sent back to a users browser. The bloated HTML from the Web Forms model (quickly pointing the finger at the ViewState hidden field) is something I don't have to painfully scroll over when inspecting the generated HTML.

I particularly like how MVC makes use of attributes on action methods, things like the AuthorizeAttribute are a nice and clean way of executing repeated functionality without it really getting in the way of your usual controller or action level logic.

The main purpose of this post is therefore just for me to continuously document the useful attributes I come across. My intention is to update the table below whilst working on the project mentioned above.

Attribute Name	Notes
System.Web.Mvc.AuthorizeAttribute	Applied on actions that require the user to be authenticated. If the user is not authenticated, they are automaticallly redirected to the login page. Can also be used at the controlller (class) level - which applies it on all actions within the controller.
System.Web.Mvc.ChildActionOnlyAttribute	Applied on actions that shouldn't be invokable directly through the browser. Use this when the action returns inline HTML markup e.g. partial views. Can only be called via Action or RenderAction HTML extension methods.
System.Web.Mvc.NonActionAttribute	Use this when you don't want the MVC framework to treat a method in your controller class as an action. By default, the framework will treat all public methods in a controller as an action method.
System.Web.Mvc.OutputCacheAttribute	Used to cache the output of an action. Has a number of useful named parameters, one of which is "Duration" that lets you specify the number of seconds to cache the output for.

Ajax Auto Complete suggestion in asp.net using webservices (Ajax AutocompleteExtender)

AutoCompelete using Ajax in Asp.net 

Ajax a powerfull script on the web,It provides you a lot more functionality to
improve your application Performance.
Heres the article to show how to work with AutoCompleteExtender (Control in AjaxControlToolKIt).

AutoComplete Description

• AutoComplete is an ASP.NET AJAX extender that can be attached to any TextBox control,
  and will associate that control with a popup panel to display words that
  begin with the prefix typed into the textbox.
• The dropdown with candidate words supplied by a web service is
  positioned on the bottom left of the text box.

This means that the control will fetch the data from a webservice(sdsd), and it can be attached to a asp.net TextBox control.
Whenever users starts typing in the textbox, it automatically fetches a suggestion list from the configured webservice.

Note: Add latest Ajax dll in your application bin folder.

Step 1: Add  webservices (WebService.asmx)
code:  appcode/WebService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using System.Collections;

/// Summary description for WebService
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
[System.Web.Script.Services.ScriptService]
public class WebService : System.Web.Services.WebService {

public WebService () {
 //Uncomment the following line if using designed components
 //InitializeComponent();
}

[WebMethod]
public string[] GetNames(string prefixText, int count, string contextKey)
{
 ArrayList sampleList = new ArrayList();
 sampleList.Add("ABC"); sampleList.Add("Hello");
 sampleList.Add("Hi"); sampleList.Add("Apple");
 sampleList.Add("Hey");
 ArrayList filteredList = new ArrayList();
 foreach (string s in sampleList){
  if (s.ToLower().StartsWith(prefixText.ToLower()))
   filteredList.Add(s);
 }
 return (string[])filteredList.ToArray(typeof(string));
 }
}

Step 2: AC.aspx page:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Ac.aspx.cs" Inherits="Ac" %>

<%@  Register Assembly="AjaxControlToolkit" Namespace="AjaxControlToolkit" TagPrefix="Ajaxtoolkit"  %>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server"></head>
 <body>

  <form id="form1" runat="server">
    <asp:scriptmanager id="ScriptManager1" runat="server"></asp:scriptmanager>
   <div>
        <asp:textbox id="TextBox1" runat="server"></asp:textbox>
          <ajaxtoolkit:autocompleteextender enabled="true" minimumprefixlength="0" runat="server" servicemethod="GetNames" servicepath="WebService.asmx" targetcontrolid="TextBox1" usecontextkey="true">
        </ajaxtoolkit:autocompleteextender>
    </div>
</form>
</body>
</html>

Save and retrive Binarydata from database into image

How to Save and Retrive BinaryData from Database into Image

This article will demonstrate how to display/store and retrieve image data from an SQL database to aspx page. First we have to add generic handler.

Create an ashx page that you'll target as an image URL.Then you need to write the byte array as response stream in the ProcessRequest method inside that handler as show in below code snippet.

ShowImage.ashx

%@ WebHandler Language="C#" Class="ShowImage" %>

using System;
using System.Configuration;
using System.Web;
using System.IO;
using System.Data;
using System.Data.SqlClient;
public class ShowImage : IHttpHandler
{
  public void ProcessRequest(HttpContext context)
   {
      Int32 empno;
        if (context.Request.QueryString["id"] != null)
           empno = Convert.ToInt32(context.Request.QueryString["id"]);
        else
           throw new ArgumentException("No parameter specified");
       context.Response.ContentType = "image/jpeg";
       Stream strm = ShowEmpImage(empno);
       byte[] buffer = new byte[4096];
       int byteSeq = strm.Read(buffer, 0, 4096);
       while (byteSeq > 0)
       {
         context.Response.OutputStream.Write(buffer, 0, byteSeq);
         byteSeq = strm.Read(buffer, 0, 4096);
       }      
    }
 
   public Stream ShowEmpImage(int empno)
   {  string conn = ConfigurationManager.ConnectionStrings["ConnString"].ConnectionString;
       SqlConnection connection = new SqlConnection(conn);
       string sql = "SELECT* FROM  table WHERE empid = @ID";
       SqlCommand cmd = new SqlCommand(sql,connection);
       cmd.CommandType = CommandType.Text;
       cmd.Parameters.AddWithValue("@ID", empno);
       connection.Open();
       object img = cmd.ExecuteScalar();
       try
       {
         return new MemoryStream((byte[])img);
       }
        
 catch 
  { return null; }
        
 finally 
  { connection.Close(); }
     }
   public bool IsReusable
   {
        get { return false;  }
   }
}

Default page.aspx.cs

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

public partial class _Default : System.Web.UI.Page
{
protected void btnSubmit_Click(object sender, EventArgs e)
{
 SqlConnection connection = null;
try
 {
 FileUpload img = (FileUpload)imgUpload;
 Byte[] imgByte = null;
 if (img.HasFile && img.PostedFile != null)
 {
 //To create a PostedFile
 HttpPostedFile File = imgUpload.PostedFile;
 //Create byte Array with file len
 imgByte = new Byte[File.ContentLength];
 //force the control to load data in array
 File.InputStream.Read(imgByte, 0, File.ContentLength);
 }
 // Insert the employee name and image into db
  string conn = ConfigurationManager.ConnectionStrings["ConnString"].ConnectionString;
  connection = new SqlConnection(conn);
  connection.Open();
  string sql = "INSERT INTO 
  table(empname,empimg) VALUES(@enm, @eimg) SELECT @@IDENTITY";
  SqlCommand cmd = new SqlCommand(sql, connection);
  cmd.Parameters.AddWithValue("@enm", txtEName.Text.Trim());
  cmd.Parameters.AddWithValue("@eimg", imgByte);
  int id = Convert.ToInt32(cmd.ExecuteScalar());
  lblResult.Text = String.Format("Employee ID is {0}", id);

  // Display the image from the database
  Image1.ImageUrl = "~/ShowImage.ashx?id=" + id;
 }
 catch
 {
 lblResult.Text = "There was an error";
 }
finally { connection.Close(); }
 }
}

NDataFlow - Open Source .NET Dataflow Library

Last year, a colleague of mine showed me an open source .NET extract, transform and load (ETL) helper library that he's working on. It is called NDataFlow and allows you to annotate methods with attributes to create a dataflow in your application. It's a nice lightweight library that you can use whenever you are developing simple or complex ETL programs. The example below simulates a very simple ETL scenario where a set of people (hard-coded in the example) are filtered based on their location and then output to a file.

class Program : DataflowComponent
{
  static void Main(string[] args)
  {
    new Program().Run();
  }

  //First method in the flow
  [Operation]
  public void DataSource(Output output)
  {
    //Imagine retrieving people from a real data source
    //e.g. database, xml file, csv file, etc.
    output.Emit(new Person() { Name = "Alice", City = "London" });
    output.Emit(new Person() { Name = "Bob", City = "New York" });
    output.Emit(new Person() { Name = "Foo", City = "London" });
    output.Emit(new Person() { Name = "Bar", City = "Sydney" });
  }

  [Operation]
  public IEnumerable FilterForLondonPeople
    ([Link("DataSource")] IEnumerable input)
  {
    return input.Where
      (p => p.City.Equals("London", 
        StringComparison.InvariantCultureIgnoreCase));
  }

  [Operation]
  public void OutputResults
    ([Link("FilterForLondonPeople")] IEnumerable results)
  {
    using (var sw = new StreamWriter(@"C:\LondonPeople.txt", false)
    {
      foreach (var p in results)
        sw.WriteLine("{0} {1}", p.Name, p.City);
    }
  }
}

The example shows that there is little work needed to get a simple dataflow setup and running. You inherit the Run method by deriving from the NDataFlow.DataflowComponent class. Then, if you've setup your method and attributes correctly using the LinkAttribute it's a simple case of calling Run to start your dataflow. In this case, the first method in the dataflow would be DataSource, whose output is sent to FilterForLondonPeople and finally whose output is sent to the OutputResults method.

Fluent Interface in C#

I've seen a number of API's now that utilise a "fluent" interface (e.g., Fluent NHibernate, Moq etc.). So far, I've had mixed feelings about it. If you're not familiar with what a fluent interface is, then Martin Fowler's post on this subject is a good starting point. By following a fluent design, you get some neat looking "client-side" code that is almost self-describing. The following example models a real-world person and exposes a fluent interface.

public class Person
{
    public string FirstName { get; private set; }
    public string Surname { get; private set; }

    private Person() { }

    public static Person New()
    {
        return new Person();
    }

    public Person SetFirstName(string firstName)
    {
        this.FirstName = firstName;
        return this;
    }

    public Person SetSurname(string surname)
    {
        this.Surname = surname;
        return this;
    }

    public override string ToString()
    {
        return string.Format(
            "I am {0} {1}",
                this.FirstName,
                    this.Surname);
    }
}

As the code snippet shows, each setter method in the Person class returns a reference to the "current" object (think context/state). This is important as it permits users of the class to chain method calls on the object, with each invocation returning an up-to-date state of the original object. For example, we can create an instance of Person and then set its state in one single C# statement:

var person = Person.New()
    .SetFirstName("Ravi")
        .SetSurname("Singh");

This looks neat and is very readable. Without a fluent interface, you may have code that looks somewhat like:

var person = new Person();
person.FirstName = "Ravi";
person.Surname = "Singh";

Of course, you could use the object initialiser syntax or pass the names through to an appropriate constructor, but that's not the point. The point is that you don't get the same readability or fluentness that you get using method chaining. If your methods are named properly, then using the fluent technique makes reading your code closer to reading a sentence in natural language.

I personally prefer the fluent version. Earlier in the post, I mentioned that I had a mixed feeling - this mainly stems from the fact that it becomes difficult to debug code that uses a fluent interface. For example, if you have a statement in which a number of method calls are chained on an object, it's difficult to see the intermediary values returned by each method unless you step into each method call. This can be a bit of a pain when debugging. Other than this one problem, I've enjoyed working with fluent-based API's and will strive to write classes in a more "fluent" way.