.NET Basic All Errors into a single Xml document Helper Functions

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Reflection;
using System.Diagnostics;
using System.Web;
using System.Configuration;

namespace IDS.Rapport.Dell.Helpers
{
    public class ErrorHandler
    {
        string _strErrorMessage, _strDetails, _strClassName, _strMethodName;
        DateTime _dtOccuranceTime = new DateTime();

        public ErrorHandler() { }

        /// <summary>
        /// overloaded constructor for quick error logging with limited details
        /// </summary>
        /// <param name="time">Error datetime</param>
        /// <param name="className">Class in which error occurred</param>
        /// <param name="methodName">Method in which error occurred</param>
        /// <param name="errorMessage">Error stack</param>
        /// <param name="details">Error details</param>
        public ErrorHandler(DateTime time, string className, string methodName, string errorMessage, string details)
        {
            _dtOccuranceTime = time;
            _strClassName = className;
            _strDetails = details;
            _strErrorMessage = errorMessage;
            _strMethodName = methodName;
        }

        /// <summary>
        /// Log error in XML file
        /// </summary>
        /// <param name="ex">Exception details</param>
        public static void WriteError(Exception ex)
        {
            WriteError(ex, "");
        }

        /// <summary>
        /// Log error in XML file
        /// Copy the existing node from xml and append the the new node by copying the structure existing node
        /// Its mandatory to have errorlog.xml in application with one record for structure
        /// its picks the errorlog.xml path from web.config ("logfilepath" key)
        /// </summary>
        /// <param name="ex">Exception details<</param>
        /// <param name="fileName">File in which error occurred</param>
        public static void WriteError(Exception ex, string fileName)
        {
            if (Convert.ToBoolean(System.Configuration.ConfigurationManager.AppSettings["Error_Logging"]) == true)
            {
                XmlDocument doc = new XmlDocument();
                string strRootPath = HttpContext.Current.Server.MapPath(Convert.ToString(ConfigurationManager.AppSettings["logfilepath"]).Trim());
                string xmlPath = strRootPath;
                doc.Load(@xmlPath);
                XmlNode newXMLNode, oldXMLNode;
                oldXMLNode = doc.ChildNodes[1].ChildNodes[0];
                newXMLNode = oldXMLNode.CloneNode(true);

                StackTrace stackTrace = new StackTrace();
                StackFrame stackFrame = stackTrace.GetFrame(1);
                MethodBase methodBase = stackFrame.GetMethod();

                newXMLNode.ChildNodes[0].InnerText = DateTime.Now.ToString();
                newXMLNode.ChildNodes[1].InnerText = fileName;
                newXMLNode.ChildNodes[2].InnerText = methodBase.DeclaringType.FullName;
                newXMLNode.ChildNodes[3].InnerText = methodBase.Name;
                newXMLNode.ChildNodes[4].InnerText = ex.TargetSite.Name;
                newXMLNode.ChildNodes[5].InnerText = ex.Message;
                newXMLNode.ChildNodes[6].InnerText = ex.StackTrace;
                newXMLNode.ChildNodes[7].InnerText = System.Web.HttpContext.Current.Request.UserHostAddress;
                newXMLNode.ChildNodes[8].InnerText = System.Web.HttpContext.Current.Request.Url.OriginalString;
                doc.ChildNodes[1].AppendChild(newXMLNode);
                doc.Save(@xmlPath);
            }
        }
    }
}

Calling these functions:

ErrorHandler.WriteError(ex, "Logging.cs Perform_Logging");

.NET Logging Helper Functions

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.IO;

namespace IDS.Rapport.Dell.Helpers
{
    public class Logging
    {
        public static string Perform_Logging(string Data, string FileName)
        {
            try
            {
                // Get Random value for Logging
                Random RandomGen = new Random();
                int intRandom = Convert.ToInt32(Math.Floor(1000000 * RandomGen.NextDouble()));
                string strLogFilePart = string.Empty;
                string logFilePath = null;
                bool logging = false;

                logging = Convert.ToBoolean(ConfigurationManager.AppSettings["Logging"].ToString());

                if (logging)
                {
                    logFilePath = ConfigurationManager.AppSettings["strLogFilePath"].ToString();
                    strLogFilePart = DateTime.Now.ToString("s").Replace(":", "-") + " " + intRandom.ToString("000000");
                    File.WriteAllText(logFilePath + FileName + strLogFilePart + ".txt", Data.Trim());
                }
               
            }
            catch (Exception ex)
            {
                //Error Logging
                ErrorHandler.WriteError(ex, "Logging.cs Perform_Logging");
            }

            return "";

        }
    }
}

Calling these functions:

1. Perform_Logging

Logging.Perform_Logging(RequestXmlDoc.OuterXml, "Request_Before_Posting_To_RapportDataImport");

.NET Web service Call Helper Functions

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Xsl;
using System.Configuration;
using System.Web;
using System.Net;
using System.IO;
using IDS.Rapport.Dell.Helpers;

namespace IDS.Rapport.Dell.Helpers
{
    public class RapportDataImport
    {

        public static string RapportDataImportCall(XmlDocument RequestXmlDoc)
        {
            string ResponseText = "";

            try
            {

                if (string.Equals(RequestXmlDoc.DocumentElement.Name.ToString(), "Requests"))
                {
                    ResponseText = RapportDataImportCall_MultiApp(RequestXmlDoc);
                }
                else
                {
                    // Request to IL web service
                    string strUrlPort = Convert.ToString(ConfigurationManager.AppSettings["RapportDataImportURL"]).Trim();
                    HttpWebRequest PostRequest = (HttpWebRequest)HttpWebRequest.Create(strUrlPort);
                    PostRequest.Method = "POST";
                    PostRequest.Accept = "text/xml";
                    PostRequest.ContentType = "text/xml;charset=\"utf-8\"";
                    PostRequest.Timeout = -1;

                    Logging.Perform_Logging(RequestXmlDoc.OuterXml, "Request_Before_Posting_To_RapportDataImport");

                    ASCIIEncoding encoding = new ASCIIEncoding();

                    byte[] byte1 = encoding.GetBytes(RequestXmlDoc.OuterXml);
                    PostRequest.ContentLength = byte1.Length;
                    Stream newStream = PostRequest.GetRequestStream();
                    newStream.Write(byte1, 0, byte1.Length);
                    newStream.Close();

                    // Get the response from PostRequest above
                    HttpWebResponse Response = PostRequest.GetResponse() as HttpWebResponse;
                    Stream ResponseStream = Response.GetResponseStream();
                    StreamReader ResponseReader = new StreamReader(ResponseStream);

                    ResponseText = ResponseReader.ReadToEnd();

                    Logging.Perform_Logging(ResponseText, "Response_From_RapportDataImport");

                    ResponseReader.Close();
                    Response.Close();

                }
                string FirstString = "";
                string LastString = "";

                if (ResponseText.Contains("&lt;message&gt;"))
                {
                    FirstString = "&lt;message&gt;";
                    LastString = "&lt;/message&gt;";
                }
                else
                {
                    FirstString = "&lt;InfoMsg&gt;";
                    LastString = "&lt;/InfoMsg&gt;";
                }

                ResponseText = StringHelper.Between(ResponseText,FirstString,LastString);

            }
            catch (Exception ex)
            {
                //Error Logging
                ErrorHandler.WriteError(ex, "RapportDataImport.cs RapportDataImportCall");
            }
            finally
            {
                GC.Collect();
            }

            return ResponseText;
        }

        public static string RapportDataImportCall_MultiApp(XmlDocument RequestXmlDoc)
        {
            string ResponseText = "";

            // Request to IL web service
            string strUrlPort = Convert.ToString(ConfigurationManager.AppSettings["RapportDataImportURL"]).Trim();

            XmlNodeList Requests = RequestXmlDoc.SelectNodes("Requests/Request");

            foreach(XmlNode Request in Requests)
            {
                HttpWebRequest PostRequest = (HttpWebRequest)HttpWebRequest.Create(strUrlPort);
                PostRequest.Method = "POST";
                PostRequest.Accept = "text/xml";
                PostRequest.ContentType = "text/xml;charset=\"utf-8\"";
                PostRequest.Timeout = -1;

                Logging.Perform_Logging(RequestXmlDoc.OuterXml, "Request_Before_Posting_To_RapportDataImport");

                ASCIIEncoding encoding = new ASCIIEncoding();

                byte[] byte1 = encoding.GetBytes(Request.InnerXml);
                PostRequest.ContentLength = byte1.Length;
                Stream newStream = PostRequest.GetRequestStream();
                newStream.Write(byte1, 0, byte1.Length);
                newStream.Close();

                // Get the response from PostRequest above
                HttpWebResponse Response = PostRequest.GetResponse() as HttpWebResponse;
                Stream ResponseStream = Response.GetResponseStream();
                StreamReader ResponseReader = new StreamReader(ResponseStream);

                ResponseText += ResponseReader.ReadToEnd();

                Logging.Perform_Logging(ResponseText, "Response_From_RapportDataImport");

                ResponseReader.Close();
                Response.Close();
            }

            return ResponseText;
        }
    }
}

Calling these functions

1. RapportDataImportCall

responsemessage = IDS.Rapport.Dell.Helpers.RapportDataImport.RapportDataImportCall(PurchaseOrders);

.NET String Helper Functions

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IDS.Rapport.Dell.Helpers
{
    class StringHelper
    {
        public static string Between(string Text, string FirstString, string LastString)
        {
            string STR = Text;
            string STRFirst = FirstString;
            string STRLast = LastString;
            string FinalString;

            int Pos1 = STR.IndexOf(FirstString) + FirstString.Length;
            int Pos2 = STR.IndexOf(LastString);
            FinalString = STR.Substring(Pos1, Pos2 - Pos1);
            return FinalString;
        }

    }
}

Calling these functions

1. Between

ResponseText = StringHelper.Between(ResponseText,FirstString,LastString);

.NET Basic XML Helper Functions

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Xml.Xsl;
using System.Xml.XPath;

namespace IDS.Rapport.Dell.Helpers
{
    public class XmlHelper
    {
        #region Methods

        //public static string ToXmlString(Object Input)
        //{
        //    try
        //    {
        //        XmlWriterSettings settings = new XmlWriterSettings();
        //        settings.OmitXmlDeclaration = true;

        //        MemoryStream ms = new MemoryStream();
        //        XmlWriter writer = XmlWriter.Create(ms, settings);

        //        XmlSerializerNamespaces names = new XmlSerializerNamespaces();
        //        names.Add("", "");

        //        XmlSerializer cs = new XmlSerializer(Input.GetType());

        //        cs.Serialize(writer, Input, names);

        //        ms.Flush();
        //        ms.Seek(0, SeekOrigin.Begin);
        //        StreamReader sr = new StreamReader(ms);
        //        return sr.ReadToEnd();
        //    }
        //    catch (Exception ex) {
        //        throw new Exception("Exception occurred while serializing object to XML string.", ex);
        //    }
        //}

        public static string TransformInMemory(XslCompiledTransform Transform, XmlDocument InputXML)
        {
            StringBuilder sb = new StringBuilder();

            try
            {
                XmlWriterSettings wSettings = new XmlWriterSettings();
                wSettings.ConformanceLevel = ConformanceLevel.Fragment;
                XmlWriter xWriter = XmlWriter.Create(sb, wSettings);
                Transform.Transform(new XmlNodeReader(InputXML), xWriter);
            }
            catch (Exception ex)
            {
                //Error Logging
                ErrorHandler.WriteError(ex, "XmlHelper.cs TransformInMemory");
            }
            finally
            {
                GC.Collect();
            }

            return sb.ToString();
        }

        #endregion
    }
}


Calling the functions

TransformInMemory

XmlDocument returnDoc = new XmlDocument();
string OrderImportXSLPath = HttpContext.Current.Server.MapPath(Convert.ToString(ConfigurationManager.AppSettings["OrderImportXSLTPath_WithinRapport"]).Trim());
                XslCompiledTransform xslTransform1 = new XslCompiledTransform();
                xslTransform1.Load(OrderImportXSLPath, new XsltSettings(false, true), new XmlUrlResolver());
                returnDoc.LoadXml(IDS.Rapport.Dell.Helpers.XmlHelper.TransformInMemory(xslTransform1, returnDoc));