Tech.It.2.Me->{By.Anton.Perez}

If you’ve used Visual Studio 2008 or 2010, you’ll notice that Web Reference is no longer there (like in VS 2005 and previous), instead, you see Service Reference –- actually, it’s STILL there, just hidden!

So, what’s the difference?  Well, according to this post:

Add Web Reference is the old-style, deprecated ASP.NET webservices (ASMX) technology (using only the XmlSerializer for your stuff) – if you do this, you get an ASMX client for an ASMX web service. You can do this in just about any project (Web App, Web Site, Console App, Winforms – you name it).

Add Service Reference is the new way of doing it, adding a WCF service reference, which gives you a much more advanced, much more flexible service model than just plain old ASMX stuff.

So, how do you access it?  Simple — right-click on Service References in the Solution Explorer window and…

Click on “Advanced…”

Then click on “Add Web Reference…”

Voila!  You can now consume the web service like you did pre-Visual Studio 2008 era.  Happy coding!

Adding for archival purposes…

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Security.Cryptography;

namespace Classes
{
    public class Hash
    {
        public Hash()
        { }

        #region Hash Choices
        /// <summary>The wanted hash function.</summary>
        public enum HashType : int
        {
            /// <summary>MD5 Hashing</summary>
            MD5,
            /// <summary>SHA1 Hashing</summary>
            SHA1,
            /// <summary>SHA256 Hashing</summary>
            SHA256,
            /// <summary>SHA384 Hashing</summary>
            SHA384,
            /// <summary>SHA512 Hashing</summary>
            SHA512
        } /* HashType */
        #endregion

        #region Public Methods
        /// <summary>Generates the hash of a text.</summary>
        /// <param name="strPlain">The text of which to generate a hash of.</param>
        /// <param name="hshType">The hash function to use.</param>
        /// <returns>The hash as a hexadecimal string.</returns>
        public static string GetHash(string strPlain, HashType hshType)
        {
            string strRet;
            switch (hshType)
            {
                case HashType.MD5:
                    strRet = GetMD5(strPlain);
                    break;
                case HashType.SHA1:
                    strRet = GetSHA1(strPlain);
                    break;
                case HashType.SHA256:
                    strRet = GetSHA256(strPlain);
                    break;
                case HashType.SHA384:
                    strRet = GetSHA384(strPlain);
                    break;
                case HashType.SHA512:
                    strRet = GetSHA512(strPlain);
                    break;
                default:
                    strRet = "Invalid HashType";
                    break;
            }
            return strRet;
        } /* GetHash */

        /// <summary>Checks a text with a hash.</summary>
        /// <param name="strOriginal">The text to compare the hash against.</param>
        /// <param name="strHash">The hash to compare against.</param>
        /// <param name="hshType">The type of hash.</param>
        /// <returns>True if the hash validates, false otherwise.</returns>
        public static bool CheckHash(string strOriginal, string strHash, HashType hshType)
        {
            string strOrigHash = GetHash(strOriginal, hshType);
            return (strOrigHash == strHash);
        } /* CheckHash */
        #endregion

        #region Hashers
        private static string GetMD5(string strPlain)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] HashValue, MessageBytes = UE.GetBytes(strPlain);
            MD5 md5 = new MD5CryptoServiceProvider();
            string strHex = "";

            HashValue = md5.ComputeHash(MessageBytes);
            foreach (byte b in HashValue)
            {
                strHex += String.Format("{0:x2}", b);
            }
            return strHex;
        } /* GetMD5 */

        private static string GetSHA1(string strPlain)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] HashValue, MessageBytes = UE.GetBytes(strPlain);
            SHA1Managed SHhash = new SHA1Managed();
            string strHex = "";

            HashValue = SHhash.ComputeHash(MessageBytes);
            foreach (byte b in HashValue)
            {
                strHex += String.Format("{0:x2}", b);
            }
            return strHex;
        } /* GetSHA1 */

        private static string GetSHA256(string strPlain)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] HashValue, MessageBytes = UE.GetBytes(strPlain);
            SHA256Managed SHhash = new SHA256Managed();
            string strHex = "";

            HashValue = SHhash.ComputeHash(MessageBytes);
            foreach (byte b in HashValue)
            {
                strHex += String.Format("{0:x2}", b);
            }
            return strHex;
        } /* GetSHA256 */

        private static string GetSHA384(string strPlain)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] HashValue, MessageBytes = UE.GetBytes(strPlain);
            SHA384Managed SHhash = new SHA384Managed();
            string strHex = "";

            HashValue = SHhash.ComputeHash(MessageBytes);
            foreach (byte b in HashValue)
            {
                strHex += String.Format("{0:x2}", b);
            }
            return strHex;
        } /* GetSHA384 */

        private static string GetSHA512(string strPlain)
        {
            UnicodeEncoding UE = new UnicodeEncoding();
            byte[] HashValue, MessageBytes = UE.GetBytes(strPlain);
            SHA512Managed SHhash = new SHA512Managed();
            string strHex = "";

            HashValue = SHhash.ComputeHash(MessageBytes);
            foreach (byte b in HashValue)
            {
                strHex += String.Format("{0:x2}", b);
            }
            return strHex;
        } /* GetSHA512 */
        #endregion
    }
}

Have you ever come across the error below with one of your ASP.NET web apps that is trying to write to the Eventlogs? If so, read on…

By default the ASPNET user cannot access the existing eventlogs categories. To resolve this, you must set the permissions in the Eventlog key in the registry:

1. Launch RegEdit.
2. Navigate to HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\.
3. From the menu, select Edit->Permissions.
4. Click the Add button and write ASPNET (if ASP.NET is running under a different User ID, use that ID instead).
5. Click OK.
6. Select the newly added user from the list (ASP.NET Machine User by default).
7. Click on Full Control in the Allow column. 8. Click OK.

More info here.

Below is a summary of the “two top things that cause trouble in production ASP.NET web sites,” per Scott Hanselman, which he obtained from deep within Microsoft Developer Support.  Go here to read the complete article.

#1 Issue – Configuration

Seems the #1 issue in support for problems with ASP.NET 2.x and 3.x is configuration. 

#2 Issue – Problems with an External (non-ASP.NET) Root Cause

Sometimes when you’re having trouble with an ASP.NET site, the problem turns out to not be ASP.NET itself.

Just sign up with your Windows Live/Passport account and you can download all three e-books by Microsoft Press.  It includes the following:

Enjoy!