Circular Buffer Implementation

Like @Gareth mentioned in his comment it would be perfect to use the ConcurrentQueue<T>.

You answered @Gareth the queue needs to be bounded in size but where is the problem. We can just add a check to the Add() method and if the queue's size is equal to the bounded size we will just dequeue one item.

If the passed in size parameter of the constructor is 0 you will get a DivideByZeroException at _i = (_i + 1)%_size; and it doesn't really make sense to have a CircularBuffer with size == 0, does it ?

As you will notice in the adjusted code, I have placed the _lock.EnterWriteLock(); outside of the try..finally because what happens if the call to EnterWriteLock() fails ?

public class CircularBuffer<T>
{
    private readonly ConcurrentQueue<T> _data;
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private readonly int _size;

    public CircularBuffer(int size)
    {
        if (size < 1)
        {
            throw new ArgumentException($"{nameof(size)} cannot be negative or zero");
        }
        _data = new ConcurrentQueue<T>();
        _size = size;
    }

    public IEnumerable<T> Latest()
    {
        return _data.ToArray();
    }

    public void Add(T t)
    {
        _lock.EnterWriteLock();
        try
        {
            if (_data.Count == _size)
            {
                T value;
                _data.TryDequeue(out value);
            }

            _data.Enqueue(t);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }
}

although using a ConcurrentQueue is IMO the cleaner way I will post a solution using a generic array as well like so

public class CircularBuffer<T>
{
    private readonly ReaderWriterLockSlim slimLock = new ReaderWriterLockSlim();
    private readonly int capacity;
    private readonly T[] buffer;
    private readonly int upperBound;

    private int currentIndex = -1;
    private int currentStart = 0;

    public CircularBuffer(int size)
    {
        if (size < 1)
        {
            throw new ArgumentException($"{nameof(size)} cannot be negative nor zero");
        }

        buffer = new T[size];
        capacity = size;
        upperBound = size - 1;
    }

    public void Add(T value)
    {
        slimLock.EnterWriteLock();
        try
        {

            if (IsFull || currentIndex == upperBound)
            {
                currentStart = FetchNextSlot(currentStart);
                IsFull = true;
            }

            currentIndex = FetchNextSlot(currentIndex);
            buffer[currentIndex] = value;

        }
        finally
        {
            slimLock.ExitWriteLock();
        }

    }

    public bool IsFull { get; private set; }

    private int FetchNextSlot(int value)
    {
        return (value + 1) % capacity;
    }

    public IEnumerable<T> Latest()
    {
        slimLock.EnterReadLock();
        try
        {
            return FetchItems().ToArray();
        }
        finally
        {
            slimLock.ExitReadLock();
        }
    }

    private IEnumerable<T> FetchItems()
    {
        IEnumerable<T> fetchedItems = Enumerable.Empty<T>();
        if (IsFull)
        {
            return FetchItems(currentStart, upperBound);
        }
        return fetchedItems.Concat(FetchItems(0, currentIndex));
    }
    private IEnumerable<T> FetchItems(int start, int end)
    {
        for (int i = start; i <= end; i++)
        {
            yield return buffer[i];
        }
    }
}  

You can make the usage of the ReaderWriteLockSlim a little bit nicer and get rid of the try/catch block with two disposable helpers:

public class ReaderLockSlim : IDisposable
{
    private readonly ReaderWriterLockSlim _lockSlim;

    public ReaderLockSlim(ReaderWriterLockSlim lockSlim) 
    { 
        _lockSlim = lockSlim; 
        _lockSlim.EnterReadLock();
    }

    public void Dispose()
    {
        _lockSlim.ExitReadLock();
    }
}

public class WriterLockSlim : IDisposable
{
    private readonly ReaderWriterLockSlim _lockSlim;

    public WriterLockSlim(ReaderWriterLockSlim lockSlim)
    {
        _lockSlim = lockSlim;
        _lockSlim.EnterWriteLock();
    }

    public void Dispose()
    {
        _lockSlim.ExitWriteLock();
    }
}

Example

before:

public IEnumerable<T> Latest()
{
    slimLock.EnterReadLock();
    try
    {
        return FetchItems().ToArray();
    }
    finally
    {
        slimLock.ExitReadLock();
    }
}

after:

public IEnumerable<T> Latest()
{
    using (new ReaderLockSlim(slimLock)) 
    {
        return FetchItems().ToArray();
    }
}