Dominic Burford - Professional Profile

try / catch

public class MyDataClass: BaseData, IMyInterface
{
	// implement data methods here
}

public class MyUnitTestDataClass: IMyInterface
{
	// implement data methods here
}

public interface IMyInterface
{
    List<Mileage> GetPreviousMileages(int driverId);
    List<Driver> GetDriverVehicles(int driverId);
}

public class MyBusinessService
{
    private readonly IMyInterface _data;

    /// <summary>
    /// If no data class is passed to the constructor then use the default data class.
    /// </summary>
    public MyBusinessService()
    {
        this._data = new MyDataClass();
    }

    /// <summary>
    /// Allow unit testing fixtures to implement their own version of the data class
    /// which can be injected via the constructor.
    /// </summary>
    /// <param name="data"></param>
    public MyBusinessService(IMyInterface data)
    {
        this._data = data;
    }
}

[TestMethod]
public void MyTestMethods()
{
    //Act
    MyBusinessService service = new MyBusinessService(new MyUnitTestDataClass()); //inject your unit test class here
            
    //Arrange
    var result = service.GetPreviousMileages(123);

    //Assert
    Assert.IsNotNull(result);
    Assert.IsTrue(result.Any());
}

//the client application serialises the date
string jsonDate = JavaScriptSerializer().Serialize(DateTime.Now);

//the receiving application attempts to de-serialise the date
DateTime dt = new JavaScriptSerializer().Deserialize<DateTime>(jsonDate); //this throws an exception!

/Date(1484904895490)/

var isoConvert = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm:ss" };
DateTime dt = JsonConvert.SerializeObject(jsonDate, isoConvert);

[TestMethod]
public void ClearDeadLetterQueue()
{
    string deadLetterQueueName = "myQueue/$DeadLetterQueue";
    QueueClient client = QueueClient.CreateFromConnectionString("connectionString",
            deadLetterQueueName, ReceiveMode.PeekLock);
     while (client.Receive() != null)
    {
        var receivedMessage = client.Receive();
	//do something with the message here
        receivedMessage?.Complete();
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.ServiceBus.Messaging;

public static void Run(BrokeredMessage message, TraceWriter log)
{
    log.Info($"C# ServiceBus queue trigger function processed message: {message.MessageId}");

    try
    {
        if (message != null)
        {
            //do something with the message here

            log.Info("Completing message.");
            message.Complete();
        }
    }
    catch (Exception ex)
    {
        message.Abandon();
        log.Info($"Exception occurred: {ex.Message}");
    }
}

/// <summary>
/// POCO class used for message exchange with the Azure Service Bus
/// </summary>
[DataContract]
[KnownType(typeof(MessageObjectEntity))]
public class MessageObjectEntity
{
    [DataMember]
    public string MessageType { get; set; }
    [DataMember]
    public object MessageContent { get; set; }
}

[KnownType(typeof(MyNewClass))]

/// <summary>
/// Creates a message for the service bus
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="message"></param>
/// <returns></returns>
private static MessageObjectEntity CreateMessageForServiceBus<T>(T message)
{
    return new MessageObjectEntity
    {
        MessageType = message.GetType().AssemblyQualifiedName,
        MessageContent = message
    };
}

using Microsoft.ServiceBus.Messaging;

MessageObjectEntity messageToSend = CreateMessageForServiceBus(message);
BrokeredMessage brokeredMessage = new BrokeredMessage(messageToSend);
await this._client.SendAsync(brokeredMessage);

private QueueClient GetServiceBusClient(string connection, string queuename)
{
    return this._client ??
           (this._client = QueueClient.CreateFromConnectionString(connection, queuename, ReceiveMode.PeekLock));
}

namespace CoreLibrary
{
    /// <summary>
    /// We use this interface for contructor injection in our unit tests. 
    /// We are essentially mocking the DateTime.Now property for unit testing.
    /// </summary>
    public interface IDateTime
    {
        DateTime Now { get; set; }
    }

    /// <summary>
    /// Library functions used by the application
    /// </summary>
    public class ReportLibrary
    {
        private readonly IDateTime _datetime;

        private class ActualDateTime : IDateTime
        {
            public DateTime Now { get; set; }
        }

        //If no reference to IDateTime is passed to the constructor then default to 
        //using the actual DateTime.Now property
        public ReportLibrary()
        {
            this._datetime = new ActualDateTime { Now = DateTime.Now};
        }

        //We will inject a reference to IDateTime from our unit tests with the required value for DateTime.Now specified
        public ReportLibrary(IDateTime datetime)
        {
            this._datetime = datetime;
        }
        public int MyFunction()
        {
          int result;

          //The original line of code below
          //DateTime today = DateTime.Now;

          //This is the updated line of code
          DateTime today = this._datetime.Now;

          //rest of the calculation goes here
          return result;
        }
    }
}

ReportLibrary reportLibrary = new ReportLibrary();
int result = reportLibrary.MyFunction();

[TestClass]
public class ReportLibraryTests
{
  //this goes at the top of our unit test class
  private class MockDateTime : IDateTime
  {
    public DateTime Now { get; set; }
  }
  //rest of the test methods go here
}

[TestMethod]
public void MyFunctionTests()
{
  IDateTime dateTime = new MockDateTime();
  //set the DateTime.Now property and inject this into the ReportLibrary constructor
  DateTime today = new DateTime(2016, 8, 3);
  dateTime.Now = today;
  ReportLibrary reportLibrary = new ReportLibrary(dateTime);
  int result = reportLibrary.MyFunction();
  Assert.AreEqual(999, result, "Invalid result for 'MyFunction'");
}