As it happens, it's just as easy to hook into exceptions in WCF as well. WCF conveniently provides us with an IErrorHandler which has aProvideFault method that's called on all exceptions. For example:

public class HttpErrorHandler : IErrorHandler
{
    public bool HandleError(Exception error)
    {
        return false;
    }

    public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
    {
        System.Diagnostics.Debug.WriteLine(error.ToString());
    }
}

We're returning false from HandleError to let WCF know that we haven't actually handled the error, so the dispatcher aborts any session (and the InstanceContext if the InstanceContextMode isn't Single).

Once we're done creating our custom error handler, we need to let WCF know to use it. In web.config, create a <behaviors>.<serviceBehaviors>.<behavior> configuration as follows:

<serviceBehaviors>
    <behavior name="myconfig">
        <logErrors />
    </behavior>
</serviceBehaviors>

Then, create the <logErrors> extension:

<extensions>
    <behaviorExtensions>
        <add
            name="logErrors"
            type="Example.ErrorServiceBehavior, Example" />
    </behaviorExtensions>
</extensions>

Then, you need to your services to use the myconfig behavior configuration with <service behaviorConfiguration="myconfig" />.

Fortunately, ASP.NET provides an easy way for us to accomplish this, via a custom IHttpModule. Essentially, the process goes as follows:

1. Start your timer in HttpApplication.BeginRequest.
2. Stop your timer in HttpApplication.EndRequest .
3. Raise an event with the request URL and the duration.

The code is amazingly simple, so here it is in its entirety:

public class RequestDurationEventArgs : EventArgs
{
    public string Url { get; private set; }

    public TimeSpan Duration { get; private set; }

    public DateTime RequestedAt { get; private set; }

    public RequestDurationEventArgs(string url, DateTime requestedAt, TimeSpan duration)
    {
        Url = url;
        Duration = duration;
        RequestedAt = requestedAt;
    }
}

public class RequestDurationLoggerModule : IHttpModule
{
    private const string _requestDurationKey = "RequestDurationKey";

    private EventHandler<RequestDurationEventArgs> _requestDurationCalculatedHandler;

    public event EventHandler<RequestDurationEventArgs> RequestDurationCalculated
    {
        add { _requestDurationCalculatedHandler += value; }
        remove { _requestDurationCalculatedHandler -= value; }
    }

    public void Dispose()
    {

    }

    public void Init(HttpApplication context)
    {
        context.BeginRequest += (sender, e) =>
        {
            context.Context.Items[_requestDurationKey] = DateTime.UtcNow;
        };

        context.EndRequest += (sender, e) =>
        {
            var end = DateTime.UtcNow;
            var start = (DateTime)context.Context.Items[_requestDurationKey];
            var url = context.Context.Request.RawUrl;

            if (_requestDurationCalculatedHandler != null)
            {
                _requestDurationCalculatedHandler(this, new RequestDurationEventArgs(url, start, end - start));
            }
        };
    }
}

The only steps remaining are to:

1. Let ASP.NET know about the module.
2. Hook into the RequestDurationCalculated and process it.

Step 1 requires adding the module to <httpModules> in your web.config:

<add name="RequestDurationLogger" type="Utilities.RequestDurationLoggerModule, Utilities" />            

Step 2 can be done in a variety of ways. Here's one that uses Global.asax:

protected void RequestDurationLogger_RequestDurationCalculated(object sender, RequestDurationEventArgs e)
{
    System.Diagnostics.Debug.WriteLine(string.Format("{0}: Requested At: {1}:{2}, Took: {3}s", e.Url, e.RequestedAt.ToLocalTime().ToShortDateString(), e.RequestedAt.ToLocalTime().ToShortTimeString(), e.Duration.TotalSeconds));
}

Visual Studio provides you with two handy projects to create WCF services: "WCF Service Application" and "WCF Service Library," in which Visual Studio automatically setups up the binding and endpoint information when you create a new "WCF Service." Once you publish the WCF app, assuming metadata publishing is enabled, you can use Visual Studio to automatically generate the proxies for your services in your client apps. The client configuration file is also updated with the binding and endpoint information.

This all sounds pretty good. So what's wrong with it?

1. You need to "Update Service Reference" every time you make a change in every project you're referencing the service. There's a not insignificant chance that this operation will fail at any given time, anyway, especially if you're under source control.
2. The configuration files look insane. Have more than one service in a project? You will see tons of duplicate information.
3. Having multiple services in a single project is a pain to deploy if you put each service in its own folder. The services have trouble finding the bin folder. ¹
4. Contracts and services are all mushed into the same project. Providing multiple implementations of the same contract is more difficult and less clean.

How to do everything manually?

You might think self-hosting WCF services is going to be complicated and convoluted, but nothing could be further from the truth. I'll give you the step-by-step in this article. Once you understand the process, you'll be able to do the whole thing in five minutes.

Let's look at an example. Say you're writing the next generation blogging software and want to use WCF services for your back-end. One of your business requirements might be to show all the posts created by a particular author. Here's what you would do:

Step 1: Create your solution structure

Create four projects: 1. Blog: class library. This is where your DTOs will live. 2. Blog.Contracts: class library. This is where your service interfaces will live. 3. Blog.Services: class library. This is where your service implementations will live. 4. Blog.Hosts: (Empty) ASP.NET web application. This is where your hosts will live. This is the project you will publish. 5. Blog.Proxies: class library. This is where your proxies will live.

Step 2: Add the appropriate references

Add the following references to the following projects: 1. Blog * System.Runtime.Serialization 2. Blog.Contracts: * System.ServiceModel * Blog 3. Blog.Services: * Blog * Blog.Contracts 4. Blog.Hosts: * Blog * Blog.Contracts * Blog.Services 5. Blog.Proxies: * Blog * Blog.Contracts

Step 3: Create your DTO

[DataContract]
public class Post
{
    [DataMember]
    public int Id { get; set; }

    [DataMember]
    public string Title { get; set; }

    [DataMember]
    public string Contents { get; set; }

    [DataMember]
    public string Author { get; set; }
}

The DataContract and DataMember attributes specify that the type and the properties are serializable.

Step 4: Create your contract

[ServiceContract]
public interface IPostService
{
    [OperationContract]
    Post[] GetPostsByAuthor(string author);
}

Nothing surprising here.

Step 5: Create your proxy

public class PostServiceProxy : ClientBase, IPostService { public Post[] GetPostsByAuthor(string author) { return Channel.GetPostsByAuthor(author); } }

Every other service will follow this same exact pattern: your proxy will inherit from ClientBase<IYourContractType> and implement IYourContractType. Each method's body will be the same: return Channel.MethodName(method arguments) for methods that return something and Channel.MethodName(method arguments) for methods that don't.

The benefit of creating your own proxy is that you get compile-time error checking. You can also reference this and the DTO DLL anywhere you're using the service, so you only need to make changes in one place instead of several.

Step 6: Create your service

Here's a sample implementation of the service that uses Linq to filter an in-memory post collection:

public class PostService : IPostService
{
    private static readonly List<Post> Cache = new List<Post>();

    public Post[] GetPostsByAuthor(string author)
    {
        return Cache.Where(x => x.Author == author).ToArray();
    }
}

Step 7: Create your host

<%@ ServiceHost Service="Blog.Services.PostService" %>

The way to do this is a little tricky. You don't want to add a "WCF Service," because then Visual Studio will create all kinds of useless configuration elements in your web.config, not to mention a code-behind for your service.

Instead, add a new text file to your Blog.Hosts project, but set the extension to be svc. Add the aforementioned line to the top of the file, and you're good to go.

Step 8: Add a service endpoint to the web.config

Lastly, you need to setup the endpoint information in web.config in your Blog.Hosts project.

<system.serviceModel>
    <services>
        <service name="Blog.Services.PostService">
            <endpoint 

address="" binding="wsHttpBinding" contract="Blog.Contracts.IPostService" /> </system.serviceModel>

This is all the configuration you need to create an endpoint using the defaults. If you want to change the defaults, you have to configure the endpoint -- either through code or through web.config -- but that's a topic for an upcoming article. For most services, default configurations should work just fine.

Set your host project as the startup project and the PostService.svc as your startup page. Run the solution, and you should see the service. ²

And that's all there is to it. Adding a new service follows the exact same process.

<ScrollViewer HorizontalScrollBarVisibility="Auto">
    <StackPanel name="contentPanel">
    </StackPanel>
</ScrollViewer>

Note the HorizontalScrollBarVisibility property on your ScrollViewer. You have to explicitly set it to Auto (or Visible) to see the horizontal scrollbar.

Steps

1. Download the webpage content using urlopen.
2. Find all links using HTMLParser: you can subclass HTMLParser and override the start_a method, which is called at the start of every link.
3. Figure out which of these link to PDFs: get the link's extension and make sure it's "pdf."
4. Ensure each PDF link is a "full path": sometimes, the link href will be of format "/blah.pdf" or "blah.pdf," so we need to take that into account.
5. Download each PDF via urlretrieve.

The code

import urllib, htmllib, formatter, os

class LinksExtractor(htmllib.HTMLParser):
    def __init__(self, formatter):
        htmllib.HTMLParser.__init__(self, formatter)
        self.links = []

    def start_a(self, attrs):
        if len(attrs) > 0:
            for attr in attrs:
                if attr[0] == "href":
                    self.links.append(attr[1])

    def get_links(self):
        return self.links

def full_links(url, links):
    full_links = []

    for link in links:
        if link.startswith("http"):
            full_links.append(link)
        elif link.startswith("/"):
            base_url_parts = url.split("/")[0:3]
            base_url = base_url_parts[0] + "//" + base_url_parts[2]
            full_links.append(base_url + link)
        else:
            filename_starts_at = url.rindex("/") + 1
            base_url = url[0:filename_starts_at]
            full_links.append(base_url + link)

    return full_links


def download(url, save_dir):
    urllib.urlretrieve(url, save_dir + os.sep + url.split('/')[-1])

def get_pdfs(url):
    format = formatter.NullFormatter()
    parser = LinksExtractor(format)
    data = urllib.urlopen(url)

    parser.feed(data.read())
    parser.close()

    all_links = parser.get_links()
    pdf_links = []

    for link in all_links:
        extension = link.split(".")[-1]

        if extension == "pdf":
            pdf_links.append(link)

    return pdf_links

def download_pdfs(url, save_dir):
    pdfs = full_links(url, get_pdfs(url))

    for pdf in pdfs:
        download(pdf, save_dir)

url = "url goes here"
save_dir = os.getcwd() 

download_pdfs(url, save_dir)

It turned out to be fairly simple. On Snow Leopard, anyway.

Step 1: create scrippt

Open the Apple Script Editor (in Applications/Utilities) and type the following:

do shell script "open -a /Applications/Google\\ Chrome.app --args --incognito"

You're basically telling shell to open Chrome, with the argument "incognito." Note the two back slashes in front of the space between Google and Chrome. Also note that "args" and "incognito" have two dashes in front of them, not one.

If you run the script, it should open up Chrome in incognito mode, assuming you don't have Chrome already open.

Step 2: save as application

Go File > Save As, and give the app whatever name you want. "ChromeIncognito," for example. Make sure that the File Format is "Application."

Drag the application onto your dock, maybe change the icon of the script to something more Chrome-looking, and you're done!

Let's look at your typical data population code:

using (var reader = cmd.ExecuteReader())
{
    while (reader.Read())
    {
        var user = new User
        {
            UserId = reader.GetInt32(0),
            UserName = reader.GetString(1),
            EmailAddress = reader.GetString(2)
        };
    }
}

If you detest magic constants as much as I do, your code might be a bit better:

UserId = reader.GetInt32(reader.GetOrdinal("UserId"));

You might have gone further and created a SafeDataReader of some sort that lowers the pain-threshold, so you can write:

UserId = reader.GetInt32("UserId");

The only problem is that you're exchanging one type of magic for another. "UserId" is definitely better than "0," but not by much. The best way to fix this is to use an ORM, of course, but that's not always possible. I thought .NET's new lambda expressions might come in useful here.

UserId = reader.GetInt32(user => user.UserId);

This looked much better than the previous version.¹

With my newfound knowledge on expressions, I thought i would give it a try. The main task is figuring out the name from the expression; I googled for a little bit, but then I remembered that FluentNHibernate had to solve the problem already for their syntax. After digging through their code, I came up with something similar for the parsing:

public class SafeDataReader<T> : SafeDataReader, ISafeDataReader
{
        private string parseName(UnaryExpression expression)
        {
            var malformedExpressionError = "Expression must be of form user => user.UserId";

            if (!(expression.Operand is MemberExpression))
            {
                throw new ArgumentException(malformedExpressionError, "expression.Operand");        
            }

            return parseName((MemberExpression)expression.Operand);
        }

        private string parseName(MemberExpression expression)
        {
            var member = expression.Member;
            var wrongDeclaringTypeError = "Member must be declared in " + typeof(T);

            if (member.DeclaringType != typeof(T))
            {
                throw new ArgumentException(wrongDeclaringTypeError);
            }

            return member.Name;
        }

        private string parseName(Expression<Func<T, object>> expression)
        {
            if (expression.Body is UnaryExpression)
                return parseName((UnaryExpression) expression.Body);
            if (expression.Body is MemberExpression)
                return parseName((MemberExpression)expression.Body);

            throw new ArgumentException(
                string.Format("Malformed expression: {0}", expression),
                "expression");
        }
}

(The SafeDataReader (non-generic) class is the same as an IDataReader, but it also implements the associated "get-by-name" methods.)

Your methods look as follows:

public bool GetBoolean(Expression<Func<T, object>> name)
{
    return GetBoolean(parseName(name));
}

Pretty simple. You can download all the files here

Now you'll be chasing bugs because somebody renamed the property but didn't change the stored procedure .... ;-)

You need:

1. The PowerShell
2. mysysgit

PowerShell

By default, PowerShell execution policy is set to Restricted (which you can check by running Get-ExecutionPolicy). default.ps1 script requires Unrestricted access:

Set-ExecutionPolicy Unrestricted

If the script runs without errors, good for you. It didn't for me. It kept dying on "git" for me. We're only using git to get the log for AssemblyInfo.cs (for compiling the solution, anyway). You can move past the error by going to the psake_ext.ps1 and commenting out this line (put a # before the line):

$commit = Get-Git-Commit

The script hopefully runs successfully at this point and create a bunch of directories under the root folder (for example, build).

Don't forget to revert your PowerShell execution policy back to Restricted (or something a little more secure).

import urllib
url_prefix = "the site url prefix here"
forum = forum number
thread = thread number
pages = range(thread_start_index, thread_end_index, thread_step)
file_prefix = "file prefix here"
page_count = len(pages)
file_suffix = ".html"

for page in pages:
    url = "thread format here" % (url_prefix,forum,thread,page)
    url_handle = urllib.urlopen(url)
    page_index = (page / thread_step) + 1
    file_page = "%dof%d" % (page_index, page_count)
    filename = "%s%s%s" % (file_prefix, file_page, file_suffix)

    file_handle = open(filename, 'w')

    for lines in url_handle.readlines():
        file_handle.write(lines)

    file_handle.close()
    url_handle.close()

def save_model(self,request,model,form,change):
    if not change:
        model.created_by = request.user
    model.save()

If this doesn't work, make sure you are developing against the latest Django version. A bug was reported and fixed 5-6 months ago, so you might already have the latest version, but make sure.