Monitoring directories for files that are generated by an engineering program
In this case, it would likely not make a difference. It is one call into the standard library that does a string operation that produces a short lived variable. If you want to know the correct answer, you should profile the code with real data to see what performs better.

If you don't care enough to profile it, do whatever lets you sleep better at night.



An optimization that you can do to speed up the code is change the if clauses.


In both cases, you execute NormalizePath(Path.GetDirectoryName(e.FullPath)).

This can be done once, then use the result in the string comparison of the if clause.
Perform the check of e.ChangeType first.

If the type doesn't match, you don't need do any path manipulation. Simply moving that check to the left side of the &amp;&amp; instead of the right means the boolean expression can short circuit after a cheap operation before doing the expensive one. Also, since both cases are checking for the same type, you can pull the whole check out to an outer if block.
Do this.failFolder or this.successFolder change?

If not, you can store the normalized path as a instance variable and not perform the operation each time.




The IOException is being handled in the same way and (it appears that) CopyToDestination() is the only thing that would cause it. You reduce this down to one try catch instead of two.



In general, you shouldn't be commenting your if clauses. If the boolean expression is complicated enough that it needs to be described, it should be extracted into a function with a descriptive name. In theses cases, the check being performed is straight forward.



Throw that all together and you get something like this:

if (e.ChangeType == WatcherChangeTypes.Created)
{
    var normalizedPath = NormalizePath(Path.GetDirectoryName(e.FullPath));
    try
    {
        if (normalizedPath == this.normalizeSuccessFolder)
        {
            string fileExtension = Path.GetExtension(e.FullPath);
            if(this.successDictionary.ContainsKey(fileExtension))
            {
                CopyToDestination(this.successDictionary[fileExtension], e);
            }
        }
        else if (normalizedPath == this.normalizeFailFolder)
        {
            activeLog.WriteLineToLog(e.FullPath + " has been added to the fail folder.");
            string fileExtension = Path.GetExtension(e.FullPath);
            if (this.failDictionary.ContainsKey(fileExtension))
            {
                CopyToDestination(this.failDictionary[fileExtension], e);
            }
        }
    }
    catch (IOException ioe)
    {
        activeLog.WriteLineToLog("FolderMonitor IOException: " + ioe.Message);
    }
}


Edit:

Extracting common code into a method as pointed out by ChrisWue. There is still a repeated pattern there, but with just two cases, it isn't needed to abstract it more.

Had to make an assumption about the dictionary type and make up a name for the type of e. Even though this code doesn't care if the copy is attempted, I added a boolean return to indicate if it did. I also switched to using TryGetValue() instead of indexing into the dictionary twice.

private bool AttemptCopyToDestination(IDictionary&lt;string,string&gt; knownExtensions, SomeTypeName e)
{
    string fileExtension = Path.GetExtension(e.FullPath);
    string destination;
    if (knownExtensions.TryGetValue(fileExtension, out destination)
    {
        CopyToDestination(destination, e);
        return true;
    }
    return false;
}

// ...

if (e.ChangeType == WatcherChangeTypes.Created)
{
    var normalizedPath = NormalizePath(Path.GetDirectoryName(e.FullPath));
    try
    {
        if (normalizedPath == this.normalizeSuccessFolder)
        {
            AttemptCopyToDestination(this.successDictionary, e);
        }
        else if (normalizedPath == this.normalizeFailFolder)
        {
            activeLog.WriteLineToLog(e.FullPath + " has been added to the fail folder.");
            AttemptCopyToDestination(this.failDictionary, e);
        }
    }
    catch (IOException ioe)
    {
        activeLog.WriteLineToLog("FolderMonitor IOException: " + ioe.Message);
    }
}