SCRIPTSTER. East Java Baker

Building a Community Site - It's About People, Not Technology

noreply@blogger.com (Octopus) — Mon, 17 Dec 2007 03:54:00 +0000

Sometimes in the online world when approaching a project people seem to classify the issues facing a website as a technology issue. It's as if building a web site is this mysterious thing wrapped in so much technology it's just too much handle. Just sitting in the office of a technology provider gets nerve wracking; hearing all the techno geeks spitting out acronym after acronym and having no idea what any of it means - html, Ajax, XML, HTTP, Java, ASP, .NET, Web services, Web 2.0, what all does it mean?!

I'm here to tell you not to worry about all those acronyms, phrases, and geeks telling you what to do, do what you know. Websites are nothing but a different way of doing your business; bricks and mortar are the traditional way, but they both have something in common and that's people. In this article I'm going to discuss community sites since they're a growing influence on the web and generating plenty of interest.

Community; what do you think of when you hear community? Think of community as your own home town. Anyone who's played Sim City should have some concept of what it takes to build a community. If you remember from the game, you had some cash to build houses, roads, and services. Now let's look at that on the web, you have some money to build a site, network connection to the Internet, and some functionality to the site. The site is your community and to build it, you need to provide some place for people to live.

In the beginning in order to grow your community you have to provide a place for your users to live. Granted a site that is mostly static is nice to visit, but I wouldn't want to live there (sound familiar?). You have to provide something on your site to encourage people to want to live there. There are the usual features like forums, weblogs, profile pages and the like, that's a good start, it gives a person a place to live.

When you add these "living spaces" for your users, consider what they provide, at a minimum they should provide your user community with the ability to express themselves. As in any community whether offline or online people want to express themselves and distinguish themselves from others in the crowd. They build this identity by the clothes they wear, cars they drive, and people they associate with. Online they do something similar; they create avatars, profiles to help them connect with others that have similar interests. And just like in the physical communities people go to churches, community activities, and other places to develop relationships with people that have similar interests. They'll do the same on your website, but you need to provide them with a means to do. So when shopping for interactive applications ensure that they will provide mechanisms for your users to build those relationships.

As a community grows it needs leadership and this is the same online. For example, if your site becomes popular and has forums, usually you'll see a few of your posters become pretty prominate in their activity, posting frequently. By providing them with moderator privileges or some special designation you allow leaders to step up, and provide the community with people who appear to have some connection to the site and help build community and participation. You could extend the moderator concept to enable your users to host online chats, or even participate in podcasts or weblog posts.

As time goes by your site leaders will come and go, and it will be up to you to monitor activity within the site and find leaders. This further enhances the community aspect and allows your community to be dynamic.

Another thing to foster growth and participation is to have periodic contests, contests that allow for some user contributed content is ideal. For example some sites have users submit stories, graphics like humorous graphics, basically anything that builds content for your site, but still enables your population to contribute to the site. The cost is relatively low, and if you have the traffic you may be able to work relationships with sponsors to provide the spoils to the winner.

The main idea to take from this article is community sites are not about technology, they're about people. Find out what people like and enable them to "own" your site. If you do this your site is sure to grow and prosper. Good luck!

Patrick Santry, owner of WWWCoder.com. Is an MVP, and has over 13 years in web and eBusiness strategy. His current position is a Solution Architect for the Blue Chip Consulting Group, LLC. in Cleveland, OH.

URL Rewriting in ASP.NET

noreply@blogger.com (Octopus) — Mon, 17 Dec 2007 03:52:00 +0000

Scott Mitchell
4GuysFromRolla.com

Introduction

Take a moment to look at some of the URLs on your website. Do you find URLs like http://yoursite.com/info/dispEmployeeInfo.aspx?EmpID=459-099&type=summary? Or maybe you have a bunch of Web pages that were moved from one directory or website to another, resulting in broken links for visitors who have bookmarked the old URLs. In this article we'll look at using URL rewriting to shorten those ugly URLs to meaningful, memorable ones, by replacing http://yoursite.com/info/dispEmployeeInfo.aspx?EmpID=459-099&type=summary with something like http://yoursite.com/people/sales/chuck.smith. We'll also see how URL rewriting can be used to create an intelligent 404 error.

URL rewriting is the process of intercepting an incoming Web request and redirecting the request to a different resource. When performing URL rewriting, typically the URL being requested is checked and, based on its value, the request is redirected to a different URL. For example, in the case where a website restructuring caused all of the Web pages in the /people/ directory to be moved to a /info/employees/ directory, you would want to use URL rewriting to check if a Web request was intended for a file in the /people/ directory. If the request was for a file in the /people/ directory, you'd want to automatically redirect the request to the same file, but in the /info/employees/ directory instead.

With classic ASP, the only way to utilize URL rewriting was to write an ISAPI filter or to buy a third-party product that offered URL rewriting capabilities. With Microsoft® ASP.NET, however, you can easily create your own URL rewriting software in a number of ways. In this article we'll examine the techniques available to ASP.NET developers for implementing URL rewriting, and then turn to some real-world uses of URL rewriting. Before we delve into the technological specifics of URL rewriting, let's first take a look at some everyday scenarios where URL rewriting can be employed.

Common Uses of URL Rewriting

Creating data-driven ASP.NET websites often results in a single Web page that displays a subset of the database's data based on querystring parameters. For example, in designing an e-commerce site, one of your tasks would be to allow users to browse through the products for sale. To facilitate this, you might create a page called displayCategory.aspx that would display the products for a given category. The category's products to view would be specified by a querystring parameter. That is, if the user wanted to browse the Widgets for sale, and all Widgets had a had a CategoryID of 5, the user would visit: http://yousite.com/displayCategory.aspx?CategoryID=5.

There are two downsides to creating a website with such URLs. First, from the end user's perspective, the URL http://yousite.com/displayCategory.aspx?CategoryID=5 is a mess. Usability expert Jakob Neilsen recommends that URLs be chosen so that they:

Are short.
Are easy to type.
Visualize the site structure.
"Hackable," allowing the user to navigate through the site by hacking off parts of the URL.

I would add to that list that URLs should also be easy to remember. The URL http://yousite.com/displayCategory.aspx?CategoryID=5 meets none of Neilsen's criteria, nor is it easy to remember. Asking users to type in querystring values makes a URL hard to type and makes the URL "hackable" only by experienced Web developers who have an understanding of the purpose of querystring parameters and their name/value pair structure.

A better approach is to allow for a sensible, memorable URL, such as http://yoursite.com/products/Widgets. By just looking at the URL you can infer what will be displayed—information about Widgets. The URL is easy to remember and share, too. I can tell my colleague, "Check out yoursite.com/products/Widgets," and she'll likely be able to bring up the page without needing to ask me again what the URL was. (Try doing that with, say, an Amazon.com page!) The URL also appears, and should behave, "hackable." That is, if the user hacks of the end of the URL, and types in http://yoursite.com/products, they should see a listing of all products, or at least a listing of all categories of products they can view.

Note For a prime example of a "hackable" URL, consider the URLs generated by many blog engines. To view the posts for January 28, 2004, one visits a URL like http://someblog.com/2004/01/28. If the URL is hacked down to http://someblog.com/2004/01, the user will see all posts for January 2004. Cutting it down further to http://someblog.com/2004 will display all posts for the year 2004.

In addition to simplifying URLs, URL rewriting is also often used to handle website restructuring that would otherwise result in numerous broken links and outdated bookmarks.

What Happens When a Request Reaches IIS

Before we examine exactly how to implement URL rewriting, it's important that we have an understanding of how incoming requests are handled by Microsoft® Internet Information Services (IIS). When a request arrives at an IIS Web server, IIS examines the requested file's extension to determine how handle the request. Requests can be handled natively by IIS—as are HTML pages, images, and other static content—or IIS can route the request to an ISAPI extension. (An ISAPI extension is an unmanaged, compiled class that handles an incoming Web request. Its task is to generate the content for the requested resource.)

For example, if a request comes in for a Web page named Info.asp, IIS will route the message to the asp.dll ISAPI extension. This ISAPI extension will then load the requested ASP page, execute it, and return its rendered HTML to IIS, which will then send it back to the requesting client. For ASP.NET pages, IIS routes the message to the aspnet_isapi.dll ISAPI extension. The aspnet_isapi.dll ISAPI extension then hands off processing to the managed ASP.NET worker process, which processes the request, returning the ASP.NET Web page's rendered HTML.

You can customize IIS to specify what extensions are mapped to what ISAPI extensions. Figure 1 shows the Application Configuration dialog box from the Internet Information Services Administrative Tool. Note that the ASP.NET-related extensions—.aspx, .ascx, .config, .asmx, .rem, .cs, .vb, and others—are all mapped to the aspnet_isapi.dll ISAPI extension.

Figure 1. Configured mappings for file extensions

A thorough discussion of how IIS manages incoming requests is a bit beyond the scope of this article. A great, in-depth discussion, though, can be found in Michele Leroux Bustamante's article Inside IIS and ASP.NET. It's important to understand that the ASP.NET engine gets its hands only on incoming Web requests whose extensions are explicitly mapped to the aspnet_isapi.dll in IIS.

Examining Requests with ISAPI Filters

In addition to mapping the incoming Web request's file extension to the appropriate ISAPI extension, IIS also performs a number of other tasks. For example, IIS attempts to authenticate the user making the request and determine if the authenticated user has authorization to access the requested file. During the lifetime of handling a request, IIS passes through several states. At each state, IIS raises an event that can be programmatically handled using ISAPI filters.

Like ISAPI extensions, ISAPI filters are blocks of unmanaged code installed on the Web server. ISAPI extensions are designed to generate the response for a request to a particular file type. ISAPI filters, on the other hand, contain code to respond to events raised by IIS. ISAPI filters can intercept and even modify the incoming and outgoing data. ISAPI filters have numerous applications, including:

Authentication and authorization.
Logging and monitoring.
HTTP compression.
URL rewriting.

While ISAPI filters can be used to perform URL rewriting, this article examines implementing URL rewriting using ASP.NET. However, we will discuss the tradeoffs between implementing URL rewriting as an ISAPI filter versus using techniques available in ASP.NET.

What Happens When a Request Enters the ASP.NET Engine

Prior to ASP.NET, URL rewriting on IIS Web servers needed to be implemented using an ISAPI filter. URL rewriting is possible with ASP.NET because the ASP.NET engine is strikingly similar to IIS. The similarities arise because the ASP.NET engine:

Raises events as it processes a request.
Allows an arbitrary number of HTTP modules handle the events that are raised, akin to IIS's ISAPI filters.
Delegates rendering the requested resource to an HTTP handler, which is akin to IIS's ISAPI extensions.

Like IIS, during the lifetime of a request the ASP.NET engine fires events signaling its change from one state of processing to another. The BeginRequest event, for example, is fired when the ASP.NET engine first responds to a request. The AuthenticateRequest event fires next, which occurs when the identity of the user has been established. (There are numerous other events—AuthorizeRequest, ResolveRequestCache, and EndRequest, among others. These events are events of the System.Web.HttpApplication class; for more information consult the HttpApplication Class Overview technical documentation.)

As we discussed in the previous section, ISAPI filters can be created to respond to the events raised by IIS. In a similar vein, ASP.NET provides HTTP modules that can respond to the events raised by the ASP.NET engine. An ASP.NET Web application can be configured to have multiple HTTP modules. For each request processed by the ASP.NET engine, each configured HTTP module is initialized and allowed to wire up event handlers to the events raised during the processing of the request. Realize that there are a number of built-in HTTP modules utilized on each an every request. One of the built-in HTTP modules is the FormsAuthenticationModule, which first checks to see if forms authentication is being used and, if so, whether the user is authenticated or not. If not, the user is automatically redirected to the specified logon page.

Recall that with IIS, an incoming request is eventually directed to an ISAPI extension, whose job it is to return the data for the particular request. For example, when a request for a classic ASP Web page arrives, IIS hands off the request to the asp.dll ISAPI extension, whose task it is to return the HTML markup for the requested ASP page. The ASP.NET engine utilizes a similar approach. After initializing the HTTP modules, the ASP.NET engine's next task is to determine what HTTP handler should process the request.

All requests that pass through the ASP.NET engine eventually arrive at an HTTP handler or an HTTP handler factory (an HTTP handler factory simply returns an instance of an HTTP handler that is then used to process the request). The final HTTP handler renders the requested resource, returning the response. This response is sent back to IIS, which then returns it to the user that made the request.

ASP.NET includes a number of built-in HTTP handlers. The PageHandlerFactory, for example, is used to render ASP.NET Web pages. The WebServiceHandlerFactory is used to render the response SOAP envelopes for ASP.NET Web services. The TraceHandler renders the HTML markup for requests to trace.axd.

Figure 2 illustrates how a request for an ASP.NET resource is handled. First, IIS receives the request and dispatches it to aspnet_isapi.dll. Next, the ASP.NET engine initializes the configured HTTP modules. Finally, the proper HTTP handler is invoked and the requested resource is rendered, returning the generated markup back to IIS and back to the requesting client.

Figure 2. Request processing by IIS and ASP.NET

Creating and Registering Custom HTTP Modules and HTTP Handlers

Creating custom HTTP modules and HTTP handlers are relatively simple tasks, which involve created a managed class that implements the correct interface. HTTP modules must implement the System.Web.IHttpModule interface, while HTTP handlers and HTTP handler factories must implement the System.Web.IHttpHandler interface and System.Web.IHttpHandlerFactory interface, respectively. The specifics of creating HTTP handlers and HTTP modules is beyond the scope of this article. For a good background, read Mansoor Ahmed Siddiqui's article, HTTP Handlers and HTTP Modules in ASP.NET.

Once a custom HTTP module or HTTP handler has been created, it must be registered with the Web application. Registering HTTP modules and HTTP handlers for an entire Web server requires only a simple addition to the machine.config file; registering an HTTP module or HTTP handler for a specific Web application involves adding a few lines of XML to the application's Web.config file.

Specifically, to add an HTTP module to a Web application, add the following lines in the Web.config's configuration/system.web section:

The type value provides the assembly and class name of the HTTP module, whereas the name value provides a friendly name by which the HTTP module can be referred to in the Global.asax file.

HTTP handlers and HTTP handler factories are configured by the tag in the Web.config's configuration/system.web section, like so:

Recall that for each incoming request, the ASP.NET engine determines what HTTP handler should be used to render the request. This decision is made based on the incoming requests verb and path. The verb specifies what type of HTTP request was made—GET or POST—whereas the path specifies the location and filename of the file requested. So, if we wanted to have an HTTP handler handle all requests—either GET or POST—for files with the .scott extension, we'd add the following to the Web.config file:

where type was the type of our HTTP handler.

Note When registering HTTP handlers, it is important to ensure that the extensions used by the HTTP handler are mapped in IIS to the ASP.NET engine. That is, in our .scott example, if the .scott extension is not mapped in IIS to the aspnet_isapi.dll ISAPI extension, a request for the file foo.scott will result in IIS attempting to return the contents of the file foo.scott. In order for the HTTP handler to process this request, the .scott extension must be mapped to the ASP.NET engine. The ASP.NET engine, then, will route the request correctly to the appropriate HTTP handler.

For more information on registering HTTP modules and HTTP handlers, be sure to consult the element documentation along with the element documentation.

Implementing URL Rewriting

URL rewriting can be implemented either with ISAPI filters at the IIS Web server level, or with either HTTP modules or HTTP handlers at the ASP.NET level. This article focuses on implementing URL rewriting with ASP.NET, so we won't be delving into the specifics of implementing URL rewriting with ISAPI filters. There are, however, numerous third-party ISAPI filters available for URL rewriting, such as:

Implementing URL rewriting at the ASP.NET level is possible through the System.Web.HttpContext class's RewritePath() method. The HttpContext class contains HTTP-specific information about a specific HTTP request. With each request received by the ASP.NET engine, an HttpContext instance is created for that request. This class has properties like: Request and Response, which provide access to the incoming request and outgoing response; Application and Session, which provide access to application and session variables; User, which provides information about the authenticated user; and other related properties.

With the Microsoft® .NET Framework Version 1.0, the RewritePath() method accepts a single string, the new path to use. Internally, the HttpContext class's RewritePath(string) method updates the Request object's Path and QueryString properties. In addition to RewritePath(string), the .NET Framework Version 1.1 includes another form of the RewritePath() method, one that accepts three string input parameters. This alternate overloaded form not only sets the Request object's Path and QueryString properties, but also sets internal member variables that are used to compute the Request object's values for its PhysicalPath, PathInfo, and FilePath properties.

To implement URL rewriting in ASP.NET, then, we need to create an HTTP module or HTTP handler that:

Checks the requested path to determine if the URL needs to be rewritten.
Rewrites the path, if needed, by calling the RewritePath() method.

For example, imagine that our website had information each employee, accessible through /info/employee.aspx?empID=employeeID. To make the URLs more "hackable," we might decide to have employee pages accessible by: /people/EmployeeName.aspx. Here is a case where we'd want to use URL rewriting. That is, when the page /people/ScottMitchell.aspx was requested, we'd want to rewrite the URL so that the page /info/employee.aspx?empID=1001 was used instead.

URL Rewriting with HTTP Modules

When performing URL rewriting at the ASP.NET level you can use either an HTTP module or an HTTP handler to perform the rewriting. When using an HTTP module, you must decide at what point during the request's lifecycle to check to see if the URL needs to be rewritten. At first glance, this may seem to be an arbitrary choice, but the decision can impact your application in both significant and subtle ways. The choice of where to perform the rewrite matters because the built-in ASP.NET HTTP modules use the Request object's properties to perform their duties. (Recall that rewriting the path alters the Request object's property values.) These germane built-in HTTP modules and the events they tie into are listed below:

HTTP Module	Event	Description
FormsAuthenticationModule	AuthenticateRequest	Determines if the user is authenticated using forms authentication. If not, the user is automatically redirected to the specified logon page.
FileAuthorizationMoudle	AuthorizeRequest	When using Windows authentication, this HTTP module checks to ensure that the Microsoft® Windows® account has adequate rights for the resource requested.
UrlAuthorizationModule	AuthorizeRequest	Checks to make sure the requestor can access the specified URL. URL authorization is specified through the and elements in the Web.config file.

Recall that the BeginRequest event fires before AuthenticateRequest, which fires before AuthorizeRequest.

One safe place that URL rewriting can be performed is in the BeginRequest event. That means that if the URL needs to be rewritten, it will have done so by the time any of the built-in HTTP modules run. The downside to this approach arises when using forms authentication. If you've used forms authentication before, you know that when the user visits a restricted resource, they are automatically redirected to a specified login page. After successfully logging in, the user is sent back to the page they attempted to access in the first place.

If URL rewriting is performed in the BeginRequest or AuthenticateRequest events, the login page will, when submitted, redirect the user to the rewritten page. That is, imagine that a user types into their browser window, /people/ScottMitchell.aspx, which is rewritten to /info/employee.aspx?empID=1001. If the Web application is configured to use forms authentication, when the user first visits /people/ScottMitchell.aspx, first the URL will be rewritten to /info/employee.aspx?empID=1001; next, the FormsAuthenticationModule will run, redirecting the user to the login page, if needed. The URL the user will be sent to upon successfully logging in, however, will be /info/employee.aspx?empID=1001, since that was the URL of the request when the FormsAuthenticationModule ran.

Similarly, when performing rewriting in the BeginRequest or AuthenticateRequest events, the UrlAuthorizationModule sees the rewritten URL. That means that if you use elements in your Web.config file to specify authorization for specific URLs, you will have to refer to the rewritten URL.

To fix these subtleties, you might decide to perform the URL rewriting in the AuthorizeRequest event. While this approach fixes the URL authorization and forms authentication anomalies, it introduces a new wrinkle: file authorization no longer works. When using Windows authentication, the FileAuthorizationModule checks to make sure that the authenticated user has the appropriate access rights to access the specific ASP.NET page.

Imagine if a set of users does not have Windows-level file access to C:\Inetput\wwwroot\info\employee.aspx; if such users attempt to visit /info/employee.aspx?empID=1001, then they will get an authorization error. However, if we move the URL rewriting to the AuthenticateRequest event, when the FileAuthorizationModule checks the security settings, it still thinks the file being requested is /people/ScottMitchell.aspx, since the URL has yet to be rewritten. Therefore, the file authorization check will pass, allowing this user to view the content of the rewritten URL, /info/employee.aspx?empID=1001.

So, when should URL rewriting be performed in an HTTP module? It depends on what type of authentication you're employing. If you're not using any authentication, then it doesn't matter if URL rewriting happens in BeginRequest, AuthenticateRequest, or AuthorizeRequest. If you are using forms authentication and are not using Windows authentication, place the URL rewriting in the AuthorizeRequest event handler. Finally, if you are using Windows authentication, schedule the URL rewriting during the BeginRequest or AuthenticateRequest events.

URL Rewriting in HTTP Handlers

URL rewriting can also be performed by an HTTP handler or HTTP handler factory. Recall that an HTTP handler is a class responsible for generating the content for a specific type of request; an HTTP handler factory is a class responsible for returning an instance of an HTTP handler that can generate the content for a specific type of request.

In this article we'll look at creating a URL rewriting HTTP handler factory for ASP.NET Web pages. HTTP handler factories must implement the IHttpHandlerFactory interface, which includes a GetHandler() method. After initializing the appropriate HTTP modules, the ASP.NET engine determines what HTTP handler or HTTP handler factory to invoke for the given request. If an HTTP handler factory is to be invoked, the ASP.NET engine calls that HTTP handler factory's GetHandler() method passing in the HttpContext for the Web request, along with some other information. The HTTP handler factory, then, must return an object that implements IHttpHandler that can handle the request.

To perform URL rewriting through an HTTP handler, we can create an HTTP handler factory whose GetHandler() method checks the requested path to determine if it needs to be rewritten. If it does, it can call the passed-in HttpContext object's RewritePath() method, as discussed earlier. Finally, the HTTP handler factory can return the HTTP handler returned by the System.Web.UI.PageParser class's GetCompiledPageInstance() method. (This is the same technique by which the built-in ASP.NET Web page HTTP handler factory, PageHandlerFactory, works.)

Since all of the HTTP modules will have been initialized prior to the custom HTTP handler factory being instantiated, using an HTTP handler factory presents the same challenges when placing the URL rewriting in the latter stages of the events—namely, file authorization will not work. So, if you rely on Windows authentication and file authorization, you will want to use the HTTP module approach for URL rewriting.

Over the next section we'll look at building a reusable URL rewriting engine. Following our examination of the URL rewriting engine—which is available in this article's code download—we'll spend the remaining two sections examining real-world uses of URL rewriting. First we'll look at how to use the URL rewriting engine and look at a simple URL rewriting example. Following that, we'll utilize the power of the rewriting engine's regular expression capabilities to provide truly "hackable" URLs.

Building a URL Rewriting Engine

To help illustrate how to implement URL rewriting in an ASP.NET Web application, I created a URL rewriting engine. This rewriting engine provides the following functionality:

The ASP.NET page developer utilizing the URL rewriting engine can specify the rewriting rules in the Web.config file.
The rewriting rules can use regular expressions to allow for powerful rewriting rules.
URL rewriting can be easily configured to use an HTTP module or an HTTP handler.

In this article we will examine URL rewriting with just the HTTP module. To see how HTTP handlers can be used to perform URL rewriting, consult the code available for download with this article.

Specifying Configuration Information for the URL Rewriting Engine

Let's examine the structure of the rewrite rules in the Web.config file. First, you'll need to indicate in the Web.config file if you want perform URL rewriting with the HTTP module or the HTTP handler. In the download, the Web.config file contains two entries that have been commented out:

Comment out the entry to use the HTTP module for rewriting; comment out the entry instead to use the HTTP handler for rewriting.

In addition to specifying whether the HTTP module or HTTP handler is used for rewriting, the Web.config file contains the rewriting rules. A rewriting rule is composed of two strings: the pattern to look for in the requested URL, and the string to replace the pattern with, if found. This information is expressed in the Web.config file using the following syntax:


  
  
     pattern to look for
     string to replace pattern with
  
  
     pattern to look for
     string to replace pattern with
  
  ...

Each rewrite rule is expressed by a element. The pattern to search for is specified by the element, while the string to replace the found pattern with is entered in the element. These rewrite rules are evaluated from top to bottom. If a match is found, the URL is rewritten and the search through the rewriting rules terminates.

When specifying patterns in the element, realize that regular expressions are used to perform the matching and string replacement. (In a bit we'll look at a real-world example that illustrates how to search for a pattern using regular expressions.) Since the pattern is a regular expression, be sure to escape any characters that are reserved characters in regular expressions. (Some of the regular expression reserved characters include: ., ?, ^, $, and others. These can be escaped by being preceded with a backslash, like \. to match a literal period.)

URL Rewriting with an HTTP Module

Creating an HTTP module is as simple as creating a class that implements the IHttpModule interface. The IHttpModule interface defines two methods:

Init(HttpApplication). This method fires when the HTTP module is initialized. In this method you'll wire up event handlers to the appropriate HttpApplication events.
Dispose(). This method is invoked when the request has completed and been sent back to IIS. Any final cleanup should be performed here.

To facilitate creating an HTTP module for URL rewriting, I started by creating an abstract base class, BaseModuleRewriter. This class implements IHttpModule. In the Init() event, it wires up the HttpApplication's AuthorizeRequest event to the BaseModuleRewriter_AuthorizeRequest method. The BaseModuleRewriter_AuthorizeRequest method calls the class's Rewrite() method passing in the requested Path along with the HttpApplication object that was passed into the Init() method. The Rewrite() method is abstract, meaning that in the BaseModuleRewriter class, the Rewrite() method has no method body; rather, the class being derived from BaseModuleRewriter must override this method and provide a method body.

With this base class in place, all we have to do now is to create a class derived from BaseModuleRewriter that overrides Rewrite() and performs the URL rewriting logic there. The code for BaseModuleRewriter is shown below.

public abstract class BaseModuleRewriter : IHttpModule
{
  public virtual void Init(HttpApplication app)
  {
     // WARNING!  This does not work with Windows authentication!
     // If you are using Windows authentication,
     // change to app.BeginRequest
     app.AuthorizeRequest += new
        EventHandler(this.BaseModuleRewriter_AuthorizeRequest);
  }

  public virtual void Dispose() {}

  protected virtual void BaseModuleRewriter_AuthorizeRequest(
    object sender, EventArgs e)
  {
     HttpApplication app = (HttpApplication) sender;
     Rewrite(app.Request.Path, app);
  }

  protected abstract void Rewrite(string requestedPath,
    HttpApplication app);
}

Notice that the BaseModuleRewriter class performs URL rewriting in the AuthorizeRequest event. Recall that if you use Windows authentication with file authorization, you will need to change this so that URL rewriting is performed in either the BeginRequest or AuthenticateRequest events.

The ModuleRewriter class extends the BaseModuleRewriter class and is responsible for performing the actual URL rewriting. ModuleRewriter contains a single overridden method—Rewrite()—which is shown below:

protected override void Rewrite(string requestedPath,
  System.Web.HttpApplication app)
{
  // get the configuration rules
  RewriterRuleCollection rules =
    RewriterConfiguration.GetConfig().Rules;

  // iterate through each rule...
  for(int i = 0; i < rules.Count; i++)
  {
     // get the pattern to look for, and
     // Resolve the Url (convert ~ into the appropriate directory)
     string lookFor = "^" +
       RewriterUtils.ResolveUrl(app.Context.Request.ApplicationPath,
       rules[i].LookFor) + "$";

     // Create a regex (note that IgnoreCase is set...)
     Regex re = new Regex(lookFor, RegexOptions.IgnoreCase);

     // See if a match is found
     if (re.IsMatch(requestedPath))
     {
        // match found - do any replacement needed
        string sendToUrl =
RewriterUtils.ResolveUrl(app.Context.Request.ApplicationPath,
           re.Replace(requestedPath, rules[i].SendTo));

        // Rewrite the URL
        RewriterUtils.RewriteUrl(app.Context, sendToUrl);
        break;      // exit the for loop
     }
  }
}

The Rewrite() method starts with getting the set of rewriting rules from the Web.config file. It then iterates through the rewrite rules one at a time, and for each rule, it grabs its LookFor property and uses a regular expression to determine if a match is found in the requested URL.

If a match is found, a regular expression replace is performed on the requested path with the value of the SendTo property. This replaced URL is then passed into the RewriterUtils.RewriteUrl() method. RewriterUtils is a helper class that provides a couple of static methods used by both the URL rewriting HTTP module and HTTP handler. The RewriterUrl() method simply calls the HttpContext object's RewriteUrl() method.

Note You may have noticed that when performing the regular expression match and replacement, a call to RewriterUtils.ResolveUrl() is made. This helper method simply replaces any instances of ~ in the string with the value of the application's path.

The entire code for the URL rewriting engine is available for download with this article. We've examined the most germane pieces, but there are other components as well, such as classes for deserializing the XML-formatted rewriting rules in the Web.config file into an object, as well as the HTTP handler factory for URL rewriting. The remaining three sections of this article examine real-world uses of URL rewriting.

Performing Simple URL Rewriting with the URL Rewriting Engine

To demonstrate the URL rewriting engine in action, let's build an ASP.NET Web application that utilizes simple URL rewriting. Imagine that we work for a company that sells assorted products online. These products are broken down into the following categories:

Category ID	Category Name
1	Beverages
2	Condiments
3	Confections
4	Dairy Products
...	...

Assume we already have created an ASP.NET Web page called ListProductsByCategory.aspx that accepts a Category ID value in the querystring and displays all of the products belonging to that category. So, users who wanted to view our Beverages for sale would visit ListProductsByCategory.aspx?CategoryID=1, while users who wanted to view our Dairy Products would visit ListProductsByCategory.aspx?CategoryID=4. Also assume we have a page called ListCategories.aspx, which lists the categories of products for sale.

Clearly this is a case for URL rewriting, as the URLs a user is presented with do not carry any significance for the user, nor do they provide any "hackability." Rather, let's employ URL rewriting so that when a user visits /Products/Beverages.aspx, their URL will be rewritten to ListProductsByCategory.aspx?CategoryID=1. We can accomplish this with the following URL rewriting rule in the Web.config file:


  
     
     
        ~/Products/Beverages\.aspx
        ~/ListProductsByCategory.aspx?CategoryID=1

As you can see, this rule searches to see if the path requested by the user was /Products/Beverages.aspx. If it was, it rewrites the URL as /ListProductsByCategory.aspx?CategoryID=1.

Note Notice that the element escapes the period in Beverages.aspx. This is because the value is used in a regular expression pattern, and period is a special character in regular expressions meaning "match any character," meaning a URL of /Products/BeveragesQaspx, for example, would match. By escaping the period (using \.) we are indicating that we want to match a literal period, and not any old character.

With this rule in place, when a user visits /Products/Beverages.aspx, they will be shown the beverages for sale. Figure 3 shows a screenshot of a browser visiting /Products/Beverages.aspx. Notice that in the browser's Address bar the URL reads /Products/Beverages.aspx, but the user is actually seeing the contents of ListProductsByCategory.aspx?CategoryID=1. (In fact, there doesn't even exist a /Products/Beverages.aspx file on the Web server at all!)

Figure 3. Requesting category after rewriting URL

Similar to /Products/Beverages.aspx, we'd next add rewriting rules for the other product categories. This simply involves adding additional elements within the element in the Web.config file. Consult the Web.config file in the download for the complete set of rewriting rules for the demo.

To make the URL more "hackable," it would be nice if a user could simply hack off the Beverages.aspx from /Products/Beverages.aspx and be shown a listing of the product categories. At first glance, this may appear a trivial task—just add a rewriting rule that maps /Products/ to /ListCategories.aspx. However, there is a fine subtlety—you must first create a /Products/ directory and add an empty Default.aspx file in the /Products/ directory.

To understand why these extra steps need to be performed, recall that the URL rewriting engine is at the ASP.NET level. That is, if the ASP.NET engine is never given the opportunity to process the request, there's no way the URL rewriting engine can inspect the incoming URL. Furthermore, remember that IIS hands off incoming requests to the ASP.NET engine only if the requested file has an appropriate extension. So if a user visits /Products/, IIS doesn't see any file extension, so it checks the directory to see if there exists a file with one of the default filenames. (Default.aspx, Default.htm, Default.asp, and so on. These default filenames are defined in the Documents tab of the Web Server Properties dialog box in the IIS Administration dialog box.) Of course, if the /Products/ directory doesn't exist, IIS will return an HTTP 404 error.

So, we need to create the /Products/ directory. Additionally, we need to create a single file in this directory, Default.aspx. This way, when a user visits /Products/, IIS will inspect the directory, see that there exists a file named Default.aspx, and then hand off processing to the ASP.NET engine. Our URL rewriter, then, will get a crack at rewriting the URL.

After creating the directory and Default.aspx file, go ahead and add the following rewriting rule to the element:


  ~/Products/Default\.aspx
  ~/ListCategories.aspx

With this rule in place, when a user visits /Products/ or /Products/Default.aspx, they will see the listing of product categories, shown in Figure 4.

Figure 4. Adding "hackability" to the URL

Handling Postbacks

If the URLs you are rewriting contain a server-side Web Form and perform postbacks, when the form posts back, the underlying URL will be used. That is, if our user enters into their browser, /Products/Beverages.aspx, they will still see in their browser's Address bar, /Products/Beverages.aspx, but they will be shown the content for ListProductsByCategory.aspx?CategoryID=1. If ListProductsByCategory.aspx performs a postback, the user will be posted back to ListProductsByCategory.aspx?CategoryID=1, not /Products/Beverages.aspx. This won't break anything, but it can be disconcerting from the user's perspective to see the URL change suddenly upon clicking a button.

The reason this behavior happens is because when the Web Form is rendered, it explicitly sets its action attribute to the value of the file path in the Request object. Of course, by the time the Web Form is rendered, the URL has been rewritten from /Products/Beverages.aspx to ListProductsByCategory.aspx?CategoryID=1, meaning the Request object is reporting that the user is visiting ListProductsByCategory.aspx?CategoryID=1. This problem can be fixed by having the server-side form simply not render an action attribute. (Browsers, by default, will postback if the form doesn't contain an action attribute.)

Unfortunately, the Web Form does not allow you to explicitly specify an action attribute, nor does it allow you to set some property to disable the rendering of the action attribute. Rather, we'll have to extend the System.Web.HtmlControls.HtmlForm class ourselves, overriding the RenderAttribute() method and explicitly indicating that it not render the action attribute.

Thanks to the power of inheritance, we can gain all of the functionality of the HtmlForm class and only have to add a scant few lines of code to achieve the desired behavior. The complete code for the custom class is shown below:

namespace ActionlessForm {
 public class Form : System.Web.UI.HtmlControls.HtmlForm
 {
    protected override void RenderAttributes(HtmlTextWriter writer)
    {
       writer.WriteAttribute("name", this.Name);
       base.Attributes.Remove("name");

       writer.WriteAttribute("method", this.Method);
       base.Attributes.Remove("method");

       this.Attributes.Render(writer);

       base.Attributes.Remove("action");

       if (base.ID != null)
          writer.WriteAttribute("id", base.ClientID);
    }
 }
}

The code for the overridden RenderAttributes() method simply contains the exact code from the HtmlForm class's RenderAttributes() method, but without setting the action attribute. (I used Lutz Roeder's Reflector to view the source code of the HtmlForm class.)

Once you have created this class and compiled it, to use it in an ASP.NET Web application, start by adding it to the Web application's References folder. Then, to use it in place of the HtmlForm class, simply add the following to the top of your ASP.NET Web page:

<%@ Register TagPrefix="skm" Namespace="ActionlessForm"
  Assembly="ActionlessForm" %>

Then, where you have

You can see this custom Web Form class in action in ListProductsByCategory.aspx, which is included in this article's download. Also included in the download is a Visual Studio .NET project for the action-less Web Form.

Note If the URL you are rewriting to does not perform a postback, there's no need to use this custom Web Form class.

Creating Truly "Hackable" URLs

The simple URL rewriting demonstrated in the previous section showed how easily the URL rewriting engine can be configured with new rewriting rules. The true power of the rewriting rules, though, shines when using regular expressions, as we'll see in this section.

Blogs are becoming more and more popular these days, and it seems everyone has their own blog. If you are not familiar with blogs, they are often-updated personal pages that typically serve as an online journal. Most bloggers simply write about their day-to-day happenings, others focus on blogging about a specific theme, such as movie reviews, a sports team, or a computer technology.

Depending on the author, blogs are updated anywhere from several times a day to once every week or two. Typically the blog homepage shows the most recent 10 entries, but virtually all blogging software provides an archive through which visitors can read older postings. Blogs are a great application for "hackable" URLs. Imagine while searching through the archives of a blog you found yourself at the URL /2004/02/14.aspx. Would you be terribly surprised if you found yourself reading the posts made on February 14th, 2004? Furthermore, you might want to view all posts for February 2004, in which case you might try hacking the URL to /2004/02/. To view all 2004 posts, you might try visiting /2004/.

When maintaining a blog, it would be nice to provide this level of URL "hackability" to your visitors. While many blog engines provide this functionality, let's look at how it can be accomplished using URL rewriting.

First, we need a single ASP.NET Web page that will show blog entries by day, month, or year. Assume we have such a page, ShowBlogContent.aspx, that takes in querystring parameters year, month, and day. To view the posts for February 14th, 2004, we could visit ShowBlogContent.aspx?year=2004&month=2&day=14. To view all posts for February 2004, we'd visit ShowBlogContent.aspx?year=2004&month=2. Finally, to see all posts for the year 2004, we'd navigate to ShowBlogContent.aspx?year=2004. (The code for ShowBlogContent.aspx can be found in this article's download.)

So, if a user visits /2004/02/14.aspx, we need to rewrite the URL to ShowBlogContent.aspx?year=2004&month=2&day=14. All three cases—when the URL specifies a year, month, and day; when the URL specifies just the year and month; and when the URL specifies only the yea—can be handled with three rewrite rules:


  
     
     
        ~/(\d{4})/(\d{2})/(\d{2})\.aspx
        ~/ShowBlogContent.aspx?year=$1&month=$2&day=$3
     
     
        ~/(\d{4})/(\d{2})/Default\.aspx
        
     
     
        ~/(\d{4})/Default\.aspx
        ~/ShowBlogContent.aspx?year=$1

These rewriting rules demonstrate the power of regular expressions. In the first rule, we look for a URL with the pattern (\d{4})/(\d{2})/(\d{2})\.aspx. In plain English, this matches a string that has four digits followed by a forward slash followed by two digits followed by a forward slash, followed by two digits followed by .aspx. The parenthesis around each digit grouping is vital—it allows us to refer to the matched characters inside those parentheses in the corresponding property. Specifically, we can refer back to the matched parenthetical groupings using $1, $2, and $3 for the first, second, and third parenthesis grouping, respectively.

Note Since the Web.config file is XML-formatted, characters like &, <, and > in the text portion of an element must be escaped. In the first rule's element, & is escaped to &. In the second rule's , an alternative technique is used—by using a element, the contents inside do not need to be escaped. Either approach is acceptable and accomplishes the same end.

Figures 5, 6, and 7 show the URL rewriting in action. The data is actually being pulled from my blog, http://ScottOnWriting.NET. In Figure 5, the posts for November 7, 2003 are shown; in Figure 6 all posts for November 2003 are shown; Figure 7 shows all posts for 2003.

Figure 5. Posts for November 7, 2003

Figure 6. All posts for November 2003

Figure 7. All posts for 2003

Note The URL rewriting engine expects a regular expression pattern in the elements. If you are unfamiliar with regular expressions, consider reading an earlier article of mine, An Introduction to Regular Expressions. Also, a great place to get your hands on commonly used regular expressions, as well as a repository for sharing your own crafted regular expressions, is RegExLib.com.

Building the Requisite Directory Structure

When a request comes in for /2004/03/19.aspx, IIS notes the .aspx extension and routes the request to the ASP.NET engine. As the request moves through the ASP.NET engine's pipeline, the URL will get rewritten to ShowBlogContent.aspx?year=2004&month=03&day=19 and the visitor will see those blog entries for March 19, 2004. But what happens when the user navigates to /2004/03/? Unless there is a directory /2004/03/, IIS will return a 404 error. Furthermore, there needs to be a Default.aspx page in this directory so that the request is handed off to the ASP.NET engine.

So with this approach, you have to manually create a directory for each year in which there are blog entries, with a Default.aspx page in the directory. Additionally, in each year directory you need to manually create twelve more directories—01, 02, …, 12—each with a Default.aspx file. (Recall that we had to do the same thing—add a /Products/ directory with a Default.aspx file—in the previous demo so that visiting /Products/ correctly displayed ListCategories.aspx.)

Clearly, adding such a directory structure can be a pain. A workaround to this problem is to have all incoming IIS requests map to the ASP.NET engine. This way, even if when visiting the URL /2004/03/, IIS will faithfully hand off the request to the ASP.NET engine even if there does not exist a /2004/03/ directory. Using this approach, however, makes the ASP.NET engine responsible for handling all types of incoming requests to the Web server, including images, CSS files, external JavaScript files, Macromedia Flash files, and so on.

A thorough discussion of handling all file types is far beyond the scope of this article. For an example of an ASP.NET Web application that uses this technique, though, look into .Text, an open-source blog engine. .Text can be configured to have all requests mapped to the ASP.NET engine. It can handle serving all file types by using a custom HTTP handler that knows how to serve up typical static file types (images, CSS files, and so on).

Conclusion

In this article we examined how to perform URL rewriting at the ASP.NET-level through the HttpContext class's RewriteUrl() method. As we saw, RewriteUrl() updates the particular HttpContext's Request property, updating what file and path is being requested. The net effect is that, from the user's perspective, they are visiting a particular URL, but actually a different URL is being requested on the Web server side.

URLs can be rewritten either in an HTTP module or an HTTP handler. In this article we examined using an HTTP module to perform the rewriting, and looked at the consequences of performing the rewriting at different stages in the pipeline.

Of course, with ASP.NET-level rewriting, the URL rewriting can only happen if the request is successfully handed off from IIS to the ASP.NET engine. This naturally occurs when the user requests a page with a .aspx extension. However, if you want the person to be able to enter a URL that might not actually exist, but would rather rewrite to an existing ASP.NET page, you have to either create mock directories and Default.aspx pages, or configure IIS so that all incoming requests are blindly routed to the ASP.NET engine.

Redirect, Transfer or Rewrite?

noreply@blogger.com (Octopus) — Mon, 17 Dec 2007 03:50:00 +0000

Earlier, we implemented a URL rewriting scheme; however, in some circumstances, you may wish to implement a Response.Redirect() or Server.Transfer() instead. One reason to do this is to forward from Default.aspx to another page, like Home.aspx. You may or may not want to do this "behind the scenes," but that is a decision for you to make yourself. As always, each option comes with its own set of pros and cons.

Redirects are essentially two GET (or POST) requests. The first request gets processed and then the Response.Redirect() sends a response back to the client with an HTTP 302 redirect command. This obviously causes a slight delay as the second request gets processed. Also, since the new URL is sent to the client, it won't be hidden. This clearly doesn't support URL beautification, which is the main reason most people implement handlers. Even though redirects won't solve your problems, they still play an important part in the overall solution and should be considered when developing your mapping solution.

Transfers, unlike redirects, keep control within the application; but, they are still treated as two requests. The difference is that instead of the client handling the HTTP 302 redirect command, the web server handles it. This means that any modules, as well as the handler, will be processed twice . There are three key things to remember when using transfers: (1) the Request object, and all of its properties and methods, will reflect the initial request (logical page) and not the physical page; (2) post-back will not work; and, (3) in order to use the transfer you have to have two handlers specified in the Web.config file. There might be a way to get the post-back to work, but I don't know what that would entail. Perhaps I will delve into the ASP.NET request process fully one day. As for the two handler issue, let me explain that in a bit more detail. As you may remember from above, you specified two handlers in the Web.config file. The reason for this is because after the Server.Transfer() is executed, ASP.NET will send the second request back through the handler. I'm not completely sure why this is a problem, but it is. So, to fix it, you need to have some way to identify what requests should be handled by ASP.NET's default handler and which should be handled by yours. I attacked this by putting all of my physical pages in a Pages directory. So, by re-adding the default handler to handle all requests to "*/Pages/*.aspx", we tell ASP.NET how to support each type of request. As I also mentioned before, this will fix the the "Error executing child request" error.

Rewrites provide the best performance because there is no back-tracking to re-handle requests. You simply change the URL and continue on with the request processing. Know that accessing the Request object will now reflect the new (physical) URL and you will not have access to the old (logical) URL. You can get around this by adding custom variables to the HttpContext, but that shouldn't be necessary for most situations.

To add support for redirects and transfers, we can simply change our Web.config file by prepending "redirect.", "transfer.", or "rewrite." to identify how we want the request handled. Then, update the IHttpHandler.ProcessRequest() method to treat them accordingly.

HttpHandler.ProcessRequest() Method

     public void ProcessRequest(HttpContext context)
  {
  // declare vars
  string requestedUrl;
  string targetUrl;
  int urlLength;

  // save requested, target url
    requestedUrl = context.Request.RawUrl;
  if ( requestedUrl.IndexOf("?") >= 0 )
      targetUrl =    ConfigurationSettings.AppSettings[requestedUrl.Substring(0,    requestedUrl.IndexOf("?"))];
  else
      targetUrl = ConfigurationSettings.AppSettings[requestedUrl];   
  if ( targetUrl == null   || targetUrl.Length == 0 )
      targetUrl = requestedUrl;

  // handle type     
  if ( targetUrl.StartsWith("redirect.") )
    {
      context.Response.Redirect(targetUrl.Substring(9));
    }
  else if ( targetUrl.StartsWith("transfer.") )
    {
      context.Server.Transfer(targetUrl.Substring(9));
    }
  else
    {
    // if type is specified, remove it
    if (    targetUrl.StartsWith("rewrite.") )
         targetUrl = targetUrl.Substring(8);

    // save target url length
      urlLength = targetUrl.IndexOf("?");
    if ( urlLength == -1 )
         urlLength = targetUrl.Length;

    // rewrite path
      context.RewritePath(targetUrl);
      IHttpHandler handler = PageParser.GetCompiledPageInstance(
       targetUrl.Substring(0, urlLength), null,    context );
      handler.ProcessRequest(context);
    }
  }

Conclusion

Well, congratulations on your first HTTP handler implementation. There is plenty of room for improvement, so try to think of how you can manage the mappings to add more than just a simple URL rewriting scheme. One thing that you might want to consider is a post-back processing component. Yes, post-back is handled by ASP.NET, but performance can be increased by removing that overhead. Anyway, my point is that there are a lot of things you can do to improve this simple implementation. I encourage you to add to this and let me know how well it works out for you. I'd be interested to hear some of the things people are doing with handlers. Good luck!

Json.NET 1.1: Converting between XML and JSON

noreply@blogger.com (Octopus) — Fri, 14 Dec 2007 14:37:00 +0000

JAVASCRIPT:

1.

2.
XmlDocument doc = new XmlDocument();
3.
doc.LoadXml(@"
4.

5.

6.
Alan
7.
http://www.google.com
8.

9.

10.
Louis
11.
http://www.yahoo.com
12.

13.
");
14.

15.
string jsonText = JavaScriptConvert.SerializeXmlNode(doc);
16.
//{
17.
// "?xml": {
18.
// "@version": "1.0",
19.
// "@standalone": "no"
20.
// },
21.
// "root": {
22.
// "person": [
23.
// {
24.
// "@id": "1",
25.
// "name": "Alan",
26.
// "url": "http://www.google.com"
27.
// },
28.
// {
29.
// "@id": "2",
30.
// "name": "Louis",
31.
// "url": "http://www.yahoo.com"
32.
// }
33.
// ]
34.
// }
35.
//}
36.

37.
XmlDocument newDoc = (XmlDocument)JavaScriptConvert.DeerializeXmlNode(jsonText);
38.

39.
Assert.AreEqual(doc.InnerXml, newDoc.InnerXml);
40.

Json.NET - Simplifying .NET <-> JavaScript communication

noreply@blogger.com (Octopus) — Fri, 14 Dec 2007 14:22:00 +0000

JSON (JavaScript Object Notation) is lightweight data interchange format. In recent times JSON has achieved widespread use due to the ease of which it can be parsed and then the data accessed from within JavaScript compared to alternatives like XML.

While many JavaScript libraries exist for converting JSON text to and from a JavaScript object, working with JSON in .NET has been much more problematic. Correctly escaping strings and building up objects when writing JSON text can be difficult and error prone, while parsing values back out of JSON text is harder still.

Json.NET

Json.NET is a JSON .NET API for simply and safely reading and writing valid JSON text. At the core of Json.NET, similar to the .NET XML APIs, are two classes: JsonReader and JsonWriter. Also like XML in .NET, Json.NET includes a JsonSerializer class.

Reading JSON

JsonReader is a fast, forward only, readonly cursor. Like XmlTextReader it works over the top of a TextReader and maximizes performance while minimizing memory use.

The following code is a brief example of how to read a JSON object.

string jsonText = "['JSON!',1,true,{property:'value'}]";

JsonReader reader = new JsonReader(new StringReader(jsonText));

Console.WriteLine("TokenType\t\tValueType\t\tValue");

while (reader.Read())

    Console.WriteLine(reader.TokenType + "\t\t" + WriteValue(reader.ValueType) + "\t\t" + WriteValue(reader.Value))

Resulting in...

TokenType	ValueType	Value
StartArray	null	null
String	System.String	JSON!
Integer	System.Int32	1
Boolean	System.Boolean	True
StartObject	null	null
PropertyName	System.String	property
String	System.String	value
EndObject	null	null
EndArray	null	null

TokenType

ValueType

Value

StartArray

null

String

System.String

JSON!

Integer

System.Int32

Boolean

System.Boolean

True

StartObject

null

PropertyName

System.String

property

String

System.String

value

EndObject

null

EndArray

null

Writing JSON

JsonWriter is also forward only, and writes JSON text to a TextWriter. It handles formatting numbers, escaping strings and validating that the object is valid.

The following code is a brief example of how to write a JSON object.

StringWriter sw = new StringWriter();

JsonWriter writer = new JsonWriter(sw);

writer.WriteStartArray();

writer.WriteValue("JSON!");

writer.WriteValue(1);

writer.WriteValue(true);

writer.WriteStartObject();

writer.WritePropertyName("property");

writer.WriteValue("value");

writer.WriteEndObject();

writer.WriteEndArray();

writer.Flush();

string jsonText = sw.GetStringBuilder().ToString();

Console.WriteLine(jsonText);

// ['JSON!',1,true,{property:'value'}]

Which prints out: ['JSON!',1,true,{property:'value'}].

Serializing and deserializing JSON and .NET objects

JsonSerializer, similar to XML serialization, provides a hassle free way to automatically convert .NET objects to and from JSON text.

The following code is a brief example of how to serialize and deserialize JSON and .NET objects.

string jsonText = "['JSON!',1,true,{property:'value'}]";

JsonSerializer serializer = new JsonSerializer();

JavaScriptArray jsArray = (JavaScriptArray) serializer.Deserialize(new JsonReader(new StringReader(jsonText)));

Console.WriteLine(jsArray[0]);

// JSON!

JavaScriptObject jsObject = (JavaScriptObject)jsArray[3];

Console.WriteLine(jsObject["property"]);

// value

StringWriter sw = new StringWriter();

using (JsonWriter jsonWriter = new JsonWriter(sw))

    serializer.Serialize(sw, jsArray);

Console.WriteLine(sw.GetStringBuilder().ToString());

// ['JSON!',1,true,{property:'value'}]

Json.NET - Json.NET Homepage

Download Json.NET - Json.NET dll and C# source code

Json.NET

noreply@blogger.com (Octopus) — Fri, 14 Dec 2007 14:17:00 +0000

The Json.NET library makes working with JavaScript and JSON formatted data in .NET simple. Quickly read and write JSON using the JsonReader and JsonWriter or serialize your .NET objects with a single method call using the JsonSerializer.

Json.NET CodePlex Project

Json.NET Download

Features

Lightning fast JsonReader and JsonWriter
The JsonSerializer for quickly converting your .NET objects to JSON and back again
Json.NET can optionally produce well formatted, indented JSON for debugging or display
Attributes like JsonIgnore and JsonProperty can be added to a class to customize how a class is serialized
Ability to convert JSON to and from XML

Example

Product product = new Product();

product.Name = "Apple";

product.Expiry = new DateTime(2008, 12, 28);

product.Price = 3.99M;

product.Sizes = new string[] { "Small", "Medium", "Large" };

string json = JavaScriptConvert.SerializeObject(product);

//{

//  "Name": "Apple",

//  "Expiry": new Date(1230422400000),

//  "Price": 3.99,

//  "Sizes": [

//    "Small",

//    "Medium",

//    "Large"

//  ]

//}

Product deserializedProduct = JavaScriptConvert.DeserializeObject<Product>(json);

History

Json.NET grew out of projects I was working on in late 2005 involving JavaScript, AJAX and .NET. At the time there were no libraries for working with JavaScript in .NET so I began to grow my own.

Starting out as a couple of static methods for escaping JavaScript strings, Json.NET evolved as features were added. To add support for reading JSON a major refactor was required and Json.NET will split into the three major classes it still uses today, JsonReader, JsonWriter and JsonSerializer.

Json.NET was first released in June 2006. Since then Json.NET has been downloaded thousands of times by developers and is used in a number of major projects open source projects such as MonoRail, Castle Project's MVC web framework, and Mono, an open source implementation of the .NET framework.

C# and .Net on Linux

noreply@blogger.com (Octopus) — Wed, 05 Dec 2007 07:44:00 +0000

Compile and run C# command line and GUI applications on Linux

Shekhar Govindarajan

In the past issues of PCQuest we have talked much about MS .Net and C# programming language. .Net and its programming languages (C#, VB .Net, VC++ .Net, Visual J#, Python .Net, Perl .Net, COBOL .Net, etc) are available for only the Windows platform�Win 9x, ME, NT, 2000, XP, Win CE (for portables), etc. But a project named Mono has been introduced now. This is an effort to port .Net and its languages. As of now only C# has been ported to non-Windows platforms.

Libraries, compiler/interpreter and a runtime environment are the three essentials to write and run a program on a platform (OS + hardware architecture). Libraries make the writing of large programs easy by providing commonly-used routines in the form of classes and methods (functions). The .Net framework also has a number of libraries called class libraries. The compiler and the runtime are needed to convert a program into an executable and to run this executable respectively.

Mono packages the port of .Net library classes, a C# compiler and the .Net runtime�CLR (Common Language Runtime).

Mono claims to run on Linux, Solaris, FreeBSD and MS Windows. And besides the Intel x86 processors (486, Pentiums), it is said to support Sparc, PowerPC and StrongArm processors too.

Without getting into more theory, let�s see how Mono works on Linux. We�ll install Mono on PCQLinux 7.1, compile some C# programs and execute them. We are assuming that you are familiar with the .Net framework and the basics of C#.

Installation
Mount this month�s PCQuest CD and change to the directory system/cdrom/unltdos/linux/mono. Install all the RPMs found in this directory as

rpm -ivh *.rpm

Among other RPMs required by Mono, the Mono RPM named mono-0.12_baselabs-20020709.i386.rpm gets installed. The basic .Net assemblies like System.Data.dll, System.dll, System.Drawing.dll, System.Web.dll and System.Xml.dll are copied to the directory /usr/lib.

Now, type in the following program in a Linux text editor and save the file as HelloMono.cs.

class HelloMono
{
public static void Main(string[ ] args)
{ System.Console.WriteLine(�Hello Mono�);
}
}

Compile the program as

mcs HelloMono.cs

Mcs is the Mono C# command-line compiler. It has many command-line options like the csc compiler of MS .Net SDK. The above command will produce an executable named HelloMono. exe. Note that this executable is not a Linux executable but a .Net executable, technically called the IL (Intermediate Language) code. To run this executable, issue the following.

mono HelloMono.exe

You will see �Hello Mono� displayed on the Linux console. For more on mcs and Mono, refer to their man pages, which can be brought up by issuing:

man mcs
man mono

GUI on Mono
Mono does not support Windows Forms for GUI widgets. However, GTK# (a C# binding of GTK+graphical library) can be used for coding GUI components in C#. You�ll find all the requisites for installing GTK# on the CD. Let�s first install it and then execute some sample GTK# programs.

Change to the directory system/cdrom/unltdos/linux/gtksharp/dep on the CD and install the RPMs as

rpm -Uvh *.rpm --nodeps

Copy the file named gtk-sharp-0.2.1.tar.gz found in the directory system/cdrom/unltdoss/ linux/gtksharp to /opt directory. Extract the archive as

tar �zxvf gtk-sharp-0.2.1.tar.gz

This will produce a directory named gtk-sharp-0.2.1 within /opt. Change to this directory and issue

./configure --prefix=/usr
make
make install

Monkey Business

Money wise with Mono: .Net development can take place on a low-cost non-Windows platform like Linux. The deployment platform can be either Linux or Windows, with the OS cost (per user, per system licenses) in Windows concerning only the end user and not the developer.

Consider the scenario of a client-server .Net application. A user will interact only with the client (which should hopefully be a pleasant-looking GUI application) and expect a familiar platform like Windows. It will not matter to him if the server part is on Windows or Linux. So, the server part can be deployed on a Linux server using Mono, saving on the cost of setting up a dedicated Windows server.

Easy migration: If Mono comes out well, Windows developers, too, can develop for Linux and other non-Windows platforms. It won�t be a surprise if later a free or low-cost .Net IDE (Integrated Development Environment) like Visual Studio .Net makes a debut for Linux.

Linux developers, who should already have a grip of C/C++, can learn C# with similar syntax and constructs as in C/C++. Or, they can wait for a Mono C++ compiler that would give them an easier migration path.

The success of all this depends upon how well Mono is developed and how close and compatible it is with the implementation of the .Net framework on Windows. Other key factors will be its performance and the look-and-feel of its GUI components.

If you�re wondering what the title Monkey Business means, here�s the mystery unraveled�Mono means monkey in Spanish.

All the assemblies related to GTK# (gtk-sharp.dll, atk-sharp.dll, gdk-sharp.dll, glib-sharp.dll and pango-sharp.dll) are copied to the directory /usr/lib. You will need to refer to them using the �r option (see below) when you compile a C# program that uses GTK# for GUI. Reboot the machine once before proceeding further.

You�ll find some GTK# sample programs (HelloWorld.cs, Menu. cs, ButtonApp.cs) in the directory /opt/gtk-sharp-0.2.1/sample. You can compile them as

mcs -r gtk-sharp -r glib-sharp HelloWorld.cs

mcs -r gtk-sharp -r glib-sharp -r System.Drawing Menu.cs

mcs -r gtk-sharp -r glib-sharp -r System.Drawing ButtonApp.cs

Note how we are referring to the various assemblies using the �r option. Next, start X Window using the startx command and from within a terminal window, change (cd) to the directory /opt/gtk-sharp-0.2.1/sample and issue the following commands to execute the respective programs.

mono HelloWorld.exe
mono Menu.exe
mono ButtonApp.exe

Since Mono is an ongoing project and not all the .Net class libraries have been ported, you may find some quirks with it. Nevertheless, it�s usable to a great extent. You can check out the port status of class libraries at www.go-mono.com/class-status.html. For more on Mono, go to www.go-mono.com. For more on GTK#, see http://gtk-sharp. sourceforge.

Net/.

Shekhar Govindarajan

Running .Net applications on Linux with Mono

noreply@blogger.com (Octopus) — Wed, 05 Dec 2007 07:39:00 +0000

Imagine the fate of your company rests on your completing your new Linux project on time. You have a crack team of first-class developers, but they're all .Net programmers. What are you going to do? Admit that Windows is better that Linux? Cry? Resign? No, you're going to install Mono and save the world!

Mono is an open source project (sponsored by Novell ) that allows you to run .Net applications on Linux (as well as Unix, Mac OS X, Solaris and even Windows). To obtain it, go to the Mono download page and find the version you need for your distro.

Once you've installed Mono, get one of your .Net programmers to create and compile a simple Microsoft Visual Studio C# console application. Just something easy, such as:

using System; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Console.WriteLine("Hello World"); } } }

If you don't have your own tame .Net programmer, you're going to need a Windows machine with Microsoft Visual Studio installed. (Stop making faces like that!) Download the free Microsoft Visual C# Express Edition .

Transfer the compiled application from the Windows machine by using FTP or Samba, then log on to your Linux box and run the application:

$ ConsoleApplication1.exe Hello World

Surely it can't be as simple as that? Amazingly, it is. If you don't believe that it's Mono that's allowing you to do this, try transferring the application to a Linux box that hasn't got Mono installed. You'll get a result something like:

$ ConsoleApplication1.exe

-bash: ./ConsoleApplication1.exe: cannot execute binary file

You may need to run chmod +x on the file to get it to run. Also, I found that on Debian at this stage I got an error: The assembly mscorlib.dll was not found or could not be loaded. It should have been installed in the '/usr/lib/mono/2.0/mscorlib.dll' directory. I cured that by executing:

$ cd /usr/lib/mono $ sudo ln -s 1.0 2.0

The application name ends in .exe because it has been compiled as a Windows application. Once you've got it on Linux you can of course call it whatever you want:

$ mv ConsoleApplication1.exe HelloWorld $ HelloWorld Hello World

You've just seen just how easy is to use a Microsoft Visual Studio application on Linux. However, you're also probably thinking that you have absolutely no intention of using Windows at all; your .Net programmers are just going to have to have to learn to program in something that runs solely on Linux. That's a good idea -- if you've got the time for them to learn something new. If not, don't despair. Mono comes with its own .Net compiler, mcs. To us it, paste the code for the 'Hello World' application above into a file, compile it (using mcs), then run the new application from the command line.

$ mcs -out:HelloWorld.exe Program.cs $ HelloWorld.exe Hello World

If you've still got that Windows machine fired up, you may find it interesting to transfer the newly compiled application to it and running your app in Windows. You'll find that you've created something on Linux that will also run on Windows.

Of course, by the time you've explained all this to your .Net programmers they'll be up in arms. "How can you expect us to program without a pretty GUI?" they'll cry.

"With Monodevelop ," you'll say, referring to Mono's integrated development environment (IDE). With Monodevelop your developers can happily work with Glade#, Gnome#, and GTK#, all within a .Net-type environment. Check the software's download page for your distro's version and any dependencies.

When you install Glade, make sure that you obtain Glade2 and not Glade1. On Debian sudo apt-get install glade will grab Glade1, which will not work with Monodevelop. The correct installation command is sudo apt-get install glade-2 .

The developers should leave you in peace for a while, but they'll be back. "Where's the GUI designer?" they'll ask. This is where you introduce them to building interfaces with Glade . When you start a new Monodevelop Glade# application, use a file called gui.glade . You can edit this with Glade and then do the programming in Monodevelop. If your developers have any further questions, point them in the direction of the Mono GTK# Beginner's Guide .

With your .Net programmers happily producing applications for Linux, you can turn your attention to ASP .Net for building Web applications. You're going to need a Web server, which can be either Apache (with mod_mono installed) or Mono's own Web server, XSP. Have a look at the Mono Handbook page for Web sites and Web services to find out how to set up the XSP server. On Debian, for example, its just a matter of installing the software:

sudo apt-get install mono-xsp

Then running it:

$ cd mono $ xsp xsp Listening on port: 8080 Listening on address: 0.0.0.0 Root directory: /home/bainm/mono Hit Return to stop the server.

XSP will run in the directory where you start it, will use this as its home directory, and will use port 8080 by default. If you don't want to have to change into that directory every time you start the server, you can use its --root option. To change the port, use the --port option:

$ xsp --root ~/mono --port 8081

When you've got your server up and running, go to Mono's Web Services page , where you'll find some good examples of the types of services that you can start running. However, if you're desperate to see the server in action, go to the directory you're running XSP from and cat the following into index.aspx:

<%@ Page Language="C#" %> <html><body> <% Response.Output.Write("Hello World!"); %> </body> </html>

Now open up a Web browser and type in the URL of your host (plus the port number) -- e.g. http://hector:8080 . Granted, this isn't the most exciting example in the world, but it proves that you can run ASP .Net on Linux. A quick search on Google will give you a host of other examples that you can use.

With Mono, Monodevelop, and XSP in place, you can throw away Microsoft Visual Studio and you can throw away Windows, and you don't have to throw away the valued experience of your .Net programmers.

Mono 1.0 Brings Linux .Net-Style Development

noreply@blogger.com (Octopus) — Wed, 05 Dec 2007 07:35:00 +0000

By Jason Brooks

Novell Inc.'s Mono 1.0 is an open-source implementation of Microsoft Corp.'s .Net development platform that provides companies with the opportunity to pursue the latest Microsoft development technologies while leaving open the door to cross-platform support.

While the .Net Framework targets only Windows, Mono 1.0 supports Linux and Unix platforms, as well as systems running Windows and Mac OS X.

Mono comprises a compiler for the C# programming language, a run-time engine for Microsoft's Common Language Infrastructure and a group of .Net-compatible class libraries that are required for running .Net applications with Mono. These libraries include open-source versions of Microsoft's ADO.Net data access and ASP.Net Web application development technologies.

There have been rumors that Microsoft may open-source the Common Language Runtime component of .Net. Click here to read more.

Using the mod_mono Apache Web server module that ships with Mono 1.0, sites can serve ASP.Net pages with Apache on Linux (the module doesn't support Apache on Windows). This means that companies can make development and production platform choices separately.

Perhaps more important than Mono 1.0's ability to bring certain Windows applications to Linux is that it brings the .Net development model to Linux. A variety of class libraries for developing native Linux applications are included along with Mono's .Net compatibility libraries.

In eWEEK Labs' tests, for example, we were able to quickly create a simple Web browser in C#, with a GUI based on the Gtk framework and rendering handled by Mozilla's Gecko engine.

Although Mono 1.0 is intended to provide full compatibility with pure .Net Version 1.1 applications, .Net applications that make use of native Windows APIs will require porting work to be brought over to Linux.

Applications that use Microsoft's WinForms rich user interface classes, which depend on native Windows system calls, can run with Mono using a library based on Wine that ships along with Mono.

Mono 1.0 ships with MonoDevelop, a port of the open-source .Net IDE (integrated development environment) SharpDevelop to Gtk#. MonoDevelop doesn't handle GUI creation—for that, we used the Gtk interface tool Glade.

Mono also includes a documentation browser. We were impressed with the breadth of Mono's documentation, which includes lots of sample projects.

Mono's compiler supports C#, and a Mono compiler for Microsoft's Visual Basic .Net, called MBas, is under development.

Mono ships with IKVM, a Mono-based Java virtual machine, plus implementations of Java class libraries based on work from the open-source project Classpath. IKVM enables sites to run Java applications with Mono and use Java libraries in .Net applications.

Mono 1.0 is available for free download in source code form at www.mono-project.com/downloads.

Mono's run-time engine supports the x86, x86-64, PowerPC, SPARC, S390, StrongARM and HPPA processor architectures on Linux, Windows, HP-UX, Solaris, Mac OS and BSD operating systems. Mono also ships with a native optimizing compiler in both ahead-of-time and just-in-time compilation modes for the x86, SPARC, S390 and PowerPC architectures.

Precompiled, ready-to-install packages are also available through this site for Red Hat Linux 9, Fedora Core 1 and 2, SuSE Linux Enterprise Server 8, SuSE Linux 9.0 and 9.1, Slackware 10, Windows 2000 and above, and Mac OS X Panther.

Senior Analyst Jason Brooks can be reached at jason_brooks@ziffdavis.com.

PHP Webservices and C# / .NET SOAP Clients

noreply@blogger.com (Octopus) — Tue, 04 Dec 2007 07:43:00 +0000

Code Zulu Bind Maker is a project I started working on about 3 years ago. Its a stupid little app that configures game settings for Counter-Strike. When I wrote it, version 1.6 was in beta, and everybody played version 1.5 (which was ever so different). Anyway I run a website that supports the app, and of course, its written in PHP / MySql (my poison of choice on the web).

The reason for the boring and seemingly pointless background is that ever since I wrote the app, I always wanted to integrate the website and application, but never really thought of a "good" way to do it. A couple days ago, I had some spare time and sat down to see how easy it would be to create some PHP webservices that I could easily consume in C#. I had been considering expanding the community aspect of the bind maker website into the application so that they'd work seamlessly together. I also wanted to add a common place that gaming communities could spend their time (which I had previously planned for just the website, but was thinking of the possibilities of bringing that into the app as well), and a PHP webservice combined with a C# windows app seemed like the best option.

C# webservices (server side) are about as easy-as-it-gets to write. C#'s SOAP client is completely transparent (or I should say completely generated so you code just like you would use any other objects) and is completely brainless to use. Since I'd never done webservice work in PHP, I started asking Mr. Google how it worked, and what would you now but that I stumbled across the NuSOAP library for php. It sure beat the heck out of writing all my WSDL files by hand, wrapping and unwrapping stupidly simple SOAP messages, and hacking everything very poorly.

My first PHP webservice iteration was a simple "hello " web method. It used a simple type (xsd:string) as its parameter and returned a simple type (again another xsd:string) as its return value and looked like this:

 /**
* ProcessSimpleType method
* @param string $who name of the person we'll say hello to
* @return string $helloText the hello  string
*/
function ProcessSimpleType($who) {
 return "Hello $who";
}

NuSoap was great. It took care of all the nitty-gritty work that I had previously done myself. All it took was about 8 lines of code to set up the SOAP server and register the method and my types.

require_once("lib/nusoap/nusoap.php");
$namespace = "http://sanity-free.org/services";
// create a new soap server
$server = new soap_server();
// configure our WSDL
$server->configureWSDL("SimpleService");
// set our namespace
$server->wsdl->schemaTargetNamespace = $namespace;
// register our WebMethod
$server->register(
               // method name:
               'ProcessSimpleType',   
               // parameter list:
               array('name'=>'xsd:string'),
               // return value(s):
               array('return'=>'xsd:string'),
               // namespace:
               $namespace,
               // soapaction: (use default)
               false,
               // style: rpc or document
               'rpc',
               // use: encoded or literal
               'encoded',
               // description: documentation for the method
               'A simple Hello World web method');
              
// Get our posted data if the service is being consumed
// otherwise leave this data blank.               
$POST_DATA = isset($GLOBALS['HTTP_RAW_POST_DATA'])
               ? $GLOBALS['HTTP_RAW_POST_DATA'] : '';

// pass our posted data (or nothing) to the soap service                   
$server->service($POST_DATA);               
exit();

That was it. From visual studio I was then able to consume the webservice by adding a web reference

With the reference added, I put a button on my form, and added the following button click event handler:

private void button1_Click(object sender, EventArgs e) {
   SimpleService svc = new SimpleService();
   string s = svc.ProcessSimpleType("steve");
   MessageBox.Show(s);
}

Ran my application, pressed the button (which in turn called the webservice), and voilà I get a message box telling me Hello:

That's great! Completely useless, but great!

Now to get a little more complicated... I had planned on using complex data types that would be consumed by both PHP and .NET clients (A PHP SOAP client for the website, and .NET client for the windows application). It may sound stupid to have a PHP client when most likely I'd have access to the method directly, but the server that is going to host the webservices is actually different than the "web presence" server I host my website on. Anyway, the test complex types I came up needed to look like simple structs (in C#) which would also be used in an array, and they looked something like this:

public struct MySoapObject {
   public string Author;
   public string Name;
   public string Description;
   public string Text;
   public int VoteTotal;
   public int VoteCount;
}

MySoapObject[] soapObjects = new MySoapObject[10];

so I added the definitions in PHP using NuSOAP like this:

$server->wsdl->addComplexType(
   'MySoapObject',
   'complexType',
   'struct',
   'all',
   '',
   array(
       'Author' => array('name'=>'Author','type'=>'xsd:string'),
       'Name' => array('name'=>'Name','type'=>'xsd:string'),
       'Description' => array('name'=>'Description','type'=>'xsd:string'),
       'Text' => array('name'=>'Text','type'=>'xsd:string'),
       'VoteTotal' => array('name'=>'VoteTotal','type'=>'xsd:int'),
       'VoteCount' => array('name'=>'VoteCount','type'=>'xsd:int')
   )
);

$server->wsdl->addComplexType(
   'MySoapObjectArray',
   'complexType',
   'array',
   '',
   'SOAP-ENC:Array',
   array(),
   array(array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'tns:MySoapObject[]')),
   'tns:MySoapObject'
);

I defined the method in PHP that would take in an array of MySoapObjects, process them, and then return one MySoapObject that it had "processed".

That method looked like this:

function ProcessMySoapObject($mySoapObjects) {
 $mso = $mySoapObjects[3];
 $mso['Name'] = "|||";
 return $mso;
}

The SOAP server registration:

$server->register(
   'ProcessMySoapObject',
   array('soapObjects'=>'tns:MySoapObjectArray'),
   array('return'=>'tns:MySoapObject'),
   $ns,
   false,
   'rpc',
   false,
   'Processes an array of MySoapObjects and returns one of them');

And I did exactly the same as I did before--and added the web reference in visual studio to my project. This time not only did Visual Studio add the Service class and web method, it added the 2 data types I had defined in PHP on my SOAP server (actually, it just built the MySoapObject, and the array was left out because arrays are an implied data type).

I changed my button click event in my windows form and added the following code:

private void button1_Click(object sender, EventArgs e) {
   Services s = new Services();
   MySoapObject[] ms = new MySoapObject[10];
   for(int i = 0; i < ms.Length; i++) {
       ms[i] = new MySoapObject();
       ms[i].Author = "Steve";
       ms[i].Description = "The One that should be returned";
       ms[i].Name = i.ToString();
       ms[i].Text = "something something something " + i.ToString();
       ms[i].VoteCount = i * 2;
       ms[i].VoteTotal = (int)Math.Pow(ms[i].VoteCount, 2);
   }
   MySoapObject retn = s.ProcessMySoapObject(ms);
   string output = "";
   output += retn.Author + "\t\t\r\n";
   output += retn.Description + "\t\t\r\n";
   output += retn.Name + "\t\t\r\n";
   output += retn.Text + "\t\t\r\n";
   output += retn.VoteCount.ToString() + "\t\t\r\n";
   output += retn.VoteTotal.ToString() + "\t\t\r\n";
   MessageBox.Show(output);
}

Compiled, ran and clicked.

Simple, Easy, Can't believe I never tried it before now!

This opened up a whole new world of opportunities in cross-platform distributed computing that I'd never exposed myself to before... what a wonderful thing!

The Future of PHP

noreply@blogger.com (Octopus) — Thu, 29 Nov 2007 07:57:00 +0000

source : Marc's blog

Marc says :

Last Friday there was a rather spirited discussion at the office between Kaiton (a Ruby aficionado and ex-Panmedia employee currently at Microsoft), Nesta (a python aficionado who is forced to use PHP) and myself, (an un-biased PHP user who is forced to defend it ;-). The topic of course was PHP, its woes, its past, its present and its future.

According to Kaiton, PHP will be marginalised in 2008 by more literate programming languages like Ruby, Python and even Erlang. His view is that as the web becomes more important to business, backend programmers will start to get involved in the front end and web programming will be dominated by more experienced programmers who care more about the language they code with. According to Nesta, Drupal is the only good thing that ever came out of PHP. I think that 2007 will be the year of PHP.

By the end of the ~~argument~~ discussion, things were kinda starting to go around in circles so I decided to try and articulate my ideas in written format so that they could be dated, critiqued and openly ridiculed, and so that a year or two from now I can come back read the crazy things I was thinking way back in 2007. It will also serve as an official record in case Kaiton wants to put his money where his mouth is ;-)

Before I present my argument, let me get a few things straight.

There are definitely some dislikeable things about PHP. The language design (or lack thereof) is far from perfect. PHP’s roots and a laissez-faire approach to adding new features early on have scarred the language with inconsistent naming conventions and function behaviour. A late start in the object oriented game meant that it took them a little while to get that feature right. Its popularity has been its Achilles heel and prevented the developers from making radical sweeping changes to normalize the language.

On the flip side there are a few unfair assertions that people tend to make against PHP. I often hear people say “you can’t build large apps in PHP, it just gets messy!”. While there is a lot of bad PHP code out there, that doesn’t mean you can’t write clean code. The PHP language does not enforce a lot rules to prevent you from coding sloppily; whether or not a language should police coders is a separate matter of debate. The fact remains however that PHP provides you with everything you need to code your applications according to tried and true Object Oriented Design Patterns. Whether or not you choose to do so is up to you.

Just so it is clear, I am not saying that PHP deserves to prosper, I am not saying that I personally want it to prosper, I am simply saying that it will prosper. Here is why:

PHP is popular. This has a couple ramifications.

PHP 4 is available by default in just about any web-hosting plan you come across. And PHP 5 availability is rising steadily.
It has been widely and heavily tested against a multitude of different environments and configurations (Hardware, OS, Database, 3rd party software, etc).
You are much more likely to have somebody in-house who knows at lease some PHP than any Ruby or Python, and it is also much easier to hire a PHP developer.

PHP 5 is “good enough”.

Regardless of what you want to say about PHP’s language design (or complete lack thereof) as it currently stands at version 5.2:

It has sufficient object oriented features for coding according to enterprise patterns.
It has deprecated the magic functions (register globals, magic quotes, etc) that have been the source of many security issues in the past an scheduled them for complete removal in PHP 6.
The Internet’s most trafficked site is built using PHP. They are heavily invested its success and are one of the major driving forces behind the PHP 6’s upcoming Unicode support. They have a presentation online explaining their rationale for choosing PHP.

This meets my definition of good enough. Far from perfect, not necessarily the best, but good enough for web work of all sizes.

The PHP Collaboration Project makes PHP better.

The Zend Framework leads by example to help solve the sloppy PHP coder epidemic and give developers a solid basis for rapid application development.
The Zend Developer Zone plays in important role by engaging the community and providing example code.
However, to me, the most important part of the Collaboration project is the new Eclipse based IDE/Debugger. A well designed, fully integrated free and open source graphical coding/debugging solution for PHP will a major step forward for web application development. One year from now many of use will scratch our heads in amazement at the primitive methods we used to employ for debugging complex web apps. The difference will be as huge as the jump from debugging JavaScript using alert messages to using Firebug 1.0 (more on that in a later blog post).

Zend knows how to compete

From a developer point of view the entire PHP Collaboration Project is an attempt to compete with ASP.NET. The combination of a Developer Zone, an IDE and a Framework are straight out of the Microsoft playbook. They are even working with Microsoft to compete in the arena where Microsoft typically dominates… distribution to the windows desktop. Zend Core for Windows will be a simple download and install and I wouldn’t put it past them to bundle the framework in as well.

On the Framework level the Zend Framework competes with Ruby on Rails, Django and ASP.Net. It covers all the typical bases MVC, ORM, Caching, JSON, etc.

On the language level PHP 5’s object-oriented improvements and PHP 6’s upcoming Unicode support give the language some more “enterprise” features, but I don’t think Zend is actually trying to compete with Java. Zend and Sun’s collaborated on JSR-223 (Scripting for the Java Platform) which will allow scripting languages like PHP to access Java objects in the recently released Java 6 JRE. When you combine this with the Java language support in Zend Studio 5.5 it indicates to me that Zend wants to co-exist rather than compete with Java.

Zend is making inroads into the corporate world

Separate and apart from working with IBM, Intel, EBay and Amazon on the collaboration project, Zend has established partnerships with the major proprietary Database vendors and created a special set of PHP distributions just for them called Zend Core; this now includes Zend Core for Oracle, and Zend Core for IBM . Not only do these types of partnerships make companies feel more comfortable using PHP with the proprietary databases they have built their business on but they also offer a number of other benefits:

Improved drivers. By working directly with the database vendors, Zend has already made numerous improvements to the PHP extensions for Oracle and DB2.
Simplified distribution and setup for those who need to use proprietary drivers (since they aren’t distributed with the standard php.net download).
GUI based management. Each Zend Core distribution comes with a web based interface for viewing the server status and managing the PHP configuration. Zend Core also comes with an updater that allows you to easily apply and rollback PHP updates.
Zend Core provides a nice smooth on ramp to support. You can download the basic system for free and then choose your level of support later on. Support for PHP may not seem necessary to most developers but it is nice to have the option in case the company you are working for wants it.

Not to be left behind, rumour has it that early this year we will see a Zend Core for MySQL as well as a brand new MySQL driver developed specifically for PHP that provides added performance and reliability. When you consider this along with MySQL’s upcoming Falcon storage engine and their extremely useful GUI tools, 2007 may be the year of MySQL as well.

The train has left the station

I have a python book here on my desk that is number 2 or 3 in my reading queue right now, I would really like to learn Ruby (but don’t see it happening anytime soon). I have no doubt that I will find both these languages more pleasant to code with than PHP, but my personal tastes have little to do with what I think will happen in 2007/2008. The PHP train is a rollin’ and my learning or loving another language ain’t gonna stop it.

What do you think? Will 2007/2008 see PHP rise or fall?

Zend Framework - Power PHP

noreply@blogger.com (Octopus) — Thu, 29 Nov 2007 07:45:00 +0000

by Huw Collingbourne

Zend Interview...

In July, Zend Technologies released version 1.0 of the Zend Framework, an open source application framework for PHP. Here, Huw Collingbourne talks to Mark de Visser, Zend’s Chief Marketing Officer, about Zend Framework, the future of PHP and the challenges of Ruby On Rails, Flex and Silverlight...

So What Is ‘Zend Framework’, Anyhow...?

We asked Mark de Visser to give us an overview of the main features of the Zend Framework and what they offer to developers. This is what he told us...

Zend Framework (ZF) is completely free for development and distribution, that is, is open-source and free to download & use and features the following:
New BSD license: business-friendly – it’s easy to build your own commercial intellectual property on top of ZF
An Apache-like Contributor License Agreement (CLA) process assures that the code is free of legal issues – important protection and peace-of-mind
Fully object-oriented PHP 5 class library, with attention to best design practices
Tested thoroughly with about 90,000 lines of test code for 140,000 lines of framework code, all contributors were asked to submit test code and documentation with every submission.
Extreme simplicity, modular “use-at-will” architecture for easy migration and ability to share ZF code with your current applications and even with other frameworks if necessary.
That’s the high-level (above); more specific features and their benefits are here:

Model/View/Controller architecture – an industry standard best practice for web apps Full database support (incl. MySQL, PostgreSQL, SQLite, Oracle, DB2, & MS SQL Server) – all major databases you may need, with the ease-of-use you expect from a framework
Internationalization support necessary for most modern web applications – in a global economy providing localized versions in your users’ language is easy and straightforward
Authentication & sessions – to make managing sign-on & users of your application easy.
AJAX/JSON support – to help meet the ease-of-use your users now come to expect
Search – native PHP port of industry-standard Lucence search engine
Syndication (RSS & Atom supported) – don’t be left behind without the data formats & access your Web 2.0 users need
Web services – Zend Framework aims to be the premier place to consume and publish web services with support for REST, Http, Google Gdata APIs, Amazon, Flickr, Yahoo!, del.ici.ous, StrikeIron services, and others – create mashups and other web 2.0 apps easily.
Adobe PDF – support for PDF creation, reading, editing
Mail – read and send e-mail, including support for MIME Many other framework services including support for safer and more secure applications with input filtering, authentication, & HTML escaping, as well as caching, filtering, logging, input validation, and more.

Download Zend Framework: http://framework.zend.com/

HC: Let’s start by talking about the Zend Framework. There are already numerous PHP frameworks around - such as CakePHP, PEAR and CodeIgniter. Is the Zend Framework ‘in competition’ with those or can it be use in collaboration with them?

Mark de Visser: We would not say that Zend Framework competes per se, with any other PHP framework. Different frameworks have different aims and there really is no “one size fits all” in that regard.

Due to its modular “use-at-will” architecture, Zend Framework can be used with any/all of these frameworks. As a result, bolting on the Lucene search engine, adding PDF generation/editing, or even re-architecting your app to be a modern model-view-controller web app can all be done to greater or lesser degrees, depending on which other framework you are working with.

HC: What factors would determine which the choice of framework for a potential user?

Mark de Visser: We anticipate that larger enterprise developers will find Zend Framework an excellent choice to start any “green field” (new) project and that some of the factors they might use to choose a framework would be to carefully investigate: licensing (both of the framework itself and of any contributed code), how best practices are embodied in the framework, security support built-in, how thoroughly the code has been tested, how well it has been documented, how easy is it to migrate and whether or not you are ‘stuck’ in a particular way of doing things once migrated, as well as that it contains all the latest features one might want in a framework.

HC: Recently CodeGear launched a ‘visual’ PHP system, Delphi For PHP, which has its own open source class library and a drag-and-drop application designer. Is this the way forward for PHP development?

Mark de Visser: We are not familiar with CodeGear’s approach but subscribe to the idea of enabling framework classes so they can be used in visual designers.

HC: Over the past year or so, Ruby On Rails has emerged as an increasingly influential framework. If I were considering the pros and cons of developing a web application using Ruby On Rails or PHP and the Zend Framework, what things should I consider when coming to a decision?

Mark de Visser: We find that most programmers pick languages based on a number of criteria. We think that Zend Framework will be an important addition that makes PHP more attractive, just as Rails makes Ruby more attractive in others. .

Aside from that, by choosing Ruby on Rails a developer subscribes to a whole approach, including semantics, naming conventions, application architecture, etc. In contrast, Zend Framework lets you use as much or as little of the framework as you wish, making it very easy to adopt it gradually for existing code bases.

PHP is the technology used for many of the most scalable web applications, including Yahoo, Facebook and YouTube. These sites drive the decision for many commercial developers to PHP, and subsequently to Zend Framework.

HC: One of the features of the Ruby language is that it is object oriented from the ground up. With PHP, objects have been ‘bolted onto’ the language, haven’t they? Doesn’t that mean that PHP won’t take advantage of things like, for example, rigorous encapsulation and data hiding? Isn’t that something that goes in Ruby’s favour?

Mark de Visser: A key part of the move from PHP 4 to 5 was to make objects first-class citizens, including rigorous encapsulation and data hiding. So with PHP5 programming in PHP is really no different than programming in any other object oriented languages.

Zend Framework leverages this capability of PHP5 and to create a framework that is fully OO and rigorously encapsulates and hides data. By embodying object-oriented best practices Zend Framework helps a developer learn, and stay safe.

HC: Can you explain what part Zend plays in the development of the PHP language? Do you have full control over the design and implementation? Or is the future of PHP determined by the efforts of the open source community?

Mark de Visser: Zend does not have control over PHP, although some of its employees are active participants in the decisions of the open source community. Zend benefits greatly from the vibrant PHP ecosystem and tries to give back to this community whenever possible. It has many of the developers who work on maintenance and future versions of PHP on its payroll and also supports major open source projects like Zend Framework and the Eclipse PHP Development Tools (PDT).

HC: What is the state of development on PHP 6? What are the significant new features that will be added to the language and will they ‘break’ existing applications?

Mark de Visser: There is an active PHP open-source community at work on PHP 6. i18n with full unicode support for multi-byte characters and most likely namespaces seem to be the major features under consideration for PHP6.

HC: There is a great deal of activity in the realm of so-called ‘Rich Internet Applications’ at the moment - a field currently dominated by Adobe’s Flex but now being challenged by Microsoft’s Silverlight. One of the special features of Silverlight is that it will be programmable using Python, VB, Ruby or JavaScript. Are Flex and Silverlight going to squeeze out PHP? Can PHP find a way of working with them?

Mark de Visser: PHP being a server-side language works just fine with Silverlight & Flex. Flex and PHP work together beautifully. There is an article on the Zend Developer Zone HERE that explains this well - and is written by an Adobe employee. Additionally, Microsoft (one of our partners) has released an Atlas-based Ajax toolkit for PHP (some links you might see are on the main library site that Microsoft supports; also see HERE, HERE and HERE, which further strengthens the usage of PHP and other client-side technologies like Silverlight and Flex/Flash.

Unrelated to those two, but a connector between client & server side is the WebORB project that you can find HERE; they are also interested in building their code into Zend Framework—and they already have a free open-source PHP kit available now.

HC: Finally, PHP has been one of the driving forces of ‘Web 2’. Looking ahead, five or ten years from now, how will the face of the web have changed and what part will PHP play in that?

Mark de Visser: Zend finds predictions of that sort difficult at best. But as Andi Gutmans, Zend CTO for Product Strategy and co-founder has said in a recent ComputerWorld profile of him:

“One trend that I think is going to be critical to the IT industry in the coming years is the decentralization of IT. It is being enabled by a few factors. The first is dynamic languages like PHP, which are making it increasingly easy for lightweight developers to become productive. The second is the rise of service-oriented architecture, which is leading to the end of monolithic application architectures. Third, the shift toward Web applications that are making it extremely easy to deploy applications inside the enterprise, not requiring a central function to test, deploy and manage those applications. This change is going to allow companies to become far more productive and agile, significantly decreasing the traditional backlog of business applications IT has in its queue. It will also enable an increasing number of such applications to leverage the organization’s existing assets by integrating the SOA-enabled infrastructure.”

As a follow-up to Andi’s prognostications we’ll also mention that IBM has built a management dashboard ‘mash-up’ tool of sorts to do just that, that is, leverage an organization’s existing assets—and though it’s just getting released, it’s already a fairly high profile project at IBM gaining them many SOA-enabled customers—and is called QEDWiki (Quickly & Easily Done Wiki) which is built entirely on Zend Framework. You can find out more about this project here: http://services.alphaworks.ibm.com/qedwiki/

You also may want to view this demo here: http://www.alphaworks.ibm.com/demo/flash/display/qedwiki4

Zend Technologies, Inc., the PHP company (http://www.zend.com/), is the leading provider of products and services for developing, deploying and managing business-critical PHP applications. Zend’s founders are the architects of PHP, which is used by more than 22 million Web sites.

Mark de Visser joined Zend in December 2005. Previously he worked for Agitar Software, a supplier of tools for Java software developers. Before Agitar, de Visser was vice president of marketing at Red Hat Inc. where he was a member of the team that created the company’s market-leading position with the introduction of Red Hat Enterprise Linux. He also worked for twelve years at Borland International in international and product marketing roles, and as vice president of corporate marketing.

Caching in PHP using the filesystem, APC and Memcached

noreply@blogger.com (Octopus) — Wed, 21 Nov 2007 08:10:00 +0000

By Evert on 2006-11-01 02:14:18

Caching is very important and really pays off in big internet applications. When you cache the data you're fetching from the database, in a lot of cases the load on your servers can be reduced enormously.

One way of caching, is simply storing the results of your database queries in files.. Opening a file and unserializing is often a lot faster than doing an expensive SELECT query with multiple joins.

Here's a simple file-based caching engine.

<?php

// Our class

class FileCache {

// This is the function you store information with

function store ( $key , $data , $ttl ) {

// Opening the file

$h = fopen ( $this -> getFileName ( $key ), 'w' );

     if (! $h ) throw new Exception ( 'Could not write to cache' );

// Serializing along with the TTL

$data = serialize (array( time ()+ $ttl , $data ));

     if ( fwrite ( $h , $data )=== false ) {

       throw new Exception ( 'Could not write to cache' );

     }

fclose ( $h );

   }

// General function to find the filename for a certain key

private function getFileName ( $key ) {

       return '/tmp/s_cache' . md5 ( $key );

   }

// The function to fetch data returns false on failure

function fetch ( $key ) {

$filename = $this -> getFileName ( $key );

       if (! file_exists ( $filename ) || ! is_readable ( $filename )) return false ;

$data = file_get_contents ( $filename );

$data = @ unserialize ( $data );

       if (! $data ) {

// Unlinking the file when unserializing failed

unlink ( $filename );

          return false ;

       }

// checking if the data was expired

if ( time () > $data [ 0 ]) {

// Unlinking

unlink ( $filename );

          return false ;

       }

       return $data [ 1 ];

     }

}

?>

Key strategies

All the data is identified by a key. Your keys have to be unique system wide; it is therefore a good idea to namespace your keys. My personal preference is to name the key by the class thats storing the data, combined with for example an id.

example

Your user-management class is called My_Auth, and all users are identified by an id. A sample key for cached user-data would then be " My_Auth:users:1234 ". '1234' is here the user id.

Some reasoning behind this code

I chose 4096 bytes per chunk, because this is often the default inode size in linux and this or a multiple of this is generally the fastest. Much later I found out file_get_contents is actually faster.

Lots of caching engines based on files actually don't specify the TTL (the time it takes before the cache expires) at the time of storing data in the cache, but while fetching it from the cache. This has one big advantage; you can check if a file is valid before actually opening the file, using the last modified time ( filemtime() ).

The reason I did not go with this approach is because most non-file based cache systems do specify the TTL on storing the data, and as you will see later in the article we want to keep things compatible. Another advantage of storing the TTL in the data, is that we can create a cleanup script later that will delete expired cache files.

Usage of this class

The number one place in web applications where caching is a good idea is on database queries. MySQL and others usually have a built-in cache, but it is far from optimal, mainly because they have no awareness of the logic of you application (and they shouldn't have), and the cache is usually flushed whenever there's an update on a table. Here is a sample function that fetches user data and caches the result for 10 minutes.

<?php

// constructing our cache engine

$cache = new FileCache ();

function getUsers () {

     global $cache ;

// A somewhat unique key

$key = 'getUsers:selectAll' ;

// check if the data is not in the cache already

if (! $data = $cache -> fetch ( $key )) {

// there was no cache version, we are fetching fresh data

        // assuming there is a database connection

$result = mysql_query ( "SELECT * FROM users" );

$data = array();

// fetching all the data and putting it in an array

while( $row = mysql_fetch_assoc ( $result )) { $data [] = $row ; }

// Storing the data in the cache for 10 minutes

$cache -> store ( $key , $data , 600 );

     }

     return $data ;

}

$users = getUsers ();

?>

The reason i picked the mysql_ set of functions here, is because most of the readers will probably know these.. Personally I prefer PDO or another abstraction library. This example assumes there's a database connection, a users table and other issues.

Problems with the library

The first problem is simple, the library will only work on linux, because it uses the /tmp folder. Luckily we can use the php.ini setting 'session.save_path'.

<?php

private function getFileName ( $key ) {

return ini_get ( 'session.save_path' ) . '/s_cache' . md5 ( $key );

}

?>

The next problem is a little bit more complex. In the case where one of our cache files is being read, and in the same time being written by another process, you can get really unusual results. Caching bugs can be hard to find because they only occur in really specific circumstances, therefore you might never really see this issue happening yourself, somewhere out there your user will.

PHP can lock files with flock() . Flock operates on an open file handle (opened by fopen) and either locks a file for reading (shared lock, everybody can read the file) or writing (exclusive lock, everybody waits till the writing is done and the lock is released). Because file_get_contents is the most efficient, and we can only use flock on filehandles, we'll use a combination of both.

The updated store and fetch methods will look like this

<?php

// This is the function you store information with

function store ( $key , $data , $ttl ) {

// Opening the file in read/write mode

$h = fopen ( $this -> getFileName ( $key ), 'a+' );

     if (! $h ) throw new Exception ( 'Could not write to cache' );

flock ( $h , LOCK_EX ); // exclusive lock, will get released when the file is closed

fseek ( $h , 0 ); // go to the beginning of the file

     // truncate the file

ftruncate ( $h , 0 );

// Serializing along with the TTL

$data = serialize (array( time ()+ $ttl , $data ));

     if ( fwrite ( $h , $data )=== false ) {

       throw new Exception ( 'Could not write to cache' );

     }

fclose ( $h );

   }

   function fetch ( $key ) {

$filename = $this -> getFileName ( $key );

       if (! file_exists ( $filename )) return false ;

$h = fopen ( $filename , 'r' );

       if (! $h ) return false ;

// Getting a shared lock

flock ( $h , LOCK_SH );

$data = file_get_contents ( $filename );

fclose ( $h );

$data = @ unserialize ( $data );

       if (! $data ) {

// If unserializing somehow didn't work out, we'll delete the file

unlink ( $filename );

          return false ;

       }

       if ( time () > $data [ 0 ]) {

// Unlinking when the file was expired

unlink ( $filename );

          return false ;

       }

       return $data [ 1 ];

    }

?>

Well that actually wasn't too hard.. Only 3 new lines.. The next issue we're facing is updates of data. When somebody updates, say, a page in the cms; they usually expect the respecting page to update instantly.. In those cases you can update the data using store(), but in some cases it is simply more convenient to flush the cache.. So we need a delete method.

<?php

function delete ( $key ) {

$filename = $this -> getFileName ( $key );

         if ( file_exists ( $filename )) {

             return unlink ( $filename );

         } else {

             return false ;

         }

     }

?>

Abstracting the code

This cache class is pretty straight-forward. The only methods in there are delete, store and fetch.. We can easily abstract that into the following base class. I'm also giving it a proper prefix (I tend to prefix everything with Sabre, name yours whatever you want..). A good reason to prefix all your classes, is that they will never collide with other classnames if you need to include other code. The PEAR project made a stupid mistake by naming one of their classes 'Date', by doing this and refusing to change this they actually prevented an internal PHP-date class to be named Date.

<?php

abstract class Sabre_Cache_Abstract {

         abstract function fetch ( $key );

         abstract function store ( $key , $data , $ttl );

         abstract function delete ( $key );

     }

?>

The resulting FileCache (which I'l rename to Filesystem) is:

<?php

class Sabre_Cache_Filesystem extends Sabre_Cache_Abstract {

// This is the function you store information with

function store ( $key , $data , $ttl ) {

// Opening the file in read/write mode

$h = fopen ( $this -> getFileName ( $key ), 'a+' );

     if (! $h ) throw new Exception ( 'Could not write to cache' );

flock ( $h , LOCK_EX ); // exclusive lock, will get released when the file is closed

fseek ( $h , 0 ); // go to the start of the file

     // truncate the file

ftruncate ( $h , 0 );

// Serializing along with the TTL

$data = serialize (array( time ()+ $ttl , $data ));

     if ( fwrite ( $h , $data )=== false ) {

       throw new Exception ( 'Could not write to cache' );

     }

fclose ( $h );

   }

// The function to fetch data returns false on failure

function fetch ( $key ) {

$filename = $this -> getFileName ( $key );

       if (! file_exists ( $filename )) return false ;

$h = fopen ( $filename , 'r' );

       if (! $h ) return false ;

// Getting a shared lock

flock ( $h , LOCK_SH );

$data = file_get_contents ( $filename );

fclose ( $h );

$data = @ unserialize ( $data );

       if (! $data ) {

// If unserializing somehow didn't work out, we'll delete the file

unlink ( $filename );

          return false ;

       }

       if ( time () > $data [ 0 ]) {

// Unlinking when the file was expired

unlink ( $filename );

          return false ;

       }

       return $data [ 1 ];

    }

    function delete ( $key ) {

$filename = $this -> getFileName ( $key );

       if ( file_exists ( $filename )) {

           return unlink ( $filename );

       } else {

           return false ;

       }

    }

   private function getFileName ( $key ) {

       return ini_get ( 'session.save_path' ) . '/s_cache' . md5 ( $key );

   }

}

?>

There you go, a complete, proper OOP, file-based caching class... I hope I explained things well.

Memory based caching through APC

If files aren't fast enough for you, and you have enough memory to spare.. Memory-based caching might be the solution. Obviously, storing and retrieving stuff from memory is a lot faster. The APC extension not only does opcode cache (speeds up your php scripts by caching the parsed php script), but it also provides a simple mechanism to store data in shared memory.

Using shared memory in APC is extremely simple, I'm not even going to explain it, the code should tell enough.

<?php

class Sabre_Cache_APC extends Sabre_Cache_Abstract {

         function fetch ( $key ) {

             return apc_fetch ( $key );

         }

         function store ( $key , $data , $ttl ) {

             return apc_store ( $key , $data , $ttl );

         }

         function delete ( $key ) {

             return apc_delete ( $key );

         }

     }

?>

My personal problem with APC that it tends to break my code.. So if you want to use it.. give it a testrun.. I have to admit that I haven't checked it anymore since they fixed 'my' bug . . This bug is now fixed, APC is amazing for single-server applications and for the really often used data.

Memcached

Problems start when you are dealing with more than one webserver. Since there is no shared cache between the servers situations can occur where data is updated on one server and it takes a while before the other server is up to date.. It can be really useful to have a really high TTL on your data and simply replace or delete the cache whenever there is an actual update. When you are dealing with multiple webservers this scheme is simply not possible with the previous caching methods.

Introducing memcached . Memcached is a cache server originally developed by the LiveJournal people and now being used by sites like Digg , Facebook , Slashdot and Wikipedia .

How it works

Memcached consists of a server and a client part.. The server is a standalone program that runs on your servers and the client is in this case a PHP extension.

If you have 3 webservers which all run Memcached, all webservers connect to all 3 memcached servers. The 3 memcache servers are all in the same 'pool'.

The cache servers all only contain part of the cache. Meaning, the cache is not replicated between the memcached servers.

To find the server where the cache is stored (or should be stored) a so-called hashing algorithm is used. This way the 'right' server is always picked.

Every memcached server has a memory limit. It will never consume more memory than the limit. If the limit is exceeded, older cache is automatically thrown out (if the TTL is exceed or not).

This means it cannot be used as a place to simply store data.. The database does that part. Don't confuse the purpose of the two!

Memcached runs the fastest (like many other applications) on a Linux 2.6 kernel.

By default, memcached is completely open.. Be sure to have a firewall in place to lock out outside ip's, because this can be a huge security risk.

Installing

When you are on debian/ubuntu, installing is easy:

apt-get install memcached

You are stuck with a version though.. Debian tends to be slow in updates. Other distributions might also have a pre-build package for you. In any other case you might need to download Memcached from the site and compile it with the usual:

./configure

make

make install

There's probably a README in the package with better instructions.

After installation, you need the Pecl extension . All you need to do for that (usually) is..

pecl install Memcache

You also need the zlib development library. For debian, you can get this by entering:

apt-get install zlib1g-dev

However, 99% of the times automatic pecl installation fails for me. Here's the alternative installation instructions.

pecl download Memcache

tar xfvz Memcache-2.1.0.tgz #version might be changed

cd Memcache-2.1.0

phpize

./configure

make

make install

Don't forget to enable the extension in php.ini by adding the line extension=memcache.so and restarting the webserver.

The good stuff

After the Memcached server is installed, running and you have PHP running with the Memcache extension, you're off.. Here's the Memcached class.

<?php

class Sabre_Cache_MemCache extends Sabre_Cache_Abstract {

// Memcache object

public $connection ;

         function __construct () {

$this -> connection = new MemCache ;

         }

         function store ( $key , $data , $ttl ) {

             return $this -> connection -> set ( $key , $data , 0 , $ttl );

         }

         function fetch ( $key ) {

             return $this -> connection -> get ( $key );

         }

         function delete ( $key ) {

             return $this -> connection -> delete ( $key );

         }

         function addServer ( $host , $port = 11211 , $weight = 10 ) {

$this -> connection -> addServer ( $host , $port , true , $weight );

         }

     }

?>

Now, the only thing you have to do in order to use this class, is add servers. Add servers consistently! Meaning that every server should add the exact same memcache servers so the keys will distributed in the same way from every webserver.

If a server has double the memory available for memcached, you can double the weight. The chance that data will be stored on that specific server will also be doubled.

Example

<?php

$cache = new Sabre_Cache_MemCache ();

$cache -> addServer ( 'www1' );

$cache -> addServer ( 'www2' , 11211 , 20 ); // this server has double the memory, and gets double the weight

$cache -> addServer ( 'www3' , 11211 );

// Store some data in the cache for 10 minutes

$cache -> store ( 'my_key' , 'foobar' , 600 );

// Get it out of the cache again

echo( $cache -> fetch ( 'my_key' ));

?>

Some final tips

Be sure to check out the docs for Memcache and APC to and try to determine whats right for you.

Caching can help everywhere SQL queries are done.. You'd be surprised how big the difference can be in terms of speed..

In some cases you might want the cross-server abilities of memcached, but you don't want to use up your memory or have your items automatically get flushed out.. Wikipedia came across this problem and traded in fast memory caching for virtually infinite size file-based caching by creating a memcached-compatible engine, called Tugela Cache , so you can still use the Pecl Memcache client with this, so it should be pretty easy. I don't have experience with this or know how stable it is.

If you have different requirements for different parts of your cache, you can always consider using the different types alongside.

Create a searchable Google map

noreply@blogger.com (Octopus) — Wed, 21 Nov 2007 08:04:00 +0000

Google's Mark Lucokvsky shows you how to add search functionality to maps using the GSmapSearchControl Solution

The GSmapSearchControl Solution is a simple to use application of the Google AJAX Search API that is designed to let you easily add a searchable map to your pages, sites and blogs. The rest of this page discusses this topic in detail - but if you just want to cut and paste some code, the “hello world” of the Map Search Control solution is available at the end of this article .

This basic sample demonstrates the following features:

A search control that allows you to look up addresses and business listings, plotting the results on a map.

The search control has a programmable center point, and at this center point you can specify a custom title and url.

The search control takes a small amount of verticle space while inactive, the inactive view is a small map with a white center point.

Once a search completes, the map expands and the search result cursors allow you to scroll through the set of search results.

Each search result contains a link to a details page for the result as well as a link to get driving directions from the center point of the map to the current search result.

The clear button in the center of the cursor controls clears the current set of results and sets the control into the idle state.

The solution is designed for extreme ease of use. As a site designer you are able to control the center point location as well as a custom title and url. In addition, you can easily program a collection of “search links” that you can place on your page that when clicked, will drive the search control.

New Functionality Update

If you are already familiar with this solution, you might find the following new functionality helpful and useful.

Custom Icons

Zoom Level Control

Enabling GMapTypeControl

Instructions for adding this to your site

Adding the solution is a simple three step process.

Step 1 - Load AJAX Search API, the Google Maps API, and the Map Search Solution

First you need to load the Google AJAX Search API, the Google Maps API, and the Map Search solution into your application. If you don't already have a Google AJAX Search API key, your first step is to sign up for a key . With your key in hand, add the following five lines of code to your page or blog template.

<script src="http://maps.google.com/maps?file=api&v=2&key=YOUR-KEY" type="text/javascript"></script> <script src="http://www.google.com/uds/api?file=uds.js&v=1.0&key=YOUR-KEY" type="text/javascript"></script> <script src="http://www.google.com/uds/solutions/mapsearch/gsmapsearch.js" type="text/javascript"></script>  <link href="http://www.google.com/uds/css/gsearch.css" rel="stylesheet" type="text/css"/> <link href="http://www.google.com/uds/solutions/mapsearch/gsmapsearch.css" rel="stylesheet" type="text/css"/>

Step 2 - Define a location on your page for the Map Search Control

The next step is to define a place on your page for the search control (note: you can have more than one). This is typically done by defining a named <div> element as we have shown below:

<div id="mapsearch">Loading...</div>

You might want to set some styling attributes on this element to constrain the width of the control, set a border or margin, etc. For example, a style rule like this might be useful.

#mapsearch { width : 400px; margin : 10px; padding : 4px; border : 1px solid #f9f9f9; }

In addition to this base style, the height of the idle state map and the active state map is easily modified.

/* set height of idle state map */ #mapsearch .gsmsc-idleMapDiv { height : 200px; } /* set height of active state map */ #mapsearch .gsmsc-mapDiv { height : 300px; }

Step 3 - Create a GSmapSearchControl and bind it to your page

The final step involves creating and configuring the control. The control is very powerful and offers several options. In this section, we will describe the simplest case of adding a control to your page or blog followed several examples that demonstrate more advanced concepts.

The first step is to actually get your code to run. The easiest way to do this is to either extend an existing body onload handler, or create a new one. Find the <body> element on your page and add an onload handler.

Now write your onload handler by adding some code to an existing <script> block, or by creating a new one. Find the <body> element on your page and add an onload handler. The code snippet below demonstrates how to create a new map search control that will appear on your page inside the element named “mapsearch”. The map will center itself on Google corporate headquarters located at “1600 Amphitheatre Parkway, Mountain View, CA.”

Options

Notice in the above example, the value null is passed as the options argument, a Javascript object which is typically specified in object literal form. The following sections describe the possible values for options . These values support the following features:

Setting a special title and url for the map center point.

Specifying a set of hot spots on your page that will trigger searches

Setting a special title and url for the map center point

A special title and url can be programmed into the control and bound to the white center point marker of an active map. A typical use case for this feature might be to specify a conference name and conference url, or a company name and url. In order to request this functionality, the title and url properties of the options argument must be set. The following code snippet demonstrates this.

Setting up hot spots

A common use case for this control is program hot spots on to your page thatwhen clicked will drive the search control. These hot spots might take the form of a list of recommendations, hotels, restaurants, etc. The search control supports this by allowing you to program a list of HTML elements and associated queries. When your users click on the element, the search control is activated with the specified query.

The options argument contains an optional hotspot property. This property is an array of objects, where each object contains an element property which is a reference to an HTML element on your page, as well as a query property which specifies a query to execute when the element is clicked.

The following code fragment demonstrates the use of this feature including the CSS declarations,HTML fragments, and options programming. If you prefer programming this on your own, perhaps by using <a> tags with javascript: urls, that's a perfectly reasonable way to proceed. We include this capability in the solution because for some of our users, this is a simpler mechanism that requires less of their time to develop. In the snippet that follows we are going to show sample CSS, HTML, and search control initialization logic.

/* define the CSS used to style the hotspots */ h4.hotspot { font-size : 100%; font-weight : normal; color : rgb(9, 122, 182); margin-left : 8px; margin-top : 0px; margin-bottom : 2px; font-style : normal; cursor : pointer; } h4.hotspot:hover { color : rgb(237, 92, 11); text-decoration : underline; }  <div id="mapsearch">Loading...</div> <h3 class="hotspotheader">Recommendations</h3> <h4 id="hs01" class="hotspot">Caffeine</h4> <h4 id="hs02" class="hotspot">Thai Food</h4> <h4 id="hs03" class="hotspot">Pizza</h4> <h4 id="hs04" class="hotspot">Gym</h4> <h4 id="hs05" class="hotspot">Hotel Avante</h4> <h4 id="hs06" class="hotspot">Residence Inn</h4> <h4 id="hs07" class="hotspot">The Four Seasons</h4> <h4 id="hs08" class="hotspot">The Westin, Palo Alto</h4> <script type="text/javascript"> function OnLoad() { // Create an array of hotspots. Each entry contains and html element // from your page, and the query to execute when that element is clicked var hotspotsList = [ { element : document.getElementById("hs01"), query : "Starbucks" }, { element : document.getElementById("hs02"), query : "Amarin Thai" }, { element : document.getElementById("hs03"), query : "Frankie Johnnie & Luigi" }, { element : document.getElementById("hs04"), query : "Hotel Avante" }, { element : document.getElementById("hs05"), query : "Residence Inn" }, { element : document.getElementById("hs06"), query : "Four Seasons Palo Alto" }, { element : document.getElementById("hs07"), query : "Westin Palo Alto" } ]; // set title to the Googleplex and the link to // the Google corporate information page // set the hotspot list to the list above var options = { title : "Googleplex", url : "http://www.google.com/corporate/index.html", hotspots : hotspotsList } // create the map search control new GSmapSearchControl( document.getElementById("mapsearch"), "1600 Amphitheatre Parkway, Mountain View, CA", options ); } </script>

New! Setting Custom Center Icon

Applications can either accept the default center location icon, or they can supply their own GIcon and the system will use that Icon to mark the center point of the map.

The options argument contains an optional centerIcon property. When supplied, property must specify a valid GIcon . When specified, this icon is used as the center point marker for both the idle and active map.

The following code fragment demonstrates the use of this feature. It demonstrates the use of both a hand built icon, as well as the G_DEFAULT_ICON two calls:

// use the ridefinder, small yellow icon as the center point marker var ci = new GIcon(); ci.image = "http://labs.google.com/ridefinder/images/mm_20_yellow.png"; ... (rest of initialization omitted) new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", centerIcon : ci } ); // use the G_DEFAULT_ICON as the center point marker new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", centerIcon : G_DEFAULT_ICON } );

New! Setting Custom Selected and Unselected Icons

Applications are able to specify the icons for the currently selected search result as well as for all unselected search results using a similar model.

The options argument contains an optional selectedIcon property. When supplied, property must specify a valid GIcon . When specified, this icon is used as the marker for the selected search result.

The options argument contains an optional unselectedIcon property. When supplied, property must specify a valid GIcon . When specified, this icon is used as the marker for all other search results.

The following code fragment demonstrates the use of this feature:

// use the G_DEFAULT_ICON as the for selected and unselected search results new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", selectedIcon : G_DEFAULT_ICON, unselectedIcon : G_DEFAULT_ICON } );

Controlling the Zoom Level

Applications can control the Zoom Level for the idle map (displayed when no searches are active) as well as for the active map (displayed when a map is showing results). The system defines two constants that are helpful when configuring this aspect of the control:

GSmapSearchControl.IDLE_MAP_ZOOM - the default zoom level for the idle map

GSmapSearchControl.ACTIVE_MAP_ZOOM - the default zoom level for the active map

The options argument contains an optional idleMapZoom property. When supplied, this property specifies the zoom level for the idle map. A common use of this property is to have the idle map's zoom level match the default zoom level for the active map. In order to do this, use the constants described above to set idleMapZoom to GSmapSearchControl.ACTIVE_MAP_ZOOM .

The zoom level for the active map is controlled in a similar manner. The options argument contains an optional activeMapZoom property. When supplied, this property specifies the zoom level for the active map. Note: Applications can use these properties independently of each other.

The following code fragment demonstrates the use of this feature.

// set the idle map zoom so that it matches the // default active map zoom level new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", idleMapZoom : GSmapSearchControl.ACTIVE_MAP_ZOOM } ); // set the active map zoom level up by 1 new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", activeMapZoom : GSmapSearchControl.ACTIVE_MAP_ZOOM+1 } );

New! Enabling the Map Type Control

The default behavior of the maps created by this control is for them to not contain the GMapTypeControl , the control that allows switching between map, hybrid and satellite mode. This behavior is programmable allowing applications to cause the control to build maps with the GMapTypeControl available on all maps, or just on the active map.

The options argument contains an optional mapTypeControl property. When supplied, this property specifies which maps should be programmed to include the GMapTypeControl .

GSmapSearchControl.MAP_TYPE_ENABLE_ACTIVE - When this value is specified for the mapTypeControl property, the active map will contain a GMapTypeControl

GSmapSearchControl.MAP_TYPE_ENABLE_ALL - When this value is specified for the mapTypeControl property, both the active map and the idle map will contain a GMapTypeControl

The following code fragment demonstrates the use of this feature.

// enable a GMapTypeControl on the active map new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", mapTypeControl : GSmapSearchControl.MAP_TYPE_ENABLE_ACTIVE } ); // enable a GMapTypeControl on the all maps new GSmapSearchControl(container, "1600 Amphitheatre Parkway, Mountain View, CA", { title : "Googleplex", url : "http://www.google.com/press/factorytour.html", mapTypeControl : GSmapSearchControl.MAP_TYPE_ENABLE_ALL } );

The “Hello World” of GSmapSearchControl

The following page demonstrates a complete page which uses the GSmapSearchControl solution. You can start with this simple page, change internal to the value of your key and be up and running in seconds.

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/> <title>GSmapSearchControl Sample</title>   <script src="http://maps.google.com/maps?file=api&v=2&key=internal" type="text/javascript"></script> <script src="http://www.google.com/uds/api?file=uds.js&v=1.0&key=internal" type="text/javascript"></script> <script src="http://www.google.com/uds/solutions/mapsearch/gsmapsearch.js" type="text/javascript"></script>  <link href="http://www.google.com/uds/css/gsearch.css" rel="stylesheet" type="text/css"/> <link href="http://www.google.com/uds/solutions/mapsearch/gsmapsearch.css" rel="stylesheet" type="text/css"/> <style type="text/css"> body, table, p{ background-color: white; font-family: Arial, sans-serif; font-size: 13px; } #mapsearch { width : 400px; margin-left: 10px; padding: 4px; border : 1px solid #f9f9f9; } </style> <script type="text/javascript"> function OnLoad() { var options = { title : "Googleplex", url : "http://www.google.com/corporate/index.html" } new GSmapSearchControl( document.getElementById("mapsearch"), "1600 Amphitheatre Parkway, Mountain View, CA", options ); } </script> </head> <body onload="OnLoad()"> <div id="mapsearch">Loading...</div> </body> </html>

Examples

Basic Google Map Search

‘Hotspots' Google Map Search

15 Things you can do with Yahoo! UI

noreply@blogger.com (Octopus) — Wed, 21 Nov 2007 08:01:00 +0000

write by :Dustin Diaz dustindiaz.com

Slicken up your web apps with these tips and tricks using the Yahoo! User Interface library

I will admit straight up front - I don’t like writing long articles. There, I said it. I passed College English convincing my professors that I should be rewarded more for my creativity rather than the length of my prose. I’m the kind of guy that spent more time writing short stories than huge complicated essays. Eventually I went on to write for the school Newspaper, a.k.a. The State Hornet which gave me the freedom to keep my stories to a minimum of 500 words, or just a couple of paragraphs.

Today that legacy still stands and has transferred into my love for making widgets. No, not those widgets. I’m talking about those little goofy things you do on a Sunday afternoon from when you had that idea on Saturday night which left you frustrated on Friday after work. Yes, you’re not the only one with crazy ideas.

I’m talking about sliders, yoyos, tooltips, shakers, better looking code, faster queries, and random jubilees of DOM hoopla. It’s those small things that some of us live to create and find it rewarding even if it’s one line of code. And although these little works of ‘code art’ don’t always work on all browsers while having labels of ‘experimental’ written all over them, don’t feel ashamed of them. They come from you and you should embrace your work. You are, a Web Professional.

Segue

In this article I’m going to share some of my short stories, poems, and random sonnets of affectionate escapades I’ve had with JavaScript during the last few months, which I’ve built using the Yahoo UI utilities. Some are rather embarrassing, others useful, and yet others I feel are just downright sexy. If you see something you like, feel free to take it, tweak it, and make it your own. This is what some poetry afficionados of secret societies would call a poetry slam. So for want of a better phrase, this can be a .

Why YUI?

The YUI utilities give me the expressive freedom to do what I want. And although comparing libraries is generally silly, the best illustration I can give is the Script.aculo.us Effects library vs the YUI Animation utility. Script.aculo.us offers you some pretty sweet looking effects like Fade, SlideUp, BlindDown, Shake, etc.. You can even add Parallel effects (way to go Thomas). On the flip side, the animation util doesn’t aim to give you these canned effects to package up with your web app, but rather it lets you make up your own effects by giving you the finely crafted tools (like a utility knife) to make what you want.

Another reason I like YUI is that it isn’t out to change the language itself, but rather it solves many of the cross-browser incompatibilities that we run into on a daily basis. Beyond that, it does quite a few other sexy things that I think you might like.

Code

Below is a compilation of fifteen things that I have either developed over the last few months, or have been inspired by a friend (who will receive full credit on the original idea). Enjoy!

DOM + The getElementBy’s

These days, when you’re working with the DOM, it’s all about getting the elements you want, with conditions applied. Thankfully the Dom util doesn’t go all out and try to do all the guesswork for you resulting in a bulky library with large sets of unwanted code. Instead it gives you a handy method for you to work with called getElementsBy.

YAHOO.util.Dom.getElementsByClassName

Let’s kick off our slam with the classic getElementsByClassName (which is actually in the utility by default). I like to think of it as our token example by the YUI folks showing off how getElementsBy can work natively within your functions. See Demo

getElementsByAttribute

This method is not in the Dom util by default, but demonstrates exactly how we can add it in if we wanted. See Demo

getElementsByExternal & getElementsByInternal

This function allows you to get outbound or inbound links returned to you as an HTMLElement collection. At that point it’s up to you what you want to do with your array of elements (eg. bind event listeners or run a method against them). Currently this is untested on IP address URIs, but I presume that won’t be an issue for most situations. See Demo

Random Effects of Love

Because everyone enjoys California cheese.

Pagination Slide Pattern

Paginating through large data sets and keeping someone’s attention can be a tedious task. Sliding results within a container is one way to keep a person entertained. See Demo

BlindUp & BlindDown (Yoyo)

These are classic effects that almost any animation lover would want in their toolkit. For the sake of making them a macro, here they are. See Demo

BlindOut

A demonstration of animating a box from any given corner. See Demo

Faux Mutation Events with CustomEvent

Most folk don’t know what mutation events are, mainly because they don’t work in IE6. These are events just like regular DOM events like ‘click’,'mouseover’, or ‘mouseout’ that you can listen for. Just to name a few there are ‘DOMNodeInserted’, ‘DOMNodeRemoved’, and ‘DOMNodeInsertedIntoDocument’. For a better reference you can see Wikipedia’s entry on DOM events and search for the Mutation events within the event table. Anyway, here’s how you can simulate some of those events using the CustomEvent class.

DOMNodeInserted

Create some elements, listen for the event, then make them draggable. See Demo

DOMNodeRemoved

Create some elements, then remove them to update an information box. See Demo

More with CustomEvents

There really is an endless amount of Custom Events that you can create. So we’ll keep this to a minimum. Here are three places that the CustomEvent can come in useful:

Extending the Drag and Drop

Currently, the Drag and Drop utility is packaged with quite a few custom events you can override such as startDrag, onDrag, or endDrag. However the problem is that you can’t subscribe to any of these, only override. Here is one trick you can use to make them subscribable. See Demo

onMenuOpen & onMenuCollapse

This is a combination of animation and custom events where we show menu items sliding into view and firing off subscribable events. See Demo

General Recipes

None of these have any rhyme or reason. But I tend to think that in some place or another, they can solve a problem.

Sweet Titles (YUI Style)

Here we have an OO version of Sweet Titles that allows us to declare multiple instances of tooltips on separate elements with some optional configuration parameters you can pass into the constructor object to get that exact look and feel you want out of a tooltip. See Demo

Faux Lightbox Effect

For the sake of doing something that’s already been done, here’s a faux light box effect that can be obtained using some core tools. See Demo

Photo Batching

YAHOO.util.Dom.batch alone may convince you of how cool the DOM Collection utility can be. This shows you how you can batch an HTML Element collection to a method. (Thanks Matt Sweeny) See Demo

Unobtrusive new windows links

For some reason or another, this always seems to create some noise regardless of its controversial nature. Here is a very simple way to do it with Event, DOM, and some of the tools we’ve defined in this very article. See Demo

Layout Switching with Grids

This is a combination of using the CSS Grids toolkit and swapping out the templates using JavaScript animation See Demo

That’s All Folks

At least for this article’s sake. There are plenty of other things you can making using the Yahoo! UI utilities and this has only scratched the surface. I hope it was as fun for you as it was for me.

Application logic versus template logic

noreply@blogger.com (Octopus) — Wed, 21 Nov 2007 07:55:00 +0000

By Quentin Zervaas, 1 May 2006

This article takes a look at separating application logic from template logic. We will use the Smarty Template Engine as the basis for the article and its examples.

What this is basically saying is that anything relating to the final output should be determined in the template, while any data handling or processing should be done in your PHP files and classes. There's a little more to it than though, which we'll soon see.

An important aspect of this is that it works both ways. Often people focus on making sure their templates don't do anything application related, but then make the mistake of making their PHP scripts (or classes) doing work that their templates should be doing. We will look at both situations and common issues that arise.

What is application logic?

Application logic (also called business logic) is any code that deals with processing of data. That is, the processing behind the scenes. Common examples of this include:

Processing the input from a web form

Saving data to a database

Debiting money from a credit card

Reading or writing cookies on the client's computer

This even includes instantiating the Smarty class and displaying a template:

Highlight: PHP

<?php $smarty = new Smarty () ; $smarty -> display ( ' index.tpl ' ) ; ?>

It also includes generating data that may be used in your template logic, but we'll look at that in a little while.

What is template logic?

Template logic (also called display logic) is any code in your templates that determines how things are displayed. For instance, if you output a certain message if a string is empty, or the string if it isn't empty, then this is template logic. Here's an example:

Highlight: Smarty Template

{if $name|strlen == 0) < p > You didn't enter your name! < p > {else} < p > Hello {$name} </ p > {/if}

Formatting of a string is also template logic (although there may be exceptions, depending on the data). For example:

Highlight: Smarty Template

< p > Title: {$title|strtoupper} Summary: {$summary|truncate} </ p >

We'll look at some more examples of application logic and template logic shortly, for now, we'll look at things that aren't application logic and aren't template logic.

Application logic in templates—bad!

Smarty allows developers to directly embed PHP code by using the {php} {/php} tag. Personally, while it's good to have the functionality available, I think it's almost always a bad idea to ever use this. It is also possible to use any declared PHP function (builtin or user defined) as a modifier (unless you have template security turned on).

An example would be to directly access some data from a form and sanitize it in the template:

Highlight: Smarty Template

< p > This is bad, but you entered {$smarty.get.name|strip_tags|trim}. </ p >

The way this should be done is done in the PHP file, and then passing the sanitized value to the template:

Highlight: PHP

<?php require_once ( ' Smarty.class.php ' ) ; $name = trim ( strip_tags ( $_GET [ ' name ' ])) ; $smarty = new Smarty () ; $smarty -> assign ( ' name ' , $name ) ; $smarty -> display ( ' example.tpl ' ) ; ?>

And then the template would look like:

Highlight: Smarty Template

< p > This is good. You entered {$name}. </ p >

Examples of acceptable logic in templates

So now that I've covered a few bad things, what kinds of things are acceptable? Here are some examples.

Checking a string value or boolean flag (or string length, etc.) to determine what to output:

Highlight: Smarty Template

{if $name|strlen > 8} < p > Your name is long! </ p > {/if} {if $male} < img src = " male.gif " /> {else} < img src = " female.gif " /> {/if}

Alternating background colours

Actually, this is made easy in Smarty with the {cycle} function:

Highlight: Smarty Template

< table > < tr > < th > Field 1 </ th > < th > Field 2 </ th > </ tr > {foreach from=$data item=row} < tr style = " background: {cycle values='#ccc,#ddd'} " > < td > {$row.field1} </ td > < td > {$row.field2} </ td > </ tr > {/foreach} </ table >

Displaying a running count

This is also made easy in Smarty, using the {counter} function.

Highlight: Smarty Template

{foreach from=$items row=item} < p > Item number {counter}. {$item} </ p > {/foreach}

Including another template

This will be required frequently, and as we point out next, the alternative to doing this is quite bad!

Highlight: Smarty Template

{include file='header.tpl'} < p > Example of including a header and a footer. </ p > {include file='footer.tpl'}

Template logic in applications

There are several situations where you may incorrectly end up using template logic in your application without even realising.

Case 1: displaying multiple template files

Take a look at this PHP code to output a single page:

Highlight: PHP

<?php require_once ( ' Smarty.class.php ' ) ; $smarty = new Smarty () ; $smarty -> display ( ' header.tpl ' ) ; $smarty -> display ( ' example.tpl ' ) ; $smarty -> display ( ' footer.tpl ' ) ; ?>

This is extremely bad! You have essentially hardcoded in your application that your templates are built by displaying a header, then the main content, and then the footer. The fact that your templates are split into 3 templates like this is a function of the templates, not of the application.

The correct way to do this is:

Highlight: PHP

<?php require_once ( ' Smarty.class.php ' ) ; $smarty = new Smarty () ; $smarty -> display ( ' example.tpl ' ) ; ?>

And then the example.tpl file would like:

Highlight: Smarty Template

{include file='header.tpl'} < p > Example of including a header and a footer. </ p > {include file='footer.tpl'}

Case 2: Determining a style or an image in code and then assigning it to a template

Let's assume you're outputting a document and you want to show an image that says ‘new' if it was submitted today, or an image that says ‘old' if it was submitted earlier.

It would be bad to specify this image in the code like so:

Highlight: PHP

<?php require_once ( ' Smarty.class.php ' ) ; if ( $article -> isNew ) $image = ' new.gif ' ; else $image = ' old.gif ' ; $smarty = new Smarty () ; $smarty -> assign ( ' image ' , $image ) ; $smarty -> display ( ' example.tpl ' ) ; ?>

Even worse would be:

Highlight: PHP

<?php if ( $article -> isNew ) $image = ' <img src="new.gif" alt="New" /> ' ; else $image = ' <img src="old.gif" alt="Old" /> ' ; ?>

It seems obvious, but I have seen it done. The correct way would be to pass the flag to the template and in the template determine which image to use:

Highlight: PHP

<?php require_once ( ' Smarty.class.php ' ) ; $smarty = new Smarty () ; $smarty -> assign ( ' isNew ' , $article -> isNew ) ; $smarty -> display ( ' example.tpl ' ) ; ?>

And the template:

Highlight: Smarty Template

{if $isNew} < img src = " new.gif " alt = " New " /> {else} < img src = " old.gif " alt = " New " /> {/if}

Afterall, the image is tied to display. You might change template sets or image sets, resulting a new filename. You should only have to change your templates, not your application code.

Exceptions

There are always going to be exceptions where you may need to put application logic in a template, or some circumstances that sit right on the fence. Here's an example:

Highlight: Smarty Template

< input type = " text " name = " title " value = " {$title|escape} " />

In this situation, to deal with the fact a user might enter a quotation mark (”), we must escape the data. You could argue that this is application logic, but personally, I think this is directly related to the output of your HTML document, and so should be escaped when it is output.

Another exception I can think of would be if you wanted to list news articles in your template, but you're not sure how many. That is, the number of articles shown is a function of the template. In one layout you might have room to fit three articles, but if you change templates, you might have room for 5. So how many articles do you assign?

The only way to cover all bases would be to get every single article and assign them all to the template. This seems somewhat excessive. The way I have dealt with this in the past is to use a function call with the number of articles. This function directly calls the database, which as we have said is therefore application logic, but sometimes there's no easier way around things:

Highlight: Smarty Template

{foreach from=$news->getArticles(5) item=article} < h2 > {$article.headline} </ h2 > {/foreach}

Common sense

You must use your own judgement when determining what should be in code and what should be in template. Take a look at this example of checking for an empty array:

Highlight: Smarty Template

{assign var='numElements' value=$myArray|@count} {if $numElements == 0} < p > The array is empty. </ p > {else} < p > There are {$numElements} elements. </ p > {/if}

Strictly speaking, you should determine the count in PHP, and perhaps even a flag to check if it's empty:

Highlight: PHP

<?php require_once ( ' Smarty.class.php ' ) ; $myArray = array ( 1 , 2 , 3 ) ; $numElements = count ( $myArray ) ; $isEmpty = $numElements == 0 ; $smarty = new Smarty () ; $smarty -> assign ( ' myArray ' , $myArray ) ; $smarty -> assign ( ' numElements ' , $numElements ) ; $smarty -> assign ( ' isEmpty ' , $isEmpty ) ; $smarty -> display ( ' example.tpl ' ) ; ?>

And the example.tpl file:

Highlight: Smarty Template

{if $isEmpty} < p > The array is empty. </ p > {else} < p > There are {$numElements} elements. </ p > {/if}

Personally, I think the second method is overkill and I would always use the first method. The additional problem is that we don't necessarily know in the script what data the template requires.

The fact that we do something in the template for an empty array is display specific, not something that needs to be known in the application.

Conclusion

In this article I explained the difference between application logic and template logic when using Smarty. Hopefully you found some simple ways to improve your template design, but also recognised that some complexities can arise when doing this and sometimes comprimises must be made.

One (simplified) way to look at it is like this:

You should be able to completely change templates, including all image files and CSS files, without having to touch any of your PHP files.

All fundamental data required in your templates should be fetched or determined ahead of time and assigned to your templates (this doesn't include meta data, such as the length of a string, etc.).

Further reading

Smarty Template Engine

Smarty – why use it?

URL Rewriting with ASP.NET 2.0

noreply@blogger.com (Octopus) — Wed, 21 Nov 2007 07:51:00 +0000

Introduction

In this article, you will learn about URL Rewriting in ASP.NET 2.0. URL Rewriting was originally introduced by Apache as an extensions called mod_rewrite. The concept of URL rewriting is simple. It allows you to rewrite URL from those ugly URL into a better URL and hence it will perform better in SEO.

Most Search Engines will ignore those dynamic URL such as the one ended with querystring
e.g http://www.worldofasp.net/displayproduct.aspx?ID=10
Therefore if you like to have more hits and traffic from search engine, consider of rewriting all those querystring url into normal URL.

If you rewrite the URL above, you can actually rewrite it into more readable format
e.g http://www.worldofasp.net/product10.aspx.
or you can rewrite it to http://www.worldofasp.net/product/10.aspx.

Search Engine robot will think that your dynamic page is a normal page and therefore it will crawl your page and your page will have a better search results.
If you check all the page in Worldofasp.net or CodeProject.com, you can see that the web developer is using URL rewriting techniques.

Main

Microsoft .NET Framework 2.0 come with limited URL Rewriting Library support and you have to write your own URL Rewriting engine if you need complex URL rewriting for your website.

The simplest URL Rewriting that you can achieve in seconds is by copy and paste the code below to your global.asax file.

void Application_BeginRequest(Object sender, EventArgs e)
{
String strCurrentPath;
String strCustomPath;
strCurrentPath = Request.Path.ToLower();

if (strCurrentPath.IndexOf("ID") >= 0)
{
strCustomPath = "/Product10.aspx";
// rewrite the URL
Context.RewritePath( strCustomPath );
}
}

As you can see from the code above, the URL Redirection is only limited to one rules. It will always redirect to one page called product10.aspx if it detects that your URL contains ID keyword.
Of course this one will not work if you want different Query String ID to redirect to different page or if you want to have different page redirection for different query string type.

To have a more complex URL Rewriting Rules, we can use Regular Expressions for implementing different redirection techniques.

Now, lets start writing some rules for your Redirection.

product/(.*)\.aspx
displayProduct.aspx?ID=$1

Items/Mouse/(.*)\.aspx
ViewItem.aspx?ID=$1

As you can see from the first rules above, It will redirect the URL from product/(Number).aspx into displayProduct.aspx?ID=(Number).
Second rules will redirect the URL if it Contains Items/Mouse/(Number).aspx into ViewItem.aspx?ID=(Number). You can add as many rules as you like by just adding the xml node above

void Application_BeginRequest(Object sender, EventArgs e)
{
string sPath = Context.Request.Path;
//To overcome Postback issues, stored the real URL.
Context.Items["VirtualURL"] = sPath;
Regex oReg;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(Server.MapPath("/XML/Rule.xml"));
_oRules = xmlDoc.DocumentElement;

foreach (XmlNode oNode in _oRules.SelectNodes("rule"))
{
oReg = new Regex(oNode.SelectSingleNode("url/text()").Value);
Match oMatch = oReg.Match(sPath);

if (oMatch.Success)
{
sPath = oReg.Replace(sPath, oNode.SelectSingleNode("rewrite/text()").Value);
break;
}
}
Context.RewritePath(sPath);
}

The code above is self explanatory. It will search from the rules in XML file and if it match, then it will rewrite the path.
Thats all you need to do to implement URL Rewriting. However after you rewrite the URL, all your page postbacks will not work. The reason is because, ASP.NET will automatically by default output the "action" attribute of the markup to point back to the page it is on. The problem when using URL-Rewriting is that the URL that the page renders is not the original URL of the request . This means that when you do a postback to the server, the URL will not be your nice clean one.

To overcome this problem, you need to add this code on every page that you want to do postbacks.

protected override void Render(HtmlTextWriter writer)
{
if (HttpContext.Current.Items["VirtualURL"] != null)
{
string sVirURL= HttpContext.Current.Items["VirtualURL"].ToString()
RewriteFormHtmlTextWriter oWriter = new RewriteFormHtmlTextWriter(writer,sVirURL);
base.Render(oWriter);
}

}

Source Code for RewriteFormHtmlTextWriter

public class RewriteFormHtmlTextWriter : HtmlTextWriter
{
private bool inForm;
private string _formAction;

public RewriteFormHtmlTextWriter(System.IO.TextWriter writer):base(writer)
{

}
public override void RenderBeginTag(string tagName)
{
if (tagName.ToString().IndexOf("form") >= 0)
{
base.RenderBeginTag(tagName);
}
}
public RewriteFormHtmlTextWriter(System.IO.TextWriter writer, string action)
: base(writer)
{

this._formAction = action;

}
public override void WriteAttribute(string name, string value, bool fEncode)
{
if (name == "action")
{
value = _formAction;
}
base.WriteAttribute(name, value, fEncode);
}

}

That's all you need to implement a complex and fully extensible URL Rewriting. You can create unlimited rules into your Rules.xml file and redirect to the page you want.

Conclusion

In this article, you can see how easy it is to implement URL Rewriting for your website. You can do enhancements and improve the workflow of the code above. For faster execution of your rules, you can also stores the Rules.xml files as Caching objects so it will save lots of time compare to open and close the xml files everytime the rewrite happens.

Storing Images in database with C#

noreply@blogger.com (Octopus) — Wed, 24 Oct 2007 09:08:00 +0000

Storing Images

Create a table in a SQL Server 2000 database which has at least one field of type IMAGE.

Here is the script I used:

CREATE TABLE [dbo].[tblImgData] (

       [ID] [int] NOT NULL ,

       [Name] [varchar] (50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL ,

       [Picture] [image] NULL

) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

Actually IMAGE field is just holding the reference to the page containing the binary data so we have to convert our image into bytes.

I used a file open dialog box to locate the file.

this.openFileDialog1.ShowDialog(this);
string strFn=this.openFileDialog1.FileName;

By using FileInfo class, I retrieved the file size:
```
FileInfo fiImage=new FileInfo(strFn);
```

Declare an array of that size.

this.m_lImageFileLength=fiImage.Length;
m_barrImg=new byte[Convert.ToInt32(this.m_lImageFileLength)];

By using FileStream object, I filled the byte array.

FileStream fs=new FileStream(strFn,FileMode.Open,
                 FileAccess.Read,FileShare.Read);
int iBytesRead=fs.Read(m_barrImg,0,
              Convert.ToInt32(this.m_lImageFileLength));
fs.Close();

Complete Load Image Code

protected void LoadImage()
{
   try
   {
       this.openFileDialog1.ShowDialog(this);
       string strFn=this.openFileDialog1.FileName;
       this.pictureBox1.Image=Image.FromFile(strFn);
       FileInfo fiImage=new FileInfo(strFn);
       this.m_lImageFileLength=fiImage.Length;
       FileStream fs=new FileStream(strFn,FileMode.Open,
                         FileAccess.Read,FileShare.Read);
       m_barrImg=new byte[Convert.ToInt32(this.m_lImageFileLength)];
       int iBytesRead = fs.Read(m_barrImg,0,
                        Convert.ToInt32(this.m_lImageFileLength));
       fs.Close();
   }
   catch(Exception ex)
   {
       MessageBox.Show(ex.Message);
   }
}

Saving byte array data to database.

Create command text to insert record.

this.sqlCommand1.CommandText=
 "INSERT INTO tblImgData(ID,Name,Picture)" +
 " values(@ID,@Name,@Picture)";

Create parameters.

this.sqlCommand1.Parameters.Add("@ID",
          System.Data.SqlDbType.Int, 4);
this.sqlCommand1.Parameters.Add("@Name",
          System.Data.SqlDbType.VarChar, 50);

this.sqlCommand1.Parameters.Add("@Picture",
          System.Data.SqlDbType.Image);

Notice “@Picture” has “SqlDbType.Image” because it is of IMAGE type Field.

Provide the value to the parameters.

this.sqlCommand1.Parameters["@ID"].Value=this.editID.Text;
this.sqlCommand1.Parameters["@Name"].Value=this.editName.Text;

this.sqlCommand1.Parameters["@Picture"].Value=this.m_barrImg;

“this.m_barrImg” is a byte array which we filled in the previous step.

Now execute non-query for saving the record to the database.
```
int iresult=this.sqlCommand1.ExecuteNonQuery();
```

Complete Save Image Code

Collapse

private void btnSave_Click(object sender, System.EventArgs e)
{
   try
   {
       this.sqlConnection1.Open();
       if (sqlCommand1.Parameters.Count ==0 )
       {
           this.sqlCommand1.CommandText="INSERT INTO tblImgData(ID," +
                          " Name,Picture) values(@ID,@Name,@Picture)";
           this.sqlCommand1.Parameters.Add("@ID",
                            System.Data.SqlDbType.Int,4);
           this.sqlCommand1.Parameters.Add("@Name",
                            System.Data.SqlDbType.VarChar,50);
           this.sqlCommand1.Parameters.Add("@Picture",
                            System.Data.SqlDbType.Image);
       }

       this.sqlCommand1.Parameters["@ID"].Value=this.editID.Text;
       this.sqlCommand1.Parameters["@Name"].Value=this.editName.Text;
       this.sqlCommand1.Parameters["@Picture"].Value=this.m_barrImg;

       int iresult=this.sqlCommand1.ExecuteNonQuery();
       MessageBox.Show(Convert.ToString(iresult));
   }
   catch(Exception ex)
   {
       MessageBox.Show(ex.Message);
   }
   finally
   {
       this.sqlConnection1.Close();
   }
}

Retrieving Image

Retrieving images from the database is the exact reverse process of saving images to the database.

First create command text to retrieve record.

SqlCommand cmdSelect = new SqlCommand("select Picture" +
                      " from tblImgData where ID=@ID",
                      this.sqlConnection1);

Create parameter for the query.

cmdSelect.Parameters.Add("@ID",SqlDbType.Int,4);

Provide value to the parameter.

cmdSelect.Parameters["@ID"].Value=this.editID.Text;

Open database connection and execute “ExecuteScalar” because we want only “IMAGE” column data back.
```
byte[] barrImg=(byte[])cmdSelect.ExecuteScalar();
```
As the execute scalar returns data of “Object” data type, we cast it to byte array.

Save this data to a temporary file.

string strfn=Convert.ToString(DateTime.Now.ToFileTime());
FileStream fs=new FileStream(strfn,FileMode.CreateNew,FileAccess.Write);
fs.Write(barrImg,0,barrImg.Length);
fs.Flush();
fs.Close();

And display the image anywhere you want to display.
```
pictureBox1.Image=Image.FromFile(strfn);
```

Complete Image Retrieving Code

private void btnLoad_Click(object sender, System.EventArgs e)
{
   try
   {
       SqlCommand cmdSelect=new SqlCommand("select Picture" +
             " from tblImgData where ID=@ID",this.sqlConnection1);
       cmdSelect.Parameters.Add("@ID",SqlDbType.Int,4);
       cmdSelect.Parameters["@ID"].Value=this.editID.Text;

       this.sqlConnection1.Open();
       byte[] barrImg=(byte[])cmdSelect.ExecuteScalar();
       string strfn=Convert.ToString(DateTime.Now.ToFileTime());
       FileStream fs=new FileStream(strfn,
                         FileMode.CreateNew, FileAccess.Write);
       fs.Write(barrImg,0,barrImg.Length);
       fs.Flush();
       fs.Close();
       pictureBox1.Image=Image.FromFile(strfn);
   }
   catch(Exception ex)
   {
       MessageBox.Show(ex.Message);
   }
   finally
   {
       this.sqlConnection1.Close();
   }
}

Storing Binary Data to Database using ASP.NET 2.0

noreply@blogger.com (Octopus) — Wed, 24 Oct 2007 09:06:00 +0000

As a developer, you might face few requirements where you want to upload large documents, PDF's and images from your application. Then how do you manage and store such large data? Usually, traditional approach was to store those large files on web server's file system. But you also have database approach which allows you to store those large documents like PDF's, .zip files, images etc., as binary data directly in the database itself. Let's elaborate on Database approach a bit further. How do we usually store large data objects in Databases like SQL Server 2000? Ok, SQL server 2000 supports exclusive image data type to hold image data. Now SQL Server 2005 supports another new data type varbinary which allows storing binary data up to 2GB in size.

Even with new data types, we still need to understand that working with binary data is not the same as straight forward working with text data. So, we are here to discuss how to use ASP.NET 2.0 SqlDataSource control to store and retrieve image files directly from a database.

We will create application which allows user to upload images and display the uploaded pictures. The uploaded images will be stored in database as binary data. You can download sample project, used in this tutorial. To hold image data, we need to create new table called PictureTable as shown below

if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[PictureTable]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[PictureTable]
GO

CREATE TABLE [dbo].[PictureTable] (
[ImageID] [int] IDENTITY (1, 1) NOT NULL ,
[Title] [varchar] (50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL ,
[DateAdded] [datetime] NOT NULL ,
[MIMEType] [varchar] (50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL ,
[Image] [image] NOT NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
Schema script for PictureTable

This table records details of pictures and content. The PictureTable table's MIMEType field holds the MIME type of the uploaded image (image/jpeg for JPG files, image/gif for GIF files, and so on); the MIME type specifies to the browser how to render the binary data. The Image column holds the actual binary contents of the picture.

<asp:Label ID="Label1" runat="server" Text="Upload Image"asp:Label>
:Label ID="Label2" runat="server" Text="Title">asp:Label>
<asp:TextBox ID="TextBox1" runat="server">asp:TextBox>
<asp:Label ID="Label3" runat="server" Text="Image">asp:Label>
<asp:FileUpload ID="FileUpload1" runat="server" />
<asp:Button ID="Button1" runat="server" Text="Upload"/>

Uploading Images

As shown above, we are using Fileupload control to browse picture files on hard disk. FileUpload control is a composite control which includes a textbox and browse button together. To add this control, simply drag and drop FileUpload control from Toolbox as shown below.

File upload control on toolbox

Once user selects appropriate picture file using FileUpload control, click upload button which inserts selected image into PictureTable as new record. The logic to insert the image into PictureTable is handled in Click event of Upload button as shown below.

Protected Sub Upload_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Upload.Click
Dim fileUpload1 As FileUpload = CType(Me.FindControl("fileUpload1"), FileUpload)
'Make sure a file has been successfully uploaded
If fileUpload1.PostedFile Is Nothing OrElse String.IsNullOrEmpty(fileUpload1.PostedFile.FileName) OrElse fileUpload1.PostedFile.InputStream Is Nothing Then
Label1.Text = "Please Upload Valid picture file"
Exit Sub
End If
'Make sure we are dealing with a JPG or GIF file
Dim extension As String = System.IO.Path.GetExtension(fileUpload1.PostedFile.FileName).ToLower()
Dim MIMEType As String = Nothing
Select Case extension
Case ".gif"
MIMEType = "image/gif"
Case ".jpg", ".jpeg", ".jpe"
MIMEType = "image/jpeg"
Case ".png"
MIMEType = "image/png"
Case Else
'Invalid file type uploaded
Label1.Text = "Not a Valid file format"
Exit Sub
End Select
'Connect to the database and insert a new record into Products
Using myConnection As New SqlConnection(ConfigurationManager.ConnectionStrings("ImageGalleryConnectionString").ConnectionString)
Const SQL As String = "INSERT INTO [Pictures] ([Title], [MIMEType], [Image]) VALUES (@Title, @MIMEType, @ImageData)"
Dim myCommand As New SqlCommand(SQL, myConnection)
myCommand.Parameters.AddWithValue("@Title", TextBox1.Text.Trim())
myCommand.Parameters.AddWithValue("@MIMEType", MIMEType)
'Load FileUpload's InputStream into Byte array
Dim imageBytes(fileUpload1.PostedFile.InputStream.Length) As Byte
fileUpload1.PostedFile.InputStream.Read(imageBytes, 0, imageBytes.Length)
myCommand.Parameters.AddWithValue("@ImageData", imageBytes)
myConnection.Open()
myCommand.ExecuteNonQuery()
myConnection.Close()
End Using
End Sub

Once the user has selected a file and posted back the form by clicking the "Upload" button, the binary contents of the specified file are posted back to the web server. From the server-side code, this binary data is available through the FileUpload control's PostedFile.InputStream property.

This event handler starts off by ensuring that a file has been uploaded. It then determines the MIME type based on the file extension of the uploaded file. You can observe how @ImageData parameter is set. First, a byte array named imageBytes is created and sized to the Length of the InputStream of the uploaded file. Next, this byte array is filled with the binary contents from the InputStream using the Read method. It's this byte array that is specified as the @ImageData's value.

Displaying binary Data

Regardless of what technique you employ to store the data in the database, in order to retrieve and display the binary data we need to create a new ASP.NET page for this task. This page, named DisplayPicture.aspx, will be passed ImageID through the Querystring parameter and return the binary data from the specified product's Image field. Once completed, the particular picture can be viewed by browsing the link to view uploaded images. For example
http://localhost:3219/BinaryDataVb/Displaypicture.aspx?ImageID=5.

Therefore, to display an image on a web page, we can use an Image control whose ImageUrl property is set to the appropriate URL.

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
Dim ImageID As Integer = Convert.ToInt32(Request.QueryString("ImageID"))

'Connect to the database and bring back the image contents & MIME type for the specified picture
Using myConnection As New SqlConnection(ConfigurationManager.ConnectionStrings("NorthwindConnection").ConnectionString)
Publish Post
Const SQL As String = "SELECT [MIMEType], [Image] FROM [PictureTable] WHERE [ImageID] = @ImageID"
Dim myCommand As New SqlCommand(SQL, myConnection)
myCommand.Parameters.AddWithValue("@ImageID", ImageID)

myConnection.Open()
Dim myReader As SqlDataReader = myCommand.ExecuteReader

If myReader.Read Then
Response.ContentType = myReader("MIMEType").ToString()
Response.BinaryWrite(myReader("Image"))
End If

myReader.Close()
myConnection.Close()
End Using

End Sub
Code listing for DisplayPicture.aspx

Displaying picture using QueryString parameter

The DisplayPicture.aspx does not include any HTML markup in the .aspx page. In the code-behind class's Page_Load event handler, the specified Pictures row's MIMEType and Image are retrieved from the database using ADO.NET code. Next, the page's ContentType is set to the value of the MIMEType field and the binary data is emitted using Response.BinaryWrite(Image): When DisplayPicture.aspx page complete, the image can be viewed by either directly visiting the URL.

On the same way, we could call .zip, .pdf or any other binary file, stored in database system. If you want to get .zip file from database, you don't need to use Image control. Instead of using src parameter of Image control, for .zip and .pdf files use href parameter of hyperlink tag (e.g. Get great zip file )

SQL Server Transact-SQL General Tips Part III

noreply@blogger.com (Octopus) — Fri, 21 Sep 2007 07:00:00 +0000

By : Brad McGehee

When using the WHILE statement, don't avoid the use of BREAK just because some people consider it bad programming form. Often when creating Transact-SQL code using the WHILE statement, you can avoid using BREAK by moving a few lines of code around. If this works in your case, then by all means don't use BREAK. But if your efforts to avoid using BREAK require you to add additional lines of code that makes your code run slower, then don't do that. Sometimes, using BREAK can speed up the execution of your WHILE statements. [6.5, 7.0, 2000, 2005] Updated 6-12-2006

*****

One of the advantages of using SQL Server for n-tier applications is that you can offload much (if not most) of the data processing work from the other tiers and place it on SQL Server. The more work you can perform within SQL Server, the fewer the network roundtrips that need to be made between the various tiers and SQL Server. And generally the fewer the network roundtrips, the more scalable and faster the application becomes.

But in some applications, such as those than involve complex math, SQL Server has traditionally been weak. In these cases, complex math often could not be performed within SQL Server, instead it had to be performed on another tier, causing more network roundtrips than desired.

By using user-defined functions (UDFs), this is becoming less of a problem. UDFs allow developers to perform many complex math functions from within SQL Server, functions that previously could only be performed outside of SQL Server. By taking advantage of UDFs, more work can stay with SQL Server instead of being shuttled to another tier, reducing network roundtrips, and potentially boosting your application's performance.

Obviously, boosting your application's performance is not as simple as moving math functions to SQL Server, but it is one feature of SQL Server 2000/2005 that developers can take advantage of in order to boost their application's scalability and performance. [2000, 2005] Updated 6-12-2006

*****

SQL Server 2000/2005 offers a data type called "table." Its main purpose is for the temporary storage of a set of rows. A variable, of type "table," behaves as if it is a local variable. And like local variables, it has a limited scope, which is within the batch, function, or stored procedure in which it was declared. In most cases, a table variable can be used like a normal table. SELECTs, INSERTs, UPDATEs, and DELETEs can all be made against a table variable.

For better performance, if you need a temporary table in your Transact-SQL code, consider using a table variable instead of creating a conventional temporary table. Table variables are often faster, but not always. In addition, table variables found in stored procedures result in fewer compilations (than when using temporary tables), and transactions using table variables only last as long as the duration of an update on the table variable, requiring less locking and logging resources. [2000, 2005] Updated 10-02-2006

*****

Don't repeatedly reuse the same function to calculate the same result over and over within your Transact-SQL code. For example, if you need to reuse the value of the length of a string over and over within your code, perform the LEN function once on the string, and this assign the result to a variable, and then use this variable, over and over, as needed in your code. Don't recalculate the same value over and over again by reusing the LEN function each time you need the value, as it wastes SQL Server resources and hurts performance. [6.5, 7.0, 2000, 2005] Updated 10-02-2006

*****

Many developers choose to use an identify column at their primary key. By design, an identity column does not guarantee that that each newly created row will be consecutively numbered. This means there will most likely be occasional gaps in the identity column numbering scheme. For most applications, occasional gaps in the identity column present no problems.

On the other hand, some developers don't like these occasional gaps, trying to avoid them. With some clever use of INSTEAD OF triggers in SQL Server 2000,2005, it is possible prevent these numbering gaps. But at what cost?

The problem with trying to force an identify column to number consecutively without gaps can lead to locking and scalability problems, hurting performance. So the recommendation is not to try to get around the identify column's built-in method of working. If you do, expect performance problems. [2000, 2005] Updated 10-02-2006

*****

If you use the BULK INSERT to import data into SQL Server, seriously consider using the TABLOCK hint along with it. This will prevent SQL Server from running out of locks during vary large imports, and also boost performance due to the reduction of lock contention. [7.0, 2000, 2005] Added 11-22-2004

*****

To help identify long running queries, use the SQL Server Profiler Create Trace Wizard to run the "TSQL By Duration" trace. You can specify the length of the long running queries you are trying to identify (such as over 1000 milliseconds), and then have these recorded in a log for you to investigate later. [7.0]

SQL Server Transact-SQL General Tips Part II

noreply@blogger.com (Octopus) — Fri, 21 Sep 2007 06:59:00 +0000

By : Brad McGehee

Instead of using temporary tables, consider using a derived table instead. A derived table is the result of using a SELECT statement in the FROM clause of an existing SELECT statement. By using derived tables instead of temporary tables, you can reduce I/O and often boost your application's performance. [7.0, 2000, 2005] Updated 6-12-2006

*****

Sometimes, it is handy to be able to perform some calculation on one or more columns of a record, and then take the result of that calculation and then add it to similar calculations performed on other related records to find a grand total.

For example, let's say you want to find the total dollar cost of an invoice. An invoice will generally involve a header record and one or more detail records. Each detail record will represent a line item on the invoice. In order to calculate the total dollar cost of an invoice, based on two or more line items, you would need to multiply the quantity of each item sold times the price of each item. Then, you would need to add the total price of each line item together in order to get the total dollar cost of the entire invoice. To keep this example simple, let's ignore things like discounts, taxes, shipping, etc.

One way to accomplish this task would be to use a cursor; like we see below (we are using the Northwind database for this example code):

DECLARE @LineTotal money --Declare variables
DECLARE @InvoiceTotal money
SET @LineTotal = 0 --Set variables to 0
SET @InvoiceTotal = 0

DECLARE Line_Item_Cursor CURSOR FOR --Declare the cursor

SELECT UnitPrice*Quantity --Multiply unit price times quantity ordered
FROM [order details]
WHERE orderid = 10248 --We are only concerned with invoice 10248

OPEN Line_Item_Cursor --Open the cursor
FETCH NEXT FROM Line_Item_Cursor INTO @LineTotal --Fetch next record
WHILE @@FETCH_STATUS = 0

BEGIN
SET @InvoiceTotal = @InvoiceTotal + @LineTotal --Summarize line items
FETCH NEXT FROM Line_Item_Cursor INTO @LineTotal
END

CLOSE Line_Item_Cursor --Close cursor
DEALLOCATE Line_Item_Cursor --Deallocate cursor
SELECT @InvoiceTotal InvoiceTotal --Display total value of invoice

The result for invoice number 10248 is $440.00.

What the cursor does is to select all of the line items for invoice number 10248, then multiply the quantity ordered times the price to get a line item total, and then it takes each of the line item totals for each record and then adds them all up in order to calculate the total dollar amount for the invoice.

This all works well, but the code is long and hard to read, and performance is not great because a cursor is used. Ideally, for best performance, we need to find another way to accomplish the same goal as above, but without using a cursor.

Instead of using a cursor, let's rewrite the above code using set-based Transact-SQL instead of a cursor. Here's what the code looks like:

DECLARE @InvoiceTotal money
SELECT @InvoiceTotal = sum(UnitPrice*Quantity)
FROM [order details]
WHERE orderid = 10248
SELECT @InvoiceTotal InvoiceTotal

The result for invoice number 10248 is $440.00.

Right away, it is obvious that this is a lot less code and that is it more readable. What may not be obvious is that it uses less server resources and performs faster. In our example--with few rows--the time difference is very small, but if many rows are involved, the time difference between the techniques can be substantial.

The secret here is to use the Transact-SQL "sum" function to summarize the line item totals for you, instead of relying on a cursor. You can use this same technique to help reduce your dependency on using resource-hogging cursors in much of your Transact-SQL code. [6.5, 7.0, 2000, 2005] Updated 6-12-2006

*****

While views are often convenient to use, especially for restricting users from seeing data they should not see, they aren't always good for performance. So if database performance is your goal, avoid using views (SQL Server 2000/2005 Indexed Views are another story).

When the Query Optimizer gets a request to run a view, it runs it just as if you had run the view's SELECT statement from the Query Analyzer or Management Studio. If fact, a view runs slightly slower than the same SELECT statement run from the Query Analyzer or Management Studio--but you probably would not notice the small difference--as it is small in simple examples like this.

Another issue with views is that they are often combined (nested) with other code, such as being embedded within another view, a stored procedure, or other T-SQL script. Doing so often makes it more difficult to identify potential performance issues.

Views don't allow you to add more restrictive WHERE clauses as needed. In other words, they can't accept input parameters, which are often needed to restrict the amount of records returned. I have seen lazy developers write generic views that return hundreds of thousands of unnecessary rows, and then user other code, such as client code, to filter only those few records that are needed. This is a great waste of SQL Server's resources.

Instead of embedding SELECT statements in a view, put them in a stored procedure for optimum performance. Not only do you get an added performance boost (in many cases), you can also use the stored procedure to restrict user access to table columns, just as you can with views. [6.5, 7.0, 2000, 2005] Updated 6-12-2006

SQL Server Transact-SQL General Tips Part I

noreply@blogger.com (Octopus) — Fri, 21 Sep 2007 06:57:00 +0000

By : Brad McGehee

Don't include code, variable, or parameters that don't do anything. This may sound obvious, but I have seen this in some off-the-shelf SQL Server-based applications. For example, you may see code like this:

SELECT column_name FROM table_name
WHERE 1 = 0

When this query is run, no rows will be returned. Obviously, this is a simple example (and most of the cases where I have seen this done have been very long queries). A query like this (even if part of a larger query) doesn't perform anything useful, and doesn't need to be run. It is just wasting SQL Server resources. In addition, I have seen more than one case where such dead code actually causes SQL Server to throw errors, preventing the code from even running. [6.5, 7.0, 2000, 2000, 2005] Updated 1-24-2006

*****

Don't be afraid to make liberal use of in-line and block comments in your Transact-SQL code, they will not affect the performance of your application, and they will enhance your productivity when you have to come back to the code and try to modify it. [6.5, 7.0, 2000, 2005] Updated 1-24-2006

*****

If possible, avoid using SQL Server cursors. They generally use a lot of SQL Server resources and reduce the performance and scalability of your applications. If you need to perform row-by-row operations, try to find another method to perform the task. Some options are to perform the task at the client, use tempdb tables, use derived tables, use a correlated subquery, or use the CASE statement. More often than not, there are non-cursor techniques that can be used to perform the same tasks as a SQL Server cursor. [6.5, 7.0, 2000, 2005] Updated 1-24-2006

*****

If your users perform many ad hoc queries on your SQL Server data, and you find that many of these "poorly-written" queries take up an excessive amount of SQL Server resources, consider using the "query governor cost limit" configuration option to limit how long a query can run.

This option allows you to specify the maximum amount of "seconds" a query will run, and whenever the query optimizer determines that a particular query will exceed the maximum limit, the query will be aborted before it even begins.

Although the value you set for this setting is stated as "seconds," it does not mean seconds like we think of seconds. Instead, it relates to the actual estimated cost of the query as calculated by the query optimizer. You may have to experiment with this value until you find one that meets your needs.

There are two ways to set this option. First, you can change it at the server level (all queries running on the server are affected by it) using sp_configure "query governor cost limit," or you can set it at the connection level (only this connection is affected) by using the SET QUERY_GOVERNOR_COST_LIMIT command. [7.0, 2000, 2005] Updated 1-24-2006

*****

You may have heard of a SET command called SET ROWCOUNT. Like the TOP operator, it is designed to limit how many rows are returned from a SELECT statement. In effect, the SET ROWCOUNT and the TOP operator perform the same function.

While in most cases, using either option works equally efficiently, there are some instances (such as rows returned from an unsorted heap) where the TOP operator is more efficient than using SET ROWCOUNT. Because of this, using the TOP operator is preferable to using SET ROWCOUNT to limit the number of rows returned by a query. [6.5, 7.0, 2000, 2005] Updated 1-24-2006

*****

If you have the choice of using a join or a subquery to perform the same task within a query, generally the join is faster. But this is not always the case, and you may want to test the query using both methods to determine which is faster for your particular application. [6.5, 7.0, 2000, 2005] Updated 1-24-2006

*****

If you need to create a primary key (using a value meaningless to the record, other than providing a unique value for a record), many developers will use either an identity column (with an integer data type) or an uniqueindentifier data type.

If your application can use either option, then you will most likely want to choose the identity column over the uniqueindentifier column.

The reason for this is that the identity column (using the integer data type) only takes up 4 bytes, while the uniqueindentifier column takes 16 bytes. Using an identifier column will create a smaller and faster index. [7.0, 2000, 2005] Updated 1-24-2006

*****

If your application requires you to create temporary tables for use on a global or per connection use, consider the possibility of creating indexes for these temporary tables. While most temporary tables probably won't need, or even use an index, some larger temporary tables can benefit from them. A properly designed index on a temporary table can be as great a benefit as a properly designed index on a standard database table.

In order to determine if indexes will help the performance of your applications using temporary tables, you will probably have to perform some testing. [6.5, 7.0, 2000, 2005] Updated 1-24-2006

*****

Suppose you have data in your table that represents the logical information of "Yes" and "No" and you want to give the results of a query to someone who isn't working all day with computers. For such people, they may not know that a 1 is the logical representation of TRUE while a 0 represents FALSE. Sure, you can do this at the presentational layer. But what if someone comes to your desk, begging for immediate help? Here's a little trick to make BITs (or any other 0 and 1 data) look a bit more intuitive:

CREATE TABLE MyBits

id INT IDENTITY(1,1) PRIMARY KEY

, bool BIT

GO

INSERT INTO MyBits

SELECT 0

UNION ALL

SELECT 1

GO

SELECT

id

, bool

, SUBSTRING('YesNo', 4 - 3 * bool, 3) as YesNo

FROM

MyBits

GO

DROP TABLE MyBits

id          bool YesNo

----------- ---- -----

1           0    No

2           1    Yes

(2 row(s) affected)

How does this work? The trick happens inside the SUBSTRING function. Precisely, when calculating the start value for the SUBSTRING. If our column "bool" contains a 0, the calculation looks like SUBSTRING('YesNo', 4 - 3 * 0, 3), which resolves to SUBSTRING('YesNo', 4, 3) and therefore, correctly returns 'No'. We actually use here another feature of SUBSTRING. If the string is shorter than our requested length, SUBSTRING simply returns the shorter string without filling up the missing spaces. Finally, in case a 1 is in our "bool" column, the calculation goes like SUBSTRING('YesNo', 4 - 3 * 1, 4), which is SUBSTRING('YesNo, 1, 3) and that is 'Yes'. [7.0, 2000, 2005] Added 5-9-2005

Fedora Core 6 Tips and Tricks (v1.3)

noreply@blogger.com (Octopus) — Thu, 20 Sep 2007 07:17:00 +0000

This is based on my Fedora Core 5 Tips and Tricks page. This is in maintenance only mode since there is now a Fedora 7 version of this guide in the works. Recent changes are highlighted in yellow.

I've started to add x86_64 specific instructions below when they differ from traditional 32-bit instructions. The biggest issue is with multimedia plug-ins which are still often available only in 32-bit versions.

Fix i586/i686 Kernel issue

Under some circumstances the Fedora Core 6 installer (called Anaconda) will mistakenly install the i586 version of the Kernel rather than the more appropriate i686 version for Pentium 4 and newer 32-bit processors. This is not a problem on x86_64 and non-Intel/AMD processors.

To find out if your system has this problem type the following command:

$ rpm -qa --queryformat "%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n"|grep kernel|sort

If you have a Pentium 4 or newer processor and the kernel version ends in i586 then your system and affected and needs to be updated to function at it's best. There are many ways described to do this on various forums but by far the easiest is the Kernel Fix Script on the Bugs/FC6Common site:

Fedora Core 6 - Common Bugs and Known Issues

Script down and find the script. Download it to your hard drive and run it as root:

# mkdir /tmp/kernel-fix
# cd /tmp/kernel-fix
# sh kernel-fix.sh

Then just follow the prompts and it will update your installed kernel. Using kernel-fix.sh sould be with care as it runs all the *.rpm at current directory (see line 32).

Add support for other repositories

Fedora core 6 has one major problem where on some systems it installs the i586 version of the kernel instead of i686. What this means is that those systems will be a little slower and will lack CPU frequency scaling. If you are running an i686 based system you can force the installation of the correct kernel by booting the installer with the following command:

linux i686

Fedora comes with a ton of software but there are still plenty of packages of interest to most users that are not included for a variety of reasons. This is where you find the MP3 plug-in and a ton of other packages.

These instructions can vary depending on 32bit or 64bit architecture. If there is a difference it will be noted. If you don't know which architecture you're running you can run the following command:

$ uname -m
x86_64
...or...
i686

I'm still working on the 64 bit specific instructions so your feedback is very important.

Before you add repositories it's probably a good idea to make sure your system is fully updated first. It's still early but right now the Livna and freshrpms repositories seems to be the most useful. The easiest way to get started is to install the freshrpms-release packages:

Both 32 and 64 bits:
# rpm -ihv http://ayo.freshrpms.net/fedora/linux/6/i386/RPMS.freshrpms/freshrpms-release-1.1-1.fc.noarch.rpm
32 bit version:
# rpm -ihv http://rpm.livna.org/fedora/6/i386/livna-release-6-1.noarch.rpm
64 bit version:
# rpm -ihv http://rpm.livna.org/fedora/6/x86_64/livna-release-6-1.noarch.rpm

To automatically install/update the Macromedia Flash version 9.0 plug-in copy This File to your /etc/yum.repos.d directory. You can browse the packages available there at http://rpm.livna.org/fedora/6/i386/ and http://zod.freshrpms.net/.

Install MP3 Plug-in

Since you've been following along this next step is about as easy as it gets. Just use yum to automatically install the MP3 plug-ins for xmms and Rhythmbox like this:

# yum -y install xmms xmms-mp3 xmms-faad2 gstreamer-plugins-ugly libmad libid3tag

While you're here you might as well install my personal favorite (this week at least) music player Banshee:

# yum -y install banshee

The -y flag is to automatically answer yes to any question. If you want to be able to say no you can ignore that flag.

While you're there I highly recommend the grip CD ripper which supports both MP3 and Ogg formats. Once again installation is quite simple:

# yum -y install grip

Install Macromedia Flash/Shockwave plug-in

Flash Plug-in 9.0
If you set up the repositories correctly above you should just need to do this to install the Flash plug-in version 9.0:

# yum -y install flash-plugin

You can get more information about this plug-in at http://macromedia.mplug.org/. Before the plug-in gets installed you'll need to agree to the terms of the license.

Special 64-bit instructions:
Now the problem with 64 bit, even on Windows, is that most plug-ins are still for some reason only available in a 32 bit version. This is a problem because a 64 bit version of Firefox can only use 64 bit plugins. There are several ways to solve this but by far the easiest is to just force the use of the 32-bit Firebox. Both versions are installed by default, you just need to make a little change to make sure only the 32-bit version gets run.

As of firefox-1.5.0.10-5.fc6 the method of selecting the 32-bit version has been simplified. Now you simply create a file called /etc/sysconfig/firefox-arch containing the following lines:

MOZ_LIB_DIR="/usr/lib"
SECONDARY_LIB_DIR="/usr/lib64"

The remainder of these instructions are only for people who have not updated lately and still have an older version of Firefox. These instructions will go away soon:

Edit the file /usr/bin/firefox as root and go down to about line 40 and comment out the following code:

# Force 32 bit version
#if [ -x "/usr/lib64/firefox-1.5.0.8/firefox-bin" ]
#then
#  MOZ_LIB_DIR="/usr/lib64"
#fi

Then when you restart Firefox you'll be running the 32 bit version and the plug-ins you installed above will work just fine.

Install DVD player

Currently I find the DVD player that works best is the Xine Multimedia Player which is found in the Livna repository so installing it is just this simple:

# yum -y install xine xine-lib xine-skins xine-lib-extras-nonfree libdvdcss

This will install the xine DVD/VCD/CD player. Now to get xine to automatically play a DVD upon insertion instead of the Totem player which can't actually play DVDs, you can simply use the gconftool-2 utility as follows:

$ gconftool-2 --set /desktop/gnome/volume_manager/autoplay_dvd_command \
 'xine --auto-play --auto-scan dvd' --type='string'

Install MPlayer Media Player

At some point you're probably going to want to play a QuickTime, AVI or ASF file so you'll want the MPlayer media player. Fortunately with the FreshRpms repositories it's also very easy to download and install. Once again there are conflicts between the Livna and FreshRpms repositories and you'll have to disable one of them.

To prevent potential problems of updates in the Livna repository from messing up the mplayer and mencoder packages add the following line highligted in bold to the file /etc/yum.repos.d/livna.repo :

gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-livna
exclude=mplayer* mencoder* ffmpeg*

[livna-debuginfo]

Then you can go ahead and install mplayer and all it's dependencies:

# yum -y install mplayer mplayer-skins mplayer-fonts mplayerplug-in

This command line will download the whole kit and kaboodle. that if you want to play content from a command line that you use the gmplayer version which will include a skin-able control panel. This will install the plug-in to play a wide variety of media within your browser window. Restart your web browser after that whole mess is done installing and you'll also have a plug-in for Mozilla so you can play embedded content. While you're at it be sure to configure mplayer to use the ALSA sound system rather than the default. It just works better. Edit the file ~/.mplayer/config and add the following line:

ao=alsa

Special 64-bit instructions:
This installs the 64-bit version of everything but because your other plug-ins are 32-bits you need to run the 32-bit version of Firefox, which won't be able to use the 64-bit version of the plug-in you just installed. The plug-in can use the 64-bit version of the mplayer application just fine so all you need to do then is to install the 32-bit mplayerplug-in plus a dependency it requires. If you know of any easier way to do this please let me know below.

# rpm -ihv http://ftp.ndlug.nd.edu/pub/fedora/linux/core/6/i386/os/Fedora/RPMS/libXpm-3.5.5-3.i386.rpm
# rpm -ihv http://ftp.freshrpms.net/pub/freshrpms/fedora/linux/6/mplayerplug-in/mplayerplug-in-3.31-2.fc6.i386.rpm

And finally you'll probably also want some additional codecs to play all that proprietary video that seems to have infected the Internet. Go to the MPlayer Download page and download the essential Binaries Codec Package. You'll need to install those files in /usr/local/lib/win32. Here are the steps. Remember the exact file names may change at some point.

# gtar xjvf essential-20061022.tar.bz2
# mkdir /usr/local/lib/win32
# mv essential-20061022/* /usr/local/lib/win32

Install VLC (VideoLAN Client)

Multimedia can be the achilles heel of Linux, but with just a little work you should be able to play just about anything your friends can. Besides Mplayer the other great video player is called VLC. It too is trivially easy to install once you have your repositories set up:

# yum -y install videolan-client

Once the client and a zillion dependencies get installed you can play a huge variety of video formats easy with the command vlc

Install RealPlayer 10 Media Player

If you have a better way of installing a Real Medial player please let me know if in the comments section below. Thanks to Chandra Shekhar for this great tip for making RealPlayer actually use ALSA instead of OSS. I've incorporated the changes into the guide below but here is a link to the original document.

http://docs.google.com/View?docid=ddt5bn9t_4c9238p

Before you install the play you'll need to make sure the compat-libstdc++-33 module is installed. Download the RealPlayer10 package from the following location:

RealPlayer10GOLD.rpm

First install the dependencies.

32 bit version
# yum -y install compat-libstdc++-33 alsa-oss
64 bit version  There really MUST be an easier way!
# rpm -ihv ftp://fedora.cat.pdx.edu/linux/extras/6/i386/alsa-oss-1.0.12-3.fc6.i386.rpm

Then install the RPM:

# rpm -ihv RealPlayer10GOLD.rpm

The other thing you'll need to do is prevent the mplayerplug-in you installed above from trying to handle Real Media. I don't know why it's included because it almost never works correctly. The easiest way to disable it is to remove the appropriate plugin files:

# cd /usr/lib/mozilla/plugins
# rm mplayerplug-in-rm.so

Then whenever you want to view something just use /usr/bin/realplay . Here is a link to a cute test video to make sure it's working for you.

If audio is working but you have a black screen then it's possible your video card doesn't support XVideo. You can turn it off by clicking on Tools -> Preferences then choose the Hardware tab and disable Use XVideo .

If the video doesn't play properly the first thing to check is to make sure you're not running SElinux, it seems to prevent the RealPlayer from getting access to the drivers. I currently run with SElinux disabled but I recommend you run it in the Targeted mode rather than the most secure mode.

Now a bit of a tricky part. You'll need to edit the executable /usr/bin/realplay as root and locate the section below around line 56. Then add the code that's highlighted and save the file back.

 .
 .
   export HELIX_LIBS
fi

LD_PRELOAD="$LDPRELOAD:/usr/lib/libaoss.so.0.0.0"
export LD_PRELOAD
  
# See if LD_PRELOAD contains any of the sound server libs. If so, remove them.
LD_PRELOAD=`echo $LD_PRELOAD | sed -e 's/\([^:]*libesd[^:]*\|[^:]*libarts[^:]*\):\?//g'`
 .
 .

After you've run it the first time and gone through the configuration screens edit the ~/.realplayerrc file and add the following line in the [helix] section of the configuration:

[helix]
SoundDriver=2
       .
       .

For some reason on my system RealPlayer uses the the old and virtually obsolete OSS sound driver. The line above tells it to use the newer ALSA sound driver instead.

Install Java J2RE and Mozilla Plug-in

It's also very handy to have the Java run-time environment available and most importantly a Mozilla plug-in so you can view dynamic content. It's unfortunate that Mozilla will actually crash if you go to a site containing Java and you don't have the plug-in installed.

For now there is no easy way to do this but I found the following instructions on FedoraForums.org. Basically, start by downloading the Java Runtime Environment (JRE) 5.0 Update 9 (at the time I wrote this) from Sun.com. You'll want to grab the Linux RPM in self-extracting file. Then you want to install it with:

# sh ./jre-1_5_0_09-linux-i586-rpm.bin

Then you'll probably want to enable Java Plug-ins and here once again there is no easy way:

# ln -s /usr/java/jre1.5.0_09/plugin/i386/ns7/libjavaplugin_oji.so /usr/lib/mozilla/plugins

And finally you'll need to tell Fedora that you wish to use this version of Java as the preferred interpreter rather than the Open Source version that's installed by default. You'll of course need to adjust the full pathname if you install a newer version of the jre than the one in this example:

# /usr/sbin/alternatives --install /usr/bin/java java /usr/java/jre1.5.0_09/bin/java 1509
# java -version
java version "1.5.0_09"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_09-b05)
Java HotSpot(TM) Client VM (build 1.5.0_09-b05, mixed mode, sharing)

If you know of an easier way please post it to the Comments section below.

Install NTFS driver

With repositories like Fedora Extras it's now very easy to add NTFS support to Fedora:

# yum -y install ntfs-3g

Then you can simply mount NTFS file systems using the option -t ntfs-3g. You can find more detailed information about this driver at http://www.ntfs-3g.org/

Install Internet Explorer

I know what you're saying, why would I ever want Internet Explorer installed on my perfectly good Linux system? If you don't have your own answer to that question, feel free to just skip this section. For everyone else, it's actually quite easy thanks to some very handy scripts from IEs4Linux. Before you start you'll need to make sure you have wine and cabextract installed:

# yum -y install wine cabextract

Then just download the latest script, extract and run it. The example below is based on version 2.0.5, just adjust the version number as necessary. Please note that you will want to install and run this as your own user, NOT as root. I used the defaults except that I installed all the versions of IE. I do some web development and I always find myself needing to resolve some goofy incompatibilites with older versions of IE.

$ gtar xzvf ies4linux-2.0.5.tar.gz
$ cd ies4linux-2.0.5
$ ./ies4linux
Welcome, greg! I'm IEs4Linux.
I can install IE 6, 5.5 and 5.0 for you easily and quickly.
You are just four 'enter's away from your IEs.

I'll ask you some questions now. Just answer y or n (default answer is the bold one)

IE 6 will be installed automatically.
Do you want to install IE 5.5 SP2 too? [ y / n ] y
 .
 .
 .
IEs 4 Linux installations finished!

To run your IEs, type:
ie6
ie55
ie5

You can read more about this feature on my Internet Explorer with ActiveX on Linux page. It goes into a little more detail about using IE on Linux.

Install Other Odds and Ends

Add MS TrueType Fonts (TTF)

Many people will find it handy to have MS TrueType fonts available to make sure many websites render correctly. You can download the latest RPM from http://www.mjmwired.net/resources/mjm-fedora-fc5.html#ttf and install it as follows:

#  wget --referer=http://www.mjmwired.net/resources/mjm-fedora-fc6.html \
   http://www.mjmwired.net/resources/files/msttcorefonts-2.0-1.noarch.rpm
# rpm -ihv msttcorefonts-2.0-1.noarch.rpm
# service xfs restart

Turn off the ANNOYING Spatial Nautilus Behavior

I don't know if it's the worst feature of Fedora but it's definitely in the top 5. You can get the old more sane behavior by bringing up nautilus then choose Edit -> Preferences then select the Behavior tab. Near the top find the option for Always open in browser windows and make sure it is checked.

Other Handy Utilities

Here are a few other tools that aren't installed by default but a lot of people find handy:

# yum -y install bittorrent-gui gnomebaker testdisk thunderbird \
 audacity-nonfree screen cups-pdf

audacity-nonfree - A version of the excellent Audacity sound editor which includes MP3 support bittorrent-gui - Simple Gnome based BitTorrent client
cups-pdf - Add-on to CUPS which creates a PDF Printer which you can use to print any document in PDF format. The file is written to your Desktop.
gnomebaker - GTK based CD/DVD burning utility
screen - If you do a lot with the command line you'll find screen invaluable
testdisk - Two command line utilities to recover lost partitions and undelete files on FAT filesystems. VERY handy for undeleting files on flash memory cards.
thunderbird - Excellent E-mail client that complements Firefox

Other Useful Resources

I've tried to not just copy other people's tips so I've included a list of other people's tips and tricks I've found to be useful. There should be little or no overlap. FedoraForum - Linux Support Community - This is now the official way to get community support of the Fedora Linux system. There is no official Red Hat mailing list for any version of Fedora any more.

Mauriat Miranda's FC6 Installation Guide - Great guide that goes into more depth of selecting options during the installation process. This is also the source of the MS fonts RPM.

Fedora Core 5 Linux Installation Notes - Another great Fedora installation guide. This guide goes into some server related features rather than just desktop features.

Using Linux and Bluetooth DUN on the Treo 650 - A very nice guide to using a Treo 650 phone as a modem with your Linux based PC. It works great for me with one change. Do NOT uncomment the line encrypt enable; as it just won't work for me with encryption enabled with a D-Link DBT-120 and a Treo 650 phone.

Fedora Multimedia Installation HOWTO - I discovered this great resource after I wrote this. This document goes into more detail than mine so it's a great resource.

The Unofficial Fedora FAQ - Another great guide that should answer most general questions about Fedora. Fedora Core 5 doesn't seem to be addressed there yet but most answers are the same for both FC4 and FC5.

This Fedora Core 6 Tips & Tricks translated into Italian - Thanks to Guido for translating this guide into Italian. Please contact me if you wish to translate this guide into other languages.

Fedora fc5 on EasyLinux.info - Yet another guide. The thing I love about Linux is that you can solve any problem a number of different ways. That includes these tips guides, everyone has a different way. Different strokes for different folks.

Tip/Trick: Optimizing ASP.NET 2.0 Web Project Build Performance with VS 2005

noreply@blogger.com (Octopus) — Wed, 19 Sep 2007 07:43:00 +0000

This posts covers how to best optimize the build performance with Visual Studio 2005 when using web projects. If you are experiencing slow builds or want to learn how to speed them up please read on.

Quick Background on VS 2005 Web Site Project and VS 2005 Web Application Project options

VS 2005 supports two project-model options: VS 2005 Web Site Projects and VS 2005 Web Application Projects.

VS 2005 Web Site Projects were built-in with the initial VS 2005 release, and provide a project-less based model for doing web development that uses that same dynamic compilation system that ASP.NET 2.0 uses at runtime. VS 2005 Web Application Projects were released as a fully supported download earlier this spring, and provide a project model that uses a MSBuild based build system that compiles all code in a project into a single assembly (similar to VS 2003 -- but without many of the limitations that VS 2003 web projects had with regard to FrontPage Server Extensions, IIS dependencies, and other issues). To learn more about VS 2005 Web Application Projects, please review the tutorials I've published on my http://webproject.scottgu.com web-site. Note that VS 2005 Web Application Project support will be included in VS 2005 SP1 (so no additional download will be required going forward).

Both the VS 2005 Web Site Project option and the VS 2005 Web Application Project option will continue to be fully supported going forward with future Visual Studio releases. What we've found is that some people love one option, while disliking the other, and vice-versa. From a feature perspective there is no "one best option" to use - it really depends on your personal preferences and team dynamics as to which will work best for you. For example: a lot of enterprise developers love the VS 2005 Web Application option because it provides a lot more build control and team integration support, while a lot of web developers love the VS 2005 Web Site model because of its "just hit save" dynamic model and flexibility.

Two articles you might find useful to decide which works best for you is this MSDN whitepaper that includes some comparisons between the two models, and Rick Strahl's Web Application Projects and Web Deployment Projects are Here article that provides a good discussion of the pros/cons of the different options.

To migrate from the VS 2005 Web Site Project model to the VS 2005 Web Application Project model, please follow this C# or VB tutorial that walks-through the steps for how to-do so.

So Which Project Option Builds Faster?

When doing full builds of projects, the VS 2005 Web Application Project option will compile projects much faster that the VS 2005 Web Site Project option. By "full build" I mean cases where every class and page in a project is being compiled and re-built - either because you selected a "Rebuild" option within your "build" menu, or because you modified code within a dependent class library project or in the /app_code directory and then hit "build" or "ctrl-shift-b" to compile the solution.

There are a few reasons why the VS 2005 Web Application Project ends up being significantly faster than Web Site Projects in these "full rebuild" scenarios. The main reason is that (like VS 2003), the VS 2005 Web Application Project option only compiles your page's code-behind code and other classes within your project. It does not analyze or compile the content/controls/in-line code within your .aspx pages -- which means it does not need to parse those files. On the downside this means that during compilation it will not check for errors in those files (unlike the VS 2005 Web Site Project option which will identify any errors there). On the positive side it makes compilations much faster.

So does this mean that you should always use the VS 2005 Web Application Project option to get the fastest build times with large projects? No -- not necessarily. One nice feature that you can enable with the VS 2005 Web Site Project option is support for doing "on demand compilation". This avoids you having to always re-build an entire project when dependent changes are made -- instead you can just re-build those pages you are working on and do it on-demand. This will lead to significant build performance improvements for your solution, and can give you a very nice workflow when working on very large projects. I would definitely recommend using this option if you want to improve your build performance, while retaining the flexibility of the web-site model.

The below sections provide specific tutorials for both the VS 2005 Web Site Project Model and the VS 2005 Web Application Project Model on optimization techniques -- including the "on demand compilation" build option I described above.

Specific Tips/Tricks for Optimizing VS 2005 Web Site Project Build Times

When using the VS 2005 Web Site Project model, you can significantly improve build performance times by following these steps:

1) Verify that you are not suffering from an issue I call "Dueling Assembly References". I describe how to both detect and fix this condition in this blog post. If you are ever doing a build and see the compilation appear to pause in the "Validating Web Site" phase of compilation (meaning no output occurs in the output window for more than a few seconds), then it is likely that you are running into this problem. Use the techniques outlined in this blog post to fix it.

2) Keep the number of files in your /app_code directory small. If you end up having a lot of class files within this directory, I'd recommend you instead add a separate class library project to your VS solution and move these classes within that instead since class library projects compile faster than compiling classes in the /app_code directory. This isn't usually an issue if you just have a small number of files in /app_code, but if you have lots of directories or dozens of files you will be able to get speed improvements by moving these files into a separate class library project and then reference that project from your web-site instead. One other thing to be aware of is that whenever you switch from source to design-view within the VS HTML designer, the designer causes the /app_code directory to be compiled before the designer surface loads. The reason for this is so that you can host controls defined within /app_code in the designer. If you don't have an /app_code directory, or only have a few files defined within it, the page designer will be able to load much quicker (since it doesn't need to perform a big compilation first).

3) Enable the on-demand compilation option for your web-site projects. To enable this, right-click on your web-site project and pull up the project properties page. Click the "Build" tab on the left to pull up its build settings. Within the "Build" tab settings page change the F5 Start Action from "Build Web Site" to either the "Build Page" or "No Build" option. Then make sure to uncheck the "Build Web site as part of solution" checkbox:

When you click ok to accept these changes you will be running in an on-demand compilation mode. What this means (when you select the "Build Page" option in the dialog above) is that when you edit a page and then hit F5 (run with debugging) or Ctrl-F5 (run without debugging) the solution will compile all of the class library projects like before, then compile the /app_code directory and Global.asax file, and then instead of re-verifying all pages within the web-site it will only verify the current page you are working on, and any user controls that the page references. With large (and even medium) projects with lots of pages, this can obviously lead to major performance wins. Note that ASP.NET will automatically re-compile any other page or control you access at runtime -- so you will always have an up-to-date and current running application (you don't need to worry about old code running). You can optionally also use the "No Build" option to by-pass page-level validation in the IDE, which obviously speeds up the entire process much further (I'd recommend giving both options a try to see which you prefer).

By deselecting the "Build Web site as part of solution" checkbox, you will find that the Ctrl-Shift-B keystroke (which builds the solution) will continue compiling all class library projects, but will not re-build all pages within your web-site project. You will still get full intellisense support in your pages in this scenario - so you won't lose any design-time support. You will also continue to get warning/error squiggles in code/class when they are open. If you want a way to force a re-build to occur on pages not open, or across all pages within the web-site, you can use the "Build Page" or "Build Web Site" menu options within the "Build" menu of Visual Studio:

This gives you control as to which pages on your site you want to verify (and when) - and can significantly improve build performance. One trick I recommend doing is adding a new shortcut keystroke to your environment to allow you to quickly short-cut the "Build Page" menu option to avoid you having to ever use a mouse/menu for this. You can do this by selecting the Tools->Customize menu item, and then click the "Keyboards" button on the bottom-left of the customize dialog. This will bring up a dialog box that allows you to select the VS Build.BuildPage command and associate it within any keystroke you want:

Once you do this, you can type "Ctrl-Shift-P" (or any other keystroke you set) on any page to cause VS to compile any modified class library project (effectively the same thing that Ctrl-Shift-B does), then verify all classes within the /app_code directory, and then re-build just the page or user control (and any referenced master pages or user controls it uses) that you are working on within the project.

Once the above steps are applied, you should find that your build performance and flexibility is much improved - and that you have complete control over builds happen.

Specific Tips/Tricks for Optimizing VS 2005 Web Application Project Build Times

If you are using the VS 2005 Web Application project option, here are a few optimizations you might want to consider:

1) If you have a very large project, or are working on an application with many other developers, you might want to consider splitting it up into multiple "sub-web" projects. I wouldn't necessarily recommend this for performance reasons (unless you have thousands and thousands of pages it probably doesn't make a huge difference), but it can sometimes make it easier to help manage a large project. Please read this past blog-post of mine on creating sub-web projects to learn how to use this.

2) Consider adding a VS 2005 Web Deployment project to your solution for deep verification. I mentioned above that one downside of using the VS 2005 Web Application Project option was that it only compiled the code-behind source code of your pages, and didn't do a deeper verification of the actual .aspx markup (so it will miss cases where you have a mis-typed tag in your .aspx markup). This provides the same level of verification support that VS 2003 provided (so you aren't loosing anything from that), but not as deep as the Web Site Project option. One way you can still get this level of verification with VS 2005 Web Application Projects is to optionally add a VS 2005 Web Deployment Project into your solution (web deployment projects work with both web-site and web-application solutions). You can configure this to run only when building "release" or "staging" builds of your solution (to avoid taking a build hit at development time), and use it to provide a deep verification of both your content and source code prior to shipping your app.

Common Tips/Tricks for Optimizing any VS 2005 Build Time

Here are a few things I recommend checking anytime you have poor performance when building projects/solutions (note: this list will continue to grow as I hear new ones - so check back in the future):

1) Watch out for Virus Checkers, Spy-Bots, and Search/Indexing Tools

VS hits the file-system a lot, and obviously needs to reparse any file within a project that has changed the next time it compiles. One issue I've seen reported several times are cases where virus scanners, spy-bot detecters, and/or desktop search indexing tools end up monitoring a directory containing a project a little too closely, and continually change the timestamps of these files (they don't alter the contents of the file - but they do change a last touched timestamp that VS also uses). This then causes a pattern of: you make a change, rebuild, and then in the background the virus/search tool goes in and re-searches/re-checks the file and marks it as altered - which then causes VS to have to re-build it again. Check for this if you are seeing build performance issues, and consider disabling the directories you are working on from being scanned by other programs. I've also seen reports of certain Spybot utilities causing extreme slowness with VS debugging - so you might want to verify that you aren't having issues with those either.

2) Turn off AutoToolboxPopulate in the Windows Forms Designer Options

There is an option in VS 2005 that will cause VS to automatically populate the toolbox with any controls you compile as part of your solution. This is a useful feature when developing controls since it updates them when you build, but I've seen a few reports from people who find that it can cause VS to end up taking a long time (almost like a hang) in some circumstances. Note that this applies both to Windows Forms and Web Projects. To disable this option, select the Tools->Options menu item, and then unselect the Windows Forms Designer/General/AutoToolboxPopulate checkbox option (for a thread on this see: http://forums.asp.net/1108115/ShowPost.aspx).

3) Examine which 3rd party packages are running in Visual Studio

There are a lot of great 3rd party VS packages that you can plug into Visual Studio. These deliver big productivity wins, and offer tons of features. Occasionally I've seen issues where performance or stability is being affected by them though. This is often true in cases where an older version (or beta) of one of these packages is being used (always keep an eye out for when a manufacturer updates them with bug-fixes). If you are seeing issues with performance or stability, you might want to look at trying a VS configuration where you uninstall any additional packages to see if this makes a difference. If so, you can work with the 3rd party manufacturer to identify the issue.

Visual Basic Build Performance HotFix

The Visual Basic team has released several hotfixes for compilation performance issues with large VB projects. You can learn how to obtain these hotfixes immediately from this blog post. The VB team also has a direct email address -- vbperf@microsoft.com -- that you can use to contact them directly if you are running into performance issues.

Hope this helps,

Scott
original link: http://weblogs.asp.net/scottgu/archive/2006/09/22/

Dependency injection in PHP5

noreply@blogger.com (Octopus) — Tue, 18 Sep 2007 01:54:00 +0000

Several months ago I started using Spring Framework . That is how I faced the dependency injection . As my programming skills mostly originated from web development with PHP, I found out that I've missed a great technique, which is as usually common in Java land, but rare in PHP. I ended up with a research of dependency injection libraries for PHP. There was a port of Pico container by Pawel Kozlowski, who gave a talk on it recently, and that was almost it (some bright minds from #php.thinktank had their own solutions for that).

However, all these solutions made you to define your dependencies within the code of your application, and were quite minimalistic. That made my mind - I started working on Garden - the dependency injection container for PHP5, which would use XML definitions with syntax as similar as possible to the Spring. Today Garden is packed up and ready for use. Here is a sample application context that injects a collar on a dog:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//GARDEN//DTD BEAN//EN" "garden-beans.dtd">

<beans default-lazy-init="true">

   <bean id="dog" class="Dog" file="ext/Dog.php">

     <property name="collar">

       <ref local="dogCollar"/>

     </property>

   </bean>

   <bean id="dogCollar" class="Collar" file="ext/Dog/Collar.php">

     <property name="spiked" value="true"/>

   </bean>

</beans>

The contents of Dog and Collar classes:

class Dog

{

     private $collar;

     public function setCollar($collar)

     {

         $this->collar = $collar;

     }

     public function getCollar()

     {

         return $this->collar;

     }

}

class Collar

{

     private $spiked;

     public function setSpiked($spiked)

     {

          $this->spiked = $spiked;

     }

     public function getSpiked()

     {

          return $this->spiked;

     }

}

And finally, a piece of code to access the beans:

require_once 'Garden.php';

Garden::initApplicationContext('example.xml');

$ctx = Garden::getApplicationContext();

$dog = $ctx->getBean('dog');

$collar1 = $dog->getCollar();

$collar2 = $ctx->getBean('dogCollar');

var_dump($dog, $collar1, $collar1 === $collar2);

The output of dump:

object(Dog)#1 (1) {

["collar:private"]=>

object(Collar)#2 (1) {

["spiked:private"]=>

bool(true)

}

}

object(Collar)#2 (1) {

["spiked:private"]=>

bool(true)

}

bool(true)

This example reveals only a basic setter injection, however the possibilities allow to use constructor argument injection, nested bean definitions, combined XML definition resources, aliasing, and literally almost all functionality found here . I hope this will be helpful for those of you who work on large scale, and trust that PHP applications can be scalable, easily maintainable and designed well. Make your applications blossom!