igorbuchelnikov / observablecomputations Goto Github PK

The extension methods doesn't have an overload with ReadOnlyObservableCollection. As ReadOnlyObservableCollection does not inherit from ObservableCollection we have to specify type parameters (or create our own extension methods for ReadOnlyObservableCollection).

I'm trying to use this into Unity. The .dll from nuget threw errors, so I was going to try and build it myself. However, building has many errors including not being to find ISourceIndexerPropertyTracer, ICanProcessSourceItemKeyChange, ICanProcessSourceItemValueChange... Where are these supposed to be located at?

Have you considered using WeakEventManagers to make the references of events weak, instead of using an explicit unsubscribe API? (See microsoft docs PropertyChangedEventManager, CollectionChangedEventManager and Weak Event Patterns) I do not know, but I would expect that Microsoft came up with something that has no (or few) garbage collection issues.

Introducing an unsubscribe API would require all classes using this library implementing IDisposable (or something similar), right?

I hope this is an option for you, because I really like this library and not having to unsubscribe makes it so much nicer to use.

In the previous version, there was a possibility of memory leaks due to weak subscription to NotifyPropertyChanged and NotifyCollectionChanged events. In the new version, I removed the weak subscription and added an API to manage the strong subscription to events. See Two computation states: active and inactive section for details. For other changes, see the Release Notes section at NuGet.

Noticed this when looking for the equivalent of FirstOrDefault. Maybe it was renamed in the source at some point but the docs are out of date?

The readme file says there's a CollectionDispatch() method to dispatch a collection, but there's none in the NuGet package v1.4.0. Is there any workaround?

Because comparisonWithMiddleItem may be a number greater than 1 or smaller than -1 (returned from IComparer.Compare), this code will produce an index out of range error.

` public class Order : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;

	public int Num {get; set;}

	private decimal _price;
	public decimal Price
	{
		get => _price;
		set
		{
			_price = value;
			PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Price)));
		}
	}

	public Order(int num, decimal price)
	{
		Num = num;
		_price = price;
	}


	public Order(int num, decimal price, string type)
	{
		Num = num;
		_price = price;
		_type = type;
	}

	private string _type;
	public string Type
	{
		get => _type;
		set
		{
			_type = value;
			PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Type)));
		}
	}
}

		ObservableCollection<Order> orders = 
			new ObservableCollection<Order>(new []
			{
				new Order(1, 15, "A"),
				new Order(2, 15, "A"),
				new Order(3, 25, "B"),
				new Order(4, 27, "C"),
				new Order(5, 30, "A"),
				new Order(6, 75, "C"),
				new Order(7, 80, "A"),
			});

		ObservableCollection<string> selectedOrderTypes = new ObservableCollection<string>(){"A", "B"};

		ObservableCollection<Order> filteredOrders = orders
			.Joining(selectedOrderTypes, (o, ot) => o.Type.Equals(ot))
			.Selecting(oot => oot.OuterItem);

`

Hi, could you consider adding a changelog file to this repo? For example it'd be nice to know what changed between v1.3.0 and v1.4.0, but this doesn't appear to be documented anywhere, and there's no release notes, and the commit history looks like this:

Thanks!

While performance profiling my app, I noticed that ObservableComputations starts a thread called "ObservableComputations events unsubscriber #0" and that thread sits there waiting on a ManualResetEventSlim.
Is this wasteful? Nothing else in my app uses a whole separate thread like this.
Could the same thing be achieved with a TaskCompletionSource or AsyncManualResetEvent ?