C#: Only Use Static Methods

ClassWithDependency.csx

public class Thing : IThing
{
    public Thing(IDependency dependency)    {  }

    public void Do(string arg)    {  }
}

DoThing.csx

public static void DoThing(IDependency dependency, string arg) { }

FunctionalComposition.csx

public static Action Compose()
{
    return () => RunCustomerReportBatch(
        GetCustomersForCustomerReport,
        CreateCustomerReport,
        SendEmail);
}

FunctionalUnitTest.csx

[Fact]
public void FunctionalTest()
{
    // arrange
    var expectedCustomer = new Customer("[email protected]");
    var expectedReportBody = "the report body";

    Func<IEnumerable<Customer>> getCustomersForCustomerReport  = 
        () => new[] {expectedCustomer};

    Func<Customer, Report> createCustomerReport = 
        customer => new Report(expectedCustomer.Email, expectedReportBody);

    var actualToAddress = "";
    var actualBody = "";

    Action<string, string> sendEmail = (toAddress, body) =>
    {
        actualToAddress = toAddress;
        actualBody = body;
    };

    // act
    Functional.RunCustomerReportBatch(getCustomersForCustomerReport, createCustomerReport, sendEmail);

    // assert
    Assert.Equal(expectedCustomer.Email, actualToAddress);
    Assert.Equal(expectedReportBody, actualBody);
}

Implementations.csx

public class CustomerData : ICustomerData
{
    public IEnumerable<Customer> GetCustomersForCustomerReport()
    {
        // pretend to do data access
        yield return new Customer("[email protected]");
        yield return new Customer("[email protected]");
        yield return new Customer("[email protected]");
    }
}

public class ReportBuilder : IReportBuilder
{
    public Report CreateCustomerReport(Customer customer)
    {
        return new Report(customer.Email, $"This is the report for {customer.Email}!");
    }
}

public class Emailer : IEmailer
{
    public void Send(string toAddress, string body)
    {
        // pretend to send an email here
        Console.Out.WriteLine("Sent Email to: {0}, Body: '{1}'", toAddress, body);
    }
}

Interfaces.csx

public interface ICustomerData
{
    IEnumerable<Customer> GetCustomersForCustomerReport();
}

public interface IReportBuilder
{
    Report CreateCustomerReport(Customer customer);
}

public interface IEmailer
{
    void Send(string toAddress, string body);
}

ObjectOrientedComposition.csx

public static ReportingService Compose()
{
    return new ReportingService(
        new CustomerData(), 
        new ReportBuilder(), 
        new Emailer()
        );
}

ObjectOrientedTest.csx

[Fact]
public void RunCustomerReportBatchShouldSendReports()
{
    // Arrange
    var customerDataMock = new Mock<ICustomerData>();   
    var reportBuilderMock = new Mock<IReportBuilder>();
    var emailerMock = new Mock<IEmailer>();

    var expectedCustomer = new Customer("[email protected]");
    var expectedReportBody = "the report body";

    customerDataMock.Setup(x => x.GetCustomersForCustomerReport())
        .Returns(new[] { expectedCustomer });

    reportBuilderMock.Setup(x => x.CreateCustomerReport(expectedCustomer))
        .Returns(new Report(expectedCustomer.Email, expectedReportBody));

    var sut = new ReportingService(
        customerDataMock.Object, 
        reportBuilderMock.Object, 
        emailerMock.Object);

    // Act
    sut.RunCustomerReportBatch();

    // Assert
    emailerMock.Verify(x => x.Send(expectedCustomer.Email, expectedReportBody));
}

ReportingService.csx

public class ReportingService
{
    public ReportingService(ICustomerData customerData, IReportBuilder reportBuilder, IEmailer emailer)
    {
        CustomerData = customerData;
        ReportBuilder = reportBuilder;
        Emailer = emailer;
    }

    public ICustomerData CustomerData { get; private set; }
    public IReportBuilder ReportBuilder { get; private set; }
    public IEmailer Emailer { get; private set; }

    public void RunCustomerReportBatch()
    {
        var customers = CustomerData.GetCustomersForCustomerReport();

        foreach (var customer in customers)
        {
            var report = ReportBuilder.CreateCustomerReport(customer);
            Emailer.Send(report.ToAddress, report.Body);
        }
    }
}

RunCustomerReportsBatch.csx

public static void RunCustomerReportBatch(
    Func<IEnumerable<Customer>> getCustomersForCustomerReport,
    Func<Customer, Report> createCustomerReport,
    Action<string, string> sendEmail)
{
    var customers = getCustomersForCustomerReport();

    foreach (var customer in customers)
    {
        var report = createCustomerReport(customer);
        sendEmail(report.ToAddress, report.Body);
    }
}

StaticMethodsReplaceClasses.csx

public static IEnumerable<Customer> GetCustomersForCustomerReport()
{
    // pretend to do data access
    yield return new Customer("[email protected]");
    yield return new Customer("[email protected]");
    yield return new Customer("[email protected]");
}

public static Report CreateCustomerReport(Customer customer)
{
    return new Report(customer.Email, $"This is the report for {customer.Email}!");
}

public static void SendEmail(string toAddress, string body)
{
    // pretend to send an email here
    Console.Out.WriteLine("Sent Email to: {0}, Body: '{1}'", toAddress, body);
}

ThingComposition.csx

var dependency = new ThingThatImplementsIDependency();

// RelyOnThing is something that that takes Action<string> as a dependency.
Action relyOnThing = () => RelyOnThing(arg => DoThing(dependency, arg));

Hi, line 3 of ThingComposition.csx contains a small typo: that that. :-)