Most of the outlined problems and solutions are focused on testability, maintainability and other good code practices. If you are not familiar with them, I recommend read about them ASAP as there is big chance that you are doing those things described in this post and don’t even realize how wrong they are. Believe me, you will soon find yourself a way better developer.

Separate logic

This one is the most obvious one, but trust me, I have found cases of it in every single project I have worked before (more than 10 with Zend Framework in a past half year and counting). If it’s controller, don’t do business logic, if it’s model don’t base behavior on POST parameters etc. Same applies to forms, bootstrap, views, various helpers and many more other components – logic should be separate and have its place.

Move all logic from controller to a model or service. Use forms only to handle validation and filtering, not to actually process data and persist it in any fashion. Hide session and authentication handling in one place and provide API for other algorithms. I can go on, but I hope it’s starting to get pretty clear, or at least it will eventually when you start testing your code: when you need to setup frontController, request, cookie and mail server just to test a form you realize that something is really wrong.

Globals

If you haven’t seen this video, please do it immediately – you won’t regret it. Global state makes testing problematic and is completely opposite to what OOP proposes. This applies for use of $_SERVER, $_SESSION etc. values and all of them are accessible via request object (look at Zend_Controller_Request_Http) methods or separate classes, like Zend_Session.

Yet again I’m going to mention testability, because that’s something you always need to keep in mind. Test should not modify global variables, but rather inject mocked request/other objects which just return expected values (like client IP), because Zend Framework does pretty good job abstracting access to all global variables.

Use form values, not request

This one is both security and ease of coding issue, let’s look at this code sample:

$form = new Form();
 
if ($this->_request->isPost()) {
 
    if ($form->isValid($this->_request->getPost())
    {
        $model = new Model($this->_request->getPost());
        $model->save();
    }
    else
    {
        $form->populate($this->_request->getPost());
    }
}

After form is validated (and hence values are filtered), raw values from request are still used from $this->_request->getPost(). Not only do you lose Zend_Form functions like ignored elements (for submit buttons for example) but also none of the filters are applied (which you use, yes?). Also I can pass pretty much anything I want and model needs to do way more validation. Hence $form->getValues() should always be used as it returns form data with respect to all defined rules and filters.

Form populate() method is also very overused. This method is designed to set default values for a form, from for example GB entry (when editing something) apart from that, you simply don’t need to use it as method isValid() sets values for all elements, so there is no need to apply default values too.

Do not rely or use exit()/die()

One of the first things I do is remove all these exit() calls and handle such cases with exceptions or return statements. There is only very very limited amount of situations where you actually need to use one of those functions. Just for example, imagine this controller action code:

if (!$this->userHasPermissions())
{
    $this->_redirect('/');
}
 
$form = new Form_Add();
 
if (//submit form)
{
    // save with $form->getValues();
    $this->_redirect('/index');
    exit();
}
 
// do something else

First problem – thinking that $this->_redirect() will call exit() and hence nothing else will be executed. Even though this is true by default, this should be avoided in all cases. Not only it makes all post* events to not be fired, but also it makes testing impossible or incorrect. Zend_Test disables use of exit() in controller helpers, so in this case while testing you cannot test permissions checking as in all cases it will still execute later code. To fix this just add return in front of redirect (return $this->_redirect(‘/’)) and you are safe.

Furthermore, second exit() is completely useless and makes code even more untestable. Again you can just use return to cancel later code (view will not be rendered as viewRenderer helper checks for redirection header and does nothing if detects such). From my experience, after saving entry, there is only some assignments to view in left code so you won’t suffer a lot if you just leave redirect, of course without exit().

Use a framework, not PHP

This can sound wrong at first, but if you use a framework (Zend Framework in this case) don’t start throwing in hacks from 5 year old PHP apps. Like this (controller action):

$object = new Some_Object();
 
$image = $object->generateImage();
 
header ('Content-type: image/jpeg');
echo $image;

I don’t even know where to start… All this logic is incorporated in response object, so you can do things like:

$this->getResponse()->setHeader("Content-type", 'image/jpeg');
$this->getResponse()->setBody($image);

It might seem as same thing, but it’s not. Yet again you can actually test it, you are not working with global state (header() is global state function) and request dispatch process is left working as it should. Controllers do not output any data (hence no echo should be used) they just get request object and return response object, that’s it. In a similar fashion as exit() breaks dispatch process, outputting from controller does that too, so don’t forget to make sure that you preserve this flow.

Some small ones

Application.ini has a property includePaths, which is used to add additional paths to include path. Even though it works great, I still recommend not to use it because it will add those paths every time you create new application instance (true for 1.9, can change in future). If you try to do some controllers testing, you are probably going to instantiate it before every single test and after some hundreds of tests you will notice that somehow it’s getting slower and slower. That took me a few hours to find, though fix was easy, but still keep that in mind.

If you are using jQuery or any other javascript view helpers, take full power of them. By that I mean use functions like addJavascriptFile(), addJavascript(), addStylesheet(), addOnload() etc. to add some additional resources and code from views. If you add javascript straight to view everything will still work, but by using view helper container you will have all your code nicely placed in one place and not scattered all other the place.

Conclusion

This is just a small list of problems and issue I have seen in my work – there are way more to look at (you can share some tips too). I hope those will give you some idea how to work with Zend Framework in a clean fashion and you will soon find that your code is starting to look nicer and coding time is decreasing as everything is nicely separated and transparent to other code.

History

First time I have actually built an application with Zend Framework was about a half year ago, if I remember correctly version 1.8 was already around. Although my first applications were more than two years ago, but hey were more than tests and playing with at that time new features. So as I said above, not that long ago I switched most of my company’s code to use Zend Framework, contributed some code and have also started working as Zend Framework consultant (drop me an email if interested), so I think I have a pretty decent experience to judge it.

Before diving in to the analysis, I would like to clarify, that the reasons why I’m not using other frameworks are mainly caused by the fact that I didn’t had a chance to do that. Since I’m usually working with projects lasting more than 3 months, I need to be confident enough to know that after 2 months I don’t need to throw everything away and start from scratch. Also to test a framework for me is not to create a Hello World application, I need to build something serious to know what features are missing and what problems can be a big issue. Nevertheless, I’m planning to do some research sometime.

Advantages

For me the most important piece of software: how customizable it is. As you might have noticed from the posts like this, I usually work with complex web application and would like to have ability to built it from ground up. Zend Framework was perfect for this, because everything is just a collection of building blocks, literally (or loosely coupled in proper terms). I really liked that there is no default or even worse required structure and everything can be configured very easily.

Because I’m also in a position responsible for a whole project, quality for me is very important. I don’t know how other frameworks handle this, but Zend is pretty serious with what’s in framework and how the code is maintained. Starting from requirement to sign Contributor License agreement (known as CLA) and requirement of 80% unit-tests coverage, ending with bug hunt days. Somehow it helps me to have a confidence to rely on the framework, and backwards compatibility has never been an issue (it’s surprisingly good).

Variety of components and libraries makes development faster because I do not need to search for another library (there is also coding standards problem and a lot of smaller libraries are just a bunch of files, without any clear structure). As of today, I probably have used more than 90% of available components and because they tend to share the same configuration style or just work style, it didn’t took long to start using them. For example, just last night I converted whole application to use custom routes (one custom route per action) in about 4 hours, without having done it before at all.

Community is number one best thing of Zend Framework. Apart from contributors, there are thousands of people willing to help and share their knowledge. Usually I hangout in twitter (here), but there are also IRC channels, mailing lists, forums and many more. I’m subscribed to hundreds of PHP blogs and from what I can see, Zend Framework articles are most common and usually in a very good quality. For me web applications development is not just writing code, so having a wonderful community really helps.

Disadvantages

Hard to learn. This is not a problem (any more) for me, but can be tricky when working with others, especially with things like form decorators. Even though Zend Framework has a very good documentation, I would say, that used techniques are sometimes not straightforward for starters and can lead to a very bad code. As with example with form decorators, once you get them, work with forms will be a joy, however at first they seem as pointless complication. I guess the best thing is just read the manual properly (RTFM in more rude words) – you will benefit later.

For some an issue can be that Zend Framework has no scaffolding. In short, scaffolding is a user interface and logic generation based on database description and business logic definitions. If you have used frameworks like Django (my favorite for Python, has perfect scaffolding), you will miss these things and it can be a first “brick wall” for your learning. Zend Framework has Zend_Tool component which provides basic project generation (you can customize it easily), but this is pretty much everything.

Connected to the both issues outlined above, Zend Framework in general is sometimes too much loosely coupled. Because all the components are just separate classes and out of the box you don’t get any sort of web application, one might have problems trying to understand what to do with all this stuff at all. It’s a great feature for me, but for someone not having any experience with Zend Framework it is probably impossible to build application without a help of blogs, books or (my recommendation) manual.

As you might have guessed, the fact that Zend Framework has lots of components also means that there should be enough developers to support them. However, this is not always the case and some components are really lacking new features or updates. For example Zend_Pdf is quite out-dated and not moving as fast as a lot of us would like to. But hey, it’s an open-source framework, so if you have ideas of how to improve things – you are free to do, believe me, it’s a great fun to contribute to such a influential software application. Nevertheless, always evaluate available components and choose what’s best for your project.

There is also the funny part – misconceptions and myths. I’ve just started working on a new article about these, so expect some interesting things very soon.

Conclusion

I hope it’s clear, that most of the advantages and disadvantages are coming from the same root – depending on what experience you have and what you are looking for Zend Framework can be a good or absolutely awful choice. For me it’s a perfect tool and currently I have no plans (even though Symfony is in my todo list) to use something else, and if you look at things which are coming in version 2.0 of both Doctrine and Zend Framework (yes, they will have integration)… Simply a good solution for serious work.

Doctrine is a very powerful framework, however you should study its behavior a little bit to get it working properly. As it turns out – it’s not that hard.

Speed

One of the first things I recommend looking at is query cache. Because there is quite a lot happening in turning DQL statement into the SQL query, caching that process can increase performance by a big margin. Best choice – APC, although robo47.net has an example code for use of Zend_Cache adapters, just don’t forget that file back-end is probably not the best pick.

Hydrators are probably the easiest thing to misuse. Hydration in Doctrine language is turning SQL query results into data graph. It can be an array, object or single value. It’s very nice to get results as PHP objects (in this case – models), however it’s slow. Slower than hydrating like array, and much slower than getting raw result from PDO. That’s why I always recommend answering one simple question: “will you be updating/deleting records?”. If the answer is no – hydrate as array, because you are not going to need an actual model (usually).

For this reason I always try to use array notation to access properties rather than like-object-vars one. Basically instead of $product->name I tend to write $product['name'], which returns the same result, but makes switching to array hydration very easy. You can find more tips and tricks at Doctrine manual here, but the key moment is to remember that the faster data structure in PHP is array (I believe so), so if application is not performing well – start playing with hydrations first.

Doctrine has a very nice support for relations, where they work like proxies and data can be retrieved when it’s needed (lazy-loading). However, this is wrong:

$user = Doctrine_Core::getTable('User')->find(1);
 
foreach ($user->Comments as $comment)
{
   print $comment->NewsItem->title . '<br />';
}

This code is bad, because for each comment you will load news item using a separate query, hence you are wasting db server resources and making code slower. Optimization is pretty straightforward:

$query = Doctrine_Query::create();
 
$query->from('Comments C')
        ->innerJoin('C.NewsItem N')
        ->where('C.user_id = ?');
 
foreach ($query->execute(array(1)) as $comment)
{
   print $comment->NewsItem->title . '<br />';
}

Here all the data is loaded in one query and everything happens much faster (and in this case making it to hydrate as array would also improve the performance).

However, make sure you know what you are joining. For example imagine that in previous example news item is also one-to-many (comment has many news items) relation and user 1 has written 1000 comments where each comment is attached to average news items. Query above will return 50′000 records (50 * 1000) which Doctrine will need to hydrate then. This will be very slow and probably going to kill your web server after some time. One day I had a query which was returning 2GB of data, server admins where probably not very happy about it…

Memory

One of my favorite parts of software development is playing with memory usage and making it efficient. Even though it sounds really simple, debugging it and finding it where the memory is leaking is not an easy task. Recently I was using Doctrine to work with quite big datasets (on average 50′000 of records) and probably have tried all the possible tricks to make Doctrine memory efficient. My code looked really simple:

$data = Doctrine_Query::create()->execute();
 
foreach ($data as $item)
{
    // do some work here
}

You might expect that memory usage would be steady, however it is not. Doctrine uses identity map and objects also have a lot of references which makes freeing up memory a tricky job. As my experience showed, even though records have a method free() which is supposed to de-reference it, sometimes it doesn’t help.

So to make memory management work, make sure to try these:

• $record->free(true) – deep free-up, calls free() on all relations too
• $collection->free() – free all collection references
• Doctrine_Manager::connection()->clean() – cleanup connection (and remove identity map entries)

With some debugging and profiling (and these methods) you hopefully can make memory usage to be low. I’m also using some custom iterators (available here) to divide query into chunks, because loading 50′000 of objects in one go is not going to work, so you might want to look at it too.

Another recommended tip: make sure to free queries too. As collections hold references to all records, query object also has some references to parsed sub-parts of query. For this I use auto-free setting enabled by (available in my first part post also here):

// enable automatic queries resource freeing
$manager->setAttribute(
	Doctrine_Core::ATTR_AUTO_FREE_QUERY_OBJECTS,
	true
);

It’s very easy to forget to free a query and it’s again creating these references which makes garbage collector’s work hard. Nevertheless, after enabling this one I don’t know any other place where the memory can start to leak.

Last step – PHP 5.3. I’ve been working with this version for a few months and it works great, so if it’s possible – I recommend using it (you will also help with testing frameworks, but both Zend Framework and Doctrine already should work fine). One important function here is improved garbage collector, so the actual script takes less memory to execute. I haven’t recorded benchmarks on this one, but what I’ve noticed during development is that 5.3 does in fact has a lower peak memory usage.

Conclusion

I think I haven’t missed anything here, or at least these are the tips which made applications work fast (if I have – let me know). To finish with – good optimizations are done by comprehensive benchmarking and profiling, so the fact that Doctrine is a big framework doesn’t necessary mean it’s slow too. At the end of the day, it’s usually only a matter of reading a manual.

All parts:

1. Zend Framework and Doctrine. Part 1
2. Zend Framework and Doctrine. Part 2
3. Zend Framework and Doctrine. Part 3

Final application available at http://winphp.juokaz.com:82/.

Goal was:

My project will allow people to upload huge collections of photos (probably archived in one zip file) and get nice online gallery.

I decided not to use archived files and simply allowed to upload multiple files using Silverlight control, but pretty much everything left the same. My approach to this competition was to focus on technologies and not on functionality. That’s why I spent huge amount of time creating abstractions and making parts of application to be very customizable and not adding a lot of functions.

Functions in my app are really easy to add and in a matter of some lines one can add various parameters to images (tags, name etc.) and then sort/filter them – a lot of hard work is done under the hood. Silverlight based gallery is also absolutely independent from whole application and will work as long as front-end supplies correct gallery xml file, hence it can be easily customized.

Rules had 4 criterias:

1. Application originality – I think I passed this one
2. Completeness – I have done everything what I’ve wanted
3. Use of Windows specific features/services – uses COM objects, Silverlight
4. Documentation of the process – articles in this blog and a lot of tweets

I think I have done everything that was required and now will try to push this application even further. Maybe Microsoft itself will show interest in it, because what I’ve done and used has been key topics in MIX 09.

Silverlight part and images processing is based on Jellyfish library. At first I used Microsoft libraries, but soon I got stuck because of lack of documentation and functionality. However Jellyfish is far from perfect – a lot of things are hardcoded, made private and hard to change. Also, it has some functions which are useful only in rare cases and need to be removed. For example, each mouse move, click and scroll used to look through all images in scene (using loop) and detect which one is under the mouse cursor. Very inefficient (especially if you don’t need it).

Zend Framework was used to power whole website. I didn’t find any difference running it on Windows from running on Linux, so I can’t say much about anything specific. However, I decided to use the new Sql driver implementation for PHP, but it wasn’t included in Zend Framework supported adapters list. That’s why me and Rob Allen started a project at codeplex to create an adapter for sql driver. It’s almost complete and at least both of us use it for our projects – everyone is free to test it and suggest changes though.

Windows was good enough. I haven’t used Windows for any development for more than two years, but it worked surprisingly good. NetBeans works the same in all platforms, but Visual Studio was almost a new thing. Nevertheless, both have done their job. IIS was a new thing too, but I didn’t find a big difference for a developer, only that it allows to change everything without touching config files – I found it faster when settings are in multiple places.

Community is outstanding. Stuart Herbert,  Rob Allen, Alton Crosslen and organizer Bram Veenhof were all chatting on Twitter and it felt more like a community project and not a competition. Also the level of entries, from my point of view, is really high – this competition doesn’t had a lot of entrants (only slightly more than 10), but all of them are really competitive.

It was really a great time.

1. PHP extensions
2. COM objects, programs executed with exec()

Today I’m going to look at all of them and explain my choice to use COM objects and not others from above.

Three choices

PHP extensions (how to create them read here) are fast and (at least should be) stable. However they are quite hard to create at start and uses C. For example, I’m now using library written in C# and rewriting it in C just to use it as extension is way to complicated and time consuming (and probably not worth it). I can only image PHP extensions as libraries to optimize some parts of code or to be used in multiple projects. In my case, I only need to some limited tasks.

Next logical choice would be executing programs with exec(). In my opinion it’s the easiest way because programs can be created with any language you like, can be supplied with source code and none of system settings need be changed. If exec() is not blocked in php.ini it’s very practical solution.

Windows users has an option to use COM objects. COM objects stand somewhere between PHP extensions and exec(). They can be created in many languages, but libraries are not executed outside PHP script – they behave as normal PHP objects (almost). They are more convenient to work with than compiled programs, but need to registered with Windows.

The best

I was testing last two solutions for more than two weeks and my final choice is… COM objects.  To explain this choice here is a short story:

I have a webpage which allows uploading multiple pictures. Two files are uploaded in parallel and once uploaded they are processed (resized, thumbnail and special structure for DeepZoom is created). All this processing is written in C# and uses various windows and 3rd-party libraries.

At first I tried compiling a program as “console application” (in VisualStudio) and then run it with exec(). It worked as expected, but was a little bit too slow. Script was taking around 3 s. to execute, even though actual program ran in 1 s. I didn’t spent much time analyzing where overhead was coming from but it was clear that it can be optimized.

So I compiled program as “class library”, registered it with the Windows assembly cache and then used with a DOTNET class. First problem was IIS server – it kept throwing 500 errors no matter what I did. I didn’t wanted to waste my time trying to find where was a problem – after changing to COM class it magically started to work (even though it uses the same library). Using my library inside PHP was much more faster and execution time reduced to less than a second (depends on a size of image).

Conclusion

I have tested most of possible ways to execute external code. Even though COM objects perform better they can’t be suggested as default choice, because libraries need to registered with a system what can be problematic and maybe not even possible. So if you have limited permissions to server – use exec(), but in all other cases – I definitely recommend using COM. PHP extensions are even better, but harder to code and limited to C.

Configuration syntax

Flash uses flashvars object parameter which is easy to use and passed variables automatically become available within actionscript variables scope. Luckily, Silverlight has almost the same thing.

Flash: name1=value1&name2=value2&name3=value3
Silverlight: name1=value1,name2=value2,name3=value3

To start with, lets create a simple script which will form an arguments string (you can use array of params and then implode with ‘,’, but for the sake of simplicity I just use static string):

$connect = '/users/juozas';
$args = "Connect=" . urlencode($connect) . ",id=1,somethingElse=true";

Inside an object element in HTML add this code (depending on framework you (not)use you may need to change it to work as a template or a view script):

<param name="initParams" value="<?php echo $args; ?>" />

Reading configuration in Silverlight

If you start with a default Silverlight project in Visual Studio, you initially have two classes: App and Page. App is a main class, which (by default) on start up creates a new Page instance and assigns it to a root visual element of itself (App), where Page is your actual Silverlight application (visual part, controls, etc.). Standard start up event in App looks like this:

private void Application_Startup(object sender, StartupEventArgs e)
{
    this.RootVisual = new Page();
}

To use parameters from HTML tag, we need to get initParams from the passed e argument (which has type of StartupEventArgs) and set corresponding properties of some object to their values. You can have global static configuration class, but (also for simplicity) I just pass them to the Page instance:

private void Application_Startup(object sender, StartupEventArgs e)
{
    Page page = new Page();
 
    if (e.InitParams.Keys.Contains("Connect") && 
        !string.IsNullOrEmpty(e.InitParams["Connect"]))
    {
     page.connectPath = HttpUtility.UrlDecode(e.InitParams["Connect"]);
    }
 
    this.RootVisual = page;
}

Here I’m setting connectPath using Connect from initParams. One last thing – don’t trust user input, if you have integers, use Int32.Parse() and always check if passed values are in range of expected values. It’s really important to remember that SQL injections and other similar attacks are also threat in Silverlight (as Flash also).

Outside information sources

However, not all properties can be passed initially – some times it’s required to refresh information from server during actual runtime (think AJAX). You can easily create asynchronous calls to server from Silverlight too (works almost exactly the same as normal JavaScript AJAX script):

public Page()
{
    InitializeComponent();
 
    LoadButton.Click += new RoutedEventHandler(LoadButton_Click);
}
 
void LoadButton_Click(object sender, RoutedEventArgs e)
{
    var wc = new WebClient();
    wc.OpenReadCompleted
            +=new OpenReadCompletedEventHandler(wc_OpenReadCompleted);
    wc.OpenReadAsync( new Uri( "/script.php?id=1", UriKind.Relative ) );
 
    Text.Text = "Loading...";
}
 
void wc_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
    if ( e.Error != null )
    {
        // Do something with an error
        Text.Text = e.Error.ToString();
    }
    else
    {
        try
        {
            // e.Result has a type of Stream, so we need to read it first
            // (not just cast to string)
            StreamReader rdr = new StreamReader(e.Result);
            Text.Text = rdr.ReadToEnd();
        }
        finally
        {
            if ( e.Result != null ) e.Result.Close();
        }
    }
}

This code creates onClick event which asynchronously downloads “/script.php?id=1″ and sets results to TextBlock element named “Text”. You can use absolute URLs too, but don’t forget that cross-domain requests protection will try to block it. Look here to read more about how to avoid it. Not even localhost will work if you are testing with VisualStudio (witch creates temporary “ASP.NET development server” with random port (not 80)), so make sure to check it first.

As you can see it’s very easy and simple to create dynamical Silverlight applications. I have done some work with Flash too (probably more than with Silverlight, especially with ActionScript language) and I can confirm that there isn’t much difference. Silverlight is more like Flex though.

What’s Wrong With The Existing MSSQL Extension For PHP?

… or, why do we need an improved SQL Server extension for PHP? :)

The existing MSSQL extension works well, but has a few practical limitations that have to be worked around.

• Limited to varchar(255) support
• No support for unicode columns like nvarchar
• No PDO drivers
• Poor error reporting

Now some of these issues are fixed, however Microsoft native Sql driver is still not used. As I’ve mentioned before, there are to ways to use native driver in PHP now:

1. As PHP extension
2. Through ODBC

However, none of these is available in Zend Framwork. So my task now (because of Winphp competition) is to come up with something what can be used to connect to Microsft Sql database with the new driver. To start with, lets look how standard DB config looks like:

;application/config/application.ini, ZF 1.8
resources.db.adapter = PDO_MYSQL
resources.db.params.host = localhost
resources.db.params.username = usr
resources.db.params.password = psw
resources.db.params.dbname = zf-tutorial

My goal is to change it as minimal as possible to allow easy db’s migration. To test ODBC connector I downloaded this class and renamed it to Add_Db_Adapter_Pdo_Odbc (because it’s not a good idea to change something in actual Zend Framework library). To use it in your code you need to change config file to something like this:

resources.db.adapter = PDO_ODBC
resources.db.params.adapterNamespace = App_Db_Adapter
resources.db.params.username = usr
resources.db.params.password = psw
resources.db.params.dbname = "Driver={SQL Native Client};
Server=localhost\SQLEXPRESS;Database=zf-tutorial;"

Note dbname string – now it has not only database name, but also driver information and host. I guess such format is chosen because dns’ for ODBC are very different for different providers, so to make things easier you just supply whole string, not it’s parts (driver, server/file, etc.). Don’t forget to use correct server host – for some strange reasons 127.0.0.1 refused to work for me.

Problem with ODBC is that it’s too general: ODBC supports a lot databases, hence they each can have something different (correct me if I’m wrong). That’s why I’m thinking about refactoring this class to App_Db_Adapter_Pdo_Odbc_Abstract abstract class and separate classes for different drivers. Although this class works fine for MSSQL, so can be used as is.

To test PHP extension there are no classes at all (at least I haven’t found, only in Adodb). So I decided to implement one myself – with a help of SqlSrv API Reference and Zend_Db_Adapter_Abstract abstract class I quite quickly came up with a working solution App_Db_Adapter_Mssql. Connection configuration looks the same:

resources.db.adapter = MSSQL
resources.db.params.adapterNamespace = App_Db_Adapter
resources.db.params.host = localhost\SQLEXPRESS
resources.db.params.username = usr
resources.db.params.password = psw
resources.db.params.dbname = zf-tutorial

I’ve tested both classes with the same application from previous post and benchmark results surprised me. They were equal! With a small variations page generation times were about 140 ms (all default settings, IIS7, MSSQL Express). Why? SQL server driver for PHP is open source, so if you look at it’s source you would find (C++):

SQLRETURN build_connection_string_and_set_conn_attr(
       sqlsrv_conn const* conn, const char* server, zval const* options,
       __inout std::string& connection_string TSRMLS_DC )
{
   ...
 
   connection_string = "Driver={SQL Native Client};Server=";
   connection_string += server;
   connection_string += ";";
 
   ...
 
   for( zend_hash_internal_pointer_reset( oht );
         zend_hash_has_more_elements( oht ) == SUCCESS;
         zend_hash_move_forward( oht )) {
 
      ...
 
       if( NO_ATTRIBUTE == ret.attr ) {
           if( ret.add ) {
               connection_string += key;
               connection_string += "={";
               connection_string += ret.str_value;
               connection_string += "};";
           }
       }
       ...
   }
 
   ...
 
   return SQL_SUCCESS;
}

If you are familiar with C++ you can look at full source at codeplex.com. What this function does is it creates ODBC connection string, so basically it’s the same thing as using PDO_ODBC (no?). Both are implemented as extensions (not as PHP code) so there are no performance differences, test proves that.

After today’s analysis I can’t say which driver is better to use: ODBC or native driver. However, since Pdo driver is already being used in Zend Framework it’s easier and faster to use ODBC. Also, ODBC doesn’t require Sql PHP extension to be installed, so as long as you have Sql server and native client it will work without php.ini modifications.

In conclusion, if you want to use SQL Native driver with Zend Framework solutions are almost here. I can promise, that something stable and proven to be working by actual application will be released before middle of June. I would love to hear comments from Microsoft people or ODBC users – I’m confused a little bit, because I didn’t have a lot of experience with Microsoft’s Sql and ODBC (you can share find me in twitter also @juokaz).

Making your library COM visible requires that you register the DLL in the GAC and registering something in the GAC should only be done when multiple applications need to access the same version of the same library. Even then, most software houses will deploy each app with it’s own copy of the DLL instead of using the GAC.

Nevertheless, C# (and most of other languages) support Reflection. Basically using reflection, programs can “observe and modify its own structure and behavior” (wiki). .NET has System.Reflection namespace with all needed methods. Purpose of this post is to find a way how to load DLL’s dynamically – without worrying about registering, re-registering, unregistering them in running system/production servers.

DLL’s are library assemblies, which “contain code in CIL, which is usually generated from .NET languages, and then compiled into machine language at runtime by the CLR just-in-time compiler.” (from). For all not familiar with assemblies, assembly “is a reusable, versionable, and self-describing building block of a common language runtime application.” (from). Consider this code:

using System;
using System.Reflection;
 
namespace Php
{
    public class Reflection
    {
        public Object get(string assembly, string className)
        {
            Assembly asm = Assembly.LoadFrom(assembly);
 
            return asm.CreateInstance(className, true);
        }
    }
}

This is very basic class, which can be used to do such things as:

Php.Reflection obj = new Php.Reflection ();
Object my = obj.get("my.dll", "namespace.class");

You may have thought that this class is absolutely useless, because you can simply use System.Reflection.Assembly without wrapping it into separate class. However, I was writing this code with an intention to use it as COM object in PHP and because PHP can’t access static COM class methods (which I find very disappointing) I needed to create this class. Now in PHP you can write:

$obj = new Com ("Php.Reflection");
$math = $obj->get("math_class.dll", "phpclass3.first");

This method, in my opinion, is much much more better than registering every single class with global assembly cache. It’s more practical and maintainable to have all required libraries in the same project directory, and not somewhere in Windows core. However, benchmarks are still coming so stay tuned.

* For everyone interested in Winphp contest, and people building PHP apps in Windows, I recommend reading www.eurowinphp.com blog, which aggregates all participants blogs. For example, Timmy Kokke, another WinPHP participant, recently wrote another great tutorial how to make your .NET classes accessible in PHP. Also, you can follow my on Twitter at twitter.com/juokaz.

I followed this tutorial, which has most of required information. Firstly, you create your “Class library”, then create assembly key file and assign it to project assembly. After project is built, you register and add to global assembly cache your library. Probably it’s quite natural process for all .NET developers, but for PHP developer like me, registering something with whole system seemed quite odd (dll hell?).

First problem was ComVisible. ComVisible is a keyword in assembly which is used to control types visibility: “If you need to access a type in this assembly from COM, set the ComVisible attribute to true on that type”. VisualStudio by default sets it to false, so all types are hidden and trying to register dll will result in this warning:

RegAsm : warning RA0000 : No types were registered

Luckily, I find out about ComVisible property quite soon – it’s quite hard to know about it if you haven’t done anything serious with .NET. Nevertheless, after setting it to true, everything should work fine. Sometimes VisualStudio (2008 Professional Edition) refused to build project because of locked dll, so don’t forget to try to kill PHP-CGI process first (Ctrl+Alt+Del). I didn’t had any other problems.

After some tests and failures I ended up with two simple C# classes and PHP caller. Class1 has two public variables (x, y) which are set by PHP in $math object. Method Class1.sum() creates new Math object with constructor parameters x and y, and calls getSum() which returns sum of x and y. Useless stuff, but it worked great to test if:

• COM objects works
• One class can call another (Class1 -> Math)
• Types are correctly understood/converted

Working PHP code (phpclass2 is C# library namespace):

$math = new COM ("phpclass2.Class1");
$math->x = 100;
$math->y = 100;
 
echo "sum = " . $math->sum();
 
unset($math);

Which successfully outputted:

sum = 200

I tried this code with the same Web Platform I used in Windows Server 2008, but now with older IIS (v5, Windows XP) and it worked perfectly with all default settings. Also, IIS control panel in Server 2008 is 10 times better than in Windws Xp – in Xp-one I couldn’t even find how to add new virtual host (my bad, but in IIS 7 it’s way easier to do). And because I was installing it second time, it took me only few minutes.

Getting this to work was probably one of the biggest milestones – actual frontend code and Deepzoom C# library is not that tricky. After some days of working with PHP+Windows things are starting to get a shape – except of different OS GUI, web server works good in both Linux and Windows – clearly Microsoft is holding this competition to show it. And they are in the right way.

Luckily, I had Windows XP in VirtualBox so I tried it. And it worked really well. I’m using university internet network so connections speeds are very fast and Ubuntu -> Windows Xp -> Windows Server 2008 worked just fine. Later I will probably use real Windows system, but for first steps virtual machine worked much more faster than I expected.

Almost 4 years ago I had experience installing IIS server, but I haven’t done much since then. Nevertheless, installing IIS+PHP was really easy – I followed this tutorial, which shows you how to install Microsoft Web Platform, and IIS was ready. Platform installer allows you to install not only SQL, PHP, ASP.NET, etc. but also various web applications – Wordpress, Drupal and many more. Experience with IIS was very similar to Zend Server, but IIS control panel is way better.

I chose to install Wordpress, just to test if IIS is working properly, but Platform installer doesn’t install MySQL. PHP is installed with MySQL extension, but no server is being installed – quite illogical. However, installing MySQL server is as easy as installing any other windows application (subjective) – download installer, Next, Next, Next and server is running. Also, mysql tool works the same in Windows cmd and Linux console.

Tutorials and other information:

• Creating your PHP dev environment for the WinPHP Challenge
• Microsoft Web Platform
• Setting up MySQL for PHP applications
• PHP on IIS7

What I liked very much is GUI for web server control. Currently I have 13 web apps running in my laptop and every app has different port (localhost:80, localhost:81, localhost:82, etc.), but I haven’t found any good tool for adding more sites. I would like to have simple tool, which would accept port number and directory, and create virtual host. IIS control application allows it very easily.

In conclusion, working with PHP in Windows server seems to be pretty acceptable. I haven’t tested setting up anything except Wordpress, but Wordpress seems to work just fine. Especially I liked using GUI, because most of tasks for development machine can be done much more easier and faster, still I’m not going to switch from Linux yet.

Advantages:

• GUI
• Easy to setup
• PHP works

Disadvantages:

• Some functionality is hard to find
• Differences from Apache (mod_rewrite, etc.)