Bindable LINQ

New Post: Bindable LINQ + Charting from Silverlight Toolkit

mihailik — Sun, 14 Jun 2009 12:40:31 GMT

Hi,

I have created a demo of using Bindable LINQ for Charting here:

http://bindablelinqcharting.codeplex.com/

The app is very simple, but shows a really easy way to get charts from your business data.

Cheers

Oleg.

New Post: How to make property visible in Visual studio designer?

JNikolov — Tue, 09 Jun 2009 13:39:48 GMT

I have a property of type IBindableQuery.

I want to bind that property to a control on windows form using Visual Studio 2008 designer.

But I can’t see the property In designer.

How shoud I bind that property through Visual Studio 2008 designer?

New Post: Still active?

cameronm — Thu, 28 May 2009 02:26:51 GMT

I really hate to ask this question, but is Bindable LINQ still active?

New Post: Is binding on nested collections supported?

mihailik — Fri, 08 May 2009 14:25:08 GMT

Yes, it looks like SelectMany is not working properly, I tried to do similar things and failed too.

New Post: Is binding on nested collections supported?

jamesthurley — Fri, 08 May 2009 08:56:51 GMT

Update: I just tried the above scenario with ComponentOne's LiveLINQ and it works correctly, so this does appear to be a limitation of the current version of BindableLINQ.

James.

New Post: Delayed change 'tracking

mihailik — Thu, 07 May 2009 23:07:44 GMT

Hi,

I wonder whether Bin-LINQ can implement a feature.

Whenever some of the dependencies change, current implementation recalculates result. When one of the dependencies is TextBox-like, you'd want to have half-second delay before applying recalculations. It means when user types a word, there will be just one recalculation instead of one for every letter typed.

I understand the change would be around IDispatcher-implementors. There are several options for visible API, but that's not too important as soon as the feature is there somewhere.

The only thing that bothers me is how safe is it to delay those events. Well, they are already somewhat delayed in some cases (when change is marshalled between threads). But particularly IBindingList notification model looks prone to delays. It is based on indices, not objects, which means if you don't convert index to object straight away, you may miss your chance forever, as the new event may render the first index unusable.

Many thanks

Oleg.

New Post: Is binding on nested collections supported?

jamesthurley — Thu, 07 May 2009 15:40:54 GMT

In this scenario I have a collection of items, and each item has a collection of sub-items. I want BindableLINQ to return me a list of all the sub-items in all items.

I've included the code which tests this scenario, but where the standard LINQ query correctly retuns 1 sub-item the BindableLINQ version doesn't update and returns zero sub-items.

Is this not supported, or have I made an error in my usage?

    class Program
    {
        static void Main(string[] args)
        {
            Root r = new Root();

var bindableLinqResult = r.Items.AsBindable().SelectMany(i => i.SubItems.AsBindable());

            Item a = new Item();
            r.Items.Add(a);
            a.SubItems.Add(new SubItem());

var standardLinqResult = r.Items.SelectMany(i => i.SubItems.AsBindable());

            Console.WriteLine("BindableLINQ: " + bindableLinqResult.Count);
            Console.WriteLine("LINQ: " + standardLinqResult.Count());
        }
    }

    class Root
    {
        ObservableCollection<Item> items = new ObservableCollection<Item>();
        public ObservableCollection<Item> Items { get { return this.items; } }
    }

    class Item
    {
        ObservableCollection<SubItem> subItems = new ObservableCollection<SubItem>();
        public ObservableCollection<SubItem> SubItems { get { return this.subItems; } }
    }

class SubItem { }

Created Issue: BindingListAdapter does not implement ITypedList - Affects binding to empty set

reddogaw — Wed, 15 Apr 2009 21:28:49 GMT

Paul,

BindingListAdapter should implement ITypedList in order to allow WinForms DataGridView column binding to succeed when the binding list is initially empty.

Code is:

// This method is only used in the design-time framework
// and by the obsolete DataGrid control.
public string GetListName(PropertyDescriptor[] listAccessors)
{
return typeof(TElement).Name;
}

public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
{
PropertyDescriptorCollection pdc = null;
if (null == listAccessors)
{
pdc = new PropertyDescriptorCollection(_propertyDescriptors.Values.ToArray());
}
else
{
// Return child list shape.
pdc = ListBindingHelper.GetListItemProperties(listAccessors[0].PropertyType);
}
return pdc;
}

Where ListBindingHelper is in the System.Windows.Forms namespace...

Hope this helps,
Andrew.

Created Issue: UnionIterator does not work. Affects SelectMany too.

reddogaw — Fri, 03 Apr 2009 17:25:42 GMT

Hey Paul!

So I was trying to use a SelectMany operation and due to some dysfunction in the UnionIterator it wasn't evaluating the child lists soon enough.

I think I've fixed it, but I'm not positive that I should be evaluating the child list at such a soon point in time. Please look it over.

Find attached some very limited unit tests for the Union operation as well as the UnionIterator class with changes to the Action's for when ChildCollection's are added.

Cheers,
Andrew.

Created Issue: I can't compile in SILVERLIGHT

mhnyborg — Tue, 17 Mar 2009 15:05:30 GMT

Error 19 Cannot convert lambda expression to type 'System.Delegate' because it is not a delegate type C:\Data\Silverlight\bindablelinq-25046\trunk\source\Bindable.Linq\Threading\SilverlightDispatcher.cs 35 21 Bindable.Linq

New Post: BindableLinq vs LiveLinq?

meisen — Fri, 13 Mar 2009 01:40:20 GMT

LiveLinq has two areas of functionality:
(1) Optimizing LINQ performance, mainly with indexes;
(2) What we (ComponentOne) call "live views".
Live view functionality is similar to Bindable LINQ.
Indexing (optimization, speedup) functionality is not present in Bindable LINQ.
Also, Live LINQ optimizes the process of updating (what we call "maintaining") its
views, similar to some Incremental View Maintenance algorithms, to make view maintenance as fast as possible.
Optimization also allows to use LiveLinq live views not only in GUI (what we call "immediate maintenance mode"), but also in non-GUI, batch tasks ("deferred maintenance mode", enabling what we tentatively call "view-oriented programming").
Also, LiveLinq supports joins in live views (not yet supported in Bindable LINQ), which is critical for many applications.
On the other hand, Live LINQ does not yet support automatic handling of dependencies (other than standard LINQ dependencies),
a feature supported in Bindable LINQ.
And I, one of the LiveLinq authors, would love to talk to you.

-Michael Eisenstein, ComponentOne

New Post: BindableLinq vs LiveLinq?

stovellp — Thu, 12 Mar 2009 03:23:22 GMT

Thanks for sharing Craig, I too am interested in what the differences are.

New Post: BindableLinq vs LiveLinq?

CraigD — Wed, 11 Mar 2009 21:56:11 GMT

I only just saw LiveLinq in an email from ComponentOne... it sounds a bit like BindableLinq - "Live view is a LINQ query result that is kept constantly up-to-date without re-populating it every time its base data changes. This makes LiveLinq extremely useful in common data-binding scenarios where objects are edited and may be filtered in or out of views".

I haven't had a chance to try it out - will post something when I do - but am interested if anyone already has an opinion on similarities/differences...

New Post: Group By in VB

bjgrosse — Tue, 03 Mar 2009 02:23:26 GMT

I just downloaded the Bindable LINQ framework. I really like the looks of it. Unfortunately, using VB (Visual Studio 2008) I seem to be unable to get it to compile a Group By query using AsBindable. I've created an issue report here. Has anyone else seen this problem, or has anyone successfully using Group By loginc with Bindable LINQ?

Thanks,
Benjamin

Created Issue: Unable to Group By in VB

bjgrosse — Tue, 03 Mar 2009 02:16:30 GMT

I seem to be completely unable to utilize Bindable Linq in a Group By query. I've downloaded the latest codebase and compiled without a problem.

As an example of my problem, the following standard Linq works fine:

DataContext = From p In people Group p By p.Gender Into Items = Group

But when I add .AsBindable like this...

DataContext = From p In people.AsBindable() Group p By p.Gender Into Items = Group

...I get the following compilation error:

Overload resolution failed because no accessible 'GroupBy' is most specific for these arguments:
Extension method 'Public Function GroupBy(Of TKey, TResult)(keySelector As System.Func(Of Person, TKey), resultSelector As System.Func(Of TKey, System.Collections.Generic.IEnumerable(Of Person), TResult), comparer As System.Collections.Generic.IEqualityComparer(Of TKey)) As System.Collections.Generic.IEnumerable(Of TResult)' defined in 'System.Linq.Enumerable': Not most specific.
Extension method 'Public Function GroupBy(Of Person.Genders, Person, <anonymous type>)(keySelector As System.Func(Of Person, Person.Genders), elementSelector As System.Func(Of Person, Person), resultSelector As System.Func(Of Person.Genders, System.Collections.Generic.IEnumerable(Of Person), <anonymous type>)) As System.Collections.Generic.IEnumerable(Of <anonymous type>)' defined in 'System.Linq.Enumerable': Not most specific.
Extension method 'Public Function GroupBy(Of TKey, TResult)(keySelector As System.Linq.Expressions.Expression(Of System.Func(Of Person, TKey)), resultSelector As System.Linq.Expressions.Expression(Of System.Func(Of TKey, Bindable.Linq.Interfaces.IBindableCollection(Of Person), TResult)), comparer As System.Collections.Generic.IEqualityComparer(Of TKey)) As Bindable.Linq.Interfaces.IBindableCollection(Of TResult)' defined in 'Bindable.Linq.BindableEnumerable': Not most specific.
Extension method 'Public Function GroupBy(Of Person.Genders, Person, <anonymous type>)(keySelector As System.Linq.Expressions.Expression(Of System.Func(Of Person, Person.Genders)), elementSelector As System.Linq.Expressions.Expression(Of System.Func(Of Person, Person)), resultSelector As System.Linq.Expressions.Expression(Of System.Func(Of Person.Genders, Bindable.Linq.Interfaces.IBindableCollection(Of Person), <anonymous type>))) As Bindable.Linq.Interfaces.IBindableCollection(Of <anonymous type>)' defined in 'Bindable.Linq.BindableEnumerable': Not most specific.
Extension method 'Public Function GroupBy(Of TKey, TResult)(keySelector As System.Linq.Expressions.Expression(Of System.Func(Of Person, TKey)), resultSelector As System.Linq.Expressions.Expression(Of System.Func(Of TKey, Bindable.Linq.Interfaces.IBindableCollection(Of Person), TResult)), dependencyAnalysisMode As Bindable.Linq.DependencyDiscovery) As Bindable.Linq.Interfaces.IBindableCollection(Of TResult)' defined in 'Bindable.Linq.BindableEnumerable': Not most specific.

I'm not sure if this is a problem with my syntax (I've tried every variation I can come up with) or if Bindable Linq needs some tweaking to be compatible with VB.

New Post: Bindable LINQ vs Continuous LINQ

ky0ung123 — Tue, 17 Feb 2009 02:22:28 GMT

I poked around a little and see from your Tech-Ed presentation that the author is aware of C-Linq, but would still value your opinions on how they compare/contrast.

New Post: Bindable LINQ vs Continuous LINQ

ky0ung123 — Tue, 17 Feb 2009 01:25:03 GMT

I was wondering if you have seen continuous LINQ and how Bindable LINQ compares/contrasts to that project. Seems like they are similar in nature.

New Post: Linq to SQL - collections aren't Observable

rjempson — Fri, 14 Nov 2008 05:46:26 GMT

I have a Linq to SQL data access layer upon which I bind some WPF UI, particularly a grid. The following works nicely, where SiteEntity.SiteTanks is a LINQ to SQL collection.

Private IBindingList _siteTanks;
        public IBindingList SiteTanks
        {
            get
            {
                    _siteTanks = this.SiteEntity.SiteTanks.GetNewBindingList();
                    _siteTanks.ListChanged += new ListChangedEventHandler(_siteTanks_ListChanged);
                    return _siteTanks;

I can
a) add entities to the underlying data source and the grid picks up the changes.
b) delete from - ditto (because I can call _siteTanks.Remove() in addition to the Linq to sql DeleteOnSubmit(instance)
c) I can edit the entity properties and the ListChanged event fires, thus allowing me to know the data IsDirty.

However, at some point I know that I will need to filter the list based on user actions, eg adding a filter condition such as "ProductTypeID = 2". Hence my interest in Bindable LINQ.

I have considered and tried an implementation using Bindable LINQ. However none of the above work. Editing the items on the list works, as point c), but the grid isn't notified.

New Post: Strong Name Key on DLL

BestSnowman — Thu, 06 Nov 2008 03:37:14 GMT

It would be nice if the release DLL was signed so signed applications can load it. Being New BSD license it isn't a huge deal to recompile it, but it would be nice to not have to if possible.

Otherwise very cool, this made my day when I found it today!

New Post: Add support for System.Linq.IQueryable

stovellp — Thu, 09 Oct 2008 16:13:45 GMT

Hi Norman,

Since you'd be doing the operation yourself, you can control routing back to the UI thread, and controlling when the query is re-executed. This would be required because things like "wait 3 seconds for the user to stop typing" is a very UI-oriented thing (out of interest, I'd probably do this via an attached dependency property, and use Explicit bindings on a TextBox, and then have my ADP manage the timers and push the value when the timer ticked).

Here's an example of a super basic "integration point":

private static ObservableCollection<WeakReference> _allKnownCustomers = new ObservableCollection<WeakReference>();

public static IBindableCollection<Customer> SearchForCustomers(string name)
{
     // Start a background thread to fetch stuff from the DB using Stored Procs, web services, LINQ to SQL, whatever, using the "name" property
     // When it completes, use the Dispatcher to route the fetched items to the _allKnownCustomers collection. It'll raise events, and the query below get them and update...

     // This code is just performing an in-memory query on the items you fetched last time
     return _allKnownCustomers.Select(wr => (Customer)wr.Target).Where(c => c.Name.Contains(name));
}

The key here is that you're returning a bindable collection, which means as items can be added as they are yielded form the background thread, and the UI will get them. If you wanted to extend it to the point of doing live queries as the user types in a text box, you'd be doing similar things but with a more stateful object containing the query, and you'd cancel the current background thread and start a new one each time.

There's a bunch of things you could customize with such an "integration point" framework:

How items are stored. Above I used a weak references, so the GC can clean them up when they aren't used. You might instead choose to use the Caching Application Block
The "scope" of the integration point and the items it manages (and tracks changes to). Per call, per some context, or maybe global.
How you'll do conflict detection and resolution, and whether you'll only ever have one instance of any item at once (an IdentityMap pattern)
How you'll handle timeouts and drop outs in connectivity, via a Circuit Breaker pattern
How you'll receive updates. SQL query notifications, polling, or WCF duplex bindings

What's nice about this is that although many of these problems are tricky, it's easy to abstract them and build some common patterns around them. Then, you abstract the whole thing in an "integration point". That integration point can be a service shared throughout your application, so that from the 3 views where you show the status of a job on a server, all 3 of them are always in sync, and yet you only have one active duplex channel or query notifications connection managed by the integration point.

I'm hoping this could replace all external communication from my WPF applications. Conceptually, you treat external calls of any nature as discreet interactions, but the rest of your application is completely reactive.