As a web developer, it is very common to have the need for an image server. Usually the requirement is pretty straight forward: We need to dynamically re size an image. This is very common when you display thumbnails and regular size pictures in a site.

Personally, I also like to have a single source image; that way, I don’t have to create all the sizes I need before hand. But most importantly, if I need a new size in the future I don’t have to create that new size for all the images I already have.

When working on enterprise environment, people tend consider only solutions by big companies which tend to be pretty expensive. People that can’t afford these solutions try to create the component them selves, which can be very time consuming (if done correctly).

I’ve been u sing Spry Photo for a while (http://www.spryphoto.com/). You can see it in action in http://www.clickclassified.ca and http://www.storybank.com.

With Spry Photo, I get all that I need for image resizing and more… All of it for a very reasonable price. In addition to resizing, it provides cropping,  image conversion, variant quality (affects image sizes) and text overlay (a great way to protect your content).

The integration with ASP.Net which is very simple and straight forward… I noticed they now have a PHP version which I haven’t tried.

TIP

In my integration of this product I added an extra step, I generated a CustomControl that inherits from the Image control. This control receives a source url but also an Alias. This alias is translated inside the control to the properties requried by the image server to generate my image.

In my case, I keet the Aliases in the database, but this is just one or many possible implementation. In any case, having the combination of the custom control and alias allows me to have something like this:

<cc:PortalImage id=”image” runat=”server” src=”/UserPicture.JPG” Alias=”Thumb” />

and translate it into:

<img src=”http://www.storybank.com/ImageServer/SpryIS.aspx?img=../UserPicture.JPG&cell=40,40,0xffffff&qlt=90&cvt=jpg”>

Doing this will save you time, and if done correctly you can re-use it in upcoming projects.

I hope you find this helpfull.

-Ricardo

I recently had the need to interact with Oodle as a way to feed a classified site.

I was suprise to see that while they had php and java libraries/samples already available, but they did not have a .Net one. I searched on their forums and on the web and did not find a library I could use.

Since I had to interact with the api, I decided to make a library, and publish it as an open source component so other developers can use it.

 You can find the library at: http://www.codeplex.com/oodlenet; all the references, source code & samples are included in the workspace.

 I hope this helps!

On October 29-07, I attended the real development event in Toronto presented by Jean-Luc David. I found this event interesting because it was really targeted at developers; it was mainly all demos, and the best part is that they showcased some interesting tools to help us develop better sites.

Not all of the tools shown where new to me, but they were used in a way made those tools that I was already using even more useful. Important to notice that the majority of the tools are free.

 I plan to present here a summary of all the tools they used, with a bit of description. I believe this will be helpful to the development community that couldn’t attend to the event.

Security
Threat Analysis & Modeling –> This tool allows you to run an attack library against your web site, locate possible threats and suggest solutions

IE ActiveX Analyze –> Locates and identifies ActiveX controls on your web site, including objects, applets and embeds tags in your code

Accessibility
Built in Visual Studio 2005. This one I hadn’t use before and for sure will start using it. To use it go to Tools–>Check Accessibility… while on Design view of a page or user control. The tool will analyze the page and generate warnings. This checks for things like images without alternate code.

WebXACT. Checks accessibility on an already published web site. Is pretty easy to use, go to the site and enter the URL you would like to check; you’ll be presented with a report with the warnings/errors found.

http://validator.w3.org/ –> Checks the markup validity of web documents (HTML, XHTML, Etc). Simply enter your URL and start fixing

Development Blocks
Personally I have used the 3 resources presented for development:

Enterprise Library(now in version 3.1), is a set of reusable, extensible development blocks, developed by the community with MS support that allow developers to focus on application specific development. Personally I have used: the Data Block, Caching Block and Logging Block.

ASP.Net Ajax is a open source framework developed by MS to make Ajax development easier.

Ajax Toolkit is a community developed library of reusable AJAX controls for ASP.Net.

Performance
There are a few ways to improve performance: Only post back what is needed (use ajax), only use the view state when required, use caching when possible, use session state if possible, etc.

Web App Stress Test Tool –> This tool I have been using for a quite some time; and while is not by any means an enterprise QA tool, it does help a lot. With this app you will be able to test your web site by simulating many concurrent users.

However, what was most interesting for me was that the presenter used it to measure the size of the pages. By doing that, he was able to compare the performance and the bandwidth usage of pages with/without view state.

Drip Leak Detector -> Using this tool you will be able to see exactly how much memory is used when you do an action on your site. Is very good to debug a site that you know is generating a memory leak but you don’t know where the leak is.

Debug View –> MS Tool that allows you to see the debug output on any computer you can reach by TCP/IP. It is very useful to debug production sites, but bear in mind that the site must have been written with this in mind to be able to get any results: That is, you need to include debug.write type of lines where ever you want to report something back.

Well, that is the extend of my notes. I hope this is helpful!

Overview 

By now, you are probably familiar with Facebook and what it is; in fact, chances are that you are already addicted to it. In their own words, Facebook is a social utility that connects you with people around you.

The success of this site is a great example of Web 2.0: we have passed from being strictly consumers, to become great contributors of the Internet content. On Facebook, users can publish almost everything: posts (editorials), photos, videos, create groups and even create classified ads.

Facebook started as a school-only site; but since opening the site to everyone, they have experienced and continue to experience very impressive growth, with an even more impressive user engagement. Let’s look at the numbers: 

• Has 43 million active users, with the number doubling every 6 months!
• 50% of users return to the site at least once a day.
• A typical Facebook user is 25 years or older.
• 5th site in number of Page views
• 1st photo site

Impressed yet? Well, lets see the numbers for in Canada in, one of the countries with greatest reception of Facebook:

• 6 million active users (1 in ever 5 Canadians!)
• 9 out of the top 30 cities (in terms of memberships) are Canadian including
  • #2 for Toronto (with 800.000) users
  • #3 Vancouver

 In fact, a Development Camp series (2 conferences) hold in Toronto in August and October respectively, drew crowd of 1000 people in total.

New, Exciting Opportunities

 The opportunities to reach the Facebook users market goes beyond the regular advertising models or self promoting via community content.

Facebook has given 3rd party companies the ability to create applications that gives them immediate potential access to massive audiences; not only that, they allow developers and companies to monetize on their applications!

They have created a model where they have given the developer community the power generate applications used within Facebook; in my opinion this is a great idea: getting thousands of people thinking about and generating applications with fresh ideas and at an amazing rate.

Granted, not all the applications are great, but a more few are good or great; and those are enough to addict us further, increasing our engagement with Facebook.

So, with such a massive audience, is no surprise to find business of all sizes looking for ways to reach the Facebook’s users with their own applications. Big corporations such as Telus and Red Bull already run applications; and even banks are interested, in order to reach a younger market TD Canada Trust has announce it will develop an application .

What does this mean? This basically means, that you can create a web site, that will reside within Facebook, will have immediate access to a subset of Facebook’s data and will have the potential to reach big audiences.

How are people using this?

Companies are using this opportunity to do several things:

• Have their Facebook application complement their Web Site offerings.
  • Sample: Jobster for example allows users to upload their resume, which is integrated into their regular site.
• Draw traffic to your site, by creating an interactive, fun and useful application on facebook, that have links to your site.
• Increase Brand Awareness; I would say this is the case of Telus, they have created a fun application where they promote their brand, services and promotions.
• Have stand alone applications: developers and companies have generated brand new applications tailored specifically for Facebook and it’s social aspect.

One thing to mention is that your Facebook application should be aligned with your overall business strategy; unless you are doing a brand new application only for Facebook.

There is still more to discuss in the subject, but this post is getting rather long. I’ll do a second post on the following topics:

• Applications Integration Points
• Characteristics of Succesful Applications
• Promoting your Application.

As a Web Developer, I’ve frequently have had the need to make asynchronical function calls.

Usually, you need to do async calls when:

• Function takes a long time to process
• There is no need to present a response to the user

In this example, I will be showing some code I use on my Facebook Application (Network Trotters) to update the users profiles.

As a quick contextual background, user profiles are cached on Facebook’s side, and periodically I need to clear the cache so it is updated. This action can take a bit of time when you have a high number of users, but it doesn’t really require any response to the user.

There are 3 main things you need to do to create an async call:

1. Create a delegate with the signature you would like
2. Implement a Function with the same function as the delegate
3. Call the delegate

Create a delegate

public delegate void AsyncDelegate(FacebookService fbService, string connectionString);

With the code above, I hve created an async delegate that takes 2 parameters, an FacebookService class (see references below), and a connection string.

Implement a Function

The next step if to implement the function we want to call, as shown in the code below:

public void RefreshProfiles(FacebookService fbService, string connectionString)
{
try
{

//get users ids
foreach (string userId in userIds)
{
//refresh the profile url
fbService.RefreshRefUrl(string.Format("{0}?uid={1}", Resources.FbAppSettings.ProfileHandlerUrl, userId));
}
}
catch
{
//ex management.
}
}

This particular call is refreshing a previously set URL from Facebook’s cache. This is how I manage to refresh profiles. I call this function periodically. I keep a cache with the last time I ran it, and that way I control how often I want it to run.

Check out my previous post for more info on Facebook Profile Management.

Call Function

// Create the delegate.
AsyncDelegate refreshProfileDelegate = new AsyncDelegate(profileRefresher.RefreshProfiles);

// Initiate the asychronous call.
IAsyncResult ar = refreshProfileDelegate.BeginInvoke(fbService, connectionString, null, null);

First step is to create a delegate,and as an input you put the previously created function.

Second step is to invoke the delegate you just created. In this example I do not receive anything back from the function, so I send callback and object as null.

References

To get more information about check out:

• Facebook Developer Toolkit .Net for documentation on the wrapper used in this post
• Network Trotters: Facebook Application

Complete Code

//Deleage definition
public delegate void AsyncDelegate(FacebookService fbService, string connectionString);

public class ProfileRefresher
{
public ProfileRefresher()
{
}

public static void Run(FacebookService fbService, string connectionString)
{
//if is null we need to update
if (HttpContext.Current.Cache["UpdateProfiles"] == null)
{
ProfileRefresher profileRefresher = new ProfileRefresher();

// Create the delegate.
AsyncDelegate refreshProfileDelegate = new AsyncDelegate(profileRefresher.RefreshProfiles);

// Initiate the asychronous call.
IAsyncResult ar = refreshProfileDelegate.BeginInvoke(fbService, connectionString, null, null);

//we set the cache
HttpContext.Current.Cache.Add("UpdateProfiles", true, null,
DateTime.Now.AddMinutes(60),
Cache.NoSlidingExpiration, CacheItemPriority.High, null);
}
}

public void RefreshProfiles(FacebookService fbService, string connectionString)
{
try
{
//Get user Ids -
foreach (string userId in userIds)
{
fbService.RefreshRefUrl(string.Format("{0}?uid={1}", URL_STATIC, userId));
}
}
catch
{
//ex management.
}
}
}

Originally written on June 2006 

This message is relevant to all of us who build ASP.Net applications that are being deployed into a Web Farm/Garden. A small modification will have to be done in the web.config to avoid view state inconsistencies.

The problem is that the ViewState on ASP.Net pages are encoded based on a Key. By default an application will use the key on the machine.config file, which is auto generated, thus, different in every machine (server). If an application runs in a web farm, then there is a potential of having inconsistencies in the way the ViewState is encoded/decoded.

The solution is to set a the key used for encoding in the web.config… and setting it to a static key. This way all the encoding/decoding of the ViewState will be done with the same Key, and there will be no problems. Plus the Key will have an application scope, instead of a Server scope (which has when uses the machine.config).

The setting in the web.config is something like this (the one below is an example only):

<system.web>
  <machineKey validationKey=”21F090935F6E49C2C797F69BBAAD8402ABD2EE0B667A8B44EA7DD4″  decryptionKey=”261F793EB53B761503AC445E0CA28DA44AA9B3CF06263B77″ validation=”SHA1″ />
  <!– OTHER SETTINGS –>
</system.web>

It is recommended to have different key setting for each application. Here are a key generator:

Machine Key Generator

So, basically, if our application is on a web farm, or we think it will be, it is recommended to add a machine key section in our web.config.

Originally written on April, 2006 

ASP.Net 2.0 has introduced a few new different concepts in regards of dll generation and deployment.

 In ASP.Net 1.x, all your class files would get compiled into 1 dll and that was it. In the new world there are actually 3 options:

1.  You release everything including class files and they get compiled on the fly. This means nothing of the web application gets copied to the bin folder.
2. You release only binaries. Everything, including ASPX pages are pre-compiled (If you open the ASPX file after the compilation you can’t see your client side code). This means everything is in the bin folder, pretty much one precompiled file per file in your application.
3. A mix of the 2 above (and the most similar to ASP.Net 1.x). Every class gets compiled, but ASPX pages remain normal. Even in this scenario, multiple dlls get generated per project. 

One of the main challenges here is the version management; you can not implicitly assign versions (no AssemblyInfo.cs in web apps), plus there are multiple assemblies generated.

However, there is a command that will merge all your dlls (per application) into one, applying versions, signatures, etc. The utility command is called aspnet_merge.exe. It is important to know what it does, but notice that we won’t have to use it directly as Microsoft has now released it as an Add-On for Visual studio.

The Add-On is really easy to use, and I would recommend we all get familiar with it. You can get it here: http://msdn2.microsoft.com/en-us/asp.net/Aa336619.aspx

In this post I will discuss how I implemented the Profile Management for Network Trotters .

Profile Management Generals

As an application developer, you get the opportunity to place some information in the user profile page. Specifically you can set a Profile Action (link below the Profile Pic) and a Profile Box.

In your application you basically tell the Facebook platform where it should get the FBML/HTML that defines both the Profile Action and Profile Box. It is important to notice, that Facebook will Cache this FBML/HTML, until you specifically tell them to refresh it.

So in summary, you set the user Profile from your application, but you have to build a mechanism to refresh the users profile periodically.

Context

I am using the Facebook Development Toolkit as the Facebook Platform API wrapper; and the profiles are set by using Urls.

.Net Implementation (one of many)

In my implementation, the profile management contains 3 main components:

• Profile Content Page
• Setting a user profile
• Refresh the profile

Profile Content Page

In this component you generate the combination of FBML and HTML that will be passed to Facebook. Please note that only a subset of tags are allowed in the profile.

The following example shows part of the code I have live for Net Trotters. I set both the Action and the Profile box (the code has been re-factored for display purposes), notice that all the code below resides on the same page:

<!–Sets the Action Link –>
<fb:if-is-own-profile>
    <fb:profile-action url=’<%= GuestTrotterLink %>’>
        Guest Trotters (<%= GuestTrotters %>)
    </fb:profile-action>
</fb:if-is-own-profile>
<!–Sets the Profile Box–>
<!– trotter information (to long to attach) –>
Last Updated: <%= CurrentDateTime %>

I left the Last Update  section intentionally, it is important to the user to know how old is the information he is looking at. It will be also good for the developer for debugging purposes.

Setting the Profile

Most of the applications have an specific landing page for the people that just installed the app, this will be the best place for you to set up the profile for the first time. If you don’t have a landing page, simply put it on the default page of you app.

In my appI use URLs as identifiers for the Profile content, but I believe the idea works as well with Handlers. To set the users profile you include the following code:

FBService.SetFBML(string.Format("<fb:ref url='{0}?uid={1}' />", ProfileContentUrl, FBService.UserId));

Where “ProfileContentUrl” is the url of the page you created with the code above, and the ”FBService.UserId”  is the user if of the Logged In user.  Notice that for Facebook the entire URL (including the querystring) becomes a key to the cache content it generates.

At this point you have successfully set up a relationship between the Logged In user and a URL.  The profile Action Link and Box should now appear on the users profile page.

Refreshing the Profile

Now that you have set up the URL for the user, you need to update it. It is not a good idea to rely on the any single user coming back to the site, because you don’t know when that is going to happen.

My idea was to update profiles every 15 minutes, to do so, I keep the last updated time on my application’s cache, and set the expiry to 15 minutes. Every time someone goes in the application, the function gets called, if its is time to refresh the urls, it does it.When is time to refresh profiles, all you need to do is call the refresh function, which takes the Facebook Cache Key (remember, is the entire URL). The function contains the following code:

if (HttpContext.Current.Cache["UpdateProfiles"] == null)
{
List<string> userIds = dbTrotter.GetTrotterOwners();
foreach (string userId in userIds)
{
fbService.RefreshRefUrl(string.Format("{0}?uid={1}", ProfileContentUrl, userId));
}
//we set the cache
HttpContext.Current.Cache.Add("UpdateProfiles", true, null, DateTime.Now.AddMinutes(15, Cache.NoSlidingExpiration, CacheItemPriority.High, null);
}

In the code above I loop through all my users refreshing their URL, which basically indicates Facebook to clean the cache for that URL; next time the URL is requested,  it will get it from the profile handler.

That is it, you now build your Profile Content Page, you set the profile for the first time, and you updated it periodically!

References

To get more information about check out:

• Facebook Developers for reference on FBML and what is allowed in a profile.
• Facebook Developer Toolkit .Net for documentation on the wrapper used in this post

NOTE: Once your application gets decent numbers of users, you will need to call the function above asynchronously so the user doesn’t have to wait until the request is done. Because this post is getting a little long; I’ll do a different post about calling functions asynchronously.

Hey!

After much procrastinating, I have finally decided to start my blog to talk about my experiences, both professional and personal.

 The main subject will be software development in Microsoft’s Technologies; the intent is to share my experiences so I can collaborate to the community of .Net developers out there.

I run my own Software Development company  (Web Nodes), so I encounter many different challenges daily; most likely other developers are running into the same kind of issues… For a while now I have been only consumer of information: it is time to start giving back

Feel free to suggest any topic, I’ll do my best to provide you with insights or samples if possible.

Let’s blog!