clinq Work Item Rss Feed

Created Issue: Possible bug in ExpressionPropertyAnalyzer.AnalyzeLambda [9271]

candritzky — Fri, 30 Mar 2012 07:09:29 GMT

The for-loop in the ExpressionPropertyAnalyzer.AnalyzeLambda lambda method looks suspicious to me:

for (int i = 0; i < expression.Parameters.Count; i++)
{
ParameterExpression parameterExpression = expression.Parameters[0];
tree.Children.Add(new ParameterNode(parameterExpression.Type, parameterExpression.Name));
}

Shouldn't the line

ParameterExpression parameterExpression = expression.Parameters[0];

be changed to:

ParameterExpression parameterExpression = expression.Parameters[i];

Commented Issue: Using with .NET 4.0 [6958]

rea5245 — Fri, 11 Mar 2011 18:32:53 GMT

I had a little bit of a difficulty using this within a .NET 4.0 solution. The compiler was complaining that there were duplicate implementations of the Func and Action delegates. In the end, I recompiled the solution (Clinq 2.2) and updated the Curry.tt file so that it didn't create as many of these delegates. I've attached my updated Curry.tt file.
Comments: ** Comment from web user: rea5245 **

I see what happened. Curry.tt generates a bunch of System.Action<> and System.Func<> delegates with as few as 6 and as many as 20 arguments. In 3.5, .NET only included Action and Func with up to 5 arguments, so there was no name collision. In 4.0, .NET has added Action and Func delegates with up to 16 arguments, so the names Curry was generating collided.

Your modification removes Curry's Action and Func with 6 through 16 arguments but continues to generate them with 17, 18, 19, and 20 arguments.

Alas, I figured this all out on my own before coming across your post. Still, thank you!

Created Issue: Possible Bug in ContinuousLinq 2's SubscriptionNode class [7327]

nallenwagner — Fri, 01 Oct 2010 20:42:50 GMT

I think there is an issue in the SubscriptionNode class. This seems to be preventing CLinq from detecting changes in some multi-value expressions. As a result, some continuous value based expressions are not kept up to date.

On line 91 of SubscriptionNode.cs (in ContinuousLinq2), I think the following lines should be changed from:

...
if (nodeMatchingPropertyName == null)
return;

nodeMatchingPropertyName.UpdateSubject(this.Subject);
...

to
...
if (nodeMatchingPropertyName != null)
nodeMatchingPropertyName.UpdateSubject(this.Subject);
...

To reproduce this scenario, construct a multi-value ContinuousValue like:

_result = LineItems.AsReadOnly().ContinuousSum(item => item.NumberPurchased * item.Product.UnitCost);

where LineItems is a collection of classes with a numeric NumberPurchased property and another property that references the Product class, which in turn has a numeric property UnitCost.

In this case, changes to the Product's UnitCost will update the _result. However, changes tot he item.NumberPurchased will not update the _result value.

The code in the current version of SubscriptionNode will cause the OnPropertyChanged method to return before it has a chance to invoke the PropertyChanged() delegate on the last line of the method.

The attached project includes a sample that reproduces the issue.

Created Issue: Readding an item causes ArgumentException [7003]

jbcooley — Mon, 19 Jul 2010 22:32:06 GMT

This test (added to WhereTest) fails.

[Test]
public void ClearSource_ThenAdd_SameItems()
{
ReadOnlyContinuousCollection<Person> output = from person in _source
where person.Age > 10
select person;
Assert.AreEqual(1, output.Count);
List<Person> oldItems = new List<Person>(_source);
_source.Clear();
Assert.AreEqual(0, output.Count);
_source.Add(oldItems[0]);
Assert.AreEqual(0, output.Count);
_source.Add(oldItems[1]);
Assert.AreEqual(1, output.Count);
}

Patch provided in Patches section.

Commented Issue: Collections of internal types [6983]

jbcooley — Tue, 13 Jul 2010 16:08:45 GMT

Change 46495 breaks using continuous linq on some collections containing internal types with a TypeLoadException at DynamicProperty.GetValue. Changing the DynamicMethod construction back fixes this issue.
Fixed (older) code below:
DynamicMethod dynamicMethod = new DynamicMethod(
string.Empty,
typeof(object),
new[] { typeof(object) },
_property.Module,
true);
Comments: ** Comment from web user: jbcooley **

It appears this old code doesn't work in Silverlight. Please consider adding this to the sections that need #if for each platform.

Created Issue: Collections of internal types [6983]

jbcooley — Tue, 13 Jul 2010 15:53:14 GMT

Created Issue: Using with .NET 4.0 [6958]

nallenwagner — Wed, 07 Jul 2010 16:57:06 GMT

Closed Issue: skiplisttest.cs missing [5493]

akutruff — Tue, 08 Jun 2010 19:58:42 GMT

Referenced in ContinuousLinq.UnitTests.csproj
Comments:

Created Issue: Needed for Windows Phone 7 Series projects [6292]

richoncode — Fri, 09 Apr 2010 18:42:01 GMT

CLinq offers much more efficient incremental updates to collections than whole requeries. As such is could be very valuable to have it on the phone where processor, UI update costs, and battery life are at a premium.

Commented Issue: Can't compile 'Hello World - CLINQ Style' [5450]

Natxo — Fri, 29 Jan 2010 11:02:24 GMT

My problem is that the select statement when creating _legalDrinkers doesn't compile. The error message is as follows:

Cannot implicitly convert type 'ContinuousLinq.ReadOnlyContinuousCollection<ConsoleApplication1.Customer>' to 'ContinuousLinq.ContinuousCollection<ConsoleApplication1.Customer>'

I am using version 2.1.0.0 of CLINQ.

Best regards,
Disore
Comments: ** Comment from web user: Natxo **

I see, you can not use it with ContinuousCollections. Update this and will work:

private static ObservableCollection<Customer> _source = new ObservableCollection<Customer>();
private static ReadOnlyContinuousCollection<Customer> _legalDrinkers = from cust in _source
where cust.Age >= 21
select cust;

Commented Issue: Can't compile 'Hello World - CLINQ Style' [5450]

Natxo — Fri, 29 Jan 2010 10:36:08 GMT

I have the same problem... using 2.2.0.0
Please, give us some light. Is not easy to get it to work without clues (doc & samples)

Created Issue: skiplisttest.cs missing [5493]

matelich — Mon, 23 Nov 2009 21:57:37 GMT

Referenced in ContinuousLinq.UnitTests.csproj

Created Issue: Can't compile 'Hello World - CLINQ Style' [5450]

Disore — Tue, 10 Nov 2009 09:52:26 GMT

Closed Issue: indexing error [3401]

akutruff — Tue, 20 Oct 2009 16:07:44 GMT

clinq2\collections\selectmanyreadonlycontinuouscollection.cs

in public override TResult this[int index]

- if (index <= resultItems.Count() + tempIndex)
+ if (index < resultItems.Count() + tempIndex)

Loving clinq so far!
Comments:

Fixed with rewrite of SelectMany

Closed Issue: SelectManyReadOnlyContinuousCollection needs to monitor changes made to child collections [4845]

akutruff — Mon, 19 Oct 2009 15:13:28 GMT

SelectManyReadOnlyContinuousCollection operates on a collection of collections.
Currently, the INotifyPropertyChanged interface of the parent collection is monitored, but changes to the child collections are not monitored.

I have attached a patch that fixes this issue and extends the unit tests matelich wrote for this class.
Comments:

SelectMany overhauled. Now actually works, supports multilevel property changes, duplicates, and worst case log(N) for sources without duplicates.

Commented Issue: SelectManyReadOnlyContinuousCollection needs to monitor changes made to child collections [4845]

akutruff — Tue, 29 Sep 2009 15:44:22 GMT

Not quite there yet, but I'm fixing SelectMany now.

Created Issue: SelectManyReadOnlyContinuousCollection needs to monitor changes made to child collections

JohnMartinMalone — Mon, 31 Aug 2009 15:25:35 GMT

Created Issue: NullReferenceException using static properties

jbcooley — Mon, 27 Jul 2009 17:22:15 GMT

Using a where expression that references a static property causes a NullReferenceException. Here's a sample built from the unit tests.
// a class with a static property.
public class Constants
{
public static int AgeValue
{
get { return 10; }
}
}

// a new test on WhereTest
[Test]
public void Where_SimpleOnePropertyFilter_ItemsFiltered2()
{
ReadOnlyContinuousCollection<Person> output = from person in _source
where person.Age > Constants.AgeValue
select person;

Assert.AreEqual(1, output.Count);
}

Closed Issue: ContinuousLinq should output ReadOnlyObservableCollection

akutruff — Mon, 01 Jun 2009 15:15:22 GMT

The output of a query should be a ReadOnlyObservableCollection and not a ReadOnlyContinuousCollection. Clinq should be using the built-in .NET classes as much as possible.
Comments:

Cannot fix because of the framework

Commented Issue: indexing error

matelich — Wed, 31 Dec 2008 21:49:24 GMT

So, I decided I'd write a unittest to show the need for this change, and succeeded, but I can't figure out why my AddItem and RemoveItem tests are failing. Here's the code anyway, gotta move on for now.