HTML XML and Internet

How to connect to FTP Server and get a Directory Listing

2009-05-30T08:52:00.002-07:00

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.IO;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create("ftp://ftp.microsoft.com");

//Set username and password for the FTP Server
NetworkCredential c = new NetworkCredential("anonymous", "thisisme@hotmail.com");
request.Credentials = c;

//Set the command to get the directory listing. If you want to do something else
//this is the place to look, the enumeration has many different operations.
request.Method = WebRequestMethods.Ftp.ListDirectory;

//Go go gadget!
FtpWebResponse response = (FtpWebResponse)request.GetResponse();

//Read the results and spit em at the console
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
string text = reader.ReadLine();

while(text!=null)
{
Console.WriteLine(text);
text = reader.ReadLine();
}
}
}
}
}

Format/Clean up an XML File

2009-05-30T08:52:00.001-07:00

using System;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.IO;
using System.Diagnostics;
//using System.Runtime.InteropServices;
namespace Clean_XML
{
public partial class Form1 : Form
{
private System.Text.StringBuilder mclsStr;
/*
[DllImport("Kernel32.dll")]
private static extern bool QueryPerformanceCounter(
out long lpPerformanceCount);

[DllImport("Kernel32.dll")]
private static extern bool QueryPerformanceFrequency(
out long lpFrequency);
*/
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
//long iStart,freq;
//QueryPerformanceFrequency(out freq);
//QueryPerformanceCounter(out iStart);
XmlDocument ms = new XmlDocument();
string sInput, sOutput;
string mOut;
sInput = txtInput.Text;
sOutput = txtOutput.Text;

if (File.Exists(sInput) == false)
{
MessageBox.Show("Please enter or drag a valid file into the input text file");
return;
}

if (sOutput.Length == 0)
{
sOutput = sInput + ".out";
txtOutput.Text = sOutput;
}
mclsStr = new System.Text.StringBuilder();
try
{
ms.Load(sInput);
}
catch(Exception exc)
{
MessageBox.Show("An error occured parsing the file" + (char)10 + exc.ToString());
return;
}
GetNodesRec((ms.ChildNodes), 0);

mOut = mclsStr.ToString();
Encoding enCode = Encoding.ASCII;
if (ms.FirstChild.NodeType == XmlNodeType.XmlDeclaration)
{
XmlDeclaration decl = (XmlDeclaration)ms.FirstChild;
if (decl.Encoding == "UTF-7")
enCode = Encoding.UTF7;
else if (decl.Encoding == "UTF-8")
enCode = Encoding.UTF8;
else if (decl.Encoding == "UTF-32")
enCode = Encoding.UTF32;
else //if (decl.Encoding == "UTF")
enCode = Encoding.Unicode;
}
StreamWriter sw = new StreamWriter(sOutput, false, enCode);
sw.Write(mclsStr.ToString());
sw.Close();

//long iEnd;
//QueryPerformanceCounter(out iEnd);
//double iTime = (double)(iEnd - iStart) / (double)freq;

//Form1.ActiveForm.Text = "Processing Took: " + Math.Round(iTime,2).ToString() + " Seconds";
DialogResult drAns = MessageBox.Show("Done - " + sOutput + " has been created. Do you want to open this file", "Open File", MessageBoxButtons.YesNo);
if (drAns == DialogResult.Yes)
{
Process p = new Process();
p.StartInfo.FileName = @"notepad";
p.StartInfo.Arguments = sOutput;
p.StartInfo.CreateNoWindow = true;

p.Start();

}

}
private void GetNodesRec(System.Xml.XmlNodeList oNodes, int iTab)
{
for (int iLoop = 0; iLoop < oNodes.Count; iLoop++)
{
if (oNodes[iLoop].ChildNodes.Count > 0)
{
mclsStr.AppendLine(GetTabs(iTab) + FirstPart(oNodes[iLoop].OuterXml));
GetNodesRec((oNodes[iLoop].ChildNodes), iTab + 1);
mclsStr.AppendLine(GetTabs(iTab) + LastPart((oNodes[iLoop].OuterXml)));
}
else
{
mclsStr.AppendLine(GetTabs(iTab) + oNodes[iLoop].OuterXml);
}
}

}

private string LastPart(string p)
{
int iPos;
iPos = p.LastIndexOf("<");
return p.Substring(iPos);
}

private string FirstPart(string p)
{
int iPos;
iPos = p.IndexOf(">")+1;
return p.Substring(0, iPos);
}

private string GetTabs(int iTab)
{
if (iTab < 0)
iTab = 1;
return new string((char)9, iTab);
}

private void OnDragDrop(object sender, DragEventArgs e)
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
txtInput.Text = files[0];
SetOutPutFileName();
}

private void OnDragEnter(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent(DataFormats.FileDrop, false) == true)
e.Effect = DragDropEffects.All;
}
private void SetOutPutFileName()
{
if (txtOutput.Text.Length == 0)
txtOutput.Text = txtInput.Text + ".out";

}
}
}

Send a SMTP E-Mail

2009-05-30T08:51:00.001-07:00

using System;
using System.Web.Mail;

namespace TestMail
{
public class SendMail
{
public void Send(string serverName, string to, string from, string subject)
{
SmtpMail.SmtpServer = serverName;

MailMessage m = new MailMessage();
m.To = to;
m.From = from;
m.Subject = subject;
m.Body = body;

SmtpMail.Send(m);
}
}
}

Read an xml file, twist it with an xsl file and then write to a string

2009-05-30T08:50:00.002-07:00

using System;
using System.IO;
using System.Xml;
using System.Xml.Xsl;

class WriteXMLViaXSL
{
public static void Main(string[] args)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(args[0]);

XslTransform xslTransform = new XslTransform();
xslTransform.Load(args[1]);

StringWriter stringWriter = new StringWriter();
XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
xmlTextWriter.Formatting = Formatting.Indented;
xslTransform.Transform(xmlDocument, null, xmlTextWriter);

xmlTextWriter.Flush();
Console.Write(stringWriter.ToString());
}
}

Download webpage from URL and print to console

2009-05-30T08:50:00.001-07:00

// Download webpage from URL and print to console

using System;
using System.Net;
using System.Text;
using System.IO;

namespace Test {

class GetWebPage {
public static void Main(string[] args) {
for(int i=0;i HttpWebRequest httpWebRequest =
(HttpWebRequest)WebRequest.Create(args[i]);

HttpWebResponse httpWebResponse =
(HttpWebResponse)httpWebRequest.GetResponse();

Stream stream = httpWebResponse.GetResponseStream();

StreamReader streamReader =
new StreamReader(stream, Encoding.ASCII);
Console.WriteLine(streamReader.ReadToEnd());
}

Console.Read();
}
}

}

XML serialization from string

2009-05-30T08:49:00.003-07:00

// XML serialization from string

xmlSerializer.Deserialize(new StringReader(xmlString));

Stream data directly to website user

2009-05-30T08:49:00.001-07:00

// Stream data directly to website user

FileStream liveStream = new FileStream(localfilename, FileMode.Open, FileAccess.Read);

byte[] buffer = new byte[(int)liveStream.Length];
liveStream.Read(buffer, 0, (int)liveStream.Length);
liveStream.Close();

Response.Clear();
Response.ContentType = "application/octet-stream";
Response.AddHeader("Content-Length", buffer.Length.ToString());
Response.AddHeader("Content-Disposition", "attachment; filename=" + originalFilename);
Response.BinaryWrite(buffer);
Response.End();

Turn standard XmlDocument into XPath Document

2009-05-30T08:48:00.002-07:00

/*
It's not obvious how you might turn your standard XmlDocument into
an XPathDocument as there is no direct method to do so. The best way
is to make use of a reader for the conversion:
*/

XPathDocument xpathDoc = new XPathDocument (new XmlNodeReader(doc));

From DataSet to XmlDocument

2009-05-30T08:48:00.001-07:00

// From DataSet to XmlDocument

// This is the final document
XmlDocument Data = new XmlDocument();

// Create a string writer that will write the Xml to a string
StringWriter stringWriter = new StringWriter();

// The Xml Text writer acts as a bridge between the xml stream and the text stream
XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);

// Now take the Dataset and extract the Xml from it, it will write to the string writer
content.WriteXml(xmlTextWriter, XmlWriteMode.IgnoreSchema);

// Write the Xml out to a string
string contentAsXmlString = stringWriter.ToString();

// load the string of Xml into the document
Data.LoadXml(contentAsXmlString);

Moving nodes from one XmlDocument to another

2009-05-30T08:47:00.003-07:00

// Moving nodes from one XmlDocument to another

/*
In .NET has some powerful tools to deal with Xml. All Xml nodes
need to be created in the context of a XmlDocument object. If you need
to move the nodes from one Xml Document to another, it's not obvious that
you can just copy the nodes from one XmlDocument to another, after all Xml
is just text isn't it.

Here's how to move all the nodes from one Xml Document to another:
*/

// Dont forget this one:
using System.Xml;

// First, get some documents together
XmlDocument DocumentSource = new XmlDocument();
XmlDocument DocumentDestination = new XmlDocument();

// Load the documents with some nodes
DocumentSource.LoadXml("");
DocumentDestination.LoadXml("");

// Now to do the conversion
XmlNode tempNode = DocumentDestination.ImportNode( DocumentSource.FirstChild )

// Now insert the fragment into the document
DocumentDestination.FirsChild.AppendChild(tempNode);

XML (or any string type) compression

2009-05-30T08:47:00.001-07:00

// XML (or any string type) compression

public static byte[] CompressXML(string xml)
{
byte[] temp = Encoding.UTF8.GetBytes(xml);
MemoryStream ms = new MemoryStream();
DeflateStream ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Write(temp, 0, temp.Length);
ds.Flush();
ds.Close();
return ms.ToArray();
}

public static string DecompressXML(byte[] data)
{
const int BUFFER_SIZE = 10;
byte[] tempArray = new byte[BUFFER_SIZE];
ArrayList tempList = new ArrayList();
int count = 0, length = 0;

MemoryStream ms = new MemoryStream(data);
DeflateStream ds = new DeflateStream(ms, CompressionMode.Decompress);

while ((count = ds.Read(tempArray, 0, BUFFER_SIZE)) > 0)
{
if (count == BUFFER_SIZE)
{
tempList.Add(tempArray);
tempArray = new byte[BUFFER_SIZE];
}
else
{
byte[] temp = new byte[count];
Array.Copy(tempArray, 0, temp, 0, count);
tempList.Add(temp);
}
length += count;
}

byte[] retVal = new byte[length];

count = 0;
foreach (byte[] temp in tempList)
{
Array.Copy(temp, 0, retVal, count, temp.Length);
count += temp.Length;
}

return Encoding.UTF8.GetString(retVal);
}

Write HTML code directly to a WebBrowser control

2009-05-30T08:46:00.000-07:00

// Write HTML code directly to a WebBrowser control

webBrowser1.Navigate("about:blank");
webBrowser1.Document.Write("

Hello World!

");

Remove XML comments

2009-05-30T08:45:00.000-07:00

// Remove XML comments

XmlNodeList list = xmlDoc.SelectNodes("//comment()");
foreach(XmlNode node in list)
node.ParentNode.RemoveChild(node);

Remove empty XML nodes

2009-05-30T08:44:00.004-07:00

// Remove empty XML nodes

public static void RemoveEmptyNodes(XmlDocument doc)
{
XmlNodeList nodes = doc.SelectNodes("//node()");

foreach (XmlNode node in nodes)
if ((node.Attributes.Count == 0) && (node.ChildNodes.Count == 0))
node.ParentNode.RemoveChild(node);
}

HTML Encoding/Decoding

2009-05-30T08:44:00.003-07:00

// HTML Encoding/Decoding

string temp = System.Web.HttpUtility.HtmlEncode("this is a test");
temp2 = System.Web.HttpUtility.HtmlDecode(temp2);

Strip HTML Tags From a String

2009-05-30T08:44:00.001-07:00

// Strip HTML Tags From a String

string strippedString = Regex.Replace(htmlString,@"<(.|\n)*?>",string.Empty);

/*
This will strip anything found in HTML tags.
(.|\n) -- Finds any character including the new line character
*? -- 0 or more occurences and the match will stop at the first
occuring ">" it sees
*/

Reading XML Element Contents using XPathDocument

2009-05-30T08:42:00.000-07:00

/*
Reading XML Element Contents using XPathDocument
*/

using System.Xml;
using System.Xml.XPath;

private string m_xml_path;
private string m_xml_filename;

public string FilePath
{
get { return m_xml_path; }
set { m_xml_path = value; }
}

public string FileName
{
get { return m_xml_filename; }
set { m_xml_filename = value; }
}

private XPathNavigator CreateNavigator(string path, string filename)
{
XPathDocument doc = new XPathDocument(path + filename);
return doc.CreateNavigator();
}

public string GetXMLString(string xpath)
{
string xmlString = null;
try
{
XPathNavigator nav = CreateNavigator(m_xml_path, m_xml_filename);
XPathNodeIterator iter = nav.Select(xpath);
iter.MoveNext();
xmlString = iter.Current.Value;
iter = null;
nav = null;
}
catch (XPathException xe)
{
throw new XPathException(xe.Message);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return xmlString;
}

URL Parameters for Dynamic JS and CSS

2009-05-30T08:41:00.000-07:00

/*
URL Parameters for Dynamic JS and CSS
--
This snippet allows an aspx page (c#) to accept URL parameters to
allow styles or script to be dynamically appended to the rendered
page.

I wrote this simple snippet to allow one of our vendors to accept
a style override so that their application would morph into
something more closely resembling our own portal application.
Please see screenshots for clarification.
*/

<%
foreach (object Key in Request.QueryString)
{
if (Key.ToString().ToLower().Trim() ="style")
{
string style= Request.QueryString.Get(Key.ToString().Trim());
Response.Write("");
}

if (Key.ToString().ToLower().Trim() ="script")
{
string script= Request.QueryString.Get(Key.ToString().Trim());
Response.Write("");
}
}
%>

Serializing and Deserializing XML String

2009-05-30T08:40:00.000-07:00

//This will returns the set of included namespaces for the serializer.
public static XmlSerializerNamespaces GetNamespaces()
{

XmlSerializerNamespaces ns;
ns = new XmlSerializerNamespaces();
ns.Add("xs", "http://www.w3.org/2001/XMLSchema");
ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
return ns;

}

//Returns the target namespace for the serializer.
public static string TargetNamespace
{

Get
{

return http://www.w3.org/2001/XMLSchema;
}

}

//Creates an object from an XML string.
public static object FromXml(string Xml, System.Type ObjType)
{

XmlSerializer ser;
ser = new XmlSerializer(ObjType);
StringReader stringReader;
stringReader = new StringReader(Xml);
XmlTextReader xmlReader;
xmlReader = new XmlTextReader(stringReader);
object obj;
obj = ser.Deserialize(xmlReader);
xmlReader.Close();
stringReader.Close();
return obj;

}

//Serializes the Obj to an XML string.
public static string ToXml(object Obj, System.Type ObjType)
{

XmlSerializer ser;
ser = new XmlSerializer(ObjType, SerializeObject.TargetNamespace);
MemoryStream memStream;
memStream = new MemoryStream();
XmlTextWriter xmlWriter;
xmlWriter = new XmlTextWriter(memStream, Encoding.UTF8);
xmlWriter.Namespaces = true;
ser.Serialize(xmlWriter, Obj, SerializeObject.GetNamespaces());
xmlWriter.Close();
memStream.Close();
string xml;
xml = Encoding.UTF8.GetString(memStream.GetBuffer());
xml = xml.Substring(xml.IndexOf(Convert.ToChar(60)));
xml = xml.Substring(0, (xml.LastIndexOf(Convert.ToChar(62)) + 1));
return xml;

}

Writing XML Fragments

2009-05-30T08:39:00.000-07:00

static void writeTree(XmlNode xmlElement, int level) {
String levelDepth = "";
for(int i=0;i {
levelDepth += " ";
}
Console.Write("\n{0}<{1}",levelDepth,xmlElement.Name);
XmlAttributeCollection xmlAttributeCollection = xmlElement.Attributes;
foreach(XmlAttribute x in xmlAttributeCollection)
{
Console.Write(" {0}='{1}'",x.Name,x.Value);
}
Console.Write(">");
XmlNodeList xmlNodeList = xmlElement.ChildNodes;
++level;
foreach(XmlNode x in xmlNodeList)
{
if(x.NodeType == XmlNodeType.Element)
{
writeTree((XmlNode)x, level);
}
else if(x.NodeType == XmlNodeType.Text)
{
Console.Write("\n{0} {1}",levelDepth,(x.Value).Trim());
}
}
Console.Write("\n{0}",levelDepth,xmlElement.Name);
}