Now I’ve found the resolution and it’s so easy it’s stupid, just undo your changes. That’s right, go on, right click your solution and select Undo Pending Changes

You’ll see see the Undo Pending Changes dialog, make sure you only select edited files (e.g. uncheck add / delete actions), then go ahead and click Undo Changes.

Now the catch is TFS will go ahead and undo the checkout for any unmodified files, when it hits a modified file it’ll prompt you with Confirm Undo Checkout, select No to All.

TFS will continue to undo all unmodified files but leave your modified files alone, now you’re left with only your modified files checked out. Hooraah.

I couldn’t find a good tutorial anywhere for doing this so here’s how I stumbled through it.

1. Create a shelveset of your current working copy
   File > Source Control > Shelve Pending Changes
   Uncheck ‘Preserve pending changes locally’. This sill undo all your pending changes.
2. Create branch
   One way to do this is go to the Team Explorer tab > Source Control. Right click on the branch, trunk or root folder and select Branching and Merging > Branch.
   In Branch From Version, select By Workspace Version.
3. Map branch to a working folder
   Right click on new branch and select Map to Local Folder.
4. Unshelve your changes to the new branch
   To do this you need TFS Power Tools ‘unshelve’. More info here:
   http://geekswithblogs.net/TarunArora/archive/2011/06/06/unshelve-shelveset-created-from-one-branch-to-another.aspx

You can can now check in your changes to the new branch

Features

ToolBucket contains the following features:

• Multi-line search and replace dialog.
• Change indentation dialog.
• Generate GUID
• Generate Lorem Ipsum
• Compute MD5 Hash
• Compute SHA1 Hash
• Base 64 encode
• Base 64 decode

Download

The latest version is available here:
https://github.com/phdesign/NppToolBucket/downloads

Installation

Copy the NppToolBucket.dll file to your Notepad++\plugins directory.

Dependencies

Requires .NET Framework 2.0 or higher to be installed on the system.

Screenshots

// This doesn’t work as expected, it removes the relationship but not the Response entity.
Patient.Responses.Remove(Patient.Responses.Where(r => r.Id == 1));

If I try to save this, I get the error:

System.InvalidOperationException: The operation failed: The relationship could not be changed because one or more of the foreign-key properties is non-nullable. When a change is made to a relationship, the related foreign-key property is set to a null value. If the foreign-key does not support null values, a new relationship must be defined, the foreign-key property must be assigned another non-null value, or the unrelated object must be deleted.

What’s happening is the Response entity does not get deleted, just the relationship to the Patient. However when the relationship is removed, Entity Framework doesn’t know what to do with Response.PatientId, it can’t null it because it’s marked as not null.

Reading this blog post helped me understand the issue a bit more. So one solution is to make the Response entity primary key depend on the foreign key field, i.e. PatientId, this will make Entity Framework act as expected and delete the dependent entity when the relationship is deleted.

We can do this by providing the following Fluent API mapping:

modelBuilder.Entity().HasKey(m => new { m.Id, m.PatientId }); 

But if you’re not comfortable changing your database structure to suit Entity Framework there is another way. By overriding the SaveChanges method of our DbContext class, we can monitor for changes to Responses where they have been orphaned from a Patient and delete them:

public override int SaveChanges()
{
  // Need to manually delete all responses that have been removed from the patient, otherwise they'll be orphaned.
  var orphanedResponses = ChangeTracker.Entries().Where(
    e => (e.State == EntityState.Modified || e.State == EntityState.Added) &&
      e.Entity is Response &&
        e.Reference("Patient").CurrentValue == null);
  foreach (var orphanedResponse in orphanedResponses)
  {
    Responses.Remove(orphanedResponse.Entity as Response);
  }

  return base.SaveChanges();
}

In our example project we want to validate the state field is a valid Australian state if the country field is “Australia”.

IValidatableObject

Any model that implements IValidatableObject in MVC3 (note this doesn’t work in MVC2) will get it’s Validate method called when validating the object.

public abstract class ModelBase : IValidatableObject
...
public IEnumerable Validate(ValidationContext validationContext)

ConditionalValidationAttribute

To define the conditional validation we’ll use a ConditionalValidationAttribute which identifies a method to call to perform the validation. The method must be static, accept at least one parameter (the value of the property to be validated), optionally accept a second context parameter (this will be the object whose property is being validated) and return a ValidationResult.

[ConditionalValidation(typeof(User), "ValidateState")]
public string State { get; set; }
...
public static ValidationResult ValidateState(string state, object context)

ModelBase

The ModelBase class brings this all together. The constructor builds a dictionary of ConditionalValidationAttributes for each property and it implements the IValidatableObject.Validate method to loop through all the ConditionalValidationAttributes and validate them.

Note that the IValidatableObject.Validate method is called after all data annotations have been successfully validated. So if you have some properties with a RequiredAttribute, the required field error message will show and the user will need to fix this before our model’s Validate messages are displayed.

Here’s the full code for ModelBase.cs:

public abstract class ModelBase : IValidatableObject
{
  /// <summary>
  /// The list of validations for each property
  /// </summary>
  protected Dictionary<string, ConditionalValidationAttribute[]> Validations { get; private set; }

  protected ModelBase()
  {
    Validations = (from property in GetType().GetProperties()
             let validations = GetValidations(property)
             where validations.Length > 0
             select new {PropertyName = property.Name, Validations = validations})
      .ToDictionary(a => a.PropertyName, a => a.Validations);
  }

  /// <summary>
  /// Validates all ConditionalValidationAttributes
  /// </summary>
  /// <param name="validationContext"></param>
  /// <returns></returns>
  public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
  {
    return from property in Validations
         from validator in property.Value
         select validator.IsValid(GetPropertyValue(property.Key), this)
         into validationResult
         where validationResult != ValidationResult.Success
         select validationResult;
  }

  #region Private & Protected Methods

  /// <summary>
  /// Gets the validation attributes attached to a property.
  /// </summary>
  /// <param name="property">The property.</param>
  /// <returns>An array of validation attributes.</returns>
  private static ConditionalValidationAttribute[] GetValidations(PropertyInfo property)
  {
    return property.GetCustomAttributes(typeof(ConditionalValidationAttribute), true)
      .Cast<ConditionalValidationAttribute>().ToArray();
  }

  /// <summary>
  /// Gets the value for a property.
  /// </summary>
  /// <param name="propertyName">The property name.</param>
  /// <returns>The value of the property as an object.</returns>
  protected object GetPropertyValue(string propertyName)
  {
    try
    {
      return GetType().GetProperty(propertyName).GetValue(this, null);
    }
    catch (TargetInvocationException exception)
    {
      if (exception.InnerException != null)
        throw exception.InnerException;
      throw;
    }
  }

  #endregion
}

Note that when we call the ConditionalValidationAttribute.IsValid method we pass in ‘this’ as the context so we have a reference to the object being validated.

ConditionalValidationAttribute.cs:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property)]
public class ConditionalValidationAttribute : Attribute
{
  #region Fields

  private readonly MethodInfo _methodInfo;
  private readonly bool _isSingleArgumentMethod;
  private readonly Type _valuesType;

  #endregion

  #region Properties

  public string ErrorMessage { get; set; }
  public string Method { get; private set; }
  public Type ValidatorType { get; private set; }

  #endregion

  #region Constructor

  /// <summary>
  /// Performs validation by calling a specified static method with one of the following signatures:
  /// ValidationResult Method(object value)
  /// ValidationResult Method(object value, object context)
  /// The value parameter may be strongly typed, if a process passes a value of a different type, type conversion will be attempted.
  /// </summary>
  /// <param name="validatorType">The type that contains the method that performs custom validation.</param>
  /// <param name="method">The method that performs custom validation.</param>
  public ConditionalValidationAttribute(Type validatorType, string method)
  {
    if (string.IsNullOrEmpty(method))
      throw new ArgumentException("method");

    Method = method;
    ValidatorType = validatorType;
    // Find a matching method - if multiple matching methods, pick the one with 2 parameters.
    var methods = from m in validatorType.GetMethods(BindingFlags.Public | BindingFlags.Static)
            let p = m.GetParameters().Length
            where m.Name == method &&
              m.ReturnType == typeof(ValidationResult) &&
              (p == 1 || p == 2)
            orderby p descending
            select m;

    if (methods.Count() == 0)
      throw new InvalidOperationException(string.Format("No method '{0}' found in class '{1}' with a valid signature.", method, validatorType));
    _methodInfo = methods.First();
    var parameters = _methodInfo.GetParameters();
    _isSingleArgumentMethod = parameters.Length == 1;
    _valuesType = parameters[0].ParameterType;
  }

  #endregion

  #region Public Methods

  public ValidationResult IsValid(object value, object context)
  {
    object convertedValue;
    var info = _methodInfo;
    if (!TryConvertValue(value, out convertedValue))
    {
      throw new InvalidOperationException(
        string.Format(
          "Unable to convert value from type {0} to type {1}",
          (value != null) ? value.GetType().ToString() : "null",
          _valuesType));
    }
    try
    {
      var parameters = _isSingleArgumentMethod ? new[] { convertedValue } : new[] { convertedValue, context };
      var result = (ValidationResult)info.Invoke(null, parameters);
      if (result != ValidationResult.Success && result.ErrorMessage == null)
        result.ErrorMessage = ErrorMessage;
      return result;
    }
    catch (TargetInvocationException exception)
    {
      if (exception.InnerException != null)
      {
        throw exception.InnerException;
      }
      throw;
    }
  }

  #endregion

  #region Private Methods

  private bool TryConvertValue(object value, out object convertedValue)
  {
    convertedValue = null;
    Type conversionType = _valuesType;
    if (value == null)
    {
      return (!conversionType.IsValueType || (conversionType.IsGenericType && (conversionType.GetGenericTypeDefinition() == typeof(Nullable<>))));
    }
    if (conversionType.IsAssignableFrom(value.GetType()))
    {
      convertedValue = value;
      return true;
    }
    try
    {
      convertedValue = Convert.ChangeType(value, conversionType, CultureInfo.CurrentCulture);
      return true;
    }
    catch (FormatException)
    {
      return false;
    }
    catch (InvalidCastException)
    {
      return false;
    }
    catch (NotSupportedException)
    {
      return false;
    }
  }

  #endregion
}

A few notes here:

• The constructor tries to find an appropriate method using reflection. If there are multiple overloads of the method then the one with 2 parameters will be chosen.
• The first parameter of the validation method can be of any type. Type conversion is attempted on the value to validate to match the method signature. I.e. the first (value) parameter can be object, string, int, etc.
• A generic error message can be supplied to the ConditionalValidationAttribute. If the validation method doesn’t set an error message when it returns a validation error, the ConditionalValidationAttribute.ErrorMessage property will be used.

And a sample model User.cs:

public class User : ModelBase
{
  [Required]
  public int UserId { get; set; }
  [Required]
  public string FirstName { get; set; }
  [Required]
  public string LastName { get; set; }
  [Required]
  public string Country { get; set; }
  [Required]
  [ConditionalValidation(typeof(User), "ValidateState")]
  public string State { get; set; }

  public static ValidationResult ValidateState(string state, object context)
  {
    var user = context as User;
    if (user == null)
      throw new ArgumentException("context is not of type User", "context");

    var australianStates = new[] {"VIC", "TAS", "NSW", "ACT", "QLD", "NT", "WA", "SA"};
    if (user.Country.Equals("Australia", StringComparison.CurrentCultureIgnoreCase))
    {
      if (!australianStates.Contains(state, StringComparer.CurrentCultureIgnoreCase))
        return new ValidationResult("Not a valid Australian state", new[] {"State"});
    }
    return ValidationResult.Success;
  }
}

Download the example by clicking the button below.

_filteredSubmissions = (from s in _filteredSubmissions
                        group s by s.Email
                        into g
                        where g.Count() > 1
                        select new { Emails = g.Key, DuplicateCount = g.Count() }

Which will just return any email addresses that are duplicates and the count. But what if you want to list all the original items that are duplicates? If you just ‘select g’ in the example above you’ll end up with an IEnumerable<IEnumerable<Submission>>, not what we want. This is where SelectMany() is perfect, it will flatten our collection of a collection back down to a single collection, perfect!

_filteredSubmissions = (from s in _filteredSubmissions
                        group s by s.Email
                        into g
                        where g.Count() > 1
                        select g).SelectMany(g => g)

So now I want to find Submissions that have the same first and last names, I use an anonymous type.

_filteredSubmissions = (from s in _filteredSubmissions
                        group s by new { s.FirstName, s.LastName }
                        into g
                        where g.Count() > 1
                        select g).SelectMany(g => g)

And finally I want to find all Submissions that have the same first name and last name OR the same email. Simply use Union(), this will join the two collections and remove any duplicates (that’s duplicate instances of the classes, not to be confused with the duplicates we’re trying to find).

_filteredSubmissions = (from s in _filteredSubmissions
                        group s by new { s.FirstName, s.LastName }
                        into g
                        where g.Count() > 1
                        select g).SelectMany(g => g)
    .Union(
        (from s in _filteredSubmissions
         where !string.IsNullOrWhiteSpace(s.Email)
         group s by s.Email
         into g
         where g.Count() > 1
         select g).SelectMany(g => g)
    );

Note that I also stuck in a check for blank emails, I don’t consider a Submission the same just because they both have no email address, I didn’t do this on the FirstName or LastName fields because I know they are mandatory in my system.

The code I am copying from Visual Studio uses spaces for indentation, in Blend I was using tabs, this means when I paste code from VS, Blend doesn’t see any tabs to ‘unindent’.

Simple solution – make sure your Visual Studio indentation settings match your Blend settings.

Here is my original code that kept losing it’s binding:

<ItemsControl ItemsSource="{Binding Elements}" Margin="0,10,0,10">
  <ItemsControl.ItemTemplate>
    <DataTemplate>
      <RadioButton Content="{Binding Key}"
        GroupName="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type UserControl}}, Path=DataContext.Title}"
        IsChecked="{Binding Path=IsSelected}"
        Margin="0,5,0,5"/>
    </DataTemplate>
  </ItemsControl.ItemTemplate>
</ItemsControl>

There a couple of ways to solve this,

1. You can subclass the RadioButton
2. You could use OneWay binding on IsChecked to set the RadioButton state from code, then bind the Command property to a  Command when user clicks on the RadioButton.

   <ItemsControl ItemsSource="{Binding Elements}" Margin="0,10,0,10">
     <ItemsControl.ItemTemplate>
       <DataTemplate>
         <RadioButton Content="{Binding Key}"
           GroupName="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type UserControl}}, Path=DataContext.Title}"
           IsChecked="{Binding Path=IsSelected, Mode=OneWay}"
           Command="{Binding IsSelectedCommand}"
           CommandParameter="{Binding}"
           Margin="0,5,0,5"/>
       </DataTemplate>
     </ItemsControl.ItemTemplate>
   </ItemsControl>

3. My preferred option: (as suggested by karliwatson) use a ListBox for the grouping and bind the ListBoxItem’s IsSelected property to your ViewModel, then bind the RadioButton’s IsChecked property to the list box item’s IsSelected property. Don’t set a group on the RadioButton.

   <ListBox ItemsSource="{Binding Elements}" Margin="0,10,0,10" BorderThickness="0" Background="Transparent">
     <ListBox.ItemContainerStyle>
       <Style TargetType="{x:Type ListBoxItem}">
         <Setter Property="IsSelected" Value="{Binding Path=IsSelected, Mode=TwoWay}" />
         <Setter Property="Template">
           <Setter.Value>
             <ControlTemplate TargetType="ListBoxItem">
               <ContentPresenter/>
             </ControlTemplate>
           </Setter.Value>
         </Setter>
       </Style>
     </ListBox.ItemContainerStyle>
     <ListBox.ItemTemplate>
       <DataTemplate>
           <RadioButton Content="{Binding Key}"
               IsChecked="{Binding Path=IsSelected, Mode=TwoWay, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ListBoxItem}}}"
               Margin="0,5,0,5"/>
       </DataTemplate>
     </ListBox.ItemTemplate>
   </ListBox>

Below are two simple ways to log a message to a text file.

1. The simplest way if you don’t care about the format of the message is to use a filter on the trace listener in app.config to determine which events to log.

<system.diagnostics>
  <trace autoflush="true">
    <listeners>
      <add name="LogListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="trace.log" traceOutputOptions="DateTime">
        <!--
        EventTypes:
        Critical: Fatal error or application crash.
        Error: Recoverable error.
        Warning: Noncritical problem.
        Information: Informational message.
        Verbose: Debugging trace.
        Start: Starting of a logical operation.
        Stop: Stopping of a logical operation.
        Suspend: Suspension of a logical operation.
        Resume: Resumption of a logical operation.
        Transfer: Changing of correlation identity.
        -->
        <filter type="System.Diagnostics.EventTypeFilter" initializeData="Error"/>
      </add>
    </listeners>
  </trace>
</system.diagnostics>

Then you only need to call one of the following methods to log a message with a specific EventType.

System.Diagnostics.Trace.TraceInformation("Information messge");
System.Diagnostics.Trace.TraceError("Error messge");

2. If you want more control over the format of the message you can use a TraceSwitch in app.config:

<system.diagnostics>
  <switches>
    <clear/>
    <!--
    Trace Levels:
    Off: 0: None
    Error: 1: Only error messages
    Warning: 2: Warning messages and error messages
    Info: 3: Informational messages, warning messages, and error messages
    Verbose: 4: Verbose messages, informational messages, warning messages, and error messages
    -->
    <add name="LogLevel" value="Info"/>
  </switches>
  <trace autoflush="true">
    <listeners>
      <add name="LogListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="trace.log"/>
    </listeners>
  </trace>
</system.diagnostics>

Then retrieve the TraceSwitch in code as follows:

TraceSwitch logLevel = new TraceSwitch("LogLevel", "The logging level");
Trace.WriteLineIf(logLevel.Level >= level, string.Format("[{0}] [{1}]: {2}", DateTime.Now, level, message));

The examples are for a desktop application, but they would work equally well in a web application by configuring web.config. Note that web applications aren’t compiled with Trace enabled, so you need to enable them in web.config by using the following after the <system.diagnostics> node:

<system.codedom>
  <compilers>
    <compiler language="c#;cs;csharp"
      extension=".cs"
      compilerOptions="/d:TRACE"
      type="Microsoft.CSharp.CSharpCodeProvider, System, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" warningLevel="1" />
    </compilers>
</system.codedom>

The VB6 source code will be released under the GNU Lesser General Public License (LGPL), in my understanding this means that anyone can use phreplace and even include the library in a greater works (e.g. PSPad), however if they modify the code it must be released under a similar open source library, in order that everyone will benefit from the changes.

The source code is available at Assembla, feel free to send any code changes to me to be included in the project.

Architecture

I rewrote phreplace in early 2009 when I was studying design patterns and as such the VB6 source code is heavily object-oriented and pattern focused. VB6 is not strictly an oo language but it does support inheritance through the ‘Implements’ keyword.

phreplace uses the iterator, observer and factory methods. I found some of the sample chapters of Visual Basic design patterns: VB 6.0 and VB.NET By James William Cooper on Google Books a very useful resource.

This early class architecture diagram (PDF) may help decipher some of the code design.

Future Direction

phreplace was designed to be application agnostic, it currently works only with PSPad but I hoped that by implementing only a few interfaces (IHostAdapter, IDocument and IDocumentCollection) it could work with any other editor that supported the basic operations required. My next intended editor to support was SciTE.

The first major change that I would like to see is support for Vista / Windows 7. At present the phreplace.vbs script intialises the application by checking to see if the phreplace.dll library is registered, if it isn’t it tries to register it with regsvr32. This works for Windows XP but standard users aren’t able to register libraries in Vista / Windows 7. So far I have come up with 3 solutions.

1. Override DllRegisterServer using vbAdvance. I can’t get this library to work. See Registering phreplace DLL in Windows Vista.
2. Create a separate utility similar to regsvr32 and include this with phreplace. I think this is messy. Again see Registering phreplace DLL in Windows Vista.
3. Use the Registration-Free COM solution of adding a manifest file for PSPad which references the phreplace.dll library so that we don’t have to register it in the registry at all. This solution works for XP, see the reg-free-com branch of the source code, but doesn’t seem to work for Vista. My theory is that perhaps Vista handles vbscript differently, so it doesn’t inherit the PSPad manifest. If someone could get this working I think this is the most elegant solution.

I look forward to seeing user contributions to this project.