How can I make a read-only ObservableCollection property?

The [previously] accepted answer will actually return a different ReadOnlyObservableCollection every time ReadOnlyFoo is accessed. This is wasteful and can lead to subtle bugs.

A preferable solution is:

public class Source{    Source()    {        m_collection = new ObservableCollection<int>();        m_collectionReadOnly = new ReadOnlyObservableCollection<int>(m_collection);    }     public ReadOnlyObservableCollection<int> Items    {        get { return m_collectionReadOnly; }    }     readonly ObservableCollection<int> m_collection;    readonly ReadOnlyObservableCollection<int> m_collectionReadOnly;}

See ReadOnlyObservableCollection anti-pattern for a full discussion.

I don't like using ReadOnlyObservableCollection<T> as it seems like a mistake / broken class; I prefer a contract based approach instead.

Here is what I use that allows for covarience:

public interface INotifyCollection<T>        : ICollection<T>,          INotifyCollectionChanged{}public interface IReadOnlyNotifyCollection<out T>        : IReadOnlyCollection<T>,          INotifyCollectionChanged{}public class NotifyCollection<T>        : ObservableCollection<T>,          INotifyCollection<T>,          IReadOnlyNotifyCollection<T>{}public class Program{    private static void Main(string[] args)    {        var full = new NotifyCollection<string>();        var readOnlyAccess = (IReadOnlyCollection<string>) full;        var readOnlyNotifyOfChange = (IReadOnlyNotifyCollection<string>) full;        //Covarience        var readOnlyListWithChanges =             new List<IReadOnlyNotifyCollection<object>>()                {                    new NotifyCollection<object>(),                    new NotifyCollection<string>(),                };    }}

You could change the type of your property to be an IEnumerable:

public IEnumerable<foo> CollectionOfFoo {      get {          return _CollectionOfFoo;     }}

I don't believe there is a standard interface that exposes an indexer. If you need it you could write an interface and extend ObservableCollection to implement it:

public interface IIndexerCollection<T> : IEnumerable<T>{    T this[int i]    {        get;    }}public class IndexCollection<T> : ObservableCollection<T>, IIndexerCollection<T>{}