Linked object for creating chains without lists

I need a LinkedList but unfortunatelly the one that the .NET provides didn't have the functionality I was looking for (not working with linq and the LinkedListNode is sealed). I created a replacement that works similar but is linq-compatible.

The main class is a LinkedObject<T> that might be used on it's own but is better suited to be used by composition and should provide all the functionality of a chain:

[DebuggerDisplay("Value = {Value?.ToString()}")]
class LinkedObject<T>
{
    private LinkedObject<T> _previous;
    private LinkedObject<T> _next;

    public LinkedObject() {}

    public LinkedObject(T value)
    {
        Value = value;
    }

    public LinkedObject<T> Previous
    {
        get { return _previous; }
        set
        {
            _previous = value;
            value._next = this;
        }
    }

    public LinkedObject<T> Next
    {
        get { return _next; }
        set
        {
            _next = value;
            value._previous = this;
        }
    }

    public T Value { get; set; }

    // or maybe precessors?
    public IEnumerable<LinkedObject<T>> Before
    {
        get
        {
            var item = this;
            while (item != null)
            {
                yield return item;
                item = item.Previous;
            }
        }
    }

    // or maybe successors?
    public IEnumerable<LinkedObject<T>> After
    {
        get
        {
            var item = this;
            while (item != null)
            {
                yield return item;
                item = item.Next;
            }
        }
    }

    public void Remove()
    {            
        _previous.Next = _next;
        _next.Previous = _previous;
        _previous = null;
        _next = null;
    }
}

Some custom object would use it like this (my real linked-object has a few more additional properties then this simple example):

class Word
{
    private readonly LinkedObject<Sentence> _linkedObject;

    public Word()
    {
        _linkedObject = new LinkedObject<Sentence>(this);
    }

    public string Value 
    { 
        get { return _linkedObject.Value; } 
        set { _linkedObject.Value = value; }
    }        

    public WordPrevious
    {
        get { return _linkedObject.Previous.Value; }
        set { _linkedObject.Previous = value._linkedObject; }
    }

    public Word Next
    {
        get { return _linkedObject.Next.Value; }
        set { _linkedObject.Next = value._linkedObject; }
    }

    public IEnumerable<Word> Before
    {
        get { return _linkedObject.Before.Select(x => x.Value); }
    }

    public IEnumerable<Word> After
    {
        get { return _linkedObject.After.Select(x => x.Value); }
    }
}

Example (I use a loop to create the real chain):

var foo = new LinkedObject<string>
{
    Value = "foo",
    Next = new LinkedObject<string>
    {
        Value = "bar",
        Next = new LinkedObject<string>() { Value = "baz" }
    }
};

// foo, bar, baz

foo.Next.Remove(); // foo, baz