Thread Safe Events while utilizing EAP This is my code for a server using EAP (Sockets).

Is AsyncOperation.Post the right way to raise thread safe events?

AsyncOperation.Post states: 


  Invokes a delegate on the thread or context appropriate for the application model.


Is there any other mistake in the code (i.e something that can be improved or is a bad thing to do)?

public sealed class Server
{
    private Socket _server;
    private SocketAsyncEventArgs _acceptArg;
    private AsyncOperation _asyncOperation;

    public EndPoint LocalEndPoing { get; private set; }
    public bool Listening { get; private set; }

    public delegate void ErrorOccuredEventHandler(Server sender, Exception e);

    public delegate void ClientConnectedEventHandler(Server sender, EndPoint remoteEndpoint);

    public event ErrorOccuredEventHandler ErrorOcurred;

    public event ClientConnectedEventHandler ClientConnected;

    private void OnErrorOccured(Exception e)
    {
        if(ErrorOcurred!=null)
            ErrorOcurred.Invoke(this,e);
    }

    private void OnClientConnected(EndPoint remoteEndPoint)
    {
        if(ClientConnected!=null)
            ClientConnected.Invoke(this,remoteEndPoint);
    }

    public Server(EndPoint localEndPoint)
    {
        LocalEndPoing = localEndPoint;
        Listening = false;
        _asyncOperation = AsyncOperationManager.CreateOperation(null);
    }

    public void Start()
    {
        try
        {
            if (Listening)
                return;

            _server = _server ?? new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            _server.Bind(LocalEndPoing);
            _server.Listen(10);

            Listening = true;

            _acceptArg = _acceptArg ?? new SocketAsyncEventArgs();
            _acceptArg.Completed += _acceptArg_Completed;

            if (!_server.AcceptAsync(_acceptArg))
                _acceptArg_Completed(null, _acceptArg);

        }
        catch (Exception exception)
        {
            _asyncOperation.Post(ex=&gt;OnErrorOccured(ex as Exception),exception);
        }
    }

    public void Stop()
    {
        try
        {
            if(!Listening)
                return;

            _server.Close();
            _acceptArg.Dispose();

            _server = null;
            _acceptArg = null;

            Listening = false;

        }
        catch (Exception exception)
        {
            _asyncOperation.Post(ex =&gt; OnErrorOccured(ex as Exception), exception);
        }
    }

    private void _acceptArg_Completed(object sender, SocketAsyncEventArgs e)
    {
        if (e.SocketError == SocketError.Success)
        {
            _asyncOperation.Post(remoteEndPoint=&gt;OnClientConnected(remoteEndPoint as EndPoint),e.AcceptSocket.RemoteEndPoint);

            //Do nasty things with the accepted socket

            e.AcceptSocket = null;

            if(!_server.AcceptAsync(e))
                _acceptArg_Completed(null,e);
        }
        else
        {
            _asyncOperation.Post(ex =&gt; OnErrorOccured(ex as Exception), new SocketException((int)e.SocketError));
            Stop();
        }
    }
}
public EndPoint LocalEndPoing { get; private set; }  



should be LocalEndPoint.  




public void Start()
{
    try
    {
        if (Listening)
            return;  



why is this if statement inside the try..catch ? It can be granted that this won't ever throw any exception. As a rule of thumb, only put code inside a try..catch which can throw.  

You should always use braces {}, although they might be optional, to make your code less error prone.  


_server.Listen(10);  



why 10 and not 1000? Using magic numbers should be avoided to make the code easier to read and understand. You should extract magic numbers/strings into meaningful variables/constants so Sam the maintainer will see at first glance what this is about.  




_asyncOperation.Post(ex=&gt;OnErrorOccured(ex as Exception),exception);  



Let your variables and operators have some space to breathe, its just making your code more readable like so  

_asyncOperation.Post(ex =&gt; OnErrorOccured(ex as Exception), exception);  





private void _acceptArg_Completed(object sender, SocketAsyncEventArgs e)  



having an underscore prefixed methodname is a no go. Underscore prefixing is tolerated for class level variable names only.