With the public release of Office 2007 (or whatever it's called), I decided to grab it and start using it on a day to day basis. Tons of great stuff. Word is great, excel is great, I'm really liking the new UI.
Outlook has a new UI and some other features that I'm getting used to.
I have come to love the service of Squeet, which I have an account on, that manages all my RSS feeds. When Squeet finds a new entry, it emails it to me. I have a slew of Outlook rules that process the Squeet mails, and move them to the right folders, making it very easy to read.
Outlook 2007 has an RSS feature. Just subscribe to an RSS feed and Outlook adds a folder for the RSS feed, and brings in all the feeds. Ut..... Ohhhh. This is a feature that I might be tempted to use. After all, my love of the Squeet service was to read my RSS content in the application that I live my life, Outlook. So I got started very easily, because Squeet offer up an OPML feed, that let me easily import all my feeds to Outlook. Right now I have around 80 feeds. I was amazed at how fast all the feed folders were created.
<Scott Smiles />
This is going to work well I think to myself. And go back to work.
Then, about an hour later, I see the famous error in the bottom right corner of Outlook, that happens when your mail server is down, that says something like "Error / Can't Connect Blah Blah". What The .....
I realize that it's checking the RSS feeds.
It hits me.
Squeet is not just an RSS to Email tool. It's a bandwidth tool. I don't have to hit 80+ RSS feeds once an hour to get new content. With Squeet, all I have to do is check my mail. They do all the pinging and checking, and I get to sit back and wait for new content. They deal with broken feeds and all the other jazz that comes with RSS.
So, I tried, and killed it. I'm still a squeet fan.
Today is my travel day to get to Orlando for the VSLive conference. My talk is titled Advanced Ajax. I'm going to start with the core understandings of what Ajax is and isn't, then show how the Ajax.NET Pro Library works with Ajax and ASP.NET (1.1 and 2.0), and then follow up with how the Atlas Framework works with Ajax.
My goal in this talk is to focus on the How of Ajax, not the What. Let me explain what I mean. Plenty of presentations show the "What can be done?" side of Ajax. I'm interested in showing you the "How does it work?" side of Ajax.
The talk is titled Advanced Ajax, but that is kind of an oxymoron. Ajax itself is very simple to understand. It's what you intend on doing with the response you get back from the Ajax call that can get tricky.
Time Slot :: This is a double session, not just a single hour. I've practiced this delivery several times, and two hours is a great delivery time. I'm not one to present a thousand topics at 30,000 feet. Instead we'll focus on very few topics, but we'll examine them thoroughly.
Outline :: I'm going to start with the fundamentals...
- Ajax - The origins. XmlHttp in 3 flavors are ...
- The response from XmlHttp is ...
- JSON objects
- DHTML
The above code examples will all be done with HTML and Some Client Side JavaScript. This will get the audience introduced to what's really happening with Ajax in general.
Then I'm going to show how the Ajax.NET Pro Library makes working with Ajax and ASP.NET very simple. I'll build a quick example, and then we'll show exaclty how that example works. Highlighted points will be...
- The Ajax.NET Pro ASHX Handler
- Registering the Page Object
- The Auto Generated Client Scripts that created
- The reflection that happens when these scripts are executed
- To Sync or ASync ::: Using Ajax.NET Pro Callbacks
- The Ajax.NET Response Object
And the last portion of my session will bring Atlas into the picture. Atlas is a client side framework that is a huge solution, and Ajax support is just one of the benefits of using Atlas. I'm going to round out the session showing you how Atlas is built with what I call a "Foward Development" architecture. I'll explain more in the talk, but in a nutshell, what I mean by Forward Development, is that Atlas is being built, so that you can easily adapt your existing code, and start taking advantages of some Ajax functionality. The two large highlighted points during this section will be...
- The <Atlas:UpdatePanel />
- What is it really?
- What is the magic?
- How does it work?
- How is this Forward Development?
- Web Service calls in Atlas.
- How do they work?
- How is this Forward Development?
Summary Goal :: By the end of this session, you should have a great understanding of how Ajax works, and have a better understanding on how the two most popular solutions for ASP.NET accomplish Ajax functionality.
So if you're going to the VSLive conference, I'd love to have you stop in and say hello.
UPDATE :: Here is the link to Code / Slide / Project from the talk.
http://ScottCate.com/Downloads/AdvancedAjax.zip
We started Saturday, May 6th, at about 7am. People were already setup and checking in attendees and speakers by the time I got there. The UAT campus we used was perfect for delivering the sessions. The only thing I didn't like about the morning was that there wasn't a common area large enough to get the attention of everyone at once, so we didn't have a welcome general session, so people were on there own to figure everything out.
We did have a volunteer staff of about 10 to answer questions, and get people to where they wanted to go. We had a nicely printed page with a schedule matrix on one side, and the CodeCamp eval on the other. So everything was contained on a single page. Very nicely done.
Lunch went off without a hitch. We had Subway deliver boxed lunches and beverages. 1/2 the order came in at 11am, and the other 1/2 of the order came in at noon. Which is perfect to our schedule. We actually had 11am and 12pm sessions, so we broke our lunch into two breaks. It helped eliminate crowding, and everyone was happy. REALLY HAPPY.
It turned out that we had a little bit of extra food. Many of us had the idea of donating our extra food, so I got online and through the magic of the internet, searching here and there, mapping this and that, I got connected with the Salvation Army Kitchen in Downtown Phoenix. They said they would be happy to have our leftovers, if we could bring them down. We dispatched two of the volunteers, and an hour later, they were back with reports of some very happy people from the Salvation Army. I'm not sure how many boxed lunches were left over, but I know it was enough to feed a small dining hall. Much better than letting it go to waste.
Around 5:15 I went into each session for a 10 second interruption. My goal was simply to remind people to fill out their evals, and leave them at the front door as they exit for the day. (Yes, 5;15 -- we had sessions up until 6pm).
As promised, here are the evaluation numbers that we we're able to crunch. At our best count, we had between 297 and 315 attendees. We received back 161 evaluations. Here are the details.
Question :: Would you attend another CodeCamp in the Future?
Question :: What technologies to you use on a day-to-day basis.
- 60.9% SQL
- 46.0% HTML
- 45.3% ASP.NET
- 42.2% C#
- 37.3% JavaScript
- 32.9% CSS
- 24.8% Visual Basic
- 19.9% Java
- 18.0% Other
- 9.9% PHP
- 9.9% Perl
- 8.1% Ruby
- 6.2% Flash
- 3.1% Python
- 3.1% ColdFusion
Question :: Favorite Session
- 14.9% Form Follows Function: CSS and Web Standards
- 6.2% Ruby on Rails
- 5.6% C# 3.0
- 5.0% T-SQL 2005 Enhancements, Tricks and Tips
- 4.3% Schrodinger's Hack - Removing Uncertainty from Application Security
- 3.1% Intro to Cryptography
- 3.1% Mastering Code Snippets
- 2.5% Introduction to Atlas
- 2.5% An Introduction to the Ruby Programming Language
- 2.5% CMS 101: DIY Website in minutes using Joomla!
- 2.5% Introduction to Agile/Extreme Programming
- 2.5% Web Parts in ASP.NET 2.0
- 2.5% Using AjaxPro.Net
- 1.9% Creating Custom Controls for ASP.NET 2.0
- 1.9% Holding the Web on Your Shoulders with Atlas
- 1.9% WCF Design Patterns
- 1.9% Writing CLR Stored Procedures in SQL 2005 using C#
- 1.9% Introduction to WCF
- 1.9% WCF Deep Dive
- 1.9% What makes Ruby different
- 1.9% Performance and scalability enhancements from ADO.NET 2.0
- 1.9% Regular Expressions
- 1.9% URL Rewriting with ASP.NET
- 1.9% .NET Security
- 1.9% Introduction to Crystal Reports
- 1.2% Creating a Firefox extension
- 1.2% Application Development Principles and Best Practices
- 1.2% Enterprise Library Overview
- 1.2% Bob Villa meets the Web - building a Provider foundation
- 1.2% An introduction to Windows Workflow Foundation
- 1.2% Xbox Mods 101
- 1.2% An introduction to Java and Object Oriented Programming
- 1.2% LDAP Directory Programming with AD and .NET
- 1.2% Location Based Services in J2ME
- 1.2% .NET Coding Standards & Best Practices
- 0.6% An introduction to DirectX
- 0.6% Building the Next Generation Enterprise Service Bus on the Microsoft Platform
- 0.6% An introduction to Coldfusion MX
- 0.6% Developing a Hosted HTML Application for Windows Media Center
- 0.6% Exception Handling Block
- 0.6% Intro to the Revolution 3D game engine
- 0.6% Genetically Networked Architecture
- 0.6% Securing ASP.NET User and Web Service
- 0.6% XML Inside SQL Server
- 0.6% Introduction to BizTalk Server 2006
- 0.6% NetBeans IDE
- 0.6% SQL Server - When to break the rules
- 0.6% Generating GIF, PNG, and JPG images with GDI+
- 100.0%
We also had a space for general comments, and a space for future CodeCamp improvements. These are all positive comments, and some things we could have done better. Some of these comments were better room signage, better schedule timing, and better marketing of the event. All of which will be integrated into our next event.
Congratulations to everyone that volunteered to pull off this great event. And special thanks goes out to UAT for giving us there facility for the day. We couldn't have done this without you.
We're going to get started planning our next CodeCamp in the coming weeks. It only gets better from here.
At my User Group meeting last night, I presented on Atlas, and more specifically the control extenders.
Here is a control extender that I wrote for the example, and I think it's a nice little simple control, that is worthy of learning from. First I wrote the sample extender "Disabled Button" that is shown on the Atlas site. From that code, I wrote this control extender. The extender uses a label and a textbox, we watch the TextBox onkeyup event, and then write the length of the text entered in the textbox to the label.
The extender is built with three properties.
- TargetControlId (which is a default property, not one I added) that points to the textbox
- TargetLabelId is a custom property that I added, and it points to the label
- OutputFormat is the final property that asks the user for a string.format like approach to not hardcode the text output.
The finished asp.net code looks like this.
1: <asp:TextBox ID="TextBox1" runat="server" TextMode="MultiLine" Rows="5" Columns="50"></asp:TextBox><br />
2: <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
3:
4: <cc1:textboxcounterextender id="TextBoxCounterExtender1" runat="server">
5: <cc1:TextBoxCounterProperties
6: OutputFormat="{0} Chars" 7: TargetControlID="TextBox1" TargetLabelId="Label1" />
8: </cc1:textboxcounterextender>
The finished screen looks like this. See the 0 Chars? That's because nothing is typed in, as you type, the count updates itself.
Once you type, it'll look like this.
Here are the steps I followed.
First, you have to have the April CTP of Atlas installed, along with the Control Toolkit.
Once this is done, create a project that is of the type "Atlas Control Project" and Name it TextBoxCounter.
Once this is done, the Atlas Control Project template, will create 4 files for you.
These fiels are already stubbed out for you, with great comments on what to do, to get your control extender built. The majority of the work is done in the javascript file, so we'll save that for last.
The designer file, is used for visual studio design support. Remember that an extender is just a server control. It's job is going to be to wire up the control you point it at, and create some javascript that outputs to the page. So my extender targets a textbox. Remember we're watching the textbox (with a client side event) so the textbox is our target control.
Here is my finished TextBoxCounterDesigner.cs file
1: using System.Web.UI.WebControls;
2: using System.Web.UI;
3: using Microsoft.AtlasControlExtender;
4: using Microsoft.AtlasControlExtender.Design;
5:
6: namespace LearnAtlasExtenders
7: { 8: class TextBoxCounterDesigner : ExtenderControlBaseDesigner<TextBoxCounterProperties, TextBox>
9: { 10:
11:
12: }
13: }
The only change I had to make to this file, is line 8, which originally targets a generic "control", and I changed it to TextBox.
I had to make the same/similar changes to the TextBoxCounterExtender.cs file
1: using System.Web.UI.WebControls;
2: using System.Web.UI;
3: using System.ComponentModel;
4: using System.ComponentModel.Design;
5: using Microsoft.AtlasControlExtender;
6:
7: #region Assembly Resource Attribute
8: [assembly: System.Web.UI.WebResource("LearnAtlasExtenders.TextBoxCounterBehavior.js", "text/javascript")] 9: #endregion
10:
11:
12: namespace LearnAtlasExtenders
13: { 14: [Designer(typeof(TextBoxCounterDesigner))]
15: [ClientScriptResource("TextBoxCounter", "TextBoxCounterBehavior", "LearnAtlasExtenders.TextBoxCounterBehavior.js")] 16: public class TextBoxCounterExtender : ExtenderControlBase<TextBoxCounterProperties, TextBox>
17: { 18: }
19: }
Next is to create our customer properties in TextBoxCounterProperties.cs
1: using System.Web.UI.WebControls;
2: using System.Web.UI;
3: using System.ComponentModel;
4: using Microsoft.AtlasControlExtender;
5:
6: namespace LearnAtlasExtenders
7: { 8: // TODO Set this to be your default extender property name
9: //
10: [DefaultProperty("TargetLabelId")] 11: public class TextBoxCounterProperties : TargetControlPropertiesBase<TextBox>
12: { 13: [IDReferenceProperty(typeof(Label))]
14: public string TargetLabelId
15: { 16: get { return GetPropertyStringValue("TargetLabelId"); } 17: set { SetPropertyStringValue("TargetLabelId", value); } 18: }
19:
20: public string OutputFormat
21: { 22: get { return GetPropertyStringValue("OutputFormat"); } 23: set { SetPropertyStringValue("OutputFormat", value); } 24: }
25: }
26: }
You can see here, we're creating two properties, each wtih a get and set routine. The SetPropertyStringValue and GetPropertyStringValue are methods built into the base class, we don't have to create them, just use them.
Finally, our .js file -- TextBoxCounterBehavior.js
1: Type.registerNamespace('LearnAtlasExtenders'); 2:
3: LearnAtlasExtenders.TextBoxCounterBehavior = function() { 4: LearnAtlasExtenders.TextBoxCounterBehavior.initializeBase(this);
5:
6: // TODO : (Step 1) Add your property variables here
7: //
8: var _TargetLabelId;
9: var _OutputFormat;
10:
11: this.initialize = function() { 12: LearnAtlasExtenders.TextBoxCounterBehavior.callBaseMethod(this, 'initialize');
13:
14: this.control.element.attachEvent('onkeyup', Function.createDelegate(this, this._onkeyup)); 15: this._onkeyup();
16: }
17:
18: this.dispose = function() { 19: LearnAtlasExtenders.TextBoxCounterBehavior.callBaseMethod(this, 'dispose');
20: }
21:
22: this.getDescriptor = function() { 23: var td = LearnAtlasExtenders.TextBoxCounterBehavior.callBaseMethod(this, 'getDescriptor');
24:
25: // TODO: (Step 2) Add your property declarations here.
26: //
27: td.addProperty('TargetLabelId', String); 28: td.addProperty('OutputFormat', String); 29: return td;
30: }
31:
32: this.get_TargetLabelId = function () { 33: return _TargetLabelId;
34: }
35:
36: this.set_TargetLabelId = function(value) { 37: _TargetLabelId = value;
38: }
39:
40: this.get_OutputFormat = function () { 41: return _OutputFormat;
42: }
43:
44: this.set_OutputFormat = function(value) { 45: _OutputFormat = value;
46: }
47:
48:
49: // These are helper functions for communicating state back to the extender on the
50: // server side. They take or return a custom string that is available in your initialize method
51: // and later.
52: //
53: this.getClientState = function() { 54: var value = LearnAtlasExtenders.TextBoxCounterBehavior.callBaseMethod(this, 'get_ClientState');
55: if (value == '') value = null;
56: return value;
57: }
58:
59: this.setClientState = function(value) { 60: return LearnAtlasExtenders.TextBoxCounterBehavior.callBaseMethod(this, 'set_ClientState',[value]);
61: }
62:
63: //custom behavior
64: this._onkeyup = function() { 65: var lbl = document.getElementById(_TargetLabelId);
66: var regex = /\{0\}/g; 67: lbl.innerHTML = _OutputFormat.replace(regex, this.control.element.value.length);
68: //lbl.innerHTML = _OutputFormat.split("{0}").join(this.control.element.value.length); 69: }
70:
71: }
72:
73: LearnAtlasExtenders.TextBoxCounterBehavior.registerSealedClass('LearnAtlasExtenders.TextBoxCounterBehavior', Microsoft.AtlasControlExtender.BehaviorBase); 74: Sys.TypeDescriptor.addType('TextBoxCounter', 'TextBoxCounterBehavior', LearnAtlasExtenders.TextBoxCounterBehavior);On lines 8,9 we define our javascript holder properties.
On lines 14-15 we wire up on onkeyup event to this.control, which is the TargetControl, which is the TextBox we point our extender at.
On lines 27-28 we add our properties to the base method (decalred on line 23
On lines 32-46 we write javascript get/set routines for our 2 properties
And finally on line 64-69 we write our onkeyup function, that changes the label text with a javascript routine. (Special thanks to my user group meeting, who helped my put this together with a regex replace as seen on lines 66-67, I originally had a javascript .split().join() routine that worked, but their solution was more elegant, so mine's commented out).
Save All.
Compile
Set a reference in your web project, to this control extender project
Add the extender to your tool box, and you'll forever have an extender that is easy to use, that will count the length of the text in a textbox.
Hope this helps as a good introduction to building custom control extenders.