delegate vs event

What are the differences between delegate and an event? 

An event declaration adds a layer of abstraction and protection on the delegate instance. This protection prevents clients of the delegate from resetting the delegate and its invocation list and only allows adding or removing targets from the invocation list. 
To understand the differences you can look at 2 examples below:

Example with Delegate

First let's try to implement an "event trigger" by using "delegate" instead of "event". 
in this case, the example delegate Run is an Action - that is a kind of delegate that doesn't return a value.

public class Animal
{
public Action Run {get; set;}
public void RaiseEvent()
{
if (Run != null)
{
Run();
}
}
}

To use the delegate, you should do something like this:

Animal animal= new Animal();
animal.Run += () => Console.WriteLine("I'm running");
animal.Run += () => Console.WriteLine("I'm still running") ;
animal.RaiseEvent();

This code works well but you could have some weak spots: 
For example, if I write this:

animal.Run += () => Console.WriteLine("I'm running");
animal.Run += () => Console.WriteLine("I'm still running");
animal.Run = () => Console.WriteLine("I'm sleeping") ;

with the last line of code, I have overridden the previous behaviors just with one missing + (I have used = instead of +=)

Another weak spot is that every class which uses your Animal class can raise the Run event without calling the public RaiseEvent function, but with code snippet like:

if (animal.Run != null)
{
   animal.Run();
}

To avoid these weak spots you can use events in c#.

Example with Event

Your "event version" of the Animal class will looks like:

public class ArgsSpecial : EventArgs
{
    public ArgsSpecial (string val)
    {
        Operation=val;
    }
    public string Operation {get; set;}
} 
public class Animal
{
    // Empty delegate. In this way you are sure that value is always != null 
    // because no one outside of the class can change it.
    public event EventHandler<ArgsSpecial> Run = delegate{};
    public void RaiseEvent()
    {  
         Run(this, new ArgsSpecial("Run faster"));
    }
}

to call events

 Animal animal= new Animal();
 animal.Run += (sender, e) => Console.WriteLine("I'm running. My value is {0}", e.Operation);
 animal.RaiseEvent();

Differences:

1. You aren't using a public property but a public field. 
Using events, the compiler protects your fields from unwanted access 
2. Event can't be assigned directly. 
In this case, it is impossible to override the previous behaviors by using = instead of +=. 
3. No one outside of your class can raise the event. 
Even the Run event is public, a compiler error will occur if someone tries to raise the event with code snippet below:

// Error: the event 'delegateEvent.Animal.Run' can only appear on the left hand side of += or -= 
// (except when used from within the type 'delegateEvent.Animal')
animal.Run(animal, new ArgsSpecial("Run slower"));

4. Event can be included in an interface declaration, whereas a delegate field cannot.