Keith's Blog https://docs.microsoft.com/archive/blogs/keithjones/feed.xml Insights on testing, Silverlight, and other stuff Wed, 17 Apr 2019 03:22:01 GMT en-US hourly 1 Developing Testable Silverlight Applications: Part One – Abstracting Data Persistence https://docs.microsoft.com/archive/blogs/keithjones/developing-testable-silverlight-applications-part-one-abstracting-data-persistence Fri, 08 Jan 2010 17:19:00 GMT https://blogs.msdn.microsoft.com/keithjones/2010/01/08/developing-testable-silverlight-applications-part-one-abstracting-data-persistence/ At Microsoft PDC 2009 I gave a talk entitled “Developing Testable Silverlight Applications”. We looked at how to use the Inversion of Control principle with the Model-View-ViewModel design pattern to isolate the dependencies within a Silverlight 4 application for easier testing. We also saw how to improve testability by taking advantage of the natural boundaries in Silverlight applications utilizing WCF RIA Services to query for data and persist units of work. There was so much material to cover during my assigned lunch hour (or rather, lunch 45-minute) session that I am going use a series of blog posts to provide more in-depth detail on the techniques I talked about.

First, I feel that I should provide a short description of my application-design philosophy.

  • Good design is a long-term investment – it is usually expensive and not necessarily cost effective for short term gains
  • Good design has many benefits – for example, improved modularity, extensibility, and testability
  • Average design and even poor design have places in the programming world but should not be used by default
  • The “right” design should be chosen through cost-benefit analysis

Abstracting the DAL’s Persistence Logic

This first entry in the series will actually be about the last demonstration in the talk since my brief explanation did not do it justice. First, let’s take a look at the problem we’re trying to solve. The following diagram shows how the WCF RIA Services components (colored blue) fit into an overall n-tier Silverlight application.

ntier

In this post we’ll be focusing on how to test the domain model without reading/writing data to/from the data store. One way you can handle this is by implementing the repository pattern to completely abstract domain services and other business logic from the Data Access Layer (DAL). The WCF RIA Services team has a sample available for that approach.

One of the benefits of that approach is that you can change your DAL mechanism if you need to. On the other hand, it is fairly expensive to implement since you have to wrap each of your collections of entities and maintain their lifetimes yourself. It looks simple enough if you have one entity type (e.g. Products), but it doesn’t scale out well for real-world domain problems (e.g. Products, Orders, OrderDetails and more).

There is definitely value in that flexibility especially if you’ll be maintaining an application over several years as technology changes around you. Looking at your past experiences however, how often have you had to change your DAL? Many applications don’t need that flexibility but they still want to decouple the business logic from the persistence of those changes for the sake of testability. To help with that, the ADO.NET Entity Framework features in Microsoft .NET v4.0 has made some huge strides. Particularly helpful for our problem, they introduced an IObjectSet<T> interface and opened up their T4 code generation mechanism for customization. The rest of this post is going to explore how to use those features with RIA Services Silverlight applications to decouple persistence in as few steps as possible.

The quickest way to get started is to download the source code for the demo app and tests I used in my talk.

Steps to use this support with your own projects

  1. Download the source files.
  2. Install Unity 1.2 and Unity 1.2 for Silverlight.
  3. Install the November 2009 release of the  Microsoft Silverlight Toolkit (for the Silverlight Unit Test Framework and Shiny Red theme that the demo uses).
  4. Include the PersistenceStrategy project in your own solution and add references to it in your Web project and Web test project.
  5. Open your edmx file so that the data model designer is showing and in the properties window change the "Code Generation Strategy" property to "None".
  6. Include the DataModel.tt file in your Web project and change the 'SourceCsdlPath = @"DataModel.edmx"' line to point to your own edmx file.
  7. In your Web.config for the Web project add a unity section like what is shown in the attached example solution (or in the explanations below).
  8. In your domain service override CreateObjectContext() to create an instance of your object context passing in the Unity-resolved IPersistenceStrategy instance. See FantasyPresentingDomainService.cs in the example solution.
  9. Update the wizard-generated code in your domain service to use IObjectSet<T> friendly API's. See the Making the domain service IObjectSet<TEntity> friendly section at the bottom of this post for details.

Continue reading for an in-depth explanation of how I abstracted data persistence.

Customizing Entity Framework code generation to use IObjectSet<T>

The IObjectSet<T> interface essentially exposes the repository pattern within the Entity Framework as the class diagram suggests below. Also, in the class diagram you can see that the Entity Framework supplies a default implementation, ObjectSet<T>, which inherits from ObjectQuery<T>.

diagram

The code generated by Entity Framework uses ObjectSet<T> by default. We would like it to use IObjectSet<T> so that any callers won’t take a dependency on a specific implementation. Entity Framework uses T4 to generate the entity and object context code for your data model and in Visual Studio 2010 Beta you can override the code generation with your own template.

  1. Right click the Entity Data Model Designer
  2. Select “Add Code GenerationItem…”
  3. In the Add New Item dialog, select “ADO.NET EntityObject Generator” and click OK

The Entity Framework Design blog has step-by-step instructions and screenshots for doing this – please note that the menu item has text has changed from “Add New Artifact Generation Item…” since that post was written.

Now, let’s edit the .tt file contents so that it generates code using IObjectSet<T> instead of ObjectSet<T>. To do so, look for the comment with the text “Write EntityContainer and ObjectContext ObjectSet properties.” Replace, the two instances of ObjectSet with IObjectSet as shown below. Note: a full copy of a .tt file that you can drop into your own project is available in the source code zip file at the beginning of this post.

   1: <#
   2:         ////////
   3:         //////// Write EntityContainer and ObjectContext ObjectSet properties. 
   4:         ////////
   5:         region.Begin(GetResourceString("Template_RegionObjectSetProperties"));
   6:         foreach (EntitySet set in container.BaseEntitySets.OfType<EntitySet>())
   7:         {
   8:             VerifyEntityTypeAndSetAccessibilityCompatability(set);
   9: #>
  10:  
  11:     /// <summary>
  12:     /// <#=SummaryComment(set)#>
  13:     /// </summary><#=LongDescriptionCommentElement(set, region.CurrentIndentLevel)#>
  14:     <#=code.SpaceAfter(NewModifier(set))#><#=Accessibility.ForReadOnlyProperty(set)#> ObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>> <#=code.Escape(set)#>
          <#=code.SpaceAfter(NewModifier(set))#><#=Accessibility.ForReadOnlyProperty(set)#> IObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>> <#=code.Escape(set)#>
  16:     {
  17:         get
  18:         {
  19:             if ((<#=code.FieldName(set)#> == null))
  20:             {
  21:                 <#=code.FieldName(set)#> = base.CreateObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>>("<#=set.Name#>");
  22:             }
  23:             return <#=code.FieldName(set)#>;
  24:         }
  25:     }
  26:     private ObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>> <#=code.FieldName(set)#>;
          private IObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>> <#=code.FieldName(set)#>;

After you save your changes, look in the generated .cs file (it should be shown as a childe of the .tt file in the solution explorer) and you should see that IObjectSet<T> is now used everywhere ObjectSet<T> was before. Great. But we still have to insert some logic somewhere to tell the program which implementation of IObjectSet<T> to use. Enter the IPersistenceStrategy interface, dependency injection, and a handful of other helper interfaces and classes.

Building out a strategy pattern for runtime-swapping of IObjectSet<T> implementations

Unfortunately, plugging in a new implementation to abstract DB access isn’t quite as simple just providing something like an IObjectSet factory class. There are other pieces of the Entity Framework workflow for querying and submitting changes that also expect a DB connection. What we need is a collection of patterns which need to be implemented as a whole to provide support for a non-DB persistence model. That sounds like a strategy pattern to me so I pulled them together in to one strategy pattern interface, IPersistenceStrategy. Note: Full doc-comments are provided in the downloadable source at the end of this post.

   1: /// <summary>
   2: /// Defines a set of API's for abstracting the persistence of changes to a datastore. The
   3: /// interface is intended to be consumed by an Entity Framework-generated class deriving
   4: /// from ObjectContext.
   5: /// </summary>
   6: public interface IPersistenceStrategy
   7: {
   8:     /// <summary>
   9:     /// Factory method for creating an IObjectSet<TEntity> for the strategy implementation.
  10:     /// </summary>
  11:     IObjectSet<TEntity> CreateObjectSet<TEntity>(ObjectContext objectContext, string entitySetName) where TEntity : class;
  12:  
  13:     /// <summary>
  14:     /// Factory method for creating an EntityKey for the strategy implementation
  15:     /// </summary>
  16:     EntityKey CreateEntityKey(ObjectContext objectContext, string entitySetName, object entity);
  17:  
  18:     /// <summary>
  19:     /// Method for including results from additional tables as part of the query.
  20:     /// </summary>
  21:     IQueryable<TEntity> Include<TEntity>(IQueryable<TEntity> queryable, string path);
  22:     
  23:     /// <summary>
  24:     /// Method to enable change tracking for an existing original entity and modify it with values from the current entity.
  25:     /// </summary>
  26:     void AttachAsModified<TEntity>(IObjectSet<TEntity> objectSet, TEntity current, TEntity original) where TEntity : class, EntityObject;
  27:     
  28:     /// <summary>
  29:     /// Method to persist the changes in the ObjectContext.
  30:     /// </summary>
  31:     int SaveChanges(ObjectContext objectContext, SaveOptions options);
  32: }

Here’s a brief description for why we need all of these methods. In all cases the arguments in the signatures are predetermined based on what the underlying real DB persistence implementation needs, but more on that later.

  • CreateObjectSet – a basic factory method to create and return instances of whichever IObjectSet<T> implementation the strategy implementation chooses.
  • CreateEntityKey – a basic factory method to create and return an EntityKey instance for a given entity. Entity keys are used by Entity Framework to verify the uniqueness of a given entity and to improve the performance of queries. It is required on all entities and creating one using the standard Entity Framework implementation requires a connection to the DB.
  • Include – a helper method to abstract the ObjectQuery.Include method implementation. Many RIA Services domain service use the Include method to load multiple entity types with one query. It takes and returns an IQueryable<TEntity> because the original Include method returns an ObjectQuery<T> which does not implement IObjectSet<T>. Plus this method needs to be a fluent API like the original.
  • AttachAsModified – a helper method to adapt the RIA Services ObjectContext.AttachAsModified extension method to work against IObjectSet<T>. The RIA Services implementation makes calls to the ObjectContext which requires a DB connection so we also need to be able to provide an alternate implementation.
  • SaveChanges – a helper method to abstract the persistence of the data.

Here is the IPersistenceStrategy implementation that uses the actual ObjectContext to work with the real DB datastore. You’ll notice that in a few places I make the assumption that the passed in IQueryable<TEntity> or IObjectSet<TEntity> is actually an ObjectQuery<TEntity>. This is a reasonable expectation since the CreateObjectSet implementation returns an ObjectSet<TEntity> which derives from ObjectQuery<TEntity>.

   1: /// <summary>
   2: /// IPersistenceStrategy implementation for persisting data changes to the backing datastore with Entity Framework
   3: /// </summary>
   4: public class DatastorePersistenceStrategy : IPersistenceStrategy
   5: {
   6:     public IObjectSet<TEntity> CreateObjectSet<TEntity>(ObjectContext objectContext, string entitySetName) where TEntity : class
   7:     {
   8:         return objectContext.CreateObjectSet<TEntity>(entitySetName);
   9:     }
  10:  
  11:     public EntityKey CreateEntityKey(ObjectContext objectContext, string entitySetName, object entity)
  12:     {
  13:         return objectContext.CreateEntityKey(entitySetName, entity);
  14:     }
  15:  
  16:     public IQueryable<TEntity> Include<TEntity>(IQueryable<TEntity> queryable, string path)
  17:     {
  18:         ObjectQuery<TEntity> asObjectQuery = queryable as ObjectQuery<TEntity>;
  19:         if (asObjectQuery != null)
  20:         {
  21:             return asObjectQuery.Include(path);
  22:         }
  23:         else
  24:         {
  25:             throw new InvalidOperationException("This implementation only handles queryables which derive from ObjectQuery<T>.");
  26:         }
  27:     }
  28:  
  29:     public void AttachAsModified<TEntity>(IObjectSet<TEntity> objectSet, TEntity current, TEntity original) where TEntity : EntityObject
  30:     {
  31:         ObjectQuery<TEntity> asObjectQuery = objectSet as ObjectQuery<TEntity>;
  32:         if (asObjectQuery != null)
  33:         {
  34:             asObjectQuery.Context.AttachAsModified(current, original);
  35:         }
  36:         else
  37:         {
  38:             throw new InvalidOperationException("This implementation only handles object sets deriving from ObjectQuery<T>.");
  39:         }
  40:     }
  41:  
  42:     public int SaveChanges(ObjectContext objectContext, SaveOptions options)
  43:     {
  44:         return objectContext.SaveChanges(options);
  45:     }
  46: }

Before showing the alternate test implementations let’s first look at how to pull the pieces together.

Consuming the IPersistenceStrategy interface

Our next step is to get the Entity Framework-generated object context code to use the IPersistenceStrategy methods instead of the default ones. We could extend the existing generated code with a partial class but since we are already fooling with the T4 template, our custom .tt file seemed like the more appropriate place to put this support. There are three places that we need to update in our custom .tt file.

1. Add System.Data and PersistenceStrategy namespace imports.

   1: using System;
   2: using System.Data;
   3: using System.Data.Objects;
   4: using System.Data.Objects.DataClasses;
   5: using System.Data.EntityClient;
   6: using System.ComponentModel;
   7: using System.Xml.Serialization;
   8: using System.Runtime.Serialization;
   9: using PersistenceStrategy;

2. Add a private member variable to hold the IPersistenceStrategy instance, a constructor to set the member variable, a protected read-only accessor property for the member variable, and shadow the CreateEntityKey and SaveChanges methods from the parent ObjectContext type to use the implementations provided by the IPersistenceStrategy implementation. Note that I add this code in its own region just after the region containing the OnContextCreated partial method definition.

   1: #region Persistence Strategy
   2:  
   3: private IPersistenceStrategy _persistenceStrategy;
   4:  
   5: public <#=code.Escape(container)#>(IPersistenceStrategy persistenceStrategy)
   6:     : this()
   7: {
   8:     this._persistenceStrategy = persistenceStrategy;
   9: }
  10:  
  11: protected IPersistenceStrategy PersistenceStrategy
  12: {
  13:     get
  14:     {
  15:         return this._persistenceStrategy;
  16:     }
  17: }
  18:  
  19: public new EntityKey CreateEntityKey(string entitySetName, object entity)
  20: {
  21:     return this.PersistenceStrategy.CreateEntityKey(this, entitySetName, entity);
  22: }
  23:  
  24: public new int SaveChanges(SaveOptions options)
  25: {
  26:     return this.PersistenceStrategy.SaveChanges(this, options);
  27: }
  28:  
  29: #endregion
  30: 

3. Change the line of code that calls the parent ObjectContext’s CreateObjectSet method to instead call IPersistenceStrategy’s CreateObjectSet method. This is in the same block of template code that we changed earlier to support IObjectSet<T>.

   1: /// <summary>
   2: /// <#=SummaryComment(set)#>
   3: /// </summary><#=LongDescriptionCommentElement(set, region.CurrentIndentLevel)#>
   4: <#=code.SpaceAfter(NewModifier(set))#><#=Accessibility.ForReadOnlyProperty(set)#> IObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>> <#=code.Escape(set)#>
   5: {
   6:     get
   7:     {
   8:         if ((<#=code.FieldName(set)#> == null))
   9:         {
  10:             <#=code.FieldName(set)#> = base.CreateObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>>("<#=set.Name#>");
                  <#=code.FieldName(set)#> = this.PersistenceStrategy.CreateObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>>(this, "<#=set.Name#>");
  12:         }
  13:         return <#=code.FieldName(set)#>;
  14:     }
  15: }
  16: private IObjectSet<<#=MultiSchemaEscape(set.ElementType, code)#>> <#=code.FieldName(set)#>;

Finally, we need to tell our domain service class to use the constructor we just added for the generated object context. To do that we override the CreateObjectContext method of the parent LinqToEntitiesDomainService<T> in our domain service.

   1: /// <summary>
   2: /// Overridden method to create FantasyPresentingEntities with
   3: /// a specific IPersistenceStrategy implementation
   4: /// </summary>
   5: protected override FantasyPresentingEntities CreateObjectContext()
   6: {
   7:     return new FantasyPresentingEntities(new DatastorePersistenceStrategy());
   8: }

One of the themes of my PDC talk was to improve testability we want to de-couple and hard coding CreateObjectContext to pass an instance of DatastorePersistenceStrategy into our constructor violates that. To fix the problem, I used a dependency injection framework to register/resolve the desired implementation of IPersistenceStrategy at runtime. This will pay huge dividends when it comes time to testing our service.

Using Unity to hook up the dependencies

Unity is a dependency injection framework created by the Microsoft Patterns and Practices team. My persistence strategy solution uses Unity’s ability to load the dependency mapping (or registration) from the default configuration file which makes it easy to switch mappings at runtime which helps in our quest for testability as we’ll see later. Here is the <unity> section from our web project’s Web.config file.

   1: <unity>
   2:   <typeAliases>
   3:     <!-- Lifetime manager types -->
   4:     <typeAlias alias="singleton" type="Microsoft.Practices.Unity.ContainerControlledLifetimeManager, Microsoft.Practices.Unity" />
   5:     <!-- User-defined type aliases -->
   6:     <typeAlias alias="IPersistenceStrategy" type="PersistenceStrategy.IPersistenceStrategy, PersistenceStrategy" />
   7:     <typeAlias alias="DatastorePersistenceStrategy" type="PersistenceStrategy.DatastorePersistenceStrategy, PersistenceStrategy" />
   8:   </typeAliases>
   9:   <containers>
  10:     <container>
  11:       <types>
  12:         <!-- Type mapping using aliases defined above -->
  13:         <!-- Use the DatastorePersistenceStrategy class where IPersistenceStrategy instances are required.-->
  14:         <type type="IPersistenceStrategy" mapTo="DatastorePersistenceStrategy">
  15:           <lifetime type="singleton"/>
  16:         </type>
  17:       </types>
  18:     </container>
  19:   </containers>
  20: </unity>

There are a few things to note. First, the classes are defined in the namespace PersistenceStrategy in an assembly named PersistenceStrategy. Second, the mapping is set up as a singleton. Third, there is also an additional section at the the top of the Web.config file with the following xml. You can check out this MSDN article for more details on using configuration files with Unity.

   1: <configuration>
   2:   <configSections>
   3:     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
   4:   </configSections>
   5:   ...

The second half of the dependency injection process is resolving the dependencies at runtime – when I need an IPersistenceStrategy instance, give me an instance of the implementation specified in my configuration file. To do this I need an instance of a UnityContainer. I chose to hold on to a singleton instance of a UnityContainer class for the lifetime of the AppDomain. While many Unity samples add the instance as a static member of the application (or possibly part of an ASP.NET application’s property bag), our instance needs to live outside the application so I followed the standard singleton class pattern.

   1: /// <summary>
   2: /// Singleton class for a configured unity container read from the application's default
   3: /// configuration file.
   4: /// </summary>
   5: public class ConfiguredUnityContainer
   6: {
   7:     private readonly static object _padlock = new object();
   8:     private static IUnityContainer _instance;
   9:  
  10:     private ConfiguredUnityContainer()
  11:     {
  12:     }
  13:  
  14:     public static IUnityContainer Instance
  15:     {
  16:         get
  17:         {
  18:             lock (ConfiguredUnityContainer._padlock)
  19:             {
  20:                 if (ConfiguredUnityContainer._instance == null)
  21:                 {
  22:                     // Read the configuration data from the default configuration file
  23:                     // (e.g. web.config for ASP.NET apps or app.config for .NET apps including test apps).
  24:                     ConfiguredUnityContainer._instance = new UnityContainer();
  25:                     UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
  26:                     section.Containers.Default.Configure(ConfiguredUnityContainer._instance);
  27:                 }
  28:             }
  29:             return ConfiguredUnityContainer._instance;
  30:         }
  31:     }
  32: }

Now we can change our CreateObjectContext overridden method in the domain service to be loosely coupled.

   1: /// <summary>
   2: /// Overridden method to use Unity to resolve the IPersistenceStrategy
   3: /// implementation at runtime.
   4: /// </summary>
   5: protected override FantasyPresentingEntities CreateObjectContext()
   6: {
   7:     return new FantasyPresentingEntities(new DatastorePersistenceStrategy());
          return new FantasyPresentingEntities(ConfiguredUnityContainer.Instance.Resolve<IPersistenceStrategy>());
   9: }

Not only is the solution loosely-coupled, but the IPersistenceStrategy implementation can be shared by multiple consumers. Even better is that since we set the mapping up as a singleton in the configuration file, the same instance of DatastorePersistenceStrategy will be returned each time Resolve is called for the IPersistenceStrategy generic type. This is especially helpful to plug a couple of holes (albeit a bit awkwardly).

First, ever since we’ve changed the generated object context to return IObjectSet<T> instances, we’ve had compilation errors wherever we’ve used the Include extension method in our domain service. This is because Include is an extension method for the ObjectQuery type. So we need to provide an Include extension method for IObjectSet<T>. In the implementation below you’ll notice that we delegate the call to IPersistenceStrategy.Include on an instance we get from the ConfiguredUnityContainer singleton.

   1: /// <summary>
   2: /// Method for including results from additional tables as part of the query.
   3: /// </summary>
   4: public static IQueryable<T> Include<T>(this IQueryable<T> queryable, string path) where T : class
   5: {
   6:     IPersistenceStrategy persistenceStrategy =
   7:         ConfiguredUnityContainer.Instance.Resolve<IPersistenceStrategy>();
   8:     return persistenceStrategy.Include<T>(queryable, path);
   9: }

Second, we need redirect all usages of the AttachAsModified extension method for the ObjectContext type to use the AttachAsModified implementation we provide through the IPersistenceStrategy implementation. To do this, we can take a similar approach and add a new AttachAsModified extension method for the IObjectSet<T> type.

   1: /// <summary>
   2: /// Method to enable change tracking for an existing original entity and modify it with values from the current entity.
   3: /// </summary>
   4: public static void AttachAsModified<T>(this IObjectSet<T> objectSet, T current, T original) where T : EntityObject
   5: {
   6:     IPersistenceStrategy persistenceStrategy =
   7:         ConfiguredUnityContainer.Instance.Resolve<IPersistenceStrategy>();
   8:     persistenceStrategy.AttachAsModified(objectSet, current, original);
   9: }

The domain service code will automatically pick up the new Include extension method, but to get the domain service to use the new AttachAsModified extension method we need to do the following replacement in all of the Update methods (using a Team entity type as an example).

Old New
this.ObjectContext.AttachAsModified(currentTeam, this.ChangeSet.GetOriginal(currentTeam)); this.ObjectContext.Teams.AttachAsModified(currentTeam, this.ChangeSet.GetOriginal(currentTeam));

That should be it, but unfortunately the Domain Service wizard in the RIA Services Preview for VS 2010 Beta 2 does not generate IObjectSet<T> friendly code. I am following up with the RIA Services team to get them to fix this but in the meantime we’ll need to do one more step. Follow the steps detailed in the Making the domain service IObjectSet<TEntity> friendly section under Caveats/Things to Note at the bottom of the post.

Now we can build and run our application with its new loosely-couple backend.

Leveraging the Abstracted Persistence Logic for Tests

Everything we’ve done to this point has essentially been refactoring to achieve the end goal of testability. So we can just plug in a couple of new “test” implementations for IObjectSet<T> and IPersistenceStrategy and write our tests.

Implementing IObjectSet<T> and IPersistenceStrategy for testing

What we’re going to do is provide an alternative implementation of IObjectSet<T>  which manipulates in-memory data for the purpose of testing. The implementation I’ve used is taken nearly verbatim from this MSDN article – the only change is that I named the class InMemoryObjectSet. It is a very basic implementation using a HashSet to store and operate on the in-memory entities so I won’t include the code here. Take a look at the source files downloadable at the beginning of this post or follow the link to the MSDN article.

Now let’s have a look at a test implementation of IPersistenceStrategy.

   1: /// <summary>
   2: /// IPersistenceStrategy implementation for working with in-memory data without saving the changes to the backing datastore.
   3: /// </summary>
   4: public class InMemoryPersistenceStrategy : IPersistenceStrategy
   5: {
   6:     private IInMemoryDatastore _datastore;
   7:  
   8:     public InMemoryPersistenceStrategy(IInMemoryDatastore datastore)
   9:     {
  10:         this._datastore = datastore;
  11:     }
  12:  
  13:     public IObjectSet<TEntity> CreateObjectSet<TEntity>(ObjectContext objectContext, string entitySetName) where TEntity : class
  14:     {
  15:         return this._datastore.GetObjectSet<TEntity>();
  16:     }
  17:  
  18:     public EntityKey CreateEntityKey(ObjectContext objectContext, string entitySetName, object entity)
  19:     {
  20:         return new EntityKey();
  21:     }
  22:  
  23:     public IQueryable<TEntity> Include<TEntity>(IQueryable<TEntity> queryable, string path)
  24:     {
  25:         // Include is not applicable for in-memory data sets
  26:         return queryable;
  27:     }
  28:  
  29:     public void AttachAsModified<TEntity>(IObjectSet<TEntity> objectSet, TEntity current, TEntity original) where TEntity : EntityObject
  30:     {
  31:         objectSet.Attach(original);
  32:  
  33:         // Use reflection to look for DataMember attributes which adequately identify the members whose values need to be copied
  34:         var propertiesToCopy = from p in typeof(TEntity).GetProperties()
  35:                                where p.GetCustomAttributes(typeof(DataMemberAttribute), false).FirstOrDefault() != null
  36:                                select p;
  37:         foreach (PropertyInfo property in propertiesToCopy)
  38:         {
  39:             property.SetValue(original, property.GetValue(current, new object[] { }), new object[] { });
  40:         }
  41:     }
  42:  
  43:     public int SaveChanges(ObjectContext objectContext, SaveOptions options)
  44:     {
  45:         // TODO: It would be great to return something other than zero here
  46:         return 0;
  47:     }
  48: }

You’ll notice a couple of things. First, it introduces yet another interface IInMemoryDatastore. This interface allows you to decouple this implementation from the actual test data which allows you to re-use this test implementation for any project with any test data. 

   1: /// <summary>
   2: /// Defines an API for retrieving an IObjectSet<TEntity> instance for given entity type.
   3: /// </summary>
   4: public interface IInMemoryDatastore
   5: {
   6:     /// <summary>
   7:     /// Method to retrieve an IObjectSet<TEntity> instance.
   8:     /// </summary>
   9:     IObjectSet<TEntity> GetObjectSet<TEntity>() where TEntity : class;
  10: }

Before I show the implementation for that interface lets look a little closer at our InMemoryPersistenceStrategy implementation.

  • CreateObjectSet delegates the IObjectSet<TEntity> creation to our IInMemoryDatstore implementation.
  • CreateEntityKey creates an empty default EntityKey instance. This seems to be enough satisfy the requirements of my testing so far.
  • Include just returns the passed in IQuerable<TEntity> since all of the entities are already loaded into memory. This is one of the three places where I feel a little squeamish about the persistence abstraction strategy (the others being the CreateEntityKey and SaveChanges implementations above) since it doesn’t “act” on the IQueryable<TEntity> like the real Entity Framework Include method does. This means that the returned IQueryable<TEntity> could behave differently. Diego Vega briefly talks about this in this post. I’d be happy to hear any input from anybody else on what might be a better answer here.
  • AttachAsModified attaches the original object to the IObjectSet<TEntity> instance and uses reflection to copy the values of the properties marked with [DataMember] from the altered entity to the original entity.
  • SaveChanges returns zero since we aren’t actually saving any changes. That seems logical, but again our test implementation will return a different result than the real Entity Framework implementation so it could invalidate your testing (depending on your viewpoint).

Providing the test data

We’re getting closer to writing tests but first we need the test data. By the way, all of the remaining code I’ll be discussing should be in a different project/assembly than the persistence strategy guts we’ve talked about to this point. In the downloadable solution file at the beginning of this post I include this stuff in the FantasyPresenting.Web.Test project.

Here is an excerpt of the simple test data for the application I used in my demos at PDC.

   1: using System.Collections.Generic;
   2: using FantasyPresenting.Web;
   3:  
   4: namespace FantasyPresenting.Test
   5: {
   6:     /// <summary>
   7:     /// Sample data for test purposes
   8:     /// </summary>
   9:     public class TestData
  10:     {
  11:         public readonly List<Team> Teams = new List<Team>()
  12:         {
  13:              new Team { TeamId=1, TeamName="Team1", UserId=1234, LeagueId=1},
  14:              new Team { TeamId=2, TeamName="Team 2", UserId=2345, LeagueId=1}
  15:         };
  16:         ...
  17:     }
  18: }

I’m a big fan of reusing test data because it takes so much effort to generate. One of the nice side effects of using RIA Services for your n-tier development is that the client code generation outputs the client entity code in the same namespace as it is on the mid-tier (in this case FantasyPresenting.Web). This way I can use my sample data for my testing my client code as well as the domain service code on the mid-tier.

The piece that connects the test data to our InMemoryPersistenceStrategy implementation is through an implementation of the IInMemoryDatastore interface. Remember how the InMemoryPersistenceStrategy constructor takes an IInMemoryDatastore instance as a parameter? Below is the TestDatastore class which creates InMemoryObjectSet instances for the lists of entities in our test data.

   1: /// <summary>
   2: /// IInMemoryDatastore implementation which uses InMemoryObjectSet<TEntity>
   3: /// as a test implementation of IObjectSet<TEntity>.
   4: /// </summary>
   5: public class TestDatastore : IInMemoryDatastore
   6: {
   7:     private Dictionary<Type, object> _objectSets = new Dictionary<Type, object>();
   8:  
   9:     public TestDatastore()
  10:     {
  11:         FantasyPresenting.Test.TestData testData = new FantasyPresenting.Test.TestData();
  12:         this._objectSets.Add(typeof(Team), new InMemoryObjectSet<Team>(testData.Teams));
  13:         this._objectSets.Add(typeof(League), new InMemoryObjectSet<League>(testData.Leagues));
  14:         this._objectSets.Add(typeof(Presenter), new InMemoryObjectSet<Presenter>(testData.Presenters));
  15:         this._objectSets.Add(typeof(Event), new InMemoryObjectSet<Event>(testData.Events));
  16:     }
  17:  
  18:     public IObjectSet<TEntity> GetObjectSet<TEntity>() where TEntity : class
  19:     {
  20:         return this._objectSets[typeof(TEntity)] as IObjectSet<TEntity>;
  21:     }
  22: }

Next we’ll use Unity to glue all of the pieces together in the test project. Our tests will be instantiating the domain service and other classes through a compiled Visual Studio unit test assembly so it won’t be spinning up the domain service in the context of an ASP.NET app. Therefore, the unity configuration will need to be defined in the test project’s App.config. Here’s what it would look like.

   1: <?xml version="1.0" encoding="utf-8" ?>
   2: <configuration>
   3:   <configSections>
   4:     <section name="unity"
   5:               type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,
   6:                  Microsoft.Practices.Unity.Configuration, Version=1.2.0.0,
   7:                  Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
   8:   </configSections>
   9:   <connectionStrings>
  10:     <add name="FantasyPresentingEntities" connectionString="metadata=res://*/DataModel.csdl|res://*/DataModel.ssdl|res://*/DataModel.msl;provider=System.Data.SqlClient;" providerName="System.Data.EntityClient" />
  11:   </connectionStrings>
  12:   <unity>
  13:     <typeAliases>
  14:       <!-- User-defined type aliases -->
  15:       <typeAlias alias="IPersistenceStrategy"
  16:            type="PersistenceStrategy.IPersistenceStrategy, PersistenceStrategy" />
  17:       <typeAlias alias="InMemoryPersistenceStrategy"
  18:            type="PersistenceStrategy.InMemoryPersistenceStrategy, PersistenceStrategy" />
  19:       <typeAlias alias="IInMemoryDatastore"
  20:            type="PersistenceStrategy.IInMemoryDatastore, PersistenceStrategy"/>
  21:       <typeAlias alias="TestDatastore"
  22:            type="FantasyPresenting.Web.Test.TestDatastore, FantasyPresenting.Web.Test"/>
  23:     </typeAliases>
  24:     <containers>
  25:       <container>
  26:         <types>
  27:           <!-- Type mapping using aliases defined above -->
  28:           <!-- Use the InMemoryPersistenceStrategy class where IPersistenceStrategy instances are required.-->
  29:           <type type="IPersistenceStrategy" mapTo="InMemoryPersistenceStrategy"/>
  30:           <!-- Use the TestDatastore class where IInMemoryDatastore instances are required.-->
  31:           <type type="IInMemoryDatastore" mapTo="TestDatastore"/>
  32:         </types>
  33:       </container>
  34:     </containers>
  35:   </unity>
  36: </configuration>

This information gets read by the ConfiguredUnityContainer singleton instance when it gets created so that requests for IPersistenceStrategy resolve to the InMemoryPersistenceStrategy class and IInMemoryDatastore resolve to the TestDatastore class.

You may also note that I’ve included a “FantasyPresentingEntities” connection string. This information corresponds to a connection string by the same name in the mid-tier assembly’s Web.config file. While we don’t need to provide full connection string data, Entity Framework requires at least the metadata part of the connection string entry when our domain service creates an instance of our generated object context (i.e. FantasyPresentingEntities).

Writing the tests

Finally, we have everything we need to write some tests. Here is an example test class for the FantasyPresentingDomainService. Before a domain service instance can be used it needs to have its Initialize method called. Unfortunately that method takes an instance of a DomainServiceContext class whose constructor requires an IServiceProvider. From my research I couldn’t find an appropriate class anywhere in the .NET framework so I cobbled together a FakeServiceProvider nested class for testing.

   1: /// <summary>
   2: /// Sample set of unit tests for the FantasyPresentingDomainService
   3: /// </summary>
   4: [TestClass]
   5: public class DomainServiceTests
   6: {
   7:     private TestContext testContextInstance;
   8:  
   9:     /// <summary>
  10:     ///Gets or sets the test context which provides
  11:     ///information about and functionality for the current test run.
  12:     ///</summary>
  13:     public TestContext TestContext
  14:     {
  15:         get
  16:         {
  17:             return testContextInstance;
  18:         }
  19:         set
  20:         {
  21:             testContextInstance = value;
  22:         }
  23:     }
  24:  
  25:     [TestMethod]
  26:     public void QueryTest()
  27:     {
  28:         FantasyPresentingDomainService domainService = InstantiateDomainService(DomainOperationType.Query);
  29:         IQueryable<Team> teams = domainService.GetTeamsForUser(2345);
  30:         Assert.AreEqual(1, teams.Count(), "Only one team should have been returned.");
  31:         Assert.AreEqual(teams.Single().TeamId, 2, "Team with ID 2 should have been returned.");
  32:     }
  33:  
  34:     [TestMethod]
  35:     public void SubmitChangesTest()
  36:     {
  37:         FantasyPresentingDomainService domainService = InstantiateDomainService(DomainOperationType.Submit);
  38:         bool result = domainService.Submit(new ChangeSet(new ChangeSetEntry[] { }));
  39:         Assert.IsTrue(result, "Submit should have succeeded.");
  40:     }
  41:  
  42:     /// <summary>
  43:     /// Helper method to create a FantasyPresentingDomainService instance for a given operation
  44:     /// </summary>
  45:     private FantasyPresentingDomainService InstantiateDomainService(DomainOperationType operation)
  46:     {
  47:         FantasyPresentingDomainService domainService = new FantasyPresentingDomainService();
  48:         domainService.Initialize(new DomainServiceContext(new FakeServiceProvider(), operation));
  49:         return domainService;
  50:     }
  51:  
  52:     /// <summary>
  53:     /// Fake class for the purpose initializing a new FantasyPresentingDomainService
  54:     /// </summary>
  55:     private class FakeServiceProvider : IServiceProvider
  56:     {
  57:         public object GetService(Type serviceType)
  58:         {
  59:             return null;
  60:         }
  61:     }
  62: }

 

Caveats/Things to Note

Just a starting point

This support is intended as a starting point and hopefully it gets you going in the right direction. You might need to expand the IPersistenceStrategy interface and the classes which implement it to support richer test cases. Even more helpful would be that RIA Services will continue to improve the testability experience to reduce the workarounds we’ve had to implement in this post.

Making the domain service IObjectSet<TEntity> friendly

Remember that the default code generated by the Domain Services class wizard will not take advantage of the changes in the custom .tt file to use IObjectSet<TEntity> which bypasses all the abstraction work that we did. I am following up with the RIA Services team to make sure they change the Domain Services wizard code spit, but you'll have to hand edit your own Domain Service code.

Here are the patterns you will need to change (using a Team entity type as an example). Your Get (or Select) methods will not need any fix-ups.

Operation Old New
Insert this.ObjectContext.AddToTeams(team); this.ObjectContext.Teams.AddObject(team);
Update this.ObjectContext.AttachAsModified(currentTeam, this.ChangeSet.GetOriginal(currentTeam)); this.ObjectContext.Teams.AttachAsModified(currentTeam, this.ChangeSet.GetOriginal(currentTeam));
Delete this.ObjectContext.Attach(team); this.ObjectContext.Teams.Attach(team);
Delete this.ObjectContext.DeleteObject(team); this.ObjectContext.Teams.DeleteObject(team);

Testing update methods

Testing the Update methods is tricky since you have to call this.ChangeSet.GetOriginal(...) to get the original entity to pass into AttachAsModified. However the ChangeSet property returns null in mocked scenarios like we’re doing and even if it weren’t null the list of entries is read-only. My goal was to be able to demonstrate that you don't have change the way you write your domain service to be able to test it, but it falls apart here. I'm following up with the RIA Services team to make sure they improve this experience. In the meantime you can abstract the call to GetOriginal like I did in the downloadable source code for my demo. Note: No, you didn’t miss something from the PDC talk. I included this support in the demo solution afterwards.

FantasyPresenting.zip

]]> Making multiple selection in a DataGrid bindable https://docs.microsoft.com/archive/blogs/keithjones/making-multiple-selection-in-a-datagrid-bindable Thu, 01 Oct 2009 21:08:00 GMT https://blogs.msdn.microsoft.com/keithjones/2009/10/01/making-multiple-selection-in-a-datagrid-bindable/ A customer recently asked how to change the selection of a row in the Silverlight 3 DataGrid based on the values of the columns. The brief answer is to add an event handler for LoadingRow and call dataGrid.SelectedItems.Add(e.Row.DataContext), but the customer did mention that he was using M-V-VM and that got me thinking. The selection state of a DataGrid should be pulled from the model, not calculated as part of the UI processing when the row gets loaded. The DataGrid supports this concept for single-item selection because DataGrid.SelectedItem is data-bindable. The problem is that DataGrid.SelectedItems is pre-populated with an internal collection which implements IList (the return type of DataGrid.SelectedItems). I turned to using attached properties - the trusty duct-tape of Silverlight - to fill the gap.

Below is the C# code for a class containing an attached property called SelectedItemsSource which can be applied to a DataGrid to keep its SelectedItems internal collection in-sync with a source list you specify. The synchronization is two-way and works with multiple DataGrid instances synced to the same source list. The only limitation is that the source list must implement IList and INotifyCollectionChanged. Disclaimer: This plays nice for the most part if the DataGrid.ItemsSource is bound to a collection implementing ICollectionView (which handles single-item currency). In my limited testing this workaround falls down when you have multiple DataGrids with the SelectedItemsSource attached property set to the same list and ItemsSource bound to the same ICollectionView instance.

The full source for the class is dowloadable from a link at the end of the post.

using System;

using System.Collections;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.Diagnostics;

using System.Windows;

using System.Windows.Controls;

 

namespace Samples

{

    /// <summary>

    /// Class providing support to faux-bind the SelectedItems for a DataGrid to an IList implementing INotifyCollectionChanged

    /// </summary>

    public static class DataGridMultipleSelection

    {

        /// <summary>

        /// Used in the selectedItemsSources private registry to hold state

        /// </summary>

        private class DataGridsAndInitiatedSelectionChange

        {

            public readonly List<WeakReference> BoundDataGridReferences = new List<WeakReference>();

            public bool InitiatedSelectionChange { get; set; }

        }

 

        // Use each source list's hashcode as the key so that we don't hold on

        // to any references in case the DataGrid gets disposed without telling

        // to remove the source list from our registry.

        private static Dictionary<int, DataGridsAndInitiatedSelectionChange> selectedItemsSources = new Dictionary<int, DataGridsAndInitiatedSelectionChange>();

 

        #region InitiatedSelectionChangeProperty

        /// <summary>

        /// For use only by this implementation to track if a DataGrid is the one changing the selection

        /// </summary>

        private static readonly DependencyProperty InitiatedSelectionChangeProperty = DependencyProperty.RegisterAttached("InitiatedSelectionChange", typeof(bool), typeof(DataGridMultipleSelection), new PropertyMetadata(false));

 

        /// <summary>

        /// Accessor to get the InitiatedSelectionChange DependencyProperty

        /// </summary>

        private static bool GetInitiatedSelectionChange(DataGrid element)

        {

            return (bool)element.GetValue(DataGridMultipleSelection.InitiatedSelectionChangeProperty);

        }

 

        /// <summary>

        /// Accessor to set the InitiatedSelectionChange DependencyProperty

        /// </summary>

        private static void SetInitiatedSelectionChange(DataGrid element, bool value)

        {

            element.SetValue(DataGridMultipleSelection.InitiatedSelectionChangeProperty, value);

        }

        #endregion

 

        #region SelectedItemsSourceProperty

 

        /// <summary>

        /// Holds an IList implementing INotifyCollectionChanged to use as an items source for DataGrid.SelectedItems

        /// </summary>

        public static readonly DependencyProperty SelectedItemsSourceProperty = DependencyProperty.RegisterAttached("SelectedItemsSource", typeof(INotifyCollectionChanged), typeof(DataGridMultipleSelection), new PropertyMetadata(null, SelectedItemsSourceChanged));

 

        /// <summary>

        /// Accessor to get the SelectedItemsSource DependencyProperty

        /// </summary>

        public static INotifyCollectionChanged GetSelectedItemsSource(DataGrid element)

        {

            return element.GetValue(DataGridMultipleSelection.SelectedItemsSourceProperty) as INotifyCollectionChanged;

        }

 

        /// <summary>

        /// Accessor to set the SelectedItemsSource DependencyProperty

        /// </summary>

        public static void SetSelectedItemsSource(DataGrid element, INotifyCollectionChanged value)

        {

            element.SetValue(DataGridMultipleSelection.SelectedItemsSourceProperty, value);

        }

 

        /// <summary>

        /// Updates the items source registry when the SelectedItemsSource for a DataGrid changes

        /// </summary>

        private static void SelectedItemsSourceChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)

        {

            DataGrid dataGrid = sender as DataGrid;

            IList selectedItemsSource = null;

 

            // Check if the app is setting the source to a new or different list, or if it is removing the binding

            if (args.NewValue != null)

            {

                selectedItemsSource = args.NewValue as IList;

                if (selectedItemsSource == null)

                {

                    throw new ArgumentException("The value for SelectedItemsSource must implement IList.");

                }

 

                INotifyCollectionChanged collection = args.NewValue as INotifyCollectionChanged;

                if (collection == null)

                {

                    throw new ArgumentException("The value for SelectedItemsSource must implement INotifyCollectionChanged.");

                }

 

                // Don't add the event handler if the DataGrid is not setting its SelectedItemsSource for the first time

                if (args.OldValue == null)

                {

                    // Sign up for changes to the DataGrid's selected items to enable a two-way binding effect

                    dataGrid.SelectionChanged += UpdateSourceListOnDataGridSelectionChanged;

                }

 

                // Track this DataGrid instance for the specified source list

                DataGridsAndInitiatedSelectionChange sourceListInfo = null;

                if (DataGridMultipleSelection.selectedItemsSources.TryGetValue(selectedItemsSource.GetHashCode(), out sourceListInfo))

                {

                    sourceListInfo.BoundDataGridReferences.Add(new WeakReference(dataGrid));

                }

                else

                {

                    // This is a new source collection

                    sourceListInfo = new DataGridsAndInitiatedSelectionChange() { InitiatedSelectionChange = false };

                    sourceListInfo.BoundDataGridReferences.Add(new WeakReference(dataGrid));

                    DataGridMultipleSelection.selectedItemsSources.Add(selectedItemsSource.GetHashCode(), sourceListInfo);

 

                    // Sign up for changes to the source only on the first time the source is added

                    collection.CollectionChanged += UpdateDataGridsOnSourceCollectionChanged;

                }

 

                // Now force the DataGrid to update its SelectedItems to match the current

                // contents of the source list

                sourceListInfo.InitiatedSelectionChange = true;

                UpdateDataGrid(dataGrid, selectedItemsSource, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));

                sourceListInfo.InitiatedSelectionChange = false;

            }

            else

            {

                // This DataGrid is removing its SelectedItems binding to any list

                dataGrid.SelectionChanged -= UpdateSourceListOnDataGridSelectionChanged;

                dataGrid.SelectedItems.Clear();

            }

           

            if (args.OldValue != null)

            {

                // Clean up the items source that was the old value

 

                // Remove the DataGrid from the source list's registry and remove the source list

                // if there are no more DataGrids bound to it.

                DataGridsAndInitiatedSelectionChange sourceListInfo = DataGridMultipleSelection.selectedItemsSources[args.OldValue.GetHashCode()];

                WeakReference dataGridReferenceNeedingRemoval = null;

                foreach (WeakReference dataGridReference in sourceListInfo.BoundDataGridReferences)

                {

                    if (dataGridReference.IsAlive && (dataGridReference.Target == dataGrid))

                    {

                        dataGridReferenceNeedingRemoval = dataGridReference;

                        break;

                    }

                }

                sourceListInfo.BoundDataGridReferences.Remove(dataGridReferenceNeedingRemoval);

                if (sourceListInfo.BoundDataGridReferences.Count == 0)

                {

                    DataGridMultipleSelection.selectedItemsSources.Remove(args.OldValue.GetHashCode());

 

                    // Detach the event handlers and clear DataGrid.SelectedItems since the source is now null

                    INotifyCollectionChanged collection = args.OldValue as INotifyCollectionChanged;

                    if (collection != null)

                    {

                        collection.CollectionChanged -= UpdateDataGridsOnSourceCollectionChanged;

                    }

                }

            }

        }

 

        /// <summary>

        /// INotifyCollectionChanged.CollectionChanged handler for updating DataGrid.SelectedItems when the source list changes

        /// </summary>

        private static void UpdateDataGridsOnSourceCollectionChanged(object source, NotifyCollectionChangedEventArgs collectionChangedArgs)

        {

            DataGridsAndInitiatedSelectionChange sourceListInfo = DataGridMultipleSelection.selectedItemsSources[source.GetHashCode()];

 

            // For each DataGrid that is bound to this list, is alive, and did not initate selection changes, update its selection

            sourceListInfo.InitiatedSelectionChange = true;

            IList sourceList = source as IList;

            Debug.Assert(sourceList != null, "SelectedItemsSource must be of type IList");

            DataGrid dataGrid = null;

            foreach (WeakReference dataGridReference in sourceListInfo.BoundDataGridReferences)

            {

                if (dataGridReference.IsAlive && !DataGridMultipleSelection.GetInitiatedSelectionChange(dataGridReference.Target as DataGrid))

                {

                    dataGrid = dataGridReference.Target as DataGrid;

                    UpdateDataGrid(dataGrid, sourceList, collectionChangedArgs);

                }

            }

            sourceListInfo.InitiatedSelectionChange = false;

        }

 

        /// <summary>

        /// Helper method to update the items in DataGrid.SelectedItems based on the changes defined in the given NotifyCollectionChangedEventArgs

        /// </summary>

        /// <param name="dataGrid">DataGrid which owns the SelectedItems collection to update</param>

        /// <param name="sourceList">IList which is the SelectedItemsSource</param>

        /// <param name="collectionChangedArgs">The NotifyCollectionChangedEventArgs that was passed into the CollectionChanged event handler</param>

        private static void UpdateDataGrid(DataGrid dataGrid, IList sourceList, NotifyCollectionChangedEventArgs collectionChangedArgs)

        {

            switch (collectionChangedArgs.Action)

            {

                case NotifyCollectionChangedAction.Add:

                    foreach (object newItem in collectionChangedArgs.NewItems)

                    {

                        dataGrid.SelectedItems.Add(newItem);

                    }

                    break;

                case NotifyCollectionChangedAction.Remove:

                    foreach (object oldItem in collectionChangedArgs.OldItems)

                    {

                        dataGrid.SelectedItems.Remove(oldItem);

                    }

                    break;

                case NotifyCollectionChangedAction.Reset:

                    // Unfortunately can not do the following two steps as an atomic change

                    // so the target list could raise multiple notifications as it gets updated

                    dataGrid.SelectedItems.Clear();

                    foreach (object item in sourceList)

                    {

                        dataGrid.SelectedItems.Add(item);

                    }

                    break;

                default:

                    throw new NotImplementedException("Only Add, Remove, and Reset actions are implemented.");

            }

        }

 

        /// <summary>

        /// DataGrid.SelectionChanged handler to update the source list given the SelectionChangedEventArgs

        /// </summary>

        private static void UpdateSourceListOnDataGridSelectionChanged(object sender, SelectionChangedEventArgs selectionChangedArgs)

        {

            DataGrid dataGrid = sender as DataGrid;

            IList selectedItemsSource = DataGridMultipleSelection.GetSelectedItemsSource(dataGrid) as IList;

            Debug.Assert(selectedItemsSource != null, "SelectedItemsSource must be of type IList");

            // If the source list initiated the changes then don't pass the DataGrid's changes back down to the source list

            if (!DataGridMultipleSelection.selectedItemsSources[selectedItemsSource.GetHashCode()].InitiatedSelectionChange)

            {

                DataGridMultipleSelection.SetInitiatedSelectionChange(dataGrid, true);

                foreach (object removedItem in selectionChangedArgs.RemovedItems)

                {

                    selectedItemsSource.Remove(removedItem);

                }

 

                foreach (object addedItem in selectionChangedArgs.AddedItems)

                {

                    selectedItemsSource.Add(addedItem);

                }

                DataGridMultipleSelection.SetInitiatedSelectionChange(dataGrid, false);

            }

        }

        #endregion

    }

}

 

 

Usage of the attached property is extremely simple. In the first example, the view model is assumed to be already set as the DataGrid's DataContext. The second example assumes that the view model has been instantiated as a static resource either for the App or some other container. Remember to set SelectionMode="Extended" to enable multiple selection in the DataGrid.

<data:DataGrid ... SelectionMode="Extended" samples:DataGridMultipleSelection.SelectedItemsSource="{Binding SelectedProducts}" />

<data:DataGrid ... SelectionMode="Extended" samples:DataGridMultipleSelection.SelectedItemsSource="{Binding SelectedProducts, Source={StaticResource CatalogModel}}" />

 

 

DataGridMultipleSelection.zip

]]> Failures in .NET RIA Services are silent by default https://docs.microsoft.com/archive/blogs/keithjones/failures-in-net-ria-services-are-silent-by-default Thu, 19 Mar 2009 16:57:00 GMT https://blogs.msdn.microsoft.com/keithjones/2009/03/19/failures-in-net-ria-services-are-silent-by-default/ Due to the async nature of the .NET RIA Services programming model, exceptions and errors during load and submits aren't thrown on the client. Instead, the errors are exposed through an Error property which can be found in the event args instances passed in to handlers for the Loaded and Submitted events.

So, the first thing I do whenever I create a new DomainContext instance on the client is add a simple handler for the Loaded event. If I am going to be doing submits, then I add a handler for the Submitted event.

For example,

myDomainContext.Loaded += delegate(object sender, LoadedDataEventArgs e)
{
    if (e.Error != null)
    {
        throw e.Error;
    }
};
myDomainContext.Submitted += delegate(object sender, SubmittedChangesEventArgs e)
{
    if (e.Error != null)
    {
        throw e.Error;
    }
};

Later on, I might to do more complex things on those event handlers, but at beginning using anonymous methods are just fine.

]]> Building a dual thumb slider for Silverlight 2 Beta 1 https://docs.microsoft.com/archive/blogs/keithjones/building-a-dual-thumb-slider-for-silverlight-2-beta-1 Tue, 08 Apr 2008 21:06:00 GMT https://blogs.msdn.microsoft.com/keithjones/2008/04/08/building-a-dual-thumb-slider-for-silverlight-2-beta-1/  

hosted by Silverlight Streaming - the source is available as an attachment at the bottom of this post.

The Slider control that shipped with the Silverlight 2 Beta 1 SDK only supports picking a single value. Back at Mix08 in March I threw together a control that allows selecting a range using two thumbs, but I haven't had a chance to talk about it until now. So, without further ado let me introduce the RangeFinder control.

 

 

[TemplatePart(Name = RangeFinder.RootElementName, Type = typeof(FrameworkElement))]

[TemplatePart(Name = RangeFinder.TrackGridElementName, Type = typeof(Grid))]

[TemplatePart(Name = RangeFinder.LeftTrackElementName, Type = typeof(Rectangle))]

[TemplatePart(Name = RangeFinder.RightTrackElementName, Type = typeof(Rectangle))]

[TemplatePart(Name = RangeFinder.LeftGridSplitterElementName, Type = typeof(GridSplitter))]

[TemplatePart(Name = RangeFinder.RightGridSplitterElementName, Type = typeof(GridSplitter))]

public class RangeFinder : RangeBase

{

    /// <summary>

    /// Raised when the UpperValue dependency property changes

    /// </summary>

    public event RoutedPropertyChangedEventHandler<double> UpperValueChanged;

 

    /// <summary>

    /// Constructor for the RangeFinder class

    /// </summary>

    public RangeFinder() {}

 

    /// <summary>

    /// Gets/sets the UpperValue dependency property for the upper value of the selected range

    /// </summary>

    public double UpperValue {get; set;}

 

    /// <summary>

    /// Gets/sets the ThumbWidth dependency property for width of the individual thumbs

    /// </summary>

    public double ThumbWidth {get; set;}

 

    /// <summary>

    /// Gets/sets the TrackMargin dependency property for the distance from the edges of the control that track should be displayed

    /// </summary>

    public Thickness TrackMargin {get; set;}

 

    /// <summary>

    /// Gets/sets the Background dependency property for the background of the control

    /// </summary>

    public Brush Background {get; set;}

 

    /// <summary>

    /// Gets/sets the Foreground dependency property for the foreground of the control

    /// </summary>

    public Brush Foreground {get; set;}

 

    /// <summary>

    /// Gets/sets the MinimumRange dependency property for the minimum allowable difference

    /// between the Value and UpperValue properties

    /// </summary>

    public double MinimumRange  {get; set;}

}

 

 

The first decision to make was whether or not I could extend the existing Slider control. I think I could have restyled the thumb by inserting a custom control that would have allowed me to expand it, but that seemed really complex. Instead, I chose to inherit directly from RangeBase and implement the UI of the control from scratch.

 

The Slider class uses a grid with three columns to lay out the UI. Moving the thumb actually changes the dimensions of the first and third columns. When the size of the first column changes, a rectangle in that column invokes a SizeChanged event handler which updates the Value based on the new size.

 

I thought that was a pretty slick approach so I borrowed the concept for RangeFinder. I had a problem though; I needed two independent values. Instead of creating a second thumb and trying to coordinate it with the first, I decided to use a control whose sole purpose in life is resizing grids - the GridSplitter.

 

Here is the general concept:

  • A three-column Grid
  • Two Rectangles, one filling the first column and the other filling the third.
  • Two GridSplitters, one aligned-right in the first column and the other aligned-left in the third.
  • Dragging one of the GridSplitters resizes the adjacent columns causing a rectangle in one of the columns to invoke its SizeChanged event handler which updates the Value or UpperValue property, as appropriate.
  • There is a little math behind the scenes to convert the value range (e.g. 1 to 100) to visual coordinates (e.g. 0 to 50 pixels).

 

Creating a default RangeFinder

 

Creating an instance of the control on a Silverlight page is very easy. The first RangeFinder shown in the example above just sticks with default colors and a Minimum of 0 and a Maximum of 1.

 

<local:RangeFinder x:Name="rangeFinder0" />

 

 

Seeing the RangeFinder's values

 

The RangeFinder isn't very fun though if you can't see what the Value and UpperValue properties actually are. Silverlight 2 Beta 1 doesn't dynamically update any UI data bound to dependency properties so you need to create a little Data Transfer Object (DTO) to fill the gap. The ValueDataObject class in the attached project serves this purpose.

 

/// <summary>

/// Data transport object for binding the UI to the actual values selected

/// </summary>

/// <remarks>

/// When dependency properties change in Silverlight 2 Beta 1, they do not

/// update the targets of any data binding made to those properties. One

/// way to do this is to use a data transport object that implements the

/// INotifyPropertyChanged interface as the source of the bindings as

/// demonstrated by this ValueDataObject class.

/// </remarks>

public class ValueDataObject : INotifyPropertyChanged

{

    /// <summary>

    /// Implementation of the INotifyPropertyChanged.PropertyChanged event

    /// </summary>

    public event PropertyChangedEventHandler PropertyChanged;

 

    /// <summary>

    /// Constructor for the ValueDataObject class

    /// </summary>

    /// <param name="instance">RangeFinder object to associate this instance with</param>

    public ValueDataObject(RangeFinder instance, string valueFormat) {}

 

    /// <summary>

    /// Gets the Value property of the associated RangeFinder object

    /// </summary>

    public Double Value {get; }

 

    /// <summary>

    /// Gets a formatted string for the Value property of the associated RangeFinder object

    /// </summary>

    public string FormattedValue {get; }

 

    /// <summary>

    /// Gets the UpperValue property of the associated RangeFinder object

    /// </summary>

    public Double UpperValue {get; }

 

    /// <summary>

    /// Gets a formatted string for the UpperValue property of the associated RangeFinder object

    /// </summary>

    public string FormattedUpperValue {get; }

 

    /// <summary>

    /// Gets/sets the string format to be used when formatting the Value and UpperValue properties

    /// </summary>

    public string ValueFormat { get; set; }

}

 

 

Now, you want to set up the UI to be able to show the values. I used two TextBlocks in the second RangeFinder in the example above. Note that the example code binds the Text property of the TextBlocks to the FormattedValue and FormattedUpperValue properties of ValueDataObject. This allows it to change the formatting when converting the value to a string.

 

 

<Grid x:Name="customRangeFinderContainer" VerticalAlignment="Center">

    <Grid.ColumnDefinitions>

        <ColumnDefinition />

        <ColumnDefinition Width="200"/>

        <ColumnDefinition />

    </Grid.ColumnDefinitions>

    <Grid.RowDefinitions>

        <RowDefinition Height="20"/>

    </Grid.RowDefinitions>

    <TextBlock Grid.Column="0" Style="{StaticResource valueTextBlockStyle}" Text="{Binding FormattedValue, Mode=OneWay}" />

    <local:RangeFinder x:Name="rangeFinder1" Grid.Column="1"

                       Minimum="0" Maximum="5.5" Value=".5" UpperValue="5.0" MinimumRange="1.5"

                       Background="DarkGray" Foreground="Brown" />

    <TextBlock Grid.Column="2"  Style="{StaticResource valueTextBlockStyle}" Text="{Binding FormattedUpperValue, Mode=OneWay}" />

</Grid>

 

 

It was very easy to change the default Background and Foreground colors, the Minimum and Maximum properties, and the initial Value and UpperValue properties. It is also easy to set a minimum range.

 

One last piece is needed to hook it all up. You need to set the DataContext of some parent UI element to be an instance of ValueDataObject. In the example code this is done in the code-behind for Page.xaml.

 

protected override void OnApplyTemplate()

{

    base.OnApplyTemplate();

    this.customRangeFinderContainer.DataContext = new ValueDataObject(this.rangeFinder1, "'$'0.00");

    ...

}

 

 

Customizing the RangeFinder

 

The third RangeFinder example from above re-templates the whole RangeFinder control and re-styles the GridSplitters. Even though the TextBlocks showing the Value and UpperValue properties are part of the GridSplitter style, the ValueDataObject instance in the parent's DataContext gives them something to bind to.

 

<Grid x:Name="flagRangeFinderContainer" Height="80" Width="300" Background="#FFDDDDDD">

    <local:RangeFinder x:Name="rangeFinder2" Height="70" Width="200" VerticalAlignment="Bottom" HorizontalAlignment="Center"

                       Minimum="10" Maximum="90" Value="20" UpperValue="70"

                       Background="Green">

        <local:RangeFinder.Style>

            <Style TargetType="local:RangeFinder">

                <Setter Property="Template">

                    <Setter.Value>

                        <ControlTemplate TargetType="local:RangeFinder">

                            <Grid x:Name="RootElement" Background="Transparent">

                                <Grid x:Name="TrackElement">

                                    <Grid.Resources>

                                        <SolidColorBrush x:Key="EndCap" Color="#55000000"/>

                                        <LinearGradientBrush x:Key="VerticalShadow" StartPoint="0,0" EndPoint="0,1">

                                            <GradientStopCollection>

                                                <GradientStop Color="Black" Offset="0"/>

                                                <GradientStop Color="Transparent" Offset="1"/>

                                            </GradientStopCollection>

                                        </LinearGradientBrush>

                                        <LinearGradientBrush x:Key="HorizontalShadow" StartPoint="0,0" EndPoint="1,0">

                                            <GradientStopCollection>

                                                <GradientStop Color="Black" Offset="0"/>

                                                <GradientStop Color="Transparent" Offset="1"/>

                                            </GradientStopCollection>

                                        </LinearGradientBrush>

                                        <LinearGradientBrush x:Key="SoutheastShadow" StartPoint="0,0" EndPoint="1,1">

                                            <GradientStopCollection>

                                                <GradientStop Color="Black" Offset=".32"/>

                                                <GradientStop Color="Transparent" Offset=".59"/>

                                            </GradientStopCollection>

                                        </LinearGradientBrush>

                                        <LinearGradientBrush x:Key="RaisedShadow" StartPoint="0,1" EndPoint="0,0">

                                            <GradientStopCollection>

                                                <GradientStop Color="#AA000000" Offset=".2"/>

                                                <GradientStop Color="Transparent" Offset=".8"/>

                                            </GradientStopCollection>

                                        </LinearGradientBrush>

                                        <LinearGradientBrush x:Key="TrackShadow" StartPoint="0,1" EndPoint="0,0">

                                            <GradientStopCollection>

                                                <GradientStop Color="#88000000" Offset=".2"/>

                                                <GradientStop Color="Transparent" Offset=".7"/>

                                                <GradientStop Color="Transparent" Offset=".8"/>

                                                <GradientStop Color="#88000000" Offset=".95"/>

                                            </GradientStopCollection>

                                        </LinearGradientBrush>

 

                                        <Style x:Key="valueTextBlockStyle" TargetType="TextBlock">

                                            <Setter Property="FontFamily" Value="Trebuchet MS"/>

                                            <Setter Property="FontSize" Value="11"/>

                                        </Style>

 

                                        <Style x:Key="RightGridSplitter" TargetType="GridSplitter">

                                            <Setter Property="Template">

                                                <Setter.Value>

                                                    <ControlTemplate TargetType="GridSplitter">

                                                        <Grid x:Name="RootElement" IsHitTestVisible="{TemplateBinding IsEnabled}">

                                                            <Grid.RowDefinitions>

                                                                <RowDefinition Height="26"/>

                                                                <RowDefinition Height="*"/>

                                                            </Grid.RowDefinitions>

                                                            <Grid.ColumnDefinitions>

                                                                <ColumnDefinition Width="6"/>

                                                                <ColumnDefinition Width="*"/>

                                                                <ColumnDefinition Width="6"/>

                                                            </Grid.ColumnDefinitions>

 

                                                            <!-- Inner Shadow -->

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-.1,5.9,0,0" HorizontalAlignment="Stretch" VerticalAlignment="Top" Height="4" Fill="{StaticResource VerticalShadow}"/>

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-.1,6,0,6" VerticalAlignment="Stretch" HorizontalAlignment="Left" Width="4" Fill="{StaticResource HorizontalShadow}">

                                                                <Rectangle.Clip>

                                                                    <PathGeometry>

                                                                        <PathGeometry.Figures>

                                                                            <PathFigure StartPoint="0,0">

                                                                                <PathFigure.Segments>

                                                                                    <LineSegment Point="5,5"/>

                                                                                    <LineSegment Point="5,26"/>

                                                                                    <LineSegment Point="0,26"/>

                                                                                </PathFigure.Segments>

                                                                            </PathFigure>

                                                                        </PathGeometry.Figures>

                                                                    </PathGeometry>

                                                                </Rectangle.Clip>

                                                            </Rectangle>

 

                                                            <!-- Outer Shadow -->

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="0,0,0,-3.9" HorizontalAlignment="Stretch" VerticalAlignment="Bottom" Height="4" Fill="{StaticResource VerticalShadow}"/>

                                                            <Rectangle Grid.Row="0" Grid.Column="2" Margin="0,2,-2.9,5" VerticalAlignment="Stretch" HorizontalAlignment="Right" Width="4" Fill="{StaticResource HorizontalShadow}"/>

                                                            <Rectangle Grid.Row="0" Grid.Column="2" Margin="0,0,-2,-3" HorizontalAlignment="Right" VerticalAlignment="Bottom" Height="8" Width="8" Fill="{StaticResource SoutheastShadow}"/>

 

                                                            <!-- Stem and Shadow -->

                                                            <Rectangle Grid.Row="1" Grid.Column="0" Margin="0,-1,0,-1" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{TemplateBinding Background}"/>

                                                            <Rectangle Grid.Row="1" Grid.Column="0" Margin="0,-1,0,0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{StaticResource RaisedShadow}"/>

 

                                                            <!-- Flag Shape -->

                                                            <Polygon Grid.Row="0" Grid.Column="0" Points="0,26 0,5 5,0 6,0 6,26" Fill="{TemplateBinding Background}" />

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-1,0,0,0" Fill="{TemplateBinding Background}" HorizontalAlignment="Stretch" VerticalAlignment="Top" Height="6" />

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-1,0,0,0" Fill="{TemplateBinding Background}" HorizontalAlignment="Stretch" VerticalAlignment="Bottom" Height="6" />

                                                            <Polygon Grid.Row="0" Grid.Column="2" Margin="-1,0,0,0" Points="0,26 0,0 6,0 6,21 1,26" Fill="{TemplateBinding Background}"/>

 

                                                            <TextBlock Grid.Row="0" Grid.Column="1" Margin="0,2,0,0" HorizontalAlignment="Center" VerticalAlignment="Center" Text="{Binding FormattedUpperValue, Mode=OneWay}" Style="{StaticResource valueTextBlockStyle}" />

                                                        </Grid>

                                                    </ControlTemplate>

                                                </Setter.Value>

                                            </Setter>

                                        </Style>

                                        <Style x:Key="LeftGridSplitter" TargetType="GridSplitter">

                                            <Setter Property="Template">

                                                <Setter.Value>

                                                    <ControlTemplate TargetType="GridSplitter">

                                                        <Grid x:Name="RootElement" IsHitTestVisible="{TemplateBinding IsEnabled}">

                                                            <Grid.RowDefinitions>

                                                                <RowDefinition Height="26"/>

                                                                <RowDefinition Height="*"/>

                                                            </Grid.RowDefinitions>

                                                            <Grid.ColumnDefinitions>

                                                                <ColumnDefinition Width="6"/>

                                                                <ColumnDefinition Width="*"/>

                                                                <ColumnDefinition Width="6"/>

                                                            </Grid.ColumnDefinitions>

 

                                                            <!-- Inner Shadow -->

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-.1,5.9,0,0" HorizontalAlignment="Stretch" VerticalAlignment="Top" Height="4" Fill="{StaticResource VerticalShadow}"/>

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-.1,6,0,6" VerticalAlignment="Stretch" HorizontalAlignment="Left" Width="4" Fill="{StaticResource HorizontalShadow}">

                                                                <Rectangle.Clip>

                                                                    <PathGeometry>

                                                                        <PathGeometry.Figures>

                                                                            <PathFigure StartPoint="0,0">

                                                                                <PathFigure.Segments>

                                                                                    <LineSegment Point="5,5"/>

                                                                                    <LineSegment Point="5,26"/>

                                                                                    <LineSegment Point="0,26"/>

                                                                                </PathFigure.Segments>

                                                                            </PathFigure>

                                                                        </PathGeometry.Figures>

                                                                    </PathGeometry>

                                                                </Rectangle.Clip>

                                                            </Rectangle>

 

                                                            <!-- Outer Shadow -->

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="0,0,0,-3.9" HorizontalAlignment="Left" VerticalAlignment="Bottom" Width="4" Height="4" Fill="{StaticResource VerticalShadow}">

                                                                <Rectangle.Clip>

                                                                    <PathGeometry>

                                                                        <PathGeometry.Figures>

                                                                            <PathFigure StartPoint="0,0">

                                                                                <PathFigure.Segments>

                                                                                    <LineSegment Point="5,5"/>

                                                                                    <LineSegment Point="26,5"/>

                                                                                    <LineSegment Point="26,0"/>

                                                                                </PathFigure.Segments>

                                                                            </PathFigure>

                                                                        </PathGeometry.Figures>

                                                                    </PathGeometry>

                                                                </Rectangle.Clip>

                                                            </Rectangle>

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="3.9,0,0,-3.9" HorizontalAlignment="Stretch" VerticalAlignment="Bottom" Height="4" Fill="{StaticResource VerticalShadow}"/>

                                                            <Rectangle Grid.Row="0" Grid.Column="2" Grid.RowSpan="2"  Margin="0,7,-3.9,0" VerticalAlignment="Stretch" HorizontalAlignment="Right" Width="4" Fill="{StaticResource HorizontalShadow}">

                                                                <Rectangle.Clip>

                                                                    <PathGeometry>

                                                                        <PathGeometry.Figures>

                                                                            <PathFigure StartPoint="0,0">

                                                                                <PathFigure.Segments>

                                                                                    <LineSegment Point="5,5"/>

                                                                                    <LineSegment Point="5,26"/>

                                                                                    <LineSegment Point="0,26"/>

                                                                                </PathFigure.Segments>

                                                                            </PathFigure>

                                                                        </PathGeometry.Figures>

                                                                    </PathGeometry>

                                                                </Rectangle.Clip>

                                                            </Rectangle>

 

                                                            <!-- Stem and Shadow -->

                                                            <Rectangle Grid.Row="1" Grid.Column="2" Margin="0,-1,0,-1" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{TemplateBinding Background}"/>

                                                            <Rectangle Grid.Row="1" Grid.Column="2" Margin="0,-1,0,0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{StaticResource RaisedShadow}"/>

 

                                                            <!-- Flag Shape -->

                                                            <Polygon Grid.Row="0" Grid.Column="2" Points="0,26 0,0 1,0 6,5 6,26" Fill="{TemplateBinding Background}" />

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-1,0,-1,0" Fill="{TemplateBinding Background}" HorizontalAlignment="Stretch" VerticalAlignment="Top" Height="6" />

                                                            <Rectangle Grid.Row="0" Grid.Column="1" Margin="-1,0,-1,0" Fill="{TemplateBinding Background}" HorizontalAlignment="Stretch" VerticalAlignment="Bottom" Height="6" />

                                                            <Polygon Grid.Row="0" Grid.Column="0" Margin="0,0,-1,0" Points="0,21 0,0 6,0 6,26 5,26" Fill="{TemplateBinding Background}"/>

 

                                                            <TextBlock Grid.Row="0" Grid.Column="1" Margin="0,2,0,0" HorizontalAlignment="Center" VerticalAlignment="Center" Text="{Binding FormattedValue, Mode=OneWay}" Style="{StaticResource valueTextBlockStyle}"/>

                                                        </Grid>

                                                    </ControlTemplate>

                                                </Setter.Value>

                                            </Setter>

                                        </Style>

                                    </Grid.Resources>

                                    <Grid.ColumnDefinitions>

                                        <ColumnDefinition Width="*"/>

                                        <ColumnDefinition Width="*"/>

                                        <ColumnDefinition Width="*"/>

                                    </Grid.ColumnDefinitions>

                                    <Grid.RowDefinitions>

                                        <RowDefinition Height="*"/>

                                        <RowDefinition Height="6"/>

                                        <RowDefinition Height="*"/>

                                    </Grid.RowDefinitions>

 

                                    <!-- Placeholder rectangles for measuring - should never be displayed -->

                                    <Rectangle x:Name="LeftTrackElement" Grid.Column="0" Grid.RowSpan="3" Fill="Transparent" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>

                                    <Rectangle x:Name="RightTrackElement" Grid.Column="2" Grid.RowSpan="3" Fill="Transparent" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>

 

                                    <!-- The two thumbs -->

                                    <GridSplitter x:Name="LeftGridSplitterElement" Style="{StaticResource LeftGridSplitter}" Grid.Column="0" HorizontalAlignment="Right" Width="{TemplateBinding ThumbWidth}" Background="{TemplateBinding Background}" VerticalAlignment="Bottom" Height="30"/>

                                    <GridSplitter x:Name="RightGridSplitterElement" Style="{StaticResource RightGridSplitter}" Grid.Column="2" HorizontalAlignment="Left" Width="{TemplateBinding ThumbWidth}" Background="{TemplateBinding Background}" VerticalAlignment="Bottom" Height="30"/>

 

                                    <!-- The track and its shadow -->

                                    <Rectangle Grid.Row="1" Margin="{TemplateBinding TrackMargin}"  Grid.ColumnSpan="3" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{TemplateBinding Background}"/>

                                    <Rectangle Grid.Row="1" Margin="{TemplateBinding TrackMargin}"  Grid.ColumnSpan="3" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{StaticResource TrackShadow}"/>

 

                                    <!-- The end caps for the track -->

                                    <Rectangle Grid.Row="1" Margin="{TemplateBinding TrackMargin}" Width="1" HorizontalAlignment="Left" VerticalAlignment="Stretch" Fill="{StaticResource EndCap}"/>

                                    <Rectangle Grid.Row="1" Grid.Column="2" Margin="{TemplateBinding TrackMargin}" Width="1" HorizontalAlignment="Right" VerticalAlignment="Stretch" Fill="{StaticResource EndCap}"/>

                                </Grid>

                            </Grid>

                        </ControlTemplate>

                    </Setter.Value>

                </Setter>

                <Setter Property="Background" Value="DarkGray"/>

                <Setter Property="ThumbWidth" Value="40"/>

            </Style>

        </local:RangeFinder.Style>

    </local:RangeFinder>

</Grid>

 

 

There are some things the RangeFinder sample code is missing - fancy state transitions, rock-solid coercion, and thorough testing. The code is provided as-is but feel free to party away and mutate it in to your own concoction.

RangeFinderExampleCode.zip

]]> Re-templating a WatermarkedTextBox https://docs.microsoft.com/archive/blogs/keithjones/re-templating-a-watermarkedtextbox Fri, 04 Apr 2008 14:32:00 GMT https://blogs.msdn.microsoft.com/keithjones/2008/04/04/re-templating-a-watermarkedtextbox/

Hosted by Silverlight Streaming  

Ta-da! Here's a new look for the WatermarkedTextBox (a.k.a. WTB) in Silverlight 2 Beta 1. This was relatively simple to do just by changing the template.

Here is the XAML for the template:

    <ControlTemplate x:Key="wtbTemplate"  TargetType="WatermarkedTextBox">

        <Grid x:Name="RootElement" >

            <Grid.Resources>

                <Storyboard x:Key="Disabled State">

                    <DoubleAnimation Storyboard.TargetName="DisabledVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0.5" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                </Storyboard>

                <Storyboard x:Key="Disabled Watermarked State">

                    <DoubleAnimation Storyboard.TargetName="DisabledVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0.5" Duration="0:0:0.0"/>

                </Storyboard>

                <Storyboard x:Key="Normal State">

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                </Storyboard>

                <Storyboard x:Key="Focused State">

                    <DoubleAnimation Storyboard.TargetName="FocusVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.1"/>

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                </Storyboard>

                <Storyboard x:Key="MouseOver State">

                    <!--<DoubleAnimation Storyboard.TargetName="FocusVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.1"/>-->

                    <DoubleAnimation Storyboard.TargetName="MouseOverVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.1"/>

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                </Storyboard>

                <Storyboard  x:Key="Normal Watermarked State">

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                </Storyboard>

                <Storyboard x:Key="MouseOver Watermarked State">

                    <!--<DoubleAnimation Storyboard.TargetName="FocusVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.1"/>-->

                    <DoubleAnimation Storyboard.TargetName="MouseOverVisual"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.1"/>

                    <DoubleAnimation Storyboard.TargetName="ELEMENT_Content"

                                     Storyboard.TargetProperty="Opacity"

                                     To="0" Duration="0:0:0.0"/>

                    <DoubleAnimation Storyboard.TargetName="WatermarkElement"

                                     Storyboard.TargetProperty="Opacity"

                                     To="1" Duration="0:0:0.0"/>

                </Storyboard>

            </Grid.Resources>

           

            <!-- To get a white background -->

            <Rectangle HorizontalAlignment="Stretch" VerticalAlignment="Stretch"

                       RadiusX="5" RadiusY="5" Opacity="1" Fill="White"/>

           

            <!-- Simple drop shadow effect on Mouse Over -->

            <Grid x:Name="MouseOverVisual" Opacity="0">

                <Rectangle Height="10" Width="10" RadiusX="5" RadiusY="5"

                           HorizontalAlignment="Right" VerticalAlignment="Bottom"

                           Stroke="Gray" StrokeThickness="4" Margin="0,0,-2,-2">

                    <Rectangle.Clip>

                        <RectangleGeometry Rect="4,4,6,6"/>

                    </Rectangle.Clip>

                </Rectangle>

                <Rectangle Width="3" RadiusX="2" RadiusY="2" HorizontalAlignment="Right"

                           VerticalAlignment="Stretch"  Fill="Gray" Margin="0,5,-2,3"/>

                <Rectangle Height="3" RadiusX="2" RadiusY="2" HorizontalAlignment="Stretch"

                           VerticalAlignment="Bottom"  Fill="Gray" Margin="5,0,3,-2"/>

            </Grid>

           

            <Grid>

                <Grid.RowDefinitions>

                    <RowDefinition Height="3*"/>

                    <RowDefinition Height="5*"/>

                </Grid.RowDefinitions>

               

                <!-- Top of tag-->

                <Rectangle Grid.Row="0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"

                           RadiusX="5" RadiusY="5" Fill="LimeGreen"/>

                <Rectangle Grid.Row="0" Height="5" HorizontalAlignment="Stretch"

                           VerticalAlignment="Bottom" Fill="LimeGreen"/>

                <TextBlock Grid.Row="0" Text="Hello, my name is ..." FontFamily="Comic Sans MS"

                           FontSize="24" Foreground="White" VerticalAlignment="Center" Margin="5,0,0,0"/>

 

                <!-- Bottom of tag where the name is typed -->

                <Border x:Name="ELEMENT_Content" Grid.Row="1" Background="Transparent"

                        BorderBrush="Transparent" BorderThickness="0" HorizontalAlignment="Stretch"

                        VerticalAlignment="Stretch" Padding="10,0,0,0"/>

                <ContentControl

                    Grid.Row="1"

                      x:Name="WatermarkElement"

                      IsTabStop="False"

                      IsHitTestVisible="False"

                      Content="{TemplateBinding Watermark}"

                      Foreground="Gray"

                      Background="{TemplateBinding Background}"

                      FontFamily="{TemplateBinding FontFamily}"

                      FontSize="{TemplateBinding FontSize}"

                      FontStretch="{TemplateBinding FontStretch}"

                      FontStyle="{TemplateBinding FontStyle}"

                      FontWeight="{TemplateBinding FontWeight}"

                      Padding="10,0,0,0"/>

            </Grid>

           

            <!-- A nice black border on top of it all-->

            <Rectangle StrokeThickness="2" Stroke="Black" Fill="Transparent" RadiusX="5" RadiusY="5"

                       HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>

           

            <!-- Show a star if the control has focus -->

            <Polygon x:Name="FocusVisual"  Stroke="Blue" StrokeThickness="1.0" Fill="Blue" Opacity="0"

                     Stretch="Fill" Height="50" Width="50"

                     HorizontalAlignment="Right" VerticalAlignment="Top" Margin="0,-25,-20,0"

                     Points="317.667,129.333 308.043,112.31 320.505,97.2405 301.341,101.133 290.86,84.6235 288.64,104.052 269.7,108.919 287.492,117.034 286.267,136.551 299.483,122.138 317.667,129.333"/>

           

            <!-- Put a semi-transparent mask over the control if it is disabled -->

            <Rectangle x:Name="DisabledVisual" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"

                       RadiusX="5" RadiusY="5" Opacity="0" Fill="#55AAAAAA"/>

        </Grid>

    </ControlTemplate>

Here is the XAML for adding the templated WTB to a page:

    <WatermarkedTextBox Template="{StaticResource wtbTemplate}" Height="100" Width="300" FontFamily="Comic Sans MS" FontSize="36" Watermark="&lt;Bob&gt;"/>

Here are some details for what it took.

1.     Even though I wasn’t changing the watermark or disabled behavior I still had to redefine all of the related template parts.

a.     The WatermarkElement ContentControl is used to host the actual watermark text (or other content if applicable).

b.    The ELEMENT_Content Border is required because that is how the internal text box code knows where to draw the caret and the text that the user types.

c.     The DisabledVisual UI element is not part of the template part contract, but the default disabled state needs it to prevent user interaction with the control.

d.    The Disabled State, Disabled Watermarked State, Normal State, and Normal Watermarked State storyboards all needed to be redefined even if the animations they contained didn’t change. This is a side effect of the control template parts model.

2.     I wanted to change the layout and the focus and mouse over visuals.

a.     I used a nested grid to help layout all of the different pieces of the UI.

b.    I created a drop shadow UI element that I called MouseOverVisual and a star UI element that I called FocusedVisual.

c.     Notice that the names don’t end with “Element”. The convention for the control template parts model is that only those UI elements that are actually part of the contract and used by the internal control code should end with “Element”.

d.    Just adding the visuals wasn’t enough, I needed to update the Focused State, MouseOver State, and MouseOver Watermarked State storyboards to change the opacity of the visuals for the appropriate user actions.

e.     Bug Alert! The internal code for the WTB has a flaw that causes the MouseOver states to always override the Focused state. Therefore, if you use the mouse to set the focus on the control, the FocusVisual UI element never gets displayed. However, if you tab to the control to set the focus, the visual will get displayed (try it out – tab between the default WTB and the re-templated WTB). You could always uncomment the commented out code in the MouseOver storyboards to combine the two behaviors. This flaw isn’t obvious in the default WTB because there aren’t separate UI elements for the focus and mouse over states.

3.     Lastly, I needed to set the Template property and not the Style property of the target WTB due to the fact that the Template is set in the constructor in WTB. This is discussed a little more in one of my other posts.

 

]]> How to set the XAML editor to full view by default https://docs.microsoft.com/archive/blogs/keithjones/how-to-set-the-xaml-editor-to-full-view-by-default Mon, 10 Mar 2008 00:50:00 GMT https://blogs.msdn.microsoft.com/keithjones/2008/03/10/how-to-set-the-xaml-editor-to-full-view-by-default/ For hard-core XAML programmers or just to boost performance when working with XAML files in VS 2008, you may want to have the default view be just the XAML editor (no designer visible). To do so, select the Tools->Options... menu item. Then navigate in the tree view to Text Editor->XAML->Miscellaneous. Check the box for "Always open documents in full XAML view". Click OK to save.

]]> Silverlight 2 Beta 1 Hints https://docs.microsoft.com/archive/blogs/keithjones/silverlight-2-beta-1-hints Wed, 05 Mar 2008 18:53:00 GMT https://blogs.msdn.microsoft.com/keithjones/2008/03/05/silverlight-2-beta-1-hints/ Remember, it is a beta so there are going to be some things that are by design and others which just need temporary workarounds. Here are some things I learned when developing and testing some of the controls delivered as part of the Silverlight 2 Beta 1 SDK.

1.      Unlike WPF, the xaml in Silverlight 2 is parsed at runtime, not compile time. (By Design)

 

2.      The Style property can only be set once on a control. If you are creating a custom control don't set the Style property in the constructor or nobody will be able to style your control.

 

3.      Setters in styles do not override any properties set in code. For example, if the constructor of a custom control calls this.Template = someTemplate, then there is no way for a Setter in a style to  change the Template property. However, setting the property directly in xaml does override the value set in constructor. (By Design)

 

4.      Bindings using dependency properties as sources do not notify the target when the source changes. To workaround this issue temporarily, you should create a business object that implements the INotifyPropertyChanged interface and can be used as a proxy for any dynamic data binding that you may need to do.

 

5.      If you set the Template attribute of a control (whether through a Setter property in a Style or by directly setting the Template property) you will need to redefine the animation storyboards to get the state transition effects (e.g. MouseOver). For examples of the default templates from which you can copy and paste, check out https://msdn2.microsoft.com/en-us/library/cc278075(vs.95).aspx . (By Design)

 

6.      Anything that uses a ContentControl to display text (like Button) cannot simply use styles to change the FontFamily, FontStretch, FontSource, FontStyle, and FontWeight properties. This is a bug that will be fixed in future releases. Instead, you will have to explicitly set those properties on each instance of the element. For example

<Style x:Name="topLink" TargetType="HyperlinkButton">

    <Setter Property="FontSize" Value="24" />

    <Setter Property="Foreground" Value="#000000" />

</Style>

<HyperlinkButton Style="{StaticResource topLink}" FontFamily="Verdana"/>

 

7.      You cannot set the Style property for the TextBox or (correction) WatermarkedTextBox controls because the controls currently set the Style in the constructor (see #3). To change the appearance of these controls you need to set the Template property explicitly

<WatermarkedTextBox  Template="{StaticResource wtbTemplate}"/>

8.      You can only call the Begin() method on a storyboard after the object has been added to the visual tree. Specifically, if you construct a brand new control but don’t add it to a visible parent, calling Begin() on a storyboard affecting that control will throw an exception.

]]>