List property that returns subset of other list property, but can be altered In my application I have a list of objects of that have an enum property. To make the class slightly more friendly, I have decided to add a list that return a specific subject of those objects, based on their enum property.
The problem that I am running into is that if I add objects to this subset, it does not update the main list.
Is this possible? 
public class foo
{
    public int Id { get; set; }
    public string Description { get; set; }
    public List<bar> bars { get; set; }

    //list of only bars of barType one
    public List<bar_one> bar_ones
    {
get
{
return (this.bars.Where(x => x.barType == barType.one)).ToList().Cast<bar_one>().ToList();
}
    }

    public foo()
    {
this.bars = new List<bar>();
    }
}

public class bar
{
    public bar() { }
    public bar(barType bt) {
this.barType = bt;
    }

    public int Id { get; set; }
    public string Description { get; set; }
    public barType barType { get; set; }
}

public class bar_one : bar
{
    public bar_one() : base(barType.one) { }
}

public enum barType
{
    one,
    two,
    three
}


public static void Main()
{
    foo f = new foo();
    f.bars.Add(new bar { Id = 1, Description = "b1", barType = barType.one });
    f.bars.Add(new bar { Id = 2, Description = "b2", barType = barType.two });

    //this does not break, but the amount of objects in f.bars remain the same.
    f.bar_ones.Add(new bar_one { Id= 3, Description="b1_2" });
}


By using ToList() you create a new list so that the subsequent Add does not add the new bar_one to the bars list, but to the wrong list (that only exists temporarily). 
As bar_one derives from bar, you can also add the item to the original list bars: 
f.bar.Add(new bar_one { Id= 3, Description="b1_2" });

In order to avoid misunderstandings, you should change the implementation of bar_ones so that it allows extracting the list items of type bar_one, but does not support adding, e.g. by using IEnumerable<bar_one> instead of IList<bar_one>:
public IEnumerable<bar_one> bar_ones
{
    get
    {
return this.bars.OfType<bar_one>();
    }
}

In addition, I'd propose to think about whether you really need the class bar_one and the barType enumeration. In the current approach, you have both an enum and a class for each barType. So for new types, you need to create both. 
It would be better to decide for one way, e.g. only having a class hierarchy without the enums (this is better from the OOD perspective). 

You should change:
public List<bar_one> bar_ones
{
    get
    {
return (this.bars.Where(x => x.barType == barType.one)).ToList().Cast<bar_one>().ToList();
    }
}

to:
IEnumerable<bar_one> bar_ones
{
    get
    {
return this.bars.Where(x => x.barType == barType.one).Cast<bar_one>();
    }
}

Then rather than adding entries to bar_ones you should add them to bars. This will be automatically reflected in bar_ones.

If you really want a subset, this is how you could do it (basic example):
  public class Subset<T> : ICollection<T>
  {
    private readonly IList list_;
    public Subset(IList list) { list_ = list; }
    public IEnumerator<T> GetEnumerator() => list_.OfType<T>().GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    public void Add(T item) => list_.Add(item);
    public void Clear() => list_.Clear();
    public bool Contains(T item) => list_.Contains(item);
    public void CopyTo(T[] array, int arrayIndex) => list_.CopyTo(array, arrayIndex);
    public int Count => list_.Count;
    public bool IsReadOnly => list_.IsReadOnly;
    public bool Remove(T item) { list_.Remove(item); return true; }
  }