run80

I think it’s one of the most common scenarios around, you would like to bind a button set for use of typical operations.

See those 3 little buttons next to the title? It’s a very common case, having 3 generic buttons for CRUD operations over data right next to datagrid for ease of use. It can be whatever and you could effectively put there a few more, but this will suffice for showing off a nice way how caliburn.micro can make your life easier.
So for instance you have this control with these generic buttons, and you called it ListButtons:

<UserControl x:Class="AltinetSilver.AltiControls.ListButtons"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:telerik="clr-namespace:Telerik.Windows.Controls;assembly=Telerik.Windows.Controls" mc:Ignorable="d"
    VerticalAlignment="Bottom" Margin="5,0,5,0">
    <UserControl.Resources>
        <SolidColorBrush x:Key="BorderBrush" Color="#FF767676" />
    </UserControl.Resources>
    <StackPanel Orientation="Horizontal" Grid.Column="1" HorizontalAlignment="Right">
        <Button x:Name="Add" BorderBrush="Transparent" BorderThickness="0,0,0,0" Visibility="{Binding AddNewButtonVisibility}" Height="18" Margin="2,4,2,4" Width="18"/>
        <Button x:Name="Edit" BorderBrush="Transparent" BorderThickness="0,0,0,0" Visibility="{Binding EditButtonVisibility}" Height="18" Margin="2,4,2,4" Width="18"/>
        <Button x:Name="Delete" BorderBrush="Transparent" BorderThickness="0,0,0,0" Visibility="{Binding DeleteButtonVisibility}" Height="18" Margin="2,4,4,4" Width="19" Padding="0"/>
    </StackPanel>
</UserControl>

U use it in your PartnersView.xaml in the following way

.
.
<StackPanel Orientation="Horizontal">
     <TextBlock Style="{StaticResource HeaderStyle}" VerticalAlignment="Top" Text="{Binding Partners,Source={StaticResource Strings}}"/>
     <AltiControls:ListButtons x:Name="PartnerButtons"/>
</StackPanel>
.
.

It’s the code shown from the picture above, buttons next to the header. Notice the name of the control, it’s important for the convention

Your PartnersViewModel.cs looks something like this, with commands for using those buttons:

.
.
        public void AddPartner()
        {

        }

        public bool CanAddPartner
        { get { return true; }}

        public void DeletePartner()
        {

        }

        public bool CanDeletePartner
        {
            get { return SelectedPartner != null; }
        }

        public void EditPartner()
        {

        }

        public bool CanEditPartner
        {
            get { return SelectedPartner != null; }
        }
.
.

So you want to hook up these methods to those generic buttons without any extra work.
First let’s define how a convention would look like

            ConventionManager.AddElementConvention<ListButtons>(UserControl.ContentProperty, "DataContext", null)
                .ApplyBinding = (viewModelType, path, property, element, convention) =>
                                    {

                                        var buttons = element as ListButtons;
                                        if (buttons == null) return;
                                        if (!buttons.Name.EndsWith("Buttons")) return;
                                        var entName = buttons.Name.Remove(buttons.Name.IndexOf("Buttons"));
                                        SetListButton(viewModelType, buttons.Add, "Add" + entName);
                                        SetListButton(viewModelType, buttons.Edit, "Edit" + entName);
                                        SetListButton(viewModelType, buttons.Delete, "Delete" + entName);
                                    };

What we are doing here is searching for naming convention for ListButtons class. It has to start with entity name and end with “Buttons” text. After we find it, we go through buttons and Set them up.
SetListButton function looks like following:

        private static void SetListButton(Type modelType,AltiButton button,string methodName)
        {
            if (modelType.GetMethod(methodName) != null)
                Message.SetAttach(button, methodName);
            else
                button.Visibility = Visibility.Collapsed;
        }

So there you have it. This method basically hooks up a button with an appropriate methodname, or it hides the button.
One last thing left to do. We need to define a property in the main viewmodel so we expose the object which holds our button methods. For the previous example, you just add the following to PartnersViewModel.cs

        public object PartnerButtons
        {
            get { return this; }
        }

Caliburn will hook the property to “PartnerButtons” user control, and the convention will do the rest. Hope this helps!

AutoCompleteBox connected to web service is often needed solution, and there are many solutions out there that are bare bone ones, but using such powerful UI framework as Caliburn.Micro is can reap some interesting benefits. So here’s my implementation.
I decided to subclass AutoCompleteBox because i subclass all of the controls i use. I called it AltiAutoCompleteBox.
A new event was added called PopulatingAsync and a new EventArg called PopulatingAsyncEventArgs:

AltiAutoCompleteBox basically just adds another event PopulatingAsync which is called every time Populating event is called:

    public partial class AltiAutoCompleteBox:AutoCompleteBox
    {
        public event EventHandler<PopulatingAsyncEventArgs> PopulatingAsync;

        public AltiAutoCompleteBox()
        {
            MinimumPopulateDelay = 500;
            MinimumPrefixLength = 2;
            FilterMode = AutoCompleteFilterMode.None;
            // handle the populating event of the associated auto complete box
            Populating += AssociatedObject_Populating;

        }

        private void AssociatedObject_Populating(object sender, PopulatingEventArgs e)
        {
            if (PopulatingAsync == null) return;

            PopulatingAsync(this,new PopulatingAsyncEventArgs(PopulateComplete,e.Parameter));
            // cancel the population of the auto complete box
            e.Cancel = true;
        }
    }

PopulatingAsyncEventArgs class is consisted of a Parameter and an action which will be called on ViewModel side when population of items is complete. It basically calls a PopulateComplete Action of AutoCompleteBox

    public class PopulatingAsyncEventArgs:EventArgs
    {
        public PopulatingAsyncEventArgs(Action complete,string parameter)
        {
            PopulateComplete = complete;
            Parameter = parameter;
        }

        public string Parameter { get; private set; }

        public Action PopulateComplete { get; private set; }
    }

On viewmodel side you do it something like this:

        public void FilterPartners(PopulatingAsyncEventArgs args)
        {
            Context.Load(Context.GetPartnersQuery().Where(x => x.Name.Contains(args.Parameter)),
                        x =>
                            {
                                PartnerList.Clear();
                                PartnerList.AddRange(x.Entities);
                                args.PopulateComplete();
                            }

                         , null);
        }

And on the view side you hook it up like this:

 <AltiControls:AltiAutoCompleteBox
 Micro:Message.Attach="[Event PopulatingAsync]=[Action FilterPartners($eventArgs)]"
SelectedItem="{Binding Partner,Mode=TwoWay}"
ItemsSource="{Binding ElementName=ClaimFormUc, Path=DataContext.PartnerList}"/>

The important thing is the Message.Attach part.

And that’s basicall it! Next time you want to use this AutoCompleteBox, you just define the service and hook it up with message.Attach! And it has that yummy bubbling through visual tree built in and all!

Till next time..:)

I needed a classic “where guid in” type of query to do (though i’m not sure if i should be thinking in that way when using linq:) so i poked around a bit, but couldn’t find anything good. So here it is:

        public static IQueryable<T> WhereIn<T,TMember>(this IQueryable<T> query, Expression<Func<T, TMember>> member, IList<TMember> inList) where T : BaseEntity
        {
            if (inList.Count() == 0) return query.Where(x => false);
            Expression<Func<TMember, bool>> expr = x => Enumerable.Contains(inList,x);
            var method = ((MethodCallExpression)expr.Body).Method;
            var expression = Expression.Call(null, method, ((MethodCallExpression)expr.Body).Arguments[0], member.Body);
            var lambda = Expression.Lambda<Func<T, bool>>(expression, "inLambda", member.Parameters);
            return inList.Count() > 0 ? query.Where(lambda) : query.Where(x => false);
        }

A classic example of usage would be something like this

Repository.Query<Partner>().WhereIn(x => x.Guid, partnerGuidList))

We are basically selecting partners by partnerguid, it’s very useful for paging and such.

An ispiration for this type of solution came from the this blog post for catching future values. Hope this helps!

Well, i ran into an issue while inserting multiple records which is nicely described in my post on a forum:

http://forums.silverlight.net/forums/t/222783.aspx

Long story short, ria services doesn’t take care of the ordering of the items when calling insert methods for entities, ie it could easily call insert on child before parent. This problem doesn’t show itself when using Composition attribute, but it’s not like you want to use that attribute every time, so if you’re not using you’re pretty much leaving yourself at the mercy of your ORM. And Nhibernate is pretty crude sometimes in some respects, one of them being the data insertion.
If you don’t explicitly establish 2-way connection, NHibernate is just going to insert the data in the order you persisted it. Which in combination with RIA Service’s indifference is BAD.
I won’t give any sample project because it’s a bit difficult to extract plus i don’t have time, but this is the basic principle.
I decided to make a workaround on the Service level. What i decided to do is make an override on domainservice’s Submit method.

        public override bool Submit(ChangeSet changeSet)
        {
            InsertList = changeSet.ChangeSetEntries
                .Where(x => x.Operation == DomainOperation.Insert && x.Entity is BaseEditModel)
                .Select(y => new InsertEntry(false, y)).ToList();

            foreach (var entry in InsertList)
            {
                if (!entry.Inserted)
                {
                    PersistEntry(entry, InsertList);
                }
            }
            return base.Submit(changeSet);
        }

BaseEditModel is a base class i use for all the Presentation models, you should use your own base clas, the point is that you just take entites which are getting inserted.
InsertEntry class is pretty basic:

        private class InsertEntry
        {
            public InsertEntry(bool inserted, ChangeSetEntry entry)
            {
                Inserted = inserted;
                Entry = entry;
            }

            public ChangeSetEntry Entry { get; set; }

            public bool Inserted { get; set; }

        }

It’s used basically for keeping track of already persisted entities.
The meat of the solution is in the PersistEntry method:

        private void PersistEntry(InsertEntry insEntry, IEnumerable<InsertEntry> insertList)
        {
            if (insEntry.Inserted) return;
            var entPm = (BaseEditModel)insEntry.Entry.Entity;
            if (entPm == null) return;
            if (insEntry.Entry.Associations != null)
//iterate through associations of the entry
                foreach (var ass in insEntry.Entry.Associations)
                {
//test if the association is a foreign key association
                    if (IsForeignKey(entPm.GetType(), ass.Key))
                    {
//find the entity from association in the insertList
                        var entryTup = insertList.FirstOrDefault(x => x.Entry.Id == ass.Value[0]);
//if it's found and it's not already inserted, insert it
                        if (entryTup != null && !entryTup.Inserted)
//the insertion is done recursively
                            PersistEntry(entryTup, insertList);
                    }
                }
//since i'm using the presentation model, i first have to find the corresponding domain entity model
            var entType = GetEntType(entPm);
            var ent = (BaseEntity)Activator.CreateInstance(entType);
            ent.Guid = entPm.Guid;
//sets the entity properties from presentation model
            entPm.SetEntity(ent, this);
//and finally persist it
            Repository.Persist(ent);
//set the inserted property to true so that the same entity doesn't get inserted 2 times
            insEntry.Inserted = true;
        }

The IsForeignKey method basically tests the association of a property for foreignkey bool value

        private static bool IsForeignKey(Type entPmType, string propName)
        {
            var propInfo = entPmType.GetProperties().FirstOrDefault(x => x.Name == propName);
            if (propInfo == null) return false;
            var assAtt = propInfo.GetCustomAttributes(typeof(AssociationAttribute), false)[0] as AssociationAttribute;
            return assAtt != null && assAtt.IsForeignKey;
        }

I documented the code the best i could, so i hope you get the picture. The only thing left to do is to modify the InsertEntity methods so that it doesn’t persist anything, because we already persisted it.

        protected void InsertEntity(TPm entityPm)
        {
            var entity = Repository.GetItem(entityPm.Guid);
            ChangeSet.Associate(entityPm, entity, UpdateEntityPmAttributes);
        }

So the previous method is used mostly to do the Association, we already did the persistion stuff in the submit method.
And that’s basically it, we did the insertion in the order which respects associations, and therefore you don’t get those nasty foreign key sql exceptions. Hope it’s well explained and you’ll find the way to use it on your example. It can easily be used on Entity domain models too.
Hope this helps!

Ok, i’m putting this here so i can get back to this later and finally write this one down, along with some nice examples and code samples.
This is a sequal of on of previous blog posts. It turned out to be REALLY beneficial, for a number of reasons so stay tuned…. Now onward with the topic of the day….