Click here to Skip to main content
Click here to Skip to main content
Articles » Web Development » ASP.NET » General » Downloads
 
Add your own
alternative version
Go to top

Implementing Model-View-Presenter in ASP.NET

, 17 Nov 2007
Three implementations of Model-View-Presenter in ASP.NET 2.0.
MVPSampleApp.zip
MVP.SampleApp
Lib
Microsoft.Practices.EnterpriseLibrary.Common.dll
Microsoft.Practices.EnterpriseLibrary.Data.dll
MySql.Data.dll
nunit.framework.dll
Rhino.Mocks.dll
Model
Data
Interfaces
Properties
Presentation
Presentation.Tests
Properties
Interfaces
Properties
SubSonic
ActiveRecord
Builder
CodeGeneration
Templates
CodeLanguage
Configuration
Controls
Calendar
lang
skin
active-bg.gif
calendar.gif
dark-bg.gif
hover-bg.gif
menuarrow.gif
normal-bg.gif
rowhover-bg.gif
status-bg.gif
title-bg.gif
today-bg.gif
Resources
DataProviders
Properties
Sql Tools
SubSonic.snk
Sugar
WebApp
App_Data
Views
SQL2000SampleDb.zip
SQL2000SampleDb.msi
using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Web.UI.WebControls;
using System.Net;
using System.Collections;
using System.Text.RegularExpressions;
using System.IO;

namespace SubSonic.Sugar
{
    public static class Web
    {

        /// <summary>
        /// Queries the string.
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="param">The param.</param>
        /// <returns></returns>
        public static t QueryString<t>(string param)
        {
            t result = default(t);

            if (HttpContext.Current.Request.QueryString[param] != null)
            {
                object paramValue = HttpContext.Current.Request[param];
                result = (t)Utilities.Utility.ChangeType(paramValue, typeof(t));
            }

            return result;
        }

        /// <summary>
        /// Cookies the specified param.
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="param">The param.</param>
        /// <returns></returns>
        public static t Cookie<t>(string param)
        {
            t result = default(t);
            if (HttpContext.Current.Request.Cookies[param] != null)
            {
                string paramValue = HttpContext.Current.Request.Cookies[param].Value;
                result = (t)Utilities.Utility.ChangeType(paramValue, typeof(t));
            }

            return result;
        }

        /// <summary>
        /// Sessions the value.
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="param">The param.</param>
        /// <returns></returns>
        public static t SessionValue<t>(string param)
        {
            t result = default(t);
            if (HttpContext.Current.Session[param] != null)
            {
                object paramValue = HttpContext.Current.Session[param];
                result = (t)Utilities.Utility.ChangeType(paramValue, typeof(t));
            }

            return result;
        }


        //many thanks to ASP Alliance for the code below
        //http://authors.aspalliance.com/olson/methods/

        /// <summary>
        /// Fetches a web page
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static string ReadWebPage(string url) {
            WebRequest request = HttpWebRequest.Create(url);
            Stream stream = request.GetResponse().GetResponseStream();
            StreamReader sr = new StreamReader(stream);
            string webPage = sr.ReadToEnd();
            sr.Close();

            return webPage;
        }

        /// <summary>
        /// Gets DNS information about a url and puts it in an array of strings
        /// </summary>
        /// <param name="url">either an ip address or a host name</param>
        /// <returns>a list with the host name, all the aliases, and all the addresses. </returns>
        public static string[] DNSLookup(string url)
        {
            ArrayList al = new ArrayList();

            //check whether url is ipaddress or hostname
            IPHostEntry ipEntry = Dns.GetHostEntry(url);

            al.Add("HostName," + ipEntry.HostName);

            foreach(string name in ipEntry.Aliases)
            {
                al.Add("Aliases," + name);
            }

            foreach(IPAddress ip in ipEntry.AddressList)
            {
                al.Add("Address," + ip);
            }
            string[] ipInfo = (string[])al.ToArray(typeof(string));

            return ipInfo;
        }

        /// <summary>
        /// Scrapes the image tags from a given URL
        /// </summary>
        /// <param name="url"></param>
        /// <returns>string array of all images on a page</returns>
        public static string[] ScrapeImages(string url) {
            //get the content of the url
            //ReadWebPage is another method in this useful methods collection
            string htmlPage = ReadWebPage(url);

            //set up the regex for finding images
            StringBuilder imgPattern = new StringBuilder();
            imgPattern.Append("<img[^>]+"); //start 'img' tag
            imgPattern.Append("src\\s*=\\s*"); //start src property
            //three possibilities  for what src property --
            //(1) enclosed in double quotes
            //(2) enclosed in single quotes
            //(3) enclosed in spaces
            imgPattern.Append("(?:\"(?<src>[^\"]*)\"|'(?<src>[^']*)'|(?<src>[^\"'>\\s]+))");
            imgPattern.Append("[^>]*>"); //end of tag
            Regex imgRegex = new Regex(imgPattern.ToString(), RegexOptions.IgnoreCase);

            //look for matches 
            Match imgcheck = imgRegex.Match(htmlPage);
            ArrayList imagelist = new ArrayList();
            //add base href for relative urls
            imagelist.Add("<BASE href=\"" + url + "\">" + url);
            while (imgcheck.Success) {
                string src = imgcheck.Groups["src"].Value;
                string image = "<img src=\"" + src + "\">";
                imagelist.Add(image);
                imgcheck = imgcheck.NextMatch();
            }
            string[] images = new string[imagelist.Count];
            imagelist.CopyTo(images);

            return images;
        }

        /// <summary>
        /// Scrapes a web page and parses out all the links.
        /// </summary>
        /// <param name="url"></param>
        /// <param name="makeLinkable"></param>
        /// <returns></returns>
        public static string[] ScrapeLinks(string url, bool makeLinkable) {
            //get the content of the url
            //ReadWebPage is another method in this useful methods collection
            string htmlPage = ReadWebPage(url);

            //set up the regex for finding the link urls
            StringBuilder hrefPattern = new StringBuilder();
            hrefPattern.Append("<a[^>]+"); //start 'a' tag and anything that comes before 'href' tag
            hrefPattern.Append("href\\s*=\\s*"); //start href property
            //three possibilities  for what href property --
            //(1) enclosed in double quotes
            //(2) enclosed in single quotes
            //(3) enclosed in spaces
            hrefPattern.Append("(?:\"(?<href>[^\"]*)\"|'(?<href>[^']*)'|(?<href>[^\"'>\\s]+))");
            hrefPattern.Append("[^>]*>.*?</a>"); //end of 'a' tag
            Regex hrefRegex = new Regex(hrefPattern.ToString(), RegexOptions.IgnoreCase);

            //look for matches 
            Match hrefcheck = hrefRegex.Match(htmlPage);
            ArrayList linklist = new ArrayList();
            //add base href for relative links
            linklist.Add("<BASE href=\"" + url + "\">" + url);
            while (hrefcheck.Success) {
                string href = hrefcheck.Groups["href"].Value; //link url
                string link = (makeLinkable)
                  ? "<a href=\"" + href + "\" target=\"_blank\">" + href + "</a>" : href;
                linklist.Add(link);
                hrefcheck = hrefcheck.NextMatch();
            }
            string[] links = new string[linklist.Count];
            linklist.CopyTo(links);

            return links;
        }

        /// <summary>
        /// Whether or not the request originated from the local network, or more specifically from localhost or a NAT address.
        /// This property is only accurate if NAT addresses are a valid indicators of a request being from within the internal network.
        /// </summary>
        public static bool IsLocalNetworkRequest
        {   
            get
            {
                if(HttpContext.Current != null)
                {
                    if(HttpContext.Current.Request.IsLocal)
                    {
                        return true;
                    }
                    string hostPrefix = HttpContext.Current.Request.UserHostAddress;
                    string[] ipClass = hostPrefix.Split(new char[] {'.'});
                    int classA = Convert.ToInt16(ipClass[0]);
                    int classB = Convert.ToInt16(ipClass[1]);
                    if(classA == 10 || classA == 127)
                    {
                        return true;
                    }
                    else if(classA == 192 && classB == 168)
                    {
                        return true;
                    }
                    else if(classA == 172 && (classB > 15 && classB < 33))
                    {
                        return true;
                    }
                    return false;
                }
                return false;
            }
        }

        /// <summary>
        /// Given a valid email address, returns a short javascript block that will emit a valid
        /// mailto: link that can't be picked up by address harvesters. Call this method where you
        /// would normally place the link in your html code.
        /// </summary>
        /// <param name="emailText">The email address to convert to spam-free format</param>
        /// <returns></returns>
        public static string CreateSpamFreeEmailLink(string emailText)
        {
            if (!String.IsNullOrEmpty(emailText))
            {
                string[] parts = emailText.Split(new char[] { '@' });
                if (parts.Length == 2)
                {
                    StringBuilder sb = new StringBuilder();
                    sb.Append("<script type='text/javascript'>");
                    sb.Append("var m = '" + parts[0] + "';");
                    sb.Append("var a = '" + parts[1] + "';");
                    sb.Append("var l = '" + emailText + "';");
                    sb.Append("document.write('<a href=\"mailto:' + m + '@' + a + '\">' + l + '</a>');");
                    sb.Append("</script>");
                    return sb.ToString();
                }
            }
            return String.Empty;
        }

    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Alex Mueller
Web Developer
United States United States
No Biography provided

You may also be interested in...

| Advertise | Privacy | Mobile
Web03 | 2.8.140922.1 | Last Updated 17 Nov 2007
Article Copyright 2007 by Alex Mueller
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid