Data binding is a really handy way to fill list controls with values from some data source – usually a database, but it can come from almost anywhere. However, there are times when you may want your list box to have some additional items – maybe an instructional message – “Please pick a value…” or an “All” option.

So – just a quick reminder that you can do this very very easily in ASP.NET.

<asp:DropDownList ID="cboCountry"
           runat="server" Width="250px"
           DataTextField="CountryName"
           DataValueField="CountryId"
           AppendDataBoundItems="true">
     <asp:ListItem Value="-1">All</asp:ListItem>
</asp:DropDownList>

Just set AppendDataBoundItems to true, and add in your other values as asp:ListItem entries. In my case the drop down list allows the user to filter data by country. But I also needed a way to have them remove a country filter – i.e. show all the data again. Thus the “All” option, and the -1 value.

Just a quick note about some updates to the Virtual Earth Tile Server code base. You can grab the latest code from the Subversion repository (http://svn2.assembla.com/svn/arcdeveloper/tileserver).

Note: This update will require some configuration changes, but I think they are well worth it.

WMS Support

The Tile Server now as a WMS Tile Provider. This allows you to very easily add WMS Services into your Virtual Earth applications. This is a pretty base implementation, but it works smoothly. You just need to specify the base Url (which should include the LAYERS you want in the map images) and the version of WMS to use. The WMSTileProvider takes care of the rest. I’ve only tested with WMS 1.1.1 at this point, but I’ll be working with all flavors shortly so should there be any issues, I’ll be fixing the code.

This is the configuration file in source control, and it is pulling a global bathymetry layer from mapsherpa.com. It can be a little slow at the top levels, but once it’s cached, it rips.

Improved Caching Options

Caching is great, and can improve performance, but it can also eat up a lot of disk space. For example, at level 15, there are more than 1 billion tiles, so you could really fill up some disk space. Unless your data only covers a small area, the likelihood of a cache hit at the higher levels is pretty low. Thus you are storing lots of tiles which are not really helping performance. To help manage this, I’ve added a MaxCacheLevel property to the Tile Service. By default it will cache everything, but you can change that by just adding maxCacheLevel into the parameter list in the service configuration…

FileStorageProvider Changes

The tiles are now stored in sub-folders with the name of the service. So – instead of seeing something like:

c:\tiles\l1\

you will see

c:\tiles\someservice\l1

This allows you to  use the same FileStorageProvider across multiple services in your configuration. Not a big deal, but saves some configuration.

Could anyone who is using the ArcGIS Server Virtual Earth Tile Server code please shoot me an email or drop a note in the comments. ESRI is preparing a press release about the Code Challenge winners, and they asked for a list of people/agencies etc using it. Some free publicity if you answer quickly!

Thanks!

Dev Summit 2008 is now over and done. Great to see so many old friends and meet tons of new ones. This conference is “the” event for developers working with the ESRI product line, so if you could not make it this year, start working on your managers now to get approval for next year.

One idea that ESRI threw out at the closing session was the idea of running another “track” that would be technical sessions presented by users. I think this would be awesome (and not just because I’d love to give a talk!). I briefly talked with them after the Q&A session was over and the idea would be that the developers would be able to submit some sort of a description of the presentation, and then the rest of the community would vote for the sessions they want to see. This would be fantastic. If this sounds like a good idea… um… yeah. I just looked for a link on EDN to send feedback (about something other than the site itself), but did not find anything that looked suitable. Just leave a comment, and I’ll find out the best way to push that back to ESRI.

While decompressing on the lawn outside the conference center, it occurred to me that having some other smaller, focused, but really technical events at other times during the year would be a great addition to the Dev Summit. Sure they could not drag the dev teams all over the place (someone has to work on 9.4!) but maybe bring some folks from tech support / professional services? Just an idea…

A quick note on my posts from this week – they were just the notes, as I typed them during the sessions, and I hope that was useful for those who could not make it out here. If something was particularly cryptic, shoot me an email, and I’ll see if I can figure out what I meant.

It’s been a fun week, and thanks to everyone at ESRI for putting on a consistently excellent event. See you next year!

Official Line: “The .NET ADF is a hybrid platform – mix of server side and client side development environment.”

Built on ASP.NET Ajax, but still supports the ASP.NET Callback model for backward compatibility.

As a quick aside – Art Haddad was running a Mac…

Core object model is relatively the same as at 9.2

Core controls are now scriptable – they work with the MS Ajax client side libraries. The javascript is now “public” and documented. This is great – in the past we had used some of the client side javascript (not supported) and found that it changed across service packs – doh!)

Common Data Source API – standard access across the spectrum of data sources. The common data source API will expose different functionalities based on the type. You can get down the the ArcObjects if need be *I’m assuming this is the same model as at 9.2 but they were moving through stuff very quickly)

This ADF has a Visual Studio design experience that provides an option to do things without getting your fingers in javascript. That said, the javascript is public, so just like the Ajax Control Toolkit, you can just jump in and use it like the “Javascript API” (which brings up the fact there are two javascript APIs – one based on Dojo and one based on MS Ajax – choice is good).

Task Framework is now extensible in the Application Manager via web controls (dlls). This will allow you can publish new tasks, and users can then include the tasks in a published application. Nice feature if your environment is involved in the author-publish-consume workflow.

They are releasing tasks into the code gallery, will allow a faster release cycle.

More “comprehensive” class library documentation, discussions of Ajax patterns, migration from 9.2 to 9.3. Lots of work on the Resource Center to help people get rolling quickly.

Can create user controls for the task frameworks (ascx) – much simpler than creating full blown web controls in dlls.

Performance

Blending at 9.2 used a single tiling scheme. At 9.3 each resource has it’s own tiling scheme, and the “blending has been massively improved”

Use of HTTPHandlers used instead of Pages so the page lifecycle is avoided, so it’s faster.

Javascript is public, documented, JSON based, and object oriented.

Better activity indicator so you know that something is going on. 

Demo of 9.2 vs 9.3 performance. Definitely much faster. Eliminated lots of callbacks, httphandlers improve performance because the control tree is not re-created and destroyed.

Webcontrols

MapControl – scriptable directly. This is provided by implementing IScriptControl, and just works. The overview map had been improved a lot. The logic has been streamlined, so it’s much simpler. You can enable the “intelligent” mode. At 9.2 there were 12 callbacks to get the overview. At 9.3 it’s 4 and then it’s just client side.

The resource manager can be managed in javascript, and has lots of configuration – i.e. layer alises, fields to show, map tips etc.

Results Viewer – bi-directional high light. The task can have different results behavior (fields, maptips etc)

Additional web controls, additional AjaxExtenders – DockExtender, HoverExpandExtender (pin window type of thing)

Supports .NET 3.5, but not required.

By final, there will be javascript intellisense for Visual Studio 2008 (you likely need to get a Visual Studio service pack as well as the ADF)

Better templates, but if you use these, be sure to send feedback to the team during the beta to get your features in the list.

To use the “Client side geometry model” – Just set the graphics layer RenderOnClient property to true. Sweet.

Automated migration for the Manager applications (author-publish-consume  three-click workflow)

There is a utility to help convert the template apps to 9.3

To do it manually – add reference to the System.Web.Extensions.dll, upgrade assembly version reference. Script manager is not required. If you want it to work with the Ajax partial postback model, you need to add a script manager.

Can use an update panel with non-Ajax controls and use triggers between the .NET ADF controls which are already Ajaxified.

Do not put the .NET ADF Controls in an update panel. This will kill your performance.

Questions:

Client geometry sent in JSON… GeoJSON, same JSON as REST API? It’s ADF JSON – basically serialized versions of the server side .NET classes. Standard .NET design pattern

Have you worked with the controls in a javascript UI layout framework like Dojo, ExtJS, or YUI? They have done some testing with YUI components, and it’s fine. All the client side code is namespaced, so there should be few issues.

Compressed / minified Javascript? By final

Thoughts:

Sounds like we can work directly with the MS Ajax Javascript API, which I personally like. The hybrid approach is very compelling for many apps which need some form of server state, but still require a very responsive interface.  Use of the ADF vs the REST/Javascript API may come down to a question of licensing.

So, despite completely spacing the voting, I just walked into the Keynote session to see my name up on the big screen winning second place. Wow. I’m totally surprised, and honored. Thanks to everyone who voted for the Virtual Earth Tile Server, and if you have used it, and made changes – please be sure to submit the fixes / updates / patches etc. either to me, or directly into the subversion repository. To get write access into the repository you need to be a member of the project @ Assembla.com – just shoot me an email (contact link above), and I’ll send you an invite.

I would list the other two winners, but honestly I was too floored to take notes.

Again – thanks to everyone who voted!

Yesterday I focused on the REST, and Javascript API’s, and today’s task is to get the skinny on the re-vamped .NET ADF.

In talking to some folks, apparently the .NET ADF includes a Javascript API based on the Microsoft Ajax client library. In contrast to the relatively simple Dojo based API, apparently this one has more depth, and with that (one would assume) comes more fine grained capabilities. So, we’ll see what some pointed questions can drag out.

At a high level, I think that the .NET ADF may have a tough sell moving forward. The REST stuff is clean and elegant. It may be that on paper it can’t do as much, but I believe that there are creative solutions that can step around any limitations. Secondly, everyone I’ve talked to who has used the 9.2 .NET ADF, well, I’ll be charitable and say they are “luke warm” on it. The difficulties they faced in getting good performance, and implementing seemingly simple functionality is what will drive them to try the REST API before the .NET ADF. And if the licensing story for the .NET ADF remains the same, and the REST API is gratis, well, money talks.

I hope that the 9.3 ADF does more than support the ASP.NET Ajax “extender” model (this is how the Ajax Control Toolkit works). From my work with the toolkit (which has been restricted to the ModalPopupExtender and the ListSearchExtender), it’s a nice model if you really want to keep your fingers out of the client side code. The difficulty is that since the extenders are setup as part of the page lifecycle, they seem to need everything they interact with to be “runat=server”. For reasons I’ll skip right now, this is not always easily done. Since all this behavior is implemented in the client, theoretically you can wire up events and use the client side code however you like, but in the Control Toolkit, this is not exactly documented (please send me details if you know otherwise!).

Getting back to the .NET ADF, I hope that the Javascript libraries are designed to be directly consumed and manipulated. Personally I like the Microsoft Ajax client library, and working with server side services is just a slick developer experience. So – I have high hopes.

The Javascript API is based on Dojo. ESRI has created some dijits for a map, and the basic pattern looks really similar to the Virtual Earth maps.

The Google Maps extended is just more javascript which extends the base GoogleMaps API to play nice with the ESRI services.

2D and 3D in Virtual Earth is also fully supported – again via javascript extensions.

Slightly different syntax across the APIs, but same basic patterns.

Embed maps and tasks into sites

Use ArcGIS Online or custom (ArcGIS Server) data sources.

Any supported projection. So you polar explorers are now in luck.

Javascript can be hosted by ESRI (like VE or Google Maps) and is in the Akami cloud (think fast, and globally cached – a nice touch).

Samples will be hosted in a live server. Much easier to dig into the samples because they are live. Can copy paste code into your html/aspx/??? file and start modifying. Very streamlined development cycle.

Examples working with a Dojox.grid (Nice because it takes a DIV as a target so the page layout is pretty smooth)

http://maps.esri.com/agsjs/surfaceprofile.html – surface profile demo

InfoWindow can contain whatever you want – i.e. another map

Symbology Model

Really nice demo of a symbol manager based on dojo controls. Incidentally it was running in FireFox on a Mac. Lots of options re: how client side features are displayed. Should be relatively easy to allow client symbolization. Again – looks very performant. They also have symbol sets. They will have a code-gen tool that will allow you to use this tool to setup your symbology, and then export the code to drop into your app. Also running in Safari. Only Solid_Fill supported in FireFox 2. All the saucy picture fills are supported in FireFox 3.

Again stressing the simple, but you’ll need to have your CSS, HTML and Javascript chops in shape.

Virtual Earth Extender

Only Tiles – no dynamic layers, but all results can be sent back as VEShapes. Also an interative SDK. Looks just like the VE Interactive API. Javascript hosted by ESRI.

Google Maps Extender

Tiled layers or dynamic layers (via GGroundOverlay). The extender allows you to easily pump results back into GM. The Extender removes the need to convert between the native classes in the base API and the ESRI javascript API – i.e. you can pass a GM LatLongBound into a query. This should be a very smooth developer experience. 

Mapplets

Run within Google Map web site. Can be published to Google Maps. Pretty cool way to push stuff out.

Thoughts:

Again – this is really great stuff. Simple stuff is really easy, and I’m betting that the hard stuff is still difficult, but I’d wager it’s miles better than the 9.2 ADF experience. We’ll see what the 9.3 .NET ADF has in store at tomorrows session…

The information flow here is very important – design the application to show focused data in small chunks. This allows very small, fast transactions. That said, if you try to push tons of data into your browser, it will bog down.

Since the Javascript is hosted by ESRI, presumably anyone can just include it on a page. From there, you can consume the free ArcGIS Online services, and of course you can mash-in anything else you want. So it would see that there is a world of good free fun just waiting to be explored…

Ah yes… a little author-publish-consume love from to start this session…

REST 101 with Keyur Shah

It’s all about addressable resources – Urls point to resources. We use use standard HTTP Verbs – GET, POST etc.

Self-descriptive messages – all necessary state is sent each time. Server then returns the complete answer.

Hiearchy of services defined as a url – catalog/service/map/layer etc

Upside of using Url for everything is that it’s bookmarkable – think

“Browser is the new command line”

Lots of thought went into the Uri design – very easy to understand and explore. From my poking around, I’d agree.

“ETags” – conditional GETs – allows the client to ask the server if a repeated request for the same content is still valid. They also cache content in the REST server itself, so we should see very good performance.

gzip content done based on the browser. 70-75% content savings when combined with JSON

HTTP Status codes used to indicate… status.

REST API requires client side session state. Because there is no session state on the server, it should scale much better. GETs are cachable because any request to the same Url will always be the same (ETags handle cache expiration when data changes)

The API can also be crawled so we’ll start to see deep indexing via search engines.

Response Formats

multiple response format – parameter “f”. Default is html which is the explorer. Also support: json, kmz, image, help, lyr (ArcMap/ArcGlobe), nmf, jsapi (load directly into the Dojo viewer), gmaps (load directly into Google Maps), ve (guess)

The “help” option is awesome as it will return context sensitive help. Very Nice!

f=json&callback=myMethod

Call the method that the json will be sent to. A shortcut.

f=pjson or f=json&pretty=true

More readable less compressed json for debugging. FireBug goodness.

f=kmz

Much better KML integration story w/o out the config needed in 9.2. Works with caches (if mercator compatible projection). Really will allow some good geoprocessing into Google Earth. Keyur also said that Geoprocessing has been improved. Will need to check this out.

Lots of caching in the REST tier. Performance looks good, but obviously this is predicated on sensible service design – don’t let your users return 10,000 features.

Ran out of juice, but the rest of the session was awesome. Yahoo Pipes demo mashing up different streams, Google Earth “application” demo. 

The REST API can serve tile caches (assuming they are in “web mercator”) into Google Maps and Virtual Earth.

Commentary:

The REST API puts ESRI back in the game in terms of public facing sites and services. This is the future. From the perspective of a consultant who’s prettu invested in the ESRI product line – Thanks.

Kudos to everyone who worked on this.

I don’t have the WEP key yet… so not on the fly updates… This is just a dump of notes taken on the fly – I’ll be talking to people later and getting more details on a lot of this. I’m really looking at the REST stuff, so if you have specific questions, drop them in the comments and I’ll see what I can do to get an answer…

Plenary Intro…

ESRI using Coverity for static analysis – lots of bugs fixed as a result. Lots of hype for Coverity.

Resource center being expanded from ArcExplorer to the entire line.

ArcGIS Server

Ismael Chivite – AGS Product Manager

<koolaid>

• “Making GIS knowlege available on the web”
• “Complete Server GIS”
• “Core Services”
• “Replication and Federated GIS Systems”
• “Out of the box applications access core services”
• “Use Google or Microsoft Virtual Earth to connect to the Services”

</koolaid>

Performance Improvments

What we’ve heard before – partial caching, on demand caching.  Nothing about improved performance for creating the caches

Web apps – lots of effort in improving the .NET ADF. Less round trips to the server. Built on MS Ajax.

AGS Image Service = Image Server, with smoother publishing workflow. Drag and drop raster in Catalog to publish it. Nothing on how you setup the overviews, so maybe that’s automated with defaults.

Security – many more options – ASP.NET membership is an option, and you can implement your own provider.

Developer Center Resource Center – portalized content, but do they have good search? Also have web services that can be included for free (interesting – wonder what the TOS are on this?)

Apparently lots more content, better organized help. Will there be any FooClass.DoThing() –> Does a thing API documentation

Code Gallery – more tasks etc will be incrementally released. Nice touch. Will include source code. Will there be stuff beyond “tasks”? The community will also be able to upload code – nice.

Rex Hansen Demo

Using the Resource Center to find info on the Microsoft ASP.NET Ajax framework. Many samples – showed a Partial Postback sample. Personally I’m more into using the lower level ASP.NET Client library with JSON Services than the update panel, but that’s just me. Moved to creating a custom web part, that can then be pushed into SharePoint. Points pulled from a CRM (unclear on how they are linked), with a ArcGIS Online Street map. I’ll be playing with this to see how the cascade performs – i.e. does the client make the street map request directly to ESRI, or does the Server do it? What’s the lag time? Are the points geometry in the browser a la VEShape?

Rex also talked about the Java ADF…  did some editing tasks – attributes shown in a pop-up instead. Not sure if it was for simplicity but the demo showed changing a building permit type – defined as a text field – wouldn’t this be a Domain? Maybe the domain pull downs are not cooked yet? Or this is just a very simple demo…

Javascript and REST API

This is one of the few areas with “NEW” functionality. Can you say Mashups? Ismael compared Javascript to Avenue or Python… “it’s very easy to create applications with the javascript API”… um yeah. It’s just object based Javascript, REST, JSON, angle brackets, and CSS but it’s very easy. “Easier” – maybe, “easy” – only if you’ve already cut your teeth in these technologies.

Jeremy Bartley Demo

No web server licensing for any of the REST/Javascript API’s. This is great news.

Interactive site for the Javascript API, with line by line review of the sample apps. Showed the simple markup for the “basic map”. Very VE like in terms of setting up a map. Nice looking API with clean documentation – I will likely be spending quite a bit of time here. Also a community area.

Samples – lots of them covering all(?) aspects of the API. All samples use ESRI services, so they are easy to get up and running locally. Nice.

Talked briefly about using the geometry service. Looked like a couple of round trips, but seems very fast.

Geoprocessing task – summarize population within a geometry – pretty simple. There is a GP Explorer that lets developers poke around on a server – includes an image of the model (shudder). Pass arguments into the service as JSON, so should be interesting.

Nice demo using the Dojo Chart API. All rendered on the client. Very sweet.

Google Maps and Virtual Earth Integration

Nice demo that takes a Google Route, and generates a profile.

Virtual Earth sample that gets hurricane tracks, and draws them on the map (not clear where the tracks came from) but they were then passed to a GP service to buffer them. Are the extenders capable of taking VEShapes directly and shooting them to the GP Task?

<koolaid>

“I have not met anyone who could not create a map application in 15 minutes” – Ismael

</koolaid>

Mobile ADF

Pretty cool stuff, and I hope to get into this. I’m sure there are improvements, but not having done more than a very very simple prototype back in the 9.2 beta, I’m not really one to say much on this.

One thing of note – there was a demo that showed a “workflow driven” application. Hurray! It’s not always all about the map! This is what a lot of people need to understand – just because you can show stuff on a map, does not mean that it’s the best way to interact with the an application. Very nice.

ArcEngine & Desktop Review (fast and furious by Euan)

More editing options – SQL Server express mentioned, but thin on details. More “use GP” talk. Better API documentation, better indexing of the documentation. Eclipse add-in for better java debugging.

Desktop has some Z-Value editing (??) HTML popup window in desktop for simplified identify type functions. VBA 6.5 will be in final, to make things easier to deploy on Vista and interop with MSOffice

Error report demo – ESRI will provide debug symbol servers. Helps with sleuthing “random crashes”

ArcGIS Explorer

Rapid evolution, releases every few months. Version Neutral (not tied to the rest of the ArcObjects API), local and remote data support.

New symbols in build 450 will also be in 9.3 – basically some prettier icons. Ability to control the look of the attribute popup via CSS. Ability to add Google 3D warehouse via KMZ/KML. Nice demo showing Youtube video integration, live-traffic cams etc. Nice, and really just catching up to Google Earth.

Tasks is where things diverge from Google Earth. More pre-cooked tasks available online. GeoNames.org demo piping one task into another task. Focusing on integration and… yep… mashups.

User Showcase for community tasks. Looks like ArcScripts’ days are numbered.

I’m going to have to play with Explorer more – looks like you can do a lot of stuff. Nice demo of vertical slicing.

Future builds will have multi-thread tile fetching, easier task updating (push? version check/update?)

Even further out – more Ux updates, integrated 2D and 3D support. Markup and collaboration (sweet), and developers can use the 2D and 3D controls in our own apps! Woot!

Andy MacDonald showed off a “build 600″ version with a Ribbon UI – context driven UI like office. Nice basemap “gallery” integration directly into the UI (instead of opening a browser first). Flyout/self-docking windows. I think this is later this year?

Explorer SDK…

Available with Build 600 & 700. Map Control. Sweet. Super Sweet. It’s certainly not a MapObjects replacement, but it sure is nice. API has been expanded – easier to use – lots of overloaded constructors. Less “interface” driven API – easier API exploration via intellisense. More helper methods to simplify verbose tasks. Collections now support enumerations so looping is smoother. Licensing?

Scott Moorehouse Big Picture

“Web is now the center of ArcGIS.”

At 9.3 the focus was on finishing concepts introduced at 9.2. “Federated” – everyone take a sip. Web = Easy to Use. Get things done. ArcGIS is part of a broader community of products – i.e. we’ll play nice with other stuff.

9.4 will be an incremental release. Nothing crazy new. Will be modularizing more aspects of the platform, which will allow ADF’s and Web APIs will have faster release cycles. Also more Linux support. Complete re-write of the dynamic map engine (sounds like new rendering engine for better performance?) for server. Silverlight SDK coming. More Geodatabase APIs, better web APIs for GDB transactions.

Wow this is long session…

EDN Community – Jim Barry

Growing online resources. Team has been expanded. Little bit of “ESRI and You lovefest”. ESRI has blogs. woot. Apparently there will be more blogs. woot. Forums *may* be updated. They had some new better forums during the 9.2 beta, but apparently that did not go anywhere. Jim asked for feed back on the forums so here goes:

If nothing else, add RSS feeds into the forums. 

Although I missed the first few minutes, no mention of “author publish consume”… wonder if that’s because this audience may be a little more skeptical of the three-clicks to greatness story line.

Found the WEP key, so more updates later…