AJAX call within the same page

There is a way you can trick the code behind on an aspx page into believing it's a web service.

Example

First set up your code behind like so:


using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.Services;

namespace PostAuthenticateRequestModule
{
public class SignOut : Page
{

[WebMethod]
public static string GetServerTime()
{
return DateTime.Now.ToString();
}
}
}

And then your ASPX page goes something like this:

ASP.NET 2.0 ObjectDataSource Madness

Ok so after several days and nights of torment, I have learnt quite a lot about GridView controls and binding (or not, as the case may be) to them.


You thought with .NET 2.0 that all your data binding woes had been answered. Oh how very wrong you were, you poor, poor developer (emphasis on poor; these are hard times, what with house prices soaring and whatnot).

It is true to say that you can use an ObjectDataSource in conjunction with a GridView control to present data to the user in a nice tabular format, though you are not likely to achieve this without a) pain b) coffee and c) (in extreme cases) a near-death experience.

Here are some brief and scattered notes on my experiences whilst attempting to use Object Data Sources:

- Update methods can get easily out of synch. There is a hack-around/fix for this - use the ODS 'OnUpdating' method, like so:

//protected void DtypesODS_Updating(object source, ObjectDataSourceMethodEventArgs e)
{
// Modify input parameters because ODS is too dumb to figure it out.
if (e.InputParameters.Contains("DType"))
e.InputParameters.Remove("DType");
}

And obviously add a ref to that in your aspx, or initialise the event by overriding OnInit.

[More to come.]

Using A Class From A Seperate Assembly With An ObjectDataSource

First, add a reference to the assembly at the top of the page:

<%@ Register TagPrefix="MyAssembly" Namespace="MyAssembly.Data" Assembly="MyAssembly, Version=1.0.0.1, Culture=neutral, PublicKeyToken=zj1251fcc32b5cg6" %>

Now set the ObjectDataSource's "TypeName" property to the specific class:

TypeName="MyAssembly.Data.MyDataClass"

Now right click on the object data source in design view and select 'Configure Data Source' and you'll see the methods on your class to choose from.

ASP.NET 2.0 - Some Basic Things To Remember

- When you want to use simple binding with no evaluation:

# Bind("MyFieldName")

- When you want to use evaluation, for example a value against a protected method, use:

# IsLead(Eval("Lead"))

Code behind:
protected string IsLead(object val)
{
if (val.ToString() == "True")
return "Yes";
else
return String.Empty;
}

Sharepoint rollup web parts

I've recently been working with Sharepoint 2007 on a large scale project. A common requirement for many Sharepoint-enabled web portals is to create what is termed as a 'rollup' of data. In a nutshell, this entails the amalgamation of one or more Sharepoint 'Lists' - e.g. Tasks, Shared Documents, etc. But not simply an amalgamation of that data on one level - For if, as is commonly the case, you have set up sub-sites underneath your top level site, then you'll want to collect data from the lists within those sites too. The term associated with this bundling of site and sub-sites' data is known as a rollup.

One of the requirements for the portal I've been working on was to create a rollup webpart of all the Tasks lists across the entire site collection. Using VS.NET, I created the following WebPart-derived class and deployed it to the Sharepoint server.

    1 using System;

    2 using System.Runtime.InteropServices;

    3 using System.Web.UI;

    4 using System.Web.UI.WebControls.WebParts;

    5 using System.Xml.Serialization;

    6 

    7 using Microsoft.SharePoint;

    8 using Microsoft.SharePoint.WebControls;

    9 using Microsoft.SharePoint.WebPartPages;

   10 

   11 using System.Xml;

   12 using System.Xml.Xsl;

   13 using System.IO;

   14 using System.Text;

   15 

   16 using System.Data;

   17 

   18 namespace Custom.WebParts

   19 {

   20     [Guid("9e209402-e946-4070-b869-3faa90a92513")]

   21     public class TasksRollUp : System.Web.UI.WebControls.WebParts.WebPart

   22     {

   23         // Private vars.

   24         private string strCulture = "en-GB";

   25         private string strUserOrGroup = "Context"; // by default, base the results on the user in context.

   26 

   27         // Checkbox private vars.

   28         private bool bStatusNotStarted = true;

   29         private bool bStatusInProgress = true;

   30         private bool bStatusCompleted = true;

   31         private bool bStatusDeferred = true;

   32         private bool bStatusWaitingOnSomeoneElse = true;

   33 

   34 

   35         /// <summary>

   36         /// The main method to write to the UI.

   37         /// </summary>

   38         /// <param name="writer"></param>

   39         protected override void Render(HtmlTextWriter writer)

   40         {

   41             string results = LoadTasks();

   42             writer.Write(results);

   43         }

   44 

   45         /// <summary>

   46         /// Loads 'All My Tasks'.

   47         /// </summary>

   48         private string LoadTasks()

   49         {

   50             // Knock up a SPSiteDataQuery object and detail the CAML query.

   51             bool applyContextOrGroup = (this.UserOrGroup == "") ? false : true;

   52 

   53             string user = "";

   54             if (this.UserOrGroup.ToLower() == "context")

   55                 user = SPContext.Current.Web.CurrentUser.Name;

   56             else

   57                 user = this.UserOrGroup;

   58 

   59             SPSiteDataQuery q = new SPSiteDataQuery();

   60 

   61             if (!applyContextOrGroup)

   62             {

   63                 q.ViewFields = "<FieldRef Name=\"ID\" /><FieldRef Name=\"Title\" /><FieldRef Name=\"Created\" /><FieldRef Name=\"Body\" />";

   64                 q.Lists = "<Lists ServerTemplate=\"107\"/>";

   65                 q.Webs = "<Webs Scope=\"Recursive\"/>";

   66                 q.Query = "<Where><Eq><FieldRef Name=\"ID\"/><Value Type=\"String\">1</Value></Eq></Where>";

   67             }

   68             else if (applyContextOrGroup == true && user == "context")

   69             {

   70                 q.ViewFields = "<FieldRef Name=\"ID\" /><FieldRef Name=\"Title\" /><FieldRef Name=\"Created\" /><FieldRef Name=\"Body\" />";

   71                 q.Lists = "<Lists ServerTemplate=\"107\"/>";

   72                 q.Webs = "<Webs Scope=\"Recursive\"/>";

   73                 q.Query = "<Where><And><Eq><FieldRef Name=\"ID\" /><Value Type=\"Counter\">1</Value></Eq><Eq><FieldRef Name=\"AssignedTo\" /><Value Type=\"User\">" + user + "</Value></Eq></And></Where>";

   74             }

   75             else

   76             {//GROUPS.

   77                 q.ViewFields = "<FieldRef Name=\"ID\" /><FieldRef Name=\"Title\" /><FieldRef Name=\"Created\" /><FieldRef Name=\"Body\" />";

   78                 q.Lists = "<Lists ServerTemplate=\"107\"/>";

   79                 q.Webs = "<Webs Scope=\"Recursive\"/>";

   80                 q.Query = "<Where><Eq><FieldRef Name=\"AssignedTo\" /><Value Type=\"User\">" + user + "</Value></Eq></Where>";

   81             }

   82 

   83             DataTable dt = null;

   84             SPWeb w = SPContext.Current.Web;

   85             // Load ALL 'My' tasks from across ALL sites.

   86             dt = w.GetSiteData(q);

   87 

   88             w = null;

   89 

   90             if (dt.Rows.Count == 0)

   91                 return "No tasks to view on this level.";

   92 

   93             DataSet ds = new DataSet();

   94             ds.Tables.Add(dt);

   95 

   96             string xml = ds.GetXml();

   97 

   98             // Format the data.

   99             xml = System.Text.RegularExpressions.Regex.Replace(xml, "&lt;", "<");

  100             xml = System.Text.RegularExpressions.Regex.Replace(xml, "&gt;", ">");

  101 

  102             // XSL parameter list.

  103             XsltArgumentList oArgList = new XsltArgumentList();

  104 

  105             // Site ID is based on SPContext.

  106 

  107 #if DEBUG

  108             oArgList.AddParam("SiteId", "", "2352352"); // FOR TEST.           

  109 #else

  110             oArgList.AddParam("SiteId", "", SPContext.Current.Site.ID.ToString());

  111 #endif

  112             // Set the culture, based on the setting. (Default to site wide culture setting).

  113             oArgList.AddParam("Culture", "", this.Culture);

  114 

  115             string outHtml = XslTransform(xml, "/", "Shared Documents", "TaskList.xsl", oArgList);

  116             return outHtml;

  117         }

  118 

  119         public CustomDocument GetDocument(string fileName, string pathWeb, string listName)

  120         {

  121             SPSite gSite = null;

  122             SPWeb gWeb = null;

  123             SPList gList;

  124             CustomDocument bdoc = new CustomDocument();

  125             try

  126             {

  127                 // If the Path web is passed in then use it to find the list otherwise use current context               

  128 #if DEBUG

  129                 //FOR TEST.

  130                 SPSite s = new SPSite("http://localhost");

  131                 gSite = s;

  132 #else

  133                 // gSite = SPContext.Current.Site; // Doesn't work. Mais pourquoi?

  134                 SPSite s = new SPSite("http://localhost");

  135                 gSite = s;

  136 #endif

  137                 gWeb = gSite.AllWebs[pathWeb];

  138                 gList = gWeb.Lists[listName];

  139 

  140                 foreach (SPListItem item in gList.Items)

  141                 {

  142                     if (item.Title.ToLower() == fileName.ToLower())

  143                     {

  144                         byte[] xmlfile = item.File.OpenBinary();

  145                         System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();

  146 

  147                         bdoc.Body = enc.GetString(xmlfile);

  148                         bdoc.DocumentID = item.UniqueId.ToString();

  149                         bdoc.list = gList.ID.ToString();

  150                         //bdoc.CheckedOutTo = item.File.CheckedOutBy.ToString();

  151                     }

  152                 }

  153                 return bdoc;

  154             }

  155             catch (Exception ex)

  156             {

  157                 bdoc.Body = ex.Message.ToString();

  158                 return bdoc;

  159             }

  160             finally

  161             {

  162 

  163                 if (gSite != null)

  164                     gSite.Dispose();

  165 

  166                 if (gWeb != null)

  167                     gWeb.Dispose();

  168             }

  169         }

  170 

  171         /// <summary>

  172         /// Perform an XSL transform.

  173         /// </summary>

  174         /// <param name="xml">The raw XML to use</param>

  175         /// <param name="xsl">The XSL document name</param>

  176         /// <param name="sharepointPath">The Sharepoint path</param>

  177         /// <param name="sharepointList">The Sharepoint list name</param>

  178         /// <param name="parameters">A list of XSL parameters</param>

  179         /// <returns></returns>

  180         public string XslTransform(string xml, string sharepointPath, string sharepointList, string xsl, XsltArgumentList parameters)

  181         {

  182             // Get the TaskList.xsl file from Sharepoint.

  183             CustomDocument oDoc = GetDocument(xsl, sharepointPath, sharepointList);

  184 

  185             TextReader trXSL;

  186             trXSL = new StringReader(oDoc.Body);

  187 

  188             // Load up a reader object with the contents of the XSL.

  189             XmlReader xrXSL = XmlReader.Create(trXSL);

  190 

  191             StringBuilder sbHTML = new StringBuilder(); // Used for HTML to be returned.

  192 

  193             // Load up an XMLDocument object with the incoming XML...

  194             XmlDocument xDoc = new XmlDocument();

  195             xDoc.LoadXml(xml);

  196 

  197             // Create an XMLWriter object based on the string builder.

  198             XmlWriter xwHTML = XmlWriter.Create(sbHTML);

  199 

  200             // Perform the conversion.

  201             XslCompiledTransform xsltTransform = new XslCompiledTransform();

  202             xsltTransform.Load(xrXSL);

  203 

  204             try

  205             {

  206                 // Attempt the transform.

  207                 xsltTransform.Transform(xDoc, parameters, xwHTML);

  208             }

  209             catch (IOException ioEx)

  210             {

  211                 throw ioEx;

  212             }

  213             catch (Exception ex)

  214             {

  215                 throw ex;

  216             }

  217             finally

  218             {

  219                 // Write the results to file.

  220                 xwHTML.Flush();

  221                 xwHTML.Close();

  222 

  223                 // Clean up.

  224 

  225                 trXSL.Close();

  226                 trXSL.Dispose();

  227 

  228                 xrXSL.Close();

  229             }

  230 

  231             return sbHTML.ToString();

  232         }

  233 

  234 

  235         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  236         [WebBrowsable(true), Personalizable(true)]

  237         [WebDescription("What is the culture? Choose for the time being from two options: the default 'en-GB' or 'en-US'")]

  238         [WebDisplayName("Active Culture")]

  239         [System.ComponentModel.Category("Custom Settings")]

  240         public string Culture

  241         {

  242             get

  243             {

  244                 return strCulture;

  245             }

  246             set

  247             {

  248                 strCulture = value;

  249             }

  250         }

  251 

  252         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  253         [WebBrowsable(true), Personalizable(true)]

  254         [WebDescription("Base the task list that is generated on the user in context (type 'Context') - e.g. show only tasks assigned to the user in context, or specify a group name, e.g. 'Administrators'")]

  255         [WebDisplayName("Filter by User or Group")]

  256         [System.ComponentModel.Category("Custom Settings")]

  257         public string UserOrGroup

  258         {

  259             get

  260             {

  261                 return strUserOrGroup;

  262             }

  263             set

  264             {

  265                 strUserOrGroup = value;

  266             }

  267         }

  268 

  269         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  270         [WebBrowsable(true), Personalizable(true)]

  271         [WebDescription("Tick to show/hide tasks that have not been started.")]

  272         [WebDisplayName("Not started")]

  273         [System.ComponentModel.Category("Task Status")]

  274         public bool NotStarted

  275         {

  276             get

  277             {

  278                 return bStatusNotStarted;

  279             }

  280             set

  281             {

  282                 bStatusNotStarted = value;

  283             }

  284         }

  285 

  286         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  287         [WebBrowsable(true), Personalizable(true)]

  288         [WebDescription("Tick to show/hide tasks that are in progress.")]

  289         [WebDisplayName("In progress")]

  290         [System.ComponentModel.Category("Task Status")]

  291         public bool InProgress

  292         {

  293             get

  294             {

  295                 return bStatusInProgress;

  296             }

  297             set

  298             {

  299                 bStatusInProgress = value;

  300             }

  301         }

  302 

  303         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  304         [WebBrowsable(true), Personalizable(true)]

  305         [WebDescription("Tick to show/hide tasks that have been completed.")]

  306         [WebDisplayName("Completed")]

  307         [System.ComponentModel.Category("Task Status")]

  308         public bool Completed

  309         {

  310             get

  311             {

  312                 return bStatusCompleted;

  313             }

  314             set

  315             {

  316                 bStatusCompleted = value;

  317             }

  318         }

  319 

  320         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  321         [WebBrowsable(true), Personalizable(true)]

  322         [WebDescription("Tick to show/hide tasks that have been deferred.")]

  323         [WebDisplayName("Deferred")]

  324         [System.ComponentModel.Category("Task Status")]

  325         public bool Deferred

  326         {

  327             get

  328             {

  329                 return bStatusDeferred;

  330             }

  331             set

  332             {

  333                 bStatusDeferred = value;

  334             }

  335         }

  336 

  337         [WebPartStorage(Storage.Shared), System.Xml.Serialization.XmlElement(Namespace = "http://localhost")]

  338         [WebBrowsable(true), Personalizable(true)]

  339         [WebDescription("Tick to show/hide tasks that are waiting on someone else.")]

  340         [WebDisplayName("Waiting on someone else")]

  341         [System.ComponentModel.Category("Task Status")]

  342         public bool WaitingOnSomeoneElse

  343         {

  344             get

  345             {

  346                 return bStatusWaitingOnSomeoneElse;

  347             }

  348             set

  349             {

  350                 bStatusWaitingOnSomeoneElse = value;

  351             }

  352         }

  353     }

  354 

  355     public class CustomDocument

  356     {

  357         public string Body;

  358         public string DocumentID;

  359         public string CheckedOutTo;

  360         public string site;

  361         public string list;

  362     }

  363 }

A Fairly Painless Way To Combine Dataset Data

foreach (DataRow dr in ds2.Tables[1].Rows)
{
object[] vals = dr.ItemArray;
ds.Tables[1].Rows.Add(vals);
}

ItemArray is key.

Using Resource Files

Recently, I had a case to use an XML embedded resource file. After adding the following XML file to the solution and setting its 'Build Action' property to 'Embedded Resource'...

<?xml version="1.0" encoding="utf-8" ?>
<Config>
    <VariablefileName>../Projects/RealEstatePostcard/PostCard.xvp</VariablefileName>
    <ProjectFileForVariableEvaluation>../Projects/RealEstatePostcard/PostCard.pf</ProjectFileForVariableEvaluation>
    <JobForVariableEvaluation>PDF_Job</JobForVariableEvaluation>
    <ShowScrollBars>Yes</ShowScrollBars>
    <BevelThickness>1</BevelThickness>
    <BevelThicknessInset>3</BevelThicknessInset>
    <BevelColorInset>lightGray</BevelColorInset>
    <BevelColorTopLeft>lightGray</BevelColorTopLeft>
    <BevelColorBottomRight>darkGray</BevelColorBottomRight>
    <uiConfiguration> PanelPostCardConfig.xml</uiConfiguration>
    <EditImage>Edit Image: Crop and Scale Your Image</EditImage>
    <bitmapUpdateMethod>xor</bitmapUpdateMethod>
</Config>

I grabbed a hold of it and set its contents against relevant public property names within my class. Like so:

private void LoadConfigValues()
        {
            // Create a new XmlDocument object and select the appropriate values.          
           
            // Reference the running assembly.
            Assembly thisAssembly = Assembly.GetExecutingAssembly();
       
            Stream oStrRead = thisAssembly.GetManifestResourceStream("Burrows.PageFlex.WYSIWYG.Config.Configuration.xml");
           

            XmlDocument xDoc = new XmlDocument();

            try
            {               
                xDoc.Load(oStrRead);
            }
            catch (IOException ioEx)
            {
                throw ioEx;
            }
            finally
            {               
                oStrRead.Close();
                oStrRead.Dispose();
            }

            // Loop through doc nodes and assign values to public properties.
            XmlNodeList oNodeList = xDoc.SelectNodes("//Config/*");
            foreach (XmlNode xN in oNodeList)
            {
                switch (xN.Name)
                {
                    case "VariablefileName":
                        this.strVariableFileName = xN.InnerText;
                        break;
                    case "ProjectFileForVariableEvaluation":
                        this.strProjectFileForVariableEvaluation = xN.InnerText;
                        break;
                    case "JobForVariableEvaluation":
                        this.strJobForVariableEvaluation = xN.InnerText;
                        break;
                    case "ShowScrollBars":
                        this.strShowScrollBars = xN.InnerText;
                        break;
                    case "BevelThickness":
                        this.strBevelThickness = xN.InnerText;
                        break;
                    case "BevelThicknessInset":
                        this.strBevelThicknessInset = xN.InnerText;
                        break;
                    case "BevelColorInset":
                        this.strBevelColorInset = xN.InnerText;
                        break;
                    case "BevelColorTopLeft":
                        this.strBevelColorTopLeft = xN.InnerText;
                        break;
                    case "BevelColorBottomRight":
                        this.strBevelColorBottomRight = xN.InnerText;
                        break;
                    case "uiConfiguration":
                        this.strUiConfiguration = xN.InnerText;
                        break;
                    case "EditImage":
                        this.strEditImage = xN.InnerText;
                        break;
                    case "bitmapUpdateMethod":
                        this.strBitmapUpdateMethod = xN.InnerText ;
                        break;
                    default:
                        break;
                };
            }          
        }

Don't Underestimate The Power Of The Alt Key

Recently, whilst doing a menacing cut and paste job, I remembered the convenience of using the Alt key when selecting text.

Take the following text, for example:

Fruit                   Crisps
=====                ======       
Strawberries        Salt And Vinegar
Apples                Cheese And Onion
Pears                  Ready Salted
Oranges              Chicken
Pineapples          Prawn Cocktail

Now, if I only want to grab hold of whatever is underneath the heading 'Crisps' then all I need to do is hold down my Alt key, hover over the area just left of the letter C and begin dragging across and down. This will select only that portion of text and will exclude whatever lies under the heading 'Fruit'.

Note that only certain programs support the use of this style of copying and pasting. So far I've successfully employed its use in both Visual Studio (2003 & 2005) and SQL Server (2000 & 2005).

How To Kill A Process That Just Won't Die

Recently when developing a Windows service, I had problems terminating something through the admin GUI. There is, fortunately though, a manual way of getting your way, via the command line.

Enum Parsing

I always seem to forget how to parse an enum, so here's the code for doing it in 2.0:

enum ConfigurationType
        {
            Internal,
            WebConfigXml,
            Win32Xml
        };

string strConfigType = System.Configuration.ConfigurationSettings.AppSettings["ConfigurationType"].ToString();
ConfigurationType configType = (ConfigurationType)Enum.Parse(typeof(ConfigurationType), strConfigType);

The ASP.NET Page Life Cycle

The ASP.NET Page Life Cycle

1. Object intialisation
2. Load Viewstate data
3. LoadPostData processes Postback data
4. Object load
5. Raise PostBack change events
6. Process Client-side Postback Event
7. Prerender the objects
8. Viewstate saved
9. Render to HTML
10. Disposal

http://www.15seconds.com/issue/020102.htm

Mod It

No, I'm not talking about altering your automobile, or bending your bike (what?). No, I'm talking about the good old fashioned Mod function of course. It took me a while to realise that the equivalent in C# is...

int result = firstNumber % secondNumber;

A Rounding Function That Really Works

public static double RoundDouble(double number,int digits)
{

string Temp;

string Temp2;

int i, j;

double ResultValue;

double Numbertemp;

Temp = Convert.ToString(number);

i = Temp.LastIndexOf(".");

if (((Temp.Length - (i + 1)) <= digits) (i == -1)) return number; Temp2 = Temp.Substring(i + digits + 1, 1); j = Convert.ToInt32(Temp2); Numbertemp = Convert.ToDouble(Temp.Substring(0, i + digits + 1)); if (j == 5) ResultValue = Numbertemp + (1 / (Math.Pow(10,digits))); else ResultValue = Math.Round(number, digits); return ResultValue; } Courtesy of

vedapuri

http://www.codeproject.com/useritems/Solving_rounding_problem.asp

When To Use Static Methods

Use static methods when the state of a class instance does not matter.

http://www.javaworld.com/javaworld/javaqa/2001-11/03-qa-1121-mrhappy.html

Another Random Web Service Error

I just got this:

"Request is not available in this context"

I discovered shortly after this is down to the web service proxy being out of synch with the content of the asmx service file itself. One to watch out for, particularly if you're creating your proxies manually and not using VS IDE.

More Teething Probs...

You may also get

"

The request failed with HTTP status 404: Not Found.

"

Again, this indicates an incorrect address.

Web Service Teething Problems

If you get the following...

"

The underlying connection was closed: The remote name could not be resolved.

"
This means you've specified an incorrect URI for the web service. Check the address and try again. Probably seems obvious, but this has caught me out several times before so this is to help me remember, if nothing else.

You may also come across....

The request failed with HTTP status 404: Not Found.

Again, incorrect address specified.

Creating A Web Service Proxy

Use the following at the .NET command prompt to create a web service proxy (note: perform this operation within the directory that contains your service file).

wsdl /l:cs /o:AppServiceProxy.cs http://localhost/MyWebService/AppService.asmx?WSDL /n:AppSettings

Using Web Response

You can the HTTP WebRequest and WebResponse objects to contact a remote server through your code, send POST data and handle a response.

Below is a method to support this activity. The example code uses a payment gateway service, sending it POST data for a payment transaction and retrieving the response.

private object ProcessHTTPRequest(IPaymentProvider provider, string POSTdata)
{
ASCIIEncoding encoding=new ASCIIEncoding();
POSTdata = "VPSProtocol=2.2&TxType=PREAUTH&amp;Vendor=MyVendor&VendorTxCode=55555&Amount=444&Currency=GBP&Description=TestDesc";
POSTdata += "&CardHolder=Test&CardNumber=000000000000&StartDate=0105&ExpiryDate=1205&IssueNumber&CV2&CardType=Visa&BillingAddress=sdklfjsdf&BillingPostCode=cmdmdm";
byte[] data = encoding.GetBytes(POSTdata);


// Create a new HTTP Web Request.
HttpWebRequest request;


try
{
System.Uri uri = new System.Uri(provider.AbsoluteUrl);
request = (HttpWebRequest)WebRequest.CreateDefault(uri);

}
catch (WebException exRequest)
{
throw exRequest;
}

// Set properties of the request object.
request.Method = "POST";
request.ContentType="application/x-www-form-urlencoded";
request.ContentLength = data.Length;

// *** WRITE THE POST DATA *** //
try
{
Stream newStream = request.GetRequestStream();
// Send the data.
newStream.Write(data, 0, data.Length);
newStream.Close();
}
catch
{}


// Create a new WebResponse object.
WebResponse response;

try
{
response = request.GetResponse();
}
catch (WebException exResponse)
{
throw exResponse;
}

string serverResponse = ""; // String for response output.

try
{
// *** READ *** //
// Get the response.
Stream responseStream = response.GetResponseStream();
// Create a stream reader from the returned stream.
StreamReader sr = new StreamReader(responseStream);
// Read the response.
serverResponse = sr.ReadToEnd();
}
catch (WebException exRead)
{
throw exRead;
}
catch (Exception genException2)
{
throw genException2;
}

// Return the response.
return serverResponse;

}

The Global Assembly Cache (GAC)

The Global Assembly Cache (GAC)

The Global Assembly Cache (GAC) is a central repository for storing shared assemblies. The GAC allows multiple versions of the same assembly to be installed concurrently and also prevents different assembly vendors from overwriting each other's assemblies.
The use of the GAC is encouraged for assemblies that will be used by more than one application on the system, and also for assemblies that are expected to be versioned in the future. When an application is launched, Mono extracts the name of the assembly, the version and its public key token and loads the required assembly from the GAC.
The GAC is a black boxed repository of assemblies capable of keeping multiple version/cultures of a same assembly. A strongname is considered a unique entry in the GAC (i.e. the GAC requires all it's assemblies to be strongnamed and signed). Note that the GAC has nothing to do with security! In fact assemblies in the GAC aren't verified when loaded from the runtime. The GAC is for manageability (avoiding DLL hell).

Source: http://www.mono-project.com/Assemblies_and_the_GAC