The next version of Visual Studio, Microsoft® Visual Studio® 2008, will provide an industry-leading developer experience for Windows Vista, the 2007 Microsoft Office system, and the Web. In addition, it will continue in the Microsoft tradition of development language innovation.

 Planet Source Code

http://abstractvb.com/code.asp?F=1

http://www.a1vbcode.com/

The common type system defines how types are declared, used, and managed in the common language runtime. Each of the data types used in Visual Basic .NET correspond directly to a type defined in the common type system.

A value-type variable directly contains its data. Each value-type variable has its own copy of data, so operations on one value-type variable cannot affect another variable.

A reference-type variable contains a reference or pointer to the value of an object. Two reference-type variables can reference the same object, so operations on one reference-type variable can affect the object referenced by another reference-type variable.

The SearchEnginesFrontEnd servlet shown above sends its data to the CustomizedSearchEngines servlet. In many respects, it is just like the SearchEngines servlet shown in the section on HTTP status codes. However, in addition to constructing a URL for a search engine and sending a redirection response to the client, the servlet also sends cookies recording the user data. These cookies will, in turn, be used by the servlet building the front end to initialize the entries in the HTML forms.

package hall;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.net.*;

/** A varition of the SearchEngine servlet that uses
 *  cookies to remember users choices. These values
 *  are then used by the SearchEngineFrontEnd servlet
 *  to create the form-based front end with these
 *  choices preset.
 *
 *  Part of tutorial on servlets and JSP that appears at
 *  http://www.apl.jhu.edu/~hall/java/Servlet-Tutorial/
 *  1999 Marty Hall; may be freely used or adapted.
 */

public class CustomizedSearchEngines extends HttpServlet {
  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
      throws ServletException, IOException {

    String searchString = request.getParameter("searchString");
    Cookie searchStringCookie =
      new LongLivedCookie("searchString", searchString);
    response.addCookie(searchStringCookie);
    searchString = URLEncoder.encode(searchString);
    String numResults = request.getParameter("numResults");
    Cookie numResultsCookie =
      new LongLivedCookie("numResults", numResults);
    response.addCookie(numResultsCookie);
    String searchEngine = request.getParameter("searchEngine");
    Cookie searchEngineCookie =
      new LongLivedCookie("searchEngine", searchEngine);
    response.addCookie(searchEngineCookie);
    SearchSpec[] commonSpecs = SearchSpec.getCommonSpecs();
    for(int i=0; i<commonSpecs.length; i++) {
      SearchSpec searchSpec = commonSpecs[i];
      if (searchSpec.getName().equals(searchEngine)) {
        String url =
          searchSpec.makeURL(searchString, numResults);
        response.sendRedirect(url);
        return;
      }
    }
    response.sendError(response.SC_NOT_FOUND,
                       "No recognized search engine specified.");
  }

  public void doPost(HttpServletRequest request,
                     HttpServletResponse response)
      throws ServletException, IOException {
    doGet(request, response);
  }
}

This servlet builds the form-based front end to the search engine servlet. At first blush, the output looks just like the page given by the static HTML page presented in the section on HTTP status codes. Here, however, selected values are remembered in cookies (set by the CustomizedSearchEngines servlet that this page sends data to), so if the user comes back to the same page at a later time (even after quitting the browser and restarting), the page is initialized with the values from the previous search.You can also download the source or try it on-line. Note that code uses ServletUtilities.java, for the getCookieValue method (shown above) and for headWithTitle for generating part of the HTML. It also uses the LongLivedCookie class, shown above, for creating a Cookie that automatically has a long-term expiration date.

package hall;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.net.*;

public class SearchEnginesFrontEnd extends HttpServlet {
  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
      throws ServletException, IOException {
    Cookie[] cookies = request.getCookies();
    String searchString =
      ServletUtilities.getCookieValue(cookies,
                                      "searchString",
                                      "Java Programming");
    String numResults =
      ServletUtilities.getCookieValue(cookies,
                                      "numResults",
                                      "10");
    String searchEngine =
      ServletUtilities.getCookieValue(cookies,
                                      "searchEngine",
                                      "google");
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    String title = "Searching the Web";
    out.println(ServletUtilities.headWithTitle(title) +
                "<BODY BGCOLOR=\"#FDF5E6\">n" +
                "<H1 ALIGN=\"CENTER\">Searching the Web</H1>n" +
                "n" +
                "<FORM ACTION=\"/servlet/hall.CustomizedSearchEngines\">n" +
                "<CENTER>n" +
                "Search String:n" +
                "<INPUT TYPE=\"TEXT\" NAME=\"searchString\"n" +
                "       VALUE=\"" + searchString + "\"><BR>n" +
                "Results to Show Per Page:n" +
                "<INPUT TYPE=\"TEXT\" NAME=\"numResults\"n" +
                "       VALUE=" + numResults + " SIZE=3><BR>n" +
                "<INPUT TYPE=\"RADIO\" NAME=\"searchEngine\"n" +
                "       VALUE=\"google\"" +
                checked("google", searchEngine) + ">n" +
                "Google |n" +
                "<INPUT TYPE=\"RADIO\" NAME=\"searchEngine\"n" +
                "       VALUE=\"infoseek\"" +
                checked("infoseek", searchEngine) + ">n" +
                "Infoseek |n" +
                "<INPUT TYPE=\"RADIO\" NAME=\"searchEngine\"n" +
                "       VALUE=\"lycos\"" +
                checked("lycos", searchEngine) + ">n" +
                "Lycos |n" +
                "<INPUT TYPE=\"RADIO\" NAME=\"searchEngine\"n" +
                "       VALUE=\"hotbot\"" +
                checked("hotbot", searchEngine) + ">n" +
                "HotBotn" +
                "<BR>n" +
                "<INPUT TYPE=\"SUBMIT\" VALUE=\"Search\">n" +
                "</CENTER>n" +
                "</FORM>n" +
                "n" +
                "</BODY>n" +
                "</HTML>n");
  }

  private String checked(String name1, String name2) {
    if (name1.equals(name2))
      return(" CHECKED");
    else
      return("");
  }
}

(Download source code)

Here’s a small class that you can use instead of Cookie if you want your cookie to automatically persist when the client quits the browser.

package hall;

import javax.servlet.http.*;

public class LongLivedCookie extends Cookie {
  public static final int SECONDS_PER_YEAR = 60*60*24*365;

  public LongLivedCookie(String name, String value) {
    super(name, value);
    setMaxAge(SECONDS_PER_YEAR);
  }
}

Here’s a section of ServletUtilities.java that slightly simplifies the retrieval of a cookie value given a cookie name by looping through the array of available Cookie objects, returning the value of any Cookie whose name matches the input. If there is no match, the designated default value is returned.

  public static String getCookieValue(Cookie[] cookies,
                                      String cookieName,
                                      String defaultValue) {
    for(int i=0; i<cookies.length; i++) {
      Cookie cookie = cookies[i];
      if (cookieName.equals(cookie.getName()))
        return(cookie.getValue());
    }
    return(defaultValue);
  }

To send cookies to the client, you created a Cookie then used addCookie to send a Set-Cookie HTTP response header. This was discussed above in section 2.1. To read the cookies that come back from the client, you call getCookies on the HttpServletRequest. This returns an array of Cookie objects corresponding to the values that came in on the Cookie HTTP request header. Once you have this array, you typically loop down it, calling getName on each Cookie until you find one matching the name you have in mind. You then call getValue on the matching Cookie, doing some processing specific to the resultant value. This is such a common process that the following section presents a simple getCookieValue method that, given the array of cookies, a name, and a default value, returns the value of the cookie matching the name, or, if there is no such cookie, the designated default value.

The cookie is added to the Set-Cookie response header by means of the addCookie method of HttpServletResponse. Here’s an example:

  Cookie userCookie = new Cookie("user", "uid1234");
  response.addCookie(userCookie);

Before adding the cookie to the outgoing headers, you can look up or set attributes of the cookie. Here’s a summary:

getComment/setComment

Gets/sets a comment associated with this cookie.

getDomain/setDomain

Gets/sets the domain to which cookie applies. Normally, cookies are returned only to the exact hostname that sent them. You can use this method to instruct the browser to return them to other hosts within the same domain. Note that the domain should start with a dot (e.g. .prenhall.com), and must contain two dots for non-country domains like .com, .edu, and .gov, and three dots for country domains like .co.uk and .edu.es.

getMaxAge/setMaxAge

Gets/sets how much time (in seconds) should elapse before the cookie expires. If you don’t set this, the cookie will last only for the current session (i.e. until the user quits the browser), and will not be stored on disk. See the LongLivedCookie class below, which defines a subclass of Cookie with a maximum age automatically set one year in the future.

getName/setName

Gets/sets the name of the cookie. The name and the value are the two pieces you virtually always care about. Since the getCookies method of HttpServletRequest returns an array of Cookie objects, it is common to loop down this array until you have a particular name, then check the value with getValue. See the getCookieValue method shown below.

getPath/setPath

Gets/sets the path to which this cookie applies. If you don’t specify a path, the cookie is returned for all URLs in the same directory as the current page as well as all subdirectories. This method can be used to specify something more general. For example, someCookie.setPath("/") specifies that all pages on the server should receive the cookie. Note that the path specified must include the current directory.

getSecure/setSecure

Gets/sets the boolean value indicating whether the cookie should only be sent over encrypted (i.e. SSL) connections.

getValue/setValue

Gets/sets the value associated with the cookie. Again, the name and the value are the two parts of a cookie that you almost always care about, although in a few cases a name is used as a boolean flag, and its value is ignored (i.e the existence of the name means true).

getVersion/setVersion

Gets/sets the cookie protocol version this cookie complies with. Version 0, the default, adheres to the original Netscape specification. Version 1, not yet widely supported, adheres to RFC 2109