DavidBreyer.com

Improve Code Maintainability by Using the Correct Accessibility Level

Tue, 26 Jul 2016 00:00:00 +0000

Most developers I have talked to use just Public or Private access modifiers. Public for methods that should be called by an external class. While private is used for internal methods. I am going to tell you why you should care about creating protected or internal methods.

Let’s take a look at the three other modifiers.

Protected - Available to derived classes.
Internal - Can be accessed by in any class in the assembly. Or via a friend class.
Protected Internal - Either functions as protected or internal (not both).

Using correct access modifiers will improve code quality by making it easier to test and extend, which makes it more maintainable.

Unit Testing:

Without some tricks using reflection the only way to test a private method is to call the public method which makes use of your private methods. Which means testing your private method now goes through an extra step (and logic) and in my opinion is a less effective test. As it lacks the granularity that is the very nature of unit testing. Which is to independently scrutinize the smallest testable part of your code.

Protected methods are easier to test than private by creating an accessor method in your unit test project.

Private functions are more difficult to unit test.

private int add(int x, int y)
{
    return x + y;
}

Change your private method to protected. Functions similar to private. But now testable and extendable.

protected virtual int add(int x, int y)
{
    return x + y;
}

So our Unit Test looks something like this.

public class MyTestExtender : ClassToTest
{
    public int AddAccessor(int x, int y)
    {
        return this.add(x, y);
    }
}

[TestMethod]
public void AddOneAndOneTest()
{
    var testClass = new MyTestExtender();

    var actual = testClass.AddAccessor(1, 1);

    Assert.AreEqual(2, actual);
}

Extensibility:

The second reason to use protected over private is you can leave your class open for extension. If you are believer in the open/close principle than marking your methods protected virtual allow for overriding a method and extending functionality of your classes. Which gives your code greater maintainability.

Additionally virtual methods have for more advanced extensibility available. Such as using the VirtualMethodInterceptor with Unity. Which I discussed a bit in my Log4Net with Unity Interceptor articles.

What about internal?

So I never mentioned internal or why you would want to use it. Internal can be used for unit testing, since you can give access to internal methods to another project. It’s my second choice after protected though.

Using the InternalsVisibleTo attribute you can give another assembly access to your internal methods. Where they would normally be accessible by the current assembly.

[assembly: InternalsVisableTo("MyTestProject")]
class ClassToTest
{
    internal int Add(int x, int y)
    {
        return x + y;
    }
}

While there may be a reason this is preferrable. I am less inclined to use Internal since the classes you are testing now contain configuration used by a test project. I would rather have all test configuration be in the Unit Testing project.

I am not saying this is the right solution all the time. Indeed there are plenty of uses for Private. But you can be aware of the benefits of lesser used access modifiers. Unit tests and allowing for extension will greatly improve the quality of your code.

Managing SQL Server Express Localdb Instances

Mon, 20 Jun 2016 00:00:00 +0000

Microsoft SQL Server 2016 Express LocalDB is an version of SQL Server Express targeted to developers. MSSQL LocalDB is not installed by default, it can be installed with Visual Studio 2015 using a custom install. It can also be added to an existing Visual Studio 2015 installation by re-running the installation and choosing to modify the installation by adding Microsoft SQL Server Data Tools.

Using the SQL Server Object Explorer you can access all your local SQL Server Express instances. While you can delete instances from this view, you cannot create or update them to new SQL Server versions.

Command Line

View Existing Instances

C:\>sqllocaldb info
MSSQLLocalDB
ProjectsV12
ProjectsV13

View Installed SQL Server versions

C:\>sqllocaldb versions
Microsoft SQL Server 2014 (12.0.2000.8)
Microsoft SQL Server 2016 Release Candidate 0 (RC0) (13.0.1100.286)

View instance details

L:\>sqllocaldb info "ProjectsV12"
Name:               ProjectsV12
Version:            12.0.2000.8
Shared name:
Owner:              dbreyer
Auto-create:        No
State:              Stopped
Last start time:    5/25/2016 10:43:53 AM
Instance pipe name:

L:\>sqllocaldb info MSSQLLocalDB
Name:               MSSQLLocalDB
Version:            13.0.1100.286
Shared name:
Owner:              dbreyer
Auto-create:        Yes
State:              Running
Last start time:    5/25/2016 10:43:24 AM
Instance pipe name: np:\\.\pipe\LOCALDB#0E377D23\tsql\query

Create Instance

Latest Version

C:\>sqllocaldb create MyNewInstance
LocalDB instance "MyNewInstance" created with version 13.0.1100.286.

Specific Version

C:\>sqllocaldb create MyNewInstance12 12.0.2000.8
LocalDB instance "MyNewInstance12" created with version 12.0.2000.8.

Auto-Create

The MSSQLLocalDB has the auto-create flag set to true. Deleting this instance will cause the instance to be recreated with the lastest installed SQL Server version.

Create a Shared Instance

Adding a shared instance to an existing localdb database will support multiple users connecting to a single instance.

Connect to a shared instance with a .\ between (localdb) and the name of the shared instance. (i.e. (localdb)\.\MyShare )

sqllocaldb share MyNewInstance "MySharedDB"
Private LocalDB instance "MyNewInstance" shared with the shared name: "MySharedDB".

Delete Instance

While it’s possible to delete instances from the SQL Server Object Explorer view, this can also be done by command line.

C:\>sqllocaldb delete MyNewInstance12
LocalDB instance "MyNewInstance12" deleted.

If you attempt to delete a running instance, you will get the following.

C:\>sqllocaldb delete MyNewInstance12
Delete of LocalDB instance "MyNewInstance12" failed because of the following error:
Requested operation on LocalDB instance cannot be performed because specified in
stance is currently in use. Stop the instance and try again.

Simply use the stop command to close the instance, then rerun the delete command.

C:\>sqllocaldb stop MyNewInstance12
LocalDB instance "MyNewInstance12" stopped.

AOP using Unity Interceptors in a Web API Project

Wed, 01 Jul 2015 00:00:00 +0000

In part one we configured Log4net logging with Unity. In part two we used AOP to add actions to Web API controllers without modifying the controllers code.

In part three we will do something similar to the components of our web API project. Using Unity we will inject behaviors into specific classes, that can execute before and after the method. In this particular example we will use it to log each method of a designated class using our ProfilingInterceptionBehavior.

Step 1: Create a New Behavior

In the first step you will create a class that extends the IInterceptionBehavior interface. This will contain any code you want to execute before and after an intercepted method.

Remember you need a public property, to expose ILog, and a dependency attribute. This will allow Unity to inject our Log4Net logger into the behavior.

[Dependency]
public ILog Log { get; set; }

In this example our behavior will log any exceptions thrown by the intercepted method.

Step 2: Add Interception Extension to Unity Container

Now this won’t do anything until we give it a class to intercept. Which we will do in a Unity configuration. I use a class called UnityConfig to configure dependency injection for my web api projects.

In part one, Configuring Log4Net with Unity, we added several extensions to the Unity Container. It looked like this:

var newContainer = new UnityContainer()
    .AddNewExtension<LogCreation>() //Custom extension that executes logger setup
    .AddNewExtension<Log4NetExtension>();

We will add a new extension, which requires the Unity Interception Extension nuget package.

PM> Install-Package Unity.Interception

Then update your Unity container creation to with the new extension.

var newContainer = new UnityContainer()
    .AddNewExtension<LogCreation>() //Custom extension that executes logger setup
    .AddNewExtension<Log4NetExtension>()
    .AddNewExtension<Interception>();

Step 3: Injecting the New Behavior into a Class

So now you want the behavior you created in step one to be invoked when calling a method in an intercepted class. This will be accomplished adding a few lines to a class registered in your Unity configuration.

container.RegisterType<IRepository, Repository>(new HierarchicalLifetimeManager()
, new Interceptor<InterfaceInterceptor>() //Interception technique
, new InterceptionBehavior<ProfilingInterceptionBehavior>()); //created in step 1.

Step 4: Add Method Profiling to the Behavior

In the last step, the behavior method created above is updated to log the start, stop and elapsed time of a method. Any thrown exceptions are also logged.

Reference: Interception Techniques

In step 2, we added an interceptor called InterfaceInterceptor to our Unity DI configuration. This is called an instance interceptor, and can proxy a class with a single interface. You can also use a VirtualMethodInterceptor, which is a type interceptor and where only methods marked virtual will be proxied. The interceptor techniques can be a topic by themselves, so you can read more about them in the Unity documentation.

Unity Interception Techniques

Add Logging to your Web API Controllers with AOP

Wed, 10 Jun 2015 00:00:00 +0000

In part one we added a log4net log to our Web API project using Unity.

In this part I will show how to create a filter that runs a function before and after a your controller method, how to inject log4net into the filter, and how to add the filter to your controllers. This part uses the same nuget packages as part one.

Step one is to create a web filter. In the example below there are three main parts.

ILog property that is marked with a dependency attribute.
OnActionExecuting will run before the requested controller method.
OnActionExected will run after the requested controller method.

If this filter executed now, the Log would be NULL. So in step two let’s use Unity to build up the filter.

There are two components to using Unity to buildup the filter.

Add a class, UnityActionFilterProvider, to your project. This will buildup the filter when called from the FilterConfig.
Add the RegisterFilterProviders method to the FilterConfig.cs file in the Web API project.

Then you call this from RegisterGlobalFilters in the FilterConfig.cs:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new HandleErrorAttribute());
    RegisterFilterProviders(); //<-- register your logging filter.
}

At this point nothing will log until you add an attribute to any controllers you want to log. In the example below, notice the [LogActionWebApiFilter] attribute that is added to the ValuesController.

[LogActionWebApiFilter]
public class ValuesController : ApiController
{
        
	// GET api/values
    public IEnumerable<string> Get()
    {
    	return new string[] { "value1", "value2" };
    }
}

Now calling the GET method of the values controller, will cause Log4Net to write to any logs you have configured.

In part three I will show how to use Unity and AOP to log other components of your web api project.

Configuring Log4Net with Unity

Tue, 09 Jun 2015 00:00:00 +0000

This is part one of a three part series on adding logging to a Web API project using AOP (Aspect Oriented Programming). The following code is a simple way to inject logging into your web api project using log4net and Microsoft Unity.

I used the following Nuget packages.

PM> Install-Package Unity
PM> Install-Package log4net
PM> Install-Package UnityLog4NetExtension

The first thing you need is to do is setup Log4net. Below you will find the code for a basic log4net setup method.

Add a log creation class that inherits UnityContainerExtension. This will allow Unity to create and config your log file, rather than calling the logger setup in the global.asax.

public class LogCreation : UnityContainerExtension
{
     protected override void Initialize()
     {
         Logger.Setup();
     }
}

var container =  new UnityContainer()
                .AddNewExtension<LogCreation>()
                .AddNewExtension<Log4NetExtension>(); //UnityLog4netExtension

Below is an example of my basic Microsoft Unity configuration file.

In the next post I will document on how to add logging to your controllers with AOP.

Create Fake Responses to REST Service Calls in C#

Sat, 11 Oct 2014 00:00:00 +0000

Creating mocks for your service calls is made easy with the use of the HttpClient and the FakeResponseHandler. The FakeResponseHandler inherits from the DelegatingHandler and will return a response based on the registered URI.

Here is a simple example of a proxy class that calls a REST service.

public class Proxy
{
    [Dependency]
    public HttpClient client { get; set; }

    public async Task<ExampleDto> GetExample(int id)
    {
        var response = client.GetAsync(
        	string.Format("/api/restserviceexample/{0}", id))
            	.Result.Content.ReadAsAsync<ExampleDto>();

        return await response;
    }
}

This is a simple example, but it works for the purposes of showing how to call a fake REST service. As you can see GetExample will be calling the GET method of the RestServiceExample controller in Web API. Notice the [Dependency] tag above the client property. I am injecting the HttpClient using Microsoft Unity. Now let’s assume we need to create a unit test for this method, but it relies on retrieving data from a service.

And here is a unit test that calls the GetExample method of the Proxy class. Notice the container.resolve in the test method. This will create an instance of the registered proxy class, and HttpClient, using dependency injection.

[TestMethod]
public void TestProxy1()
{
    var proxy = Container.Resolve<Proxy>();

    var response = proxy.GetExample(1).Result;

    Assert.IsNotNull(response);
    Assert.AreEqual("Printer", response.Name);

}

So, let’s take a look at how to connect the Unit Test to our fake REST service.

First we add the FakeResponseHandler class to our test project. This class is generic enough that it will be reused to fake any REST service. Only the registration details will change in our test initialization method.

public class FakeResponseHandler : DelegatingHandler
{
    private readonly Dictionary<Uri, HttpResponseMessage> 
    	_FakeResponses = new Dictionary<Uri, HttpResponseMessage>();
 
 
    public void AddFakeResponse(Uri uri, HttpResponseMessage responseMessage)
    {
        _FakeResponses.Add(uri, responseMessage);
    }
 
 
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request
    	, System.Threading.CancellationToken cancellationToken)
    {
        if (_FakeResponses.ContainsKey(request.RequestUri))
        {
            return Task.FromResult(_FakeResponses[request.RequestUri]);
        }
        else
        {
            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound) 
            	{ RequestMessage = request });
        }
    }
}

Next I am going to should instantiate the fake response handler in the setup method of my unit test class. And add a Uri that I want the HttpClient to respond to, along with the desired status and content.

var fakeResponseHandler = new FakeResponseHandler();

fakeResponseHandler.AddFakeResponse(
	new Uri("http://example.org/api/restserviceexample/1"),
	new HttpResponseMessage(HttpStatusCode.OK)
	{
		Content = new ObjectContent<ExampleDto>(
			new ExampleDto
			{
				Id = 1,
				Name = "Printer"
			}, new JsonMediaTypeFormatter())
	});

Then I am going to register the HttpClient and FakeResponseHandler with Microsoft Unity.

Container.RegisterType<HttpClient>(
	new InjectionFactory(x =>
	new HttpClient(fakeResponseHandler) 
		{ BaseAddress = new Uri("http://example.org/") }));

Now you should have an HttpClient that will respond to requests with fake data and response codes in your unit tests. Let’s take a look at the entire test class.

[TestClass]
public class UnitTest1
{
	public UnityContainer Container { get; set; }
	
	[TestInitialize]
	public void Setup()
	{
		Container = new UnityContainer();
 
		var fakeResponseHandler = new FakeResponseHandler();
		fakeResponseHandler.AddFakeResponse(
			new Uri("http://example.org/api/restserviceexample/1"),
			new HttpResponseMessage(HttpStatusCode.OK)
			{
				Content = new ObjectContent<ExampleDto>(
					new ExampleDto
					{
						Id = 1,
						Name = "Printer"
					}, new JsonMediaTypeFormatter())
			});
 
 
		Container.RegisterType<Proxy, Proxy>();
 
		Container.RegisterType<HttpClient>(
			new InjectionFactory(x =>
			new HttpClient(fakeResponseHandler) { 
				BaseAddress = new Uri("http://example.org/") }));
	}
	
	[TestMethod]
	public void TestProxy1()
	{
		var proxy = Container.Resolve<Proxy>();
 
		var response = proxy.GetExample(1).Result;
 
		Assert.IsNotNull(response);
			Assert.AreEqual("Printer", response.Name);
	}
}

This great thing about this method is there is no need to create a mock class for HttpClient. Just by registering your HttpClient in the Unity configuration, you can control whether to call real REST services, or fakes.

Creating Extension Methods

Tue, 07 Oct 2014 00:00:00 +0000

A useful feature of C# is the ability to add functionality to existing classes. For example, you might want a reverse function on the String class. You would then be able to call your new function this way: myString.Reverse().

Here is an example of an extension class.

public static class MyExtensions
{
	public static string Reverse(this String str)
    {
    	char[] charArray = str.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
}


//Example usage
var myString = “Hello World”;
var myStringReversed = myString.Reverse(); //Will return “dlroW olleH"

Notice that the class and the Reverse function are both marked static. This is required to create an extension method. The parameter, this String str, is how C# knows that the String class is the one the extension applies too.

You can also create extension methods that accept a parameter.

public static string ReplaceSpacesWith(this String str, string replacementValue)
{
	return str.Replace(" ", replacementValue);
}

And this can be called by, myString.ReplaceSpacesWith(“#”).

//Example usage
var myString = “Hello World”;
var myStringWithHashes = myString.ReplaceSpacesWith(“#"); //Will return “Hello#World"

Extension methods are simple to create and useful for adding functionality to an existing class. Just remember that the extension class must be marked static and have a reference to the class you are extending. And the extension method must be static and the first parameter must contain this and the class your extending.

Filter ng-Grid on keypress

Mon, 21 Jul 2014 00:00:00 +0000

Ng-Grid is the easiest way to add a sortable and filterable grid to your web application. I have used jqGrid in the past and this is by far easier to work with. Today I am going to demonstrate how to add filtering to your ng-Grid, and as a bonus I am going to do it on keypress. So the grid will filter as you type in the search box without the need for a pesky button.

View the Plunker here.

Let’s start with a basic ng-Grid setup. Our controller will populate a list of people’s names that will be displayed in a grid.

var app = angular.module('myApp', ['ngGrid']);

app.controller('GridController', function($scope) {
  $scope.people = [{
    "name": "Albert Barron",
    "age": 24,
    "eyeColor": "blue",
    "gender": "male",
    "company": "VETRON"
  }, [ List truncated for readability ]
  }];

  $scope.gridOptions = {
    data: 'people'
  };
});

<div ng-controller="GridController">
	<div class="gridStyle" ng-grid="gridOptions"></div>
</div>

.gridStyle {
    border: 1px solid rgb(212,212,212);
    width: 800px; 
    height: 400px
}

Which should look like the following image on your page.

We will now add a field that will filter on the name field. The ng-change property will designate what function to call on each keypress.

<input class="peopleNameFilter" id="personNameFilter" type="text" ng-model="nameFilter" 
placeholder="Filter by Name" ng-change="filterName()">

var app = angular.module('myApp', ['ngGrid']);

app.controller('GridController', function($scope) {
  $scope.people = [{
    "name": "Albert Barron",
    "age": 24,
    "eyeColor": "blue",
    "gender": "male",
    "company": "VETRON"
  }, [ List truncated for readability ]
  }];

  //Add the filter options to the scope.	
  $scope.filterOptions = {
    filterText: ''
  };

  //Set the filter options property of the grid to the filter options in the scope.
  $scope.gridOptions = {
    data: 'people',
    filterOptions: $scope.filterOptions
  };
  
  //This event will update the filter text.
  $scope.filterName = function() {
    var filterText = 'name:' + $scope.nameFilter;
    if (filterText !== 'name:') {
      $scope.filterOptions.filterText = filterText;
    } else {
      $scope.filterOptions.filterText = '';
    }
  };
});

As the user types the grid will show only the records that contain the field text. Clearing the text box will once again show all the records.

View the Plunker here.

Czech Republic to Austria Bike Trip

Sun, 06 Jul 2014 00:00:00 +0000

Last month I returned from a two week trip to Europe, that included a 6 day bike trip from Prague to Vienna. I am still been going through my photos and documenting places I visited and stayed.

You can see more photos on my Flickr album.

Basic Array Operations in Apple Swift

Wed, 11 Jun 2014 00:00:00 +0000

Create, Update, and Filter a Generic Array in Apple Swift.

The code

//
//  main.swift
//  ConsoleApp1

import Foundation

var cityList = Array<String>()
cityList.append("Vienna")
cityList.append("Munich")
cityList.append("Berlin")
cityList.append("Prague")

println("Number of elements in city list:")
println(cityList.count)

//Create a filtered list of elements that match the specified criteria
let filtered = cityList.filter({$0 == "Prague"})
println("Number of elements in filtered list:")
println(filtered.count)

println("Enumerate city list:")
for item in cityList
{
    println(item)
}

The output:

Number of elements in city list:
4
Number of elements in filtered list:
1
Enumerate city list:
Vienna
Munich
Berlin
Prague