ObservableColle ction(of T): Only for UI-tier or for all tiers?

[Henrik Dahl]

Hello!

In some situations I have a collection of objects which it in different
situations could be relevant to deal with at the UI-tier and sometimes at
other tiers. Typically my concept is a composite so MyCollectionEle mentClass
has a collection of MyCollectionEle mentClass.

Should I make one implementation for the UI-tier using
ObservableColle ction(MyCollect ionElementClass ) and one for the non-UI tier
using List(MyCollecti onElementClass) or should I use the implementation
using ObservableColle ction(MyCollect ionElementClass ) for all tiers?

A more general question: Should ObservableColle ction(Of T) basically only be
used at UI-tiers due to some performance or infrastructural reasons for
instance?
Best regards,

Henrik Dahl

[Nicholas Paldino [.NET/C# MVP]]

Henrik,

I don't see why it shouldn't be used at all tiers. ObservableColle ction
doesn't have any UI specific functionality. It is basically a Collection<T>
instance which implements INotifyCollecti onChanged and
INotifyProperty Changed. These interfaces, while they can be used for UI,
don't HAVE to be strictly for UI. You might want some code to run when
certain properties are changed (in a chain reaction sort of way). The most
prominent example is UI changes, but not by any means the only example.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uE******** ******@TK2MSFTN GP06.phx.gbl...

Hello!

In some situations I have a collection of objects which it in different
situations could be relevant to deal with at the UI-tier and sometimes at
other tiers. Typically my concept is a composite so
MyCollectionEle mentClass has a collection of MyCollectionEle mentClass.

Should I make one implementation for the UI-tier using
ObservableColle ction(MyCollect ionElementClass ) and one for the non-UI tier
using List(MyCollecti onElementClass) or should I use the implementation
using ObservableColle ction(MyCollect ionElementClass ) for all tiers?

A more general question: Should ObservableColle ction(Of T) basically only
be used at UI-tiers due to some performance or infrastructural reasons for
instance?
Best regards,

Henrik Dahl

[Henrik Dahl]

Hello Nicholas,

Yes, but if you invoke some methods from a non-UI thread an exception is
actually raised from the ObservableColle ction(Of T) instance. This could
indicate there's something more into this ObservableColle ction because what
you've described probably should not lead to such treading related
behaviour. What do you think?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev i
en meddelelse news:e7******** *****@TK2MSFTNG P06.phx.gbl...

Henrik,

I don't see why it shouldn't be used at all tiers.
ObservableColle ction doesn't have any UI specific functionality. It is
basically a Collection<Tins tance which implements
INotifyCollecti onChanged and INotifyProperty Changed. These interfaces,
while they can be used for UI, don't HAVE to be strictly for UI. You
might want some code to run when certain properties are changed (in a
chain reaction sort of way). The most prominent example is UI changes,
but not by any means the only example.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uE******** ******@TK2MSFTN GP06.phx.gbl...

>Hello!

In some situations I have a collection of objects which it in different
situations could be relevant to deal with at the UI-tier and sometimes at
other tiers. Typically my concept is a composite so
MyCollectionEl ementClass has a collection of MyCollectionEle mentClass.

Should I make one implementation for the UI-tier using
ObservableColl ection(MyCollec tionElementClas s) and one for the non-UI
tier using List(MyCollecti onElementClass) or should I use the
implementati on using ObservableColle ction(MyCollect ionElementClass ) for
all tiers?

A more general question: Should ObservableColle ction(Of T) basically only
be used at UI-tiers due to some performance or infrastructural reasons
for instance?
Best regards,

Henrik Dahl

[Nicholas Paldino [.NET/C# MVP]]

Henrik,

That isn't the case. There is nothing in ObservableColle ction which is
tied to the UI. The error is expected, as you are trying to update the UI
thread from a non UI thread (something not allowed in WPF as well as Win32).
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uz******** ******@TK2MSFTN GP03.phx.gbl...

Hello Nicholas,

Yes, but if you invoke some methods from a non-UI thread an exception is
actually raised from the ObservableColle ction(Of T) instance. This could
indicate there's something more into this ObservableColle ction because
what you've described probably should not lead to such treading related
behaviour. What do you think?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev i
en meddelelse news:e7******** *****@TK2MSFTNG P06.phx.gbl...

>Henrik,

I don't see why it shouldn't be used at all tiers.
ObservableColl ection doesn't have any UI specific functionality. It is
basically a Collection<Tins tance which implements
INotifyCollect ionChanged and INotifyProperty Changed. These interfaces,
while they can be used for UI, don't HAVE to be strictly for UI. You
might want some code to run when certain properties are changed (in a
chain reaction sort of way). The most prominent example is UI changes,
but not by any means the only example.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uE******* *******@TK2MSFT NGP06.phx.gbl.. .

>>Hello!

In some situations I have a collection of objects which it in different
situations could be relevant to deal with at the UI-tier and sometimes
at other tiers. Typically my concept is a composite so
MyCollectionE lementClass has a collection of MyCollectionEle mentClass.

Should I make one implementation for the UI-tier using
ObservableCol lection(MyColle ctionElementCla ss) and one for the non-UI
tier using List(MyCollecti onElementClass) or should I use the
implementatio n using ObservableColle ction(MyCollect ionElementClass ) for
all tiers?

A more general question: Should ObservableColle ction(Of T) basically
only be used at UI-tiers due to some performance or infrastructural
reasons for instance?
Best regards,

Henrik Dahl

[Henrik Dahl]

Hello again!

OK, so your point is, that the exception is not thrown by
ObservableColle ction(Of T) but by some action performed by an event handler
erroneously invoked by the non-UI thread in this case?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev i
en meddelelse news:eC******** *****@TK2MSFTNG P06.phx.gbl...

Henrik,

That isn't the case. There is nothing in ObservableColle ction which is
tied to the UI. The error is expected, as you are trying to update the UI
thread from a non UI thread (something not allowed in WPF as well as
Win32).
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uz******** ******@TK2MSFTN GP03.phx.gbl...

>Hello Nicholas,

Yes, but if you invoke some methods from a non-UI thread an exception is
actually raised from the ObservableColle ction(Of T) instance. This could
indicate there's something more into this ObservableColle ction because
what you've described probably should not lead to such treading related
behaviour. What do you think?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev
i en meddelelse news:e7******** *****@TK2MSFTNG P06.phx.gbl...

>>Henrik,

I don't see why it shouldn't be used at all tiers.
ObservableCol lection doesn't have any UI specific functionality. It is
basically a Collection<Tins tance which implements
INotifyCollec tionChanged and INotifyProperty Changed. These interfaces,
while they can be used for UI, don't HAVE to be strictly for UI. You
might want some code to run when certain properties are changed (in a
chain reaction sort of way). The most prominent example is UI changes,
but not by any means the only example.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uE****** ********@TK2MSF TNGP06.phx.gbl. ..
Hello!

In some situations I have a collection of objects which it in different
situations could be relevant to deal with at the UI-tier and sometimes
at other tiers. Typically my concept is a composite so
MyCollection ElementClass has a collection of MyCollectionEle mentClass.

Should I make one implementation for the UI-tier using
ObservableCo llection(MyColl ectionElementCl ass) and one for the non-UI
tier using List(MyCollecti onElementClass) or should I use the
implementati on using ObservableColle ction(MyCollect ionElementClass ) for
all tiers?

A more general question: Should ObservableColle ction(Of T) basically
only be used at UI-tiers due to some performance or infrastructural
reasons for instance?
Best regards,

Henrik Dahl

[Nicholas Paldino [.NET/C# MVP]]

Henrik,

Yes.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:eC******** ******@TK2MSFTN GP04.phx.gbl...

Hello again!

OK, so your point is, that the exception is not thrown by
ObservableColle ction(Of T) but by some action performed by an event
handler erroneously invoked by the non-UI thread in this case?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev i
en meddelelse news:eC******** *****@TK2MSFTNG P06.phx.gbl...

>Henrik,

That isn't the case. There is nothing in ObservableColle ction which
is tied to the UI. The error is expected, as you are trying to update
the UI thread from a non UI thread (something not allowed in WPF as well
as Win32).
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uz******* *******@TK2MSFT NGP03.phx.gbl.. .

>>Hello Nicholas,

Yes, but if you invoke some methods from a non-UI thread an exception is
actually raised from the ObservableColle ction(Of T) instance. This could
indicate there's something more into this ObservableColle ction because
what you've described probably should not lead to such treading related
behaviour. What do you think?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev
i en meddelelse news:e7******** *****@TK2MSFTNG P06.phx.gbl...
Henrik,

I don't see why it shouldn't be used at all tiers.
ObservableCo llection doesn't have any UI specific functionality. It is
basically a Collection<Tins tance which implements
INotifyColle ctionChanged and INotifyProperty Changed. These interfaces,
while they can be used for UI, don't HAVE to be strictly for UI. You
might want some code to run when certain properties are changed (in a
chain reaction sort of way). The most prominent example is UI changes,
but not by any means the only example.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uE***** *********@TK2MS FTNGP06.phx.gbl ...
Hello!
>
In some situations I have a collection of objects which it in
different situations could be relevant to deal with at the UI-tier and
sometimes at other tiers. Typically my concept is a composite so
MyCollectio nElementClass has a collection of MyCollectionEle mentClass.
>
Should I make one implementation for the UI-tier using
ObservableC ollection(MyCol lectionElementC lass) and one for the non-UI
tier using List(MyCollecti onElementClass) or should I use the
implementat ion using ObservableColle ction(MyCollect ionElementClass )
for all tiers?
>
A more general question: Should ObservableColle ction(Of T) basically
only be used at UI-tiers due to some performance or infrastructural
reasons for instance?
>
>
Best regards,
>
Henrik Dahl
>
>

[Henrik Dahl]

OK.

Do you know if instances of ObservableColle ction(Of T) may also be
marshalled via the serialization mechanishms of WCF or via XmlSerializer?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev i
en meddelelse news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

Henrik,

Yes.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:eC******** ******@TK2MSFTN GP04.phx.gbl...

>Hello again!

OK, so your point is, that the exception is not thrown by
ObservableColl ection(Of T) but by some action performed by an event
handler erroneously invoked by the non-UI thread in this case?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev
i en meddelelse news:eC******** *****@TK2MSFTNG P06.phx.gbl...

>>Henrik,

That isn't the case. There is nothing in ObservableColle ction which
is tied to the UI. The error is expected, as you are trying to update
the UI thread from a non UI thread (something not allowed in WPF as well
as Win32).
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uz****** ********@TK2MSF TNGP03.phx.gbl. ..
Hello Nicholas,

Yes, but if you invoke some methods from a non-UI thread an exception
is actually raised from the ObservableColle ction(Of T) instance. This
could indicate there's something more into this ObservableColle ction
because what you've described probably should not lead to such treading
related behaviour. What do you think?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om>
skrev i en meddelelse news:e7******** *****@TK2MSFTNG P06.phx.gbl...
Henrik,
>
I don't see why it shouldn't be used at all tiers.
ObservableC ollection doesn't have any UI specific functionality. It
is basically a Collection<Tins tance which implements
INotifyColl ectionChanged and INotifyProperty Changed. These
interface s, while they can be used for UI, don't HAVE to be strictly
for UI. You might want some code to run when certain properties are
changed (in a chain reaction sort of way). The most prominent example
is UI changes, but not by any means the only example.
>
Hope this helps.
>
>
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m
>
"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uE**** **********@TK2M SFTNGP06.phx.gb l...
>Hello!
>>
>In some situations I have a collection of objects which it in
>differen t situations could be relevant to deal with at the UI-tier
>and sometimes at other tiers. Typically my concept is a composite so
>MyCollecti onElementClass has a collection of
>MyCollecti onElementClass.
>>
>Should I make one implementation for the UI-tier using
>Observable Collection(MyCo llectionElement Class) and one for the non-UI
>tier using List(MyCollecti onElementClass) or should I use the
>implementa tion using ObservableColle ction(MyCollect ionElementClass )
>for all tiers?
>>
>A more general question: Should ObservableColle ction(Of T) basically
>only be used at UI-tiers due to some performance or infrastructural
>reasons for instance?
>>
>>
>Best regards,
>>
>Henrik Dahl
>>
>>
>
>

[Nicholas Paldino [.NET/C# MVP]]

Henrik,

Well, did you check the documentation? *smiles*

It says that the Serializable attribute is applied to it, which means
that instances of it can be serialized, assuming that T is serializable.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:OI******** ******@TK2MSFTN GP05.phx.gbl...

OK.

Do you know if instances of ObservableColle ction(Of T) may also be
marshalled via the serialization mechanishms of WCF or via XmlSerializer?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev i
en meddelelse news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

>Henrik,

Yes.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:eC******* *******@TK2MSFT NGP04.phx.gbl.. .

>>Hello again!

OK, so your point is, that the exception is not thrown by
ObservableCol lection(Of T) but by some action performed by an event
handler erroneously invoked by the non-UI thread in this case?
Best regards,

Henrik Dahl

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omskrev
i en meddelelse news:eC******** *****@TK2MSFTNG P06.phx.gbl...
Henrik,

That isn't the case. There is nothing in ObservableColle ction which
is tied to the UI. The error is expected, as you are trying to update
the UI thread from a non UI thread (something not allowed in WPF as
well as Win32).
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Henrik Dahl" <He********@com munity.nospamwr ote in message
news:uz***** *********@TK2MS FTNGP03.phx.gbl ...
Hello Nicholas,
>
Yes, but if you invoke some methods from a non-UI thread an exception
is actually raised from the ObservableColle ction(Of T) instance. This
could indicate there's something more into this ObservableColle ction
because what you've described probably should not lead to such
treading related behaviour. What do you think?
>
>
Best regards,
>
Henrik Dahl
>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om>
skrev i en meddelelse news:e7******** *****@TK2MSFTNG P06.phx.gbl...
>Henrik,
>>
> I don't see why it shouldn't be used at all tiers.
>Observable Collection doesn't have any UI specific functionality. It
>is basically a Collection<Tins tance which implements
>INotifyCol lectionChanged and INotifyProperty Changed. These
>interfaces , while they can be used for UI, don't HAVE to be strictly
>for UI. You might want some code to run when certain properties are
>changed (in a chain reaction sort of way). The most prominent
>example is UI changes, but not by any means the only example.
>>
> Hope this helps.
>>
>>
>--
> - Nicholas Paldino [.NET/C# MVP]
> - mv*@spam.guard. caspershouse.co m
>>
>"Henrik Dahl" <He********@com munity.nospamwr ote in message
>news:uE*** ***********@TK2 MSFTNGP06.phx.g bl...
>>Hello!
>>>
>>In some situations I have a collection of objects which it in
>>differe nt situations could be relevant to deal with at the UI-tier
>>and sometimes at other tiers. Typically my concept is a composite so
>>MyCollect ionElementClass has a collection of
>>MyCollect ionElementClass .
>>>
>>Should I make one implementation for the UI-tier using
>>Observabl eCollection(MyC ollectionElemen tClass) and one for the
>>non-UI tier using List(MyCollecti onElementClass) or should I use the
>>implement ation using ObservableColle ction(MyCollect ionElementClass )
>>for all tiers?
>>>
>>A more general question: Should ObservableColle ction(Of T) basically
>>only be used at UI-tiers due to some performance or infrastructural
>>reasons for instance?
>>>
>>>
>>Best regards,
>>>
>>Henrik Dahl
>>>
>>>
>>
>>
>
>

[Linda Liu [MSFT]]

Hi Henrik,

I agree that ObservableColle ction(Of T) can be used for all tiers.

the exception is not thrown by ObservableColle ction(Of T) but by some

action performed by an event handler erroneously invoked by the non-UI
thread in this case?

In my opinion, because the ObservableColle ction(Of T) implements the
INotifyCollecti onChanged and INotifyProperty Changed interfaces, it will
cause UI update when the ObservableColle ction(Of T) is changed.

Let's say a non-UI thread accesses and changes the ObservableColle ction(Of
T), then it is the non-UI thread that performs the UI update in the next
step, which is not allowed in the thread models of both WinForms and WPF
applications.

In WinForms world, the solution is to define a delegate for the method to
access the control, and then call the Invoke or BeginInvoke method of the
WinForms control to invoke the delegate.

In WPF world, the solution is similar but is a little different. We still
need to define a delegate for the method to access the UI element, and then
call the Invoke or BeginInvoke method of the Dispather linked to the UI
thread.

The following is a sample.

delegate void SetTextBoxDeleg ate();
Dispatcher.Invo ke(System.Windo ws.Threading.Di spatcherPriorit y.Normal, new
SetTextBoxDeleg ate(SetTextBox1 ));
void SetTextBox1()
{
this.textBox1.T ext = "some text";
}

For more information on the threading model in WPF, you may visit the
following link:

'Threading Model'
http://msdn2.microsoft.com/en-us/library/ms741870.aspx

Hope this helps.
If you have any question, please feel free to let me know.
Sincerely,
Linda Liu
Microsoft Online Community Support

=============== =============== =============== =====
Get notification to my posts through email? Please refer to
http://msdn.microsoft.com/subscripti...ult.aspx#notif
ications.

Note: The MSDN Managed Newsgroup support offering is for non-urgent issues
where an initial response from the community or a Microsoft Support
Engineer within 1 business day is acceptable. Please note that each follow
up response may take approximately 2 business days as the support
professional working with you may need further investigation to reach the
most efficient resolution. The offering is not appropriate for situations
that require urgent, real-time or phone-based interactions or complex
project analysis and dump analysis issues. Issues of this nature are best
handled working with a dedicated Microsoft Support Engineer by contacting
Microsoft Customer Support Services (CSS) at
http://msdn.microsoft.com/subscripti...t/default.aspx.
=============== =============== =============== =====

This posting is provided "AS IS" with no warranties, and confers no rights.