Splitting code into separate methods and avoiding the Unit Of Work / Repository pattern
What is the main purpose of the transaction? Is it to handle exceptions and then rollback? Or is there actually something to lock the database/table for everyone for during the creation of social media events. Can be that this is due to the demo code, but I see no need for the transaction itself.

If you remove the transaction, and just do SaveChanges once at the end, then you don't need the transaction. Which solves part of your problem I guess.

    public static void CreateSocialEvent(int employeeId)
    {
        using (var dbContext = new EmployeeEntities())
        {
            var employee = dbContext.Employees.FirstOrDefault(e =&gt; e.IsActive &amp;&amp; e.IsSocialEmployee &amp;&amp; e.EmployeeId == employeeId);
            if (employee == null)
            {
                throw new ArgumentException(string.Format("Unable to find employee by '{0}'", employeeId));
            }

            dbContext.Reminders.Add(new Reminder
            {
                EmployeeId = employee.EmployeeId,
                CreationDate = DateTime.Now
            });

            dbContext.SocialMailingListSubscribers.Add(new SocialMailingListSubscriber
            {
                EmployeeId = employee.EmployeeId
            });

            dbContext.Subscriptions.Add(new Subscription
            {
                EmployeeId = employee.EmployeeId
            });

            var department = dbContext.Departments
                .Include(d =&gt; d.Subscribers)
                .FirstOrDefault(d =&gt; d.DepartmentId == employee.DepartmentId);
            if (department == null)
            {
                throw new NullReferenceException("Departments could not be found");
            }
            employee.Subscribers = department.Subscribers;

            // Persist to database
            // if we fail to get here due to an exception, 
            // the using statement will dispose and the exception will be thrown
            dbContext.SaveChanges();
        }
    }


And you could move some of the creation of object parts, like in the simplest way:

public class Reminder
{
    public int EmployeeId { get; set; }
    public DateTime CreationDate { get; set; }

    public static Reminder CreateForEmployee(int employeeId)
    {
        return new Reminder
        {
            EmployeeId = employeeId,
            CreationDate = DateTime.Now
        };
    }

    public Reminder() { }

    public Reminder(int employeeId)
    {
        this.EmployeeId = employeeId;
        this.CreationDate = DateTime.Now;
    }
}


So you could do:

    public static void CreateSocialEvent(int employeeId)
    {
        using (var dbContext = new EmployeeEntities())
        {
            var employee = dbContext.Employees.FirstOrDefault(e =&gt; e.IsActive &amp;&amp; e.IsSocialEmployee &amp;&amp; e.EmployeeId == employeeId);

            if (employee == null)
            {
                throw new ArgumentException(string.Format("Unable to find employee by '{0}'", employeeId));
            }

            // with a static method
            dbContext.Reminders.Add(Reminder.CreateForEmployee(employeeId));

            // or with the constructor
            dbContext.Reminders.Add(new Reminder(employeeId));
        }
    }


To make it fit on one line, if that is what you want. Or use DI to move the responsibility of creating the object out of the method.